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

32
external/duckdb/test/sql/order/hugeint_order_by_extremes.test vendored Normal file
View File

@@ -0,0 +1,32 @@
# name: test/sql/order/hugeint_order_by_extremes.test
# description: Issue #3471: Select fails when ordering on hugeint column
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a hugeint);
statement ok
INSERT INTO test values ((-170141183460469231731687303715884105728)::hugeint), (-1111::hugeint), (-1::hugeint), (0::hugeint), (1::hugeint), (1111::hugeint);
query I
SELECT * FROM test order by a;
----
-170141183460469231731687303715884105728
-1111
-1
0
1
1111
query I
SELECT * FROM test order by a DESC;
----
1111
1
0
-1
-1111
-170141183460469231731687303715884105728

23
external/duckdb/test/sql/order/issue_11936.test vendored Normal file
View File

@@ -0,0 +1,23 @@
# name: test/sql/order/issue_11936.test
# description: Test order nested list
# group: [order]
require notmusl
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test(col1 INT, col2 INT2[][][][][][]);
statement ok
INSERT INTO test VALUES(1000000000, null), (1000000001, [[[[[[]]]]]]), (null, [[[[[[]]]]]]), (null, [[[[[[]]]]]]), (1, [[[[[[]]]]]]);
query II
SELECT col1, col2 FROM test ORDER BY col1 NULLS LAST, col2;
----
1 [[[[[[]]]]]]
1000000000 NULL
1000000001 [[[[[[]]]]]]
NULL [[[[[[]]]]]]
NULL [[[[[[]]]]]]

29
external/duckdb/test/sql/order/limit_full_outer_join.test vendored Normal file
View File

@@ -0,0 +1,29 @@
# name: test/sql/order/limit_full_outer_join.test
# description: Test LIMIT with full outer joins
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER, j INTEGER)
statement ok
INSERT INTO integers VALUES (1, 1), (3, 3)
statement ok
CREATE TABLE integers2(k INTEGER, l INTEGER)
statement ok
INSERT INTO integers2 VALUES (1, 10), (2, 20)
query IIII
SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k ORDER BY ALL LIMIT 2
----
1 1 1 10
3 3 NULL NULL
query I
SELECT COUNT(*) FROM (SELECT i, j, k, l FROM integers FULL OUTER JOIN integers2 ON integers.i=integers2.k LIMIT 2) tbl
----
2

75
external/duckdb/test/sql/order/limit_parameter.test vendored Normal file
View File

@@ -0,0 +1,75 @@
# name: test/sql/order/limit_parameter.test
# description: Test LIMIT with a parameter
# group: [order]
statement ok
PRAGMA enable_verification
query I
SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT 5
----
10000
9999
9998
9997
9996
statement ok
CREATE TABLE integers AS SELECT 5 k
query I
SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT k FROM integers)
----
10000
9999
9998
9997
9996
statement ok
CREATE TABLE strings AS SELECT '5'::VARCHAR k
query I
SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT k FROM strings)
----
10000
9999
9998
9997
9996
statement ok
PREPARE v1 AS SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT ?::VARCHAR
query I
EXECUTE v1(5)
----
10000
9999
9998
9997
9996
statement ok
PREPARE v1 AS SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT ?::VARCHAR %
query I
EXECUTE v1('0.05')
----
10000
9999
9998
9997
9996
statement ok
CREATE TABLE doubles AS SELECT 0.05 d
query I
SELECT * FROM generate_series(0, 10000, 1) tbl(i) ORDER BY i DESC LIMIT (SELECT d FROM doubles) %
----
10000
9999
9998
9997
9996

22
external/duckdb/test/sql/order/limit_union.test vendored Normal file
View File

@@ -0,0 +1,22 @@
# name: test/sql/order/limit_union.test
# description: Test LIMIT with full outer joins
# group: [order]
statement ok
PRAGMA enable_verification
query I
SELECT * FROM range(5) UNION ALL SELECT * FROM range(5) LIMIT 7
----
0
1
2
3
4
0
1
query I
SELECT COUNT(*) FROM (SELECT * FROM range(5) UNION ALL SELECT * FROM range(5) LIMIT 7) tbl
----
7

34
external/duckdb/test/sql/order/negative_offset.test vendored Normal file
View File

@@ -0,0 +1,34 @@
# name: test/sql/order/negative_offset.test
# description: Test OFFSET keyword
# group: [order]
statement ok
PRAGMA enable_verification
statement error
SELECT * FROM generate_series(0,10,1) LIMIT 3 OFFSET -1;
----
<REGEX>:.*Binder Error.*cannot be negative.*
statement error
SELECT * FROM generate_series(0,10,1) LIMIT -3;
----
<REGEX>:.*Binder Error.*cannot be negative.*
statement error
SELECT * FROM generate_series(0,10,1) LIMIT -1%
----
<REGEX>:.*Out of Range Error.*out of range.*
statement ok
CREATE TABLE integers AS SELECT -1 k;
statement error
SELECT * FROM generate_series(0,10,1) LIMIT (SELECT k FROM integers);
----
<REGEX>:.*Invalid Input Error.*out of range.*
statement error
SELECT * FROM generate_series(0,10,1) LIMIT 1 OFFSET (SELECT k FROM integers);
----
<REGEX>:.*Invalid Input Error.*out of range.*

61
external/duckdb/test/sql/order/order_by_all.test vendored Normal file
View File

@@ -0,0 +1,61 @@
# name: test/sql/order/order_by_all.test
# description: Test ORDER BY ALL
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(g integer, i integer);
statement ok
INSERT INTO integers values (0, 1), (0, 2), (1, 3), (1, NULL);
# standard usage of ORDER BY ALL
query II
SELECT * FROM integers ORDER BY ALL
----
0 1
0 2
1 NULL
1 3
query II
SELECT * FROM integers ORDER BY * DESC
----
1 NULL
1 3
0 2
0 1
query II
SELECT * FROM integers ORDER BY * DESC NULLS LAST
----
1 3
1 NULL
0 2
0 1
# ORDER BY ALL with set operations
query II
SELECT * FROM integers UNION ALL SELECT * FROM integers ORDER BY ALL
----
0 1
0 1
0 2
0 2
1 NULL
1 NULL
1 3
1 3
query II
SELECT * FROM integers UNION SELECT * FROM integers ORDER BY ALL
----
0 1
0 2
1 NULL
1 3

25
external/duckdb/test/sql/order/order_by_internal_5293.test vendored Normal file
View File

@@ -0,0 +1,25 @@
# name: test/sql/order/order_by_internal_5293.test
# description: Test ORDER BY issue 5293 - New sort code merge logic fails for fixed width strings
# group: [order]
statement ok
pragma enable_verification;
statement ok
create table t1 as from VALUES
('A', 1),
('B', 3),
('C', 12),
('A', 5),
('B', 8),
('C', 9),
('A', 10),
('B', 20),
('C', 3)
t(a, b);
statement ok
PRAGMA disabled_optimizers='compressed_materialization';
statement ok
from t1 order by a

8
external/duckdb/test/sql/order/order_overflow.test vendored Normal file
View File

@@ -0,0 +1,8 @@
# name: test/sql/order/order_overflow.test
# description: Test overflow in ORDER BY
# group: [order]
statement error
SELECT 42 ORDER BY -9223372036854775808;
----
ORDER term out of range

76
external/duckdb/test/sql/order/order_parallel_complex.test_slow vendored Normal file
View File

@@ -0,0 +1,76 @@
# name: test/sql/order/order_parallel_complex.test_slow
# description: Test ORDER BY keyword with multiple threads (internal and external sorting)
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA verify_parallelism
# we run this with an uneven amount of threads to force the merge sort to have an odd amount of blocks to merge
statement ok
PRAGMA threads=3
statement ok
SET default_null_order='nulls_first';
# internal/external, different memory limits
foreach pragma true false
foreach mem 50 500
statement ok
PRAGMA debug_force_external=${pragma}
statement ok
PRAGMA memory_limit='${mem}MB'
statement ok
create table test as (select range i from range(100000));
# complex sort orders, combining var and fixed-size sorting columns
statement ok
insert into test values (NULL);
query T
select * from test order by cast(i as varchar) nulls first
----
100001 values hashing to f57dcbb7ed54aa1427f8f0aa71095c66
query T
select * from test order by i % 10, cast(i as varchar)
----
100001 values hashing to 1d264864d6c6bd38863c743d4ad52940
query T
select * from test order by cast(i % 10 as varchar), i
----
100001 values hashing to 6860685f6aa75f5a1ca3c47174b3da65
query T
select * from test order by cast(i % 100 as varchar), i % 10, cast(i as varchar) nulls first
----
100001 values hashing to 483502102d833d8ea7ba404f341598c2
query T
select * from test order by cast(i % 1000 as varchar), i % 100, cast(i % 10 as varchar), i
----
100001 values hashing to 88c6de776107d78460a9f8c9e3644cd8
query T
select * from test order by i % 100, cast(i % 10 as varchar), cast(i as varchar)
----
100001 values hashing to 4074a204486baadfa789fd6a2d8ceb2e
query T
select * from test order by cast(i % 1000 as varchar), i % 100, i % 10, cast(i as varchar)
----
100001 values hashing to f7d8768d3c532caf7db4414cb3b2eea9
statement ok
drop table test
endloop
endloop

62
external/duckdb/test/sql/order/order_parallel_ctas.test_slow vendored Normal file
View File

