# LogicTest: local

query TTT colnames
EXPLAIN (PLAN) SELECT 1 FROM system.jobs WHERE FALSE
----
tree         field  description
render       ·      ·
 └── norows  ·      ·

query TTT colnames
EXPLAIN (PLAN) SELECT 1 FROM system.jobs WHERE NULL
----
tree         field  description
render       ·      ·
 └── norows  ·      ·

query TTT colnames
EXPLAIN (PLAN) SELECT 1 FROM system.jobs WHERE TRUE
----
tree       field  description
render     ·      ·
 └── scan  ·      ·
·          table  jobs@primary
·          spans  ALL

query TTTTT colnames
EXPLAIN (PLAN, VERBOSE) SELECT 1 a
----
tree           field     description  columns  ordering
render         ·         ·            (a)      a=CONST
 │             render 0  1            ·        ·
 └── emptyrow  ·         ·            ()       ·

query TTTTT colnames
EXPLAIN (VERBOSE,PLAN) SELECT 1 a
----
tree           field     description  columns  ordering
render         ·         ·            (a)      a=CONST
 │             render 0  1            ·        ·
 └── emptyrow  ·         ·            ()       ·

statement ok
SET tracing = on,kv,results; SELECT 1; SET tracing = off

query T
SELECT message FROM [SHOW KV TRACE FOR SESSION]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
output row: [1]

query TTTTT colnames
EXPLAIN (TYPES) SELECT 1 a
----
tree           field     description  columns  ordering
render         ·         ·            (a int)  a=CONST
 │             render 0  (1)[int]     ·        ·
 └── emptyrow  ·         ·            ()       ·

statement error cannot set EXPLAIN mode more than once
EXPLAIN (PLAN,PLAN) SELECT 1 a

statement error cannot set EXPLAIN mode more than once
EXPLAIN (PLAN,DISTSQL) SELECT 1 a

statement error unsupported EXPLAIN option
EXPLAIN (PLAN,UNKNOWN) SELECT 1 a

statement error could not determine data type of placeholder \$1
EXPLAIN (TYPES) SELECT $1

query TTTTT colnames
EXPLAIN (TYPES) SELECT $1::INT
----
tree           field     description                columns     ordering
render         ·         ·                          (int8 int)  int8=CONST
 │             render 0  (($1)[string]::INT8)[int]  ·           ·
 └── emptyrow  ·         ·                          ()          ·


# Ensure that all relevant statement types can be explained
query TTT
EXPLAIN CREATE DATABASE foo
----
create database  ·  ·

query TTT
EXPLAIN CREATE TABLE foo (x INT)
----
create table  ·  ·

statement ok
CREATE TABLE foo (x INT)

query TTT
EXPLAIN CREATE INDEX a ON foo(x)
----
create index  ·  ·

statement ok
CREATE DATABASE foo

query TTT
EXPLAIN DROP DATABASE foo
----
drop database  ·  ·

# explain SHOW JOBS - beware to test this before the CREATE INDEX
# below, otherwise the result becomes non-deterministic.
# Migrations with backfill will affect the number of rows.
query TTT
EXPLAIN SHOW JOBS
----
sort                   ·       ·
 │                     order   -"coalesce",-started
 └── render            ·       ·
      └── filter       ·       ·
           │           filter  ((job_type != 'AUTO CREATE STATS') OR (job_type IS NULL)) AND ((finished IS NULL) OR (finished > (now() - '12:00:00')))
           └── values  ·       ·
·                      size    16 columns, 0 rows

statement ok
CREATE INDEX a ON foo(x)

query TTT
EXPLAIN DROP INDEX foo@a
----
drop index  ·  ·

query TTT
EXPLAIN ALTER TABLE foo ADD COLUMN y INT
----
alter table  ·  ·

query TTT
SELECT tree, field, description FROM [EXPLAIN (VERBOSE) ALTER TABLE foo SPLIT AT VALUES (42)]
----
split        ·              ·
 └── values  ·              ·
·            size           1 column, 1 row
·            row 0, expr 0  42

query TTT
SELECT * FROM [EXPLAIN DROP TABLE foo] WHERE field != 'size'
----
drop table  ·  ·

query TTT
SELECT * FROM [EXPLAIN SHOW DATABASES] WHERE field != 'size'
----
distinct               ·          ·
 │                     order key  database_name
 └── sort              ·          ·
      │                order      +database_name
      └── render       ·          ·
           └── values  ·          ·

