# LogicTest: local

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

# There must be no limit at the index scan level.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT * FROM t WHERE v > 4 AND w > 30 ORDER BY v LIMIT 2
----
tree             field   description  columns                      ordering
limit            ·       ·            (k, v, w)                    k!=NULL; v!=NULL; w!=NULL; key(k,v); +v
 │               count   2            ·                            ·
 └── index-join  ·       ·            (k, v, w)                    k!=NULL; v!=NULL; w!=NULL; key(k,v); +v
      ├── scan   ·       ·            (k, v[omitted], w[omitted])  k!=NULL; v!=NULL; w!=NULL; key(k,v); +v
      │          table   t@t_v_idx    ·                            ·
      │          spans   /5-          ·                            ·
      └── scan   ·       ·            (k, v, w)                    ·
·                table   t@primary    ·                            ·
·                filter  w > 30       ·                            ·

# This kind of query can be used to work around memory usage limits. We need to
# choose the "hard" limit of 100 over the "soft" limit of 25 (with the hard
# limit we will only store 100 rows in the sort node). See #19677.
query TTTTT colnames
EXPLAIN (VERBOSE) SELECT DISTINCT w FROM (SELECT w FROM t ORDER BY w LIMIT 100) ORDER BY w LIMIT 25
----
tree                           field      description      columns                      ordering
limit                          ·          ·                (w)                          weak-key(w); +w
 │                             count      25               ·                            ·
 └── distinct                  ·          ·                (w)                          weak-key(w); +w
      │                        order key  w                ·                            ·
      └── limit                ·          ·                (w)                          +w
           │                   count      100              ·                            ·
           └── sort            ·          ·                (w)                          +w
                │              order      +w               ·                            ·
                │              strategy   top 100          ·                            ·
                └── render     ·          ·                (w)                          ·
                     │         render 0   test.public.t.w  ·                            ·
                     └── scan  ·          ·                (k[omitted], v[omitted], w)  k!=NULL; key(k)
·                              table      t@primary        ·                            ·
·                              spans      ALL              ·                            ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k, v FROM t ORDER BY k LIMIT 5
----
limit           ·         ·                (k, v)              k!=NULL; key(k); +k
 │              count     5                ·                   ·
 └── render     ·         ·                (k, v)              k!=NULL; key(k); +k
      │         render 0  test.public.t.k  ·                   ·
      │         render 1  test.public.t.v  ·                   ·
      └── scan  ·         ·                (k, v, w[omitted])  k!=NULL; key(k); +k
·               table     t@primary        ·                   ·
·               spans     ALL              ·                   ·
·               limit     5                ·                   ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k, v FROM t ORDER BY k OFFSET 5
----
limit                ·         ·                (k, v)              k!=NULL; weak-key(k,v); +k
 │                   offset    5                ·                   ·
 └── sort            ·         ·                (k, v)              k!=NULL; weak-key(k,v); +k
      │              order     +k               ·                   ·
      └── render     ·         ·                (k, v)              k!=NULL; weak-key(k,v)
           │         render 0  test.public.t.k  ·                   ·
           │         render 1  test.public.t.v  ·                   ·
           └── scan  ·         ·                (k, v, w[omitted])  k!=NULL; weak-key(k,v)
·                    table     t@t_v_idx        ·                   ·
·                    spans     ALL              ·                   ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k, v FROM t ORDER BY v LIMIT (1+4) OFFSET 1
----
limit           ·         ·                (k, v)              k!=NULL; weak-key(k,v); +v
 │              count     5                ·                   ·
 │              offset    1                ·                   ·
 └── render     ·         ·                (k, v)              k!=NULL; weak-key(k,v); +v
      │         render 0  test.public.t.k  ·                   ·
      │         render 1  test.public.t.v  ·                   ·
      └── scan  ·         ·                (k, v, w[omitted])  k!=NULL; weak-key(k,v); +v
·               table     t@t_v_idx        ·                   ·
·               spans     ALL              ·                   ·
·               limit     6                ·                   ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k, v FROM t ORDER BY v DESC LIMIT (1+4) OFFSET 1
----
limit              ·         ·                (k, v)              k!=NULL; weak-key(k,v); -v
 │                 count     5                ·                   ·
 │                 offset    1                ·                   ·
 └── render        ·         ·                (k, v)              k!=NULL; weak-key(k,v); -v
      │            render 0  test.public.t.k  ·                   ·
      │            render 1  test.public.t.v  ·                   ·
      └── revscan  ·         ·                (k, v, w[omitted])  k!=NULL; weak-key(k,v); -v
·                  table     t@t_v_idx        ·                   ·
·                  spans     ALL              ·                   ·
·                  limit     6                ·                   ·

query TTTTT
EXPLAIN (VERBOSE) SELECT sum(w) FROM t GROUP BY k, v ORDER BY v DESC LIMIT 10
----
limit                ·            ·          (sum)      ·
 │                   count        10         ·          ·
 └── sort            ·            ·          (sum)      ·
      │              order        -v         ·          ·
      │              strategy     top 10     ·          ·
      └── group      ·            ·          (sum, v)   weak-key(v)
           │         aggregate 0  sum(w)     ·          ·
           │         aggregate 1  v          ·          ·
           │         group by     @1-@2      ·          ·
           │         ordered      @1         ·          ·
           └── scan  ·            ·          (k, v, w)  k!=NULL; key(k)
·                    table        t@primary  ·          ·
·                    spans        ALL        ·          ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k FROM (SELECT k, v FROM t ORDER BY v LIMIT 4)
----
render               ·         ·                (k)                          k!=NULL
 │                   render 0  k                ·                            ·
 └── limit           ·         ·                (k, v[omitted])              k!=NULL; weak-key(k,v); +v
      │              count     4                ·                            ·
      └── render     ·         ·                (k, v[omitted])              k!=NULL; weak-key(k,v); +v
           │         render 0  test.public.t.k  ·                            ·
           │         render 1  NULL             ·                            ·
           └── scan  ·         ·                (k, v[omitted], w[omitted])  k!=NULL; weak-key(k,v); +v
·                    table     t@t_v_idx        ·                            ·
·                    spans     ALL              ·                            ·
·                    limit     4                ·                            ·

query TTTTT
EXPLAIN (VERBOSE) SELECT k FROM (SELECT k, v, w FROM t ORDER BY v LIMIT 4)
----
render          ·         ·          (k)                          k!=NULL
 │              render 0  k          ·                            ·
 └── limit      ·         ·          (k, v[omitted], w[omitted])  k!=NULL; weak-key(k,v); +v
      │         count     4          ·                            ·
      └── scan  ·         ·          (k, v[omitted], w[omitted])  k!=NULL; weak-key(k,v); +v
·               table     t@t_v_idx  ·                            ·
·               spans     ALL        ·                            ·
·               limit     4          ·                            ·
