@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/94-tvf-edge-cases.sqllogic

@@ -0,0 +1,58 @@
+-- tvf-edge-cases.sqllogic - Table-valued function edge cases
+-- Targets: table-valued-function.ts — empty results, single elements, subquery usage
+
+-- json_each on empty array → empty result set
+SELECT key, value FROM json_each('[]');
+→ []
+
+-- json_each on empty object → empty result set
+SELECT key, value FROM json_each('{}');
+→ []
+
+-- json_each with single element array
+SELECT key, value, type FROM json_each('[42]');
+→ [{"key":0,"value":42,"type":"integer"}]
+
+-- json_each with single key object
+SELECT key, value, type FROM json_each('{"x": true}');
+→ [{"key":"x","value":true,"type":"true"}]
+
+-- json_each with null value in array
+SELECT key, value, type FROM json_each('[1, null, 3]');
+→ [{"key":0,"value":1,"type":"integer"},{"key":1,"value":null,"type":"null"},{"key":2,"value":3,"type":"integer"}]
+
+-- json_each with nested containers (no recursion)
+SELECT key, type FROM json_each('{"a": [1, 2], "b": {"c": 3}}') ORDER BY key;
+→ [{"key":"a","type":"array"},{"key":"b","type":"object"}]
+
+-- json_each in subquery context
+SELECT count(*) AS cnt FROM (SELECT * FROM json_each('[10, 20, 30]'));
+→ [{"cnt":3}]
+
+-- json_each with WHERE filter eliminating all rows
+SELECT key, value FROM json_each('[1, 2, 3]') WHERE value > 100;
+→ []
+
+-- json_each with WHERE filter keeping some rows
+SELECT value FROM json_each('[10, 20, 30, 40, 50]') WHERE value > 25;
+→ [{"value":30},{"value":40},{"value":50}]
+
+-- json_each with root path on nested object
+SELECT key, value FROM json_each('{"a": {"x": 1, "y": 2}}', '$.a') ORDER BY key;
+→ [{"key":"x","value":1},{"key":"y","value":2}]
+
+-- json_each with aggregation in subquery
+SELECT sum(value) AS total FROM json_each('[10, 20, 30]');
+→ [{"total":60}]
+
+-- json_each with LIMIT
+SELECT value FROM json_each('[1, 2, 3, 4, 5]') LIMIT 3;
+→ [{"value":1},{"value":2},{"value":3}]
+
+-- json_each with boolean values
+SELECT key, value, type FROM json_each('[true, false]');
+→ [{"key":0,"value":true,"type":"true"},{"key":1,"value":false,"type":"false"}]
+
+-- json_each with mixed types
+SELECT key, type FROM json_each('[1, "hello", true, null, 3.14]');
+→ [{"key":0,"type":"integer"},{"key":1,"type":"text"},{"key":2,"type":"true"},{"key":3,"type":"null"},{"key":4,"type":"real"}]

package/test/logic/94.1-limit-offset-edge-cases.sqllogic