query TTT
SELECT * FROM [EXPLAIN SHOW TABLES] WHERE field != 'size'
----
sort                   ·       ·
 │                     order   +table_schema,+table_name
 └── render            ·       ·
      └── filter       ·       ·
           │           filter  table_schema = 'public'
           └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW TABLES WITH COMMENT] WHERE field != 'size'
----
render                      ·         ·
 └── hash-join              ·         ·
      │                     type      left outer
      │                     equality  (oid) = (objoid)
      ├── hash-join         ·         ·
      │    │                type      inner
      │    │                equality  (relnamespace) = (oid)
      │    ├── filter       ·         ·
      │    │    │           filter    relkind IN ('r', 'v')
      │    │    └── values  ·         ·
      │    └── filter       ·         ·
      │         │           filter    nspname = 'public'
      │         └── values  ·         ·
      └── filter            ·         ·
           │                filter    objsubid = 0
           └── values       ·         ·

query TTT
SELECT * FROM [EXPLAIN SHOW DATABASE] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  variable = 'database'
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW TIME ZONE] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  variable = 'timezone'
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW DEFAULT_TRANSACTION_ISOLATION] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  variable = 'default_transaction_isolation'
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW TRANSACTION ISOLATION LEVEL] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  variable = 'transaction_isolation'
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW TRANSACTION PRIORITY] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  variable = 'transaction_priority'
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW COLUMNS FROM foo] WHERE field != 'size'
----
sort                                       ·            ·
 │                                         order        +ordinal_position
 └── render                                ·            ·
      └── group                            ·            ·
           │                               aggregate 0  column_name
           │                               aggregate 1  crdb_sql_type
           │                               aggregate 2  is_nullable
           │                               aggregate 3  column_default
           │                               aggregate 4  generation_expression
           │                               aggregate 5  ordinal_position
           │                               aggregate 6  is_hidden
           │                               aggregate 7  array_agg(index_name)
           │                               group by     @1-@7
           └── render                      ·            ·
                └── hash-join              ·            ·
                     │                     type         left outer
                     │                     equality     (column_name) = (column_name)
                     ├── render            ·            ·
                     │    └── filter       ·            ·
                     │         │           filter       ((table_catalog = 'test') AND (table_schema = 'public')) AND (table_name = 'foo')
                     │         └── values  ·            ·
                     └── render            ·            ·
                          └── filter       ·            ·
                               │           filter       ((table_catalog = 'test') AND (table_schema = 'public')) AND (table_name = 'foo')
                               └── values  ·            ·

query TTT
SELECT * FROM [EXPLAIN SHOW GRANTS ON foo] WHERE field != 'size'
----
sort                   ·       ·
 │                     order   +database_name,+schema_name,+table_name,+grantee,+privilege_type
 └── render            ·       ·
      └── filter       ·       ·
           │           filter  (table_catalog, table_schema, table_name) IN (('test', 'public', 'foo'),)
           └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW INDEX FROM foo] WHERE field != 'size'
----
render            ·       ·
 └── filter       ·       ·
      │           filter  ((table_catalog = 'test') AND (table_schema = 'public')) AND (table_name = 'foo')
      └── values  ·       ·

query TTT
SELECT * FROM [EXPLAIN SHOW CONSTRAINTS FROM foo] WHERE field != 'size'
----
sort                             ·         ·
 │                               order     +table_name,+constraint_name
 └── render                      ·         ·
      └── hash-join              ·         ·
           │                     type      inner
           │                     equality  (relnamespace, oid) = (oid, conrelid)
           ├── filter            ·         ·
           │    │                filter    relname = 'foo'
           │    └── values       ·         ·
           └── hash-join         ·         ·
                │                type      cross
                ├── filter       ·         ·
                │    │           filter    nspname = 'public'
                │    └── values  ·         ·
                └── values       ·         ·

query TTT
EXPLAIN SHOW USERS
----
render     ·       ·
 └── scan  ·       ·
·          table   users@primary
·          spans   ALL
·          filter  "isRole" = false

# EXPLAIN selecting from a sequence.
statement ok
CREATE SEQUENCE select_test

query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM select_test
----
tree             field  description  columns                           ordering
sequence select  ·      ·            (last_value, log_cnt, is_called)  ·

statement ok
CREATE TABLE t (
  k INT PRIMARY KEY,
  v INT
)

query TTT
SELECT * FROM [EXPLAIN INSERT INTO t VALUES (1, 2)] WHERE field != 'size'
----
count             ·         ·
 └── insert       ·         ·
      │           into      t(k, v)
      │           strategy  inserter
      └── values  ·         ·

