should be it

external/duckdb/test/sql/storage/optimistic_write/optimistic_write.test_slow

@@ -0,0 +1,99 @@
+# name: test/sql/storage/optimistic_write/optimistic_write.test_slow
+# description: Test large appends within individual transactions
+# group: [optimistic_write]
+
+foreach skip_checkpoint true false
+
+load __TEST_DIR__/optimistic_write_${skip_checkpoint}.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit = ${skip_checkpoint}
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE OR REPLACE TABLE test (a INTEGER);
+
+statement ok
+INSERT INTO test SELECT * FROM range(1_000_000)
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+restart
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+statement ok
+INSERT INTO test SELECT * FROM range(1_000_000)
+
+query I
+SELECT SUM(a) FROM test
+----
+999999000000
+
+endloop
+
+# For smaller block sizes (16KB) the total blocks alternate between a few values in the loop.
+
+statement ok
+CREATE TABLE total_blocks_tbl (total_blocks UBIGINT);
+
+loop i 0 20
+
+statement ok
+BEGIN TRANSACTION;
+
+statement ok
+INSERT INTO test SELECT * FROM range(1_000_000);
+
+statement ok
+INSERT INTO test SELECT * FROM range(1_000_000);
+
+statement ok
+ROLLBACK;
+
+# Track the block count of each iteration.
+
+statement ok
+INSERT INTO total_blocks_tbl SELECT current.total_blocks FROM pragma_database_size() AS current
+
+statement ok
+CHECKPOINT;
+
+endloop
+
+# Ensure that the blocks don't grow between iterations.
+
+query I
+WITH tbl(w) AS (
+	SELECT struct_pack(
+		total_blocks := total_blocks,
+		sum := SUM (total_blocks) OVER (ROWS BETWEEN 0 PRECEDING AND 1 FOLLOWING)
+	 ) AS w
+	FROM total_blocks_tbl
+	LIMIT 19)
+SELECT list_filter(LIST(w), lambda x: x.total_blocks * 2.5 < x.sum) FROM tbl;
+----
+[]
+
+# Ensure that the blocks don't grow 'quietly' between iterations.
+
+query I
+WITH tbl(l) AS (
+	SELECT LIST(total_blocks) AS l FROM total_blocks_tbl)
+SELECT list_sum(l) < (list_count(l) * l[3] + 2 * l[3]) FROM tbl;
+----
+true
+
+statement ok
+INSERT INTO test VALUES (42);
+
+statement ok
+CHECKPOINT;

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_abort.test_slow

@@ -0,0 +1,77 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_abort.test_slow
+# description: Test abort of append within individual transaction
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_abort.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+restart
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT SUM(a) FROM test
+----
+999999000000
+
+statement ok
+CREATE TEMPORARY TABLE blocks AS SELECT total_blocks FROM pragma_database_size();
+
+# verify in a loop that the size of the system does not increase in case of rollbacks
+loop i 0 10
+
+statement error
+INSERT INTO test SELECT * FROM range(1000000) UNION ALL SELECT concat('hello', i)::INTEGER FROM range(10)
+----
+
+statement error
+INSERT INTO test SELECT * FROM range(1000000) UNION ALL SELECT concat('hello', i)::INTEGER FROM range(10)
+----
+
+statement ok
+CREATE TEMPORARY TABLE new_blocks AS SELECT total_blocks FROM pragma_database_size();
+
+query I
+SELECT new_blocks.total_blocks - blocks.total_blocks < 20 FROM blocks, new_blocks
+----
+true
+
+statement ok
+DROP TABLE blocks;
+
+statement ok
+CREATE TEMPORARY TABLE blocks AS SELECT * FROM new_blocks;
+
+statement ok
+DROP TABLE new_blocks
+
+statement ok
+CHECKPOINT;
+
+endloop
+
+statement ok
+INSERT INTO test VALUES (42);
+
+statement ok
+CHECKPOINT;
+
+statement ok
+CREATE TEMPORARY TABLE new_blocks AS SELECT total_blocks FROM pragma_database_size();
+
+query I
+SELECT new_blocks.total_blocks - blocks.total_blocks < 20 FROM blocks, new_blocks
+----
+true

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_add_column.test_slow

