# LogicTest: local

query TTTTT
EXPLAIN (VERBOSE,NOOPTIMIZE) SELECT 1 a FROM (SELECT 2 AS s)
----
render              ·         ·  (a)  a=CONST
 │                  render 0  1  ·    ·
 └── render         ·         ·  (s)  s=CONST
      │             render 0  2  ·    ·
      └── emptyrow  ·         ·  ()   ·

# Propagation to data sources.
query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM (SELECT 2 AS s)
----
render              ·         ·     (a)           a=CONST
 │                  render 0  1     ·             ·
 └── render         ·         ·     (s[omitted])  ·
      │             render 0  NULL  ·             ·
      └── emptyrow  ·         ·     ()            ·

# Propagation through CREATE TABLE.
query TTTTT
EXPLAIN (VERBOSE) CREATE TABLE t AS SELECT 1 a FROM (SELECT 2 AS s)
----
create table             ·         ·     ()            ·
 └── render              ·         ·     (a)           a=CONST
      │                  render 0  1     ·             ·
      └── render         ·         ·     (s[omitted])  ·
           │             render 0  NULL  ·             ·
           └── emptyrow  ·         ·     ()            ·

# Propagation through LIMIT.
query TTTTT
EXPLAIN (VERBOSE) SELECT 1 b FROM (SELECT 2 AS s) LIMIT 1
----
limit                    ·         ·     (b)           b=CONST
 │                       count     1     ·             ·
 └── render              ·         ·     (b)           b=CONST
      │                  render 0  1     ·             ·
      └── render         ·         ·     (s[omitted])  ·
           │             render 0  NULL  ·             ·
           └── emptyrow  ·         ·     ()            ·

query TTTTT
EXPLAIN (VERBOSE) SELECT 1 b FROM (SELECT 2 AS s LIMIT 1)
----
render                   ·         ·     (b)           b=CONST
 │                       render 0  1     ·             ·
 └── limit               ·         ·     (s[omitted])  ·
      │                  count     1     ·             ·
      └── render         ·         ·     (s[omitted])  ·
           │             render 0  NULL  ·             ·
           └── emptyrow  ·         ·     ()            ·

# Propagation through UNION.
query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM (SELECT 1 AS s UNION SELECT 2 AS s)
----
render                   ·         ·  (a)  a=CONST
 │                       render 0  1  ·    ·
 └── union               ·         ·  (s)  ·
      ├── render         ·         ·  (s)  s=CONST
      │    │             render 0  2  ·    ·
      │    └── emptyrow  ·         ·  ()   ·
      └── render         ·         ·  (s)  s=CONST
           │             render 0  1  ·    ·
           └── emptyrow  ·         ·  ()   ·

query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM (SELECT 1 AS s UNION ALL SELECT 2 AS s)
----
render                   ·         ·     (a)           a=CONST
 │                       render 0  1     ·             ·
 └── append              ·         ·     (s[omitted])  ·
      ├── render         ·         ·     (s[omitted])  ·
      │    │             render 0  NULL  ·             ·
      │    └── emptyrow  ·         ·     ()            ·
      └── render         ·         ·     (s[omitted])  ·
           │             render 0  NULL  ·             ·
           └── emptyrow  ·         ·     ()            ·

# Propagation through WITH ORDINALITY.
query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM (SELECT 1 AS s) WITH ORDINALITY
----
render                   ·         ·     (a)                         a=CONST
 │                       render 0  1     ·                           ·
 └── ordinality          ·         ·     (s[omitted], "ordinality")  weak-key("ordinality")
      └── render         ·         ·     (s[omitted])                ·
           │             render 0  NULL  ·                           ·
           └── emptyrow  ·         ·     ()                          ·

# Propagation through sort, when the sorting column is in the results.
query TTTTT
EXPLAIN (VERBOSE) SELECT x FROM (SELECT 1 AS x, 2 AS y) ORDER BY x
----
render              ·         ·     (x)              x=CONST
 │                  render 0  x     ·                ·
 └── render         ·         ·     (x, y[omitted])  x=CONST
      │             render 0  1     ·                ·
      │             render 1  NULL  ·                ·
      └── emptyrow  ·         ·     ()               ·

# Propagation through sort, when the sorting column is not in the results.
query TTTTT
EXPLAIN (VERBOSE) SELECT x FROM (SELECT 1 AS x, 2 AS y, 3 AS z) ORDER BY y
----
nosort                   ·         ·     (x)                 x=CONST
 │                       order     +y    ·                   ·
 └── render              ·         ·     (x, y)              x=CONST; y=CONST
      │                  render 0  x     ·                   ·
      │                  render 1  y     ·                   ·
      └── render         ·         ·     (x, y, z[omitted])  x=CONST; y=CONST
           │             render 0  1     ·                   ·
           │             render 1  2     ·                   ·
           │             render 2  NULL  ·                   ·
           └── emptyrow  ·         ·     ()                  ·

