# LogicTest: local-opt

subtest generate_series

query TTT
EXPLAIN SELECT * FROM generate_series(1, 3)
----
project set    ·  ·
 └── emptyrow  ·  ·

query TTT
EXPLAIN SELECT * FROM generate_series(1, 2), generate_series(1, 2)
----
hash-join           ·     ·
 │                  type  cross
 ├── project set    ·     ·
 │    └── emptyrow  ·     ·
 └── project set    ·     ·
      └── emptyrow  ·     ·

query TTT
EXPLAIN SELECT * FROM ROWS FROM (cos(1))
----
project set    ·  ·
 └── emptyrow  ·  ·

query TTT
EXPLAIN SELECT generate_series(1, 3)
----
project set    ·  ·
 └── emptyrow  ·  ·

subtest multiple_SRFs
# See #20511

query TTT
EXPLAIN SELECT generate_series(1, 2), generate_series(1, 2)
----
project set    ·  ·
 └── emptyrow  ·  ·

statement ok
CREATE TABLE t (a string)

statement ok
CREATE TABLE u (b string)

query TTTTT
EXPLAIN (VERBOSE) SELECT t.*, u.*, generate_series(1,2), generate_series(3, 4) FROM t, u
----
render                        ·         ·                      (a, b, generate_series, generate_series)  ·
 │                            render 0  a                      ·                                         ·
 │                            render 1  b                      ·                                         ·
 │                            render 2  generate_series        ·                                         ·
 │                            render 3  generate_series        ·                                         ·
 └── hash-join                ·         ·                      (b, generate_series, generate_series, a)  ·
      │                       type      cross                  ·                                         ·
      ├── hash-join           ·         ·                      (b, generate_series, generate_series)     ·
      │    │                  type      cross                  ·                                         ·
      │    ├── scan           ·         ·                      (b)                                       ·
      │    │                  table     u@primary              ·                                         ·
      │    │                  spans     ALL                    ·                                         ·
      │    └── project set    ·         ·                      (generate_series, generate_series)        ·
      │         │             render 0  generate_series(1, 2)  ·                                         ·
      │         │             render 1  generate_series(3, 4)  ·                                         ·
      │         └── emptyrow  ·         ·                      ()                                        ·
      └── scan                ·         ·                      (a)                                       ·
·                             table     t@primary              ·                                         ·
·                             spans     ALL                    ·                                         ·

subtest correlated_SRFs

statement ok
CREATE TABLE data (a INT PRIMARY KEY)

query TTTTT
EXPLAIN (VERBOSE) SELECT a, generate_series(a, a + 1) FROM data ORDER BY 1, 2
----
sort              ·         ·                            (a, generate_series)  +a,+generate_series
 │                order     +a,+generate_series          ·                     ·
 └── project set  ·         ·                            (a, generate_series)  ·
      │           render 0  generate_series(@1, @1 + 1)  ·                     ·
      └── scan    ·         ·                            (a)                   ·
·                 table     data@primary                 ·                     ·
·                 spans     ALL                          ·                     ·

statement ok
CREATE TABLE xy (x INT PRIMARY KEY, y INT)

statement ok
CREATE TABLE xz (x INT PRIMARY KEY, z INT)

query TTTTT
EXPLAIN (VERBOSE) SELECT x, y, z, information_schema._pg_expandarray(ARRAY[x, y, z])
  FROM xy NATURAL JOIN xz WHERE y < z ORDER BY 1, 2, 3
----
render                          ·               ·                                                      (x, y, z, "information_schema._pg_expandarray")  ·
 │                              render 0        x                                                      ·                                                ·
 │                              render 1        y                                                      ·                                                ·
 │                              render 2        z                                                      ·                                                ·
 │                              render 3        "information_schema._pg_expandarray"                   ·                                                ·
 └── sort                       ·               ·                                                      ("information_schema._pg_expandarray", x, y, z)  +x
      │                         order           +x                                                     ·                                                ·
      └── render                ·               ·                                                      ("information_schema._pg_expandarray", x, y, z)  ·
           │                    render 0        ((x, n) AS x, n)                                       ·                                                ·
           │                    render 1        x                                                      ·                                                ·
           │                    render 2        y                                                      ·                                                ·
           │                    render 3        z                                                      ·                                                ·
           └── project set      ·               ·                                                      (x, y, x, z, x, n)                               ·
                │               render 0        information_schema._pg_expandarray(ARRAY[@1, @2, @4])  ·                                                ·
                └── merge-join  ·               ·                                                      (x, y, x, z)                                     ·
                     │          type            inner                                                  ·                                                ·
                     │          equality        (x) = (x)                                              ·                                                ·
                     │          mergeJoinOrder  +"(x=x)"                                               ·                                                ·
                     │          pred            y < z                                                  ·                                                ·
                     ├── scan   ·               ·                                                      (x, y)                                           +x
                     │          table           xy@primary                                             ·                                                ·
                     │          spans           ALL                                                    ·                                                ·
                     └── scan   ·               ·                                                      (x, z)                                           +x
