@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/03.5-tvf.sqllogic

@@ -0,0 +1,61 @@
+-- test/logic/tvf.sqllogic
+
+-- Check query plan using the new TVF
+-- After relational constant folding, SELECT 1+1 collapses to Block → TableLiteral
+SELECT op FROM query_plan('SELECT 1 + 1');
+→ [{"op":"BLOCK"},{"op":"TABLELITERAL"}]
+
+-- Check scheduler program dump TVF (basic execution check)
+-- After relational constant folding, SELECT 1 collapses to Block → TableLiteral
+SELECT description FROM scheduler_program('SELECT 1');
+→ [{"description":"tableLiteral(1 rows, 1 cols)"},{"description":"block(1 stmts, result idx: 0)"}]
+
+-- json_each: array immediate children only
+SELECT key, value FROM json_each('[10, 20, {"a": 30}]');
+→ [{"key":0,"value":10},{"key":1,"value":20},{"key":2,"value":"{\"a\":30}"}]
+
+-- json_each: object immediate children only (does NOT recurse into nested containers)
+SELECT key, value, type FROM json_each('{"a":{"b":1},"c":2}');
+→ [{"key":"a","value":"{\"b\":1}","type":"object"},{"key":"c","value":2,"type":"integer"}]
+
+-- Basic json_tree (just test it runs for now)
+SELECT id, fullkey, type, atom FROM json_tree('{"a": [1, 2], "b": true}');
+
+-- TVF with alias and WHERE filter
+SELECT j.key FROM json_each('[5,6]') AS j WHERE j.value > 5;
+→ [{"key":1}]
+
+-- TVF with alias and qualified SELECT *
+SELECT j.* FROM json_each('[5,6]') AS j WHERE j.value > 5;
+→ [{"key":1,"value":6,"type":"integer","atom":6,"id":1,"parent":null,"fullkey":"[1]","path":""}]
+
+-- json_each with root path
+SELECT key, value FROM json_each('{"data": [1, 2]}', '$.data');
+→ [{"key":0,"value":1},{"key":1,"value":2}]
+
+-- TVF with root path (json_tree) (just test it runs for now)
+SELECT fullkey, value FROM json_tree('{"a": 1, "nested": {"b": 2}}', '$.nested');
+
+-- expect error: Invalid JSON
+SELECT * FROM json_each('invalid json');
+-- error: Error: Invalid JSON provided to json_each
+
+-- expect error: Function not found
+SELECT * FROM non_existent_tvf(1);
+-- error: Function not found: non_existent_tvf/1
+
+-- expect error: Incorrect number of arguments (json_each - no args)
+SELECT * FROM json_each();
+-- error: Error: json_each requires 1 or 2 arguments (jsonSource, [rootPath])
+
+-- expect error: Incorrect number of arguments (json_each - too many args)
+SELECT * FROM json_each('[]', '$', 'extra');
+-- error: Error: json_each requires 1 or 2 arguments (jsonSource, [rootPath])
+
+-- expect error: Incorrect number of arguments (json_tree - no args)
+SELECT * FROM json_tree();
+-- error: Error: json_tree requires 1 or 2 arguments (jsonSource, [rootPath])
+
+-- expect error: Incorrect number of arguments (json_tree - too many args)
+SELECT * FROM json_tree('{}', '$', 'extra');
+-- error: Error: json_tree requires 1 or 2 arguments (jsonSource, [rootPath])

package/test/logic/03.6-type-system.sqllogic