@@ -0,0 +1,109 @@
+-- limit-offset-edge-cases.sqllogic - Boundary cases for limit/offset emitter
+-- Targets: limit-offset.ts — LIMIT 0, negative, OFFSET beyond count, empty table
+
+CREATE TABLE lo_t (id INTEGER PRIMARY KEY, val TEXT);
+INSERT INTO lo_t VALUES (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e');
+
+-- LIMIT 0 → empty result
+SELECT * FROM lo_t LIMIT 0;
+→ []
+
+-- LIMIT 0 with OFFSET → empty result
+SELECT * FROM lo_t LIMIT 0 OFFSET 2;
+→ []
+
+-- OFFSET beyond row count → empty result
+SELECT * FROM lo_t ORDER BY id LIMIT 100 OFFSET 100;
+→ []
+
+-- OFFSET = exact row count → empty result
+SELECT * FROM lo_t ORDER BY id LIMIT 100 OFFSET 5;
+→ []
+
+-- LIMIT 1 → first row only
+SELECT * FROM lo_t ORDER BY id LIMIT 1;
+→ [{"id":1,"val":"a"}]
+
+-- LIMIT with OFFSET
+SELECT * FROM lo_t ORDER BY id LIMIT 2 OFFSET 2;
+→ [{"id":3,"val":"c"},{"id":4,"val":"d"}]
+
+-- OFFSET skips some, LIMIT takes remainder
+SELECT * FROM lo_t ORDER BY id LIMIT 100 OFFSET 3;
+→ [{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- Negative LIMIT → treated as 0 (no rows)
+SELECT * FROM lo_t LIMIT -1;
+→ []
+
+-- Negative OFFSET → treated as 0 (no offset)
+SELECT * FROM lo_t ORDER BY id LIMIT 3 OFFSET -1;
+→ [{"id":1,"val":"a"},{"id":2,"val":"b"},{"id":3,"val":"c"}]
+
+-- MySQL-style: LIMIT offset, count
+SELECT * FROM lo_t ORDER BY id LIMIT 2, 3;
+→ [{"id":3,"val":"c"},{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- LIMIT on empty table → empty
+CREATE TABLE lo_empty (id INTEGER PRIMARY KEY, val TEXT);
+
+SELECT * FROM lo_empty LIMIT 10;
+→ []
+
+SELECT * FROM lo_empty LIMIT 0;
+→ []
+
+SELECT * FROM lo_empty LIMIT 10 OFFSET 5;
+→ []
+
+DROP TABLE lo_empty;
+
+-- LIMIT exactly matches row count
+SELECT * FROM lo_t ORDER BY id LIMIT 5;
+→ [{"id":1,"val":"a"},{"id":2,"val":"b"},{"id":3,"val":"c"},{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- Large LIMIT with no practical effect
+SELECT * FROM lo_t ORDER BY id LIMIT 999999;
+→ [{"id":1,"val":"a"},{"id":2,"val":"b"},{"id":3,"val":"c"},{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- LIMIT in subquery
+SELECT * FROM (SELECT id FROM lo_t ORDER BY id LIMIT 3) ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- OFFSET in subquery
+SELECT * FROM (SELECT id FROM lo_t ORDER BY id LIMIT 2 OFFSET 1) ORDER BY id;
+→ [{"id":2},{"id":3}]
+
+-- LIMIT 1 with OFFSET at last row
+SELECT * FROM lo_t ORDER BY id LIMIT 1 OFFSET 4;
+→ [{"id":5,"val":"e"}]
+
+-- LIMIT 1 with OFFSET past last row
+SELECT * FROM lo_t ORDER BY id LIMIT 1 OFFSET 5;
+→ []
+
+-- Cast edge cases (exercises cast.ts fallback paths)
+-- CAST null → null
+SELECT CAST(null AS INTEGER) AS r;
+→ [{"r":null}]
+
+-- CAST non-numeric string to INTEGER → 0 (fallback)
+SELECT CAST('abc' AS INTEGER) AS r;
+→ [{"r":0}]
+
+-- CAST non-numeric string to REAL → 0
+SELECT CAST('xyz' AS REAL) AS r;
+→ [{"r":0}]
+
+-- CAST number to TEXT → string
+SELECT CAST(42 AS TEXT) AS r;
+→ [{"r":"42"}]
+
+-- CAST valid numeric string
+SELECT CAST('123' AS INTEGER) AS r;
+→ [{"r":123}]
+
+SELECT CAST('3.14' AS REAL) AS r;
+→ [{"r":3.14}]
+
+DROP TABLE lo_t;

package/test/logic/94.2-limit-offset-extras.sqllogic

@@ -0,0 +1,98 @@
+-- adapted from SQLite test/limit.test, test/limit2.test, test/select8.test,
+-- test/e_select.test
+-- LIMIT / OFFSET combinations that 94.1 doesn't already cover: expression
+-- operands, OFFSET without LIMIT, interaction with DISTINCT and GROUP BY.
+
+create table le (id integer primary key, val text);
+insert into le values (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e');
+
+-- LIMIT with arithmetic expression
+select * from le order by id limit 1 + 1;
+→ [{"id":1,"val":"a"},{"id":2,"val":"b"}]
+
+-- OFFSET with arithmetic expression
+select * from le order by id limit 10 offset 4 - 2;
+→ [{"id":3,"val":"c"},{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- LIMIT and OFFSET both expression-valued
+select * from le order by id limit 4 / 2 offset 1 + 1;
+→ [{"id":3,"val":"c"},{"id":4,"val":"d"}]
+
+-- OFFSET without LIMIT — Quereus parser requires explicit LIMIT before OFFSET
+select * from le order by id offset 2;
+-- error: offset
+
+-- Equivalent expressed with explicit large LIMIT
+select * from le order by id limit 1000 offset 2;
+→ [{"id":3,"val":"c"},{"id":4,"val":"d"},{"id":5,"val":"e"}]
+
+-- OFFSET equal to row count returns empty
+select * from le order by id limit 1000 offset 5;
+→ []
+
+drop table le;
+
+-- =============================================================================
+-- LIMIT after DISTINCT — DISTINCT runs first, then LIMIT trims
+-- =============================================================================
+
+create table dl (id integer primary key, category text, val integer);
+insert into dl values
+  (1, 'A', 10),
+  (2, 'A', 20),
+  (3, 'B', 10),
+  (4, 'B', 30),
+  (5, 'A', 20),
+  (6, 'C', 50);
+
+select distinct category from dl order by category limit 2;
+→ [{"category":"A"},{"category":"B"}]
+
+select distinct category from dl order by category limit 1 offset 1;
+→ [{"category":"B"}]
+
+-- DISTINCT on multiple columns, then LIMIT
+select distinct category, val from dl order by category, val limit 3;
+→ [{"category":"A","val":10},{"category":"A","val":20},{"category":"B","val":10}]
+
+drop table dl;
+
+-- =============================================================================
+-- LIMIT after GROUP BY aggregate — group reduction first, then LIMIT
+-- =============================================================================
+
+create table gp (id integer primary key, artist text, plays integer);
+insert into gp values
+  (1, 'one',   1),
+  (2, 'one',   2),
+  (3, 'two',   3),
+  (4, 'three', 5),
+  (5, 'one',   7),
+  (6, 'two',  11);
+
+-- Sorted group keys, take first
+select artist, sum(plays) as total
+from gp group by artist
+order by artist limit 1;
+→ [{"artist":"one","total":10}]
+
+-- LIMIT 1 OFFSET 1 — second group in alphabetical order
+select artist, sum(plays) as total
+from gp group by artist
+order by artist limit 1 offset 1;
+→ [{"artist":"three","total":5}]
+
+-- ORDER BY the aggregate, then LIMIT — top-N by aggregate
+select artist, sum(plays) as total
+from gp group by artist
+order by total desc limit 2;
+→ [{"artist":"two","total":14},{"artist":"one","total":10}]
+
+-- HAVING reduces groups, then LIMIT trims further
+select artist, sum(plays) as total
+from gp group by artist
+having sum(plays) > 5
+order by artist limit 1;
+→ [{"artist":"one","total":10}]
+
+drop table gp;