# LogicTest: local

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

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE b = c
----
tree  field   description   columns       ordering
scan  ·       ·             (a, b, c, d)  b=c; a!=NULL; b!=NULL; c!=NULL; key(a)
·     table   abcd@primary  ·             ·
·     spans   ALL           ·             ·
·     filter  b = c         ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE a = 1
----
tree  field  description   columns       ordering
scan  ·      ·             (a, b, c, d)  a=CONST; key()
·     table  abcd@primary  ·             ·
·     spans  /1-/1/#       ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE b = 1
----
tree  field   description   columns       ordering
scan  ·       ·             (a, b, c, d)  b=CONST; a!=NULL; key(a)
·     table   abcd@primary  ·             ·
·     spans   ALL           ·             ·
·     filter  b = 1         ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE a = 1 AND b = 1
----
tree  field   description   columns       ordering
scan  ·       ·             (a, b, c, d)  a=CONST; b=CONST; key()
·     table   abcd@primary  ·             ·
·     spans   /1-/1/#       ·             ·
·     filter  b = 1         ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE a = 1 AND b = d
----
tree  field   description   columns       ordering
scan  ·       ·             (a, b, c, d)  b=d; a=CONST; b!=NULL; d!=NULL; key()
·     table   abcd@primary  ·             ·
·     spans   /1-/1/#       ·             ·
·     filter  b = d         ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE a = b AND b = c
----
tree  field   description          columns       ordering
scan  ·       ·                    (a, b, c, d)  a=b=c; a!=NULL; b!=NULL; c!=NULL; key(a)
·     table   abcd@primary         ·             ·
·     spans   ALL                  ·             ·
·     filter  (a = b) AND (b = c)  ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd WHERE a = b AND b = c AND c = 1
----
tree  field   description                        columns       ordering
scan  ·       ·                                  (a, b, c, d)  a=b=c; a=CONST; b!=NULL; c!=NULL; key()
·     table   abcd@primary                       ·             ·
·     spans   ALL                                ·             ·
·     filter  ((a = b) AND (b = c)) AND (c = 1)  ·             ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS x(a,b,c) WHERE a = 1
----
tree         field          description        columns    ordering
filter       ·              ·                  (a, b, c)  a=CONST
 │           filter         x.a = 1            ·          ·
 └── values  ·              ·                  (a, b, c)  ·
·            size           3 columns, 2 rows  ·          ·
·            row 0, expr 0  1                  ·          ·
·            row 0, expr 1  2                  ·          ·
·            row 0, expr 2  3                  ·          ·
·            row 1, expr 0  4                  ·          ·
·            row 1, expr 1  5                  ·          ·
·            row 1, expr 2  6                  ·          ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS x(a,b,c) WHERE a = b
----
tree         field          description        columns    ordering
filter       ·              ·                  (a, b, c)  a=b; a!=NULL; b!=NULL
 │           filter         x.a = x.b          ·          ·
 └── values  ·              ·                  (a, b, c)  ·
·            size           3 columns, 2 rows  ·          ·
·            row 0, expr 0  1                  ·          ·
·            row 0, expr 1  2                  ·          ·
·            row 0, expr 2  3                  ·          ·
·            row 1, expr 0  4                  ·          ·
·            row 1, expr 1  5                  ·          ·
·            row 1, expr 2  6                  ·          ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM (VALUES (1, 2, 3), (4, 5, 6)) AS x(a,b,c) WHERE a = b AND b = 1
----
tree         field          description                columns    ordering
filter       ·              ·                          (a, b, c)  a=b; a=CONST; b!=NULL
 │           filter         (x.a = x.b) AND (x.b = 1)  ·          ·
 └── values  ·              ·                          (a, b, c)  ·
·            size           3 columns, 2 rows          ·          ·
·            row 0, expr 0  1                          ·          ·
·            row 0, expr 1  2                          ·          ·
·            row 0, expr 2  3                          ·          ·
·            row 1, expr 0  4                          ·          ·
·            row 1, expr 1  5                          ·          ·
·            row 1, expr 2  6                          ·          ·


statement ok
CREATE TABLE efg (e INT PRIMARY KEY, f INT, g INT)

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd JOIN efg ON a=e AND a=1 AND f=g
----
tree        field           description   columns                ordering
merge-join  ·               ·             (a, b, c, d, e, f, g)  a=e; f=g; a=CONST; key()
 │          type            inner         ·                      ·
 │          equality        (a) = (e)     ·                      ·
 │          mergeJoinOrder  +"(a=e)"      ·                      ·
 ├── scan   ·               ·             (a, b, c, d)           a=CONST; key()
 │          table           abcd@primary  ·                      ·
 │          spans           /1-/1/#       ·                      ·
 └── scan   ·               ·             (e, f, g)              f=g; e=CONST; f!=NULL; g!=NULL; key()
