query I
SELECT generate_series FROM generate_series(1, 100) ORDER BY generate_series LIMIT 5;
----
1
2
3
4
5

query I
SELECT generate_series FROM generate_series(1, 100) ORDER BY generate_series FETCH FIRST 5 ROWS ONLY;
----
1
2
3
4
5

query I
SELECT generate_series FROM generate_series(1, 100) ORDER BY generate_series FETCH FIRST ROW ONLY;
----
1

query I
SELECT generate_series FROM generate_series(1, 100) ORDER BY generate_series OFFSET 3 ROWS FETCH NEXT ROW ONLY;
----
4

statement error syntax error
SELECT generate_series FROM generate_series(1, 100) FETCH NEXT ROW ONLY LIMIT 3;

statement error syntax error
SELECT generate_series FROM generate_series(1, 100) LIMIT 3 FETCH NEXT ROW ONLY;

statement error syntax error
SELECT generate_series FROM generate_series(1, 100) FETCH NEXT 1 + 1 ROWS ONLY;

query I
SELECT generate_series FROM generate_series(1, 100) ORDER BY generate_series FETCH FIRST (1 + 1) ROWS ONLY;
----
1
2

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

statement ok
INSERT INTO t VALUES (1, 1, 1), (2, -4, 8), (3, 9, 27), (4, -16, 94), (5, 25, 125), (6, -36, 216)

# Verify we don't incorrectly impose a hard limit at the index scan level.
query III
SELECT * FROM t WHERE v > -20 AND w > 30 ORDER BY v LIMIT 2
----
4  -16  94
5  25   125

query II
SELECT k, v FROM t ORDER BY k LIMIT 5
----
1  1
2  -4
3  9
4  -16
5  25

query II
SELECT k, v FROM t ORDER BY k OFFSET 5
----
6  -36

query II
SELECT k, v FROM t ORDER BY v LIMIT (1+4) OFFSET 1
----
4  -16
2  -4
1  1
3  9
5  25

query II
SELECT k, v FROM t ORDER BY v DESC LIMIT (1+4) OFFSET 1
----
3  9
1  1
2  -4
4  -16
6  -36

query R
SELECT sum(w) FROM t GROUP BY k, v ORDER BY v DESC LIMIT 10
----
125
27
1
8
94
216

query I
SELECT k FROM (SELECT k, v FROM t ORDER BY v LIMIT 4)
----
6
4
2
1

query I
SELECT k FROM (SELECT k, v, w FROM t ORDER BY v LIMIT 4)
----
6
4
2
1

# Use expression for LIMIT/OFFSET value.
query II
SELECT k, v FROM t ORDER BY k LIMIT length(pg_typeof(123))
----
1  1
2  -4
3  9
4  -16
5  25
6  -36

query II
SELECT k, v FROM t ORDER BY k LIMIT length(pg_typeof(123)) OFFSET length(pg_typeof(123))-2
----
5  25
6  -36

query II
SELECT k, v FROM t ORDER BY k OFFSET (SELECT count(*)-3 FROM t)
----
4  -16
5  25
6  -36

query II
SELECT k, v FROM t ORDER BY k LIMIT (SELECT count(*)-3 FROM t) OFFSET (SELECT count(*)-5 FROM t)
----
2  -4
3  9
4  -16

# Test sort node with both filter and limit. (https://github.com/cockroachdb/cockroach/issues/31163)
statement ok
SET TRACING = ON; SELECT 1; SET TRACING = OFF

query I
SELECT SPAN FROM [SHOW TRACE FOR SESSION] WHERE span = 1 LIMIT 1
----
1

# Regression test for #38659: offset on top of limit was broken.

query I nosort
SELECT * FROM (select * from generate_series(1,10) a LIMIT 5) OFFSET 3
----
4
5

query I
SELECT * FROM (select * from generate_series(1,10) a LIMIT 5) OFFSET 6
----

# Regression test for #47283: scan with both hard limit and soft limit.
statement ok
CREATE TABLE t_47283(k INT PRIMARY KEY, a INT)

statement ok
INSERT INTO t_47283 VALUES (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)

# This should return no results; if it does, we incorrectly removed the hard
# limit in the scan.
query II
SELECT * FROM (SELECT * FROM t_47283 ORDER BY k LIMIT 4) WHERE a > 5 LIMIT 1
----

