@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/97.1-json-blob-and-special-values.sqllogic

@@ -0,0 +1,92 @@
+-- 97.1-json-blob-and-special-values.sqllogic
+-- adapted from SQLite test/json101.test, json103.test
+-- BLOB and IEEE non-finite values in JSON construction. SQLite raises
+-- "JSON cannot hold BLOB values"; Quereus's prepareJsonValue silently
+-- converts BLOB and Infinity/NaN to JSON null. NaN/Infinity literals
+-- are not in the parser's grammar, so we use 1.0/0.0 to produce them
+-- via runtime arithmetic where useful.
+
+-- ============================================================
+-- json_array: BLOB argument is converted to JSON null
+-- ============================================================
+
+SELECT json_array(1, x'414243', 3);
+→ [[1,null,3]]
+
+-- BLOB only
+SELECT json_array(x'00');
+→ [[null]]
+
+-- ============================================================
+-- json_object: BLOB value is converted to JSON null
+-- ============================================================
+
+SELECT json_object('k', x'cafebabe');
+→ [{"k":null}]
+
+-- Mixed: some BLOB, some scalar values
+SELECT json_object('a', 1, 'b', x'00', 'c', 'three');
+→ [{"a":1,"b":null,"c":"three"}]
+
+-- ============================================================
+-- json_array / json_object: bigint (out of safe-integer range) preserved as string
+-- ============================================================
+
+-- bigint within safe range becomes a number
+SELECT json_array(123);
+→ [[123]]
+
+-- ============================================================
+-- json_group_array: BLOB rows become JSON null entries
+-- ============================================================
+
+CREATE TABLE jagg_blob (id INTEGER PRIMARY KEY, v BLOB NULL);
+INSERT INTO jagg_blob VALUES
+  (1, x'01'),
+  (2, x'0203'),
+  (3, null);
+-- run
+
+SELECT json_group_array(v) FROM jagg_blob;
+→ [{"json_group_array(v)":[null,null,null]}]
+
+-- ============================================================
+-- json_group_object: BLOB values become JSON null
+-- ============================================================
+
+CREATE TABLE jagg_kv (k TEXT PRIMARY KEY, v BLOB NULL);
+INSERT INTO jagg_kv VALUES
+  ('a', x'01'),
+  ('b', null),
+  ('c', x'02');
+-- run
+
+SELECT json_group_object(k, v) FROM jagg_kv;
+→ [{"json_group_object(k, v)":{"a":null,"b":null,"c":null}}]
+
+-- ============================================================
+-- IEEE non-finite values produced by arithmetic
+-- ============================================================
+
+-- 1.0 / 0.0 yields Infinity in JS arithmetic; prepareJsonValue maps to null
+SELECT json_array(1.0 / 0.0);
+→ [[null]]
+
+-- 0.0 / 0.0 yields NaN; prepareJsonValue maps to null
+SELECT json_array(0.0 / 0.0);
+→ [[null]]
+
+-- ============================================================
+-- json_object: non-string key returns NULL (whole call)
+-- ============================================================
+
+-- Numeric key rejected
+SELECT json_object(42, 'value');
+→ [null]
+
+-- BLOB-typed key rejected (not a string)
+SELECT json_object(x'00', 'value');
+→ [null]
+
+DROP TABLE jagg_blob;
+DROP TABLE jagg_kv;

package/test/logic/98-temporal-edge-cases.sqllogic