@@ -0,0 +1,62 @@
# name: test/sql/order/order_parallel_ctas.test_slow
# description: Test parallel CREATE TABLE AS with ORDER BY
# group: [order]
# load the DB from disk
load __TEST_DIR__/order_parallel_ctas.db
statement ok
PRAGMA disable_checkpoint_on_shutdown
statement ok
PRAGMA wal_autocheckpoint='1TB';
statement ok
pragma verify_parallelism
statement ok
create table integers as select range i from range(100000) order by random()
loop i 0 20
statement ok
create table sorted_integers as select i from integers order by i
restart
# empty result if sorted
query T
select * FROM sorted_integers QUALIFY NOT (i>lag(i) over () OR lag(i) OVER () IS NULL)
----
statement ok
drop table sorted_integers
endloop
# now we do the same but with a UNION ALL
loop i 0 20
statement ok
create table sorted_integers as
with p1 as (
select i from integers order by i
), p2 as (
select i + 100000 from integers order by i
)
select * from p1 union all select * from p2
restart
# empty result if sorted
query T
select * FROM sorted_integers QUALIFY NOT (i>lag(i) over () OR lag(i) OVER () IS NULL)
----
statement ok
drop table sorted_integers
endloop

61
external/duckdb/test/sql/order/order_parallel_fixed.test_slow vendored Normal file
View File

@@ -0,0 +1,61 @@
# name: test/sql/order/order_parallel_fixed.test_slow
# description: Test ORDER BY keyword with multiple threads (internal and external sorting)
# group: [order]
statement ok
PRAGMA verify_parallelism
# we run this with an uneven amount of threads to force the merge sort to have an odd amount of blocks to merge
statement ok
PRAGMA threads=3
# do one asc test to hit some coverage, the rest is desc
statement ok
create table test as (select range i from range(100000) order by i desc);
# all fixed-size
query T
select * from test order by i asc;
----
100000 values hashing to 1933b84f18ddb7545c63962be5d10bb5
statement ok
drop table test
# internal/external, different memory limits
foreach pragma true false
foreach mem 50 500
statement ok
PRAGMA debug_force_external=${pragma}
statement ok
PRAGMA memory_limit='${mem}MB'
statement ok
create table test as (select range i from range(100000));
# all fixed-size
query T
select * from test order by i desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
# fixed size sorting, variable payload
query T
select cast(i as varchar) from test order by i desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
query T
select cast(i + 1000000000000 as varchar) from test order by i desc;
----
100000 values hashing to fd8914b27c93792cac93f3f8ee479a89
statement ok
drop table test
endloop
endloop

74
external/duckdb/test/sql/order/order_parallel_many_ties.test_slow vendored Normal file
View File

@@ -0,0 +1,74 @@
# name: test/sql/order/order_parallel_many_ties.test_slow
# description: Test ORDER BY keyword with multiple threads (internal and external sorting)
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA verify_parallelism
# we run this with an uneven amount of threads to force the merge sort to have an odd amount of blocks to merge
statement ok
PRAGMA threads=3
# internal/external, different memory limits
foreach pragma true false
foreach mem 50 500
statement ok
PRAGMA debug_force_external=${pragma}
statement ok
PRAGMA memory_limit='${mem}MB'
statement ok
create table test as (select range i from range(100000));
# complex sort orders, combining var and fixed-size sorting columns
statement ok
insert into test values (NULL);
# same complex sort orders but with many ties due to the large prefix
query T
select * from test order by cast(i + 1000000000000 as varchar) nulls first
----
100001 values hashing to 9642fae1704358551de522343cfbc99e
query T
select * from test order by i % 10, cast(i + 1000000000000 as varchar)
----
100001 values hashing to 6860685f6aa75f5a1ca3c47174b3da65
query T
select * from test order by cast(i % 10 + 1000000000000 as varchar), i
----
100001 values hashing to 6860685f6aa75f5a1ca3c47174b3da65
query T
select * from test order by cast(i % 100 + 1000000000000 as varchar), i % 10, cast(i + 1000000000000 as varchar) nulls first
----
100001 values hashing to fae9b116ca4c8e280da063f78b28e78f
query T
select * from test order by cast(i % 1000 + 1000000000000 as varchar), i % 100, cast(i % 10 + 1000000000000 as varchar), i
----
100001 values hashing to c694f8aa434f0617970c6f3540b20863
query T
select * from test order by i % 100, cast(i % 10 + 1000000000000 as varchar), cast(i + 1000000000000 as varchar)
----
100001 values hashing to fae9b116ca4c8e280da063f78b28e78f
query T
select * from test order by cast(i % 1000 + 1000000000000 as varchar), i % 100, i % 10, cast(i + 1000000000000 as varchar)
----
100001 values hashing to c694f8aa434f0617970c6f3540b20863
statement ok
drop table test
endloop
endloop

63
external/duckdb/test/sql/order/order_parallel_varsize.test_slow vendored Normal file
View File

@@ -0,0 +1,63 @@
# name: test/sql/order/order_parallel_varsize.test_slow
# description: Test ORDER BY keyword with multiple threads (internal and external sorting)
# group: [order]
statement ok
PRAGMA verify_parallelism
# we run this with an uneven amount of threads to force the merge sort to have an odd amount of blocks to merge
statement ok
PRAGMA threads=3
# internal/external, different memory limits
foreach pragma true false
foreach mem 50 500
statement ok
PRAGMA debug_force_external=${pragma}
statement ok
PRAGMA memory_limit='${mem}MB'
statement ok
create table test as (select range i from range(100000));
# variable size sorting
query T
select i from test order by cast(i as varchar) desc;
----
100000 values hashing to 14d85a71bc549aeb80f7e77766a9fc93
query T
select i from test order by list_value(i) desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
query T
select i from test order by list_value(0, i) desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
query T
select i from test order by struct_pack(i) desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
query T
select i from test order by struct_pack(a:=0, i) desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
# the same, but with large prefix string so ties need to be broken
query T
select i from test order by cast(i + 1000000000000 as varchar) desc;
----
100000 values hashing to 6a720b227e361303445c41f7ff4a8109
statement ok
drop table test
endloop
endloop

22
external/duckdb/test/sql/order/persistent_list_of_varchar_order.test_slow vendored Normal file
View File

@@ -0,0 +1,22 @@
# name: test/sql/order/persistent_list_of_varchar_order.test_slow
# description: Test ORDER BY on persistent list of varchars
# group: [order]
require parquet
load __TEST_DIR__/candidate.db
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE candidate AS SELECT * FROM 'data/parquet-testing/candidate.parquet'
statement ok
select * from candidate order by name;
statement ok
select * from candidate where jaccard(name, 'BATMAN') >= 0.4 order by jaccard(name, 'BATMAN');
statement ok
select * from candidate where jaro_winkler_similarity(name, 'BATMAN') >= 0.4 order by jaro_winkler_similarity(name, 'BATMAN');

306
external/duckdb/test/sql/order/test_limit.test vendored Normal file
View File

@@ -0,0 +1,306 @@
# name: test/sql/order/test_limit.test
# description: Test LIMIT keyword
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22), (12, 21), (13, 22)
# constant limit
query I
SELECT a FROM test LIMIT 1
----
11
# decimal limit
query I
SELECT a FROM test LIMIT 1.25
----
11
# LIMIT with operation
query I
SELECT a FROM test LIMIT 2-1
----
11
# LIMIT with non-scalar should fail
statement error
SELECT a FROM test LIMIT a
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
# LIMIT with non-scalar operation should also fail
statement error
SELECT a FROM test LIMIT a+1
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
# aggregate in limit
statement error
SELECT a FROM test LIMIT SUM(42)
----
<REGEX>:Binder Error:.*Aggregate functions are not supported.*
# window function in limit
statement error
SELECT a FROM test LIMIT row_number() OVER ()
----
<REGEX>:Not implemented Error:.*expression class.*
# LIMIT Bug #321 Crazy Result
statement ok
CREATE TABLE test2 (a STRING);
statement ok
INSERT INTO test2 VALUES ('Hello World')
statement ok
PREPARE v1 AS SELECT * FROM test2 LIMIT 3
query I
EXECUTE v1
----
Hello World
# can only limit by integers
statement error
select 1 limit date '1992-01-01';
----
<REGEX>:Conversion Error.*Unimplemented type for cast.*
# Test limits with no constants
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (4), (5);
statement ok
CREATE SEQUENCE seq START 3;
statement ok
PRAGMA disable_verification;
statement ok
PRAGMA disable_verify_fetch_row;
query I
SELECT * FROM integers LIMIT nextval('seq');
----
1
2
3
query I
SELECT * FROM integers LIMIT nextval('seq');
----
1
2
3
4
# non-foldable expression in limit
statement ok
SELECT * FROM integers LIMIT RANDOM();
# subquery in limit
query I
SELECT * FROM integers as int LIMIT (SELECT MIN(integers.i) FROM integers);
----
1
statement ok
CREATE SEQUENCE of_seq START 1;
query I
SELECT * FROM integers OFFSET nextval('of_seq');
----
2
3
4
5
query I
SELECT * FROM integers OFFSET nextval('of_seq');
----
3
4
5
# non-foldable expression in limit
statement ok
SELECT * FROM integers OFFSET RANDOM();
# subquery in limit
query I
SELECT * FROM integers as int OFFSET (SELECT MIN(integers.i) FROM integers);
----
2
3
4
5
#Both LIMIT and OFFSET together with subqueries
query I
SELECT * FROM integers as int LIMIT (SELECT MAX(integers.i) FROM integers) OFFSET (SELECT MIN(integers.i) FROM integers);
----
2
3
4
5
#Subqueries that return zero rows = Same as ommiting limit clause
query I
SELECT * FROM integers as int LIMIT (SELECT max(integers.i) FROM integers where i > 5)
----
1
2
3
4
5
#Limit of NULL, offset of NULL
query I
SELECT * FROM integers as int LIMIT (SELECT max(integers.i) FROM integers where i > 5)
----
1
2
3
4
5
#Subqueries that return NULL
query I
SELECT * FROM integers as int LIMIT (SELECT NULL)
----
1
2
3
4
5
#Subqueries that return negative values
statement error
SELECT * FROM integers as int LIMIT (SELECT -1);
----
<REGEX>:Invalid Input Error.*INT32.*out of range for.*UINT64.*
#Subqueries that return strings that can't be converted to integers
statement error
SELECT * FROM integers as int LIMIT (SELECT 'ab');
----
<REGEX>:Invalid Input Error.*Could not convert string.*
# Test use subquery in limit and offset
statement ok
CREATE OR REPLACE TABLE t AS SELECT range x FROM range(10);
statement ok
PRAGMA enable_verification;
query I
SELECT * FROM t ORDER BY x;
----
0
1
2
3
4
5
6
7
8
9
query I
SELECT * FROM t ORDER BY x OFFSET 5;
----
5
6
7
8
9
# scalar subquery in offset
query I
SELECT * FROM t ORDER BY x OFFSET (SELECT 5);
----
5
6
7
8
9
# scalar subquery in limit
query I
SELECT * FROM t ORDER BY x LIMIT (SELECT 5);
----
0
1
2
3
4
# scalar subquery both in limit and offset
query I
SELECT * FROM t ORDER BY x LIMIT (SELECT 3) OFFSET (SELECT 3);
----
3
4
5
# scalar subquery in offset
query I
SELECT * FROM t ORDER BY x LIMIT 3 OFFSET (SELECT 3);
----
3
4
5
# scalar subquery in limit
query I
SELECT * FROM t ORDER BY x LIMIT (SELECT 3) OFFSET 3;
----
3
4
5
# negeive number in the limit
statement error
SELECT * FROM t ORDER BY x LIMIT (SELECT -1);
----
<REGEX>:Invalid Input Error.*INT32.*out of range for.*UINT64.*
# negeive number in the offset
statement error
SELECT * FROM t ORDER BY x OFFSET (SELECT -1);
----
<REGEX>:Invalid Input Error.*INT32.*out of range for.*UINT64.*
statement ok
create table t0(c0 int);
statement ok
insert into t0 values (1), (2), (3), (4), (5), (6), (7);
# some complex expression in the offset clause
statement error
SELECT * FROM t0 ORDER BY ALL OFFSET (SELECT DISTINCT 6.5 FROM (SELECT 1) t1(c0) UNION ALL SELECT 3);
----
More than one row returned by a subquery
statement ok
SET scalar_subquery_error_on_multiple_rows=false
query I
SELECT * FROM t0 ORDER BY ALL OFFSET (SELECT DISTINCT 6.5 FROM (SELECT 1) t1(c0) UNION ALL SELECT 3);
----
7