# Test various combinations of LIMIT and OFFSET with values coming from
# subqueries, including values that can cause overflows.
statement ok
CREATE TABLE vals (k STRING PRIMARY KEY, v INT);
INSERT INTO vals VALUES ('zero', 0), ('one', 1), ('large', 9223372036854775806), ('maxint64', 9223372036854775807);
CREATE TABLE probe (a INT PRIMARY KEY);
INSERT INTO probe VALUES (1), (2), (3), (4);

# No offset.
query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'zero');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'one');
----
1

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'large');
----
1
2
3
4

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'maxint64');
----
1
2
3
4

# No limit.
query I
SELECT a FROM probe ORDER BY a OFFSET (SELECT v FROM vals WHERE k = 'zero');
----
1
2
3
4

query I
SELECT a FROM probe ORDER BY a OFFSET (SELECT v FROM vals WHERE k = 'one');
----
2
3
4

query I
SELECT a FROM probe ORDER BY a OFFSET (SELECT v FROM vals WHERE k = 'large');
----

query I
SELECT a FROM probe ORDER BY a OFFSET (SELECT v FROM vals WHERE k = 'maxint64');
----


# Offset zero.
query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'zero') OFFSET (SELECT v FROM vals WHERE k = 'zero');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'one') OFFSET (SELECT v FROM vals WHERE k = 'zero');
----
1

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'large') OFFSET (SELECT v FROM vals WHERE k = 'zero');
----
1
2
3
4

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'maxint64') OFFSET (SELECT v FROM vals WHERE k = 'zero');
----
1
2
3
4

# Offset one.
query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'zero') OFFSET (SELECT v FROM vals WHERE k = 'one');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'one') OFFSET (SELECT v FROM vals WHERE k = 'one');
----
2

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'large') OFFSET (SELECT v FROM vals WHERE k = 'one');
----
2
3
4

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'maxint64') OFFSET (SELECT v FROM vals WHERE k = 'one');
----
2
3
4

# Offset large.
query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'zero') OFFSET (SELECT v FROM vals WHERE k = 'large');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'one') OFFSET (SELECT v FROM vals WHERE k = 'large');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'large') OFFSET (SELECT v FROM vals WHERE k = 'large');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'maxint64') OFFSET (SELECT v FROM vals WHERE k = 'large');
----

# Offset maxint64.
query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'zero') OFFSET (SELECT v FROM vals WHERE k = 'maxint64');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'one') OFFSET (SELECT v FROM vals WHERE k = 'maxint64');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'large') OFFSET (SELECT v FROM vals WHERE k = 'maxint64');
----

query I
SELECT a FROM probe ORDER BY a LIMIT (SELECT v FROM vals WHERE k = 'maxint64') OFFSET (SELECT v FROM vals WHERE k = 'maxint64');
----

# Regression test for incorrectly treating LIMIT query as containing full scan (Issue #60751).
statement ok
SET disallow_full_table_scans = true;

query I
SELECT w FROM t ORDER BY k LIMIT 1;
----
1

statement ok
SET disallow_full_table_scans = false;

# Regression test for incorrectly de-duplicating rows before reaching LIMIT. (Issue #65171)
statement ok
CREATE TABLE t65171 (x INT, y INT, INDEX(x, y))

statement ok
INSERT INTO t65171 VALUES (1, 2), (1, 2), (2, 3)

query II
SELECT * FROM t65171 WHERE x = 1 OR x = 2 ORDER BY y LIMIT 2
----
1  2
1  2

query III
SELECT * FROM t ORDER BY v, w LIMIT 3;
----
6  -36  216
4  -16  94
2  -4   8

query IT
SELECT oid::INT, typname FROM pg_type ORDER BY oid LIMIT 3
----
16  bool
17  bytea
18  char

# Regression test for limit hint overflowing int64 range and becoming negative.
statement ok
SELECT * FROM t65171 WHERE x = 1 OFFSET 1 LIMIT 9223372036854775807

# Regression test for #122748. Do not drop the limit in the row-based engine when
# a partial sort is needed.
statement ok
CREATE TABLE t122748 (a int, b int, INDEX t_b_idx (b ASC) STORING (a));
INSERT INTO t122748 VALUES
  (1, 2),
  (3, 4),
  (5, 6)

query I
SELECT count(*) AS col1
FROM t122748
GROUP BY a, b
ORDER BY b, a DESC
LIMIT 2
----
1
1
