marsultor/email-tracker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

should be it

Browse Source
This commit is contained in:
Mars Ultor
2025-10-24 19:21:19 -05:00
parent a4b23fc57c
commit f09560c7b1
14047 changed files with 3161551 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
external/duckdb/test/sql/update/block_boundary_update.test_slow vendored Normal file
View File

@@ -0,0 +1,51 @@
# name: test/sql/update/block_boundary_update.test_slow
# description: Update big table of even and odd values
# group: [update]
statement ok
CREATE TABLE test AS SELECT * FROM range (0, 50000, 1) t1(i);
query II
SELECT COUNT(i), SUM(i) FROM test
----
50000 1249975000
statement ok
UPDATE test SET i=i+1
query II
SELECT COUNT(i), SUM(i) FROM test
----
50000 1250025000
statement ok
UPDATE test SET i=i+1
query II
SELECT COUNT(i), SUM(i) FROM test
----
50000 1250075000
statement ok
INSERT INTO test SELECT * FROM test;
query II
SELECT COUNT(i), SUM(i) FROM test
----
100000 2500150000
statement ok
UPDATE test SET i=i+1
query II
SELECT COUNT(i), SUM(i) FROM test
----
100000 2500250000
statement ok
UPDATE test SET i=i+1
query II
SELECT COUNT(i), SUM(i) FROM test
----
100000 2500350000

33
external/duckdb/test/sql/update/large_string_null_update.test_slow vendored Normal file
View File

@@ -0,0 +1,33 @@
# name: test/sql/update/large_string_null_update.test_slow
# description: Test back and forth update of string NULL values with many strings
# group: [update]
load __TEST_DIR__/string_null_update.db
statement ok
create table t (id int, col varchar);
statement ok
insert into t (id) select range as id from range(0, 1000000);
query III
SELECT COUNT(*), COUNT(id), COUNT(col) FROM t
----
1000000 1000000 0
statement ok
update t set col = 'x';
query III
SELECT COUNT(*), COUNT(id), COUNT(col) FROM t
----
1000000 1000000 1000000
statement ok
update t set col = NULL;
query III
SELECT COUNT(*), COUNT(id), COUNT(col) FROM t
----
1000000 1000000 0

128
external/duckdb/test/sql/update/null_update_merge.test vendored Normal file
View File

@@ -0,0 +1,128 @@
# name: test/sql/update/null_update_merge.test
# description: Test repeated updates that change the nullness of values
# group: [update]
# create a table
statement ok
CREATE TABLE test (id INTEGER, a INTEGER);
statement ok
INSERT INTO test VALUES (1, 1), (2, 2), (3, 3), (4, NULL);
query II
SELECT * FROM test ORDER BY id;
----
1 1
2 2
3 3
4 NULL
statement ok
UPDATE test SET a=CASE WHEN id=1 THEN 7 ELSE NULL END WHERE id <= 2
query II
SELECT * FROM test ORDER BY id;
----
1 7
2 NULL
3 3
4 NULL
statement ok
UPDATE test SET a=17 WHERE id > 2
query II
SELECT * FROM test ORDER BY id;
----
1 7
2 NULL
3 17
4 17
statement ok
UPDATE test SET a=CASE WHEN id=4 THEN 1 ELSE NULL END
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 1
statement ok
UPDATE test SET a=2 WHERE id >= 2 AND id <= 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 2
3 2
4 1
statement ok
UPDATE test SET a=NULL WHERE id >= 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 2
3 NULL
4 NULL
statement ok
UPDATE test SET a=id WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 1
2 2
3 NULL
4 4
statement ok
UPDATE test SET a=NULL WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 NULL
statement ok
UPDATE test SET a=3 WHERE id != 2
query II
SELECT * FROM test ORDER BY id;
----
1 3
2 NULL
3 3
4 3
statement ok
UPDATE test SET a=7 WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 7
2 7
3 3
4 7
statement ok
UPDATE test SET a=NULL
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 NULL

120
external/duckdb/test/sql/update/null_update_merge_transaction.test vendored Normal file
View File

@@ -0,0 +1,120 @@
# name: test/sql/update/null_update_merge_transaction.test
# description: Test repeated updates that change the nullness of values
# group: [update]
# create a table
statement ok
CREATE TABLE test (id INTEGER, a INTEGER);
statement ok
INSERT INTO test VALUES (1, 1), (2, 2), (3, 3), (4, NULL);
query II
SELECT * FROM test ORDER BY id;
----
1 1
2 2
3 3
4 NULL
statement ok
BEGIN TRANSACTION
statement ok
UPDATE test SET a=CASE WHEN a IS NULL THEN 1 ELSE NULL END
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 1
statement ok
UPDATE test SET a=2 WHERE id >= 2 AND id <= 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 2
3 2
4 1
statement ok
UPDATE test SET a=NULL WHERE id >= 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 2
3 NULL
4 NULL
statement ok
UPDATE test SET a=id WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 1
2 2
3 NULL
4 4
statement ok
UPDATE test SET a=NULL WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 NULL
statement ok
UPDATE test SET a=3 WHERE id != 2
query II
SELECT * FROM test ORDER BY id;
----
1 3
2 NULL
3 3
4 3
statement ok
UPDATE test SET a=7 WHERE id != 3
query II
SELECT * FROM test ORDER BY id;
----
1 7
2 7
3 3
4 7
statement ok
UPDATE test SET a=NULL
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 NULL
statement ok
COMMIT
query II
SELECT * FROM test ORDER BY id;
----
1 NULL
2 NULL
3 NULL
4 NULL

27
external/duckdb/test/sql/update/string_update_issue_2471.test_slow vendored Normal file
View File