query I
SELECT max(level) FROM [EXPLAIN (VERBOSE) INSERT INTO t VALUES (1, 2)]
----
2

statement ok
INSERT INTO t VALUES (1, 2)

query TTT
EXPLAIN SELECT * FROM t
----
scan  ·      ·
·     table  t@primary
·     spans  ALL

query TTTTT
EXPLAIN (VERBOSE) SELECT * FROM t
----
scan  ·      ·          (k, v)  k!=NULL; key(k)
·     table  t@primary  ·       ·
·     spans  ALL        ·       ·

query TTT
EXPLAIN SELECT * FROM t WHERE k = 1 OR k = 3
----
scan  ·         ·
·     table     t@primary
·     spans     /1-/1/# /3-/3/#
·     parallel  ·

query TTTTT
EXPLAIN (VERBOSE) SELECT * FROM t WHERE k % 2 = 0
----
scan  ·       ·            (k, v)  k!=NULL; key(k)
·     table   t@primary    ·       ·
·     spans   ALL          ·       ·
·     filter  (k % 2) = 0  ·       ·

query TTT
EXPLAIN VALUES (1, 2, 3), (4, 5, 6)
----
values  ·     ·
·       size  3 columns, 2 rows

query TTT
EXPLAIN VALUES (1)
----
values  ·     ·
·       size  1 column, 1 row

query TTT
SELECT tree, field, description FROM [EXPLAIN (VERBOSE) SELECT * FROM t WITH ORDINALITY LIMIT 1 OFFSET 1]
----
limit            ·       ·
 │               count   1
 │               offset  1
 └── ordinality  ·       ·
      └── scan   ·       ·
·                table   t@primary
·                spans   ALL
·                limit   2

query TTT
EXPLAIN SELECT DISTINCT v FROM t
----
distinct        ·      ·
 └── render     ·      ·
      └── scan  ·      ·
·               table  t@primary
·               spans  ALL

query TTT
SELECT tree, field, description FROM [EXPLAIN (VERBOSE) SELECT DISTINCT v FROM t LIMIT 1 OFFSET 1]
----
limit                ·         ·
 │                   count     1
 │                   offset    1
 └── distinct        ·         ·
      └── render     ·         ·
           │         render 0  test.public.t.v
           └── scan  ·         ·
·                    table     t@primary
·                    spans     ALL

statement ok
CREATE TABLE tc (a INT, b INT, INDEX c(a))

query TTTTT
EXPLAIN (VERBOSE) SELECT * FROM tc WHERE a = 10 ORDER BY b
----
sort                  ·         ·                 (a, b)                                   a=CONST; +b
 │                    order     +b                ·                                        ·
 └── render           ·         ·                 (a, b)                                   a=CONST
      │               render 0  test.public.tc.a  ·                                        ·
      │               render 1  test.public.tc.b  ·                                        ·
      └── index-join  ·         ·                 (a, b, rowid[hidden,omitted])            a=CONST; rowid!=NULL; key(rowid)
           │          table     tc@primary        ·                                        ·
           └── scan   ·         ·                 (a[omitted], b[omitted], rowid[hidden])  a=CONST; rowid!=NULL; key(rowid)
·                     table     tc@c              ·                                        ·
·                     spans     /10-/11           ·                                        ·

query TTTTT colnames
EXPLAIN (TYPES) INSERT INTO t VALUES (1, 2)
----
tree              field          description       columns                     ordering
count             ·              ·                 ()                          ·
 └── insert       ·              ·                 ()                          ·
      │           into           t(k, v)           ·                           ·
      │           strategy       inserter          ·                           ·
      └── values  ·              ·                 (column1 int, column2 int)  ·
·                 size           2 columns, 1 row  ·                           ·
·                 row 0, expr 0  (1)[int]          ·                           ·
·                 row 0, expr 1  (2)[int]          ·                           ·

query TTTTT
EXPLAIN (TYPES) SELECT 42 a
----
render         ·         ·          (a int)  a=CONST
 │             render 0  (42)[int]  ·        ·
 └── emptyrow  ·         ·          ()       ·

query TTTTT
EXPLAIN (TYPES) SELECT * FROM t
----
scan  ·      ·          (k int, v int)  k!=NULL; key(k)
·     table  t@primary  ·               ·
·     spans  ALL        ·               ·

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

