# LogicTest: local

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

query T
EXPLAIN SELECT DISTINCT y, z FROM xyz
----
distribution: local
vectorized: true
·
• distinct
│ distinct on: y, z
│ order key: y, z
│
└── • scan
      missing stats
      table: xyz@foo
      spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY z
----
distribution: local
vectorized: true
·
• distinct
│ distinct on: y, z
│ order key: y, z
│
└── • scan
      missing stats
      table: xyz@foo
      spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY y
----
distribution: local
vectorized: true
·
• sort
│ order: +y
│
└── • distinct
    │ distinct on: y, z
    │ order key: y, z
    │
    └── • scan
          missing stats
          table: xyz@foo
          spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y, z FROM xyz ORDER BY y, z
----
distribution: local
vectorized: true
·
• sort
│ order: +y,+z
│
└── • distinct
    │ distinct on: y, z
    │ order key: y, z
    │
    └── • scan
          missing stats
          table: xyz@foo
          spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y + z AS r FROM xyz ORDER BY y + z
----
distribution: local
vectorized: true
·
• distinct
│ distinct on: r
│ order key: r
│
└── • sort
    │ order: +r
    │
    └── • render
        │
        └── • scan
              missing stats
              table: xyz@xyz_pkey
              spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y AS w, z FROM xyz ORDER BY z
----
distribution: local
vectorized: true
·
• distinct
│ distinct on: y, z
│ order key: y, z
│
└── • scan
      missing stats
      table: xyz@foo
      spans: FULL SCAN

query T
EXPLAIN SELECT DISTINCT y AS w FROM xyz ORDER BY y
----
distribution: local
vectorized: true
·
• sort
│ order: +y
│
└── • distinct
    │ distinct on: y
    │
    └── • scan
          missing stats
          table: xyz@xyz_pkey
          spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT DISTINCT x FROM xyz
----
distribution: local
vectorized: true
·
• scan
  columns: (x)
  estimated row count: 1,000 (missing stats)
  table: xyz@xyz_pkey
  spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT DISTINCT x, y, z FROM xyz
----
distribution: local
vectorized: true
·
• scan
  columns: (x, y, z)
  estimated row count: 1,000 (missing stats)
  table: xyz@xyz_pkey
  spans: FULL SCAN

# Test the case when the DistinctOn operator is projecting away a column.
query T
EXPLAIN (VERBOSE) SELECT DISTINCT z FROM (SELECT y, z FROM xyz WHERE y > 1)
----
distribution: local
vectorized: true
·
• distinct
│ columns: (z)
│ estimated row count: 98 (missing stats)
│ distinct on: z
│ order key: z
│
└── • project
    │ columns: (z)
    │ ordering: +z
    │
    └── • filter
        │ columns: (y, z)
        │ ordering: +z
        │ estimated row count: 333 (missing stats)
        │ filter: y > 1
        │
        └── • scan
              columns: (y, z)
              ordering: +z
              estimated row count: 1,000 (missing stats)
              table: xyz@foo
              spans: FULL SCAN

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 T
EXPLAIN (VERBOSE) SELECT DISTINCT 1 AS z, d, b FROM abcd ORDER BY d, b
----
distribution: local
vectorized: true
·
• render
│ columns: (z, d, b)
│ ordering: +d,+b
│ render z: 1
│ render b: b
│ render d: d
│
└── • scan
      columns: (b, d)
      ordering: +d,+b
      estimated row count: 1,000 (missing stats)
      table: abcd@abcd_d_b_key
      spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT DISTINCT a, b FROM abcd
----
distribution: local
vectorized: true
·
• distinct
│ columns: (a, b)
│ estimated row count: 1,000 (missing stats)
│ distinct on: a, b
│ order key: a, b
│
└── • scan
      columns: (a, b)
      ordering: +a,+b
      estimated row count: 1,000 (missing stats)
      table: abcd@abcd_pkey
      spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT DISTINCT a, b, c FROM abcd
----
distribution: local
vectorized: true
·
• scan
  columns: (a, b, c)
  estimated row count: 1,000 (missing stats)
  table: abcd@abcd_pkey
  spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT DISTINCT a, b, c, d FROM abcd
----
distribution: local
vectorized: true
·
• scan
  columns: (a, b, c, d)
  estimated row count: 1,000 (missing stats)
  table: abcd@abcd_pkey
  spans: FULL SCAN

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

query T
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv
----
distribution: local
vectorized: true
·
• distinct
│ columns: (v)
│ estimated row count: 991 (missing stats)
│ distinct on: v
│ order key: v
│
└── • scan
      columns: (v)
      ordering: +v
      estimated row count: 1,000 (missing stats)
      table: kv@idx
      spans: FULL SCAN

# Verify we don't incorrectly elide the distinct node when we only have a weak key (#19343).
query T
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv@idx
----
distribution: local
vectorized: true
·
• distinct
│ columns: (v)
│ estimated row count: 991 (missing stats)
│ distinct on: v
│ order key: v
│
└── • scan
      columns: (v)
      ordering: +v
      estimated row count: 1,000 (missing stats)
      table: kv@idx
      spans: FULL SCAN

# Here we can infer that v is not-NULL so eliding the node is correct.
query T
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv@idx WHERE v > 0
----
distribution: local
vectorized: true
·
• scan
  columns: (v)
  estimated row count: 330 (missing stats)
  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 T
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv2@idx
----
distribution: local
vectorized: true
·
• scan
  columns: (v)
  estimated row count: 1,000 (missing stats)
  table: kv2@idx
  spans: FULL SCAN
