should be it

external/duckdb/test/sql/insert/big_insert_rollback.test_slow

@@ -0,0 +1,25 @@
+# name: test/sql/insert/big_insert_rollback.test_slow
+# description: Rollback big insert statement
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO integers SELECT * FROM range(0, 500000)
+
+query I
+SELECT COUNT(*) FROM integers
+----
+500000
+
+statement ok
+ROLLBACK
+
+query I
+SELECT COUNT(*) FROM integers
+----
+0

external/duckdb/test/sql/insert/insert_by_name.test

@@ -0,0 +1,97 @@
+# name: test/sql/insert/insert_by_name.test
+# description: Test parallel insert from many groups
+# group: [insert]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE integers(i INTEGER, j INTEGER);
+
+# partial names
+# i=NULL, j=42
+statement ok
+INSERT INTO integers BY NAME SELECT 42 AS j
+
+# i=84, j=NULL
+statement ok
+INSERT INTO integers BY NAME SELECT 84 AS i
+
+# re-ordered names
+# i=9, j=99
+statement ok
+INSERT INTO integers BY NAME SELECT 99 AS j, 9 AS i
+
+# i=1, j=10
+statement ok
+INSERT INTO integers BY POSITION SELECT 1 AS j, 10 AS i
+
+query II
+FROM integers
+----
+NULL	42
+84	NULL
+9	99
+1	10
+
+# column that needs to be quoted
+statement ok
+CREATE TABLE "My Table"("My Column 1" INT, "My Column 2" INT);
+
+statement ok
+INSERT INTO "My Table" BY NAME SELECT 1 AS "My Column 2"
+
+query II
+FROM "My Table"
+----
+NULL	1
+
+# name does not exist
+statement error
+INSERT INTO integers BY NAME SELECT 1 AS xxx
+----
+xxx
+
+# duplicate names
+statement error
+INSERT INTO integers BY NAME SELECT 1 AS i, 2 AS i
+----
+i
+
+statement error
+INSERT INTO integers (i, i) SELECT 1, 2
+----
+i
+
+# rowid
+statement error
+INSERT INTO integers BY NAME SELECT 1 AS rowid
+----
+rowid
+
+# generated column
+statement ok
+CREATE TABLE tbl (
+	price INTEGER,
+	total_price AS ((price)::DATE)
+);
+
+statement error
+INSERT INTO tbl BY NAME SELECT 1 AS total_price
+----
+generated
+
+# insert by name with values list
+statement error
+INSERT INTO integers BY NAME VALUES (42, 84);
+----
+INSERT BY NAME
+
+# insert by name with columns list
+statement error
+INSERT INTO integers BY NAME (i) SELECT 1 AS j
+----
+explicit column list
+
+statement ok
+INSERT INTO integers BY POSITION VALUES (42, 84);

external/duckdb/test/sql/insert/insert_from_many_grouping_sets.test

@@ -0,0 +1,42 @@
+# name: test/sql/insert/insert_from_many_grouping_sets.test
+# description: Test parallel insert from many groups
+# group: [insert]
+
+statement ok
+CREATE TABLE integers AS SELECT i, i%2 as j FROM generate_series(0,999999,1) tbl(i);
+
+statement ok
+CREATE TABLE integers2 AS SELECT * FROM integers GROUP BY GROUPING SETS ((), (i), (i, j), (j));
+
+query IIIII
+SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers;
+----
+499999500000	500000	1000000	1000000	1000000
+
+query IIIII
+SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers2;
+----
+999999000000	500001	2000003	2000000	1000002
+
+statement ok
+DROP TABLE integers;
+
+statement ok
+DROP TABLE integers2;
+
+# now with null values
+statement ok
+CREATE TABLE integers AS SELECT case when i%2=0 then null else i end AS i, i%2 as j  FROM generate_series(0,999999,1) tbl(i);
+
+statement ok
+CREATE TABLE integers2 AS SELECT * FROM integers GROUP BY GROUPING SETS ((), (i), (i, j), (j));
+
+query IIIII
+SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers
+----
+250000000000	500000	1000000	500000	1000000
+
+query IIIII
+SELECT SUM(i), SUM(j), COUNT(*), COUNT(i), COUNT(j) FROM integers2
+----
+500000000000	500001	1000005	1000000	500003