·                               table           xz@primary                                             ·                                                ·
·                               spans           ALL                                                    ·                                                ·

query TTTTT
EXPLAIN (VERBOSE) SELECT generate_series(x, z) FROM xz WHERE z < ANY(SELECT generate_series(x, y) FROM xy)
----
render                      ·         ·                        (generate_series)        ·
 │                          render 0  generate_series          ·                        ·
 └── project set            ·         ·                        (x, z, generate_series)  ·
      │                     render 0  generate_series(@1, @2)  ·                        ·
      └── hash-join         ·         ·                        (x, z)                   ·
           │                type      semi                     ·                        ·
           │                pred      z < generate_series      ·                        ·
           ├── scan         ·         ·                        (x, z)                   ·
           │                table     xz@primary               ·                        ·
           │                spans     ALL                      ·                        ·
           └── project set  ·         ·                        (x, y, generate_series)  ·
                │           render 0  generate_series(@1, @2)  ·                        ·
                └── scan    ·         ·                        (x, y)                   ·
·                           table     xy@primary               ·                        ·
·                           spans     ALL                      ·                        ·

query TTTTT
EXPLAIN (VERBOSE) SELECT generate_subscripts(ARRAY[0, x, 1, 2]), generate_series(x, y), unnest(ARRAY[0, x, y, z]), y, z
  FROM xy NATURAL LEFT OUTER JOIN xz
----
render                ·               ·                                        (generate_subscripts, generate_series, unnest, y, z)        ·
 │                    render 0        generate_subscripts                      ·                                                           ·
 │                    render 1        generate_series                          ·                                                           ·
 │                    render 2        unnest                                   ·                                                           ·
 │                    render 3        y                                        ·                                                           ·
 │                    render 4        z                                        ·                                                           ·
 └── project set      ·               ·                                        (x, y, x, z, generate_subscripts, generate_series, unnest)  ·
      │               render 0        generate_subscripts(ARRAY[0, @1, 1, 2])  ·                                                           ·
      │               render 1        generate_series(@1, @2)                  ·                                                           ·
      │               render 2        unnest(ARRAY[0, @1, @2, @4])             ·                                                           ·
      └── merge-join  ·               ·                                        (x, y, x, z)                                                ·
           │          type            left outer                               ·                                                           ·
           │          equality        (x) = (x)                                ·                                                           ·
           │          mergeJoinOrder  +"(x=x)"                                 ·                                                           ·
           ├── scan   ·               ·                                        (x, y)                                                      +x
           │          table           xy@primary                               ·                                                           ·
           │          spans           ALL                                      ·                                                           ·
           └── scan   ·               ·                                        (x, z)                                                      +x
·                     table           xz@primary                               ·                                                           ·
·                     spans           ALL                                      ·                                                           ·

query TTTTT
EXPLAIN (VERBOSE) SELECT generate_series((SELECT unnest(ARRAY[x, y]) FROM xy), z) FROM xz
----
root                             ·             ·                                     (generate_series)     ·
 ├── render                      ·             ·                                     (generate_series)     ·
 │    │                          render 0      generate_series                       ·                     ·
 │    └── project set            ·             ·                                     (z, generate_series)  ·
 │         │                     render 0      generate_series(@S1, @1)              ·                     ·
 │         └── scan              ·             ·                                     (z)                   ·
 │                               table         xz@primary                            ·                     ·
 │                               spans         ALL                                   ·                     ·
 └── subquery                    ·             ·                                     (generate_series)     ·
      │                          id            @S1                                   ·                     ·
      │                          original sql  (SELECT unnest(ARRAY[x, y]) FROM xy)  ·                     ·
      │                          exec mode     one row                               ·                     ·
      └── max1row                ·             ·                                     (unnest)              ·
           └── render            ·             ·                                     (unnest)              ·
                │                render 0      unnest                                ·                     ·
                └── project set  ·             ·                                     (x, y, unnest)        ·
                     │           render 0      unnest(ARRAY[@1, @2])                 ·                     ·
                     └── scan    ·             ·                                     (x, y)                ·
·                                table         xy@primary                            ·                     ·
·                                spans         ALL                                   ·                     ·

# Regression test for #24676.
statement ok
CREATE TABLE groups(
  id SERIAL,
  data jsonb,
  primary key (id)
)

query TTTTT
EXPLAIN (VERBOSE) SELECT
  g.data->>'name' AS group_name,
  jsonb_array_elements( (SELECT gg.data->'members' FROM groups gg WHERE gg.data->>'name' = g.data->>'name') )
FROM
  groups g