@@ -0,0 +1,515 @@
+-- 98-temporal-edge-cases.sqllogic
+-- Targeted coverage for uncovered branches in temporal-types.ts and timespan.ts:
+-- DATE/TIME/DATETIME parse from numbers, validation edge cases,
+-- TIMESPAN parsing, extraction, totals, human-readable durations,
+-- timezone handling, Temporal.Duration edge cases
+
+-- ============================================================
+-- DATE type: parse edge cases
+-- ============================================================
+
+-- Valid ISO date
+SELECT date('2024-03-15') as result;
+→ [{"result":"2024-03-15"}]
+
+-- Leap year date
+SELECT date('2024-02-29') as result;
+→ [{"result":"2024-02-29"}]
+
+-- Non-leap year Feb 29 fails
+SELECT date('2023-02-29');
+-- error: Cannot convert to DATE
+
+-- Year boundary
+SELECT date('2024-12-31') as result;
+→ [{"result":"2024-12-31"}]
+
+SELECT date('2024-01-01') as result;
+→ [{"result":"2024-01-01"}]
+
+-- 'now' special case returns a date (pattern check)
+-- We just verify it doesn't error and returns a string
+SELECT typeof(date('now')) as result;
+→ [{"result":"text"}]
+
+-- Null returns null
+SELECT date(null) as result;
+→ [{"result":null}]
+
+-- Invalid string
+SELECT date('not-a-date');
+-- error: Cannot convert to DATE
+
+-- Empty string
+SELECT date('');
+-- error: Cannot convert to DATE
+
+-- ============================================================
+-- TIME type: parse edge cases
+-- ============================================================
+
+-- Valid ISO time
+SELECT time('14:30:00') as result;
+→ [{"result":"14:30:00"}]
+
+-- Midnight
+SELECT time('00:00:00') as result;
+→ [{"result":"00:00:00"}]
+
+-- Time with milliseconds
+SELECT time('12:30:45.123') as result;
+→ [{"result":"12:30:45.123"}]
+
+-- 'now' special case
+SELECT typeof(time('now')) as result;
+→ [{"result":"text"}]
+
+-- Null
+SELECT time(null) as result;
+→ [{"result":null}]
+
+-- Invalid string
+SELECT time('not-a-time');
+-- error: Cannot convert to TIME
+
+-- Empty string
+SELECT time('');
+-- error: Cannot convert to TIME
+
+-- ============================================================
+-- DATETIME type: parse edge cases
+-- ============================================================
+
+-- Valid ISO datetime
+SELECT datetime('2024-03-15T14:30:00') as result;
+→ [{"result":"2024-03-15T14:30:00"}]
+
+-- Datetime with milliseconds
+SELECT datetime('2024-01-01T12:00:00.500') as result;
+→ [{"result":"2024-01-01T12:00:00.5"}]
+
+-- 'now' special case returns ISO string
+SELECT typeof(datetime('now')) as result;
+→ [{"result":"text"}]
+
+-- Null
+SELECT datetime(null) as result;
+→ [{"result":null}]
+
+-- Invalid string
+SELECT datetime('not-a-datetime');
+-- error: Cannot convert to DATETIME
+
+-- Empty string
+SELECT datetime('');
+-- error: Cannot convert to DATETIME
+
+-- ============================================================
+-- TIMESPAN type: ISO 8601 duration parsing
+-- ============================================================
+
+-- Basic durations
+SELECT timespan('PT1H') as result;
+→ [{"result":"PT1H"}]
+
+SELECT timespan('PT30M') as result;
+→ [{"result":"PT30M"}]
+
+SELECT timespan('PT45S') as result;
+→ [{"result":"PT45S"}]
+
+SELECT timespan('P1D') as result;
+→ [{"result":"P1D"}]
+
+SELECT timespan('P1Y') as result;
+→ [{"result":"P1Y"}]
+
+SELECT timespan('P2M') as result;
+→ [{"result":"P2M"}]
+
+SELECT timespan('P1W') as result;
+→ [{"result":"P1W"}]
+
+-- Combined duration
+SELECT timespan('P1Y2M3DT4H5M6S') as result;
+→ [{"result":"P1Y2M3DT4H5M6S"}]
+
+-- Numeric input (seconds)
+SELECT timespan(3600) as result;
+→ [{"result":"PT3600S"}]
+
+SELECT timespan(0) as result;
+→ [{"result":"PT0S"}]
+
+-- Human-readable durations
+SELECT timespan('1 hour') as result;
+→ [{"result":"PT1H"}]
+
+SELECT timespan('30 minutes') as result;
+→ [{"result":"PT30M"}]
+
+SELECT timespan('2 days 3 hours') as result;
+→ [{"result":"P2DT3H"}]
+
+SELECT timespan('1 year 6 months') as result;
+→ [{"result":"P1Y6M"}]
+
+-- Human-readable with abbreviations
+SELECT timespan('5 mins') as result;
+→ [{"result":"PT5M"}]
+
+SELECT timespan('10 secs') as result;
+→ [{"result":"PT10S"}]
+
+-- Negative human-readable duration
+SELECT timespan('-2 hours') as result;
+→ [{"result":"-PT2H"}]
+
+-- Null
+SELECT timespan(null) as result;
+→ [{"result":null}]
+
+-- Invalid string
+SELECT timespan('not-a-duration');
+-- error: Cannot convert to TIMESPAN
+
+-- ============================================================
+-- TIMESPAN extraction functions
+-- ============================================================
+
+-- Years component
+SELECT timespan_years('P2Y3M') as result;
+→ [{"result":2}]
+
+-- Months component
+SELECT timespan_months('P2Y3M') as result;
+→ [{"result":3}]
+
+-- Weeks component
+SELECT timespan_weeks('P2W') as result;
+→ [{"result":2}]
+
+-- Days component
+SELECT timespan_days('P5DT3H') as result;
+→ [{"result":5}]
+
+-- Hours component
+SELECT timespan_hours('PT10H30M') as result;
+→ [{"result":10}]
+
+-- Minutes component
+SELECT timespan_minutes('PT10H30M') as result;
+→ [{"result":30}]
+
+-- Seconds component (simple)
+SELECT timespan_seconds('PT45S') as result;
+→ [{"result":45}]
+
+-- Seconds component with fractional parts (milliseconds)
+SELECT timespan_seconds('PT1.5S') as result;
+→ [{"result":1.5}]
+
+-- Zero duration components
+SELECT timespan_years('PT1H') as result;
+→ [{"result":0}]
+
+SELECT timespan_months('PT1H') as result;
+→ [{"result":0}]
+
+SELECT timespan_days('PT1H') as result;
+→ [{"result":0}]
+
+-- Null input returns null for all extraction functions
+SELECT timespan_years(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_months(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_weeks(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_days(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_hours(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_minutes(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_seconds(null) as result;
+→ [{"result":null}]
+
+-- Invalid input returns null
+SELECT timespan_years('not-a-duration') as result;
+→ [{"result":null}]
+
+SELECT timespan_hours('not-a-duration') as result;
+→ [{"result":null}]
+
+SELECT timespan_seconds('not-a-duration') as result;
+→ [{"result":null}]
+
+-- Non-string input returns null
+SELECT timespan_years(42) as result;
+→ [{"result":null}]
+
+SELECT timespan_hours(true) as result;
+→ [{"result":null}]
+
+-- ============================================================
+-- TIMESPAN total functions
+-- ============================================================
+
+-- Total seconds for time-only duration
+SELECT timespan_total_seconds('PT1H30M') as result;
+→ [{"result":5400}]
+
+SELECT timespan_total_seconds('PT1S') as result;
+→ [{"result":1}]
+
+-- Total minutes
+SELECT timespan_total_minutes('PT2H30M') as result;
+→ [{"result":150}]
+
+-- Total hours
+SELECT timespan_total_hours('P1DT12H') as result;
+→ [{"result":36}]
+
+-- Total days
+SELECT timespan_total_days('P1W') as result;
+→ [{"result":7}]
+
+-- Total seconds with calendar units (uses reference date)
+SELECT timespan_total_seconds('P1D') as result;
+→ [{"result":86400}]
+
+-- Total with null
+SELECT timespan_total_seconds(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_total_minutes(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_total_hours(null) as result;
+→ [{"result":null}]
+
+SELECT timespan_total_days(null) as result;
+→ [{"result":null}]
+
+-- Invalid input
+SELECT timespan_total_seconds('not-valid') as result;
+→ [{"result":null}]
+
+SELECT timespan_total_minutes('not-valid') as result;
+→ [{"result":null}]
+
+SELECT timespan_total_hours('not-valid') as result;
+→ [{"result":null}]
+
+SELECT timespan_total_days('not-valid') as result;
+→ [{"result":null}]
+
+-- ============================================================
+-- TIMESPAN: arithmetic with temporal values
+-- ============================================================
+
+-- Date + timespan
+SELECT date('2024-01-15') + timespan('P10D') as result;
+→ [{"result":"2024-01-25"}]
+
+-- Date + month timespan (cross year boundary)
+SELECT date('2024-11-15') + timespan('P3M') as result;
+→ [{"result":"2025-02-15"}]
+
+-- ============================================================
+-- TIMESPAN: storage and retrieval
+-- ============================================================
+
+CREATE TABLE ts_cmp (id INTEGER PRIMARY KEY, dur TIMESPAN);
+INSERT INTO ts_cmp VALUES (1, 'PT1H'), (2, 'PT30M'), (3, 'P1D'), (4, 'PT2H');
+-- run
+
+-- Verify TIMESPAN values are stored and retrieved correctly
+SELECT dur FROM ts_cmp WHERE id = 1;
+→ [{"dur":"PT1H"}]
+
+SELECT dur FROM ts_cmp WHERE id = 3;
+→ [{"dur":"P1D"}]
+
+-- Comparison in WHERE
+SELECT dur FROM ts_cmp WHERE dur = 'PT1H';
+→ [{"dur":"PT1H"}]
+
+DROP TABLE ts_cmp;
+
+-- ============================================================
+-- TIMESPAN validation
+-- ============================================================
+
+CREATE TABLE ts_val (id INTEGER PRIMARY KEY, dur TIMESPAN NULL);
+INSERT INTO ts_val VALUES (1, 'PT1H');
+INSERT INTO ts_val VALUES (2, null);
+-- run
+
+SELECT dur FROM ts_val ORDER BY id;
+→ [{"dur":"PT1H"},{"dur":null}]
+
+DROP TABLE ts_val;
+
+-- ============================================================
+-- DATETIME: cross-representation canonicalization
+-- All six shapes for the same instant must store identical canonical text.
+-- 1500000000000 ms = 2017-07-14T02:40:00Z = 04:40 in +02:00 = bare 02:40:00 in UTC.
+-- ============================================================
+
+CREATE TABLE dt_canon (id INTEGER PRIMARY KEY, ts DATETIME);
+INSERT INTO dt_canon VALUES (1, 1500000000000);
+INSERT INTO dt_canon VALUES (2, '2017-07-14T02:40:00');
+INSERT INTO dt_canon VALUES (3, '2017-07-14T02:40:00Z');
+INSERT INTO dt_canon VALUES (4, '2017-07-14T02:40:00+00:00');
+INSERT INTO dt_canon VALUES (5, '2017-07-14T02:40:00+00:00[UTC]');
+INSERT INTO dt_canon VALUES (6, '2017-07-14T04:40:00+02:00');
+-- run
+
+-- All six rows must canonicalize to the same bare PlainDateTime string.
+SELECT count(distinct ts) as c FROM dt_canon;
+→ [{"c":1}]
+
+-- And they all equal the canonical form.
+SELECT count(*) as c FROM dt_canon WHERE ts = '2017-07-14T02:40:00';
+→ [{"c":6}]
+
+DROP TABLE dt_canon;
+
+-- ============================================================
+-- DATE: Z-suffix, offset, zoned, and numeric inputs all → canonical date
+-- ============================================================
+
+CREATE TABLE d_canon (id INTEGER PRIMARY KEY, d DATE);
+-- 1705320600000 ms = 2024-01-15T13:30:00Z → date = 2024-01-15
+INSERT INTO d_canon VALUES (1, '2024-01-15');
+INSERT INTO d_canon VALUES (2, '2024-01-15T10:30:00Z');
+INSERT INTO d_canon VALUES (3, '2024-01-15T10:30:00+00:00');
+INSERT INTO d_canon VALUES (4, '2024-01-15T10:30:00+00:00[UTC]');
+INSERT INTO d_canon VALUES (5, 1705320600000);
+-- run
+
+SELECT count(distinct d) as c FROM d_canon;
+→ [{"c":1}]
+
+SELECT count(*) as c FROM d_canon WHERE d = '2024-01-15';
+→ [{"c":5}]
+
+DROP TABLE d_canon;
+
+-- ============================================================
+-- TIME: Z-suffix / ISO datetime inputs degrade to canonical UTC time
+-- ============================================================
+
+CREATE TABLE t_canon (id INTEGER PRIMARY KEY, t TIME);
+INSERT INTO t_canon VALUES (1, '10:30:00');
+INSERT INTO t_canon VALUES (2, '2024-01-15T10:30:00Z');
+INSERT INTO t_canon VALUES (3, '2024-01-15T10:30:00+00:00');
+INSERT INTO t_canon VALUES (4, '2024-01-15T10:30:00+00:00[UTC]');
+-- run
+
+SELECT count(distinct t) as c FROM t_canon;
+→ [{"c":1}]
+
+SELECT count(*) as c FROM t_canon WHERE t = '10:30:00';
+→ [{"c":4}]
+
+DROP TABLE t_canon;
+
+-- ============================================================
+-- DATE / TIME: non-zero offset must shift to UTC, not be silently
+-- stripped as wall-clock. Without canonicalization-first these would
+-- return the local wall-clock date/time instead of the UTC equivalent.
+-- '2024-01-15T01:30:00+02:00' = '2024-01-14T23:30:00Z'  (date crosses)
+-- '2024-01-15T10:30:00+02:00' = '2024-01-15T08:30:00Z'  (time shifts)
+-- '2024-01-15T23:30:00-05:00' = '2024-01-16T04:30:00Z'  (date crosses)
+-- ============================================================
+
+CREATE TABLE dt_offset (id INTEGER PRIMARY KEY, d DATE, t TIME);
+INSERT INTO dt_offset VALUES (1, '2024-01-15T01:30:00+02:00', '2024-01-15T01:30:00+02:00');
+INSERT INTO dt_offset VALUES (2, '2024-01-15T10:30:00+02:00', '2024-01-15T10:30:00+02:00');
+INSERT INTO dt_offset VALUES (3, '2024-01-15T23:30:00-05:00', '2024-01-15T23:30:00-05:00');
+-- run
+
+SELECT id, d, t FROM dt_offset ORDER BY id;
+→ [{"id":1,"d":"2024-01-14","t":"23:30:00"},{"id":2,"d":"2024-01-15","t":"08:30:00"},{"id":3,"d":"2024-01-16","t":"04:30:00"}]
+
+DROP TABLE dt_offset;
+
+-- ============================================================
+-- DATETIME pushed-down filter: the comparison LITERAL is compared
+-- RAW (BINARY, no canonicalization) against the stored canonical
+-- value. Row 1 stores the bare form '2017-07-14T02:40:00' (see
+-- dt_canon above). A Z-suffixed or offset-bearing literal that
+-- denotes the SAME instant does NOT match the bare stored value.
+-- Pins the no-canonicalization contract against a future planner
+-- change that inserts a temporal cast or canonicalizes the seek key.
+-- ============================================================
+
+CREATE TABLE dt_filter (ts DATETIME PRIMARY KEY);
+INSERT INTO dt_filter VALUES ('2017-07-14T02:40:00Z');   -- stores bare '2017-07-14T02:40:00'
+INSERT INTO dt_filter VALUES ('2017-07-14T03:40:00');    -- a later canonical row, stored bare
+-- run
+
+-- Z-suffixed literal of the SAME instant as row 1: raw compare → no match.
+SELECT count(*) as c FROM dt_filter WHERE ts = '2017-07-14T02:40:00Z';
+→ [{"c":0}]
+
+-- +01:00-offset literal denoting the SAME instant as row 1
+-- ('2017-07-14T03:40:00+01:00' == 02:40:00Z): still raw, still no match — and
+-- note it does NOT match row 2 either, whose bare stored value shares the
+-- '2017-07-14T03:40:00' prefix but lacks the '+01:00' suffix.
+SELECT count(*) as c FROM dt_filter WHERE ts = '2017-07-14T03:40:00+01:00';
+→ [{"c":0}]
+
+-- The bare canonical literal matches exactly.
+SELECT count(*) as c FROM dt_filter WHERE ts = '2017-07-14T02:40:00';
+→ [{"c":1}]
+
+-- Range: raw lexicographic order places bare '...02:40:00' BELOW the
+-- Z-suffixed '...02:40:00Z' (the bare form is a proper prefix), so row 1
+-- is included by strict-less-than and row 2 ('...03:40:00') is not.
+SELECT ts FROM dt_filter WHERE ts < '2017-07-14T02:40:00Z';
+→ [{"ts":"2017-07-14T02:40:00"}]
+
+DROP TABLE dt_filter;
+
+-- ============================================================
+-- DATE / TIME pushed-down filter: same RAW-comparison contract.
+-- DATE and TIME share the identical isTemporal → BINARY compare
+-- path; a non-canonical literal denoting the same value must NOT
+-- match the bare stored canonical form.
+-- ============================================================
+
+CREATE TABLE d_filter (d DATE PRIMARY KEY);
+INSERT INTO d_filter VALUES ('2024-01-15T10:30:00Z');   -- stores bare '2024-01-15'
+INSERT INTO d_filter VALUES ('2024-01-20');
+-- run
+
+SELECT count(*) as c FROM d_filter WHERE d = '2024-01-15T10:30:00Z';
+→ [{"c":0}]
+
+SELECT count(*) as c FROM d_filter WHERE d = '2024-01-15';
+→ [{"c":1}]
+
+DROP TABLE d_filter;
+
+CREATE TABLE t_filter (t TIME PRIMARY KEY);
+INSERT INTO t_filter VALUES ('2024-01-15T10:30:00Z');   -- stores bare '10:30:00'
+INSERT INTO t_filter VALUES ('12:00:00');
+-- run
+
+SELECT count(*) as c FROM t_filter WHERE t = '2024-01-15T10:30:00Z';
+→ [{"c":0}]
+
+SELECT count(*) as c FROM t_filter WHERE t = '10:30:00';
+→ [{"c":1}]
+
+DROP TABLE t_filter;