@@ -0,0 +1,27 @@
# name: test/sql/update/string_update_issue_2471.test_slow
# description: Repeated update of string values
# group: [update]
statement ok
CREATE VIEW test_table_view AS SELECT * FROM 'data/csv/issue2471.csv'
statement ok
create table test_table (isin VARCHAR(20), value VARCHAR(1));
statement ok
insert into test_table SELECT * FROM test_table_view;
statement ok
UPDATE test_table set value = tdv.value FROM test_table_view tdv where tdv.isin = test_table.isin;
query IIIII
select count(distinct isin), min(isin), max(isin), min(value), max(value) from test_table;
----
2300 XXXXAT0000A22H40 XXXXXS2366276595 1 1
loop i 0 100
statement ok
UPDATE test_table set value = tdv.value FROM test_table_view tdv where tdv.isin = test_table.isin
endloop

35
external/duckdb/test/sql/update/string_update_transaction_local_7348.test vendored Normal file
View File

@@ -0,0 +1,35 @@
# name: test/sql/update/string_update_transaction_local_7348.test
# description: Issue #7348 - crash when updating transaction local storage
# group: [update]
statement ok
BEGIN;
statement ok
CREATE TABLE t1(a VARCHAR(256) PRIMARY KEY, b INTEGER);
statement ok
INSERT INTO t1 VALUES(' 4-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 2 + 1);
statement ok
INSERT INTO t1 VALUES(' 34-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 18);
statement ok
INSERT INTO t1 SELECT b, b + 1 FROM t1 WHERE b < 5;
query II
FROM t1
----
4-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 3
34-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 18
3 4
statement ok
UPDATE t1 SET a = CONCAT(a, 'x') WHERE b % 2 = 0;
query II
FROM t1
----
4-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 3
34-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZx 18
3x 4

96
external/duckdb/test/sql/update/test_big_string_update.test vendored Normal file
View File

@@ -0,0 +1,96 @@
# name: test/sql/update/test_big_string_update.test
# description: Test update of big string
# group: [update]
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('abcdefghijklmnopqrstuvwxyz')
# increase the size of the string until it is bigger than a block
# 26 -> 260
# concat the string 10x and insert it
statement ok con1
INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test
# delete the old value
statement ok con1
DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test)
# 260 -> 2600
# concat the string 10x and insert it
statement ok con1
INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test
# delete the old value
statement ok con1
DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test)
# 2600 -> 26000
# concat the string 10x and insert it
statement ok con1
INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test
# delete the old value
statement ok con1
DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test)
# 26000 -> 260000
# concat the string 10x and insert it
statement ok con1
INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test
# delete the old value
statement ok con1
DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test)
# 260000 -> 2600000
# concat the string 10x and insert it
statement ok con1
INSERT INTO test SELECT a||a||a||a||a||a||a||a||a||a FROM test
# delete the old value
statement ok con1
DELETE FROM test WHERE length(a) = (SELECT MIN(length(a)) FROM test)
# verify that the string length is correct
query I con1
SELECT LENGTH(a) FROM test
----
2600000
# now update the big string in a separate transaction
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a='a'
# verify the lengths
query I con1
SELECT LENGTH(a) FROM test
----
1
query I con2
SELECT LENGTH(a) FROM test
----
2600000
# now commit
statement ok con1
COMMIT
# the big string is gone now
query I con1
SELECT LENGTH(a) FROM test
----
1
query I con2
SELECT LENGTH(a) FROM test
----
1

118
external/duckdb/test/sql/update/test_big_table_update.test_slow vendored Normal file
View File

@@ -0,0 +1,118 @@
# name: test/sql/update/test_big_table_update.test_slow
# description: Update big table of even and odd values
# group: [update]
# create a table with the values [0, ..., 3K]
statement ok con1
BEGIN TRANSACTION
statement ok con1
CREATE TABLE test AS SELECT i AS a, 'hello' AS b FROM range (0, 3000, 1) t1(i);
# insert a bunch more values
# 3000 -> 6000
statement ok con1
INSERT INTO test SELECT * FROM test
# 6000 -> 12000
statement ok con1
INSERT INTO test SELECT * FROM test
# 12000 -> 24000
statement ok con1
INSERT INTO test SELECT * FROM test
# 24000 -> 48000
statement ok con1
INSERT INTO test SELECT * FROM test
# 48000 -> 96000
statement ok con1
INSERT INTO test SELECT * FROM test
# 96000 -> 192000
statement ok con1
INSERT INTO test SELECT * FROM test
# 192000 -> 384000
statement ok con1
INSERT INTO test SELECT * FROM test
statement ok con1
COMMIT
query RR con1
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
# increment all even values by two
statement ok con1
BEGIN TRANSACTION
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
query I con1
UPDATE test SET a=a+2, b='hellohello' WHERE a%2=0
----
192000
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
query RR con1
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
576192000 2880000
# now increment all odd values by two
statement ok con1
UPDATE test SET a=a+2, b='hellohello' WHERE a%2=1
query RR con1
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
576576000 3840000
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
# increment all tuples by two now
statement ok con1
UPDATE test SET a=a+2, b='hellohellohellohello'
query RR con1
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
577344000 7680000
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
575808000 1920000
statement ok con1
COMMIT
query RR con1
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
577344000 7680000
query RR con2
SELECT SUM(a), SUM(LENGTH(b)) FROM test
----
577344000 7680000

71
external/duckdb/test/sql/update/test_cascading_updates.test vendored Normal file
View File