@@ -0,0 +1,65 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_add_column.test_slow
+# description: Test optimistic write with add column in transaction-local storage
+# group: [optimistic_write]
+
+foreach skip_checkpoint true false
+
+load __TEST_DIR__/optimistic_write_add_col_${skip_checkpoint}.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=${skip_checkpoint}
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+ALTER TABLE test ADD COLUMN b INTEGER
+
+statement ok
+UPDATE test SET b=a+1
+
+statement ok
+COMMIT
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+restart
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i, i FROM range(1000000) t(i)
+
+statement ok
+ALTER TABLE test ADD COLUMN c INTEGER
+
+statement ok
+UPDATE test SET c=a+1
+
+statement ok
+ROLLBACK
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+endloop

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_alter_type.test_slow

@@ -0,0 +1,109 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_alter_type.test_slow
+# description: Test optimistic write with alter type in transaction-local storage
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_alter_type.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i FROM range(1000000) tbl(i)
+
+statement ok
+ALTER TABLE test ALTER a SET TYPE BIGINT USING a + 1
+
+statement ok
+COMMIT
+
+query I
+SELECT SUM(a) FROM test
+----
+500000500000
+
+restart
+
+query I
+SELECT SUM(a) FROM test
+----
+500000500000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i FROM range(1000000) t(i)
+
+statement ok
+ALTER TABLE test ALTER a SET TYPE VARCHAR USING concat('hello', a)
+
+statement ok
+ROLLBACK
+
+query I
+SELECT SUM(a) FROM test
+----
+500000500000
+
+# Ensure that we reclaim space correctly.
+
+require skip_reload
+
+# For smaller block sizes (16KB) the total blocks alternate between a few values in the loop.
+# Therefore, we compare to a range of total block counts.
+statement ok
+CREATE TABLE total_blocks_tbl AS SELECT total_blocks FROM pragma_database_size();
+
+loop i 0 10
+
+statement ok
+DROP TABLE test
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i FROM range(1000000) tbl(i)
+
+statement ok
+ALTER TABLE test ALTER a SET TYPE BIGINT USING a + 1
+
+statement ok
+COMMIT
+
+query I
+SELECT SUM(a) FROM test
+----
+500000500000
+
+# Ensure that the total blocks don't exceed the total blocks after the first iteration
+# by more than 1.2.
+
+query I
+SELECT CASE WHEN ${i} = 0 THEN True
+	WHEN current.total_blocks <= total_blocks_tbl.total_blocks * 1.2 THEN True
+	ELSE False END
+FROM pragma_database_size() AS current, total_blocks_tbl;
+----
+1
+
+# Adjust total_blocks_tbl once to the count after the first iteration.
+
+statement ok
+UPDATE total_blocks_tbl SET total_blocks = (
+	SELECT CASE WHEN ${i} = 0 THEN (SELECT current.total_blocks FROM pragma_database_size() AS current)
+		ELSE (total_blocks) END);
+
+statement ok
+CHECKPOINT;
+
+statement ok
+CHECKPOINT;
+
+endloop

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_custom_row_group_size.test_slow

@@ -0,0 +1,56 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_custom_row_group_size.test_slow
+# description: Test large appends within individual transactions
+# group: [optimistic_write]
+
+statement ok
+ATTACH '__TEST_DIR__/optimistic_write_custom_row_group_size.db' AS attached_db (ROW_GROUP_SIZE 204800, STORAGE_VERSION 'v1.2.0')
+
+statement ok
+USE attached_db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=true
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE OR REPLACE TABLE test (a INTEGER);
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+# re-attach, this time with a different row group size
+statement ok
+ATTACH ':memory:' AS mem
+
+statement ok
+USE mem
+
+statement ok
+DETACH attached_db
+
+statement ok
+ATTACH '__TEST_DIR__/optimistic_write_custom_row_group_size.db' AS attached_db (ROW_GROUP_SIZE 2048)
+
+statement ok
+USE attached_db
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT SUM(a) FROM test
+----
+999999000000
+

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_cyclic_dictionary.test_slow