@@ -0,0 +1,544 @@
+-- type-system.sqllogic - Regression tests for type system: CAST, comparisons, ordering
+
+-- === CAST via LogicalType.parse ===
+
+-- CAST to INTEGER
+select cast(3.7 as integer) as r;
+→ [{"r":3}]
+
+select cast(-2.9 as integer) as r;
+→ [{"r":-2}]
+
+select cast('42' as integer) as r;
+→ [{"r":42}]
+
+select cast(true as integer) as r;
+→ [{"r":1}]
+
+select cast(false as integer) as r;
+→ [{"r":0}]
+
+-- Non-numeric string: CAST should yield 0 (SQLite-compatible lenient behavior)
+select cast('abc' as integer) as r;
+→ [{"r":0}]
+
+select cast(null as integer) as r;
+→ [{"r":null}]
+
+-- CAST to REAL
+select cast(42 as real) as r;
+→ [{"r":42}]
+
+select cast('3.14' as real) as r;
+→ [{"r":3.14}]
+
+select cast(true as real) as r;
+→ [{"r":1}]
+
+select cast(null as real) as r;
+→ [{"r":null}]
+
+-- CAST to TEXT
+select cast(123 as text) as r;
+→ [{"r":"123"}]
+
+select cast(3.14 as text) as r;
+→ [{"r":"3.14"}]
+
+select cast(true as text) as r;
+→ [{"r":"true"}]
+
+select cast(null as text) as r;
+→ [{"r":null}]
+
+-- CAST to BLOB
+select typeof(cast('hello' as blob)) as r;
+→ [{"r":"blob"}]
+
+select typeof(cast(123 as blob)) as r;
+→ [{"r":"blob"}]
+
+select cast(null as blob) as r;
+→ [{"r":null}]
+
+-- CAST to NUMERIC (integer if possible, otherwise real)
+select cast('42' as numeric) as r;
+→ [{"r":42}]
+
+select cast('3.14' as numeric) as r;
+→ [{"r":3.14}]
+
+select cast(null as numeric) as r;
+→ [{"r":null}]
+
+-- CAST to BOOLEAN
+select cast(1 as boolean) as r;
+→ [{"r":true}]
+
+select cast(0 as boolean) as r;
+→ [{"r":false}]
+
+select cast(42 as boolean) as r;
+→ [{"r":true}]
+
+-- CAST aliases
+select cast(3.7 as int) as r;
+→ [{"r":3}]
+
+select cast('42' as float) as r;
+→ [{"r":42}]
+
+select cast(42 as varchar) as r;
+→ [{"r":"42"}]
+
+-- === Cross-type comparison ordering ===
+-- SQLite ordering: NULL < Numeric < TEXT < BLOB
+
+CREATE TABLE order_test (id INTEGER PRIMARY KEY, v ANY NULL);
+INSERT INTO order_test VALUES (1, null);
+INSERT INTO order_test VALUES (2, -1);
+INSERT INTO order_test VALUES (3, 0);
+INSERT INTO order_test VALUES (4, 1);
+INSERT INTO order_test VALUES (5, 'aaa');
+INSERT INTO order_test VALUES (6, 'zzz');
+INSERT INTO order_test VALUES (7, x'00');
+INSERT INTO order_test VALUES (8, x'ff');
+
+-- Verify cross-type ordering: NULL < numeric < text < blob
+select id from order_test order by v;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6},{"id":7},{"id":8}]
+
+DROP TABLE order_test;
+
+-- === BLOB comparison (byte-by-byte, then length) ===
+
+CREATE TABLE blob_cmp (id INTEGER PRIMARY KEY, b BLOB);
+INSERT INTO blob_cmp VALUES (1, x'01'), (2, x'02'), (3, x'01ff'), (4, x'0200'), (5, x'0100'), (6, x'abcd');
+
+-- Byte-by-byte: x'01...' < x'02'
+select id from blob_cmp where b < x'02' order by b;
+→ [{"id":1},{"id":5},{"id":3}]
+
+-- Full ordering: byte-by-byte then length
+select id from blob_cmp order by b;
+→ [{"id":1},{"id":5},{"id":3},{"id":2},{"id":4},{"id":6}]
+
+-- Equality
+select id from blob_cmp where b = x'abcd';
+→ [{"id":6}]
+
+DROP TABLE blob_cmp;
+
+-- === Date/time ordering uses binary comparison (not locale) ===
+
+CREATE TABLE date_cmp (id INTEGER PRIMARY KEY, d TEXT);
+INSERT INTO date_cmp VALUES (1, '2024-01-15'), (2, '2024-02-01'), (3, '2024-12-31'), (4, '2024-06-15');
+
+select d from date_cmp order by d;
+→ [{"d":"2024-01-15"},{"d":"2024-02-01"},{"d":"2024-06-15"},{"d":"2024-12-31"}]
+
+select d from date_cmp where d < '2024-02-01' order by d;
+→ [{"d":"2024-01-15"}]
+
+DROP TABLE date_cmp;
+
+CREATE TABLE time_cmp (id INTEGER PRIMARY KEY, t TEXT);
+INSERT INTO time_cmp VALUES (1, '09:00:00'), (2, '17:00:00'), (3, '23:59:59'), (4, '00:00:00');
+
+select t from time_cmp order by t;
+→ [{"t":"00:00:00"},{"t":"09:00:00"},{"t":"17:00:00"},{"t":"23:59:59"}]
+
+DROP TABLE time_cmp;
+
+CREATE TABLE dt_cmp (id INTEGER PRIMARY KEY, dt TEXT);
+INSERT INTO dt_cmp VALUES (1, '2024-01-01T00:00:00'), (2, '2024-12-31T23:59:59'), (3, '2024-06-15T12:00:00');
+
+select dt from dt_cmp order by dt;
+→ [{"dt":"2024-01-01T00:00:00"},{"dt":"2024-06-15T12:00:00"},{"dt":"2024-12-31T23:59:59"}]
+
+DROP TABLE dt_cmp;
+
+-- === NULL ordering in ORDER BY ===
+
+CREATE TABLE null_order (id INTEGER PRIMARY KEY, v INTEGER null);
+INSERT INTO null_order VALUES (1, null), (2, 10), (3, null), (4, 5);
+
+-- Nulls sort first in ASC
+select v from null_order order by v;
+→ [{"v":null},{"v":null},{"v":5},{"v":10}]
+
+DROP TABLE null_order;
+
+-- === BOOLEAN ordering and CAST ===
+
+select cast(0 as boolean) as r;
+→ [{"r":false}]
+
+select cast(1 as boolean) as r;
+→ [{"r":true}]
+
+select cast(-1 as boolean) as r;
+→ [{"r":true}]
+
+select cast(42 as boolean) as r;
+→ [{"r":true}]
+
+-- Boolean ordering: false < true
+CREATE TABLE bool_order (id INTEGER PRIMARY KEY, b BOOLEAN);
+INSERT INTO bool_order VALUES (1, true), (2, false), (3, true), (4, false);
+
+select b from bool_order order by b, id;
+→ [{"b":false},{"b":false},{"b":true},{"b":true}]
+
+DROP TABLE bool_order;
+
+-- === TEXT collation in comparisons ===
+
+CREATE TABLE text_cmp (id INTEGER PRIMARY KEY, t TEXT);
+INSERT INTO text_cmp VALUES (1, 'abc'), (2, 'ABC'), (3, 'abd'), (4, 'abc  ');
+
+-- Binary: 'ABC' < 'abc' (uppercase letters have lower code points)
+select t from text_cmp where t < 'abc' order by t;
+→ [{"t":"ABC"}]
+
+-- NOCASE: 'ABC' = 'abc'
+select id from text_cmp where t = 'abc' collate nocase order by id;
+→ [{"id":1},{"id":2}]
+
+-- RTRIM: 'abc  ' = 'abc'
+select id from text_cmp where t = 'abc' collate rtrim order by id;
+→ [{"id":1},{"id":4}]
+
+DROP TABLE text_cmp;
+
+-- === CAST in ORDER BY context ===
+
+CREATE TABLE cast_order (id INTEGER PRIMARY KEY, v TEXT);
+INSERT INTO cast_order VALUES (1, '10'), (2, '2'), (3, '1'), (4, '20');
+
+-- Text ordering (lexicographic)
+select v from cast_order order by v;
+→ [{"v":"1"},{"v":"10"},{"v":"2"},{"v":"20"}]
+
+-- Numeric ordering via CAST
+select v from cast_order order by cast(v as integer);
+→ [{"v":"1"},{"v":"2"},{"v":"10"},{"v":"20"}]
+
+DROP TABLE cast_order;
+
+-- === JSON validation on insert ===
+
+CREATE TABLE json_tbl (id INTEGER PRIMARY KEY, j JSON);
+INSERT INTO json_tbl VALUES (1, '{"a":1}'), (2, '[1,2,3]'), (3, '"hello"');
+
+select j from json_tbl order by id;
+→ [{"j":{"a":1}},{"j":[1,2,3]},{"j":"hello"}]
+
+-- Invalid JSON rejected
+INSERT INTO json_tbl VALUES (4, '{invalid');
+-- error: Type conversion failed
+
+-- typeof returns 'json' for native JSON objects
+select typeof(j) as t from json_tbl where id = 1;
+→ [{"t":"json"}]
+
+DROP TABLE json_tbl;
+
+-- === json() conversion function returns native objects ===
+
+select json('{"a":1}') as r;
+→ [{"r":{"a":1}}]
+
+select json('[1,2,3]') as r;
+→ [{"r":[1,2,3]}]
+
+select json('null') as r;
+→ [{"r":null}]
+
+select typeof(json('{"a":1}')) as t;
+→ [{"t":"json"}]
+
+-- === JSON deep comparison ===
+
+select json('{"a":1}') = json('{"a":1}') as eq;
+→ [{"eq":true}]
+
+select json('{"a":1}') = json('{"a":2}') as eq;
+→ [{"eq":false}]
+
+select json('[1,2,3]') = json('[1,2,3]') as eq;
+→ [{"eq":true}]
+
+select json('[1,2,3]') = json('[1,2,4]') as eq;
+→ [{"eq":false}]
+
+-- === Numeric type coercion in comparisons (table context) ===
+
+CREATE TABLE num_cmp (id INTEGER PRIMARY KEY, i INTEGER, r REAL, t TEXT);
+INSERT INTO num_cmp VALUES (1, 42, 42.0, '42');
+
+-- Integer vs real equality
+select i = r as r1 from num_cmp;
+→ [{"r1":true}]
+
+-- Text coerced to numeric for comparison
+select i = t as r1 from num_cmp;
+→ [{"r1":true}]
+
+-- Integer column vs text literal (planner inserts cast on text)
+select i = '42' as eq, i > '10' as gt, i < '100' as lt from num_cmp;
+→ [{"eq":true,"gt":true,"lt":true}]
+
+-- Real column vs text literal
+select r = '42.0' as eq from num_cmp;
+→ [{"eq":true}]
+
+-- Text column vs integer literal (planner inserts cast on text column)
+select t = 42 as eq from num_cmp;
+→ [{"eq":true}]
+
+-- Non-numeric text compared to integer: cast produces 0
+select '42' = 42 as r1, 'abc' = 0 as r2;
+→ [{"r1":true,"r2":true}]
+
+-- BETWEEN with mixed types: integer BETWEEN text bounds
+select i from num_cmp where i between '10' and '100';
+→ [{"i":42}]
+
+-- BETWEEN with text expr and numeric bounds
+select t from num_cmp where t between 10 and 100;
+→ [{"t":"42"}]
+
+DROP TABLE num_cmp;
+
+-- === Cross-category comparison edge cases ===
+
+-- Literal cross-category comparisons (no table needed)
+select 42 = '42' as r;
+→ [{"r":true}]
+
+select 42 != '43' as r;
+→ [{"r":true}]
+
+select 10 < '20' as r;
+→ [{"r":true}]
+
+select 100 > '50' as r;
+→ [{"r":true}]
+
+select 10 <= '10' as r;
+→ [{"r":true}]
+
+select 10 >= '10' as r;
+→ [{"r":true}]
+
+-- BETWEEN with all-literal cross-category
+select 5 between '1' and '10' as r;
+→ [{"r":true}]
+
+select '5' between 1 and 10 as r;
+→ [{"r":true}]
+
+-- NOT BETWEEN with cross-category
+select 50 not between '1' and '10' as r;
+→ [{"r":true}]
+
+-- NULL handling in cross-category (NULL propagates)
+select null = '42' as r;
+→ [{"r":null}]
+
+select 42 = null as r;
+→ [{"r":null}]
+
+-- === NUMERIC comparator across the number/bigint boundary (regression) ===
+-- A NUMERIC column accepts both number and bigint; ordering must not throw
+-- and must not lose precision past 2^53 by round-tripping through Number().
+
+CREATE TABLE numeric_big (v NUMERIC PRIMARY KEY);
+INSERT INTO numeric_big VALUES (9007199254740993);
+INSERT INTO numeric_big VALUES (3);
+
+select cast(v as text) as v from numeric_big order by v;
+→ [{"v":"3"},{"v":"9007199254740993"}]
+
+-- Adjacent bigints past 2^53, negatives, and a fractional double interleaved:
+-- key placement must use exact value order, not a rounded double.
+INSERT INTO numeric_big VALUES (9007199254740994);
+INSERT INTO numeric_big VALUES (-9007199254740993);
+INSERT INTO numeric_big VALUES (2.5);
+
+select cast(v as text) as v from numeric_big order by v;
+→ [{"v":"-9007199254740993"},{"v":"2.5"},{"v":"3"},{"v":"9007199254740993"},{"v":"9007199254740994"}]
+
+select cast(v as text) as v from numeric_big where v > 9007199254740993 order by v;
+→ [{"v":"9007199254740994"}]
+
+select count(*) as c from numeric_big;
+→ [{"c":5}]
+
+DROP TABLE numeric_big;
+
+-- === TEXT -> INTEGER / NUMERIC conversion past 2^53 (regression) ===
+-- The string arm of parse() used to go through parseInt/parseFloat, which
+-- returns a `number` and silently rounds once the value exceeds 2^53. Both
+-- CAST and cross-category comparison (which CASTs the text operand at plan
+-- time) funnel through the same parse(), so one fix covers both symptoms.
+-- No 64-bit clamp: Quereus literals are already arbitrary-precision
+-- (`select 99999999999999999999999999` is exact), so the text path must
+-- agree rather than clamp to SQLite's INT64_MAX.
+--
+-- Bigint results below are compared via cast(... as text), not the raw numeric
+-- column: the test harness's JSON-diff path normalizes an actual bigint through
+-- Number() before comparing, which rounds a wrong result and a correct one to the
+-- same double — a raw-number assertion here would pass even if the fix regressed.
+
+select cast(v as text) as v from (select cast('9007199254740993' as integer) as v);
+→ [{"v":"9007199254740993"}]
+
+select cast(v as text) as v from (select cast('9007199254740993' as numeric) as v);
+→ [{"v":"9007199254740993"}]
+
+select cast(v as text) as v from (select cast('-9007199254740993' as integer) as v);
+→ [{"v":"-9007199254740993"}]
+
+select cast(v as text) as v from (select cast('9223372036854775807' as integer) as v);
+→ [{"v":"9223372036854775807"}]
+
+-- Arbitrary precision, past SQLite's INT64_MAX: matches the literal path, not SQLite.
+select cast(v as text) as v from (select cast('99999999999999999999999999' as integer) as v);
+→ [{"v":"99999999999999999999999999"}]
+
+-- Explicit leading '+': BigInt() rejects the '+' that Number() accepts, so the sign is
+-- stripped before the bigint is rebuilt. Without that, this would fall to castFallback (0).
+select cast(v as text) as v from (select cast('+9007199254740993' as integer) as v);
+→ [{"v":"9007199254740993"}]
+
+select cast(v as text) as v from (select cast('+9007199254740993' as numeric) as v);
+→ [{"v":"9007199254740993"}]
+
+select cast('+42' as numeric) as v;
+→ [{"v":42}]
+
+-- The integer() conversion function shares INTEGER_TYPE.parse with CAST, and the docs
+-- prefer it over CAST syntax — it must agree past 2^53.
+select cast(v as text) as v from (select integer('9007199254740993') as v);
+→ [{"v":"9007199254740993"}]
+
+-- A fractional form is not all-digit, so it falls through to parseFloat and stays
+-- a REAL (double) even past 2^53 — this matches SQLite and is unaffected by the fix.
+select cast('9007199254740993.0' as numeric) as v;
+→ [{"v":9007199254740992}]
+
+-- Prefix semantics (parseInt-style leading-digit-run) are preserved, matching SQLite.
+select cast('9e18' as integer) as v;
+→ [{"v":9}]
+
+select cast(v as text) as v from (select cast('9007199254740993abc' as integer) as v);
+→ [{"v":"9007199254740993"}]
+
+-- Unaffected existing behavior: prefix parse, plain doubles, whitespace trim.
+select cast('12abc' as integer) as v;
+→ [{"v":12}]
+
+select cast('3.14' as numeric) as v;
+→ [{"v":3.14}]
+
+select cast('  42  ' as integer) as v;
+→ [{"v":42}]
+
+select cast('abc' as integer) as v;
+→ [{"v":0}]
+
+select cast('' as integer) as v;
+→ [{"v":null}]
+
+-- Cross-category comparison: text past 2^53 must compare equal to the matching
+-- integer literal, not to its Number()-rounded neighbor.
+select 9007199254740993 = '9007199254740993' as r;
+→ [{"r":true}]
+
+select 9007199254740993 = '9007199254740992' as r;
+→ [{"r":false}]
+
+-- Insert-side: a text value past 2^53 written into a NUMERIC column reads back exact.
+CREATE TABLE numeric_text_insert (v NUMERIC);
+INSERT INTO numeric_text_insert VALUES ('9007199254740993');
+select cast(v as text) as v from numeric_text_insert;
+→ [{"v":"9007199254740993"}]
+
+-- Same for a declared INTEGER column, which runs a different parse() than NUMERIC.
+-- INTEGER_TYPE.validate only accepts a number that is a SAFE integer, so a write-time
+-- parse that yielded a rounded (unsafe) number would fail the column type check outright.
+CREATE TABLE integer_text_insert (v INTEGER);
+INSERT INTO integer_text_insert VALUES ('9007199254740993');
+select cast(v as text) as v from integer_text_insert;
+→ [{"v":"9007199254740993"}]
+DROP TABLE integer_text_insert;
+DROP TABLE numeric_text_insert;
+
+-- === REAL comparator against a bigint operand past 2^53 (regression) ===
+-- REAL_TYPE.compare used to assert its operands were `number` and call isNaN()
+-- on them; isNaN() throws on a bigint. A REAL column compared against an
+-- integer literal past 2^53 (which the engine keeps as bigint) hit this on
+-- every index/primary-key lookup. Must order by exact value, not throw.
+
+CREATE TABLE real_big (id INTEGER PRIMARY KEY, r REAL);
+CREATE INDEX real_big_ir ON real_big(r);
+INSERT INTO real_big VALUES (1, 5.0), (2, 9007199254740992.0);
+
+-- Secondary index: equality against a bigint that doesn't match any stored REAL
+select id from real_big where r = 9007199254740993;
+→ []
+
+-- Secondary index: greater-than against a bigint
+select id from real_big where r > 9007199254740993;
+→ []
+
+-- Secondary index: less-than against a bigint one past the stored REAL. Both rows
+-- must come back — had the bigint been coerced through Number() it would round
+-- down to 9007199254740992 and drop row 2.
+select id from real_big where r < 9007199254740993 order by id;
+→ [{"id":1},{"id":2}]
+
+-- ...and the exact stored value excludes itself, which the rounded form would not.
+select id from real_big where r < 9007199254740992 order by id;
+→ [{"id":1}]
+
+-- Negative bigint past -2^53, below everything stored
+select id from real_big where r > -9007199254740993 order by id;
+→ [{"id":1},{"id":2}]
+
+-- Secondary index: IN-list mixing a bigint and a plain number
+select id from real_big where r in (9007199254740993, 5) order by id;
+→ [{"id":1}]
+
+select id from real_big where r in (9007199254740992, 5) order by id;
+→ [{"id":1},{"id":2}]
+
+DROP TABLE real_big;
+
+-- NULL in an indexed REAL column still sorts first and never reaches the numeric path
+-- (columns default NOT NULL in Quereus, hence the explicit `null`)
+CREATE TABLE real_big_null (id INTEGER PRIMARY KEY, r REAL null);
+CREATE INDEX real_big_null_ir ON real_big_null(r);
+INSERT INTO real_big_null VALUES (1, 5.0), (2, 9007199254740992.0), (3, NULL);
+
+select id from real_big_null where r < 9007199254740993 order by id;
+→ [{"id":1},{"id":2}]
+
+select id from real_big_null order by r, id;
+→ [{"id":3},{"id":1},{"id":2}]
+
+DROP TABLE real_big_null;
+
+-- REAL primary key, no secondary index in sight
+CREATE TABLE real_pk (r REAL PRIMARY KEY);
+INSERT INTO real_pk VALUES (5.0);
+
+select r from real_pk where r = 9007199254740993;
+→ []
+
+select r from real_pk where r in (9007199254740993, 5) order by r;
+→ [{"r":5}]
+
+DROP TABLE real_pk;