20
external/duckdb/test/sql/order/test_limit_cte.test vendored Normal file
View File

@@ -0,0 +1,20 @@
# name: test/sql/order/test_limit_cte.test
# description: Test LIMIT with CTE clauses
# group: [order]
statement ok
PRAGMA enable_verification
query I
WITH cte AS (SELECT 3) SELECT * FROM range(10000000) LIMIT (SELECT * FROM cte)
----
0
1
2
query I
WITH cte AS (SELECT 3) SELECT * FROM range(10000000) LIMIT (SELECT * FROM cte) OFFSET (SELECT * FROM cte)
----
3
4
5

160
external/duckdb/test/sql/order/test_limit_parameter.test vendored Normal file
View File

@@ -0,0 +1,160 @@
# name: test/sql/order/test_limit_parameter.test
# description: Test LIMIT with a parameter (issue 1866)
# group: [order]
statement ok
PRAGMA enable_verification
statement error
SELECT 'Test' LIMIT ?
----
<REGEX>:Invalid Input Error.*Expected 1 parameters, but none were supplied.*
statement ok
PREPARE v1 AS SELECT 'Test' LIMIT ?
query I
EXECUTE v1(1)
----
Test
query I
EXECUTE v1(0)
----
statement ok
PREPARE v2 AS SELECT * FROM RANGE(1000000000) LIMIT ? OFFSET ?
query I
EXECUTE v2(3, 0)
----
0
1
2
query I
EXECUTE v2(3, 17)
----
17
18
19
statement ok
PREPARE v3 AS SELECT * FROM RANGE(1000000000) LIMIT 2 OFFSET ?
query I
EXECUTE v3(0)
----
0
1
query I
EXECUTE v3(17)
----
17
18
statement ok
PREPARE v4 AS SELECT * FROM RANGE(1000000000) LIMIT ? OFFSET 17
query I
EXECUTE v4(3)
----
17
18
19
query I
EXECUTE v4(6)
----
17
18
19
20
21
22
statement ok
PREPARE v5 AS SELECT * FROM RANGE(1000000000) LIMIT (SELECT ?::INT) OFFSET (SELECT ?::INT)
query I
EXECUTE v5(3, 0)
----
0
1
2
query I
EXECUTE v5(3, 17)
----
17
18
19
statement ok
PREPARE v6 AS SELECT * FROM RANGE(1000000000) LIMIT 3+? OFFSET ?+2*?
query I
EXECUTE v6(1, 0, 0)
----
0
1
2
3
query I
EXECUTE v6(3, 1, 2)
----
5
6
7
8
9
10
statement ok
PREPARE v7 AS SELECT * FROM GENERATE_SERIES(0,4,1) LIMIT ? OFFSET ?
query I
EXECUTE v7(NULL, 2)
----
2
3
4
query I
EXECUTE v7(2, NULL)
----
0
1
query I
EXECUTE v7(NULL, 9223372036854775807)
----
query I
EXECUTE v7(9223372036854775807, NULL)
----
0
1
2
3
4
statement error
EXECUTE v7(NULL, 922337203685477580700)
----
<REGEX>:Conversion Error.*INT128.*is out of range for.*INT64.*
query I
EXECUTE v7(NULL, 4611686018427387904)
----
query I
EXECUTE v7(4611686018427387904, NULL)
----
0
1
2
3
4

260
external/duckdb/test/sql/order/test_limit_percent.test vendored Normal file
View File

@@ -0,0 +1,260 @@
# name: test/sql/order/test_limit_percent.test
# description: Test LIMIT keyword {% | PERCENT}
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22), (12, 21), (13, 22), (14, 32), (15, 52)
# constant limit
query I
SELECT a FROM test LIMIT 20 %
----
11
query I
SELECT a FROM test LIMIT 40 PERCENT
----
11
12
# decimal limit
query I
SELECT a FROM test LIMIT 35%
----
11
query I
SELECT a FROM test LIMIT 79.9%
----
11
12
13
query I
SELECT a FROM test LIMIT 80.1%
----
11
12
13
14
query I
SELECT a FROM test LIMIT 100 PERCENT
----
11
12
13
14
15
# LIMIT with operation
query I
SELECT a FROM test LIMIT (30-10) %
----
11
# LIMIT with non-scalar should fail
statement error
SELECT a FROM test LIMIT a %
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
# LIMIT with non-scalar operation should also fail
statement error
SELECT a FROM test LIMIT (a+1) %
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
statement error
SELECT a FROM test LIMIT (a+b*c) %
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
statement error
SELECT a FROM test LIMIT (a+b*c) %
----
<REGEX>:Binder Error:.*Referenced column.*not found.*
# aggregate in limit percent
statement error
SELECT a FROM test LIMIT SUM(42) %
----
<REGEX>:Binder Error:.*Aggregate functions are not supported.*
# non-foldable expression in limit percent
statement ok
SELECT * FROM test LIMIT RANDOM() %;
# subquery in limit percent and offset
query I
SELECT a FROM test LIMIT 50% OFFSET 2
----
13
14
query I
SELECT * FROM range(10) LIMIT 50% OFFSET 2
----
2
3
4
5
6
query I
SELECT * FROM range(10000) LIMIT 0.1% OFFSET 8000
----
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009
query I
SELECT * FROM range(10000) LIMIT 0.1% OFFSET 9999
----
9999
query I
SELECT a FROM test LIMIT (SELECT COUNT(*) FROM test) % OFFSET 1
----
query I
SELECT a FROM test LIMIT 50% OFFSET (((SELECT MIN(b) FROM test)-1)/10);
----
13
14
query I
SELECT b FROM test LIMIT 70% OFFSET (((SELECT MIN(test.a) FROM test)-1)/10);
----
21
22
32
# non-foldable expression in limit that always casts to 0
statement ok
SELECT * FROM test LIMIT 30% OFFSET RANDOM() / 10.0;
statement ok
SELECT b FROM test LIMIT 0%
#Subqueries that return negative values
statement error
SELECT * FROM range(100) LIMIT -10 %;
----
<REGEX>:Out of Range Error.*Limit percent.*
#Subqueries that return strings that can't be converted to integers
statement error
SELECT * FROM test LIMIT (SELECT 'ab') %
----
<REGEX>:Invalid Input Error.*Could not convert string.*
# can only limit % by integers
statement error
select 1 limit date '2021-11-25' %;
----
<REGEX>:Conversion Error.*Unimplemented type for cast.*
statement error
select * from test limit "Hello World" %;
----
<REGEX>:Binder Error:.*Referenced colum.*not found.*
#LIMIT % with strings
statement ok
CREATE TABLE test2 (a STRING);
statement ok
INSERT INTO test2 VALUES ('first'), ('second'), ('third'), ('4th'), ('5th')
statement ok
PREPARE v1 AS SELECT * FROM test2 LIMIT 40%
query I
EXECUTE v1
----
first
second
# LIMIT % with multiple lists
statement ok
CREATE VIEW v3 AS SELECT i % 5 g, LIST(CASE WHEN i=6 or i=8 then null else i end) l FROM RANGE(20) tbl(i) group by g
query II
SELECT g, 5=ANY(l) FROM v3 ORDER BY g LIMIT 80%;
----
0 true
1 NULL
2 false
3 NULL
query II
SELECT g, 3>ANY(l) FROM v3 ORDER BY g LIMIT 50%;
----
0 true
1 true
# LIMIT % with struct
statement ok
CREATE TABLE struct_data (g INTEGER, e INTEGER)
statement ok
INSERT INTO struct_data VALUES (1, 1), (1, 2), (2, 3), (2, 4), (2, 5), (3, 6), (5, NULL)
query T
SELECT STRUCT_PACK(a := 42, b := 43)
----
{'a': 42, 'b': 43}
query IT
SELECT e, STRUCT_PACK(e) FROM struct_data ORDER BY e LIMIT 60%
----
NULL {'e': NULL}
1 {'e': 1}
2 {'e': 2}
3 {'e': 3}
# LIMIT % of NULL
statement ok
CREATE TABLE integers(i INTEGER);
statement ok
INSERT INTO integers VALUES (1), (2), (3), (4), (5);
query I
SELECT * FROM integers as int LIMIT (SELECT max(integers.i) FROM integers where i > 5) %
----
1
2
3
4
5
# unions are usually executed in parallel, and kept in order using batch indices
# limit percent is not a parallel sink, and does not support batch indices
# this tests that the order is still preserved
loop i 0 10
query T
select 1 union all select 2 union all select 3 union all select 4 limit 50%
----
1
2
endloop