@@ -0,0 +1,63 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_cyclic_dictionary.test_slow
+# description: Test optimistic write with a cyclic scan
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_cyclic_dictionary.db
+
+statement ok
+CREATE TABLE test (c VARCHAR);
+
+statement ok
+BEGIN TRANSACTION
+
+# 250k
+statement ok
+INSERT INTO test SELECT case i%4 when 0 then 'a' when 1 then 'bb' when 2 then 'ccc' else NULL end c FROM range(250000) t(i)
+
+# 500k
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+# 1m
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+# 2m
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+statement ok
+COMMIT
+
+query IIIII
+SELECT MIN(c), MAX(c), SUM(LENGTH(c)), COUNT(c), COUNT(*) FROM test
+----
+a	ccc	3000000	1500000	2000000
+
+restart
+
+query IIIII
+SELECT MIN(c), MAX(c), SUM(LENGTH(c)), COUNT(c), COUNT(*) FROM test
+----
+a	ccc	3000000	1500000	2000000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+statement ok
+ROLLBACK
+
+query IIIII
+SELECT MIN(c), MAX(c), SUM(LENGTH(c)), COUNT(c), COUNT(*) FROM test
+----
+a	ccc	3000000	1500000	2000000
+
+restart
+
+query IIIII
+SELECT MIN(c), MAX(c), SUM(LENGTH(c)), COUNT(c), COUNT(*) FROM test
+----
+a	ccc	3000000	1500000	2000000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_cyclic_scan.test_slow

@@ -0,0 +1,83 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_cyclic_scan.test_slow
+# description: Test optimistic write with a cyclic scan
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_cyclic_scan.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+# 250k
+statement ok
+INSERT INTO test SELECT case when i%2=0 then null else i end FROM range(250000) t(i)
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+15625000000	125000	250000
+
+# 500k
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+31250000000	250000	500000
+
+# 1m
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+62500000000	500000	1000000
+
+# 2m
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+125000000000	1000000	2000000
+
+statement ok
+COMMIT
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+125000000000	1000000	2000000
+
+restart
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+125000000000	1000000	2000000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM test;
+
+statement ok
+ROLLBACK
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+125000000000	1000000	2000000
+
+restart
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+125000000000	1000000	2000000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_delete.test

@@ -0,0 +1,49 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_delete.test
+# description: Test optimistic write with deletes in transaction-local storage
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_delete.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+DELETE FROM test WHERE a=0
+
+statement ok
+COMMIT
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+restart
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+DELETE FROM test WHERE a=1
+
+statement ok
+ROLLBACK
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_delete_all.test_slow

@@ -0,0 +1,21 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_delete_all.test_slow
+# description: Test optimistic writes to a table followed by deleting all rows
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_delete_all.db
+
+statement ok
+create table foo  (d double);
+
+statement ok
+begin;
+
+statement ok
+insert into foo select random() from generate_series(1, 1000000) g(g);
+
+statement ok
+delete from foo;
+
+statement ok
+commit;

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_drop_column.test_slow

