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

3042
external/duckdb/test/sql/function/generic/big_case.test_slow vendored Normal file
View File

File diff suppressed because it is too large Load Diff

28
external/duckdb/test/sql/function/generic/can_cast_implicitly.test vendored Normal file
View File

@@ -0,0 +1,28 @@
# name: test/sql/function/generic/can_cast_implicitly.test
# description: Test the can cast implicitly function
# group: [generic]
statement ok
CREATE TABLE tbl AS SELECT * FROM range(10) tbl(i)
# can cast bigint -> bigint implicitly
query I
SELECT can_cast_implicitly(i, NULL::BIGINT) FROM tbl LIMIT 1
----
true
query I
SELECT can_cast_implicitly(i, NULL::HUGEINT) FROM tbl LIMIT 1
----
true
# cannot cast bigint -> int implicitly
query I
SELECT can_cast_implicitly(i, NULL::INTEGER) FROM tbl LIMIT 1
----
false
query I
SELECT can_cast_implicitly(i, NULL::VARCHAR) FROM tbl LIMIT 1
----
false

17
external/duckdb/test/sql/function/generic/case_condition.test vendored Normal file
View File

@@ -0,0 +1,17 @@
# name: test/sql/function/generic/case_condition.test
# description: Test CASE in a conditional statement
# group: [generic]
statement ok
CREATE TABLE tbl AS SELECT * FROM range(10) tbl(i)
query I
SELECT * FROM tbl
WHERE
CASE WHEN i%2=0 THEN 1 ELSE 0 END
AND
CASE WHEN i<5 THEN 1 ELSE 0 END
----
0
2
4

20
external/duckdb/test/sql/function/generic/case_short_circuit.test vendored Normal file
View File

@@ -0,0 +1,20 @@
# name: test/sql/function/generic/case_short_circuit.test
# description: Test correct CASE statement short circuiting
# group: [generic]
statement ok
create table t (n text);
statement ok
insert into t values ('1'),('0'),('');
query II
select n, case
when n <> '' and cast(substr(n, 1, 1) as int) <= 0 then '0'
when n <> '' and cast(substr(n, 1, 1) as int) > 0 then '1'
else '2'end as x from t
ORDER BY n;
----
(empty) 2
0 0
1 1

34
external/duckdb/test/sql/function/generic/case_varchar.test vendored Normal file
View File

@@ -0,0 +1,34 @@
# name: test/sql/function/generic/case_varchar.test
# description: Test case statement with VARCHAR columns
# group: [generic]
statement ok
CREATE TABLE tbl AS SELECT i, 'thisisalongstring' || i::VARCHAR s FROM range(10) tbl(i)
query III
SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM tbl
----
0 thisisalongstring0 thisisalongstring0
1 thisisalongstring1 thisisalongstring1
2 thisisalongstring2 thisisalongstring2
3 thisisalongstring3 thisisalongstring3
4 thisisalongstring4 thisisalongstring4
5 thisisalongstring5 thisisalongstring5
6 thisisalongstring6 thisisalongstring6
7 thisisalongstring7 thisisalongstring7
8 thisisalongstring8 thisisalongstring8
9 thisisalongstring9 thisisalongstring9
query III
SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM (SELECT i, s||'_suffix' FROM tbl) tbl(i, s)
----
0 thisisalongstring0_suffix thisisalongstring0_suffix
1 thisisalongstring1_suffix thisisalongstring1_suffix
2 thisisalongstring2_suffix thisisalongstring2_suffix
3 thisisalongstring3_suffix thisisalongstring3_suffix
4 thisisalongstring4_suffix thisisalongstring4_suffix
5 thisisalongstring5_suffix thisisalongstring5_suffix
6 thisisalongstring6_suffix thisisalongstring6_suffix
7 thisisalongstring7_suffix thisisalongstring7_suffix
8 thisisalongstring8_suffix thisisalongstring8_suffix
9 thisisalongstring9_suffix thisisalongstring9_suffix

53
external/duckdb/test/sql/function/generic/cast_to_type.test vendored Normal file
View File

@@ -0,0 +1,53 @@
# name: test/sql/function/generic/cast_to_type.test
# description: Test cast_to_type function
# group: [generic]
query I
SELECT cast_to_type(' 42', NULL::INT)
----
42
statement error
SELECT cast_to_type('hello', NULL::INT)
----
Conversion Error
statement ok
CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN cast_to_type(nullif(trim(s::VARCHAR), ''), s) ELSE s END;
query III
SELECT try_trim_null(42) as trim_int, try_trim_null(' col ') as trim_varchar, try_trim_null('') as trim_empty;
----
42 col NULL
statement ok
create table tbl(i int, v varchar);
statement ok
insert into tbl values (42, ' hello '), (100, ' ');
query II
SELECT try_trim_null(COLUMNS(*)) FROM tbl
----
42 hello
100 NULL
# prepared statements
statement ok
PREPARE v1 AS SELECT cast_to_type(' 42', ?);
query I
EXECUTE v1(NULL::INT)
----
42
query I
EXECUTE v1(NULL::VARCHAR)
----
42
# cast to NULL
statement error
SELECT cast_to_type(42, NULL);
----
cannot be used to cast to NULL