# Propagation to sub-queries.
query TTTTT
EXPLAIN (VERBOSE) SELECT 1 = (SELECT 2 AS x FROM (SELECT 3 AS s)) AS y
----
root                                    ·             ·                                     (y)           y=CONST
 ├── render                             ·             ·                                     (y)           y=CONST
 │    │                                 render 0      @S1 = 1                               ·             ·
 │    └── emptyrow                      ·             ·                                     ()            ·
 └── subquery                           ·             ·                                     (y)           y=CONST
      │                                 id            @S1                                   ·             ·
      │                                 original sql  (SELECT 2 AS x FROM (SELECT 3 AS s))  ·             ·
      │                                 exec mode     one row                               ·             ·
      └── max1row                       ·             ·                                     (x)           x=CONST
           └── limit                    ·             ·                                     (x)           x=CONST
                │                       count         2                                     ·             ·
                └── render              ·             ·                                     (x)           x=CONST
                     │                  render 0      2                                     ·             ·
                     └── render         ·             ·                                     (s[omitted])  ·
                          │             render 0      NULL                                  ·             ·
                          └── emptyrow  ·             ·                                     ()            ·

# Propagation through table scans.
statement ok
CREATE TABLE kv(k INT PRIMARY KEY, v INT)

query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM kv
----
render     ·         ·           (a)                       a=CONST
 │         render 0  1           ·                         ·
 └── scan  ·         ·           (k[omitted], v[omitted])  k!=NULL; key(k)
·          table     kv@primary  ·                         ·
·          spans     ALL         ·                         ·

# Propagation through DISTINCT.
query TTTTT
EXPLAIN (VERBOSE) SELECT DISTINCT v FROM kv
----
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               ·                ·

# Propagation through INSERT.
query TTTTT
EXPLAIN (VERBOSE) INSERT INTO kv(k, v) SELECT 1 AS a, 2 AS b FROM (SELECT 3 AS x, 4 AS y)
----
count                         ·         ·         ()                        ·
 └── insert                   ·         ·         ()                        ·
      │                       into      kv(k, v)  ·                         ·
      │                       strategy  inserter  ·                         ·
      └── render              ·         ·         (a, b)                    a=CONST; b=CONST
           │                  render 0  1         ·                         ·
           │                  render 1  2         ·                         ·
           └── render         ·         ·         (x[omitted], y[omitted])  ·
                │             render 0  NULL      ·                         ·
                │             render 1  NULL      ·                         ·
                └── emptyrow  ·         ·         ()                        ·

# Propagation through DELETE.
query TTTTT
EXPLAIN (VERBOSE) DELETE FROM kv WHERE k = 3
----
count              ·      ·        ()  ·
 └── delete range  ·      ·        ()  ·
·                  from   kv       ·   ·
·                  spans  /3-/3/#  ·   ·

# Ensure that propagations through a render node removes the renders
# and properly propagates the remaining needed columns.
query TTTTT
EXPLAIN (VERBOSE) SELECT x FROM (SELECT 1 AS x, y FROM (SELECT 2 AS y))
----
render                   ·         ·     (x)              x=CONST
 │                       render 0  x     ·                ·
 └── render              ·         ·     (x, y[omitted])  x=CONST
      │                  render 0  1     ·                ·
      │                  render 1  NULL  ·                ·
      └── render         ·         ·     (y[omitted])     ·
           │             render 0  NULL  ·                ·
           └── emptyrow  ·         ·     ()               ·

query TTTTT
EXPLAIN (VERBOSE) SELECT 1 a FROM (SELECT k+1 AS x, v-2 AS y FROM kv)
----
render     ·         ·           (a)                       a=CONST
 │         render 0  1           ·                         ·
 └── scan  ·         ·           (k[omitted], v[omitted])  k!=NULL; key(k)
·          table     kv@primary  ·                         ·
·          spans     ALL         ·                         ·

statement ok
CREATE TABLE a ("name" string, age int);

query TTTTT
EXPLAIN (VERBOSE) SELECT count(*) FROM (SELECT "name", age FROM a);
----
group                ·            ·             (count)                                               ·
 │                   aggregate 0  count_rows()  ·                                                     ·
 │                   scalar       ·             ·                                                     ·
 └── render          ·            ·             ()                                                    ·
      └── render     ·            ·             (name[omitted], age[omitted])                         ·
           │         render 0     NULL          ·                                                     ·
           │         render 1     NULL          ·                                                     ·
           └── scan  ·            ·             (name[omitted], age[omitted], rowid[hidden,omitted])  rowid!=NULL; key(rowid)
·                    table        a@primary     ·                                                     ·
·                    spans        ALL           ·                                                     ·

# Ensure that variables within filter conditions are omitted (not decoded) if
# the filter condition is replaced by an index search.

statement ok
CREATE TABLE ab (a INT, b INT, PRIMARY KEY (a, b));

query TTTTT
EXPLAIN (VERBOSE) SELECT count(*) FROM ab WHERE a=1
----
group           ·            ·             (count)                   ·
 │              aggregate 0  count_rows()  ·                         ·
 │              scalar       ·             ·                         ·
 └── render     ·            ·             ()                        ·
      └── scan  ·            ·             (a[omitted], b[omitted])  a=CONST; b!=NULL; key(b)
·               table        ab@primary    ·                         ·
·               spans        /1-/2         ·                         ·
