# LogicTest: default parallel-stmts distsql

statement ok
CREATE TABLE t (
  a INT PRIMARY KEY,
  b INT,
  c BOOLEAN
)

statement ok
INSERT INTO t VALUES (1, 9, true), (2, 8, false), (3, 7, NULL)

query B
SELECT c FROM t ORDER BY c
----
NULL
false
true

# The following test ensures that the "rowsort" directive
# in TestLogic does its work properly.
query B rowsort
SELECT c FROM t ORDER BY c
----
false
NULL
true

query B
SELECT c FROM t ORDER BY c DESC
----
true
false
NULL

query II
SELECT a, b FROM t ORDER BY b
----
3 7
2 8
1 9

query ITTT
EXPLAIN SELECT a, b FROM t ORDER BY b
----
0  sort
0        order  +b
1  render
2  scan
2        table  t@primary
2        spans  ALL

query II
SELECT a, b FROM t ORDER BY b DESC
----
1 9
2 8
3 7

query ITTT
EXPLAIN SELECT a, b FROM t ORDER BY b DESC
----
0  sort
0        order  -b
1  render
2  scan
2        table  t@primary
2        spans  ALL

query I
SELECT a FROM t ORDER BY 1 DESC
----
3
2
1

query ITTT
EXPLAIN SELECT a, b FROM t ORDER BY b LIMIT 2
----
0  limit
1  sort
1         order     +b
1         strategy  top 2
2  render
3  scan
3         table     t@primary
3         spans     ALL

query II
SELECT a, b FROM t ORDER BY b DESC LIMIT 2
----
1 9
2 8

query ITTT
EXPLAIN SELECT DISTINCT a FROM t ORDER BY b LIMIT 2
----
0  limit
1  distinct
2  sort
2            order     +b
2            strategy  iterative
3  render
4  scan
4            table     t@primary
4            spans     ALL

query I
SELECT DISTINCT a FROM t ORDER BY b DESC LIMIT 2
----
1
2

query II
SELECT a AS foo, b FROM t ORDER BY foo DESC
----
3 7
2 8
1 9

# Check that ambiguous references to renders are properly reported.
query error ORDER BY "foo" is ambiguous
SELECT a AS foo, b AS foo FROM t ORDER BY foo

# Check that no ambiguity is reported if the ORDER BY name refers
# to two or more equivalent renders (special case in SQL92).
query II
SELECT a AS foo, (a) AS foo FROM t ORDER BY foo LIMIT 1
----
1 1

query II
SELECT a AS "foo.bar", b FROM t ORDER BY "foo.bar" DESC
----
3 7
2 8
1 9

query II
SELECT a AS foo, b FROM t ORDER BY a DESC
----
3 7
2 8
1 9

query I
SELECT b FROM t ORDER BY a DESC
----
7
8
9

query ITTT
EXPLAIN SELECT b FROM t ORDER BY a DESC
----
0  nosort
0           order  -a
1  render
2  revscan
2           table  t@primary
2           spans  ALL

# Check that LIMIT propagates past nosort nodes.
query ITTT
EXPLAIN SELECT b FROM t ORDER BY a LIMIT 1
----
0  limit
1  nosort
1          order  +a
2  render
3  scan
3          table  t@primary
3          spans  ALL
3          limit  1

query ITTT
EXPLAIN SELECT b FROM t ORDER BY a DESC, b ASC
----
0  nosort
0           order  -a,+b
1  render
2  revscan
2           table  t@primary
2           spans  ALL

query ITTT
EXPLAIN SELECT b FROM t ORDER BY a DESC, b DESC
----
0  nosort
0           order  -a,-b
1  render
2  revscan
2           table  t@primary
2           spans  ALL

statement ok
INSERT INTO t VALUES (4, 7), (5, 7)

query II
SELECT a, b FROM t WHERE b = 7 ORDER BY b, a
----
3 7
4 7
5 7

query II
SELECT a, b FROM t ORDER BY b, a DESC
----
5 7
4 7
3 7
2 8
1 9

query III
SELECT a, b, a+b AS ab FROM t WHERE b = 7 ORDER BY ab DESC, a
----
5 7 12
4 7 11
3 7 10

query I
SELECT a FROM t ORDER BY a+b DESC, a
----
5
4
1
2
3

query I
SELECT a FROM t ORDER BY (((a)))
----
1
2
3
4
5

query I
(((SELECT a FROM t))) ORDER BY a DESC LIMIT 4
----
5
4
3
2

query I
(((SELECT a FROM t ORDER BY a DESC LIMIT 4)))
----
5
4
3
2

query error multiple ORDER BY clauses not allowed
((SELECT a FROM t ORDER BY a)) ORDER BY a

query error expected c to be of type int, found type bool
SELECT CASE a WHEN 1 THEN b ELSE c END as val FROM t ORDER BY val