24
external/duckdb/test/sql/order/test_limit_percent_large.test_slow vendored Normal file
View File

@@ -0,0 +1,24 @@
# name: test/sql/order/test_limit_percent_large.test_slow
# description: Test LIMIT keyword {% | PERCENT}
# group: [order]
statement ok
PRAGMA enable_verification
query I
SELECT COUNT(*) FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM range(1000000) LIMIT 10%) LIMIT 10%) LIMIT 10%)
----
1000
query I
SELECT * FROM range(10) UNION ALL SELECT * FROM range(10, 20) LIMIT 10%;
----
0
1
#boundary values
# big value
query I
SELECT * FROM range(1000000) LIMIT 0.0001%
----
0

137
external/duckdb/test/sql/order/test_nulls_first.test vendored Normal file
View File

@@ -0,0 +1,137 @@
# name: test/sql/order/test_nulls_first.test
# description: Test NULLS FIRST/NULLS LAST
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (1), (NULL)
# default is NULLS FIRST
query I
SELECT * FROM integers ORDER BY i
----
NULL
1
query I
SELECT * FROM integers ORDER BY i NULLS FIRST
----
NULL
1
query I
SELECT * FROM integers ORDER BY i NULLS LAST
----
1
NULL
query II
SELECT 10 AS j, i FROM integers ORDER BY j, i NULLS LAST
----
10 1
10 NULL
# multiple columns with a mix
statement ok
CREATE TABLE test(i INTEGER, j INTEGER)
statement ok
INSERT INTO test VALUES (1, 1), (NULL, 1), (1, NULL)
query II
SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS LAST
----
NULL 1
1 1
1 NULL
query II
SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS FIRST
----
NULL 1
1 NULL
1 1
query II
SELECT * FROM test ORDER BY i NULLS LAST, j NULLS FIRST
----
1 NULL
1 1
NULL 1
# now in window functions
query III
SELECT i, j, row_number() OVER (PARTITION BY i ORDER BY j NULLS FIRST) FROM test ORDER BY i NULLS FIRST, j NULLS FIRST;
----
NULL 1 1
1 NULL 1
1 1 2
query III
SELECT i, j, row_number() OVER (PARTITION BY i ORDER BY j NULLS LAST) FROM test ORDER BY i NULLS FIRST, j NULLS FIRST;
----
NULL 1 1
1 NULL 2
1 1 1
# TOP N
query II
SELECT * FROM test ORDER BY i NULLS FIRST, j NULLS LAST LIMIT 2
----
NULL 1
1 1
query II
SELECT * FROM test ORDER BY i NULLS LAST, j NULLS LAST LIMIT 2
----
1 1
1 NULL
# Test NULLS FIRST/NULLS LAST PRAGMA
# default is NULLS FIRST
query I
SELECT * FROM integers ORDER BY i
----
NULL
1
# changed default now
statement ok
PRAGMA default_null_order='NULLS LAST'
query I
SELECT * FROM integers ORDER BY i
----
1
NULL
statement ok
PRAGMA default_null_order='NULLS FIRST'
statement error
PRAGMA default_null_order())
----
<REGEX>:Parser Error.*syntax error.*
statement error
PRAGMA default_null_order='UNKNOWN'
----
<REGEX>:Parser Error.*Unrecognized parameter for option.*
statement error
PRAGMA default_null_order=UNKNOWN)
----
<REGEX>:Parser Error.*syntax error.*
statement error
PRAGMA default_null_order=3)
----
<REGEX>:Parser Error.*syntax error.*

195
external/duckdb/test/sql/order/test_order_by.test vendored Normal file
View File

@@ -0,0 +1,195 @@
# name: test/sql/order/test_order_by.test
# description: Test ORDER BY keyword
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22), (12, 21), (13, 22);
query I
select b from test where a = 12;
----
21
# simple ORDER BY
query I
SELECT b FROM test ORDER BY a DESC;
----
22
21
22
query II
SELECT a, b FROM test ORDER BY a;
----
11 22
12 21
13 22
query II
SELECT a, b FROM test ORDER BY a DESC;
----
13 22
12 21
11 22
# ORDER BY on multiple columns
query II
SELECT a, b FROM test ORDER BY b, a;
----
12 21
11 22
13 22
# ORDER BY using select indices
query II
SELECT a, b FROM test ORDER BY 2, 1;
----
12 21
11 22
13 22
query II
SELECT a, b FROM test ORDER BY b DESC, a;
----
11 22
13 22
12 21
query II
SELECT a, b FROM test ORDER BY b, a DESC;
----
12 21
13 22
11 22
# TOP N queries
query II
SELECT a, b FROM test ORDER BY b, a DESC LIMIT 1;
----
12 21
# Offset
query II
SELECT a, b FROM test ORDER BY b, a DESC LIMIT 1 OFFSET 1;
----
13 22
# Offset without limit
query II
SELECT a, b FROM test ORDER BY b, a DESC OFFSET 1;
----
13 22
11 22
query II
SELECT a, b FROM test WHERE a < 13 ORDER BY b;
----
12 21
11 22
query II
SELECT a, b FROM test WHERE a < 13 ORDER BY 2;
----
12 21
11 22
query II
SELECT a, b FROM test WHERE a < 13 ORDER BY b DESC;
----
11 22
12 21
query II
SELECT b, a FROM test WHERE a < 13 ORDER BY b DESC;
----
22 11
21 12
# order by expression
query IR
SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY b % 2;
----
0 24.000000
1 12.000000
# order by expression that is not in SELECT
query II
SELECT b % 2 AS f, a FROM test ORDER BY b % 2, a;
----
0 11
0 13
1 12
# ORDER BY alias
query IR
SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY f;
----
0 24.000000
1 12.000000
query IR
SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY 1;
----
0 24.000000
1 12.000000
# ORDER BY after union
query I
SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY k;
----
1
2
3
# ORDER BY on alias in right-most query
# CONTROVERSIAL: SQLite allows both "k" and "l" to be referenced here, Postgres and MonetDB give an error.
query I
SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY l;
----
1
2
3
# computations with aliases are not allowed though
statement error
SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY 1-k;
----
<REGEX>:Binder Error:.*Could not ORDER BY column.*
# but ordering on computation elements should work
query I
SELECT a-10 AS k FROM test UNION SELECT a-10 AS l FROM test ORDER BY a-10;
----
1
2
3
query I
SELECT a-10 AS k FROM test UNION SELECT a-11 AS l FROM test ORDER BY a-11;
----
0
1
2
3
# order by non-integer literal
statement error
SELECT a FROM test ORDER BY 'hello world', a
----
ORDER BY non-integer literal has no effect
statement ok
SET order_by_non_integer_literal=true
query I
SELECT a FROM test ORDER BY 'hello world', a
----
11
12
13

79
external/duckdb/test/sql/order/test_order_by_exceptions.test vendored Normal file
View File

@@ -0,0 +1,79 @@
# name: test/sql/order/test_order_by_exceptions.test
# description: Test ORDER BY exceptions
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22), (12, 21), (13, 22);
# ORDER BY index out of range
statement error
SELECT a FROM test ORDER BY 2
----
<REGEX>:Binder Error:.*term out of range.*
# ORDER BY constant returns an error
# CONTROVERSIAL: works in SQLite but not in Postgres
statement error
SELECT a FROM test ORDER BY 'hello', a
----
ORDER BY non-integer literal has no effect
statement ok
SET order_by_non_integer_literal=true
query I
SELECT a FROM test ORDER BY 'hello', a
----
11
12
13
query II
SELECT a AS k, b FROM test UNION SELECT a, b AS k FROM test ORDER BY k
----
11 22
12 21
13 22
query II
SELECT a AS k, b FROM test UNION SELECT a AS k, b FROM test ORDER BY k
----
11 22
12 21
13 22
# ambiguous reference in union parameter
statement error
SELECT a % 2, b FROM test UNION SELECT b, a % 2 AS k ORDER BY a % 2
----
<REGEX>:Binder Error:.*column.*not found.*
# but works if not ambiguous
query II
SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY a % 2
----
0 21
1 22
# out of range order also happens for unions
statement error
SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY 3
----
<REGEX>:Binder Error:.*out of range.*
statement error
SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY -1
----
<REGEX>:Binder Error:.*out of range.*
# and union itself fails if amount of entries is wrong
statement error
SELECT a % 2, b FROM test UNION SELECT a % 2 AS k FROM test ORDER BY -1
----
<REGEX>:Binder Error:.*Set operations can only apply.*

15
external/duckdb/test/sql/order/test_order_large.test vendored Normal file
View File

