@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/17-weekday-modifier.sqllogic

@@ -0,0 +1,78 @@
+-- weekday modifier tests
+-- SQLite "weekday N" advances the date forward to the next occurrence of
+-- weekday N (0=Sunday..6=Saturday). If the date is already on that weekday,
+-- no change is made.
+
+-- 2024-07-22 is a Monday (weekday 1)
+
+-- Same weekday → no change
+SELECT date('2024-07-22', 'weekday 1');
+→ ["2024-07-22"]
+
+-- Monday → next Tuesday (1 day forward)
+SELECT date('2024-07-22', 'weekday 2');
+→ ["2024-07-23"]
+
+-- Monday → next Wednesday (2 days forward)
+SELECT date('2024-07-22', 'weekday 3');
+→ ["2024-07-24"]
+
+-- Monday → next Thursday (3 days forward)
+SELECT date('2024-07-22', 'weekday 4');
+→ ["2024-07-25"]
+
+-- Monday → next Friday (4 days forward)
+SELECT date('2024-07-22', 'weekday 5');
+→ ["2024-07-26"]
+
+-- Monday → next Saturday (5 days forward)
+SELECT date('2024-07-22', 'weekday 6');
+→ ["2024-07-27"]
+
+-- Monday → next Sunday (6 days forward)
+SELECT date('2024-07-22', 'weekday 0');
+→ ["2024-07-28"]
+
+-- 2024-07-26 is a Friday (weekday 5)
+
+-- Friday → same Friday (no change)
+SELECT date('2024-07-26', 'weekday 5');
+→ ["2024-07-26"]
+
+-- Friday → next Saturday (1 day forward)
+SELECT date('2024-07-26', 'weekday 6');
+→ ["2024-07-27"]
+
+-- Friday → next Sunday (2 days forward)
+SELECT date('2024-07-26', 'weekday 0');
+→ ["2024-07-28"]
+
+-- Friday → next Monday (3 days forward)
+SELECT date('2024-07-26', 'weekday 1');
+→ ["2024-07-29"]
+
+-- Friday → next Wednesday (5 days forward)
+SELECT date('2024-07-26', 'weekday 3');
+→ ["2024-07-31"]
+
+-- 2024-07-28 is a Sunday (weekday 0)
+
+-- Sunday → same Sunday (no change)
+SELECT date('2024-07-28', 'weekday 0');
+→ ["2024-07-28"]
+
+-- Sunday → next Monday (1 day forward)
+SELECT date('2024-07-28', 'weekday 1');
+→ ["2024-07-29"]
+
+-- Sunday → next Saturday (6 days forward)
+SELECT date('2024-07-28', 'weekday 6');
+→ ["2024-08-03"]
+
+-- Weekday modifier with datetime function
+SELECT datetime('2024-07-22 10:30:00', 'weekday 3');
+→ ["2024-07-24 10:30:00"]
+
+-- Weekday modifier combined with start of day
+SELECT datetime('2024-07-22 10:30:00', 'weekday 3', 'start of day');
+→ ["2024-07-24 00:00:00"]

package/test/logic/18-json-string-escapes.sqllogic