query TTTTT
EXPLAIN (TYPES,VERBOSE) SELECT k FROM t
----
render     ·         ·                       (k int)                  k!=NULL; key(k)
 │         render 0  (test.public.t.k)[int]  ·                        ·
 └── scan  ·         ·                       (k int, v[omitted] int)  k!=NULL; key(k)
·          table     t@primary               ·                        ·
·          spans     ALL                     ·                        ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT * FROM t WHERE v > 123
----
render     ·         ·                              (k int, v int)  ·
 │         render 0  (k)[int]                       ·               ·
 │         render 1  (v)[int]                       ·               ·
 └── scan  ·         ·                              (k int, v int)  ·
·          table     t@primary                      ·               ·
·          filter    ((v)[int] > (123)[int])[bool]  ·               ·

query TTTTT
EXPLAIN (TYPES) SELECT * FROM t WHERE v > 123
----
scan  ·       ·                              (k int, v int)  k!=NULL; v!=NULL; key(k)
·     table   t@primary                      ·               ·
·     spans   ALL                            ·               ·
·     filter  ((v)[int] > (123)[int])[bool]  ·               ·

query TTTTT
EXPLAIN (TYPES) VALUES (1, 2, 3), (4, 5, 6)
----
values  ·              ·                  (column1 int, column2 int, column3 int)  ·
·       size           3 columns, 2 rows  ·                                        ·
·       row 0, expr 0  (1)[int]           ·                                        ·
·       row 0, expr 1  (2)[int]           ·                                        ·
·       row 0, expr 2  (3)[int]           ·                                        ·
·       row 1, expr 0  (4)[int]           ·                                        ·
·       row 1, expr 1  (5)[int]           ·                                        ·
·       row 1, expr 2  (6)[int]           ·                                        ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT 2*count(k) as z, v FROM t WHERE v>123 GROUP BY v HAVING v<2 AND count(k)>1
----
render                    ·            ·                                                                          (z int, v int)        ·
 │                        render 0     ((2)[int] * (agg1)[int])[int]                                              ·                     ·
 │                        render 1     (agg0)[int]                                                                ·                     ·
 └── filter               ·            ·                                                                          (agg0 int, agg1 int)  ·
      │                   filter       ((agg1)[int] > (1)[int])[bool]                                             ·                     ·
      └── group           ·            ·                                                                          (agg0 int, agg1 int)  ·
           │              aggregate 0  v                                                                          ·                     ·
           │              aggregate 1  count(k)                                                                   ·                     ·
           │              group by     @1                                                                         ·                     ·
           └── render     ·            ·                                                                          (v int, k int)        ·
                │         render 0     (v)[int]                                                                   ·                     ·
                │         render 1     (k)[int]                                                                   ·                     ·
                └── scan  ·            ·                                                                          (k int, v int)        ·
·                         table        t@primary                                                                  ·                     ·
·                         filter       ((((v)[int] > (123)[int])[bool]) AND (((v)[int] < (2)[int])[bool]))[bool]  ·                     ·


query TTTTT
EXPLAIN (TYPES) SELECT 2*count(k) as z, v FROM t WHERE v>123 GROUP BY v HAVING v<2 AND count(k)>1
----
render                    ·            ·                                                                          (z int, v int)        v!=NULL; key(v)
 │                        render 0     ((2)[int] * (agg1)[int])[int]                                              ·                     ·
 │                        render 1     (agg0)[int]                                                                ·                     ·
 └── filter               ·            ·                                                                          (agg0 int, agg1 int)  agg0!=NULL; agg1!=NULL; key(agg0)
      │                   filter       ((agg1)[int] > (1)[int])[bool]                                             ·                     ·
      └── group           ·            ·                                                                          (agg0 int, agg1 int)  agg0!=NULL; key(agg0)
           │              aggregate 0  v                                                                          ·                     ·
           │              aggregate 1  count(k)                                                                   ·                     ·
           │              group by     @1                                                                         ·                     ·
           └── render     ·            ·                                                                          (v int, k int)        v!=NULL; k!=NULL; key(k)
                │         render 0     (v)[int]                                                                   ·                     ·
                │         render 1     (k)[int]                                                                   ·                     ·
                └── scan  ·            ·                                                                          (k int, v int)        k!=NULL; v!=NULL; key(k)
·                         table        t@primary                                                                  ·                     ·
·                         spans        ALL                                                                        ·                     ·
·                         filter       ((((v)[int] > (123)[int])[bool]) AND (((v)[int] < (2)[int])[bool]))[bool]  ·                     ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) DELETE FROM t WHERE v > 1
----
count                ·         ·                            ()              ·
 └── delete          ·         ·                            ()              ·
      │              from      t                            ·               ·
      │              strategy  deleter                      ·               ·
      └── render     ·         ·                            (k int)         ·
           │         render 0  (k)[int]                     ·               ·
           └── scan  ·         ·                            (k int, v int)  ·