@@ -0,0 +1,15 @@
# name: test/sql/order/test_order_large.test
# description: Test ORDER BY with large table
# group: [order]
statement ok
PRAGMA verify_parallelism
# order of a large table, with burgers and fries
statement ok
CREATE TABLE test AS SELECT a FROM range(10000, 0, -1) t1(a)
query I
SELECT * FROM test ORDER BY a
----
10000 values hashing to 72d4ff27a28afbc066d5804999d5a504

1197
external/duckdb/test/sql/order/test_order_nested.test_slow vendored Normal file
View File

File diff suppressed because it is too large Load Diff

54
external/duckdb/test/sql/order/test_order_pragma.test vendored Normal file
View File

@@ -0,0 +1,54 @@
# name: test/sql/order/test_order_pragma.test
# description: Test ORDER BY PRAGMA
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE test (a INTEGER, b INTEGER);
statement ok
INSERT INTO test VALUES (11, 22), (12, 21), (13, 22);
# default is ORDER BY ASC
query I
SELECT a FROM test ORDER BY a
----
11
12
13
# we can change the default with a pragma
statement ok
PRAGMA default_order='DESCENDING'
query I
SELECT a FROM test ORDER BY a
----
13
12
11
statement ok
PRAGMA default_order='ASC'
statement error
PRAGMA default_order())
----
<REGEX>:Parser Error.*syntax error.*
statement error
PRAGMA default_order='UNKNOWN'
----
<REGEX>:Invalid Input Error.*Unrecognized parameter for option.*
statement error
PRAGMA default_order=UNKNOWN)
----
<REGEX>:Parser Error.*syntax error.*
statement error
PRAGMA default_order=3)
----
<REGEX>:Parser Error.*syntax error.*

111
external/duckdb/test/sql/order/test_order_range_mapping.test vendored Normal file
View File

@@ -0,0 +1,111 @@
# name: test/sql/order/test_order_range_mapping.test
# description: Test ORDER BY range mapping of order expressions using statistics
# group: [order]
statement ok
pragma enable_verification
# cast to utinyint
foreach type <integral>
statement ok
create table test (i ${type})
statement ok
insert into test values (100), (25), (75), (50);
query T
select * from test order by i
----
25
50
75
100
statement ok
drop table test
endloop
# cast to usmallint
foreach type smallint usmallint integer uinteger bigint ubigint hugeint uhugeint
statement ok
create table test (i ${type})
statement ok
insert into test values (10000), (2500), (7500), (5000)
query T
select * from test order by i
----
2500
5000
7500
10000
statement ok
drop table test
endloop
# cast to uint
foreach type integer uinteger bigint ubigint hugeint uhugeint
statement ok
create table test (i ${type})
statement ok
insert into test values (1000000), (250000), (750000), (500000)
query T
select * from test order by i
----
250000
500000
750000
1000000
statement ok
drop table test
endloop
# cast to ubigint
foreach type bigint ubigint hugeint uhugeint
statement ok
create table test (i ${type})
statement ok
insert into test values (1000000000), (250000000), (750000000), (500000000)
query T
select * from test order by i
----
250000000
500000000
750000000
1000000000
statement ok
drop table test
endloop
statement ok
create table test (i hugeint)
statement ok
insert into test values (295147905179352825856), (73786976294838206464), (147573952589676412928), (36893488147419103232)
query T
select * from test order by i
----
36893488147419103232
73786976294838206464
147573952589676412928
295147905179352825856
statement ok
drop table test

79
external/duckdb/test/sql/order/test_order_same_value.test_slow vendored Normal file
View File

@@ -0,0 +1,79 @@
# name: test/sql/order/test_order_same_value.test_slow
# description: Test ordering the same value several times
# group: [order]
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE integers(i INTEGER)
statement ok
INSERT INTO integers VALUES (0), (0), (0), (0)
# 4 -> 8
statement ok
INSERT INTO integers SELECT * FROM integers
# 8 -> 16
statement ok
INSERT INTO integers SELECT * FROM integers
# 16 -> 32
statement ok
INSERT INTO integers SELECT * FROM integers
# 32 -> 64
statement ok
INSERT INTO integers SELECT * FROM integers
# 64 -> 128
statement ok
INSERT INTO integers SELECT * FROM integers
# 128 -> 256
statement ok
INSERT INTO integers SELECT * FROM integers
# 256 -> 512
statement ok
INSERT INTO integers SELECT * FROM integers
# 512 -> 1024
statement ok
INSERT INTO integers SELECT * FROM integers
# 1024 -> 2048
statement ok
INSERT INTO integers SELECT * FROM integers
# 2048 -> 4096
statement ok
INSERT INTO integers SELECT * FROM integers
# 4096 -> 8192
statement ok
INSERT INTO integers SELECT * FROM integers
# 8192 -> 16384
statement ok
INSERT INTO integers SELECT * FROM integers
# 16384 -> 32768
statement ok
INSERT INTO integers SELECT * FROM integers
# 32768 -> 65536
statement ok
INSERT INTO integers SELECT * FROM integers
# 65536 -> 131072
statement ok
INSERT INTO integers SELECT * FROM integers
# order by
query R
SELECT SUM(i) FROM (SELECT i FROM integers ORDER BY i) t1
----
0.000000

53
external/duckdb/test/sql/order/test_order_unnest.test vendored Normal file
View File

@@ -0,0 +1,53 @@
# name: test/sql/order/test_order_unnest.test
# description: Test ORDER BY keyword with unnesting structs
# group: [order]
# issue #9433
statement ok
CREATE TABLE tbl_structs AS SELECT
{'a': 2.0, 'b': 'hello', 'c': [1, 2]} AS s1,
1::BIGINT AS i,
{'k': 1::TINYINT, 'j': 0::BOOL} AS s2;
statement ok
INSERT INTO tbl_structs VALUES (
{'a': 1.0, 'b': 'yay', 'c': [10, 20]},
42,
{'k': 2, 'j': 1});
query IIII
SELECT UNNEST(s1), s1.a AS id FROM tbl_structs ORDER BY id;
----
1.0 yay [10, 20] 1.0
2.0 hello [1, 2] 2.0
query II
SELECT s1, s1.a FROM tbl_structs ORDER BY 1;
----
{'a': 1.0, 'b': yay, 'c': [10, 20]} 1.0
{'a': 2.0, 'b': hello, 'c': [1, 2]} 2.0
query IIII
SELECT UNNEST(s1), s1.a AS id FROM tbl_structs ORDER BY 1;
----
1.0 yay [10, 20] 1.0
2.0 hello [1, 2] 2.0
query IIIIII
SELECT UNNEST(s1), UNNEST(s2), i FROM tbl_structs ORDER BY i;
----
2.0 hello [1, 2] 1 False 1
1.0 yay [10, 20] 2 True 42
query IIIIII
SELECT UNNEST(s1), UNNEST(s2), i FROM tbl_structs ORDER BY 2 DESC;
----
1.0 yay [10, 20] 2 True 42
2.0 hello [1, 2] 1 False 1
query IIIIII
SELECT i, UNNEST(s1), UNNEST(s2) FROM tbl_structs ORDER BY 5 DESC;
----
42 1.0 yay [10, 20] 2 True
1 2.0 hello [1, 2] 1 False

519
external/duckdb/test/sql/order/test_order_variable_size_payload.test_slow vendored Normal file
View File