@@ -0,0 +1,71 @@
# name: test/sql/update/test_cascading_updates.test
# description: Test many different updates
# group: [update]
load __TEST_DIR__/cascading_updates.db
statement ok
SET default_null_order='nulls_first';
statement ok
SET immediate_transaction_mode=true
statement ok con1
BEGIN
statement ok
CREATE TABLE integers(id INTEGER, val INTEGER);
statement ok
INSERT INTO integers SELECT i, i FROM range(10000) t(i)
statement ok
PRAGMA checkpoint_threshold='1GB'
statement ok
UPDATE integers SET val=val+1000000 WHERE id=1
statement ok con2
BEGIN
statement ok
UPDATE integers SET val=val+1000000 WHERE id=2
statement ok con3
BEGIN
statement ok
UPDATE integers SET val=val+1000000 WHERE id=3
statement ok con1
COMMIT
query I
SELECT COUNT(*) FROM integers WHERE val>1000000
----
3
# we cannot checkpoint because con2/con3 rely on older changes
statement error
CHECKPOINT
----
Cannot CHECKPOINT
# after committing, we can checkpoint
statement ok con2
COMMIT
statement ok con3
COMMIT
# even if con2 is active, we can still checkpoint
statement ok con2
BEGIN
statement ok
CHECKPOINT
query I
SELECT COUNT(*) FROM integers WHERE val>1000000
----
3

81
external/duckdb/test/sql/update/test_multiple_assignment.test vendored Normal file
View File

@@ -0,0 +1,81 @@
# name: test/sql/update/test_multiple_assignment.test
# description: Update with multiple assignment
# group: [update]
# create table and insert some values
# ---------------------------------------------------
statement ok
CREATE TABLE tbl (key INT, fruit VARCHAR, cost INT);
statement ok
INSERT INTO tbl VALUES (1, 'apple', 2), (2, 'orange', 3);
# simple case
# ---------------------------------------------------
statement ok
UPDATE tbl SET (key, fruit, cost) = (1, 'pear', 2);
query III
SELECT * FROM tbl;
----
1 pear 2
1 pear 2
# ROW function
# ---------------------------------------------------
statement ok
UPDATE tbl SET (key, fruit, cost) = (2, 'apple', 3);
query III
SELECT * FROM tbl;
----
2 apple 3
2 apple 3
# 1 value
# ---------------------------------------------------
statement ok
UPDATE tbl SET (key, fruit, cost) = 3;
query III
SELECT * FROM tbl;
----
3 3 3
3 3 3
# too few values
# ---------------------------------------------------
statement error
UPDATE tbl SET (key, fruit, cost) = (1, 2);
----
expected 3 values, got 2
# too many values
# ---------------------------------------------------
statement error
UPDATE tbl SET (key, fruit, cost) = (1, 2, 3, 4);
----
expected 3 values, got 4
# functions should still work
# ---------------------------------------------------
statement ok
UPDATE tbl SET (key, fruit, cost) = ADD(key, cost);
query III
SELECT * FROM tbl;
----
6 6 6
6 6 6
# empty lists
# ---------------------------------------------------
statement error
UPDATE tbl SET () = (key, fruit);
----
Parser Error: syntax error at or near ")"
statement error
UPDATE tbl SET (key, fruit) = ();
----
Parser Error: syntax error at or near ")"

196
external/duckdb/test/sql/update/test_null_update.test vendored Normal file
View File

@@ -0,0 +1,196 @@
# name: test/sql/update/test_null_update.test
# description: Test standard update behavior with NULLs
# group: [update]
statement ok
SET default_null_order='nulls_first';
# create a table
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3), (NULL)
query I con1
SELECT * FROM test ORDER BY a
----
NULL
1
2
3
# test updating from a non-null value to a null value
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=NULL WHERE a=2
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
query I con2
SELECT * FROM test ORDER BY a
----
NULL
1
2
3
# commit
statement ok con1
COMMIT
query I con1
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
# now test a rollback
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=NULL WHERE a=3
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test ORDER BY a
----
NULL
NULL
NULL
1
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
statement ok con1
ROLLBACK
query I con1
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
# test updating from a null value to a non-null value
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=10 WHERE a IS NULL
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test ORDER BY a
----
1
3
10
10
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
# now rollback
statement ok con1
ROLLBACK
# values are back to original values
query I con1
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
# perform the same update, but this time commit
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=10 WHERE a IS NULL
query I con1
SELECT * FROM test ORDER BY a
----
1
3
10
10
query I con2
SELECT * FROM test ORDER BY a
----
NULL
NULL
1
3
statement ok con1
COMMIT
query I con1
SELECT * FROM test ORDER BY a
----
1
3
10
10
query I con2
SELECT * FROM test ORDER BY a
----
1
3
10
10

61
external/duckdb/test/sql/update/test_repeated_string_update.test vendored Normal file
View File

@@ -0,0 +1,61 @@
# name: test/sql/update/test_repeated_string_update.test
# description: Test repeated update of string in same segment
# group: [update]
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('hello'), ('world')
statement ok con2
BEGIN TRANSACTION;
# scan the table
query T con1
SELECT * FROM test ORDER BY a
----
hello
world
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
# test a number of repeated updates
statement ok con1
UPDATE test SET a='test' WHERE a='hello';
query T con1
SELECT * FROM test ORDER BY a
----
test
world
statement ok con1
UPDATE test SET a='test2' WHERE a='world';
query T con1
SELECT * FROM test ORDER BY a
----
test
test2
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
statement ok con2
COMMIT;
query T con1
SELECT * FROM test ORDER BY a
----
test
test2

65
external/duckdb/test/sql/update/test_string_update.test vendored Normal file
View File

@@ -0,0 +1,65 @@
# name: test/sql/update/test_string_update.test
# description: Test update of string columns
# group: [update]
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('hello'), ('world')
statement ok con2
BEGIN TRANSACTION;
# scan the table
query T con1
SELECT * FROM test ORDER BY a
----
hello
world
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
# test a delete from the table
statement ok con1
DELETE FROM test WHERE a='hello';
query T con1
SELECT * FROM test ORDER BY a
----
world
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
# now test an update of the table
statement ok con1
UPDATE test SET a='hello';
query T con1
SELECT * FROM test ORDER BY a
----
hello
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
statement ok con2
COMMIT;
query T con2
SELECT * FROM test ORDER BY a
----
hello

130
external/duckdb/test/sql/update/test_string_update_many_strings.test vendored Normal file
View File