·           table           efg@primary   ·                      ·
·           spans           /1-/1/#       ·                      ·
·           filter          f = g         ·                      ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd JOIN efg ON a=e AND b=1 AND f=g
----
tree        field           description   columns                ordering
merge-join  ·               ·             (a, b, c, d, e, f, g)  a=e; f=g; b=CONST; a!=NULL; key(a)
 │          type            inner         ·                      ·
 │          equality        (a) = (e)     ·                      ·
 │          mergeJoinOrder  +"(a=e)"      ·                      ·
 ├── scan   ·               ·             (a, b, c, d)           b=CONST; a!=NULL; key(a); +a
 │          table           abcd@primary  ·                      ·
 │          spans           ALL           ·                      ·
 │          filter          b = 1         ·                      ·
 └── scan   ·               ·             (e, f, g)              f=g; e!=NULL; f!=NULL; g!=NULL; key(e); +e
·           table           efg@primary   ·                      ·
·           spans           ALL           ·                      ·
·           filter          f = g         ·                      ·

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd JOIN efg ON a=e
----
tree        field           description   columns                ordering
merge-join  ·               ·             (a, b, c, d, e, f, g)  a=e; a!=NULL; key(a)
 │          type            inner         ·                      ·
 │          equality        (a) = (e)     ·                      ·
 │          mergeJoinOrder  +"(a=e)"      ·                      ·
 ├── scan   ·               ·             (a, b, c, d)           a!=NULL; key(a); +a
 │          table           abcd@primary  ·                      ·
 │          spans           ALL           ·                      ·
 └── scan   ·               ·             (e, f, g)              e!=NULL; key(e); +e
·           table           efg@primary   ·                      ·
·           spans           ALL           ·                      ·

# Verify keys don't get propagated when not appropriate.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd JOIN efg ON a=f
----
tree       field     description   columns                ordering
hash-join  ·         ·             (a, b, c, d, e, f, g)  ·
 │         type      inner         ·                      ·
 │         equality  (a) = (f)     ·                      ·
 ├── scan  ·         ·             (a, b, c, d)           a!=NULL; key(a)
 │         table     abcd@primary  ·                      ·
 │         spans     ALL           ·                      ·
 └── scan  ·         ·             (e, f, g)              e!=NULL; key(e)
·          table     efg@primary   ·                      ·
·          spans     ALL           ·                      ·

# Verify we retain all keys when appropriate.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM abcd JOIN (SELECT * FROM efg WITH ORDINALITY) ON a=e
----
tree             field           description   columns                              ordering
merge-join       ·               ·             (a, b, c, d, e, f, g, "ordinality")  a=e; a!=NULL; key(a); weak-key("ordinality")
 │               type            inner         ·                                    ·
 │               equality        (a) = (e)     ·                                    ·
 │               mergeJoinOrder  +"(a=e)"      ·                                    ·
 ├── scan        ·               ·             (a, b, c, d)                         a!=NULL; key(a); +a
 │               table           abcd@primary  ·                                    ·
 │               spans           ALL           ·                                    ·
 └── ordinality  ·               ·             (e, f, g, "ordinality")              e!=NULL; key(e); weak-key("ordinality"); +e
      └── scan   ·               ·             (e, f, g)                            e!=NULL; key(e); +e
·                table           efg@primary   ·                                    ·
·                spans           ALL           ·                                    ·

# Regression test for 24500
statement ok
CREATE TABLE abc (a INT, b INT, c INT);
CREATE UNIQUE INDEX ON abc (a, b, c);
SELECT true FROM abc WHERE b=1 and b=c

# a should be a weak key.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT true FROM abc WHERE b=1 and b=c;
----
tree       field     description          columns                                    ordering
render     ·         ·                    (bool)                                     bool=CONST
 │         render 0  true                 ·                                          ·
 └── scan  ·         ·                    (a[omitted], b, c, rowid[hidden,omitted])  b=c; b=CONST; c!=NULL; weak-key(a)
·          table     abc@abc_a_b_c_key    ·                                          ·
·          spans     ALL                  ·                                          ·
·          filter    (b = 1) AND (b = c)  ·                                          ·