37
external/duckdb/test/sql/function/generic/constant_or_null.test vendored Normal file
View File

@@ -0,0 +1,37 @@
# name: test/sql/function/generic/constant_or_null.test
# description: Test constant or null
# group: [generic]
statement ok
PRAGMA enable_verification
query II
SELECT constant_or_null(1, NULL), constant_or_null(1, 10)
----
NULL 1
query I
SELECT constant_or_null(1, case when i%2=0 then null else i end) from range(5) tbl(i)
----
NULL
1
NULL
1
NULL
query I
SELECT constant_or_null(1, case when i%2=0 then null else i end, case when i%2=1 then null else i end) from range(5) tbl(i)
----
NULL
NULL
NULL
NULL
NULL
statement error
SELECT constant_or_null(1);
----
statement error
SELECT constant_or_null();
----

44
external/duckdb/test/sql/function/generic/error.test vendored Normal file
View File

@@ -0,0 +1,44 @@
# name: test/sql/function/generic/error.test
# description: Error test
# group: [generic]
statement error
SELECT error('test')
----
test
statement error
SELECT
CASE
WHEN value = 'foo' THEN 'Value is foo.'
ELSE ERROR(CONCAT('Found unexpected value: ', value))
END AS new_value
FROM (
SELECT 'foo' AS value UNION ALL
SELECT 'baz' AS value);
----
Found unexpected value: baz
query I
SELECT *
FROM (SELECT 4 AS x)
WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even number but is {}', x)));
----
4
statement error
SELECT *
FROM (SELECT 3 AS x)
WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even but is {}', x)));
----
x must be even but is 3
statement error
SELECT 42=error('hello world')
----
hello world
statement error
SELECT error('hello world') IS NULL
----
hello world

253
external/duckdb/test/sql/function/generic/hash_func.test vendored Normal file
View File