@@ -0,0 +1,130 @@
# name: test/sql/update/test_string_update_many_strings.test
# description: Test string updates with many strings
# group: [update]
statement ok
SET default_null_order='nulls_first';
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('a'), ('b'), ('c'), (NULL)
# insert the same strings many times
# 16 -> 64
statement ok con1
INSERT INTO test SELECT * FROM test
# 64 -> 256
statement ok con1
INSERT INTO test SELECT * FROM test
# 256 -> 1024
statement ok con1
INSERT INTO test SELECT * FROM test
# 1024 -> 4096
statement ok con1
INSERT INTO test SELECT * FROM test
# 4096 -> 16384
statement ok con1
INSERT INTO test SELECT * FROM test
# 16384 -> 65536
statement ok con1
INSERT INTO test SELECT * FROM test
# 65536 -> 262144
statement ok con1
INSERT INTO test SELECT * FROM test
# 262144 -> 1048576
statement ok con1
INSERT INTO test SELECT * FROM test
# verify that the distinct values are correct
query T con1
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
a
b
c
query T con2
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
a
b
c
# test update of string column in another transaction
statement ok con1
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a='aa' WHERE a='a';
# verify that the values were updated
query T con1
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
aa
b
c
query T con2
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
a
b
c
# now roll it back
statement ok con1
ROLLBACK;
# the values should be back to normal
query T con1
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
a
b
c
query T con2
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
a
b
c
# this time do the same but commit it
statement ok con1
UPDATE test SET a='aa' WHERE a='a';
# now both connections have the updated value
query T con1
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
aa
b
c
query T con2
SELECT DISTINCT a FROM test ORDER BY a
----
NULL
aa
b
c

45
external/duckdb/test/sql/update/test_string_update_null.test vendored Normal file
View File

@@ -0,0 +1,45 @@
# name: test/sql/update/test_string_update_null.test
# description: Test update of string columns with NULLs
# group: [update]
statement ok
SET default_null_order='nulls_first';
statement ok
SET immediate_transaction_mode=true
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('hello'), ('world')
statement ok con2
BEGIN TRANSACTION;
# update a string to NULL
statement ok con1
UPDATE test SET a=NULL where a='world';
query T con1
SELECT * FROM test ORDER BY a
----
NULL
hello
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
statement ok con2
COMMIT;
query T con2
SELECT * FROM test ORDER BY a
----
NULL
hello

117
external/duckdb/test/sql/update/test_string_update_rollback.test vendored Normal file
View File

@@ -0,0 +1,117 @@
# name: test/sql/update/test_string_update_rollback.test
# description: Test rollback of string update
# group: [update]
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('hello'), ('world')
statement ok con1
BEGIN TRANSACTION;
# perform an update within the transaction
statement ok con1
UPDATE test SET a='test' WHERE a='hello';
query T con1
SELECT * FROM test ORDER BY a
----
test
world
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
# now rollback the update
statement ok con1
ROLLBACK;
query T con1
SELECT * FROM test ORDER BY a
----
hello
world
query T con2
SELECT * FROM test ORDER BY a
----
hello
world
# rollback of a value that is updated twice
statement ok con1
UPDATE test SET a='test' WHERE a='hello';
statement ok con1
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a='test2' WHERE a='test';
query T con1
SELECT * FROM test ORDER BY a
----
test2
world
query T con2
SELECT * FROM test ORDER BY a
----
test
world
statement ok con1
ROLLBACK;
query T con1
SELECT * FROM test ORDER BY a
----
test
world
query T con2
SELECT * FROM test ORDER BY a
----
test
world
# test rollback of string update in different part
statement ok con1
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a='test2' WHERE a='world';
query T con1
SELECT * FROM test ORDER BY a
----
test
test2
query T con2
SELECT * FROM test ORDER BY a
----
test
world
statement ok con1
ROLLBACK;
query T con1
SELECT * FROM test ORDER BY a
----
test
world
query T con2
SELECT * FROM test ORDER BY a
----
test
world

91
external/duckdb/test/sql/update/test_string_update_rollback_null.test vendored Normal file
View File

@@ -0,0 +1,91 @@
# name: test/sql/update/test_string_update_rollback_null.test
# description: Test rollback of string update with NULL
# group: [update]
statement ok
SET default_null_order='nulls_first';
# create a table
statement ok con1
CREATE TABLE test (a VARCHAR);
statement ok con1
INSERT INTO test VALUES ('test'), ('world')
# test rollback of value -> NULL update
statement ok con1
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a=NULL WHERE a='world';
query T con1
SELECT * FROM test ORDER BY a
----
NULL
test
query T con2
SELECT * FROM test ORDER BY a
----
test
world
statement ok con1
ROLLBACK;
query T con1
SELECT * FROM test ORDER BY a
----
test
world
query T con2
SELECT * FROM test ORDER BY a
----
test
world
# test rollback of NULL -> value update
statement ok con1
UPDATE test SET a=NULL WHERE a='world';
query T con1
SELECT * FROM test ORDER BY a
----
NULL
test
statement ok con1
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a='world' WHERE a IS NULL;
query T con1
SELECT * FROM test ORDER BY a
----
test
world
query T con2
SELECT * FROM test ORDER BY a
----
NULL
test
statement ok con1
ROLLBACK;
query T con1
SELECT * FROM test ORDER BY a
----
NULL
test
query T con2
SELECT * FROM test ORDER BY a
----
NULL
test

83
external/duckdb/test/sql/update/test_unaligned_update.test_slow vendored Normal file
View File