query error ORDER BY position 0 is not in select list
SELECT * FROM t ORDER BY 0

query error non-integer constant in ORDER BY: true
SELECT * FROM t ORDER BY true

query error non-integer constant in ORDER BY: 'a'
SELECT * FROM t ORDER BY 'a'

query error non-integer constant in ORDER BY: 2\.5
SELECT * FROM t ORDER BY 2.5

query error column name "foo" not found
SELECT * FROM t ORDER BY foo

query error source name "a" not found in FROM clause
SELECT a FROM t ORDER BY a.b

# Check that sort is skipped if the ORDER BY clause is constant.
query ITTT
EXPLAIN SELECT * FROM t ORDER BY 1+2
----
0  nosort
0          order  +"1 + 2"
1  render
2  scan
2          table  t@primary
2          spans  ALL

query ITTT
EXPLAIN SELECT 1, * FROM t ORDER BY 1
----
0  render
1  scan
1          table  t@primary
1          spans  ALL

query ITTT
EXPLAIN SELECT * FROM t ORDER BY length('abc')
----
0  nosort
0          order  +"length('abc')"
1  render
2  scan
2          table  t@primary
2          spans  ALL

# Check that the sort key reuses the existing render.
query ITTTTT
EXPLAIN (METADATA) SELECT b+2 FROM t ORDER BY b+2
----
0  sort                      ("b + 2")                    +"b + 2"
0          order  +"b + 2"
1  render                    ("b + 2")
2  scan                      (a[omitted], b, c[omitted])
2          table  t@primary
2          spans  ALL

# Check that the sort picks up a renamed render properly.
query ITTTTT
EXPLAIN (METADATA) SELECT b+2 AS y FROM t ORDER BY y
----
0  sort                      (y)                          +y
0          order  +y
1  render                    (y)
2  scan                      (a[omitted], b, c[omitted])
2          table  t@primary
2          spans  ALL

# Check that the sort reuses a render behind a rename properly.
query ITTTTT
EXPLAIN (METADATA) SELECT b+2 AS y FROM t ORDER BY b+2
----
0  sort                      (y)                          +y
0          order  +y
1  render                    (y)
2  scan                      (a[omitted], b, c[omitted])
2          table  t@primary
2          spans  ALL

statement ok
CREATE TABLE abc (
  a INT,
  b INT,
  c INT,
  d CHAR,
  PRIMARY KEY (a, b, c),
  UNIQUE INDEX bc (b, c),
  INDEX ba (b, a),
  FAMILY (a, b, c),
  FAMILY (d)
)

statement ok
INSERT INTO abc VALUES (1, 2, 3, 'one'), (4, 5, 6, 'Two')

query T
SELECT d FROM abc ORDER BY LOWER(d)
----
one
Two

query ITTT
EXPLAIN (DEBUG) SELECT * FROM abc ORDER BY a
----
0 /abc/primary/1/2/3   NULL  PARTIAL
0 /abc/primary/1/2/3/d 'one' ROW
1 /abc/primary/4/5/6   NULL  PARTIAL
1 /abc/primary/4/5/6/d 'Two' ROW

query ITTT
EXPLAIN SELECT * FROM abc ORDER BY a
----
0  scan
0        table  abc@primary
0        spans  ALL

query ITTT
EXPLAIN (DEBUG) SELECT a, b FROM abc ORDER BY b, a
----
0 /abc/ba/2/1/3 NULL ROW
1 /abc/ba/5/4/6 NULL ROW

query ITTT
EXPLAIN SELECT a, b FROM abc ORDER BY b, a
----
0  render
1  scan
1        table  abc@ba
1        spans  ALL

# The non-unique index ba includes column c (required to make the keys unique)
# so the results will already be sorted.
query ITTT
EXPLAIN SELECT a, b, c FROM abc ORDER BY b, a, c
----
0  render
1  scan
1        table  abc@ba
1        spans  ALL

# We use the WHERE condition to force the use of index ba.
query ITTT
EXPLAIN SELECT a, b, c FROM abc WHERE b > 10 ORDER BY b, a, d
----
0  sort
0              order  +b,+a,+d
1  index-join
2  scan
2              table  abc@ba
2              spans  /11-
2  scan
2              table  abc@primary

# We cannot have rows with identical values for a,b,c so we don't need to
# sort for d.
query ITTT
EXPLAIN SELECT a, b, c, d FROM abc WHERE b > 10 ORDER BY b, a, c, d
----
0  index-join
1  scan
1              table  abc@ba
1              spans  /11-
1  scan
1              table  abc@primary

query ITTT
EXPLAIN SELECT a, b FROM abc ORDER BY b, c
----
0  nosort
0          order  +b,+c
1  render
2  scan
2          table  abc@bc
2          spans  ALL

