# LogicTest: local

statement ok
CREATE TABLE xyz (
  x INT PRIMARY KEY,
  y INT,
  z INT,
  INDEX foo (z, y)
)

# TODO(vivek): Use the secondary index. Use distinct in index selection.
query TTT
EXPLAIN SELECT DISTINCT y, z FROM xyz
----
distinct        ·      ·
 └── render     ·      ·
      └── scan  ·      ·
·               table  xyz@primary
·               spans  ALL

query TTT
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY z
----
distinct        ·          ·
 │              order key  y, z
 └── render     ·          ·
      └── scan  ·          ·
·               table      xyz@foo
·               spans      ALL

query TTT
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY y
----
distinct             ·          ·
 │                   order key  y
 └── sort            ·          ·
      │              order      +y
      └── render     ·          ·
           └── scan  ·          ·
·                    table      xyz@foo
·                    spans      ALL

query TTT
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY y, z
----
distinct             ·          ·
 │                   order key  y, z
 └── sort            ·          ·
      │              order      +y,+z
      └── render     ·          ·
           └── scan  ·          ·
·                    table      xyz@foo
·                    spans      ALL

query TTT
EXPLAIN SELECT DISTINCT y + z AS a FROM xyz ORDER BY a
----
distinct             ·          ·
 │                   order key  a
 └── sort            ·          ·
      │              order      +a
      └── render     ·          ·
           └── scan  ·          ·
·                    table      xyz@primary
·                    spans      ALL

query TTT
EXPLAIN SELECT DISTINCT y AS w FROM xyz ORDER BY z
----
distinct             ·      ·
 └── nosort          ·      ·
      │              order  +z
      └── render     ·      ·
           └── scan  ·      ·
·                    table  xyz@foo
·                    spans  ALL

query TTT
EXPLAIN SELECT DISTINCT y AS w FROM xyz ORDER BY y
----
distinct             ·          ·
 │                   order key  w
 └── sort            ·          ·
      │              order      +w
      └── render     ·          ·
           └── scan  ·          ·
·                    table      xyz@foo
·                    spans      ALL

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT x FROM xyz
----
render     ·         ·                  (x)                          x!=NULL; key(x)
 │         render 0  test.public.xyz.x  ·                            ·
 └── scan  ·         ·                  (x, y[omitted], z[omitted])  x!=NULL; key(x)
·          table     xyz@primary        ·                            ·
·          spans     ALL                ·                            ·

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT x, y, z FROM xyz
----
scan  ·      ·            (x, y, z)  x!=NULL; key(x)
·     table  xyz@primary  ·          ·
·     spans  ALL          ·          ·

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

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT 1 AS x, d, b FROM abcd ORDER BY d, b
----
render     ·         ·                   (x, d, b)                       x=CONST; d!=NULL; b!=NULL; key(d,b); +d,+b
 │         render 0  1                   ·                               ·
 │         render 1  test.public.abcd.d  ·                               ·
 │         render 2  test.public.abcd.b  ·                               ·
 └── scan  ·         ·                   (a[omitted], b, c[omitted], d)  b!=NULL; d!=NULL; key(b,d); +d,+b
·          table     abcd@abcd_d_b_key   ·                               ·
·          spans     ALL                 ·                               ·

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT a, b FROM abcd
----
distinct        ·          ·                   (a, b)                          a!=NULL; b!=NULL; key(a,b); +a,+b
 │              order key  a, b                ·                               ·
 └── render     ·          ·                   (a, b)                          a!=NULL; b!=NULL; +a,+b
      │         render 0   test.public.abcd.a  ·                               ·
      │         render 1   test.public.abcd.b  ·                               ·
      └── scan  ·          ·                   (a, b, c[omitted], d[omitted])  a!=NULL; b!=NULL; c!=NULL; key(a,b,c); +a,+b
·               table      abcd@primary        ·                               ·
·               spans      ALL                 ·                               ·

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT a, b, c FROM abcd
----
render     ·         ·                   (a, b, c)              a!=NULL; b!=NULL; c!=NULL; key(a,b,c)
 │         render 0  test.public.abcd.a  ·                      ·
 │         render 1  test.public.abcd.b  ·                      ·
 │         render 2  test.public.abcd.c  ·                      ·
 └── scan  ·         ·                   (a, b, c, d[omitted])  a!=NULL; b!=NULL; c!=NULL; key(a,b,c)
·          table     abcd@primary        ·                      ·
·          spans     ALL                 ·                      ·

query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT a, b, c, d FROM abcd
----
scan  ·      ·             (a, b, c, d)  a!=NULL; b!=NULL; c!=NULL; key(a,b,c)
·     table  abcd@primary  ·             ·
·     spans  ALL           ·             ·

statement ok
CREATE TABLE kv (k INT PRIMARY KEY, v INT, UNIQUE INDEX idx(v))

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv
----
tree            field     description       columns          ordering
distinct        ·         ·                 (v)              weak-key(v)
 └── render     ·         ·                 (v)              ·
      │         render 0  test.public.kv.v  ·                ·
      └── scan  ·         ·                 (k[omitted], v)  k!=NULL; key(k)
·               table     kv@primary        ·                ·
·               spans     ALL               ·                ·

# Verify we don't incorrectly elide the distinct node when we only have a weak key (#19343).
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv@idx
----
tree            field      description       columns          ordering
distinct        ·          ·                 (v)              weak-key(v); +v
 │              order key  v                 ·                ·
 └── render     ·          ·                 (v)              weak-key(v); +v
      │         render 0   test.public.kv.v  ·                ·
      └── scan  ·          ·                 (k[omitted], v)  weak-key(v); +v
·               table      kv@idx            ·                ·
·               spans      ALL               ·                ·

# Here we can infer that v is not-NULL so eliding the node is correct.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv@idx WHERE v > 0
----
tree       field     description       columns          ordering
render     ·         ·                 (v)              v!=NULL; key(v)
 │         render 0  test.public.kv.v  ·                ·
 └── scan  ·         ·                 (k[omitted], v)  v!=NULL; key(v)
·          table     kv@idx            ·                ·
·          spans     /1-               ·                ·

statement ok
CREATE TABLE kv2 (k INT PRIMARY KEY, v INT NOT NULL, UNIQUE INDEX idx(v))

# In this case it is correct to elide the distinct node.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv2@idx
----
tree       field     description        columns          ordering
render     ·         ·                  (v)              v!=NULL; key(v)
 │         render 0  test.public.kv2.v  ·                ·
 └── scan  ·         ·                  (k[omitted], v)  v!=NULL; key(v)
·          table     kv2@idx            ·                ·
·          spans     ALL                ·                ·