@@ -0,0 +1,83 @@
# name: test/sql/update/test_unaligned_update.test_slow
# description: Unaligned updates
# group: [update]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE t1 AS SELECT * FROM generate_series(0, 1999, 1) tbl(i)
statement ok
CREATE TABLE t2 AS SELECT * FROM generate_series(0, 4999, 1) tbl(i)
query I
SELECT SUM(i) FROM t1
----
1999000
query I
SELECT SUM(i) FROM t2
----
12497500
query I
SELECT COUNT(*) FROM t1, t2 WHERE t1.i<33
----
165000
query I
SELECT COUNT(*) FROM t1, t2 WHERE t2.i<33
----
66000
# update with a cross-product
statement ok
UPDATE t1 SET i=33 FROM t2 WHERE t1.i<33
statement ok
UPDATE t2 SET i=33 FROM t1 WHERE t2.i<33
query I
SELECT SUM(i) FROM t1
----
1999561
query I
SELECT SUM(i) FROM t2
----
12498061
# update with a inequality join
statement ok
UPDATE t1 SET i=34 FROM t2 WHERE t1.i=33 AND t1.i<>t2.i
statement ok
UPDATE t2 SET i=34 FROM t1 WHERE t2.i=33 AND t1.i<>t2.i
query I
SELECT SUM(i) FROM t1
----
1999595
query I
SELECT SUM(i) FROM t2
----
12498095
# update with a range join
statement ok
UPDATE t1 SET i=35 FROM t2 WHERE t1.i=34 AND t1.i<t2.i
statement ok
UPDATE t2 SET i=35 FROM t1 WHERE t2.i=34 AND t2.i<t1.i
query I
SELECT SUM(i) FROM t1
----
1999630
query I
SELECT SUM(i) FROM t2
----
12498130

102
external/duckdb/test/sql/update/test_update.test vendored Normal file
View File

@@ -0,0 +1,102 @@
# name: test/sql/update/test_update.test
# description: Test standard update behavior
# group: [update]
statement ok
PRAGMA enable_verification
# create a table
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (3)
query I con1
SELECT * FROM test
----
3
query I con1
SELECT * FROM test WHERE a=3
----
3
# test simple update
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=1
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test
----
1
query I con1
SELECT * FROM test WHERE a=1
----
1
query I con2
SELECT * FROM test
----
3
query I con2
SELECT * FROM test WHERE a=3
----
3
# commit
statement ok con1
COMMIT
query I con1
SELECT * FROM test
----
1
query I con2
SELECT * FROM test
----
1
# now test a rollback
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=4
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test
----
4
query I con2
SELECT * FROM test
----
1
statement ok con1
ROLLBACK
query I con1
SELECT * FROM test
----
1
query I con1
SELECT * FROM test WHERE a=1
----
1
query I con2
SELECT * FROM test
----
1

43
external/duckdb/test/sql/update/test_update_delete_same_tuple.test vendored Normal file
View File

@@ -0,0 +1,43 @@
# name: test/sql/update/test_update_delete_same_tuple.test
# description: Test update and delete of the same tuple
# group: [update]
# on a normal table, we can update and delete the same tuple concurrently without a conflict
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3);
statement ok con1
BEGIN TRANSACTION;
statement ok con2
BEGIN TRANSACTION;
statement ok con1
UPDATE test SET a=a+1;
statement ok con2
DELETE FROM test
query I con1
SELECT * FROM test ORDER BY a
----
2
3
4
query I con2
SELECT * FROM test ORDER BY a
----
statement ok con1
COMMIT;
statement ok con2
COMMIT;
statement ok con1
DROP TABLE test;

159
external/duckdb/test/sql/update/test_update_from.test vendored Normal file
View File

@@ -0,0 +1,159 @@
# name: test/sql/update/test_update_from.test
# description: Test updates that use a from clause
# group: [update]
# create a table
statement ok
CREATE TABLE test (a INTEGER);
statement ok
INSERT INTO test VALUES (3)
statement ok
CREATE TABLE src (a INTEGER);
statement ok
INSERT INTO src VALUES (2)
query I
SELECT * FROM test
----
3
query I
SELECT * FROM src
----
2
# test simple update
statement ok
UPDATE test SET a=test.a+s.a FROM src s
query I
SELECT * FROM test
----
5
# test self join via alias
statement ok
UPDATE test SET a=test.a+t.a FROM test t
query I
SELECT * FROM test
----
10
# test multiple tables
statement ok
UPDATE test SET a=t.a+s.a FROM test t, src s
query I
SELECT * FROM test
----
12
# test subquery
statement ok
UPDATE test SET a=s.q FROM (SELECT a+1 as q FROM src) s
query I
SELECT * FROM test
----
3
# test view
statement ok
CREATE VIEW vt AS (SELECT 17 as v)
statement ok
UPDATE test SET a=v FROM vt
query I
SELECT * FROM test
----
17
# with a where clause on the from table
statement ok
UPDATE test SET a=s.a FROM src s WHERE s.a = 2
query I
SELECT * FROM test
----
2
# with a where clause that involves both tables
statement ok
UPDATE test t SET a=1 FROM src s WHERE s.a = t.a
query I
SELECT * FROM test
----
1
# with a where clause that evaluates to false
statement ok
UPDATE test t SET a=9 FROM src s WHERE s.a=t.a
query I
SELECT * FROM test
----
1
# test with multiple updates per row (which is undefined),
# but in this case the last value in the table will win
# FIXME:
mode skip
statement ok
INSERT INTO src VALUES (7)
statement ok
UPDATE test SET a=s.a FROM src s
query I
SELECT * FROM test
----
7
mode unskip
# test described in issue 1035
statement ok
CREATE TABLE terms(docid INTEGER, term INTEGER);
statement ok
CREATE TABLE docs(id INTEGER, len INTEGER);
statement ok
insert into docs values (1, 0), (2, 0);
statement ok
insert into terms values (1, 1);
statement ok
insert into terms values (2, 1);
statement ok
insert into terms values (2, 2);
statement ok
insert into terms values (2, 3);
statement ok
UPDATE docs
SET len = sq.len
FROM (
SELECT docid AS id, count(term) AS len
FROM terms
GROUP BY docid
ORDER BY docid
) AS sq
WHERE docs.id = sq.id;
query II
select * from docs;
----
1 1
2 3