----
render                ·         ·                         (group_name, jsonb_array_elements)        ·
 │                    render 0  data->>'name'             ·                                         ·
 │                    render 1  jsonb_array_elements      ·                                         ·
 └── project set      ·         ·                         (data, "?column?", jsonb_array_elements)  ·
      │               render 0  jsonb_array_elements(@2)  ·                                         ·
      └── apply-join  ·         ·                         (data, "?column?")                        ·
           │          type      left outer                ·                                         ·
           └── scan   ·         ·                         (data)                                    ·
·                     table     groups@primary            ·                                         ·
·                     spans     ALL                       ·                                         ·

# Regression test for #32162.
query TTTTT
EXPLAIN (VERBOSE) SELECT * FROM ROWS FROM (IF(length('abc') = length('def'), 1, 0))
----
project set    ·         ·  ("if")  ·
 │             render 0  1  ·       ·
 └── emptyrow  ·         ·  ()      ·

statement ok
CREATE TABLE articles (
  id INT PRIMARY KEY,
  body STRING,
  description STRING,
  title STRING,
  slug STRING,
  tag_list STRING[],
  user_id STRING,
  created_at TIMESTAMP,
  updated_at TIMESTAMP
)

# Regression test for #31706.
query TTTTT
EXPLAIN (VERBOSE) SELECT a0.id, a0.body, a0.description, a0.title, a0.slug, a0.tag_list, a0.user_id, a0.created_at, a0.updated_at
    FROM articles AS a0
   WHERE EXISTS(SELECT * FROM unnest(a0.tag_list) AS tag WHERE tag = 'dragons')
ORDER BY a0.created_at
   LIMIT 10
  OFFSET 0;
----
limit                                 ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)          +created_at
 │                                    count        10                         ·                                                                                        ·
 │                                    offset       0                          ·                                                                                        ·
 └── sort                             ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)          +created_at
      │                               order        +created_at                ·                                                                                        ·
      └── group                       ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)          ·
           │                          aggregate 0  id                         ·                                                                                        ·
           │                          aggregate 1  any_not_null(body)         ·                                                                                        ·
           │                          aggregate 2  any_not_null(description)  ·                                                                                        ·
           │                          aggregate 3  any_not_null(title)        ·                                                                                        ·
           │                          aggregate 4  any_not_null(slug)         ·                                                                                        ·
           │                          aggregate 5  any_not_null(tag_list)     ·                                                                                        ·
           │                          aggregate 6  any_not_null(user_id)      ·                                                                                        ·
           │                          aggregate 7  any_not_null(created_at)   ·                                                                                        ·
           │                          aggregate 8  any_not_null(updated_at)   ·                                                                                        ·
           │                          group by     @1                         ·                                                                                        ·
           └── render                 ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)          ·
                │                     render 0     id                         ·                                                                                        ·
                │                     render 1     body                       ·                                                                                        ·
                │                     render 2     description                ·                                                                                        ·
                │                     render 3     title                      ·                                                                                        ·
                │                     render 4     slug                       ·                                                                                        ·
                │                     render 5     tag_list                   ·                                                                                        ·
                │                     render 6     user_id                    ·                                                                                        ·
                │                     render 7     created_at                 ·                                                                                        ·
                │                     render 8     updated_at                 ·                                                                                        ·
                └── filter            ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at, unnest)  ·
                     │                filter       unnest = 'dragons'         ·                                                                                        ·
                     └── project set  ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at, unnest)  ·
                          │           render 0     unnest(@6)                 ·                                                                                        ·
                          └── scan    ·            ·                          (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)          ·
·                                     table        articles@primary           ·                                                                                        ·
·                                     spans        ALL                        ·                                                                                        ·

# Regression test for #32723.
query TTTTT
EXPLAIN (VERBOSE)
    SELECT
        generate_series(a + 1, a + 1)
    FROM
        (SELECT a FROM ((SELECT 1 AS a, 1) EXCEPT ALL (SELECT 0, 0)))
----
render                      ·              ·                                (generate_series)         ·
 │                          render 0       generate_series                  ·                         ·
 └── project set            ·              ·                                (a, a, generate_series)   ·
      │                     render 0       generate_series(@2 + 1, @2 + 1)  ·                         ·
      └── union             ·              ·                                (a, a)                    ·
           ├── render       ·              ·                                (a, a)                    ·
           │    │           render 0       a                                ·                         ·
           │    │           render 1       a                                ·                         ·
           │    └── values  ·              ·                                (a)                       ·
           │                size           1 column, 1 row                  ·                         ·
           │                row 0, expr 0  1                                ·                         ·
           └── render       ·              ·                                ("?column?", "?column?")  ·
                │           render 0       "?column?"                       ·                         ·
                │           render 1       "?column?"                       ·                         ·
                └── values  ·              ·                                ("?column?")              ·
·                           size           1 column, 1 row                  ·                         ·
·                           row 0, expr 0  0                                ·                         ·