@@ -0,0 +1,519 @@
# name: test/sql/order/test_order_variable_size_payload.test_slow
# description: Test ORDER BY keyword (variable size sorting/payload columns)
# group: [order]
statement ok
SET default_null_order='nulls_first';
statement ok
PRAGMA enable_verification
# first iteration runs externally, second runs normally
statement ok
PRAGMA debug_force_external=true
loop i 0 2
# string that is longer than Storage::BLOCK_SIZE - this tests whether RowDataCollection dynamically increases block capacity
statement ok
select range % 2 i, string_agg('thisstringis200characterslong..........................................................................................................................................................................') s from range(5000) group by i order by i
# weird one from SQLancer
statement ok
create table t0 (c0 varchar);
statement ok
insert into t0 values ('a'), (NULL), (NULL), (NULL), (NULL), (NULL), (NULL);
query T
SELECT * FROM t0 ORDER BY t0.c0 DESC;
----
NULL
NULL
NULL
NULL
NULL
NULL
a
# strings longer than the 12 character prefix
statement ok
CREATE TABLE test0 (job VARCHAR, name VARCHAR)
statement ok
INSERT INTO test0 VALUES ('Shipping and Receiving Supervisor', 'Ackerman'), ('Shipping and Receiving Clerk', 'Berndt'), ('Shipping and Receiving Clerk', 'Kuppa'), ('Production Supervisor - WC60', 'Brown'), ('Production Supervisor - WC60', 'Campbell'), ('Production Supervisor - WC40', 'Dsa')
query TT
SELECT * FROM test0 ORDER BY job, name
----
Production Supervisor - WC40 Dsa
Production Supervisor - WC60 Brown
Production Supervisor - WC60 Campbell
Shipping and Receiving Clerk Berndt
Shipping and Receiving Clerk Kuppa
Shipping and Receiving Supervisor Ackerman
query TT
SELECT * FROM test0 ORDER BY job DESC, name DESC
----
Shipping and Receiving Supervisor Ackerman
Shipping and Receiving Clerk Kuppa
Shipping and Receiving Clerk Berndt
Production Supervisor - WC60 Campbell
Production Supervisor - WC60 Brown
Production Supervisor - WC40 Dsa
statement ok
CREATE TABLE test1 (s VARCHAR)
statement ok
INSERT INTO test1 VALUES ('2'), (NULL), ('3555555555552'), ('1'), ('355555555556'), ('10'), ('3555555555553'), ('3555555555551')
query I
SELECT * FROM test1 ORDER BY s
----
NULL
1
10
2
3555555555551
3555555555552
3555555555553
355555555556
# sort on 10000 strings
statement ok
CREATE TABLE test2 AS (SELECT CAST(range AS VARCHAR) r, random() rand FROM range(10000))
statement ok
CREATE TABLE test2_1 AS (SELECT * FROM test2 ORDER BY r)
query T
SELECT count(*) FROM test2_1
----
10000
# string payload
statement ok
CREATE TABLE test3 AS (SELECT CAST(range AS VARCHAR) r, random() rand FROM range(10000))
statement ok
CREATE TABLE test3_1 AS (SELECT * FROM test3 ORDER BY rand)
query T
SELECT count(*) FROM test3_1
----
10000
# multiple columns
statement ok
CREATE TABLE test4 (i INT, j INT)
statement ok
INSERT INTO test4 VALUES (3, 3), (2, 3), (2, 2), (3, 2)
query II
SELECT * FROM test4 ORDER BY cast(i AS VARCHAR), j
----
2 2
2 3
3 2
3 3
query II
SELECT * FROM test4 ORDER BY i, cast(j AS VARCHAR)
----
2 2
2 3
3 2
3 3
query II
SELECT * FROM test4 ORDER BY cast(i AS VARCHAR), cast(j AS VARCHAR)
----
2 2
2 3
3 2
3 3
# many payload columns
statement ok
CREATE TABLE tpch_q1_agg (l_returnflag VARCHAR, l_linestatus VARCHAR, sum_qty INT, sum_base_price DOUBLE, sum_disc_price DOUBLE, sum_charge DOUBLE, avg_qty DOUBLE, avg_price DOUBLE, avg_disc DOUBLE, count_order BIGINT);
statement ok
INSERT INTO tpch_q1_agg VALUES ('N', 'O', 7459297, 10512270008.90, 9986238338.3847, 10385578376.585467, 25.545537671232875, 36000.9246880137, 0.05009595890410959, 292000), ('R', 'F', 3785523, 5337950526.47, 5071818532.9420, 5274405503.049367, 25.5259438574251, 35994.029214030925, 0.04998927856184382, 148301), ('A', 'F', 3774200, 5320753880.69, 5054096266.6828, 5256751331.449234, 25.537587116854997, 36002.12382901414, 0.05014459706340077, 147790), ('N', 'F', 95257, 133737795.84, 127132372.6512, 132286291.229445, 25.30066401062417, 35521.32691633466, 0.04939442231075697, 3765);
query TTTTTTTTTT
SELECT * FROM tpch_q1_agg ORDER BY l_returnflag, l_linestatus;
----
A F 3774200 5320753880.69 5054096266.6828 5256751331.449234 25.537587116854997 36002.12382901414 0.05014459706340077 147790
N F 95257 133737795.84 127132372.6512 132286291.229445 25.30066401062417 35521.32691633466 0.04939442231075697 3765
N O 7459297 10512270008.90 9986238338.3847 10385578376.585467 25.545537671232875 36000.9246880137 0.05009595890410959 292000
R F 3785523 5337950526.47 5071818532.9420 5274405503.049367 25.5259438574251 35994.029214030925 0.04998927856184382 148301
statement ok
create table test5 (i int, s varchar);
statement ok
insert into test5 values (3, 'ababa'), (1, 'babab'), (NULL, 'abbab'), (2, NULL);
query TT
select i, list(string_split(s, 'b')) from test5 group by i order by i;
----
NULL [[a, '', a, '']]
1 [['', a, a, '']]
2 [NULL]
3 [[a, a, a]]
query TT
select i, struct_pack(i:=i, s:=s) from test5 order by i;
----
NULL {'i': NULL, 's': abbab}
1 {'i': 1, 's': babab}
2 {'i': 2, 's': NULL}
3 {'i': 3, 's': ababa}
query TT
select i, struct_pack(i:=i, s:=string_split(s, 'b')) from test5 order by i;
----
NULL {'i': NULL, 's': [a, '', a, '']}
1 {'i': 1, 's': ['', a, a, '']}
2 {'i': 2, 's': NULL}
3 {'i': 3, 's': [a, a, a]}
query TT
select i, struct_pack(i:=i, s:=UNNEST(string_split(s, 'b'))) from test5 order by i;
----
NULL {'i': NULL, 's': a}
NULL {'i': NULL, 's': ''}
NULL {'i': NULL, 's': a}
NULL {'i': NULL, 's': ''}
1 {'i': 1, 's': ''}
1 {'i': 1, 's': a}
1 {'i': 1, 's': a}
1 {'i': 1, 's': ''}
3 {'i': 3, 's': a}
3 {'i': 3, 's': a}
3 {'i': 3, 's': a}
query TT
select i, struct_pack(i:=i, s:=list(s)) from test5 group by i order by i;
----
NULL {'i': NULL, 's': [abbab]}
1 {'i': 1, 's': [babab]}
2 {'i': 2, 's': [NULL]}
3 {'i': 3, 's': [ababa]}
query TT
select i, struct_pack(i:=i, s:=s) from test5 order by s;
----
2 {'i': 2, 's': NULL}
3 {'i': 3, 's': ababa}
NULL {'i': NULL, 's': abbab}
1 {'i': 1, 's': babab}
query TT
select i, struct_pack(i:=i, s:=list(string_split(s, 'b'))) from test5 group by i order by i;
----
NULL {'i': NULL, 's': [[a, '', a, '']]}
1 {'i': 1, 's': [['', a, a, '']]}
2 {'i': 2, 's': [NULL]}
3 {'i': 3, 's': [[a, a, a]]}
# sorting by a mix of variable size and constant size columns
statement ok
CREATE TABLE test6 (i1 INT, s1 VARCHAR, i2 int, s2 VARCHAR)
statement ok
INSERT INTO test6 VALUES
(6, '0reallylongstring1', 3, '1reallylongstring8'),
(6, '0reallylongstring1', 3, '1reallylongstring7'),
(6, '0reallylongstring1', 4, '1reallylongstring8'),
(6, '0reallylongstring1', 4, '1reallylongstring7'),
(6, '0reallylongstring2', 3, '1reallylongstring8'),
(6, '0reallylongstring2', 3, '1reallylongstring7'),
(6, '0reallylongstring2', 4, '1reallylongstring8'),
(6, '0reallylongstring2', 4, '1reallylongstring7'),
(5, '0reallylongstring1', 3, '1reallylongstring8'),
(5, '0reallylongstring1', 3, '1reallylongstring7'),
(5, '0reallylongstring1', 4, '1reallylongstring8'),
(5, '0reallylongstring1', 4, '1reallylongstring7'),
(5, '0reallylongstring2', 3, '1reallylongstring8'),
(5, '0reallylongstring2', 3, '1reallylongstring7'),
(5, '0reallylongstring2', 4, '1reallylongstring8'),
(5, '0reallylongstring2', 4, '1reallylongstring7')
query IIII
SELECT i1, s1, i2, s2 FROM test6 ORDER BY i1, s1, i2, s2
----
5 0reallylongstring1 3 1reallylongstring7
5 0reallylongstring1 3 1reallylongstring8
5 0reallylongstring1 4 1reallylongstring7
5 0reallylongstring1 4 1reallylongstring8
5 0reallylongstring2 3 1reallylongstring7
5 0reallylongstring2 3 1reallylongstring8
5 0reallylongstring2 4 1reallylongstring7
5 0reallylongstring2 4 1reallylongstring8
6 0reallylongstring1 3 1reallylongstring7
6 0reallylongstring1 3 1reallylongstring8
6 0reallylongstring1 4 1reallylongstring7
6 0reallylongstring1 4 1reallylongstring8
6 0reallylongstring2 3 1reallylongstring7
6 0reallylongstring2 3 1reallylongstring8
6 0reallylongstring2 4 1reallylongstring7
6 0reallylongstring2 4 1reallylongstring8
query IIII
SELECT s1, i1, i2, s2 FROM test6 ORDER BY s1, i1, i2, s2
----
0reallylongstring1 5 3 1reallylongstring7
0reallylongstring1 5 3 1reallylongstring8
0reallylongstring1 5 4 1reallylongstring7
0reallylongstring1 5 4 1reallylongstring8
0reallylongstring1 6 3 1reallylongstring7
0reallylongstring1 6 3 1reallylongstring8
0reallylongstring1 6 4 1reallylongstring7
0reallylongstring1 6 4 1reallylongstring8
0reallylongstring2 5 3 1reallylongstring7
0reallylongstring2 5 3 1reallylongstring8
0reallylongstring2 5 4 1reallylongstring7
0reallylongstring2 5 4 1reallylongstring8
0reallylongstring2 6 3 1reallylongstring7
0reallylongstring2 6 3 1reallylongstring8
0reallylongstring2 6 4 1reallylongstring7
0reallylongstring2 6 4 1reallylongstring8
query IIII
SELECT s1, i1, s2, i2 FROM test6 ORDER BY s1, i1, s2, i2
----
0reallylongstring1 5 1reallylongstring7 3
0reallylongstring1 5 1reallylongstring7 4
0reallylongstring1 5 1reallylongstring8 3
0reallylongstring1 5 1reallylongstring8 4
0reallylongstring1 6 1reallylongstring7 3
0reallylongstring1 6 1reallylongstring7 4
0reallylongstring1 6 1reallylongstring8 3
0reallylongstring1 6 1reallylongstring8 4
0reallylongstring2 5 1reallylongstring7 3
0reallylongstring2 5 1reallylongstring7 4
0reallylongstring2 5 1reallylongstring8 3
0reallylongstring2 5 1reallylongstring8 4
0reallylongstring2 6 1reallylongstring7 3
0reallylongstring2 6 1reallylongstring7 4
0reallylongstring2 6 1reallylongstring8 3
0reallylongstring2 6 1reallylongstring8 4
query IIII
SELECT s1, s2, i1, i2 FROM test6 ORDER BY s1, s2, i1, i2
----
0reallylongstring1 1reallylongstring7 5 3
0reallylongstring1 1reallylongstring7 5 4
0reallylongstring1 1reallylongstring7 6 3
0reallylongstring1 1reallylongstring7 6 4
0reallylongstring1 1reallylongstring8 5 3
0reallylongstring1 1reallylongstring8 5 4
0reallylongstring1 1reallylongstring8 6 3
0reallylongstring1 1reallylongstring8 6 4
0reallylongstring2 1reallylongstring7 5 3
0reallylongstring2 1reallylongstring7 5 4
0reallylongstring2 1reallylongstring7 6 3
0reallylongstring2 1reallylongstring7 6 4
0reallylongstring2 1reallylongstring8 5 3
0reallylongstring2 1reallylongstring8 5 4
0reallylongstring2 1reallylongstring8 6 3
0reallylongstring2 1reallylongstring8 6 4
query IIII
SELECT i1, i2, s1, s2 FROM test6 ORDER BY i1, i2, s1, s2
----
5 3 0reallylongstring1 1reallylongstring7
5 3 0reallylongstring1 1reallylongstring8
5 3 0reallylongstring2 1reallylongstring7
5 3 0reallylongstring2 1reallylongstring8
5 4 0reallylongstring1 1reallylongstring7
5 4 0reallylongstring1 1reallylongstring8
5 4 0reallylongstring2 1reallylongstring7
5 4 0reallylongstring2 1reallylongstring8
6 3 0reallylongstring1 1reallylongstring7
6 3 0reallylongstring1 1reallylongstring8
6 3 0reallylongstring2 1reallylongstring7
6 3 0reallylongstring2 1reallylongstring8
6 4 0reallylongstring1 1reallylongstring7
6 4 0reallylongstring1 1reallylongstring8
6 4 0reallylongstring2 1reallylongstring7
6 4 0reallylongstring2 1reallylongstring8
query IIII
SELECT s1, s2, i1, i2 FROM test6 ORDER BY i2 DESC, s1, s2, i1
----
0reallylongstring1 1reallylongstring7 5 4
0reallylongstring1 1reallylongstring7 6 4
0reallylongstring1 1reallylongstring8 5 4
0reallylongstring1 1reallylongstring8 6 4
0reallylongstring2 1reallylongstring7 5 4
0reallylongstring2 1reallylongstring7 6 4
0reallylongstring2 1reallylongstring8 5 4
0reallylongstring2 1reallylongstring8 6 4
0reallylongstring1 1reallylongstring7 5 3
0reallylongstring1 1reallylongstring7 6 3
0reallylongstring1 1reallylongstring8 5 3
0reallylongstring1 1reallylongstring8 6 3
0reallylongstring2 1reallylongstring7 5 3
0reallylongstring2 1reallylongstring7 6 3
0reallylongstring2 1reallylongstring8 5 3
0reallylongstring2 1reallylongstring8 6 3
# snippet from tpch q16
statement ok
create table test7 (p_brand VARCHAR, p_type VARCHAR, p_size INT, supplier_cnt BIGINT)
statement ok
insert into test7 values ('Brand#11', 'ECONOMY BRUSHED COPPER', 3, 4), ('Brand#11', 'ECONOMY BRUSHED COPPER', 9, 4), ('Brand#11', 'ECONOMY BRUSHED STEEL', 36, 4), ('Brand#11', 'ECONOMY BRUSHED STEEL', 9, 4), ('Brand#11', 'ECONOMY BURNISHED BRASS', 36, 4), ('Brand#11', 'ECONOMY BURNISHED COPPER', 49, 4), ('Brand#11', 'ECONOMY BURNISHED COPPER', 9, 4), ('Brand#11', 'ECONOMY BURNISHED NICKEL', 14, 4), ('Brand#11', 'ECONOMY BURNISHED NICKEL', 49, 4)
query IIII
SELECT p_brand, p_type, p_size, supplier_cnt FROM test7 ORDER BY supplier_cnt DESC, p_brand, p_type, p_size
----
Brand#11 ECONOMY BRUSHED COPPER 3 4
Brand#11 ECONOMY BRUSHED COPPER 9 4
Brand#11 ECONOMY BRUSHED STEEL 9 4
Brand#11 ECONOMY BRUSHED STEEL 36 4
Brand#11 ECONOMY BURNISHED BRASS 36 4
Brand#11 ECONOMY BURNISHED COPPER 9 4
Brand#11 ECONOMY BURNISHED COPPER 49 4
Brand#11 ECONOMY BURNISHED NICKEL 14 4
Brand#11 ECONOMY BURNISHED NICKEL 49 4
# simple nested lists (no structs)
statement ok
create table test8 (i int, s varchar)
statement ok
insert into test8 values (3, 'aba'), (1, 'ccbcc'), (NULL, 'dbdbd'), (2, NULL);
query TT
select i, string_split(s, 'b') from test8 order by i;
----
NULL [d, d, d]
1 [cc, cc]
2 NULL
3 [a, a]
query TT
select i, list(s) from test8 group by i order by i;
----
NULL [dbdbd]
1 [ccbcc]
2 [NULL]
3 [aba]
query TT
select i, list(string_split(s, 'b')) from test8 group by i order by i;
----
NULL [[d, d, d]]
1 [[cc, cc]]
2 [NULL]
3 [[a, a]]
# lists longer than STANDARD_VECTOR_SIZE
# need single thread since order within list is otherwise undefined
statement ok
PRAGMA threads=1
statement ok
CREATE TABLE test9 AS (SELECT range % 4 i, range j FROM range(5000));
statement ok
INSERT INTO test9 VALUES (0, NULL), (1, NULL), (2, NULL), (3, NULL)
query TT
SELECT i, list(j) FROM test9 GROUP BY i ORDER BY i;
----
8 values hashing to fc909a9ac472ea404c0bceecf7f1f3d6
statement ok
CREATE TABLE DirectReports
(
EmployeeID smallint,
Name varchar NOT NULL,
Title varchar NOT NULL,
EmployeeLevel int NOT NULL,
Sort varchar NOT NULL
);
statement ok
INSERT INTO DirectReports VALUES
(1, 'Ken Sánchez', 'Chief Executive Officer', 1, 'Ken Sánchez'),
(273, '>Brian Welcker', 'Vice President of Sales', 2, 'Ken Sánchez>Brian Welcker'),
(274, '>>Stephen Jiang', 'North American Sales Manager', 3, 'Ken Sánchez>Brian Welcker>Stephen Jiang'),
(285, '>>Syed Abbas', 'Pacific Sales Manager', 3, 'Ken Sánchez>Brian Welcker>Syed Abbas'),
(16, '>>David Bradley', 'Marketing Manager', 3, 'Ken Sánchez>Brian Welcker>David Bradley'),
(275, '>>>Michael Blythe', 'Sales Representative', 4, 'Ken Sánchez>Brian Welcker>Stephen Jiang>Michael Blythe'),
(276, '>>>Linda Mitchell', 'Sales Representative', 4, 'Ken Sánchez>Brian Welcker>Stephen Jiang>Linda Mitchell'),
(286, '>>>Lynn Tsoflias', 'Sales Representative', 4, 'Ken Sánchez>Brian Welcker>Syed Abbas>Lynn Tsoflias'),
(23, '>>>Mary Gibson', 'Marketing Specialist', 4, 'Ken Sánchez>Brian Welcker>David Bradley>Mary Gibson');
query IIII
SELECT EmployeeID, Name, Title, EmployeeLevel
FROM DirectReports
ORDER BY Sort, EmployeeID;
----
1 Ken Sánchez Chief Executive Officer 1
273 >Brian Welcker Vice President of Sales 2
16 >>David Bradley Marketing Manager 3
23 >>>Mary Gibson Marketing Specialist 4
274 >>Stephen Jiang North American Sales Manager 3
276 >>>Linda Mitchell Sales Representative 4
275 >>>Michael Blythe Sales Representative 4
285 >>Syed Abbas Pacific Sales Manager 3
286 >>>Lynn Tsoflias Sales Representative 4
statement ok
DROP TABLE t0;
statement ok
DROP TABLE test0;
statement ok
DROP TABLE test1;
statement ok
DROP TABLE test2;
statement ok
DROP TABLE test2_1;
statement ok
DROP TABLE test3;
statement ok
DROP TABLE test3_1;
statement ok
DROP TABLE test4;
statement ok
DROP TABLE tpch_q1_agg;
statement ok
DROP table test5;
statement ok
DROP TABLE test6;
statement ok
DROP table test7;
statement ok
DROP table test8;
statement ok
DROP TABLE test9;
statement ok
DROP TABLE DirectReports;
statement ok
PRAGMA debug_force_external=false
endloop