111
external/duckdb/test/sql/update/test_update_issue_3170.test vendored Normal file
View File

@@ -0,0 +1,111 @@
# name: test/sql/update/test_update_issue_3170.test
# description: Update indexed table rows with large row_id ( > 122879) which cross the first segment/row_group.
# group: [update]
statement ok
PRAGMA enable_verification
# create a table
statement ok
CREATE TABLE student(id INTEGER, name VARCHAR, PRIMARY KEY(id));
statement ok
INSERT INTO student SELECT i, 'creator' FROM RANGE(260001) tbl(i)
# read
# rowgroup 0
query I
SELECT name FROM student WHERE id = 122879
----
creator
# rowgroup 1
query I
SELECT name FROM student WHERE id = 122881
----
creator
# rowgroup 2
query I
SELECT name FROM student WHERE id = 245780
----
creator
# rowgroup 1 vector > 0
query I
SELECT name FROM student WHERE id = 150881
----
creator
# Update
# rowgroup 0
statement ok
UPDATE student SET name = 'updator0' WHERE id = 122879
# rowgroup 1
statement ok
UPDATE student SET name = 'updator1' WHERE id = 122881
# rowgroup 2
statement ok
UPDATE student SET name = 'updator2' WHERE id = 245780
# rowgroup 1 vector > 0
statement ok
UPDATE student SET name = 'updator3' WHERE id = 150881
# read again
# rowgroup 0
query I
SELECT name FROM student WHERE id = 122879
----
updator0
# rowgroup 1
query I
SELECT name FROM student WHERE id = 122881
----
updator1
# rowgroup 2
query I
SELECT name FROM student WHERE id = 245780
----
updator2
# rowgroup 1 vector > 0
query I
SELECT name FROM student WHERE id = 150881
----
updator3
# Original issue.
load __TEST_DIR__/list_index_compression.db
statement ok
CREATE TABLE student(id INTEGER, name VARCHAR, PRIMARY KEY(id));
statement ok
insert into student select i, 'creator' from range(130001) tbl(i);
query II
select id, name from student where id=122881;
----
122881 creator
statement ok
UPDATE student SET name = 'updator' WHERE id = 122881;
query II
SELECT id, name FROM student WHERE id = 122881;
----
122881 updator
restart
query II
SELECT id, name FROM student WHERE id = 122881;
----
122881 updator

321
external/duckdb/test/sql/update/test_update_many_updaters.test vendored Normal file
View File

@@ -0,0 +1,321 @@
# name: test/sql/update/test_update_many_updaters.test
# description: Test update behavior with multiple updaters
# group: [update]
statement ok
SET immediate_transaction_mode=true
# this test contains four query connections (con1, con2, con3, con4)
# and one updating connection (updater)
# first create a table, filled with 3 values (1), (2), (3)
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3)
# now we start updating specific values and reading different versions
# con1 sees the initial state
statement ok con1
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=4 WHERE a=1
statement ok con2
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=5 WHERE a=2
statement ok con3
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=6 WHERE a=3
statement ok con4
BEGIN TRANSACTION
# now read the different states
# con sees {1, 2, 3}
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
# con2 sees {2, 3, 4}
query I con2
SELECT * FROM test ORDER BY a
----
2
3
4
# con3 sees {3, 4, 5}
query I con3
SELECT * FROM test ORDER BY a
----
3
4
5
# con4 sees {4, 5, 6}
query I con4
SELECT * FROM test ORDER BY a
----
4
5
6
# now verify that we get conflicts when we update values that have been updated AFTER we started
statement error con1
UPDATE test SET a=99 WHERE a=1
----
statement error con2
UPDATE test SET a=99 WHERE a=2
----
statement error con3
UPDATE test SET a=99 WHERE a=3
----
# revert to previous state
statement ok updater
UPDATE test SET a=a-3
# rollback all connections
statement ok con1
ROLLBACK
statement ok con2
ROLLBACK
statement ok con3
ROLLBACK
statement ok con4
ROLLBACK
# we repeat the previous process of updates
statement ok con1
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=4 WHERE a=1
statement ok con2
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=5 WHERE a=2
statement ok con3
BEGIN TRANSACTION
statement ok updater
UPDATE test SET a=6 WHERE a=3
statement ok con4
BEGIN TRANSACTION
# now read the different states
# con sees {1, 2, 3}
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
# con2 sees {2, 3, 4}
query I con2
SELECT * FROM test ORDER BY a
----
2
3
4
# con3 sees {3, 4, 5}
query I con3
SELECT * FROM test ORDER BY a
----
3
4
5
# con4 sees {4, 5, 6}
query I con4
SELECT * FROM test ORDER BY a
----
4
5
6
# we now verify that we CAN update values that were committed BEFORE we started
statement ok con2
UPDATE test SET a=7 WHERE a=4
statement ok con3
UPDATE test SET a=8 WHERE a=5
statement ok con4
UPDATE test SET a=9 WHERE a=6
# now read the different states again
# con sees {1, 2, 3} still
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
# con2 sees {2, 3, 7}
query I con2
SELECT * FROM test ORDER BY a
----
2
3
7
# con3 sees {3, 4, 8}
query I con3
SELECT * FROM test ORDER BY a
----
3
4
8
# con4 sees {4, 5, 9}
query I con4
SELECT * FROM test ORDER BY a
----
4
5
9
# updater still sees {4, 5, 6}
query I updater
SELECT * FROM test ORDER BY a
----
4
5
6
# now we commit in phases
# first we commit con4
statement ok con4
COMMIT
# con, con2, con3 still see the same data, con4 sees the currently committed data
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
query I con2
SELECT * FROM test ORDER BY a
----
2
3
7
query I con3
SELECT * FROM test ORDER BY a
----
3
4
8
query I con4
SELECT * FROM test ORDER BY a
----
4
5
9
# then we commit con2
statement ok con2
COMMIT
# con, con3 still see the same data, con2 and con4 see the committed data
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
query I con2
SELECT * FROM test ORDER BY a
----
5
7
9
query I con3
SELECT * FROM test ORDER BY a
----
3
4
8
query I con4
SELECT * FROM test ORDER BY a
----
5
7
9
# then we commit con3
statement ok con3
COMMIT
# con still sees the same data, but the rest all see the committed data
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
query I con2
SELECT * FROM test ORDER BY a
----
7
8
9
query I con3
SELECT * FROM test ORDER BY a
----
7
8
9
query I con4
SELECT * FROM test ORDER BY a
----
7
8
9
# now we commit con1, this should trigger a cleanup
statement ok con1
COMMIT
# now con1 also sees the committed data
query I con1
SELECT * FROM test ORDER BY a
----
7
8
9