query ITTTTT
EXPLAIN (VERBOSE) SELECT a, b FROM abc ORDER BY b, c
----
0  nosort                        (a, b)                 +b
0          order     +b,+c
1  render                        (a, b, c)              +b,+c,unique
1          render 0  test.abc.a
1          render 1  test.abc.b
1          render 2  test.abc.c
2  scan                          (a, b, c, d[omitted])  +b,+c,unique
2          table     abc@bc
2          spans     ALL

query ITTT
EXPLAIN SELECT a, b FROM abc ORDER BY b, c, a
----
0  nosort
0          order  +b,+c,+a
1  render
2  scan
2          table  abc@bc
2          spans  ALL

query ITTT
EXPLAIN SELECT a, b FROM abc ORDER BY b, c, a DESC
----
0  nosort
0          order  +b,+c,-a
1  render
2  scan
2          table  abc@bc
2          spans  ALL

query ITTT
EXPLAIN (DEBUG) SELECT b, c FROM abc ORDER BY b, c
----
0 /abc/bc/2/3 /1 ROW
1 /abc/bc/5/6 /4 ROW

query ITTT
EXPLAIN (DEBUG) SELECT a, b, c FROM abc ORDER BY b
----
0 /abc/bc/2/3 /1 ROW
1 /abc/bc/5/6 /4 ROW

query ITTT
EXPLAIN (DEBUG) SELECT a FROM abc ORDER BY a DESC
----
0 /abc/primary/4/5/6/d 'Two' PARTIAL
0 /abc/primary/4/5/6   NULL  ROW
1 /abc/primary/1/2/3/d 'one' PARTIAL
1 /abc/primary/1/2/3   NULL  ROW

query ITTT
EXPLAIN SELECT a FROM abc ORDER BY a DESC
----
0  render
1  revscan
1           table  abc@primary
1           spans  ALL

query I
SELECT a FROM abc ORDER BY a DESC
----
4
1

query I
SELECT a FROM abc ORDER BY a DESC LIMIT 1
----
4

query I
SELECT a FROM abc ORDER BY a DESC OFFSET 1
----
1

query ITTT
EXPLAIN SELECT c FROM abc WHERE b = 2 ORDER BY c
----
0  render
1  scan
1        table  abc@bc
1        spans  /2-/3

query ITTT
EXPLAIN SELECT c FROM abc WHERE b = 2 ORDER BY c DESC
----
0  render
1  revscan
1           table  abc@bc
1           spans  /2-/3

# Verify that the ordering of the primary index is still used for the outer sort.
query ITTTTT
EXPLAIN (METADATA) SELECT * FROM (SELECT b, c FROM abc WHERE a=1 ORDER BY a,b) ORDER BY b,c
----
0  nosort                      (b, c)                 +b,+c
0          order  +a,+b
1  render                      (b, c, a)              =a,+b,+c,unique
2  scan                        (a, b, c, d[omitted])  =a,+b,+c,unique
2          table  abc@primary
2          spans  /1-/2

statement ok
CREATE TABLE bar (id INT PRIMARY KEY, baz STRING, UNIQUE INDEX i_bar (baz))

statement ok
INSERT INTO bar VALUES (0, NULL), (1, NULL)

query ITTTTT
EXPLAIN (METADATA) SELECT * FROM bar ORDER BY baz, id
----
0  scan                    (id, baz)  +baz,unique
0        table  bar@i_bar
0        spans  ALL

# Here rowsort is needed because the ORDER BY clause does not guarantee any
# relative ordering between rows where baz is NULL. As we see above, because
# this is a unique index, the ordering `+baz,+id` is deemed equivalent to just
# `+baz`.
query IT rowsort
SELECT * FROM bar ORDER BY baz, id
----
0 NULL
1 NULL

statement ok
CREATE TABLE abcd (
  a INT PRIMARY KEY,
  b INT,
  c INT,
  d INT,
  INDEX abc (a, b, c)
)

statement ok
INSERT INTO abcd VALUES (1, 4, 2, 3), (2, 3, 4, 1), (3, 2, 1, 2), (4, 4, 1, 1)

# The following tests verify we recognize that sorting is not necessary
query ITTT
EXPLAIN SELECT a, b, c FROM abcd@abc WHERE (a, b) = (1, 4) ORDER BY c
----
0  render
1  scan
1        table  abcd@abc
1        spans  /1/4-/1/5

query ITTT
EXPLAIN SELECT a, b, c FROM abcd@abc WHERE (a, b) = (1, 4) ORDER BY c, b, a
----
0  render
1  scan
1        table  abcd@abc
1        spans  /1/4-/1/5

query ITTT
EXPLAIN SELECT a, b, c FROM abcd@abc WHERE (a, b) = (1, 4) ORDER BY b, a, c
----
0  render
1  scan
1        table  abcd@abc
1        spans  /1/4-/1/5