·                    table     t@primary                    ·               ·
·                    filter    ((v)[int] > (1)[int])[bool]  ·               ·

query TTTTT
EXPLAIN (TYPES) DELETE FROM t WHERE v > 1
----
count                ·         ·                            ()              ·
 └── delete          ·         ·                            ()              ·
      │              from      t                            ·               ·
      │              strategy  deleter                      ·               ·
      └── render     ·         ·                            (k int)         k!=NULL; key(k)
           │         render 0  (k)[int]                     ·               ·
           └── scan  ·         ·                            (k int, v int)  k!=NULL; v!=NULL; key(k)
·                    table     t@primary                    ·               ·
·                    spans     ALL                          ·               ·
·                    filter    ((v)[int] > (1)[int])[bool]  ·               ·

query TTTTT
EXPLAIN (TYPES) UPDATE t SET v = k + 1 WHERE v > 123
----
count                ·         ·                              ()                              ·
 └── update          ·         ·                              ()                              ·
      │              table     t                              ·                               ·
      │              set       v                              ·                               ·
      │              strategy  updater                        ·                               ·
      └── render     ·         ·                              (k int, v int, "?column?" int)  k!=NULL; v!=NULL; key(k)
           │         render 0  (k)[int]                       ·                               ·
           │         render 1  (v)[int]                       ·                               ·
           │         render 2  ((k)[int] + (1)[int])[int]     ·                               ·
           └── scan  ·         ·                              (k int, v int)                  k!=NULL; v!=NULL; key(k)
·                    table     t@primary                      ·                               ·
·                    spans     ALL                            ·                               ·
·                    filter    ((v)[int] > (123)[int])[bool]  ·                               ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) UPDATE t SET v = k + 1 WHERE v > 123
----
count                ·         ·                              ()                              ·
 └── update          ·         ·                              ()                              ·
      │              table     t                              ·                               ·
      │              set       v                              ·                               ·
      │              strategy  updater                        ·                               ·
      └── render     ·         ·                              (k int, v int, "?column?" int)  ·
           │         render 0  (k)[int]                       ·                               ·
           │         render 1  (v)[int]                       ·                               ·
           │         render 2  ((k)[int] + (1)[int])[int]     ·                               ·
           └── scan  ·         ·                              (k int, v int)                  ·
·                    table     t@primary                      ·                               ·
·                    filter    ((v)[int] > (123)[int])[bool]  ·                               ·

query TTTTT
EXPLAIN (TYPES) VALUES (1) UNION VALUES (2)
----
union        ·              ·                (column1 int)  ·
 ├── values  ·              ·                (column1 int)  ·
 │           size           1 column, 1 row  ·              ·
 │           row 0, expr 0  (2)[int]         ·              ·
 └── values  ·              ·                (column1 int)  ·
·            size           1 column, 1 row  ·              ·
·            row 0, expr 0  (1)[int]         ·              ·

query TTTTT
EXPLAIN (TYPES) SELECT DISTINCT k FROM t
----
render     ·         ·          (k int)                  k!=NULL; key(k)
 │         render 0  (k)[int]   ·                        ·
 └── scan  ·         ·          (k int, v[omitted] int)  k!=NULL; key(k)
·          table     t@primary  ·                        ·
·          spans     ALL        ·                        ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT DISTINCT k FROM t
----
distinct        ·         ·          (k int)                  weak-key(k)
 └── render     ·         ·          (k int)                  ·
      │         render 0  (k)[int]   ·                        ·
      └── scan  ·         ·          (k int, v[omitted] int)  ·
·               table     t@primary  ·                        ·

query TTTTT
EXPLAIN (TYPES) SELECT v FROM t ORDER BY v
----
sort            ·         ·          (v int)                  +v
 │              order     +v         ·                        ·
 └── render     ·         ·          (v int)                  ·
      │         render 0  (v)[int]   ·                        ·
      └── scan  ·         ·          (k[omitted] int, v int)  k!=NULL; key(k)
·               table     t@primary  ·                        ·
·               spans     ALL        ·                        ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT v FROM t ORDER BY v
----
nosort          ·         ·          (v int)                  ·
 │              order     +v         ·                        ·
 └── render     ·         ·          (v int)                  ·
      │         render 0  (v)[int]   ·                        ·
      └── scan  ·         ·          (k[omitted] int, v int)  ·