136
external/duckdb/test/sql/update/test_update_many_updaters_nulls.test vendored Normal file
View File

@@ -0,0 +1,136 @@
# name: test/sql/update/test_update_many_updaters_nulls.test
# description: Test update behavior with multiple updaters and NULL values
# group: [update]
statement ok
SET default_null_order='nulls_first';
statement ok
SET immediate_transaction_mode=true
statement ok updater
PRAGMA enable_verification
statement ok con1
PRAGMA enable_verification
statement ok con2
PRAGMA enable_verification
statement ok con3
PRAGMA enable_verification
statement ok con4
PRAGMA enable_verification
statement ok con5
PRAGMA enable_verification
# this test contains five query connections (con1, con2, con3, con4, con5)
# and one updating connection (updater)
# create a table, filled with 3 values (1), (2), (3)
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3)
# now we start updating specific values and reading different versions
statement ok con1
BEGIN TRANSACTION
query I updater
UPDATE test SET a=NULL WHERE a=1
----
1
statement ok con2
BEGIN TRANSACTION
query I updater
UPDATE test SET a=NULL WHERE a=2
----
1
statement ok con3
BEGIN TRANSACTION
query I updater
UPDATE test SET a=NULL WHERE a=3
----
1
statement ok con4
BEGIN TRANSACTION
query I updater
SELECT COUNT(*) FROM test WHERE a IS NULL
----
3
query I updater
UPDATE test SET a=99 WHERE a IS NULL
----
3
statement ok con5
BEGIN TRANSACTION
# now read the different states
# con sees {1, 2, 3}
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
# con2 sees {NULL, 2, 3}
query I con2
SELECT * FROM test ORDER BY a
----
NULL
2
3
# con3 sees {NULL, NULL, 3}
query I con3
SELECT * FROM test ORDER BY a
----
NULL
NULL
3
# con4 sees {NULL, NULL, NULL}
query I con4
SELECT * FROM test ORDER BY a
----
NULL
NULL
NULL
# con5 sees {99, 99, 99}
query I con5
SELECT * FROM test ORDER BY a
----
99
99
99
# now verify that we get conflicts when we update values that have been updated AFTER we started
statement error con1
UPDATE test SET a=99 WHERE a=1
----
statement error con2
UPDATE test SET a=99 WHERE a=2
----
statement error con3
UPDATE test SET a=99 WHERE a=3
----
statement error con4
UPDATE test SET a=99 WHERE a IS NULL
----

77
external/duckdb/test/sql/update/test_update_mix.test vendored Normal file
View File

@@ -0,0 +1,77 @@
# name: test/sql/update/test_update_mix.test
# description: Test mix of updates inserts and deletes
# group: [update]
statement ok
SET immediate_transaction_mode=true
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3);
query R con1
SELECT SUM(a) FROM test
----
6.000000
statement ok con1
BEGIN TRANSACTION
# append from con2
statement ok con2
INSERT INTO test VALUES (4), (5), (6);
query R con1
SELECT SUM(a) FROM test
----
6.000000
query R con2
SELECT SUM(a) FROM test
----
21.000000
# delete from con2
statement ok con2
DELETE FROM test WHERE a < 4
query R con1
SELECT SUM(a) FROM test
----
6.000000
query R con2
SELECT SUM(a) FROM test
----
15.000000
# update from con2
statement ok con2
UPDATE test SET a=a-3
query R con1
SELECT SUM(a) FROM test
----
6.000000
query R con2
SELECT SUM(a) FROM test
----
6.000000
# now commit
statement ok con1
COMMIT
query R con1
SELECT SUM(a) FROM test
----
6.000000
query R con2
SELECT SUM(a) FROM test
----
6.000000

41
external/duckdb/test/sql/update/test_update_same_string_value.test vendored Normal file
View File

@@ -0,0 +1,41 @@
# name: test/sql/update/test_update_same_string_value.test
# description: Test repeated update of string in same transaction
# group: [update]
# create a table
statement ok
CREATE TABLE test (a VARCHAR);
statement ok
INSERT INTO test VALUES ('hello'), ('world')
statement ok
BEGIN TRANSACTION;
statement ok
UPDATE test SET a='test' WHERE a='hello';
query T
SELECT * FROM test ORDER BY a
----
test
world
statement ok
UPDATE test SET a='test2' WHERE a='world';
query T
SELECT * FROM test ORDER BY a
----
test
test2
statement ok
COMMIT;
query T
SELECT * FROM test ORDER BY a
----
test
test2

187
external/duckdb/test/sql/update/test_update_same_value.test vendored Normal file
View File