@@ -0,0 +1,86 @@
+-- 18-json-string-escapes.sqllogic
+-- adapted from SQLite test/json101.test (json101-1.2 and surrounding escape coverage)
+-- Standard JSON string-escape sequences round-trip through JSON construction
+-- and quoting. Quereus uses native JSON.parse / JSON.stringify, so the standard
+-- two-character escapes (\" \\ \/ \b \f \n \r \t) and \uXXXX must round-trip.
+
+-- ============================================================
+-- json_quote: escape characters in strings
+-- ============================================================
+
+SELECT json_quote('String "\ Test');
+→ [{"json_quote('String \"\\ Test')":"\"String \\\"\\\\ Test\""}]
+
+-- Double quote (use char(92) to obtain a literal backslash safely)
+SELECT json_quote('he said "hi"');
+→ [{"json_quote('he said \"hi\"')":"\"he said \\\"hi\\\"\""}]
+
+-- Newline character inside string literal (real LF)
+SELECT json_quote('a
+b');
+→ [{"json_quote('a\nb')":"\"a\\nb\""}]
+
+-- ============================================================
+-- json_array: round-trip strings with embedded escapes
+-- ============================================================
+
+-- Embedded double-quote in array element
+SELECT json_array('he said "hi"');
+→ [["he said \"hi\""]]
+
+SELECT json_array('a\\b');
+→ [["a\\\\b"]]
+
+-- Embedded forward slash (no escape required)
+SELECT json_array('a/b');
+→ [["a/b"]]
+
+-- ============================================================
+-- json_extract: parse strings with standard escape sequences
+-- ============================================================
+
+SELECT json_extract('{"a":"he said \"hi\""}', '$.a');
+→ ["he said \"hi\""]
+
+SELECT json_extract('{"a":"a\\b"}', '$.a');
+→ ["a\\b"]
+
+SELECT json_extract('{"a":"line1\nline2"}', '$.a');
+→ ["line1\nline2"]
+
+SELECT json_extract('{"a":"col1\tcol2"}', '$.a');
+→ ["col1\tcol2"]
+
+-- \uXXXX: ASCII letter (no backslash so not affected)
+SELECT json_extract('{"a":"A"}', '$.a');
+→ ["A"]
+
+-- \uXXXX: Latin-1 supplement (literal char in SQL source)
+SELECT json_extract('{"a":"é"}', '$.a');
+→ ["é"]
+
+-- Surrogate pair: U+1D11E (musical G clef, literal)
+SELECT json_extract('{"a":"𝄞"}', '$.a');
+→ ["𝄞"]
+
+-- ============================================================
+-- json_valid: malformed escape sequences rejected
+-- ============================================================
+
+SELECT json_valid('{"a":"\xZZ"}');
+→ [{"json_valid('{\"a\":\"\\xZZ\"}')":false}]
+
+SELECT json_valid('{"a":"\u00"}');
+→ [{"json_valid('{\"a\":\"\\u00\"}')":false}]
+
+-- ============================================================
+-- json_array_length on a string containing a structural character
+-- ============================================================
+
+-- Comma inside a quoted string must not be treated as element separator
+SELECT json_array_length('["a,b","c,d","e"]');
+→ [3]
+
+-- Bracket inside a quoted string must not break parsing
+SELECT json_array_length('["[","]","["]');
+→ [3]

package/test/logic/18-strftime-extended-formats.sqllogic

@@ -0,0 +1,68 @@
+-- 18-strftime-extended-formats.sqllogic
+-- adapted from SQLite test/date4.test
+-- Extended strftime format specifiers beyond what 16-epoch.sqllogic and
+-- 24-builtin-branches.sqllogic exercise. Per docs/datetime.md %W is documented
+-- as the ISO 8601 week number; we also probe the SQLite-aliased forms %U
+-- (Sunday-first week), %V (ISO week), %G (ISO week-numbering year), and
+-- %g (two-digit ISO year).
+
+-- ============================================================
+-- %W — ISO 8601 week number (already documented)
+-- ============================================================
+
+-- 2024-01-01 is a Monday → ISO week 01
+SELECT strftime('%W', '2024-01-01');
+→ ["01"]
+
+-- 2024-12-30 is a Monday → ISO week 53? No: 2024 W01 = 2024-01-01..07; 2024-12-30 is W53? Actually 2024 has 52 ISO weeks, week 1 starts on 2024-01-01. 2024-12-30 falls in W01 of 2025.
+SELECT strftime('%W', '2024-12-30');
+→ ["01"]
+
+-- ============================================================
+-- %V — ISO 8601 week of year (01-53). Often equal to %W.
+-- ============================================================
+
+-- 2024-01-01 (Monday) is ISO week 01
+SELECT strftime('%V', '2024-01-01');
+→ ["01"]
+
+-- 2023-01-01 (Sunday) is ISO week 52 of year 2022
+SELECT strftime('%V', '2023-01-01');
+→ ["52"]
+
+-- ============================================================
+-- %G — ISO 8601 week-numbering year (4-digit)
+-- ============================================================
+
+-- 2023-01-01 is in ISO year 2022
+SELECT strftime('%G', '2023-01-01');
+→ ["2022"]
+
+-- 2024-12-30 is in ISO year 2025
+SELECT strftime('%G', '2024-12-30');
+→ ["2025"]
+
+-- ============================================================
+-- %g — ISO 8601 week-numbering year (2-digit)
+-- ============================================================
+
+-- 2023-01-01 → ISO year 22
+SELECT strftime('%g', '2023-01-01');
+→ ["22"]
+
+-- 2024-12-30 → ISO year 25
+SELECT strftime('%g', '2024-12-30');
+→ ["25"]
+
+-- ============================================================
+-- %U — Sunday-first week of year (00-53)
+-- Quereus does not implement %U; per docs/datetime.md unsupported
+-- specifiers are output literally.
+-- ============================================================
+
+SELECT strftime('%U', '2024-01-01');
+→ ["%U"]
+
+SELECT strftime('%U', '2024-01-07');
+→ ["%U"]
+

package/test/logic/20-empty-single-row.sqllogic

@@ -0,0 +1,261 @@
+-- empty-single-row.sqllogic - Edge-case tests for empty tables, single-row tables, and empty set operations
+
+-- =============================================================================
+-- Empty table tests (0 rows)
+-- =============================================================================
+
+-- Setup empty table
+create table e (id integer primary key, val text, num integer);
+
+-- Setup populated table
+create table p (id integer primary key, val text);
+insert into p values (1, 'p1'), (2, 'p2'), (3, 'p3');
+
+-- -----------------------------------------------------------------------------
+-- 1. SELECT from empty table
+-- -----------------------------------------------------------------------------
+
+select * from e;
+→ []
+
+select * from e where id > 0;
+→ []
+
+select id, val from e;
+→ []
+
+-- -----------------------------------------------------------------------------
+-- 2. Aggregates over empty table
+-- -----------------------------------------------------------------------------
+
+select count(*) from e;
+→ [{"count(*)":0}]
+
+select count(val) from e;
+→ [{"count(val)":0}]
+
+select sum(num) from e;
+→ [{"sum(num)":null}]
+
+select avg(num) from e;
+→ [{"avg(num)":null}]
+
+select min(num) from e;
+→ [{"min(num)":null}]
+
+select max(num) from e;
+→ [{"max(num)":null}]
+
+select group_concat(val, ',') from e;
+→ [{"group_concat(val, ',')":null}]
+
+-- Multiple aggregates in one query
+select count(*), sum(num), min(val) from e;
+→ [{"count(*)":0,"sum(num)":null,"min(val)":null}]
+
+-- -----------------------------------------------------------------------------
+-- 3. JOINs where one or both sides are empty
+-- -----------------------------------------------------------------------------
+
+-- INNER JOIN empty × populated
+select e.id, p.id from e inner join p on e.id = p.id;
+→ []
+
+-- INNER JOIN populated × empty
+select p.id, e.id from p inner join e on p.id = e.id;
+→ []
+
+-- LEFT JOIN populated × empty — rows with null on right side
+select p.id, p.val, e.id from p left join e on p.id = e.id order by p.id;
+→ [{"id":1,"val":"p1","id:1":null},{"id":2,"val":"p2","id:1":null},{"id":3,"val":"p3","id:1":null}]
+
+-- LEFT JOIN empty × populated
+select e.id, p.id from e left join p on e.id = p.id;
+→ []
+
+-- CROSS JOIN empty × populated
+select e.id, p.id from e cross join p;
+→ []
+
+-- CROSS JOIN populated × empty
+select p.id, e.id from p cross join e;
+→ []
+
+-- INNER JOIN empty × empty (self-join)
+select e1.id, e2.id from e e1 inner join e e2 on e1.id = e2.id;
+→ []
+
+-- -----------------------------------------------------------------------------
+-- 4. Subqueries returning empty
+-- -----------------------------------------------------------------------------
+
+select * from p where id in (select id from e);
+→ []
+
+select * from p where exists (select 1 from e);
+→ []
+
+select * from p where not exists (select 1 from e) order by id;
+→ [{"id":1,"val":"p1"},{"id":2,"val":"p2"},{"id":3,"val":"p3"}]
+
+-- Scalar subquery from empty table
+select (select val from e);
+→ [{"(select val from e)":null}]
+
+-- -----------------------------------------------------------------------------
+-- 5. CTE producing 0 rows
+-- -----------------------------------------------------------------------------
+
+with empty_cte as (select * from e) select count(*) from empty_cte;
+→ [{"count(*)":0}]
+
+-- CTE empty joined with populated table
+with empty_cte as (select * from e) select p.id from empty_cte inner join p on empty_cte.id = p.id;
+→ []
+
+-- -----------------------------------------------------------------------------
+-- 6. Set operations with empty side
+-- -----------------------------------------------------------------------------
+
+select id from e union select id from p order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+select id from p union select id from e order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+select id from e intersect select id from p;
+→ []
+
+select id from e except select id from p;
+→ []
+
+select id from e union all select id from e;
+→ []
+
+-- -----------------------------------------------------------------------------
+-- 7. DML on empty table
+-- -----------------------------------------------------------------------------
+
+update e set val = 'x' where id = 1;
+
+delete from e where id = 1;
+
+-- Verify table still empty after DML
+select count(*) from e;
+→ [{"count(*)":0}]
+
+-- -----------------------------------------------------------------------------
+-- 8. INSERT ... SELECT from empty source
+-- -----------------------------------------------------------------------------
+
+-- Save row count before
+select count(*) from p;
+→ [{"count(*)":3}]
+
+insert into p (id, val) select id, val from e;
+
+-- Verify p unchanged
+select count(*) from p;
+→ [{"count(*)":3}]
+
+-- -----------------------------------------------------------------------------
+-- 9. Window functions over empty result set
+-- -----------------------------------------------------------------------------
+
+select id, row_number() over (order by id) from e;
+→ []
+
+select id, sum(num) over () from e;
+→ []
+
+-- =============================================================================
+-- Single-row table tests
+-- =============================================================================
+
+-- Setup single-row table
+create table s (id integer primary key, val text, num integer);
+insert into s values (1, 'only', 42);
+
+-- Setup single-row join partner
+create table s2 (id integer primary key, val text);
+insert into s2 values (1, 'solo');
+
+-- -----------------------------------------------------------------------------
+-- 1. All join types with single-row on one or both sides
+-- -----------------------------------------------------------------------------
+
+-- INNER JOIN s × s2 with matching condition
+select s.id, s.val, s2.id, s2.val from s inner join s2 on s.id = s2.id;
+→ [{"id":1,"val":"only","id:1":1,"val:1":"solo"}]
+
+-- INNER JOIN s × s2 with non-matching condition
+select s.id, s2.id from s inner join s2 on s.id = s2.id + 1;
+→ []
+
+-- LEFT JOIN s × s2 matching
+select s.id, s.val, s2.id, s2.val from s left join s2 on s.id = s2.id;
+→ [{"id":1,"val":"only","id:1":1,"val:1":"solo"}]
+
+-- LEFT JOIN s × s2 non-matching
+select s.id, s.val, s2.id, s2.val from s left join s2 on s.id = s2.id + 1;
+→ [{"id":1,"val":"only","id:1":null,"val:1":null}]
+
+-- CROSS JOIN s × s2
+select s.id, s2.id from s cross join s2;
+→ [{"id":1,"id:1":1}]
+
+-- CROSS JOIN single-row × multi-row
+select s.id, p.id from s cross join p order by p.id;
+→ [{"id":1,"id:1":1},{"id":1,"id:1":2},{"id":1,"id:1":3}]
+
+-- Join with populated table p on matching key
+select s.id, s.val, p.val from s inner join p on s.id = p.id;
+→ [{"id":1,"val":"only","val:1":"p1"}]
+
+-- -----------------------------------------------------------------------------
+-- 2. GROUP BY on single row
+-- -----------------------------------------------------------------------------
+
+select val, count(*) from s group by val;
+→ [{"val":"only","count(*)":1}]
+
+select val, sum(num) from s group by val;
+→ [{"val":"only","sum(num)":42}]
+
+-- GROUP BY with HAVING that matches
+select val, count(*) as cnt from s group by val having cnt = 1;
+→ [{"val":"only","cnt":1}]
+
+-- GROUP BY with HAVING that doesn't match
+select val, count(*) as cnt from s group by val having cnt > 1;
+→ []
+
+-- -----------------------------------------------------------------------------
+-- 3. Window functions with single-row partition
+-- -----------------------------------------------------------------------------
+
+select id, row_number() over (order by id) as rn from s;
+→ [{"id":1,"rn":1}]
+
+select id, rank() over (order by id) as rnk from s;
+→ [{"id":1,"rnk":1}]
+
+select id, sum(num) over () as total from s;
+→ [{"id":1,"total":42}]
+
+-- lag: no previous row
+select id, lag(num) over (order by id) as prev from s;
+→ [{"id":1,"prev":null}]
+
+-- lead: no next row
+select id, lead(num) over (order by id) as nxt from s;
+→ [{"id":1,"nxt":null}]
+
+-- =============================================================================
+-- Cleanup
+-- =============================================================================
+
+drop table e;
+drop table p;
+drop table s;
+drop table s2;