·               table     t@primary  ·                        ·

query TTTTT
EXPLAIN (TYPES) SELECT v FROM t LIMIT 1
----
limit           ·         ·          (v int)                  ·
 │              count     (1)[int]   ·                        ·
 └── render     ·         ·          (v int)                  ·
      │         render 0  (v)[int]   ·                        ·
      └── scan  ·         ·          (k[omitted] int, v int)  k!=NULL; key(k)
·               table     t@primary  ·                        ·
·               spans     ALL        ·                        ·
·               limit     1          ·                        ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT v FROM t LIMIT 1
----
limit           ·         ·          (v int)                  ·
 │              count     (1)[int]   ·                        ·
 └── render     ·         ·          (v int)                  ·
      │         render 0  (v)[int]   ·                        ·
      └── scan  ·         ·          (k[omitted] int, v int)  ·
·               table     t@primary  ·                        ·

statement ok
CREATE TABLE tt (x INT, y INT, INDEX a(x), INDEX b(y))

query TTTTT
EXPLAIN (TYPES) SELECT * FROM tt WHERE x < 10 AND y > 10
----
render           ·         ·                             (x int, y int)                                       x!=NULL; y!=NULL
 │               render 0  (x)[int]                      ·                                                    ·
 │               render 1  (y)[int]                      ·                                                    ·
 └── index-join  ·         ·                             (x int, y int, rowid[hidden,omitted] int)            x!=NULL; y!=NULL; rowid!=NULL; key(x,rowid)
      │          table     tt@primary                    ·                                                    ·
      │          filter    ((y)[int] > (10)[int])[bool]  ·                                                    ·
      └── scan   ·         ·                             (x[omitted] int, y[omitted] int, rowid[hidden] int)  x!=NULL; y!=NULL; rowid!=NULL; key(x,rowid)
·                table     tt@a                          ·                                                    ·
·                spans     /!NULL-/10                    ·                                                    ·

query TTTTT
EXPLAIN (TYPES,NOEXPAND) SELECT * FROM tt WHERE x < 10 AND y > 10
----
render     ·         ·                                                                          (x int, y int)                             ·
 │         render 0  (x)[int]                                                                   ·                                          ·
 │         render 1  (y)[int]                                                                   ·                                          ·
 └── scan  ·         ·                                                                          (x int, y int, rowid[hidden,omitted] int)  ·
·          table     tt@primary                                                                 ·                                          ·
·          filter    ((((x)[int] < (10)[int])[bool]) AND (((y)[int] > (10)[int])[bool]))[bool]  ·                                          ·

query TTTTT
EXPLAIN (TYPES) SELECT $1 + 2 AS a
----
render         ·         ·                            (a int)  a=CONST
 │             render 0  (($1)[int] + (2)[int])[int]  ·        ·
 └── emptyrow  ·         ·                            ()       ·

query TTTTT
EXPLAIN (TYPES,NONORMALIZE) SELECT abs(2-3) AS a
----
render         ·         ·                      (a int)  a=CONST
 │             render 0  (abs((-1)[int]))[int]  ·        ·
 └── emptyrow  ·         ·                      ()       ·

query TTTTT
EXPLAIN (TYPES) SELECT abs(2-3) AS a
----
render         ·         ·         (a int)  a=CONST
 │             render 0  (1)[int]  ·        ·
 └── emptyrow  ·         ·         ()       ·

# Check array subscripts (#13811)
query TTTTT
EXPLAIN (TYPES) SELECT x[1] FROM (SELECT ARRAY[1,2,3] AS x)
----
render              ·         ·                                           (x int)    ·
 │                  render 0  ((x)[int[]][(1)[int]])[int]                 ·          ·
 └── render         ·         ·                                           (x int[])  x=CONST
      │             render 0  (ARRAY[(1)[int],(2)[int],(3)[int]])[int[]]  ·          ·
      └── emptyrow  ·         ·                                           ()         ·

statement error EXPLAIN \(OPT\) only supported with the cost-based optimizer
EXPLAIN (OPT) SELECT 1

# Make sure that casts of null values to collated strings roundtrip correctly.
query TTTTT
EXPLAIN (VERBOSE) SELECT NULL COLLATE en
----
render         ·         ·                                ("?column?")  "?column?"=CONST
 │             render 0  CAST(NULL AS STRING) COLLATE en  ·             ·
 └── emptyrow  ·         ·                                ()            ·