external/duckdb/test/sql/insert/insert_from_many_groups.test_slow

@@ -0,0 +1,59 @@
+# name: test/sql/insert/insert_from_many_groups.test_slow
+# description: Test parallel insert from many groups
+# group: [insert]
+
+statement ok
+CREATE TABLE integers AS SELECT * FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE integers2 AS SELECT * FROM integers GROUP BY i
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers
+----
+499999500000	1000000	1000000
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers2
+----
+499999500000	1000000	1000000
+
+statement ok
+DROP TABLE integers
+
+statement ok
+DROP TABLE integers2
+
+# now with null values
+statement ok
+CREATE TABLE integers AS SELECT case when i%2=0 then null else i end AS i  FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE integers2 AS SELECT * FROM integers GROUP BY i
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers
+----
+250000000000	1000000	500000
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers2
+----
+250000000000	500001	500000
+
+# varchars
+statement ok
+CREATE TABLE varchars AS SELECT case when i%2=0 then null else concat('thisismyvarchar-', i//4) end AS v  FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE varchars2 AS SELECT * FROM varchars GROUP BY v
+
+query IIIII
+SELECT MIN(v), MAX(v), COUNT(*), COUNT(v), COUNT(DISTINCT v) FROM varchars
+----
+thisismyvarchar-0	thisismyvarchar-99999	1000000	500000	250000
+
+query IIIII
+SELECT MIN(v), MAX(v), COUNT(*), COUNT(v), COUNT(DISTINCT v) FROM varchars2
+----
+thisismyvarchar-0	thisismyvarchar-99999	250001	250000	250000

external/duckdb/test/sql/insert/insert_from_many_groups_complex.test_slow

@@ -0,0 +1,37 @@
+# name: test/sql/insert/insert_from_many_groups_complex.test_slow
+# description: Test parallel insert from many groups with complex types
+# group: [insert]
+
+# lists
+statement ok
+CREATE TABLE lists AS SELECT [i, NULL, i + 2] AS l FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE lists2 AS SELECT * FROM lists GROUP BY l;
+
+query IIIIIII
+SELECT SUM(l[1]), SUM(l[2]), SUM(l[3]), COUNT(*), COUNT(l), COUNT(l[1]), COUNT(l[2]) FROM lists
+----
+499999500000	NULL	500001500000	1000000	1000000	1000000	0
+
+query IIIIIII
+SELECT SUM(l[1]), SUM(l[2]), SUM(l[3]), COUNT(*), COUNT(l), COUNT(l[1]), COUNT(l[2]) FROM lists2
+----
+499999500000	NULL	500001500000	1000000	1000000	1000000	0
+
+# structs
+statement ok
+CREATE TABLE structs AS SELECT {'i': i, 'j': NULL, 'k': i + 2} AS s FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE structs2 AS SELECT * FROM structs GROUP BY s
+
+query IIIIIII
+SELECT SUM(s.i), SUM(s.j), SUM(s.k), COUNT(*), COUNT(s), COUNT(s.i), COUNT(s.j) FROM structs
+----
+499999500000	NULL	500001500000	1000000	1000000	1000000	0
+
+query IIIIIII
+SELECT SUM(s.i), SUM(s.j), SUM(s.k), COUNT(*), COUNT(s), COUNT(s.i), COUNT(s.j) FROM structs2
+----
+499999500000	NULL	500001500000	1000000	1000000	1000000	0

external/duckdb/test/sql/insert/insert_non_order_preserving.test_slow

@@ -0,0 +1,66 @@
+# name: test/sql/insert/insert_non_order_preserving.test_slow
+# description: Test parallel non order-preserving insert
+# group: [insert]
+
+statement ok
+PRAGMA preserve_insertion_order=false
+
+query I
+CREATE TABLE integers AS SELECT * FROM range(1000000) tbl(i);
+----
+1000000
+
+query I
+CREATE TABLE integers2 AS SELECT * FROM integers
+----
+1000000
+
+query I
+SELECT SUM(i) FROM integers
+----
+499999500000
+
+query I
+SELECT SUM(i) FROM integers2
+----
+499999500000
+
+statement ok
+DROP TABLE integers
+
+statement ok
+DROP TABLE integers2
+
+# now with null values
+statement ok
+CREATE TABLE integers AS SELECT case when i%2=0 then null else i end AS i  FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE integers2 AS SELECT * FROM integers
+
+query I
+SELECT SUM(i) FROM integers
+----
+250000000000
+
+query I
+SELECT SUM(i) FROM integers2
+----
+250000000000
+
+# varchars
+statement ok
+CREATE TABLE varchars AS SELECT case when i%2=0 then null else concat('thisismyvarchar-', i//4) end AS v  FROM range(1000000) tbl(i);
+
+statement ok
+CREATE TABLE varchars2 AS SELECT * FROM varchars
+
+query IIIII
+SELECT MIN(v), MAX(v), COUNT(*), COUNT(v), COUNT(DISTINCT v) FROM varchars
+----
+thisismyvarchar-0	thisismyvarchar-99999	1000000	500000	250000
+
+query IIIII
+SELECT MIN(v), MAX(v), COUNT(*), COUNT(v), COUNT(DISTINCT v) FROM varchars2
+----
+thisismyvarchar-0	thisismyvarchar-99999	1000000	500000	250000

external/duckdb/test/sql/insert/insert_rollback.test

@@ -0,0 +1,25 @@
+# name: test/sql/insert/insert_rollback.test
+# description: Rollback insert statement
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO integers VALUES (0), (1), (2)
+
+query I
+SELECT COUNT(*) FROM integers
+----
+3
+
+statement ok
+ROLLBACK
+
+query I
+SELECT COUNT(*) FROM integers
+----
+0

external/duckdb/test/sql/insert/interleaved_insert_rollback.test_slow

@@ -0,0 +1,49 @@
+# name: test/sql/insert/interleaved_insert_rollback.test_slow
+# description: Rollback interleaved big insert statements
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok con1
+BEGIN TRANSACTION
+
+statement ok con2
+BEGIN TRANSACTION
+
+statement ok con1
+INSERT INTO integers SELECT * FROM range(0, 500000)
+
+statement ok con2
+INSERT INTO integers SELECT * FROM range(0, 500000)
+
+query I con1
+SELECT COUNT(*) FROM integers
+----
+500000
+
+query I con2
+SELECT COUNT(*) FROM integers
+----
+500000
+
+statement ok con1
+ROLLBACK
+
+query I con1
+SELECT COUNT(*) FROM integers
+----
+0
+
+query I con2
+SELECT COUNT(*) FROM integers
+----
+500000
+
+statement ok con2
+ROLLBACK
+
+query I
+SELECT COUNT(*) FROM integers
+----
+0

external/duckdb/test/sql/insert/null_values.test

@@ -0,0 +1,40 @@
+# name: test/sql/insert/null_values.test
+# description: Test inserting many null values
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers SELECT i FROM range(100) tbl(i);
+
+statement ok
+BEGIN TRANSACTION
+
+loop i 0 5
+
+statement ok
+INSERT INTO integers SELECT i FROM range(100) tbl(i);
+
+statement ok
+INSERT INTO integers SELECT NULL FROM range(100) tbl(i);
+
+endloop
+
+query IIIII
+SELECT COUNT(i), SUM(i), MIN(i), MAX(i), COUNT(*) FROM integers
+----
+600	29700	0	99	1100
+
+statement ok
+COMMIT
+
+query IIIII
+SELECT COUNT(i), SUM(i), MIN(i), MAX(i), COUNT(*) FROM integers
+----
+600	29700	0	99	1100
+
+query I
+SELECT SUM(CASE WHEN i IS NULL THEN 1 ELSE 0 END) FROM integers
+----
+500

external/duckdb/test/sql/insert/parallel_insert_constraints.test_slow

@@ -0,0 +1,67 @@
+# name: test/sql/insert/parallel_insert_constraints.test_slow
+# description: Test parallel insert from many groups
+# group: [insert]
+
+# run both with and without preserving insertion order
+loop i 0 2
+
+# not null constraint
+statement ok
+CREATE OR REPLACE TABLE integers AS SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT NULL;
+
+statement ok
+CREATE OR REPLACE TABLE integers_not_null(i INTEGER NOT NULL);
+
+statement error
+INSERT INTO integers_not_null SELECT * FROM integers;
+----
+
+# generated columns
+statement ok
+CREATE OR REPLACE TABLE varchars AS SELECT i::VARCHAR s FROM range(1000000) tbl(i) UNION ALL SELECT 'hello';
+
+statement ok
+CREATE OR REPLACE TABLE varchars_generated(s VARCHAR, i AS (s::INT));
+
+statement error
+INSERT INTO varchars_generated (s) SELECT * FROM varchars;
+----
+
+# primary key
+statement ok
+CREATE OR REPLACE TABLE integers AS SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT 7777;
+
+statement ok
+CREATE OR REPLACE TABLE integers_pk(i INTEGER PRIMARY KEY);
+
+statement error
+INSERT INTO integers_pk SELECT * FROM integers;
+----
+
+# foreign key
+statement ok
+CREATE OR REPLACE TABLE integers AS SELECT * FROM range(1000000) tbl(i) UNION ALL SELECT -1;
+
+statement ok
+CREATE OR REPLACE TABLE integers_pk(i INTEGER PRIMARY KEY);
+
+statement ok
+INSERT INTO integers_pk SELECT * FROM range(1000000)
+
+statement ok
+CREATE OR REPLACE TABLE integers_fk(i INTEGER PRIMARY KEY REFERENCES integers_pk(i));
+
+statement error
+INSERT INTO integers_fk SELECT * FROM integers
+----
+
+statement ok
+DROP TABLE integers_fk;
+
+statement ok
+DROP TABLE integers_pk;
+
+statement ok
+PRAGMA preserve_insertion_order=false
+
+endloop

external/duckdb/test/sql/insert/parallel_insert_index.test_slow

@@ -0,0 +1,125 @@
+# name: test/sql/insert/parallel_insert_index.test_slow
+# description: Test that parallel data insertion correctly verifies primary/unique key constraints
+# group: [insert]
+
+statement ok
+CREATE TABLE integers AS SELECT i FROM generate_series(0,999999,1) tbl(i);
+
+loop i 0 2
+
+#######################################################
+# case 1: batch insert followed by constraint violation
+#######################################################
+statement ok
+CREATE TABLE integers2(i INTEGER PRIMARY KEY);
+
+statement ok
+INSERT INTO integers2 SELECT i FROM integers;
+
+statement error
+INSERT INTO integers2 VALUES (42);
+----
+violates primary key constraint
+
+query I
+SELECT * FROM integers2 WHERE i=999
+----
+999
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers;
+----
+499999500000	1000000	1000000
+
+query III
+SELECT SUM(i), COUNT(*), COUNT(i) FROM integers2;
+----
+499999500000	1000000	1000000
+
+statement ok
+DROP TABLE integers2;
+
+#######################################################
+# case 2: constraint violation during batch insertion
+#######################################################
+
+statement ok
+CREATE TABLE integers2(i INTEGER PRIMARY KEY);
+
+statement ok
+INSERT INTO integers2 VALUES (999999)
+
+statement error
+INSERT INTO integers2 SELECT i FROM integers;
+----
+violates primary key constraint
+
+query I
+SELECT COUNT(*) FROM integers2
+----
+1
+
+statement ok
+DROP TABLE integers2;
+
+#######################################################
+# case 3: batch insert followed by constraint violation in transaction local data
+#######################################################
+statement ok
+CREATE TABLE integers2(i INTEGER PRIMARY KEY);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO integers2 SELECT i FROM integers;
+
+statement error
+INSERT INTO integers2 VALUES (42);
+----
+<REGEX>:Constraint Error.*PRIMARY KEY or UNIQUE constraint violation.*
+
+statement ok
+ROLLBACK
+
+query I
+SELECT COUNT(*) FROM integers2
+----
+0
+
+statement ok
+DROP TABLE integers2;
+
+#######################################################
+# case 4: constraint violation during batch insertion in transaction local data
+#######################################################
+statement ok
+CREATE TABLE integers2(i INTEGER PRIMARY KEY);
+
+statement ok
+BEGIN TRANSACTION
+
+statement ok
+INSERT INTO integers2 VALUES (999999)
+
+statement error
+INSERT INTO integers2 SELECT i FROM integers;
+----
+<REGEX>:Constraint Error.*PRIMARY KEY or UNIQUE constraint violation.*
+
+statement ok
+ROLLBACK
+
+query I
+SELECT COUNT(*) FROM integers2
+----
+0
+
+statement ok
+DROP TABLE integers2;
+
+# repeat for non-insertion order preserving data
+statement ok
+SET preserve_insertion_order=false
+
+endloop

external/duckdb/test/sql/insert/test_insert.test

@@ -0,0 +1,39 @@
+# name: test/sql/insert/test_insert.test
+# description: Test insert into and updates of constant values
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (4), (5)
+
+# insert a constant 1 for every uneven value in "integers"
+statement ok
+CREATE TABLE i2 AS SELECT 1 AS i FROM integers WHERE i % 2 <> 0
+
+query I
+SELECT * FROM i2 ORDER BY 1
+----
+1
+1
+1
+
+# now update the table with a constant
+statement ok
+UPDATE i2 SET i=NULL
+
+query I
+SELECT * FROM i2 ORDER BY 1
+----
+NULL
+NULL
+NULL
+
+# Test insert with long string constant
+# found by Pedro Holanda
+statement ok
+CREATE TABLE IF NOT EXISTS presentations(presentation_date Date NOT NULL UNIQUE, author VARCHAR NOT NULL, title VARCHAR NOT NULL, bio VARCHAR, abstract VARCHAR, zoom_link VARCHAR);
+
+statement ok
+insert into presentations values ('2020-05-29', 'Eduardo Pena', 'Analytical Query Processing Based on Continuous Compression of Intermediates', NULL, 'Modern in-memory column-stores are widely accepted as the adequate database architecture for the efficient processing of complex analytical queries over large relational data volumes. These systems keep their entire data in main memory and typically employ lightweight compression to address the bottleneck between main memory and CPU. Numerous lightweight compression algorithms have been proposed in the past years, but none of them is suitable in all cases. While lightweight compression is already well established for base data, the efficient representation of intermediate results generated during query processing has attracted insufficient attention so far, although in in-memory systems, accessing intermeFdiates is as expensive as accessing base data. Thus, our vision is a continuous use of lightweight compression for all intermediates in a query execution plan, whereby a suitable compression algorithm should be selected for each intermediate. In this talk, I will provide an overview of our research in the context of this vision, including an experimental survey of lightweight compression algorithms, our compression-enabled processing model, and our compression-aware query optimization strategies.', 'https://zoom.us/j/7845983526');

external/duckdb/test/sql/insert/test_insert_invalid.test

@@ -0,0 +1,46 @@
+# name: test/sql/insert/test_insert_invalid.test
+# description: Test invalid INSERT INTO statements
+# group: [insert]
+
+statement ok
+CREATE TABLE strings(i STRING)
+
+statement ok
+INSERT INTO strings VALUES ('<EFBFBD>(')
+
+statement ok
+SELECT * FROM strings WHERE i = '<EFBFBD>('
+
+# Test insert with too few or too many cols
+statement ok
+CREATE TABLE a(i integer, j integer)
+
+statement ok
+INSERT INTO a VALUES (1, 2)
+
+# scalar inserts
+statement error
+INSERT INTO a VALUES (1)
+----
+<REGEX>:.*Binder Error.*table a has 2 columns.*
+
+statement error
+INSERT INTO a VALUES (1,2,3)
+----
+<REGEX>:.*Binder Error.*table a has 2 columns.*
+
+statement error
+INSERT INTO a VALUES (1,2),(3)
+----
+<REGEX>:.*Parser Error.*must all be the same length.*
+
+statement error
+INSERT INTO a VALUES (1,2),(3,4,5)
+----
+<REGEX>:.*Parser Error.*must all be the same length.*
+
+# also with queries
+statement error
+INSERT INTO a SELECT 42
+----
+<REGEX>:.*Binder Error.*table a has 2 columns.*

external/duckdb/test/sql/insert/test_insert_query.test

@@ -0,0 +1,19 @@
+# name: test/sql/insert/test_insert_query.test
+# description: Test insert from constant query
+# group: [insert]
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers SELECT 42
+
+statement ok
+INSERT INTO integers SELECT CAST(NULL AS VARCHAR)
+
+query I
+SELECT * FROM integers
+----
+42
+NULL
+

external/duckdb/test/sql/insert/test_insert_type.test

@@ -0,0 +1,36 @@
+# name: test/sql/insert/test_insert_type.test
+# description: Test insert into from wrong type
+# group: [insert]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+CREATE TABLE strings(a VARCHAR)
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers VALUES (3), (4), (NULL)
+
+statement ok
+INSERT INTO strings SELECT * FROM integers
+
+query T
+SELECT * FROM strings
+----
+3
+4
+NULL
+
+statement ok
+UPDATE strings SET a=13 WHERE a='3'
+
+query T
+SELECT * FROM strings ORDER BY cast(a AS INTEGER)
+----
+NULL
+4
+13
+

external/duckdb/test/sql/insert/unaligned_interleaved_appends.test

@@ -0,0 +1,84 @@
+# name: test/sql/insert/unaligned_interleaved_appends.test
+# description: Test unaligned interleaved appends
+# group: [insert]
+
+statement ok
+SET immediate_transaction_mode=true
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok con1
+BEGIN TRANSACTION
+
+# con2 insert 5 rows and begins a transaction
+statement ok con2
+INSERT INTO integers SELECT * FROM range(0, 5)
+
+statement ok con2
+BEGIN TRANSACTION
+
+# con3 inserts 17 rows and begins a transaction
+statement ok con3
+INSERT INTO integers SELECT * FROM range(0, 17)
+
+statement ok con3
+BEGIN TRANSACTION
+
+# con4 inserts 1007 rows and begins a transaction
+statement ok con4
+INSERT INTO integers SELECT * FROM range(0, 1007)
+
+statement ok con4
+BEGIN TRANSACTION
+
+# con5 inserts 3020 rows and begins a transaction
+statement ok con5
+INSERT INTO integers SELECT * FROM range(0, 3020)
+
+statement ok con5
+BEGIN TRANSACTION
+
+# con6 inserts 3 rows and begins a transaction
+statement ok con6
+INSERT INTO integers SELECT * FROM range(0, 3)
+
+statement ok con6
+BEGIN TRANSACTION
+
+# now we verify all the counts
+# con1: 0
+query I con1
+SELECT COUNT(*) FROM integers
+----
+0
+
+# con2: 5
+query I con2
+SELECT COUNT(*) FROM integers
+----
+5
+
+# con3: 22
+query I con3
+SELECT COUNT(*) FROM integers
+----
+22
+
+# con4: 1029
+query I con4
+SELECT COUNT(*) FROM integers
+----
+1029
+
+# con5: 4049
+query I con5
+SELECT COUNT(*) FROM integers
+----
+4049
+
+# con6: 4052
+query I con6
+SELECT COUNT(*) FROM integers
+----
+4052