diff --git a/src/test/regress/expected/uao_compaction/alter_table_analyze.out b/src/test/regress/expected/uao_compaction/alter_table_analyze.out new file mode 100644 index 0000000000000000000000000000000000000000..b5fcaca5f81f103d0e5a2c2afb59c444646f6614 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/alter_table_analyze.out @@ -0,0 +1,75 @@ +-- @Description Checks analyze and drop column interfaction +CREATE TABLE ck_ct_ao_analyze1( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +numeric_col numeric, +int_col int4, +float_col float4, +int_array_col int[], +drop_col numeric, +before_rename_col int4, +change_datatype_col numeric, +a_ts_without timestamp without time zone, +b_ts_with timestamp with time zone, +date_column date) with (appendonly=true) distributed randomly; +INSERT INTO ck_ct_ao_analyze1 values ('0_zero', 0, '0_zero', 0, 0, 0, '{0}', 0, 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +INSERT INTO ck_ct_ao_analyze1 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze1 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +select count(*) AS only_visi_tups_ins from ck_ct_ao_analyze1; + only_visi_tups_ins +-------------------- + 3 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_ins from ck_ct_ao_analyze1; + invisi_and_visi_tups_ins +-------------------------- + 3 +(1 row) + +set gp_select_invisible = false; +update ck_ct_ao_analyze1 set bigint_col = bigint_col + 1 where text_col = '0_zero'; +select count(*) AS only_visi_tups_upd from ck_ct_ao_analyze1; + only_visi_tups_upd +-------------------- + 3 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_upd from ck_ct_ao_analyze1; + invisi_and_visi_tups_upd +-------------------------- + 4 +(1 row) + +set gp_select_invisible = false; +delete from ck_ct_ao_analyze1 where int_col = 2; +select count(*) AS only_visi_tups_del from ck_ct_ao_analyze1; + only_visi_tups_del +-------------------- + 2 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_del from ck_ct_ao_analyze1; + invisi_and_visi_tups_del +-------------------------- + 4 +(1 row) + +set gp_select_invisible = false; +-- +ALTER TABLE ck_ct_ao_analyze1 ADD COLUMN added_col character varying(30) default 'test_value'; +ALTER TABLE ck_ct_ao_analyze1 DROP COLUMN drop_col ; +ALTER TABLE ck_ct_ao_analyze1 RENAME COLUMN before_rename_col TO after_rename_col; +ALTER TABLE ck_ct_ao_analyze1 ALTER COLUMN change_datatype_col TYPE int4; +ALTER TABLE ck_ct_ao_analyze1 set with ( reorganize='true') distributed by (int_col); +-- +-- +INSERT INTO ck_ct_ao_analyze1 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze1 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +INSERT INTO ck_ct_ao_analyze1 values ('3_zero', 3, '3_zero', 0, 0, 0, '{0}', 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +update ck_ct_ao_analyze1 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +ANALYZE ck_ct_ao_analyze1; diff --git a/src/test/regress/expected/uao_compaction/alter_table_analyze2.out b/src/test/regress/expected/uao_compaction/alter_table_analyze2.out new file mode 100644 index 0000000000000000000000000000000000000000..b0bdfecba7d401f45714fe1cd456be25ebc67c18 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/alter_table_analyze2.out @@ -0,0 +1,70 @@ +-- @Description Checks analyze and drop column interfaction +CREATE TABLE ck_ct_ao_analyze2( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +numeric_col numeric, +int_col int4, +float_col float4, +int_array_col int[], +drop_col numeric, +before_rename_col int4, +change_datatype_col numeric, +a_ts_without timestamp without time zone, +b_ts_with timestamp with time zone, +date_column date) with (appendonly=true) distributed randomly; +INSERT INTO ck_ct_ao_analyze2 values ('0_zero', 0, '0_zero', 0, 0, 0, '{0}', 0, 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +INSERT INTO ck_ct_ao_analyze2 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze2 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +select count(*) AS only_visi_tups_ins from ck_ct_ao_analyze2; + only_visi_tups_ins +-------------------- + 3 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_ins from ck_ct_ao_analyze2; + invisi_and_visi_tups_ins +-------------------------- + 3 +(1 row) + +set gp_select_invisible = false; +update ck_ct_ao_analyze2 set bigint_col = bigint_col + 1 where text_col = '0_zero'; +select count(*) AS only_visi_tups_upd from ck_ct_ao_analyze2; + only_visi_tups_upd +-------------------- + 3 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_upd from ck_ct_ao_analyze2; + invisi_and_visi_tups_upd +-------------------------- + 4 +(1 row) + +set gp_select_invisible = false; +delete from ck_ct_ao_analyze2 where int_col = 2; +select count(*) AS only_visi_tups_del from ck_ct_ao_analyze2; + only_visi_tups_del +-------------------- + 2 +(1 row) + +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_del from ck_ct_ao_analyze2; + invisi_and_visi_tups_del +-------------------------- + 4 +(1 row) + +set gp_select_invisible = false; +-- +ALTER TABLE ck_ct_ao_analyze2 ADD COLUMN added_col character varying(30) default 'test_value'; +ALTER TABLE ck_ct_ao_analyze2 DROP COLUMN drop_col ; +ALTER TABLE ck_ct_ao_analyze2 RENAME COLUMN before_rename_col TO after_rename_col; +ALTER TABLE ck_ct_ao_analyze2 ALTER COLUMN change_datatype_col TYPE int4; +ALTER TABLE ck_ct_ao_analyze2 set with ( reorganize='true') distributed by (int_col); +update ck_ct_ao_analyze2 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +ANALYZE ck_ct_ao_analyze2; diff --git a/src/test/regress/expected/uao_compaction/basic.out b/src/test/regress/expected/uao_compaction/basic.out new file mode 100644 index 0000000000000000000000000000000000000000..eb8268a20d79a7b3f9383c478d786056d8768973 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/basic.out @@ -0,0 +1,28 @@ +-- @Description Basic lazy vacuum +CREATE TABLE uao_basic (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_basic_index ON uao_basic(b); +INSERT INTO uao_basic SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; +INSERT INTO uao_basic SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; +DELETE FROM uao_basic WHERE a < 4; +SELECT COUNT(*) FROM uao_basic; + count +------- +14 +(1 row) + +VACUUM uao_basic; +-- check if we get the same result afterwards +SELECT COUNT(*) FROM uao_basic; + count +------- +14 +(1 row) + +-- check if we can still insert into the relation +INSERT INTO uao_basic VALUES (11, 11); +SELECT COUNT(*) FROM uao_basic; + count +------- +15 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/delete_toast.out b/src/test/regress/expected/uao_compaction/delete_toast.out new file mode 100644 index 0000000000000000000000000000000000000000..e3081e048283c6fe785e1e677b0980b038b63979 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/delete_toast.out @@ -0,0 +1,7 @@ +-- @Description Checkes the deletion and vacuuming of toast values +-- Create a table with toasted values. +CREATE TABLE uao_delete_toast (a INT, b INT, c VARCHAR) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_delete_toast_index ON uao_delete_toast(b); +INSERT INTO uao_delete_toast SELECT i as a, 1 as b, i::text || '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' as c FROM generate_series(1, 10) AS i; +DELETE FROM uao_delete_toast; +VACUUM uao_delete_toast; diff --git a/src/test/regress/expected/uao_compaction/drop_column.out b/src/test/regress/expected/uao_compaction/drop_column.out new file mode 100644 index 0000000000000000000000000000000000000000..1d7b31991fc9563808c71b54a04acfe82403bf35 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/drop_column.out @@ -0,0 +1,63 @@ +-- @Description Tests dropping a column after a compaction +CREATE TABLE uao_drop_col (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_drop_col_index ON uao_drop_col(b); +INSERT INTO uao_drop_col SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; +DELETE FROM uao_drop_col WHERE a < 4; +SELECT COUNT(*) FROM uao_drop_col; + count +------- + 7 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col'; + relname | reltuples +--------------+----------- + uao_drop_col | 10 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col_index'; + relname | reltuples +--------------------+----------- + uao_drop_col_index | 10 +(1 row) + +VACUUM uao_drop_col; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col'; + relname | reltuples +--------------+----------- + uao_drop_col | 7 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col_index'; + relname | reltuples +--------------------+----------- + uao_drop_col_index | 7 +(1 row) + +ALTER TABLE uao_drop_col DROP COLUMN c; +SELECT * FROM uao_drop_col; + a | b +----+--- + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 +(7 rows) + +INSERT INTO uao_drop_col VALUES (42, 42); +SELECT * FROM uao_drop_col; + a | b +----+---- + 42 | 42 + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 +(8 rows) + diff --git a/src/test/regress/expected/uao_compaction/drop_column_update.out b/src/test/regress/expected/uao_compaction/drop_column_update.out new file mode 100644 index 0000000000000000000000000000000000000000..8888b807cd2b01a9dadf9d352c4a714445888659 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/drop_column_update.out @@ -0,0 +1,24 @@ +-- @Description Tests dropping a column after a compaction with update +CREATE TABLE ck_ct_ao_analyze3( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +int_array_col int[], +drop_col numeric) with (appendonly=true); +INSERT INTO ck_ct_ao_analyze3 values ('1_zero', 1, '1_zero', '{1}', 1); +ALTER TABLE ck_ct_ao_analyze3 DROP COLUMN drop_col; +Select char_vary_col, int_array_col from ck_ct_ao_analyze3; + char_vary_col | int_array_col +---------------+--------------- + 1_zero | {1} +(1 row) + +INSERT INTO ck_ct_ao_analyze3 values ('2_zero', 2, '2_zero', '{2}'); +update ck_ct_ao_analyze3 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +Select char_vary_col, int_array_col from ck_ct_ao_analyze3; + char_vary_col | int_array_col +---------------+--------------- + 2_zero | {2} + 1_zero | {1} +(2 rows) + diff --git a/src/test/regress/expected/uao_compaction/eof_truncate.out b/src/test/regress/expected/uao_compaction/eof_truncate.out new file mode 100644 index 0000000000000000000000000000000000000000..653531261d230a22119b559e43286b5e78e43318 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/eof_truncate.out @@ -0,0 +1,31 @@ +-- @Description Tests the behavior while compacting is disabled +CREATE TABLE uao_eof_truncate (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_eof_truncate_index ON uao_eof_truncate(b); +BEGIN; +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,1000) AS i; +COMMIT; +BEGIN; +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1000,2000) AS i; +ROLLBACK; +SET gp_appendonly_compaction=false; +SELECT COUNT(*) FROM uao_eof_truncate; + count +------- +1000 +(1 row) + +VACUUM uao_eof_truncate; +SELECT COUNT(*) FROM uao_eof_truncate; + count +------- +1000 +(1 row) + +-- Insert afterwards +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +SELECT COUNT(*) FROM uao_eof_truncate; + count +------- +1010 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/full.out b/src/test/regress/expected/uao_compaction/full.out new file mode 100644 index 0000000000000000000000000000000000000000..c4a9cb7478ab18674ea2065f3dc476c215471701 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/full.out @@ -0,0 +1,28 @@ +-- @Description Test the basic bahavior of vacuum full +CREATE TABLE uao_full (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_full_index ON uao_full(b); +INSERT INTO uao_full SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +INSERT INTO uao_full SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +DELETE FROM uao_full WHERE a < 4; +SELECT COUNT(*) FROM uao_full; + count +------- +14 +(1 row) + +VACUUM FULL uao_full; +-- check if we get the same result afterwards +SELECT COUNT(*) FROM uao_full; + count +------- +14 +(1 row) + +-- check if we can still insert into the relation +INSERT INTO uao_full VALUES (11, 11); +SELECT COUNT(*) FROM uao_full; + count +------- +15 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/full_eof_truncate.out b/src/test/regress/expected/uao_compaction/full_eof_truncate.out new file mode 100644 index 0000000000000000000000000000000000000000..5c232dc361c91dff3bcb371902117a78077a427e --- /dev/null +++ b/src/test/regress/expected/uao_compaction/full_eof_truncate.out @@ -0,0 +1,31 @@ +-- @Description Tests the behavior while compacting is disabled +CREATE TABLE full_eof_truncate (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX full_eof_truncate_index ON full_eof_truncate(b); +BEGIN; +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,1000) AS i; +COMMIT; +BEGIN; +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1000,2000) AS i; +ROLLBACK; +SET gp_appendonly_compaction=false; +SELECT COUNT(*) FROM full_eof_truncate; + count +------- + 1000 +(1 row) + +VACUUM FULL full_eof_truncate; +SELECT COUNT(*) FROM full_eof_truncate; + count +------- + 1000 +(1 row) + +-- Insert afterwards +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +SELECT COUNT(*) FROM full_eof_truncate; + count +------- + 1010 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/full_stats.out b/src/test/regress/expected/uao_compaction/full_stats.out new file mode 100644 index 0000000000000000000000000000000000000000..d047875502e711f794053258a96c49224c74f96d --- /dev/null +++ b/src/test/regress/expected/uao_compaction/full_stats.out @@ -0,0 +1,34 @@ +-- @Description Tests the behavior of full vacuum w.r.t. the pg_class statistics +CREATE TABLE uao_full_stats (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_full_stats_index ON uao_full_stats(b); +INSERT INTO uao_full_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_full_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_full_stats; +-- ensure that the scan go through the index +SET enable_seqscan=false; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats'; + relname | reltuples +----------------+----------- + uao_full_stats | 100 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats_index'; + relname | reltuples +----------------------+----------- + uao_full_stats_index | 100 +(1 row) + +DELETE FROM uao_full_stats WHERE a < 16; +VACUUM FULL uao_full_stats; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats'; + relname | reltuples +----------------+----------- + uao_full_stats | 85 + (1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats_index'; + relname | reltuples +----------------------+----------- + uao_full_stats_index | 85 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/full_threshold.out b/src/test/regress/expected/uao_compaction/full_threshold.out new file mode 100644 index 0000000000000000000000000000000000000000..c77cd42ad754aa4c8d0c9d8e5d584527cd40f220 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/full_threshold.out @@ -0,0 +1,8 @@ +-- @Description Tests that that full vacuum is ignoring the threshold guc value. +CREATE TABLE uao_full_threshold (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_full_threshold_index ON uao_full_threshold(b); +INSERT INTO uao_full_threshold SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 100) AS i; +VACUUM FULL uao_full_threshold; +DELETE FROM uao_full_threshold WHERE a < 4; +SET gp_appendonly_compaction_threshold=100; +VACUUM FULL uao_full_threshold; diff --git a/src/test/regress/expected/uao_compaction/index.out b/src/test/regress/expected/uao_compaction/index.out new file mode 100644 index 0000000000000000000000000000000000000000..60fa97f30c304c1d01d68029747bed21a8d80a52 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/index.out @@ -0,0 +1,13 @@ +-- @Description Tests basic index usage behavior after vacuuming +CREATE TABLE uao_index_test (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_index_test_index ON uao_index_test(b); +INSERT INTO uao_index_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1,10) AS i; +INSERT INTO uao_index_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1,10) AS i; +VACUUM uao_index_test; +SELECT * FROM uao_index_test WHERE b = 5; + a | b | c +---+---+---------------------------------------------------------------------------------------------------------------------------------- + 5 | 5 | hello world + 5 | 5 | hello world +(2 rows) + diff --git a/src/test/regress/expected/uao_compaction/index2.out b/src/test/regress/expected/uao_compaction/index2.out new file mode 100644 index 0000000000000000000000000000000000000000..a0ae4be16fd8e6c285182a2933759080489b11fb --- /dev/null +++ b/src/test/regress/expected/uao_compaction/index2.out @@ -0,0 +1,42 @@ +-- Test index usage after vacuuming. +-- Bug verification for MPP-24913 +CREATE TABLE table_index2 (a BIGINT, b BIGINT) WITH (appendonly=true); +CREATE INDEX table_index2_index_a ON table_index2(a); +CREATE INDEX table_index2_index_b ON table_index2(b); +\set QUIET off +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT 0 347305 +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT 0 347305 +UPDATE table_index2 SET b=100 WHERE a < 347305; +UPDATE 694608 +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT 0 347305 +UPDATE table_index2 SET b=100 WHERE a < 347305; +UPDATE 1041912 +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT 0 347305 +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT 0 347305 +UPDATE table_index2 SET b=101 WHERE b = 100; +UPDATE 1041914 +VACUUM table_index2; +VACUUM +UPDATE table_index2 SET b=102 WHERE b = 101; +UPDATE 1041916 +VACUUM table_index2; +VACUUM +SELECT COUNT(*) FROM table_index2; + count +--------- + 1736525 +(1 row) + +SET enable_seqscan=OFF; +SET +SELECT COUNT(*) FROM table_index2 WHERE a > 0; + count +--------- + 1736525 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/index_stats.out b/src/test/regress/expected/uao_compaction/index_stats.out new file mode 100644 index 0000000000000000000000000000000000000000..0db236c6a32d3f1c58f1919601ee6e93828dfdcf --- /dev/null +++ b/src/test/regress/expected/uao_compaction/index_stats.out @@ -0,0 +1,37 @@ +-- @Description Tests basic index stats after vacuuming +CREATE TABLE mytab( + col_int int, + col_text text, + col_numeric numeric, + col_unq int + ) with(appendonly=true) DISTRIBUTED RANDOMLY; +Create index mytab_int_idx1 on mytab(col_int); +insert into mytab values(1,'aa',1001,101),(2,'bb',1002,102); +select * from mytab; + col_int | col_text | col_numeric | col_unq +---------+----------+-------------+--------- + 1 | aa | 1001 | 101 + 2 | bb | 1002 | 102 +(2 rows) + +update mytab set col_text=' new value' where col_int = 1; +select * from mytab; + col_int | col_text | col_numeric | col_unq +---------+------------+-------------+--------- + 2 | bb | 1002 | 102 + 1 | new value | 1001 | 101 +(2 rows) + +vacuum mytab; +SELECT relname, reltuples FROM pg_class WHERE relname = 'mytab'; + relname | reltuples +---------+----------- + mytab | 2 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'mytab_int_idx1'; + relname | reltuples +----------------+----------- + mytab_int_idx1 | 2 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/outdated_partialindex.out b/src/test/regress/expected/uao_compaction/outdated_partialindex.out new file mode 100644 index 0000000000000000000000000000000000000000..02499e227167dde85fec7b595e8bed4984cdca94 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/outdated_partialindex.out @@ -0,0 +1,34 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash) in combination +-- with a partial index. +CREATE TABLE uao_outdated_partial (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_outdated_partial_index ON uao_outdated_partial(b) WHERE b < 20; +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_outdated_partial; +SET enable_seqscan=false; +DELETE FROM uao_outdated_partial WHERE a < 16; +VACUUM uao_outdated_partial; +SELECT * FROM uao_outdated_partial WHERE b = 20; + a | b | c +----+----+---------------------------------------------------------------------------------------------------------------------------------- + 20 | 20 | hello world +(1 row) + +SELECT * FROM uao_outdated_partial WHERE b = 10; + a | b | c +---+---+--- +(0 rows) + +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'Good morning' as c FROM generate_series(101, 110) AS i; +SELECT * FROM uao_outdated_partial WHERE b = 10; + a | b | c +---+---+--- +(0 rows) + +SELECT * FROM uao_outdated_partial WHERE b = 102; + a | b | c +-----+-----+---------------------------------------------------------------------------------------------------------------------------------- + 102 | 102 | Good morning +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/outdatedindex.out b/src/test/regress/expected/uao_compaction/outdatedindex.out new file mode 100644 index 0000000000000000000000000000000000000000..1fcf1fd737eba109a50c628d90f6ea37d1be532e --- /dev/null +++ b/src/test/regress/expected/uao_compaction/outdatedindex.out @@ -0,0 +1,28 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash). +CREATE TABLE uao_outdated (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_outdated_index ON uao_outdated(b); +INSERT INTO uao_outdated SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_outdated SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_outdated; +SET enable_seqscan=false; +DELETE FROM uao_outdated WHERE a < 16; +VACUUM uao_outdated; +SELECT * FROM uao_outdated WHERE b = 20; + a | b | c +----+----+---------------------------------------------------------------------------------------------------------------------------------- + 20 | 20 | hello world +(1 row) + +SELECT * FROM uao_outdated WHERE b = 10; + a | b | c +---+---+--- +(0 rows) + +INSERT INTO uao_outdated SELECT i as a, i as b, 'Good morning' as c FROM generate_series(1, 10) AS i; +SELECT * FROM uao_outdated WHERE b = 10; + a | b | c +----+----+---------------------------------------------------------------------------------------------------------------------------------- + 10 | 10 | Good morning +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/outdatedindex_abort.out b/src/test/regress/expected/uao_compaction/outdatedindex_abort.out new file mode 100644 index 0000000000000000000000000000000000000000..298f246697c0d55b12a81995217eebabe0d57c51 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/outdatedindex_abort.out @@ -0,0 +1,36 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash) in combination +-- with aborted inserts. +CREATE TABLE uao_index_abort_test (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_index_abort_test_index ON uao_index_abort_test(b); +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_index_abort_test; +SET enable_seqscan=false; +DELETE FROM uao_index_abort_test WHERE a < 16; +VACUUM uao_index_abort_test; +SELECT * FROM uao_index_abort_test WHERE b = 20; + a | b | c +----+----+---------------------------------------------------------------------------------------------------------------------------------- + 20 | 20 | hello world +(1 row) + +SELECT * FROM uao_index_abort_test WHERE b = 10; + a | b | c +---+---+--- +(0 rows) + +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(1, 4) AS i; +BEGIN; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(5, 8) AS i; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(9, 12) AS i; +ROLLBACK; +SELECT * FROM uao_index_abort_test WHERE b < 16; + a | b | c +---+---+---------------------------------------------------------------------------------------------------------------------------------- + 1 | 1 | Good morning + 2 | 2 | Good morning + 3 | 3 | Good morning + 4 | 4 | Good morning +(4 rows) + diff --git a/src/test/regress/expected/uao_compaction/stats.out b/src/test/regress/expected/uao_compaction/stats.out new file mode 100644 index 0000000000000000000000000000000000000000..23e9b5359864e99e00bec9ef80d3808b2780c75c --- /dev/null +++ b/src/test/regress/expected/uao_compaction/stats.out @@ -0,0 +1,35 @@ +-- @Description Tests that the pg_class statistics are updated on +-- lazy vacuum. +CREATE TABLE uao_stats (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_stats_index ON uao_stats(b); +INSERT INTO uao_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_stats; +-- ensure that the scan go through the index +SET enable_seqscan=false; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats'; + relname | reltuples +-----------+----------- + uao_stats | 100 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats_index'; + relname | reltuples +-----------------+----------- + uao_stats_index | 100 +(1 row) + +DELETE FROM uao_stats WHERE a < 16; +VACUUM uao_stats; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats'; + relname | reltuples +-----------+----------- + uao_stats | 85 +(1 row) + +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats_index'; + relname | reltuples +-----------------+----------- + uao_stats_index | 85 +(1 row) + diff --git a/src/test/regress/expected/uao_compaction/threshold.out b/src/test/regress/expected/uao_compaction/threshold.out new file mode 100644 index 0000000000000000000000000000000000000000..12db6c700ccc022fbdb2703154d2c017a24e5853 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/threshold.out @@ -0,0 +1,93 @@ +-- @Description Tests the basic behavior of (lazy) vacuum w.r.t. to the threshold guc. +-- The output depends on the number of segments as the skip decision and the +-- notify is done on the segments. +CREATE TABLE uao_threshold (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_threshold_index ON uao_threshold(b); +INSERT INTO uao_threshold SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 100) AS i; +\set QUIET off +VACUUM uao_threshold; +VACUUM +DELETE FROM uao_threshold WHERE a < 4; +DELETE 3 +SELECT COUNT(*) FROM uao_threshold; + count +------- + 97 +(1 row) + +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 100 | 1 +(1 row) + +-- 97 visible tuples, no vacuum +VACUUM uao_threshold; +VACUUM +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 100 | 1 +(1 row) + +DELETE FROM uao_threshold WHERE a < 12; +DELETE 8 +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 100 | 1 +(1 row) + +-- 89 visible tuples, do vacuum +VACUUM uao_threshold; +VACUUM +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 50 | 1 + 2 | 44 | 1 +(2 rows) + +-- no invisible tuples, no vacuum +VACUUM uao_threshold; +VACUUM +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 50 | 1 + 2 | 44 | 1 +(2 rows) + +DELETE FROM uao_threshold WHERE a < 15; +DELETE 3 +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 50 | 1 + 2 | 44 | 1 +(2 rows) + +-- 3 invisible tuples, no vacuum +VACUUM uao_threshold; +VACUUM +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 0 | 1 + 2 | 44 | 1 + 3 | 43 | 1 +(3 rows) + +SET gp_appendonly_compaction_threshold=2; +SET +-- 3 invisible tuples, no vacuum +VACUUM uao_threshold; +VACUUM +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); + segno | tupcount | state +-------+----------+------- + 1 | 0 | 1 + 2 | 44 | 1 + 3 | 43 | 1 +(3 rows) + diff --git a/src/test/regress/expected/uao_compaction/update_toast.out b/src/test/regress/expected/uao_compaction/update_toast.out new file mode 100644 index 0000000000000000000000000000000000000000..6bd3825da8b45401e7206056c34e091ad7b3d730 --- /dev/null +++ b/src/test/regress/expected/uao_compaction/update_toast.out @@ -0,0 +1,50 @@ +-- @Description Check updating toast values +-- Create a table with toasted values +CREATE TABLE uao_update_toast (a INT, b INT, c VARCHAR) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_update_toast_index ON uao_update_toast(b); +INSERT INTO uao_update_toast SELECT i as a, 1 as b, i::text || '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' as c FROM generate_series(1, 30) AS i; +-- Now perform updates +\set QUIET off +UPDATE uao_update_toast SET c = '' WHERE a <= 10; +UPDATE 10 +UPDATE uao_update_toast SET c = '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' WHERE a > 10 AND a <= 20; +UPDATE 10 +UPDATE uao_update_toast SET b = 50 WHERE a > 20 AND a <= 30; +UPDATE 10 +VACUUM uao_update_toast; +VACUUM +SELECT a, b, md5(c::text) FROM uao_update_toast; + a | b | md5 +----+----+---------------------------------- + 1 | 1 | d41d8cd98f00b204e9800998ecf8427e + 2 | 1 | d41d8cd98f00b204e9800998ecf8427e + 3 | 1 | d41d8cd98f00b204e9800998ecf8427e + 4 | 1 | d41d8cd98f00b204e9800998ecf8427e + 5 | 1 | d41d8cd98f00b204e9800998ecf8427e + 6 | 1 | d41d8cd98f00b204e9800998ecf8427e + 7 | 1 | d41d8cd98f00b204e9800998ecf8427e + 8 | 1 | d41d8cd98f00b204e9800998ecf8427e + 9 | 1 | d41d8cd98f00b204e9800998ecf8427e + 10 | 1 | d41d8cd98f00b204e9800998ecf8427e + 11 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 12 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 13 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 14 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 15 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 16 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 17 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 18 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 19 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 20 | 1 | bb2fe6c35888be959312c51c398e1ab3 + 21 | 50 | e4ee815f9133f7754c258622c6c50b4b + 22 | 50 | 2b8c53792716ba8783ef9893499d89a1 + 23 | 50 | ab8e449e69ac56927a11e787bcb97e3c + 24 | 50 | 9914be844e81b8d9a00bdae16dd2a4a2 + 25 | 50 | e2b84087952a14d67b9b4c738ee8e8fb + 26 | 50 | 31b7c34cbebbddc2f58e8ceff409f6a7 + 27 | 50 | eedda1277d366bbd8509f4aa2fa6d6aa + 28 | 50 | 09889ea600ec6ab4325baf6c8fed13e0 + 29 | 50 | 3f7bdfb0f49065b44ec805577607fb12 + 30 | 50 | 4830ad05263d544d83fe4b5ad2dcb84e +(30 rows) + diff --git a/src/test/regress/greenplum_schedule b/src/test/regress/greenplum_schedule index 8f467703351058abe99c0862217158094373924f..1e91e267e44afa2a75892c04c633ff5565caccf4 100755 --- a/src/test/regress/greenplum_schedule +++ b/src/test/regress/greenplum_schedule @@ -88,4 +88,26 @@ ignore: tpch500GB_orca # so what's the point of that? Anyhow, the test is disabled for now.. #test: orca_udfs +# Tests for "compaction", i.e. VACUUM, of updatable append-only tables +test: uao_compaction/full_stats +test: uao_compaction/full +test: uao_compaction/alter_table_analyze2 +test: uao_compaction/index2 +test: uao_compaction/outdated_partialindex +test: uao_compaction/index_stats +test: uao_compaction/drop_column_update +test: uao_compaction/eof_truncate +test: uao_compaction/basic +test: uao_compaction/index +test: uao_compaction/threshold +test: uao_compaction/outdatedindex +test: uao_compaction/update_toast +test: uao_compaction/outdatedindex_abort +test: uao_compaction/delete_toast +test: uao_compaction/stats +test: uao_compaction/drop_column +test: uao_compaction/alter_table_analyze +test: uao_compaction/full_eof_truncate +test: uao_compaction/full_threshold + # end of tests diff --git a/src/test/regress/pg_regress_main.c b/src/test/regress/pg_regress_main.c index b3245b570cd0a48954e914f2cd90e0e2c3177bb6..d888e1fd723d25447b64b348b38287ce445f57b7 100644 --- a/src/test/regress/pg_regress_main.c +++ b/src/test/regress/pg_regress_main.c @@ -18,6 +18,9 @@ #include "pg_regress.h" +#include +#include + /* * start a psql test process for specified file (including redirection), * and return process ID @@ -34,6 +37,7 @@ psql_start_test(const char *testname, char expectfile[MAXPGPATH] = ""; char psql_cmd[MAXPGPATH * 3]; char use_utility_mode = 0; + char *lastslash; /* generalise later */ if (strcmp(testname, "upg2") == 0) @@ -54,6 +58,31 @@ psql_start_test(const char *testname, snprintf(outfile, sizeof(outfile), "%s/results/%s.out", outputdir, testname); + /* + * If the test name contains slashes, create intermediary results + * directory. + */ + if ((lastslash = strrchr(outfile, '/')) != NULL) + { + char resultdir[MAXPGPATH]; + + memcpy(resultdir, outfile, lastslash - outfile); + resultdir[lastslash - outfile] = '\0'; + if (mkdir(resultdir, S_IRWXU | S_IRWXG | S_IRWXO) < 0) + { + if (errno == EEXIST) + { + /* exists already, that's OK */ + } + else + { + fprintf(stderr, _("could not create directory \"%s\": %s\n"), + resultdir, strerror(errno)); + exit_nicely(2); + } + } + } + if (optimizer_enabled) { snprintf(expectfile, sizeof(expectfile), "%s/expected/%s_optimizer.out", diff --git a/src/test/regress/sql/uao_compaction/alter_table_analyze.sql b/src/test/regress/sql/uao_compaction/alter_table_analyze.sql new file mode 100644 index 0000000000000000000000000000000000000000..115e7332a87e5202b776d533af6dd8e348d3349b --- /dev/null +++ b/src/test/regress/sql/uao_compaction/alter_table_analyze.sql @@ -0,0 +1,48 @@ +-- @Description Checks analyze and drop column interfaction + +CREATE TABLE ck_ct_ao_analyze1( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +numeric_col numeric, +int_col int4, +float_col float4, +int_array_col int[], +drop_col numeric, +before_rename_col int4, +change_datatype_col numeric, +a_ts_without timestamp without time zone, +b_ts_with timestamp with time zone, +date_column date) with (appendonly=true) distributed randomly; + + +INSERT INTO ck_ct_ao_analyze1 values ('0_zero', 0, '0_zero', 0, 0, 0, '{0}', 0, 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +INSERT INTO ck_ct_ao_analyze1 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze1 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +select count(*) AS only_visi_tups_ins from ck_ct_ao_analyze1; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_ins from ck_ct_ao_analyze1; +set gp_select_invisible = false; +update ck_ct_ao_analyze1 set bigint_col = bigint_col + 1 where text_col = '0_zero'; +select count(*) AS only_visi_tups_upd from ck_ct_ao_analyze1; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_upd from ck_ct_ao_analyze1; +set gp_select_invisible = false; +delete from ck_ct_ao_analyze1 where int_col = 2; +select count(*) AS only_visi_tups_del from ck_ct_ao_analyze1; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_del from ck_ct_ao_analyze1; +set gp_select_invisible = false; +-- +ALTER TABLE ck_ct_ao_analyze1 ADD COLUMN added_col character varying(30) default 'test_value'; +ALTER TABLE ck_ct_ao_analyze1 DROP COLUMN drop_col ; +ALTER TABLE ck_ct_ao_analyze1 RENAME COLUMN before_rename_col TO after_rename_col; +ALTER TABLE ck_ct_ao_analyze1 ALTER COLUMN change_datatype_col TYPE int4; +ALTER TABLE ck_ct_ao_analyze1 set with ( reorganize='true') distributed by (int_col); +-- +-- +INSERT INTO ck_ct_ao_analyze1 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze1 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +INSERT INTO ck_ct_ao_analyze1 values ('3_zero', 3, '3_zero', 0, 0, 0, '{0}', 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +update ck_ct_ao_analyze1 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +ANALYZE ck_ct_ao_analyze1; diff --git a/src/test/regress/sql/uao_compaction/alter_table_analyze2.sql b/src/test/regress/sql/uao_compaction/alter_table_analyze2.sql new file mode 100644 index 0000000000000000000000000000000000000000..56854adf6f615257a2b90a58fe61284e9371b8a8 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/alter_table_analyze2.sql @@ -0,0 +1,42 @@ +-- @Description Checks analyze and drop column interfaction + +CREATE TABLE ck_ct_ao_analyze2( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +numeric_col numeric, +int_col int4, +float_col float4, +int_array_col int[], +drop_col numeric, +before_rename_col int4, +change_datatype_col numeric, +a_ts_without timestamp without time zone, +b_ts_with timestamp with time zone, +date_column date) with (appendonly=true) distributed randomly; + +INSERT INTO ck_ct_ao_analyze2 values ('0_zero', 0, '0_zero', 0, 0, 0, '{0}', 0, 0, 0, '2004-10-19 10:23:54', '2004-10-19 10:23:54+02', '1-1-2000'); +INSERT INTO ck_ct_ao_analyze2 values ('1_zero', 1, '1_zero', 1, 1, 1, '{1}', 1, 1, 1, '2005-10-19 10:23:54', '2005-10-19 10:23:54+02', '1-1-2001'); +INSERT INTO ck_ct_ao_analyze2 values ('2_zero', 2, '2_zero', 2, 2, 2, '{2}', 2, 2, 2, '2006-10-19 10:23:54', '2006-10-19 10:23:54+02', '1-1-2002'); +select count(*) AS only_visi_tups_ins from ck_ct_ao_analyze2; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_ins from ck_ct_ao_analyze2; +set gp_select_invisible = false; +update ck_ct_ao_analyze2 set bigint_col = bigint_col + 1 where text_col = '0_zero'; +select count(*) AS only_visi_tups_upd from ck_ct_ao_analyze2; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_upd from ck_ct_ao_analyze2; +set gp_select_invisible = false; +delete from ck_ct_ao_analyze2 where int_col = 2; +select count(*) AS only_visi_tups_del from ck_ct_ao_analyze2; +set gp_select_invisible = true; +select count(*) AS invisi_and_visi_tups_del from ck_ct_ao_analyze2; +set gp_select_invisible = false; +-- +ALTER TABLE ck_ct_ao_analyze2 ADD COLUMN added_col character varying(30) default 'test_value'; +ALTER TABLE ck_ct_ao_analyze2 DROP COLUMN drop_col ; +ALTER TABLE ck_ct_ao_analyze2 RENAME COLUMN before_rename_col TO after_rename_col; +ALTER TABLE ck_ct_ao_analyze2 ALTER COLUMN change_datatype_col TYPE int4; +ALTER TABLE ck_ct_ao_analyze2 set with ( reorganize='true') distributed by (int_col); +update ck_ct_ao_analyze2 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +ANALYZE ck_ct_ao_analyze2; diff --git a/src/test/regress/sql/uao_compaction/basic.sql b/src/test/regress/sql/uao_compaction/basic.sql new file mode 100644 index 0000000000000000000000000000000000000000..0206500e809ddb2d268c5234cd8daaccaa3320c5 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/basic.sql @@ -0,0 +1,16 @@ +-- @Description Basic lazy vacuum + +CREATE TABLE uao_basic (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_basic_index ON uao_basic(b); + +INSERT INTO uao_basic SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; +INSERT INTO uao_basic SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; + +DELETE FROM uao_basic WHERE a < 4; +SELECT COUNT(*) FROM uao_basic; +VACUUM uao_basic; +-- check if we get the same result afterwards +SELECT COUNT(*) FROM uao_basic; +-- check if we can still insert into the relation +INSERT INTO uao_basic VALUES (11, 11); +SELECT COUNT(*) FROM uao_basic; diff --git a/src/test/regress/sql/uao_compaction/delete_toast.sql b/src/test/regress/sql/uao_compaction/delete_toast.sql new file mode 100644 index 0000000000000000000000000000000000000000..6335db0deb47a9cb39ada59ff8838c8add6def4d --- /dev/null +++ b/src/test/regress/sql/uao_compaction/delete_toast.sql @@ -0,0 +1,10 @@ +-- @Description Checkes the deletion and vacuuming of toast values + +-- Create a table with toasted values. +CREATE TABLE uao_delete_toast (a INT, b INT, c VARCHAR) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_delete_toast_index ON uao_delete_toast(b); +INSERT INTO uao_delete_toast SELECT i as a, 1 as b, i::text || '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' as c FROM generate_series(1, 10) AS i; + + +DELETE FROM uao_delete_toast; +VACUUM uao_delete_toast; diff --git a/src/test/regress/sql/uao_compaction/drop_column.sql b/src/test/regress/sql/uao_compaction/drop_column.sql new file mode 100644 index 0000000000000000000000000000000000000000..d9efc169d2cb674b085d98443ebfd2b9584e2e1b --- /dev/null +++ b/src/test/regress/sql/uao_compaction/drop_column.sql @@ -0,0 +1,17 @@ +-- @Description Tests dropping a column after a compaction + +CREATE TABLE uao_drop_col (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_drop_col_index ON uao_drop_col(b); +INSERT INTO uao_drop_col SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 10) AS i; + +DELETE FROM uao_drop_col WHERE a < 4; +SELECT COUNT(*) FROM uao_drop_col; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col_index'; +VACUUM uao_drop_col; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_drop_col_index'; +ALTER TABLE uao_drop_col DROP COLUMN c; +SELECT * FROM uao_drop_col; +INSERT INTO uao_drop_col VALUES (42, 42); +SELECT * FROM uao_drop_col; diff --git a/src/test/regress/sql/uao_compaction/drop_column_update.sql b/src/test/regress/sql/uao_compaction/drop_column_update.sql new file mode 100644 index 0000000000000000000000000000000000000000..8b6eb4b2d1a65f727347ec5ff408bb6cb0eb9b3d --- /dev/null +++ b/src/test/regress/sql/uao_compaction/drop_column_update.sql @@ -0,0 +1,15 @@ +-- @Description Tests dropping a column after a compaction with update + +CREATE TABLE ck_ct_ao_analyze3( +text_col text, +bigint_col bigint, +char_vary_col character varying(30), +int_array_col int[], +drop_col numeric) with (appendonly=true); + +INSERT INTO ck_ct_ao_analyze3 values ('1_zero', 1, '1_zero', '{1}', 1); +ALTER TABLE ck_ct_ao_analyze3 DROP COLUMN drop_col; +Select char_vary_col, int_array_col from ck_ct_ao_analyze3; +INSERT INTO ck_ct_ao_analyze3 values ('2_zero', 2, '2_zero', '{2}'); +update ck_ct_ao_analyze3 set bigint_col = bigint_col + 1 where text_col = '1_zero'; +Select char_vary_col, int_array_col from ck_ct_ao_analyze3; diff --git a/src/test/regress/sql/uao_compaction/eof_truncate.sql b/src/test/regress/sql/uao_compaction/eof_truncate.sql new file mode 100644 index 0000000000000000000000000000000000000000..8f8165dff223173bfceef63da430d39723c2b72d --- /dev/null +++ b/src/test/regress/sql/uao_compaction/eof_truncate.sql @@ -0,0 +1,18 @@ +-- @Description Tests the behavior while compacting is disabled + +CREATE TABLE uao_eof_truncate (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_eof_truncate_index ON uao_eof_truncate(b); +BEGIN; +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,1000) AS i; +COMMIT; +BEGIN; +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1000,2000) AS i; +ROLLBACK; + +SET gp_appendonly_compaction=false; +SELECT COUNT(*) FROM uao_eof_truncate; +VACUUM uao_eof_truncate; +SELECT COUNT(*) FROM uao_eof_truncate; +-- Insert afterwards +INSERT INTO uao_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +SELECT COUNT(*) FROM uao_eof_truncate; diff --git a/src/test/regress/sql/uao_compaction/full.sql b/src/test/regress/sql/uao_compaction/full.sql new file mode 100644 index 0000000000000000000000000000000000000000..e5c47a8d4222da943b54f76c61445aec151c0393 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/full.sql @@ -0,0 +1,15 @@ +-- @Description Test the basic bahavior of vacuum full + +CREATE TABLE uao_full (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_full_index ON uao_full(b); +INSERT INTO uao_full SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +INSERT INTO uao_full SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; + +DELETE FROM uao_full WHERE a < 4; +SELECT COUNT(*) FROM uao_full; +VACUUM FULL uao_full; +-- check if we get the same result afterwards +SELECT COUNT(*) FROM uao_full; +-- check if we can still insert into the relation +INSERT INTO uao_full VALUES (11, 11); +SELECT COUNT(*) FROM uao_full; diff --git a/src/test/regress/sql/uao_compaction/full_eof_truncate.sql b/src/test/regress/sql/uao_compaction/full_eof_truncate.sql new file mode 100644 index 0000000000000000000000000000000000000000..1464eacb3da47e412829f93aaf39e84eedfd3f67 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/full_eof_truncate.sql @@ -0,0 +1,18 @@ +-- @Description Tests the behavior while compacting is disabled + +CREATE TABLE full_eof_truncate (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX full_eof_truncate_index ON full_eof_truncate(b); +BEGIN; +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,1000) AS i; +COMMIT; +BEGIN; +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1000,2000) AS i; +ROLLBACK; + +SET gp_appendonly_compaction=false; +SELECT COUNT(*) FROM full_eof_truncate; +VACUUM FULL full_eof_truncate; +SELECT COUNT(*) FROM full_eof_truncate; +-- Insert afterwards +INSERT INTO full_eof_truncate SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1,10) AS i; +SELECT COUNT(*) FROM full_eof_truncate; diff --git a/src/test/regress/sql/uao_compaction/full_stats.sql b/src/test/regress/sql/uao_compaction/full_stats.sql new file mode 100644 index 0000000000000000000000000000000000000000..5299ffd5e9a0658627149bdb90e944e8a9d08b39 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/full_stats.sql @@ -0,0 +1,16 @@ +-- @Description Tests the behavior of full vacuum w.r.t. the pg_class statistics + +CREATE TABLE uao_full_stats (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_full_stats_index ON uao_full_stats(b); +INSERT INTO uao_full_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_full_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_full_stats; + +-- ensure that the scan go through the index +SET enable_seqscan=false; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats_index'; +DELETE FROM uao_full_stats WHERE a < 16; +VACUUM FULL uao_full_stats; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_full_stats_index'; diff --git a/src/test/regress/sql/uao_compaction/full_threshold.sql b/src/test/regress/sql/uao_compaction/full_threshold.sql new file mode 100644 index 0000000000000000000000000000000000000000..ce3c658a790905147a169165f1de5afe11306dcf --- /dev/null +++ b/src/test/regress/sql/uao_compaction/full_threshold.sql @@ -0,0 +1,10 @@ +-- @Description Tests that that full vacuum is ignoring the threshold guc value. + +CREATE TABLE uao_full_threshold (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_full_threshold_index ON uao_full_threshold(b); +INSERT INTO uao_full_threshold SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 100) AS i; + +VACUUM FULL uao_full_threshold; +DELETE FROM uao_full_threshold WHERE a < 4; +SET gp_appendonly_compaction_threshold=100; +VACUUM FULL uao_full_threshold; diff --git a/src/test/regress/sql/uao_compaction/index.sql b/src/test/regress/sql/uao_compaction/index.sql new file mode 100644 index 0000000000000000000000000000000000000000..a347c94de490f1f3670908289b671c9f1b3e271a --- /dev/null +++ b/src/test/regress/sql/uao_compaction/index.sql @@ -0,0 +1,9 @@ +-- @Description Tests basic index usage behavior after vacuuming + +CREATE TABLE uao_index_test (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_index_test_index ON uao_index_test(b); +INSERT INTO uao_index_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1,10) AS i; +INSERT INTO uao_index_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1,10) AS i; + +VACUUM uao_index_test; +SELECT * FROM uao_index_test WHERE b = 5; diff --git a/src/test/regress/sql/uao_compaction/index2.sql b/src/test/regress/sql/uao_compaction/index2.sql new file mode 100644 index 0000000000000000000000000000000000000000..67173c2f0f9090de0ac526d5a3a4a23157182f26 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/index2.sql @@ -0,0 +1,23 @@ +-- Test index usage after vacuuming. +-- Bug verification for MPP-24913 + +CREATE TABLE table_index2 (a BIGINT, b BIGINT) WITH (appendonly=true); +CREATE INDEX table_index2_index_a ON table_index2(a); +CREATE INDEX table_index2_index_b ON table_index2(b); + +\set QUIET off +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +UPDATE table_index2 SET b=100 WHERE a < 347305; +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +UPDATE table_index2 SET b=100 WHERE a < 347305; +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +INSERT INTO table_index2 SELECT *,* FROM generate_series(1, 347305); +UPDATE table_index2 SET b=101 WHERE b = 100; +VACUUM table_index2; +UPDATE table_index2 SET b=102 WHERE b = 101; +VACUUM table_index2; + +SELECT COUNT(*) FROM table_index2; +SET enable_seqscan=OFF; +SELECT COUNT(*) FROM table_index2 WHERE a > 0; diff --git a/src/test/regress/sql/uao_compaction/index_stats.sql b/src/test/regress/sql/uao_compaction/index_stats.sql new file mode 100644 index 0000000000000000000000000000000000000000..d8c3ea685383589c56581fa80cfe9c726940451b --- /dev/null +++ b/src/test/regress/sql/uao_compaction/index_stats.sql @@ -0,0 +1,19 @@ +-- @Description Tests basic index stats after vacuuming + +CREATE TABLE mytab( + col_int int, + col_text text, + col_numeric numeric, + col_unq int + ) with(appendonly=true) DISTRIBUTED RANDOMLY; + +Create index mytab_int_idx1 on mytab(col_int); + +insert into mytab values(1,'aa',1001,101),(2,'bb',1002,102); + +select * from mytab; +update mytab set col_text=' new value' where col_int = 1; +select * from mytab; +vacuum mytab; +SELECT relname, reltuples FROM pg_class WHERE relname = 'mytab'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'mytab_int_idx1'; diff --git a/src/test/regress/sql/uao_compaction/outdated_partialindex.sql b/src/test/regress/sql/uao_compaction/outdated_partialindex.sql new file mode 100644 index 0000000000000000000000000000000000000000..1e37a29b6892d88addd06c4671f45a453a390425 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/outdated_partialindex.sql @@ -0,0 +1,18 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash) in combination +-- with a partial index. + +CREATE TABLE uao_outdated_partial (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_outdated_partial_index ON uao_outdated_partial(b) WHERE b < 20; +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_outdated_partial; + +SET enable_seqscan=false; +DELETE FROM uao_outdated_partial WHERE a < 16; +VACUUM uao_outdated_partial; +SELECT * FROM uao_outdated_partial WHERE b = 20; +SELECT * FROM uao_outdated_partial WHERE b = 10; +INSERT INTO uao_outdated_partial SELECT i as a, i as b, 'Good morning' as c FROM generate_series(101, 110) AS i; +SELECT * FROM uao_outdated_partial WHERE b = 10; +SELECT * FROM uao_outdated_partial WHERE b = 102; diff --git a/src/test/regress/sql/uao_compaction/outdatedindex.sql b/src/test/regress/sql/uao_compaction/outdatedindex.sql new file mode 100644 index 0000000000000000000000000000000000000000..852dc9985f6fcca9da375e1b694d612f6e465a1f --- /dev/null +++ b/src/test/regress/sql/uao_compaction/outdatedindex.sql @@ -0,0 +1,16 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash). + +CREATE TABLE uao_outdated (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_outdated_index ON uao_outdated(b); +INSERT INTO uao_outdated SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_outdated SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_outdated; + +SET enable_seqscan=false; +DELETE FROM uao_outdated WHERE a < 16; +VACUUM uao_outdated; +SELECT * FROM uao_outdated WHERE b = 20; +SELECT * FROM uao_outdated WHERE b = 10; +INSERT INTO uao_outdated SELECT i as a, i as b, 'Good morning' as c FROM generate_series(1, 10) AS i; +SELECT * FROM uao_outdated WHERE b = 10; diff --git a/src/test/regress/sql/uao_compaction/outdatedindex_abort.sql b/src/test/regress/sql/uao_compaction/outdatedindex_abort.sql new file mode 100644 index 0000000000000000000000000000000000000000..c6f8d2184ca2e631bc7b5534b07e7bd687d0413c --- /dev/null +++ b/src/test/regress/sql/uao_compaction/outdatedindex_abort.sql @@ -0,0 +1,21 @@ +-- @Description Tests the behavior when the index of an ao table +-- has not been cleaned (e.g. because of a crash) in combination +-- with aborted inserts. + +CREATE TABLE uao_index_abort_test (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_index_abort_test_index ON uao_index_abort_test(b); +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_index_abort_test; + +SET enable_seqscan=false; +DELETE FROM uao_index_abort_test WHERE a < 16; +VACUUM uao_index_abort_test; +SELECT * FROM uao_index_abort_test WHERE b = 20; +SELECT * FROM uao_index_abort_test WHERE b = 10; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(1, 4) AS i; +BEGIN; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(5, 8) AS i; +INSERT INTO uao_index_abort_test SELECT i as a, i as b, 'Good morning' as c FROM generate_series(9, 12) AS i; +ROLLBACK; +SELECT * FROM uao_index_abort_test WHERE b < 16; diff --git a/src/test/regress/sql/uao_compaction/stats.sql b/src/test/regress/sql/uao_compaction/stats.sql new file mode 100644 index 0000000000000000000000000000000000000000..8be71e52673dbd4de7dd4941be386fd34422fec6 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/stats.sql @@ -0,0 +1,17 @@ +-- @Description Tests that the pg_class statistics are updated on +-- lazy vacuum. + +CREATE TABLE uao_stats (a INT, b INT, c CHAR(128)) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_stats_index ON uao_stats(b); +INSERT INTO uao_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(1, 50) AS i; +INSERT INTO uao_stats SELECT i as a, i as b, 'hello world' as c FROM generate_series(51, 100) AS i; +ANALYZE uao_stats; + +-- ensure that the scan go through the index +SET enable_seqscan=false; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats_index'; +DELETE FROM uao_stats WHERE a < 16; +VACUUM uao_stats; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats'; +SELECT relname, reltuples FROM pg_class WHERE relname = 'uao_stats_index'; diff --git a/src/test/regress/sql/uao_compaction/threshold.sql b/src/test/regress/sql/uao_compaction/threshold.sql new file mode 100644 index 0000000000000000000000000000000000000000..8de192d2e33b3adf94e3dd168aaf9a0e2f06463f --- /dev/null +++ b/src/test/regress/sql/uao_compaction/threshold.sql @@ -0,0 +1,34 @@ +-- @Description Tests the basic behavior of (lazy) vacuum w.r.t. to the threshold guc. +-- The output depends on the number of segments as the skip decision and the +-- notify is done on the segments. + +CREATE TABLE uao_threshold (a INT, b INT, c CHAR(128)) WITH (appendonly=true); +CREATE INDEX uao_threshold_index ON uao_threshold(b); +INSERT INTO uao_threshold SELECT i as a, 1 as b, 'hello world' as c FROM generate_series(1, 100) AS i; + +\set QUIET off + +VACUUM uao_threshold; +DELETE FROM uao_threshold WHERE a < 4; +SELECT COUNT(*) FROM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +-- 97 visible tuples, no vacuum +VACUUM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +DELETE FROM uao_threshold WHERE a < 12; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +-- 89 visible tuples, do vacuum +VACUUM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +-- no invisible tuples, no vacuum +VACUUM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +DELETE FROM uao_threshold WHERE a < 15; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +-- 3 invisible tuples, no vacuum +VACUUM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); +SET gp_appendonly_compaction_threshold=2; +-- 3 invisible tuples, no vacuum +VACUUM uao_threshold; +SELECT segno, tupcount, state FROM gp_toolkit.__gp_aoseg_name('uao_threshold'); diff --git a/src/test/regress/sql/uao_compaction/update_toast.sql b/src/test/regress/sql/uao_compaction/update_toast.sql new file mode 100644 index 0000000000000000000000000000000000000000..441e52fd5ef1c3334d91858f7929c550c373ca51 --- /dev/null +++ b/src/test/regress/sql/uao_compaction/update_toast.sql @@ -0,0 +1,15 @@ +-- @Description Check updating toast values + +-- Create a table with toasted values +CREATE TABLE uao_update_toast (a INT, b INT, c VARCHAR) WITH (appendonly=true) DISTRIBUTED BY (a); +CREATE INDEX uao_update_toast_index ON uao_update_toast(b); +INSERT INTO uao_update_toast SELECT i as a, 1 as b, i::text || '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' as c FROM generate_series(1, 30) AS i; + +-- Now perform updates +\set QUIET off + +UPDATE uao_update_toast SET c = '' WHERE a <= 10; +UPDATE uao_update_toast SET c = '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' WHERE a > 10 AND a <= 20; +UPDATE uao_update_toast SET b = 50 WHERE a > 20 AND a <= 30; +VACUUM uao_update_toast; +SELECT a, b, md5(c::text) FROM uao_update_toast;