# LogicTest: local

subtest generate_series

query T
EXPLAIN SELECT * FROM generate_series(1, 3)
----
distribution: local
vectorized: true
·
• project set
│ estimated row count: 10
│
└── • emptyrow

query T
EXPLAIN SELECT * FROM generate_series(1, 2), generate_series(1, 2)
----
distribution: local
vectorized: true
·
• cross join
│ estimated row count: 100
│
├── • project set
│   │ estimated row count: 10
│   │
│   └── • emptyrow
│
└── • project set
    │ estimated row count: 10
    │
    └── • emptyrow

query T
EXPLAIN SELECT * FROM ROWS FROM (cos(1))
----
distribution: local
vectorized: true
·
• project set
│ estimated row count: 1
│
└── • emptyrow

query T
EXPLAIN SELECT generate_series(1, 3)
----
distribution: local
vectorized: true
·
• project set
│ estimated row count: 10
│
└── • emptyrow

subtest multiple_SRFs
# See #20511

query T
EXPLAIN SELECT generate_series(1, 2), generate_series(1, 2)
----
distribution: local
vectorized: true
·
• project set
│ estimated row count: 10
│
└── • emptyrow

statement ok
CREATE TABLE t (a string)

statement ok
CREATE TABLE u (b string)

query T
EXPLAIN (VERBOSE) SELECT t.*, u.*, generate_series(1,2), generate_series(3, 4) FROM t, u
----
distribution: local
vectorized: true
·
• cross join (inner)
│ columns: (a, b, generate_series, generate_series)
│ estimated row count: 10,000,000 (missing stats)
│
├── • cross join (inner)
│   │ columns: (a, b)
│   │ estimated row count: 1,000,000 (missing stats)
│   │
│   ├── • scan
│   │     columns: (a)
│   │     estimated row count: 1,000 (missing stats)
│   │     table: t@t_pkey
│   │     spans: FULL SCAN
│   │
│   └── • scan
│         columns: (b)
│         estimated row count: 1,000 (missing stats)
│         table: u@u_pkey
│         spans: FULL SCAN
│
└── • project set
    │ columns: (generate_series, generate_series)
    │ estimated row count: 10
    │ render 0: generate_series(1, 2)
    │ render 1: generate_series(3, 4)
    │
    └── • emptyrow
          columns: ()

subtest correlated_SRFs

statement ok
CREATE TABLE data (a INT PRIMARY KEY)

query T
EXPLAIN (VERBOSE) SELECT a, generate_series(a, a + 1) FROM data ORDER BY 1, 2
----
distribution: local
vectorized: true
·
• sort
│ columns: (a, generate_series)
│ estimated row count: 10,000 (missing stats)
│ order: +a,+generate_series
│
└── • project set
    │ columns: (a, generate_series)
    │ estimated row count: 10,000 (missing stats)
    │ render 0: generate_series(a, a + 1)
    │
    └── • scan
          columns: (a)
          estimated row count: 1,000 (missing stats)
          table: data@data_pkey
          spans: FULL SCAN

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

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

query T
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
----
distribution: local
vectorized: true
·
• sort
│ columns: (x, y, z, "information_schema._pg_expandarray")
│ estimated row count: 3,267 (missing stats)
│ order: +x
│
└── • render
    │ columns: ("information_schema._pg_expandarray", x, y, z)
    │ render information_schema._pg_expandarray: ((x, n) AS x, n)
    │ render x: x
    │ render y: y
    │ render z: z
    │
    └── • project set
        │ columns: (x, y, x, z, x, n)
        │ estimated row count: 3,267 (missing stats)
        │ render 0: information_schema._pg_expandarray(ARRAY[x, y, z])
        │
        └── • merge join (inner)
            │ columns: (x, y, x, z)
            │ estimated row count: 327 (missing stats)
            │ equality: (x) = (x)
            │ left cols are key
            │ right cols are key
            │ pred: y < z
            │ merge ordering: +"(x=x)"
            │
            ├── • scan
            │     columns: (x, y)
            │     ordering: +x
            │     estimated row count: 1,000 (missing stats)
            │     table: xy@xy_pkey
            │     spans: FULL SCAN
            │
            └── • scan
                  columns: (x, z)
                  ordering: +x
                  estimated row count: 1,000 (missing stats)
                  table: xz@xz_pkey
                  spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT generate_series(x, z) FROM xz WHERE z < ANY(SELECT generate_series(x, y) FROM xy)