@@ -0,0 +1,109 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_drop_column.test_slow
+# description: Test optimistic write with drop column in transaction-local storage
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_drop.db
+
+statement ok
+CREATE TABLE test (a INTEGER, b INTEGER, c INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i, i + 1, i + 2 FROM range(1000000) tbl(i)
+
+statement ok
+ALTER TABLE test DROP COLUMN c
+
+statement ok
+COMMIT
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+restart
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i, i FROM range(1000000) t(i)
+
+statement ok
+ALTER TABLE test DROP COLUMN b
+
+statement ok
+ROLLBACK
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+# Ensure that we reclaim space correctly.
+
+require skip_reload
+
+# For smaller block sizes (16KB) the total blocks alternate between a few values in the loop.
+# Therefore, we compare to a range of total block counts.
+statement ok
+CREATE TABLE total_blocks_tbl AS SELECT total_blocks FROM pragma_database_size();
+
+loop i 0 10
+
+statement ok
+DROP TABLE test
+
+statement ok
+CREATE TABLE test (a INTEGER, b INTEGER, c INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT i, i + 1, i + 2 FROM range(1000000) tbl(i)
+
+statement ok
+ALTER TABLE test DROP COLUMN c
+
+statement ok
+COMMIT
+
+query II
+SELECT SUM(a), SUM(b) FROM test
+----
+499999500000	500000500000
+
+# Ensure that the total blocks don't exceed the total blocks after the first iteration
+# by more than 1.2.
+
+query I
+SELECT CASE WHEN ${i} = 0 THEN True
+	WHEN current.total_blocks <= total_blocks_tbl.total_blocks * 1.2 THEN True
+	ELSE False END
+FROM pragma_database_size() AS current, total_blocks_tbl;
+----
+1
+
+# Adjust total_blocks_tbl once to the count after the first iteration.
+
+statement ok
+UPDATE total_blocks_tbl SET total_blocks = (
+	SELECT CASE WHEN ${i} = 0 THEN (SELECT current.total_blocks FROM pragma_database_size() AS current)
+		ELSE (total_blocks) END);
+
+statement ok
+CHECKPOINT;
+
+statement ok
+CHECKPOINT;
+
+endloop

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_index.test_slow

@@ -0,0 +1,48 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_index.test_slow
+# description: Test optimistic writes and index creation
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_index.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+CREATE INDEX i_index ON test(a)
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+statement ok
+COMMIT
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+restart
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_large_strings.test

@@ -0,0 +1,52 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_large_strings.test
+# description: Issue #7887 - Test writing large strings using batch insertion
+# group: [optimistic_write]
+
+require parquet
+
+foreach skip_checkpoint true false
+
+load __TEST_DIR__/optimistic_write_large_strings_${skip_checkpoint}.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=${skip_checkpoint}
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE TABLE test(val VARCHAR);
+
+statement ok
+INSERT INTO test VALUES (NULL);
+
+statement ok
+COPY (SELECT repeat('X', len) FROM (VALUES (903), (4932)) t(len)) TO '__TEST_DIR__/large_strings.parquet';
+
+statement ok
+INSERT INTO test FROM read_parquet([
+	'__TEST_DIR__/large_strings.parquet',
+	'__TEST_DIR__/large_strings.parquet']
+);
+
+query I
+SELECT strlen(val) FROM test
+----
+NULL
+903
+4932
+903
+4932
+
+restart
+
+query I
+SELECT strlen(val) FROM test
+----
+NULL
+903
+4932
+903
+4932
+
+endloop

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_large_strings_deletes.test_slow

@@ -0,0 +1,54 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_large_strings_deletes.test_slow
+# description: Test writing large strings with deletes
+# group: [optimistic_write]
+
+require parquet
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_large_strings_deletes.db
+
+statement ok
+CREATE TABLE test(val VARCHAR);
+
+statement ok
+INSERT INTO test VALUES (NULL);
+
+statement ok
+COPY (SELECT 'hello' AS str FROM range(250000)) TO '__TEST_DIR__/small_strings.parquet';
+
+statement ok
+COPY (SELECT repeat('X', len) AS str FROM (VALUES (903), (4932)) t(len)) TO '__TEST_DIR__/large_strings.parquet';
+
+statement ok
+BEGIN
+
+statement ok
+INSERT INTO test FROM read_parquet([
+	'__TEST_DIR__/small_strings.parquet',
+	'__TEST_DIR__/large_strings.parquet']
+);
+
+query I
+SELECT MAX(strlen(val)) FROM test
+----
+4932
+
+query I
+DELETE FROM test WHERE val='hello'
+----
+250000
+
+query I
+SELECT MAX(strlen(val)) FROM test
+----
+4932
+
+statement ok
+COMMIT
+
+query I
+SELECT strlen(val) FROM test
+----
+NULL
+903
+4932

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_mixed.test_slow

@@ -0,0 +1,23 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_mixed.test_slow
+# description: Test mix of optimistic writes
+# group: [optimistic_write]
+
+require parquet
+
+statement ok
+copy (select uuid() sw_id, uuid()::varchar sw_system_object, uuid()::varchar source_system_id, uuid()::varchar source_system, uuid()::varchar source_system_object, uuid()::varchar source_system_field_name, random() <= 0.9 as is_primary from range(728478))
+to '__TEST_DIR__/external_ids_generated.parquet';
+
+load __TEST_DIR__/external_ids.db
+
+statement ok
+PRAGMA force_compression='uncompressed';
+
+statement ok
+SET threads = 48;
+
+statement ok
+SET preserve_insertion_order = false;
+
+statement ok
+create table external_ids_tbl as from parquet_scan('__TEST_DIR__/external_ids_generated.parquet');

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_multi_statement.test_slow

@@ -0,0 +1,27 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_multi_statement.test_slow
+# description: Test multiple appends across statements within the same transaction
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_multi_statement.db
+
+statement ok
+SET force_compression='uncompressed';
+
+statement ok
+CREATE TABLE main_tbl (v INT);
+
+statement ok
+BEGIN
+
+foreach file_size 130815 68295 68490
+
+statement ok
+CREATE OR REPLACE TEMPORARY TABLE insert_tbl AS FROM range(${file_size});
+
+statement ok
+INSERT INTO main_tbl FROM insert_tbl;
+
+endloop
+
+statement ok
+COMMIT

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_multi_statement_string.test_slow

@@ -0,0 +1,29 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_multi_statement_string.test_slow
+# description: Test multiple appends across statements within the same transaction
+# group: [optimistic_write]
+
+require parquet
+
+load __TEST_DIR__/optimistic_write_multi_statement_string.db
+
+statement ok
+SET force_compression='uncompressed';
+
+statement ok
+CREATE TABLE main_tbl (v VARCHAR);
+
+statement ok
+BEGIN
+
+foreach file_size 130815 125018 125774 77995
+
+statement ok
+COPY (SELECT uuid()::VARCHAR FROM range(${file_size})) TO '__TEST_DIR__/file.parquet' (ROW_GROUP_SIZE 100000000);
+
+statement ok
+INSERT INTO main_tbl FROM '__TEST_DIR__/file.parquet';
+
+endloop
+
+statement ok
+COMMIT

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_nulls.test

@@ -0,0 +1,43 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_nulls.test
+# description: Test large appends within individual transactions
+# group: [optimistic_write]
+
+foreach skip_checkpoint true false
+
+load __TEST_DIR__/optimistic_write_nulls_${skip_checkpoint}.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=${skip_checkpoint}
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+INSERT INTO test SELECT case when i%3=0 then null else i end FROM range(1000000) t(i)
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+333332666667	666666	1000000
+
+restart
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+833332166667	1666666	2000000
+
+restart
+
+query III
+SELECT SUM(a), COUNT(a), COUNT(*) FROM test
+----
+833332166667	1666666	2000000
+
+endloop

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_primary_key.test_slow

@@ -0,0 +1,53 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_primary_key.test_slow
+# description: Test optimistic writes and primary key
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_pk.db
+
+statement ok
+CREATE TABLE test (a INTEGER PRIMARY KEY);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+statement ok
+COMMIT
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+statement error
+INSERT INTO test VALUES (42)
+----
+
+restart
+
+query I
+SELECT * FROM test WHERE a=242773
+----
+242773
+
+query I
+SELECT SUM(a) FROM test
+----
+499999500000
+
+statement error
+INSERT INTO test VALUES (42)
+----

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_temp_table.test

@@ -0,0 +1,40 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_temp_table.test
+# description: Test large writes on temporary tables
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_temp.db
+
+statement ok
+CREATE TABLE integers AS SELECT 42 i
+
+statement ok
+CHECKPOINT
+
+query I
+SELECT total_blocks < 10 FROM pragma_database_size();
+----
+true
+
+# ensure temporary tables are not actually written to the main storage
+statement ok
+CREATE TEMPORARY TABLE test (a INTEGER);
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+query I
+SELECT total_blocks < 10 FROM pragma_database_size();
+----
+true
+
+statement ok
+CREATE TEMPORARY TABLE test2 (a INTEGER);
+
+statement ok
+INSERT INTO test2 SELECT * FROM range(1000000)
+
+query I
+SELECT total_blocks < 10 FROM pragma_database_size();
+----
+true

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_tpch_sf1.test_slow

@@ -0,0 +1,55 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_tpch_sf1.test_slow
+# description: Test large appends within individual transactions
+# group: [optimistic_write]
+
+require parquet
+
+require tpch
+
+statement ok
+CALL dbgen(sf=1);
+
+foreach tbl lineitem orders partsupp part customer supplier nation region
+
+statement ok
+COPY ${tbl} TO '__TEST_DIR__/${tbl}_sf1.parquet'
+
+endloop
+
+load __TEST_DIR__/optimistic_write_lineitem.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=true
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+foreach tbl lineitem orders partsupp part customer supplier nation region
+
+statement ok
+CREATE TABLE ${tbl} AS FROM '__TEST_DIR__/${tbl}_sf1.parquet';
+
+endloop
+
+restart
+
+loop i 1 9
+
+query I
+PRAGMA tpch(${i})
+----
+<FILE>:extension/tpch/dbgen/answers/sf1/q0${i}.csv
+
+endloop
+
+loop i 10 23
+
+query I
+PRAGMA tpch(${i})
+----
+<FILE>:extension/tpch/dbgen/answers/sf1/q${i}.csv
+
+endloop
+
+statement ok
+CHECKPOINT

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_update.test

@@ -0,0 +1,49 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_update.test
+# description: Test optimistic write with updates in transaction-local storage
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_update.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+UPDATE test SET a=500000 WHERE a=0
+
+statement ok
+COMMIT
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000
+
+restart
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+UPDATE test SET a=500000 WHERE a=0
+
+statement ok
+ROLLBACK
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_update_wal.test_slow

@@ -0,0 +1,56 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_update_wal.test_slow
+# description: Test optimistic write with updates in transaction-local storage going to the WAL
+# group: [optimistic_write]
+
+# load the DB from disk
+load __TEST_DIR__/optimistic_write_update_wal.db
+
+statement ok
+CREATE TABLE test (a INTEGER);
+
+statement ok
+SET checkpoint_threshold='1GB'
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+UPDATE test SET a=500000 WHERE a=0
+
+statement ok
+COMMIT
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000
+
+restart
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO test SELECT * FROM range(1000000)
+
+statement ok
+UPDATE test SET a=500000 WHERE a=0
+
+statement ok
+ROLLBACK
+
+query I
+SELECT SUM(a) FROM test
+----
+500000000000

external/duckdb/test/sql/storage/optimistic_write/optimistic_write_with_regular_writes_wal.test_slow

@@ -0,0 +1,52 @@
+# name: test/sql/storage/optimistic_write/optimistic_write_with_regular_writes_wal.test_slow
+# description: Mix of optimistic writes with regular writes with the WAL
+# group: [optimistic_write]
+
+load __TEST_DIR__/optimistic_write_with_regular_writes_wal.db
+
+statement ok
+SET debug_skip_checkpoint_on_commit=true
+
+statement ok
+PRAGMA disable_checkpoint_on_shutdown
+
+statement ok
+CREATE OR REPLACE TABLE test (a INTEGER, big_payload VARCHAR DEFAULT concat('longprefix_', uuid()::VARCHAR));
+
+# a bunch of (smaller) regular writes
+statement ok
+INSERT INTO test (a) SELECT * FROM range(5000)
+
+statement ok
+INSERT INTO test (a) SELECT * FROM range(5000, 10000)
+
+statement ok
+INSERT INTO test (a) SELECT * FROM range(10000, 15000)
+
+statement ok
+INSERT INTO test (a) SELECT * FROM range(15000, 20000)
+
+# a big write
+statement ok
+INSERT INTO test (a) SELECT * FROM range(20000, 1000000)
+
+query II
+SELECT SUM(a), SUM(STRLEN(big_payload)) FROM test
+----
+499999500000	47000000
+
+# restart
+restart
+
+query II
+SELECT SUM(a), SUM(STRLEN(big_payload)) FROM test
+----
+499999500000	47000000
+
+statement ok
+INSERT INTO test (a) SELECT * FROM range(1000000)
+
+query II
+SELECT SUM(a), SUM(STRLEN(big_payload)) FROM test
+----
+999999000000	94000000