395
external/duckdb/test/sql/order/top_n_nulls.test vendored Normal file
View File

@@ -0,0 +1,395 @@
# name: test/sql/order/top_n_nulls.test
# description: Issue #3015: Wrong result on using limit after order by on null data
# group: [order]
require parquet
statement ok
PRAGMA enable_verification
statement ok
CREATE TABLE orders_small AS SELECT * FROM parquet_scan('data/parquet-testing/orders_small_parquet.test');
query IIII nosort
select o_orderkey, o_clerk, o_orderstatus, o_totalprice from orders_small
order by o_orderkey NULLS FIRST,
o_clerk NULLS FIRST, o_orderstatus NULLS FIRST,
o_totalprice DESC NULLS LAST limit 360
----
NULL NULL NULL 340307.430000
NULL NULL NULL 328268.960000
NULL NULL NULL 311077.000000
NULL NULL NULL 296731.500000
NULL NULL NULL 287540.740000
NULL NULL NULL 282895.800000
NULL NULL NULL 281298.110000
NULL NULL NULL 280581.420000
NULL NULL NULL 276437.190000
NULL NULL NULL 260191.440000
NULL NULL NULL 255481.810000
NULL NULL NULL 251755.620000
NULL NULL NULL 238936.970000
NULL NULL NULL 235488.940000
NULL NULL NULL 230766.480000
NULL NULL NULL 221161.270000
NULL NULL NULL 219740.510000
NULL NULL NULL 214573.210000
NULL NULL NULL 210796.750000
NULL NULL NULL 206883.430000
NULL NULL NULL 204126.000000
NULL NULL NULL 198265.350000
NULL NULL NULL 193082.890000
NULL NULL NULL 192187.210000
NULL NULL NULL 191412.290000
NULL NULL NULL 189947.500000
NULL NULL NULL 189469.700000
NULL NULL NULL 183980.860000
NULL NULL NULL 181677.640000
NULL NULL NULL 174652.870000
NULL NULL NULL 174059.570000
NULL NULL NULL 173183.720000
NULL NULL NULL 170431.860000
NULL NULL NULL 160457.990000
NULL NULL NULL 160015.960000
NULL NULL NULL 153975.860000
NULL NULL NULL 151788.070000
NULL NULL NULL 150238.370000
NULL NULL NULL 145402.270000
NULL NULL NULL 143916.630000
NULL NULL NULL 136488.480000
NULL NULL NULL 131805.810000
NULL NULL NULL 128850.630000
NULL NULL NULL 123049.400000
NULL NULL NULL 121868.460000
NULL NULL NULL 119830.710000
NULL NULL NULL 117567.130000
NULL NULL NULL 117093.370000
NULL NULL NULL 116790.600000
NULL NULL NULL 114017.090000
NULL NULL NULL 112280.850000
NULL NULL NULL 108964.770000
NULL NULL NULL 105069.160000
NULL NULL NULL 100327.500000
NULL NULL NULL 91474.220000
NULL NULL NULL 91157.110000
NULL NULL NULL 89944.360000
NULL NULL NULL 89260.550000
NULL NULL NULL 81688.190000
NULL NULL NULL 77790.850000
NULL NULL NULL 72973.350000
NULL NULL NULL 72294.020000
NULL NULL NULL 70595.250000
NULL NULL NULL 68764.000000
NULL NULL NULL 66378.020000
NULL NULL NULL 60710.700000
NULL NULL NULL 59559.860000
NULL NULL NULL 56336.190000
NULL NULL NULL 53129.160000
NULL NULL NULL 51239.440000
NULL NULL NULL 50790.560000
NULL NULL NULL 49809.520000
NULL NULL NULL 39928.110000
NULL NULL NULL 37660.850000
NULL NULL NULL 35837.020000
NULL NULL NULL 35221.510000
NULL NULL NULL 33490.570000
NULL NULL NULL 32591.640000
NULL NULL NULL 30177.050000
NULL NULL NULL 29118.170000
NULL NULL NULL 28303.130000
NULL NULL NULL 26876.620000
NULL NULL NULL 26831.140000
NULL NULL NULL 25872.660000
NULL NULL NULL 24616.040000
NULL NULL NULL 16314.050000
NULL NULL NULL 11312.690000
NULL NULL NULL 9014.680000
NULL NULL NULL 7503.460000
NULL NULL NULL 3871.100000
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL NULL NULL
NULL NULL F 349989.590000
NULL NULL F 335735.690000
NULL NULL F 334041.320000
NULL NULL F 331669.090000
NULL NULL F 324398.570000
NULL NULL F 317411.930000
NULL NULL F 310895.320000
NULL NULL F 307954.380000
NULL NULL F 307926.950000
NULL NULL F 307456.010000
NULL NULL F 301166.380000
NULL NULL F 299823.740000
NULL NULL F 297072.030000
NULL NULL F 290385.740000
NULL NULL F 287405.920000
NULL NULL F 286773.610000
NULL NULL F 283529.640000
NULL NULL F 282014.470000
NULL NULL F 280603.770000
NULL NULL F 280405.880000
NULL NULL F 277061.220000
NULL NULL F 275521.330000
NULL NULL F 275281.660000
NULL NULL F 274822.480000
NULL NULL F 274538.860000
NULL NULL F 271586.860000
NULL NULL F 271217.930000
NULL NULL F 267185.150000
NULL NULL F 265957.830000
NULL NULL F 265607.080000
NULL NULL F 264533.250000
NULL NULL F 262449.110000
NULL NULL F 261300.360000
NULL NULL F 261050.210000
NULL NULL F 261039.730000
NULL NULL F 260351.140000
NULL NULL F 259840.310000
NULL NULL F 259657.840000
NULL NULL F 259404.300000
NULL NULL F 259087.990000
NULL NULL F 258684.610000
NULL NULL F 258579.980000
NULL NULL F 255602.240000
NULL NULL F 254618.410000
NULL NULL F 254548.570000
NULL NULL F 251805.990000
NULL NULL F 251406.480000
NULL NULL F 249275.230000
NULL NULL F 248725.100000
NULL NULL F 247746.980000
NULL NULL F 245039.860000
NULL NULL F 243023.190000
NULL NULL F 242643.430000
NULL NULL F 240655.790000
NULL NULL F 237034.940000
NULL NULL F 236460.550000
NULL NULL F 235617.950000
NULL NULL F 234010.760000
NULL NULL F 233966.350000
NULL NULL F 232113.320000
NULL NULL F 231373.450000
NULL NULL F 230457.040000
NULL NULL F 230024.970000
NULL NULL F 229414.590000
NULL NULL F 229288.880000
NULL NULL F 227618.780000
NULL NULL F 226055.660000
NULL NULL F 224525.850000
NULL NULL F 224312.920000
NULL NULL F 221370.780000
NULL NULL F 220339.470000
NULL NULL F 218914.010000
NULL NULL F 217495.070000
NULL NULL F 216985.390000
NULL NULL F 216810.390000
NULL NULL F 215663.160000
NULL NULL F 213374.730000
NULL NULL F 212335.410000
NULL NULL F 210283.090000
NULL NULL F 210208.890000
NULL NULL F 209585.840000
NULL NULL F 208296.890000
NULL NULL F 206582.090000
NULL NULL F 205314.640000
NULL NULL F 204582.020000
NULL NULL F 203543.550000
NULL NULL F 203411.630000
NULL NULL F 201576.660000
NULL NULL F 201176.510000
NULL NULL F 200947.270000
NULL NULL F 200545.740000
NULL NULL F 199261.930000
NULL NULL F 198914.570000
NULL NULL F 197486.590000
NULL NULL F 197033.240000
NULL NULL F 195414.010000
NULL NULL F 194761.080000
NULL NULL F 192862.200000
NULL NULL F 192520.790000
NULL NULL F 192441.180000
NULL NULL F 192381.000000
NULL NULL F 191444.080000
NULL NULL F 190905.510000
NULL NULL F 190592.950000
NULL NULL F 190482.600000
NULL NULL F 190126.760000
NULL NULL F 189290.690000
NULL NULL F 189280.540000
NULL NULL F 189039.370000
NULL NULL F 188680.090000
NULL NULL F 188324.420000
NULL NULL F 186916.290000
NULL NULL F 185390.890000
NULL NULL F 184643.070000
NULL NULL F 184613.750000
NULL NULL F 184004.000000
NULL NULL F 183526.660000
NULL NULL F 182684.960000
NULL NULL F 182121.850000
NULL NULL F 181182.020000
NULL NULL F 180412.050000
NULL NULL F 180382.950000
NULL NULL F 179741.160000
NULL NULL F 177448.830000
NULL NULL F 175911.010000
NULL NULL F 174955.380000
NULL NULL F 174222.720000
NULL NULL F 174106.780000
NULL NULL F 172746.640000
NULL NULL F 171924.730000
NULL NULL F 170743.710000
NULL NULL F 167759.370000
NULL NULL F 167610.730000
NULL NULL F 165444.940000
NULL NULL F 164345.780000
NULL NULL F 164210.980000
NULL NULL F 163944.310000
NULL NULL F 163621.130000
NULL NULL F 163139.720000
NULL NULL F 162738.140000
NULL NULL F 162711.120000
NULL NULL F 161834.180000
NULL NULL F 159414.900000
NULL NULL F 158465.110000
NULL NULL F 158152.500000
NULL NULL F 157920.790000
NULL NULL F 156943.760000
NULL NULL F 156784.600000
NULL NULL F 156284.740000
NULL NULL F 154704.520000
NULL NULL F 154168.110000
NULL NULL F 153286.520000
NULL NULL F 152816.280000
NULL NULL F 151336.470000
NULL NULL F 150115.300000
NULL NULL F 149905.600000
NULL NULL F 148433.120000
NULL NULL F 148101.930000
NULL NULL F 147915.500000
NULL NULL F 147468.300000
NULL NULL F 147137.150000
NULL NULL F 146549.030000
NULL NULL F 146314.600000
NULL NULL F 145156.930000
NULL NULL F 144953.970000
NULL NULL F 144682.770000
NULL NULL F 144609.160000
NULL NULL F 143556.160000
NULL NULL F 143512.900000
NULL NULL F 143497.600000
NULL NULL F 142891.770000
NULL NULL F 141951.070000
NULL NULL F 140798.730000
NULL NULL F 137584.680000
NULL NULL F 137271.360000
NULL NULL F 137213.650000
NULL NULL F 136725.440000
NULL NULL F 136031.060000
NULL NULL F 136029.040000
NULL NULL F 135615.450000
query IIII
select o_orderkey, o_clerk, o_orderstatus, o_totalprice from orders_small
order by o_orderkey NULLS FIRST,
o_clerk NULLS FIRST, o_orderstatus NULLS FIRST,
o_totalprice DESC NULLS LAST limit 10 offset 440
----
NULL NULL F 74729.940000
NULL NULL F 73548.220000
NULL NULL F 71831.320000
NULL NULL F 71567.380000
NULL NULL F 71439.220000
NULL NULL F 71204.140000
NULL NULL F 71112.310000
NULL NULL F 71109.080000
NULL NULL F 70261.720000
NULL NULL F 68763.210000