----
distribution: local
vectorized: true
·
• project
│ columns: (generate_series)
│
└── • project set
    │ columns: (x, z, generate_series)
    │ estimated row count: 3,333 (missing stats)
    │ render 0: generate_series(x, z)
    │
    └── • cross join (right semi)
        │ columns: (x, z)
        │ estimated row count: 333 (missing stats)
        │ pred: z < generate_series
        │
        ├── • project set
        │   │ columns: (x, y, generate_series)
        │   │ estimated row count: 10,000 (missing stats)
        │   │ render 0: generate_series(x, y)
        │   │
        │   └── • scan
        │         columns: (x, y)
        │         estimated row count: 1,000 (missing stats)
        │         table: xy@xy_pkey
        │         spans: FULL SCAN
        │
        └── • scan
              columns: (x, z)
              estimated row count: 1,000 (missing stats)
              table: xz@xz_pkey
              spans: FULL SCAN

query T
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
----
distribution: local
vectorized: true
·
• project
│ columns: (generate_subscripts, generate_series, unnest, y, z)
│
└── • project set
    │ columns: (x, y, x, z, generate_subscripts, generate_series, unnest)
    │ estimated row count: 10,000 (missing stats)
    │ render 0: generate_subscripts(ARRAY[0, x, 1, 2])
    │ render 1: generate_series(x, y)
    │ render 2: unnest(ARRAY[0, x, y, z])
    │
    └── • merge join (left outer)
        │ columns: (x, y, x, z)
        │ estimated row count: 1,000 (missing stats)
        │ equality: (x) = (x)
        │ left cols are key
        │ right cols are key
        │ merge ordering: +"(x=x)"
        │
        ├── • scan
        │     columns: (x, y)
        │     ordering: +x
        │     estimated row count: 1,000 (missing stats)
        │     table: xy@xy_pkey
        │     spans: FULL SCAN
        │
        └── • scan
              columns: (x, z)
              ordering: +x
              estimated row count: 1,000 (missing stats)
              table: xz@xz_pkey
              spans: FULL SCAN

query T
EXPLAIN (VERBOSE) SELECT generate_series((SELECT unnest(ARRAY[x, y]) FROM xy), z) FROM xz
----
distribution: local
vectorized: true
·
• root
│ columns: (generate_series)
│
├── • project
│   │ columns: (generate_series)
│   │
│   └── • project set
│       │ columns: (z, generate_series)
│       │ estimated row count: 10,000 (missing stats)
│       │ render 0: generate_series(@S1, z)
│       │
│       └── • scan
│             columns: (z)
│             estimated row count: 1,000 (missing stats)
│             table: xz@xz_pkey
│             spans: FULL SCAN
│
└── • subquery
    │ id: @S1
    │ original sql: (SELECT unnest(ARRAY[x, y]) FROM xy)
    │ exec mode: one row
    │
    └── • max1row
        │ columns: (unnest)
        │ estimated row count: 1
        │
        └── • project
            │ columns: (unnest)
            │
            └── • apply join (inner)
                │ columns: (x, y, unnest)
                │ estimated row count: 2,000 (missing stats)
                │
                └── • scan
                      columns: (x, y)
                      estimated row count: 1,000 (missing stats)
                      table: xy@xy_pkey
                      spans: FULL SCAN

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