@@ -0,0 +1,187 @@
# name: test/sql/update/test_update_same_value.test
# description: Update the same value multiple times in one transaction
# group: [update]
statement ok
PRAGMA enable_verification
# create a table
statement ok con1
CREATE TABLE test (a INTEGER);
statement ok con1
INSERT INTO test VALUES (1), (2), (3)
query I con1
SELECT * FROM test ORDER BY a
----
1
2
3
# update entire table
statement ok con1
BEGIN TRANSACTION
statement ok con1
UPDATE test SET a=a+1
# not seen yet by con2, only by con1
query I con1
SELECT * FROM test
----
2
3
4
query I con1
SELECT * FROM test WHERE a=4
----
4
query I con2
SELECT * FROM test
----
1
2
3
# update the entire table again
statement ok con1
UPDATE test SET a=a+1
query I con1
SELECT * FROM test ORDER BY a
----
3
4
5
query I con2
SELECT * FROM test ORDER BY a
----
1
2
3
# now commit
statement ok con1
COMMIT
query I con1
SELECT * FROM test ORDER BY a
----
3
4
5
query I con2
SELECT * FROM test ORDER BY a
----
3
4
5
# now perform updates one by one
statement ok con1
BEGIN TRANSACTION
query I con1
SELECT * FROM test
----
3
4
5
query I con1
SELECT * FROM test WHERE a=5
----
5
# 5 => 9
statement ok con1
UPDATE test SET a=9 WHERE a=5
query I con1
SELECT * FROM test ORDER BY a
----
3
4
9
# test concurrent update in con2, it should fail now
statement error con2
UPDATE test SET a=a+1
----
query I con2
SELECT * FROM test ORDER BY a
----
3
4
5
# 3 => 7
statement ok con1
UPDATE test SET a=7 WHERE a=3
query I con1
SELECT * FROM test ORDER BY a
----
4
7
9
# test concurrent update in con2, it should fail now
statement error con2
UPDATE test SET a=a+1
----
query I con2
SELECT * FROM test ORDER BY a
----
3
4
5
# 4 => 8
statement ok con1
UPDATE test SET a=8 WHERE a=4
query I con1
SELECT * FROM test ORDER BY a
----
7
8
9
# test concurrent update in con2, it should fail now
statement error con2
UPDATE test SET a=a+1
----
query I con2
SELECT * FROM test ORDER BY a
----
3
4
5
# commit
statement ok con1
COMMIT
query I con1
SELECT * FROM test ORDER BY a
----
7
8
9
query I con2
SELECT * FROM test ORDER BY a
----
7
8
9

29
external/duckdb/test/sql/update/update_after_commit.test vendored Normal file
View File

@@ -0,0 +1,29 @@
# name: test/sql/update/update_after_commit.test
# description: Issue #6651 - Crash When Updating after Commit
# group: [update]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE a (b int);
statement ok
BEGIN;
statement ok
INSERT INTO a VALUES (1);
statement ok
UPDATE a SET b = b + 10;
statement ok
COMMIT;
statement ok
UPDATE a SET b = b + 10;
query I
SELECT * FROM a
----
21

12
external/duckdb/test/sql/update/update_default.test vendored Normal file
View File

@@ -0,0 +1,12 @@
# name: test/sql/update/update_default.test
# description: Test for 40th item of fuzzer issues from https://github.com/duckdb/duckdb/issues/5984
# group: [update]
statement ok
CREATE TABLE t1 (c0 INT);
statement ok
INSERT INTO t1(c0) VALUES (1),(2),(3);
statement ok
UPDATE t1 SET c0 = DEFAULT;

41
external/duckdb/test/sql/update/update_delete_wal.test vendored Normal file
View File

@@ -0,0 +1,41 @@
# name: test/sql/update/update_delete_wal.test
# description: Integer null update checkpoint
# group: [update]
load __TEST_DIR__/update_delete_wal.db
statement ok
SET wal_autocheckpoint='1TB';
statement ok
create table test (id bigint primary key, c1 text);
statement ok
insert into test (id, c1) values (1, 'foo');
statement ok
insert into test (id, c1) values (2, 'bar');
statement ok
begin transaction;
statement ok
delete from test where id = 1;
statement ok
update test set c1='baz' where id=2;
statement ok
commit;
query II
SELECT * FROM test ORDER BY id
----
2 baz
restart
query II
SELECT * FROM test ORDER BY id
----
2 baz

19
external/duckdb/test/sql/update/update_error_suggestions.test vendored Normal file
View File

@@ -0,0 +1,19 @@
# name: test/sql/update/update_error_suggestions.test
# description: Test suggestions on UPDATE statement
# group: [update]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE tbl(mycol INTEGER)
statement error
UPDATE tbl SET myco=42
----
"mycol"
statement error
UPDATE tbl SET tbl.mycol=42
----
Parser Error: Qualified column names in UPDATE .. SET not supported

19
external/duckdb/test/sql/update/update_join_nulls.test vendored Normal file
View File

@@ -0,0 +1,19 @@
# name: test/sql/update/update_join_nulls.test
# description: Test update + join with NULl values
# group: [update]
statement ok
CREATE TABLE t(table_id BIGINT, val BOOLEAN);
statement ok
INSERT INTO t VALUES (1, NULL);
statement ok
WITH new_values(tid, new_val) AS (
VALUES (1, NULL)
)
UPDATE t
SET val=new_val
FROM new_values
WHERE table_id=tid
;

37
external/duckdb/test/sql/update/update_null_integers.test vendored Normal file
View File

@@ -0,0 +1,37 @@
# name: test/sql/update/update_null_integers.test
# description: Integer null update checkpoint
# group: [update]
load __TEST_DIR__/update_null_integers.db
statement ok
SET wal_autocheckpoint='1TB';
statement ok
CREATE TABLE t(i int, j int);
# Insert >= 1024 NULLs
statement ok
INSERT INTO t SELECT ii, NULL FROM range(1024) tbl(ii);
query III
select COUNT(j), MIN(j), MAX(j) from t;
----
0 NULL NULL
# checkpoint to trigger the issue
statement ok
CHECKPOINT;
query III
select COUNT(j), MIN(j), MAX(j) from t;
----
0 NULL NULL
statement ok
UPDATE t SET j = 1;
query III
select COUNT(j), MIN(j), MAX(j) from t;
----
1024 1 1