query ITTT
EXPLAIN SELECT a, b, c FROM abcd@abc WHERE (a, b) = (1, 4) ORDER BY b, c, a
----
0  render
1  scan
1        table  abcd@abc
1        spans  /1/4-/1/5

statement ok
CREATE TABLE nan (id INT PRIMARY KEY, x REAL)

statement ok
INSERT INTO nan VALUES (1, 0/0), (2, -1), (3, 1), (4, 0/0)

query R
SELECT x FROM nan ORDER BY x
----
NaN
NaN
-1
1

query ITTTTT
EXPLAIN (METADATA) SELECT * FROM (SELECT * FROM (VALUES ('a'), ('b'), ('c')) AS c(x) ORDER BY x)
----
0  sort                             (x)        +x
0          order  +x
1  render                           (x)
2  values                           (column1)
2          size   1 column, 3 rows

query ITTT
EXPLAIN SELECT * FROM (VALUES ('a'), ('b'), ('c')) WITH ORDINALITY ORDER BY ordinality ASC
----
0  ordinality
1  values
1              size  1 column, 3 rows

query ITTT
EXPLAIN SELECT * FROM (VALUES ('a'), ('b'), ('c')) WITH ORDINALITY ORDER BY ordinality DESC
----
0  sort
0              order  -"ordinality"
1  ordinality
2  values
2              size   1 column, 3 rows

query ITTTTT
EXPLAIN (METADATA) SELECT * FROM (SELECT * FROM (VALUES ('a'), ('b'), ('c')) AS c(x)) WITH ORDINALITY
----
0  ordinality                          (x, "ordinality")  +"ordinality",unique
1  render                              (x)
2  values                              (column1)
2              size  1 column, 3 rows

query ITTTTT
EXPLAIN (METADATA) SELECT * FROM (SELECT * FROM (VALUES ('a'), ('b'), ('c')) AS c(x) ORDER BY x) WITH ORDINALITY
----
0  ordinality                           (x, "ordinality")  +x
1  sort                                 (x)                +x
1              order  +x
2  render                               (x)
3  values                               (column1)
3              size   1 column, 3 rows

# Check that the ordering of the source does not propagate blindly to RETURNING.
query ITTTTT
EXPLAIN (METADATA) INSERT INTO t(a, b) SELECT * FROM (SELECT 1 AS x, 2 AS y) ORDER BY x RETURNING b
----
0  insert                  (b)
0           into  t(a, b)
1  render                  (x, y)  =x,=y
2  nullrow                 ()

query ITTTTT
EXPLAIN (METADATA) DELETE FROM t WHERE a = 3 RETURNING b
----
0  delete                    (b)
0          from   t
1  scan                      (a, b, c)
1          table  t@primary
1          spans  /3-/4

query ITTTTT
EXPLAIN (METADATA) UPDATE t SET c = TRUE RETURNING b
----
0  update                    (b)
0          table  t
0          set    c
1  render                    (a, b, c, "true")  ="true"
2  scan                      (a, b, c)
2          table  t@primary
2          spans  ALL

statement ok
CREATE TABLE uvwxyz (
  u INT,
  v INT,
  w INT,
  x INT,
  y INT,
  z INT,
  INDEX ywxz (y, w, x, z, u, v),
  INDEX ywz (y, w, z, x)
)

# Verify that the outer ordering is propagated to index selection and we choose
# the index that avoids any sorting.
query ITTTTT
EXPLAIN (METADATA) SELECT * FROM (SELECT y, w, x FROM uvwxyz WHERE y = 1 ORDER BY w) ORDER BY w, x
----
0  render                      (y, w, x)                                                             =y,+w,+x
1  scan                        (u[omitted], v[omitted], w, x, y, z[omitted], rowid[hidden,omitted])  =y,+w,+x
1          table  uvwxyz@ywxz
1          spans  /1-/2


statement ok
CREATE TABLE blocks (
  block_id  INT,
  writer_id STRING,
  block_num INT,
  raw_bytes BYTES,
  PRIMARY KEY (block_id, writer_id, block_num)
)

# Test that ordering goes "through" a renderNode that has a duplicate render of
# an order-by column (#13696).
query ITTTTT
EXPLAIN (METADATA) SELECT block_id,writer_id,block_num,block_id FROM blocks ORDER BY block_id, writer_id, block_num LIMIT 1
----
0  limit                          (block_id, writer_id, block_num, block_id)            +block_id,+writer_id,+block_num,unique
1  render                         (block_id, writer_id, block_num, block_id)            +block_id,+writer_id,+block_num,unique
2  scan                           (block_id, writer_id, block_num, raw_bytes[omitted])  +block_id,+writer_id,+block_num,unique
2          table  blocks@primary
2          spans  ALL
2          limit  1