query T
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
----
distribution: local
vectorized: true
·
• render
│ columns: (group_name, jsonb_array_elements)
│ render group_name: data->>'name'
│ render jsonb_array_elements: jsonb_array_elements
│
└── • project set
    │ columns: (id, data, "?column?", jsonb_array_elements)
    │ estimated row count: 100,000 (missing stats)
    │ render 0: jsonb_array_elements("?column?")
    │
    └── • distinct
        │ columns: (id, data, "?column?")
        │ estimated row count: 10,000 (missing stats)
        │ distinct on: id
        │ error on duplicate
        │
        └── • project
            │ columns: (id, data, "?column?")
            │
            └── • hash join (left outer)
                │ columns: (column16, id, data, column17, "?column?")
                │ estimated row count: 10,000 (missing stats)
                │ equality: (column16) = (column17)
                │
                ├── • render
                │   │ columns: (column16, id, data)
                │   │ render column16: data->>'name'
                │   │ render id: id
                │   │ render data: data
                │   │
                │   └── • scan
                │         columns: (id, data)
                │         estimated row count: 1,000 (missing stats)
                │         table: groups@groups_pkey
                │         spans: FULL SCAN
                │
                └── • render
                    │ columns: (column17, "?column?")
                    │ render column17: data->>'name'
                    │ render ?column?: data->'members'
                    │
                    └── • scan
                          columns: (data)
                          estimated row count: 1,000 (missing stats)
                          table: groups@groups_pkey
                          spans: FULL SCAN

# Regression test for #32162.
query T
EXPLAIN (VERBOSE) SELECT * FROM ROWS FROM (IF(length('abc') = length('def'), 1, 0))
----
distribution: local
vectorized: true
·
• project set
│ columns: ("if")
│ estimated row count: 1
│ render 0: 1
│
└── • emptyrow
      columns: ()

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 T
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;
----
distribution: local
vectorized: true
·
• top-k
│ columns: (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)
│ estimated row count: 10 (missing stats)
│ order: +any_not_null
│ k: 10
│
└── • group (hash)
    │ columns: (id, any_not_null, any_not_null, any_not_null, any_not_null, any_not_null, any_not_null, any_not_null, any_not_null)
    │ estimated row count: 14 (missing stats)
    │ aggregate 0: any_not_null(body)
    │ aggregate 1: any_not_null(description)
    │ aggregate 2: any_not_null(title)
    │ aggregate 3: any_not_null(slug)
    │ aggregate 4: any_not_null(tag_list)
    │ aggregate 5: any_not_null(user_id)
    │ aggregate 6: any_not_null(created_at)
    │ aggregate 7: any_not_null(updated_at)
    │ group by: id
    │
    └── • project
        │ columns: (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)
        │
        └── • filter
            │ columns: (id, body, description, title, slug, tag_list, user_id, created_at, updated_at, unnest)
            │ estimated row count: 14 (missing stats)
            │ filter: unnest = 'dragons'
            │
            └── • project set
                │ columns: (id, body, description, title, slug, tag_list, user_id, created_at, updated_at, unnest)
                │ estimated row count: 10,000 (missing stats)
                │ render 0: unnest(tag_list)
                │
                └── • scan
                      columns: (id, body, description, title, slug, tag_list, user_id, created_at, updated_at)
                      estimated row count: 1,000 (missing stats)
                      table: articles@articles_pkey
                      spans: FULL SCAN

# Regression test for #32723.
query T
EXPLAIN (VERBOSE)
    SELECT
        generate_series(a + 1, a + 1)
    FROM
        (SELECT a FROM ((SELECT 1 AS a, 1) EXCEPT ALL (SELECT 0, 0)))
----
distribution: local
vectorized: true
·
• project
│ columns: (generate_series)
│
└── • project set
    │ columns: (a, generate_series)
    │ estimated row count: 10
    │ render 0: generate_series(a + 1, a + 1)
    │
    └── • project
        │ columns: (a)
        │
        └── • except all
            │ columns: (a, a)
            │ estimated row count: 1
            │
            ├── • project
            │   │ columns: (a, a)
            │   │
            │   └── • values
            │         columns: (a)
            │         size: 1 column, 1 row
            │         row 0, expr 0: 1
            │
            └── • project
                │ columns: ("?column?", "?column?")
                │
                └── • values
                      columns: ("?column?")
                      size: 1 column, 1 row
                      row 0, expr 0: 0