@@ -0,0 +1,253 @@
# name: test/sql/function/generic/hash_func.test
# description: Test HASH function
# group: [generic]
# Unsupported types
foreach datatype ANY HASH POINTER
statement error
SELECT HASH(NULL::${datatype});
----
endloop
# NULLS of all scalar types should produce the same value on all platforms
foreach datatype <alltypes> CHAR BLOB DATE TIME TIMETZ TIMESTAMP TIMESTAMPTZ DECIMAL(16,4) UUID
query I
SELECT HASH(NULL::${datatype});
----
13787848793156543929
endloop
#
# Nested types
#
# Structs
statement ok
CREATE TABLE structs AS
SELECT * FROM (VALUES
({'i': 5, 's': 'string'}),
({'i': -2, 's': NULL}),
({'i': NULL, 's': 'not null'}),
({'i': NULL, 's': NULL}),
(NULL)
) tbl(s);
query II
SELECT s, HASH(s) FROM structs
----
{'i': 5, 's': string} 312378390946197788
{'i': -2, 's': NULL} 13311620765177879553
{'i': NULL, 's': not null} 12187543307399756733
{'i': NULL, 's': NULL} 18212156630472451589
NULL 18212156630472451589
# Lists
statement ok
CREATE TABLE lists AS
SELECT * FROM (VALUES
([1], ['TGTA']),
([1, 2], ['CGGT']),
([], ['CCTC']),
([1, 2, 3], ['TCTA']),
([1, 2, 3, 4, 5], ['AGGG']),
(NULL, NULL)
) tbl(li, lg);
query II
SELECT li, HASH(li) FROM lists
----
[1] 4717996019076358352
[1, 2] 6530802887144669425
[] 13787848793156543929
[1, 2, 3] 12722334483198565868
[1, 2, 3, 4, 5] 6649915151332802727
NULL 13787848793156543929
# These should all be different
query II
SELECT lg, HASH(lg) FROM lists
----
[TGTA] 2473061308111828075
[CGGT] 17252230290449032892
[CCTC] 12469451733100292545
[TCTA] 16441147910138644840
[AGGG] 6734708784738468094
NULL 13787848793156543929
# Maps
statement ok
CREATE TABLE maps AS
SELECT * FROM (VALUES
(MAP([1], ['TGTA'])),
(MAP([1, 2], ['CGGT', 'CCTC'])),
(MAP([], [])),
(MAP([1, 2, 3], ['TCTA', NULL, 'CGGT'])),
(MAP([1, 2, 3, 4, 5], ['TGTA', 'CGGT', 'CCTC', 'TCTA', 'AGGG'])),
(NULL)
) tbl(m);
query II
SELECT m, HASH(m) FROM maps
----
{1=TGTA} 7235425910004250312
{1=CGGT, 2=CCTC} 1011047862598495049
{} 13787848793156543929
{1=TCTA, 2=NULL, 3=CGGT} 6001596667924474868
{1=TGTA, 2=CGGT, 3=CCTC, 4=TCTA, 5=AGGG} 16287978232011168685
NULL 13787848793156543929
statement ok
CREATE TABLE map_as_list AS
SELECT * FROM (VALUES
([{'key':1, 'value':'TGTA'}]),
([{'key':1, 'value':'CGGT'}, {'key':2, 'value':'CCTC'}]),
([]),
([{'key':1, 'value':'TCTA'}, {'key':2, 'value':NULL}, {'key':3, 'value':'CGGT'}]),
([{'key':1, 'value':'TGTA'}, {'key':2, 'value':'CGGT'}, {'key':3, 'value':'CCTC'}, {'key':4, 'value':'TCTA'}, {'key':5, 'value':'AGGG'}]),
(NULL)
) tbl(m);
# Because the map has physical type LIST, it creates an identical hash when the same values are stored as list of key/val structs
query I nosort map_hashes
SELECT HASH(m) FROM maps
query I nosort map_hashes
SELECT HASH(m) FROM map_as_list
# Enums
statement ok
CREATE TYPE resistor AS ENUM (
'black',
'brown',
'red',
'orange',
'yellow',
'green',
'blue',
'violet',
'grey',
'white'
);
statement ok
CREATE TABLE enums (r resistor);
statement ok
INSERT INTO enums VALUES
('black'),
('brown'),
('red'),
('orange'),
('yellow'),
('green'),
('blue'),
('violet'),
('grey'),
('white'),
(NULL)
;
query II
SELECT r, HASH(r) FROM enums;
----
black 0
brown 4717996019076358352
red 2060787363917578834
orange 8131803788478518982
yellow 8535942711051191036
green 4244145009296420692
blue 8888402906861678137
violet 8736873150706563146
grey 14111048738911615569
white 17319221087726947361
NULL 13787848793156543929
#
# Variadic arguments
#
# Zero arguments are not allowed
statement error
SELECT HASH();
----
statement error
SELECT r, HASH() FROM enums;
----
# Multiple arguments of any kind are accepted
query II
SELECT r, HASH(r, 'capacitor') FROM enums;
----
black 16797622758688705282
brown 12620868779234625953
red 17584344400128560708
orange 268160620305560594
yellow 895888387990267895
green 16089427619650030004
blue 10156864916169405730
violet 3549084991787980581
grey 17281098274178594641
white 1655957553588749778
NULL 12320705626460735678
query II
SELECT r, HASH('2022-02-12'::DATE, r) FROM enums;
----
black 4250466044961212059
brown 8900520483163022923
red 2766849995292148937
orange 5342755900462846045
yellow 5515065604690625639
green 7471453529827791
blue 4730260654388144290
violet 4882794310426623697
grey 17953657405078846666
white 14602512259699608250
NULL 9630093706189153058
query II
SELECT r, HASH(r, r) FROM enums;
----
black 0
brown 523193599206204019
red 111573794787247892
orange 11131893570948557270
yellow 10594212293773127177
green 914862583577390562
blue 2211471294594404377
violet 11628961430775669869
grey 14203064203985765890
white 1133846801649713905
NULL 18212156630472451589
#
# Bugs
#
# Issue #2498: Identical nested lists should have the same hash
statement ok
CREATE TABLE issue2498 AS SELECT * FROM (VALUES
(24, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}),
(34, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]})
) tbl(v, k);
query II
SELECT k, HASH(k) FROM issue2498
----
{'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]} 14225696893928945203
{'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]} 14225696893928945203
# CombineHashScalar used to have an issue that made combining a hash with itself yield hashes that all have
# a similar number of trailing zero's, so approx_count_distinct was off by a lot (and we had more collisions in HTs)
query I
select approx_count_distinct((range, range)) > 800_000 from range(1_000_000)
----
1

14
external/duckdb/test/sql/function/generic/least_greatest_enum.test vendored Normal file
View File

@@ -0,0 +1,14 @@
# name: test/sql/function/generic/least_greatest_enum.test
# description: Test LEAST/GREATEST with enum values
# group: [generic]
statement ok
PRAGMA enable_verification
statement ok
CREATE TYPE t AS ENUM ('z','y','x');
query II
SELECT greatest('x'::t, 'z'::t), 'x'::t > 'z'::t;
----
x 1

20
external/duckdb/test/sql/function/generic/least_greatest_types.test vendored Normal file
View File

@@ -0,0 +1,20 @@
# name: test/sql/function/generic/least_greatest_types.test
# description: Test LEAST/GREATEST with all types
# group: [generic]
statement ok
CREATE TABLE all_types AS FROM test_all_types()
foreach col <all_types_columns>
query I
SELECT LEAST((SELECT MAX("${col}") FROM all_types), (SELECT MIN("${col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MIN("${col}") FROM all_types)
----
true
query I
SELECT GREATEST((SELECT MAX("${col}") FROM all_types), (SELECT MIN("${col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MAX("${col}") FROM all_types)
----
true
endloop

81
external/duckdb/test/sql/function/generic/replace_type.test vendored Normal file
View File

@@ -0,0 +1,81 @@
# name: test/sql/function/generic/replace_type.test
# description: Test replace_type function
# group: [generic]
statement ok
PRAGMA enable_verification
# start off with mirrorring all cast_to_type tests as these functions are so similar
query I
SELECT replace_type(' 42', NULL::VARCHAR, NULL::INT)
----
42
statement error
SELECT replace_type('hello', NULL::VARCHAR, NULL::INT)
----
Conversion Error
statement ok
CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN replace_type(nullif(trim(s::VARCHAR), ''), NULL::VARCHAR, s) ELSE s END;
query III
SELECT try_trim_null(42) as trim_int, try_trim_null(' col ') as trim_varchar, try_trim_null('') as trim_empty;
----
42 col NULL
statement ok
create table tbl(i int, v varchar);
statement ok
insert into tbl values (42, ' hello '), (100, ' ');
query II
SELECT try_trim_null(COLUMNS(*)) FROM tbl
----
42 hello
100 NULL
# prepared statements
statement ok
PREPARE v1 AS SELECT replace_type(' 42', NULL::VARCHAR, ?);
query I
EXECUTE v1(NULL::INT)
----
42
query I
EXECUTE v1(NULL::VARCHAR)
----
42
# cast to NULL
statement error
SELECT replace_type(42, NULL::INTEGER, NULL);
----
cannot be used to replace type with NULL
# works within struct
query I
select replace_type({duck: 3.141592653589793::DOUBLE, goose: 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2))
----
{'duck': 3.14, 'goose': 2.72}
# map
query I
select replace_type(map {'duck': 3.141592653589793::DOUBLE, 'goose': 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2))
----
{duck=3.14, goose=2.72}
# list
query I
select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[], NULL::DOUBLE, NULL::DECIMAL(15,2))
----
[3.14, 2.72]
# array
query I
select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[2], NULL::DOUBLE, NULL::DECIMAL(15,2))
----
[3.14, 2.72]

11
external/duckdb/test/sql/function/generic/table_func_varargs.test vendored Normal file
View File

@@ -0,0 +1,11 @@
# name: test/sql/function/generic/table_func_varargs.test
# description: VarArgs with a Table Function
# group: [generic]
query III
SELECT * FROM repeat_row(1, 2, 'foo', num_rows=3)
----
1 2 foo
1 2 foo
1 2 foo

20
external/duckdb/test/sql/function/generic/test_approx_database_count.test vendored Normal file
View File

@@ -0,0 +1,20 @@
# name: test/sql/function/generic/test_approx_database_count.test
# description: Test the approx_database_count table function.
# group: [generic]
statement ok
PRAGMA enable_verification
statement ok
ATTACH '__TEST_DIR__/board1.db' AS b1;
statement ok
ATTACH '__TEST_DIR__/board2.db' AS b2;
statement ok
ATTACH '__TEST_DIR__/board3.db' AS b3;
query I
SELECT approx_count >= 3 FROM duckdb_approx_database_count();
----
True

251
external/duckdb/test/sql/function/generic/test_between.test vendored Normal file
View File

@@ -0,0 +1,251 @@
# name: test/sql/function/generic/test_between.test
# description: Test between statement
# group: [generic]
statement ok
SET default_null_order='nulls_first';
# test constant BETWEEN statement
# simple between
query T
SELECT 10 BETWEEN 10 AND 20
----
1
query T
SELECT 9 BETWEEN 10 AND 20
----
0
# now with NULL values
query T
SELECT 10 BETWEEN NULL AND 20
----
NULL
query T
SELECT 30 BETWEEN NULL AND 20
----
0
query T
SELECT 10 BETWEEN 10 AND NULL
----
NULL
query T
SELECT 9 BETWEEN 10 AND NULL
----
0
query T
SELECT NULL BETWEEN 10 AND 20
----
NULL
query T
SELECT NULL BETWEEN NULL AND 20
----
NULL
query T
SELECT NULL BETWEEN 10 AND NULL
----
NULL
query T
SELECT NULL BETWEEN NULL AND NULL
----
NULL
# between with table
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL)
query T
SELECT i BETWEEN 1 AND 2 FROM integers ORDER BY i
----
NULL
1
1
0
query T
SELECT i BETWEEN NULL AND 2 FROM integers ORDER BY i
----
NULL
NULL
NULL
0
query T
SELECT i BETWEEN 2 AND NULL FROM integers ORDER BY i
----
NULL
0
NULL
NULL
# between in WHERE clause
query I
SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND 20
----
4
query I
SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND 20
----
0
query I
SELECT COUNT(*) FROM integers WHERE 10 BETWEEN NULL AND 20
----
0
query I
SELECT COUNT(*) FROM integers WHERE 30 BETWEEN NULL AND 20
----
0
query I
SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND 20
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND 20
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN 1 AND 2
----
2
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND 2
----
0
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN 2 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN -1 AND +1
----
0
query I
SELECT COUNT(*) FROM integers WHERE 0 BETWEEN -1 AND +1
----
4
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND i+1
----
3
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND 10
----
3
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN 0 AND i+1
----
3
query I
SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND i+1
----
0
query I
SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND i+1
----
2
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND i+1
----
0
query I
SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND NULL
----
0
query I
SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND 100
----
2
query I
SELECT COUNT(*) FROM integers WHERE 1 BETWEEN 0 AND i-1
----
2
query I
SELECT * FROM integers WHERE i >= 1 AND i < 2
----
1
query I
SELECT * FROM integers WHERE i > 1 AND i <= 2
----
2
query I
SELECT * FROM range(4) tbl(i) WHERE i >= 1 AND i < 2
----
1
query I
SELECT * FROM range(4) tbl(i) WHERE i > 1 AND i <= 2
----
2
# Issue #3588 - only one constant bounds
statement ok
CREATE TABLE issue3588(c0 INT);
statement ok
SELECT *
FROM issue3588
WHERE (SELECT 0) BETWEEN 0 AND issue3588.c0;

53
external/duckdb/test/sql/function/generic/test_between_sideeffects.test vendored Normal file
View File

@@ -0,0 +1,53 @@
# name: test/sql/function/generic/test_between_sideeffects.test
# description: Test between statement with expressions that have side effects
# group: [generic]
require icu
require no_extension_autoloading "FIXME: ICU is not autoloaded on '-(TIMESTAMP WITH TIME ZONE, INTERVAL)"
# prepared statement with BETWEEN
statement ok
PREPARE v1 AS SELECT ? BETWEEN 1 AND 2
query I
EXECUTE v1(1)
----
true
query I
EXECUTE v1(3)
----
false
statement error
EXECUTE v1(1, 2)
----
statement ok
PREPARE v2 AS SELECT 1 WHERE ? BETWEEN now() - INTERVAL '1 minute' AND now() + INTERVAL '1 minute';
query I
EXECUTE v2(now())
----
1
query I
EXECUTE v2(now() - INTERVAL '10 minute')
----
loop i 0 10
# this should always be false
query I
SELECT (RANDOM() * 10)::INT BETWEEN 6 AND 5
----
false
# this should always be true
query I
SELECT (RANDOM() * 10)::INT NOT BETWEEN 6 AND 5
----
true
endloop

93
external/duckdb/test/sql/function/generic/test_boolean_test.test vendored Normal file
View File

@@ -0,0 +1,93 @@
# name: test/sql/function/generic/test_boolean_test.test
# description: Test NULL IF statement
# group: [generic]
query I
select true is true
----
true
query I
select false is true
----
false
query I
select null is true
----
false
query I
select 42 is true
----
true
query I
select 0 is true
----
false
query I
select true is not true
----
false
query I
select false is not true
----
true
query I
select null is not true
----
true
query I
select 42 is not true
----
false
query I
select 0 is not true
----
true
query I
select null is null
----
true
query I
select 42 is null
----
false
query I
select null is not null
----
false
query I
select 42 is not null
----
true
query I
select null is unknown
----
true
query I
select 42 is unknown
----
false
query I
select null is not unknown
----
false
query I
select 42 is not unknown
----
true

103
external/duckdb/test/sql/function/generic/test_case.test_slow vendored Normal file
View File

@@ -0,0 +1,103 @@
# name: test/sql/function/generic/test_case.test_slow
# description: Test case statement
# group: [generic]
statement ok
PRAGMA enable_verification
foreach type <numeric> DECIMAL(4,0) DECIMAL(9,0) DECIMAL(18,0) DECIMAL(38,0)
statement ok
DROP TABLE IF EXISTS test
statement ok
CREATE TABLE test (a ${type}, b ${type});
statement ok
INSERT INTO test VALUES (11, 22), (13, 22), (12, 21)
query I
SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test
----
22
NULL
NULL
# constant case statements
# all constant
query I
SELECT CASE WHEN 1=1 THEN 1 ELSE NULL END FROM test ORDER BY b
----
1
1
1
# check + res_if_false constant
query I
SELECT CASE WHEN 1=1 THEN b ELSE NULL END FROM test ORDER BY b
----
21
22
22
# check + res_if_true constant
query I
SELECT CASE WHEN 3>2 THEN NULL ELSE b+1 END FROM test ORDER BY b
----
NULL
NULL
NULL
# check constant
query I
SELECT CASE WHEN 1=0 THEN b ELSE b+1 END FROM test ORDER BY b
----
22
23
23
# res_if_true and res_if_false constant
query I
SELECT CASE WHEN b=22 THEN NULL ELSE 1 END FROM test ORDER BY b
----
1
NULL
NULL
# res_if_false constant
query I
SELECT CASE WHEN b=22 THEN b+1 ELSE 1 END FROM test ORDER BY b
----
1
23
23
# res_if_true constant
query I
SELECT CASE WHEN b=22 THEN NULL ELSE b+1 END FROM test ORDER BY b
----
22
NULL
NULL
# fail case on types that can't be cast to boolean
statement error
SELECT CASE WHEN 'hello' THEN b ELSE a END FROM test
----
# but only when cast cannot be performed
query I
SELECT CASE WHEN 'true' THEN NULL ELSE b+1 END FROM test ORDER BY b
----
NULL
NULL
NULL
query I
SELECT CASE WHEN 'false' THEN NULL ELSE b+1 END FROM test ORDER BY b
----
22
23
23
endloop

17
external/duckdb/test/sql/function/generic/test_connection_count.test vendored Normal file
View File

@@ -0,0 +1,17 @@
# name: test/sql/function/generic/test_connection_count.test
# description: Test the connection_count table function.
# group: [generic]
statement ok
PRAGMA enable_verification
statement ok con1
BEGIN
statement ok con2
BEGIN
query I
SELECT count FROM duckdb_connection_count();
----
3

29
external/duckdb/test/sql/function/generic/test_if.test vendored Normal file
View File

@@ -0,0 +1,29 @@
# name: test/sql/function/generic/test_if.test
# description: IF test
# group: [generic]
query III
SELECT IF(true, 1, 10), IF(false, 1, 10), IF(NULL, 1, 10)
----
1 10 10
query III
SELECT IF(true, 20, 2000), IF(false, 20, 2000), IF(NULL, 20, 2000)
----
20 2000 2000
query RRR
SELECT IF(true, 20.5, 2000), IF(false, 20, 2000.5), IF(NULL, 20, 2000.5)
----
20.500000 2000.500000 2000.500000
query TTT
SELECT IF(true, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(false, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(NULL, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp)
----
2020-05-05 00:00:00 1996-11-05 10:11:56 1996-11-05 10:11:56
query TTT
SELECT IF(true, 'true', 'false'), IF(false, 'true', 'false'), IF(NULL, 'true', 'false')
----
true false false

24
external/duckdb/test/sql/function/generic/test_if_null.test vendored Normal file
View File

@@ -0,0 +1,24 @@
# name: test/sql/function/generic/test_if_null.test
# description: IFNULL test
# group: [generic]
query III
SELECT IFNULL(NULL, NULL), IFNULL(NULL, 10), IFNULL(1, 10)
----
NULL 10 1
query IR
SELECT IFNULL(NULL, 2000), IFNULL(20.5, 2000)
----
2000 20.500000
query TT
SELECT IFNULL(NULL, '1996-11-05 10:11:56'::timestamp), IFNULL('2020-05-05'::date, '1996-11-05 10:11:56'::timestamp)
----
1996-11-05 10:11:56 2020-05-05 00:00:00
query TT
SELECT IFNULL(NULL, 'not NULL'), IFNULL('NULL', 'not NULL')
----
not NULL NULL

238
external/duckdb/test/sql/function/generic/test_in.test vendored Normal file
View File

@@ -0,0 +1,238 @@
# name: test/sql/function/generic/test_in.test
# description: Test IN statement
# group: [generic]
statement ok
SET default_null_order='nulls_first';
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (2), (3), (NULL);
query I
SELECT * FROM integers WHERE i IN (1, 2) ORDER BY i
----
1
2
query I
SELECT * FROM integers WHERE i IN (1, 2, 3, 4, 5, 6, 7, 8) ORDER BY i
----
1
2
3
query IT
SELECT i, i IN (1, 2, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 1
query IT
SELECT i, i NOT IN (1, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i
----
NULL NULL
1 0
2 1
3 0
query II
SELECT i, i IN (1, 2, NULL, 4, 5, 6, 7, 8) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 NULL
query IT
SELECT i, i IN (i + 1) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 0
query IT
SELECT i, i IN (i + 1, 42, i) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 1
query IT
SELECT i, 1 IN (i - 1, i, i + 1) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 0
query IT
SELECT i, 1 NOT IN (i - 1, i, i + 1) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 1
query IT
SELECT i, i IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
----
NULL NULL
1 1
2 1
3 1
query IT
SELECT i, i NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
----
NULL NULL
1 0
2 0
3 0
query IT
SELECT i, 1 IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
----
NULL 1
1 1
2 1
3 1
query IT
SELECT i, 1 NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
----
NULL 0
1 0
2 0
3 0
query IT
SELECT i, i IN ((SELECT MAX(i) FROM integers), (SELECT MIN(i) FROM integers)) FROM integers ORDER BY i
----
NULL NULL
1 1
2 0
3 1
query III
SELECT i, (SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i) FROM integers i1 ORDER BY i
----
NULL NULL NULL
1 3 1
2 3 1
3 2 1
query IT
SELECT i, i IN ((SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i)) FROM integers i1 ORDER BY i
----
NULL NULL
1 1
2 0
3 0
query I
SELECT 1 IN [1, 2, 3];
----
true
query I
SELECT 1 IN [2, 2, 3];
----
false
statement ok
PREPARE v1 AS SELECT 1 IN ?
query I
EXECUTE v1([]);
----
false
query I
SELECT 1 IN [];
----
false
query I
EXECUTE v1([1, 2, 3]);
----
true
query I
EXECUTE v1([2, 2, 3]);
----
false
# Test <expr> IN <column_ref>
query I
with list_provider as (
select [1, 2] as lst
)
SELECT i FROM (
from integers, list_provider
) t(i, lst) WHERE i IN lst ORDER BY i
----
1
2
query I
with list_provider as (
select [1, 2, 3, 4, 5, 6, 7, 8] as lst
)
SELECT i FROM (
from integers, list_provider
) t(i, lst) WHERE i IN lst ORDER BY i
----
1
2
3
query II
with list_provider as (
select [1, 2, 3, 4, 5, 6, 7, 8] as lst
)
SELECT i, i IN lst FROM (
from integers, list_provider
) t(i, lst) order by i
----
NULL NULL
1 1
2 1
3 1
query II
with list_provider as (
select [1, 3, 4, 5, 6, 7, 8] as lst
)
SELECT i, i NOT IN lst FROM (
from integers, list_provider
) t(i, lst) order by i
----
NULL NULL
1 0
2 1
3 0
query II
with list_provider as (
select [1, 2, NULL, 4, 5, 6, 7, 8] as lst
)
SELECT i, i IN lst FROM (
from integers, list_provider
) t(i, lst) order by i
----
NULL NULL
1 1
2 1
3 0
# ^ Note the '0' on the last row
# This is different from regular IN behavior

54
external/duckdb/test/sql/function/generic/test_large_in.test_slow vendored Normal file
View File

File diff suppressed because one or more lines are too long

176
external/duckdb/test/sql/function/generic/test_least_greatest.test vendored Normal file
View File

@@ -0,0 +1,176 @@
# name: test/sql/function/generic/test_least_greatest.test
# description: Test LEAST/GREATEST
# group: [generic]
# scalar usage
query I
SELECT LEAST(1)
----
1
query I
SELECT LEAST('hello world')
----
hello world
query I
SELECT LEAST(1, 3)
----
1
query I
SELECT LEAST(1, 3, 0)
----
0
query I
SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30)
----
-100
query I
SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30, NULL)
----
-100
query I
SELECT LEAST(NULL, 3, 0, 2, 7, 8, 10, 11, -100, 30, 1)
----
-100
query I
SELECT GREATEST(NULL, 1.0::FLOAT)
----
1
# double
query R
SELECT LEAST(1.0, 10.0)
----
1.000000
# strings
query T
SELECT LEAST('hello', 'world')
----
hello
query T
SELECT LEAST('hello', 'world', 'blabla', 'tree')
----
blabla
query T
SELECT LEAST('hello', 'world', 'blabla', 'tree')
----
blabla
# dates
query T
SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01')
----
1991-01-01
query T
SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', NULL)
----
1991-01-01
query T
SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity')
----
-infinity
query T
SELECT GREATEST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity')
----
infinity
# timestamps
query T
SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45')
----
1991-01-01 01:23:45
query T
SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', NULL)
----
1991-01-01 01:23:45
query T
SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity')
----
-infinity
query T
SELECT GREATEST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity')
----
infinity
# test mix of types
statement error
SELECT LEAST(DATE '1992-01-01', 'hello', 123)
----
Cannot combine types
# tables
statement ok
CREATE TABLE t1(i INTEGER, j INTEGER);
statement ok
INSERT INTO t1 VALUES (1, NULL), (2, 1), (3, 7);
query II
SELECT LEAST(i, j), GREATEST(i, j) FROM t1 ORDER BY i;
----
1 1
1 2
3 7
query II
SELECT LEAST(i, i + 1, j), GREATEST(i, i - 1, j) FROM t1 ORDER BY i;
----
1 1
1 2
3 7
query II
SELECT LEAST(i, 800, i + 1, 1000, j), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i;
----
1 1
1 2
3 7
query II
SELECT LEAST(i, 800, i + 1, 1000, j, NULL), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i;
----
1 1
1 2
3 7
# selection vectors
query II
SELECT LEAST(i, j), GREATEST(i, j) FROM t1 WHERE j IS NOT NULL ORDER BY i;
----
1 2
3 7
# row ids
query II
SELECT LEAST(rowid + 10, i, j), GREATEST(i, rowid + 4, j) FROM t1 WHERE j IS NOT NULL ORDER BY i;
----
1 5
3 7
# generated strings
query T
SELECT LEAST(REPEAT(i::VARCHAR, 20), j::VARCHAR) FROM t1;
----
11111111111111111111
1
33333333333333333333
query I
SELECT greatest(CAST(52392441565678.308 AS DECIMAL(17,3)), CAST(52392441565678.308 AS DECIMAL(17,3)));
----
52392441565678.308

54
external/duckdb/test/sql/function/generic/test_null_if.test vendored Normal file
View File

@@ -0,0 +1,54 @@
# name: test/sql/function/generic/test_null_if.test
# description: Test NULL IF statement
# group: [generic]
# NULL IF
query T
SELECT NULLIF(NULLIF ('hello', 'world'), 'blabla');
----
hello
# NULL IF with subquery
statement ok
CREATE TABLE test (a STRING);
statement ok
INSERT INTO test VALUES ('hello'), ('world'), ('test')
statement ok
CREATE TABLE test2 (a STRING, b STRING);
statement ok
INSERT INTO test2 VALUES ('blabla', 'b'), ('blabla2', 'c'), ('blabla3', 'd')
query T
SELECT NULLIF(NULLIF ((SELECT a FROM test LIMIT 1 offset 1), a), b) FROM test2
----
world
world
world
statement ok
DROP TABLE test;
# NULL IF with strings
statement ok
CREATE TABLE test3 (a INTEGER, b INTEGER);
statement ok
INSERT INTO test3 VALUES (11, 22), (13, 22), (12, 21)
query T
SELECT NULLIF(CAST(a AS VARCHAR), '11') FROM test3;
----
NULL
13
12
query IT
SELECT a, CASE WHEN a>11 THEN CAST(a AS VARCHAR) ELSE CAST(b AS VARCHAR) END FROM test3 ORDER BY 1;
----
11 22
12 12
13 13

66
external/duckdb/test/sql/function/generic/test_set.test vendored Normal file
View File

@@ -0,0 +1,66 @@
# name: test/sql/function/generic/test_set.test
# description: Test SET function
# group: [generic]
# unrecognized configuration parameter
statement error
SELECT CURRENT_SETTING('a');
----
statement error
SELECT CURRENT_SETTING('memori_limit');
----
statement ok
SELECT CURRENT_SETTING('default_null_order');
statement ok
SET default_null_order = 'nulls_last';
# set from a function
statement ok
SET default_null_order = concat('nulls', '_', 'last');
query I
SELECT CURRENT_SETTING('default_null_order');
----
NULLS_LAST
query I
SELECT CURRENT_SETTING('DEFAULT_NULL_ORDER');
----
NULLS_LAST
query I
SELECT * FROM range(3) UNION ALL SELECT NULL ORDER BY 1
----
0
1
2
NULL
statement error
SELECT CURRENT_SETTING(i::VARCHAR) FROM range(1) tbl(i)
----
statement error
SELECT CURRENT_SETTING(NULL)
----
statement error
SELECT CURRENT_SETTING(CAST(NULL AS TEXT))
----
statement error
SELECT CURRENT_SETTING('')
----
statement error
SET default_null_order = colref || '_last';
----
cannot contain column names
statement error
SET default_null_order = (SELECT 'nulls_last')
----
cannot contain subqueries

85
external/duckdb/test/sql/function/generic/test_stats.test vendored Normal file
View File

@@ -0,0 +1,85 @@
# name: test/sql/function/generic/test_stats.test
# description: Test stats function
# group: [generic]
statement ok
select 1=1
# scalar stats
query I
SELECT STATS(5);
----
<REGEX>:.*5.*5.*
query I
SELECT STATS(7);
----
<REGEX>:.*7.*7.*
query I
SELECT STATS('hello');
----
<REGEX>:.*hello.*hello.*
query I
SELECT STATS('1234567ü');
----
<REGEX>:.*1234567.*1234567.*
# arithmetic
query I
SELECT STATS(5+2);
----
<REGEX>:.*7.*7.*
# non-scalar stats
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3);
# read stats
query I
SELECT STATS(i) FROM integers LIMIT 1;
----
<REGEX>:.*1.*3.*
# arithmetic
query I
SELECT STATS(i+2) FROM integers LIMIT 1;
----
<REGEX>:.*3.*5.*
query I
SELECT STATS(i-5) FROM integers LIMIT 1;
----
<REGEX>:.*-4.*-2.*
query I
SELECT STATS(i*2) FROM integers LIMIT 1;
----
<REGEX>:.*2.*6.*
query I
SELECT STATS(i*-1) FROM integers LIMIT 1;
----
<REGEX>:.*-3.*-1.*
# disabling statistics propagation means there will be no stats
statement ok
PRAGMA disable_optimizer
query I
SELECT STATS(i+1) FROM integers LIMIT 1;
----
No statistics
# we can enable the optimizer again
statement ok
PRAGMA enable_optimizer
query I
SELECT STATS(i*-1) FROM integers LIMIT 1;
----
<REGEX>:.*-3.*-1.*

33
external/duckdb/test/sql/function/generic/test_table_param.test vendored Normal file
View File

@@ -0,0 +1,33 @@
# name: test/sql/function/generic/test_table_param.test
# description: Test stats function
# group: [generic]
# scalar stats
statement ok
create table a (i double, j double);
statement ok
insert into a values (1, 10), (42, 420);
statement ok
EXPLAIN SELECT * FROM summary((SELECT * FROM a))
query III
SELECT * FROM summary((SELECT * FROM a))
----
[1.0, 10.0] 1.0 10.0
[42.0, 420.0] 42.0 420.0
statement ok
pragma threads=4
statement ok
pragma verify_parallelism
query III
SELECT * FROM summary((SELECT * FROM a))
----
[1.0, 10.0] 1.0 10.0
[42.0, 420.0] 42.0 420.0