@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/06.5-polymorphic-types.sqllogic

@@ -0,0 +1,169 @@
+-- polymorphic-types.sqllogic - Testing polymorphic function type inference
+
+-- Test abs() with INTEGER and REAL types
+CREATE TABLE test_abs (id INTEGER PRIMARY KEY, int_val INTEGER, real_val REAL);
+INSERT INTO test_abs VALUES (1, -42, -2.5);
+
+SELECT abs(int_val) as result FROM test_abs;
+→ [{"result": 42}]
+
+SELECT abs(real_val) as result FROM test_abs;
+→ [{"result": 2.5}]
+
+DROP TABLE test_abs;
+
+-- Test coalesce() type inference
+SELECT coalesce(NULL, 42) as result;
+→ [{"result": 42}]
+
+-- Test greatest() and least()
+CREATE TABLE test_minmax (id INTEGER PRIMARY KEY, a INTEGER, b INTEGER, c INTEGER);
+INSERT INTO test_minmax VALUES (1, 10, 42, 25);
+
+SELECT greatest(a, b, c) as result FROM test_minmax;
+→ [{"result": 42}]
+
+SELECT least(a, b, c) as result FROM test_minmax;
+→ [{"result": 10}]
+
+DROP TABLE test_minmax;
+
+-- Test MIN() and MAX() aggregates
+CREATE TABLE test_agg (id INTEGER PRIMARY KEY, int_val INTEGER NULL, real_val REAL NULL);
+INSERT INTO test_agg VALUES (1, 42, NULL), (2, 10, NULL), (3, 25, NULL);
+INSERT INTO test_agg VALUES (4, NULL, 3.5), (5, NULL, 2.5), (6, NULL, 1.5);
+
+SELECT MIN(int_val) as result FROM test_agg;
+→ [{"result": 10}]
+
+SELECT MAX(int_val) as result FROM test_agg;
+→ [{"result": 42}]
+
+SELECT MAX(real_val) as result FROM test_agg;
+→ [{"result": 3.5}]
+
+DROP TABLE test_agg;
+
+-- Test common type resolution for coalesce()
+SELECT coalesce(NULL, 42, 2.5) as result;
+→ [{"result": 42}]
+
+-- Test common type resolution for iif()
+SELECT iif(1, 42, 2.5) as result;
+→ [{"result": 42}]
+
+SELECT iif(0, 42, 2.5) as result;
+→ [{"result": 2.5}]
+
+-- Test common type resolution for greatest() and least()
+SELECT greatest(10, 2.5, 42) as result;
+→ [{"result": 42}]
+
+SELECT least(10, 2.5, 42) as result;
+→ [{"result": 2.5}]
+
+-- Test common type resolution for choose()
+SELECT choose(1, 42, 2.5, 100) as result;
+→ [{"result": 42}]
+
+SELECT choose(2, 42, 2.5, 100) as result;
+→ [{"result": 2.5}]
+
+-- Test scalar function type inference
+SELECT round(42) as result;
+→ [{"result": 42}]
+
+SELECT round(2.5) as result;
+→ [{"result": 3}]
+
+SELECT nullif(42, 0) as result;
+→ [{"result": 42}]
+
+SELECT nullif(42, 42) as result;
+→ [{"result": null}]
+
+SELECT sqrt(16.0) as result;
+→ [{"result": 4}]
+
+SELECT floor(2.5) as result;
+→ [{"result": 2}]
+
+SELECT ceil(2.5) as result;
+→ [{"result": 3}]
+
+SELECT clamp(50, 0, 100) as result;
+→ [{"result": 50}]
+
+SELECT clamp(-10, 0, 100) as result;
+→ [{"result": 0}]
+
+SELECT clamp(150, 0, 100) as result;
+→ [{"result": 100}]
+
+-- Test string function type inference
+SELECT length('hello') as result;
+→ [{"result": 5}]
+
+SELECT upper('hello') as result;
+→ [{"result": "HELLO"}]
+
+SELECT lower('HELLO') as result;
+→ [{"result": "hello"}]
+
+SELECT trim('  hello  ') as result;
+→ [{"result": "hello"}]
+
+SELECT substr('hello', 1, 3) as result;
+→ [{"result": "hel"}]
+
+SELECT replace('hello', 'l', 'L') as result;
+→ [{"result": "heLLo"}]
+
+SELECT instr('hello', 'l') as result;
+→ [{"result": 3}]
+
+-- Test arithmetic operator type inference
+-- INTEGER + INTEGER -> INTEGER
+SELECT 10 + 20 as result;
+→ [{"result": 30}]
+
+-- INTEGER + REAL -> REAL
+SELECT 10 + 2.5 as result;
+→ [{"result": 12.5}]
+
+-- REAL + INTEGER -> REAL
+SELECT 2.5 + 10 as result;
+→ [{"result": 12.5}]
+
+-- REAL + REAL -> REAL
+SELECT 2.5 + 3.5 as result;
+→ [{"result": 6}]
+
+-- INTEGER * INTEGER -> INTEGER
+SELECT 10 * 20 as result;
+→ [{"result": 200}]
+
+-- INTEGER * REAL -> REAL
+SELECT 10 * 2.5 as result;
+→ [{"result": 25}]
+
+-- INTEGER - INTEGER -> INTEGER
+SELECT 20 - 10 as result;
+→ [{"result": 10}]
+
+-- REAL - INTEGER -> REAL
+SELECT 12.5 - 10 as result;
+→ [{"result": 2.5}]
+
+-- INTEGER / INTEGER -> INTEGER
+SELECT 20 / 10 as result;
+→ [{"result": 2}]
+
+-- REAL / INTEGER -> REAL
+SELECT 10.0 / 2 as result;
+→ [{"result": 5}]
+
+-- INTEGER % INTEGER -> INTEGER
+SELECT 23 % 10 as result;
+→ [{"result": 3}]
+

package/test/logic/06.5.1-conversion-functions.sqllogic

@@ -0,0 +1,173 @@
+-- conversion-functions.sqllogic - Testing type conversion functions
+
+-- integer conversion
+select integer(42), integer('123'), integer(3.14), integer(true), integer(false);
+→ [{"integer(42)":42,"integer('123')":123,"integer(3.14)":3,"integer(true)":1,"integer(false)":0}]
+
+-- integer null
+select integer(null);
+→ [{"integer(null)":null}]
+
+-- real conversion
+select real(42), real('3.14');
+→ [{"real(42)":42,"real('3.14')":3.14}]
+
+-- text conversion
+select text(42), text(3.14), text(true), text(null);
+→ [{"text(42)":"42","text(3.14)":"3.14","text(true)":"true","text(null)":null}]
+
+-- boolean conversion
+select boolean(1), boolean(0), boolean('true'), boolean('false');
+→ [{"boolean(1)":true,"boolean(0)":false,"boolean('true')":true,"boolean('false')":false}]
+
+-- real null
+select real(null);
+→ [{"real(null)":null}]
+
+-- boolean null
+select boolean(null);
+→ [{"boolean(null)":null}]
+
+-- integer from negative
+select integer(-5), integer('-10');
+→ [{"integer(-5)":-5,"integer('-10')":-10}]
+
+-- real from integer string
+select real('42');
+→ [{"real('42')":42}]
+
+-- =============================================================================
+-- blob() -- literal UTF-8, no hex sniffing
+-- =============================================================================
+
+select blob('abc') = x'616263' as r;
+→ [{"r":true}]
+
+-- Even a string that looks like hex digits still becomes its literal UTF-8 bytes.
+select blob('6162') = x'36313632' as r;
+→ [{"r":true}]
+
+select blob(null);
+→ [{"blob(null)":null}]
+
+select typeof(blob('abc'));
+→ [{"typeof(blob('abc'))":"blob"}]
+
+-- A number or boolean renders through the one value-to-text rule, then takes
+-- those bytes -- blob(42) is the two digits of '42', not the byte 0x2a.
+select blob(42) = x'3432' as r;
+→ [{"r":true}]
+
+select blob(true) = x'74727565' as r;
+→ [{"r":true}]
+
+-- A conversion function is strict where CAST is lenient: blob() rejects a JSON
+-- document, while cast(<json> as blob) yields the document's own text as bytes.
+select blob(json('{"a":1}'));
+-- error: Cannot convert to BLOB
+
+select cast(json('{"a":1}') as blob) = x'7b2261223a317d' as r;
+→ [{"r":true}]
+
+-- =============================================================================
+-- hex() / unhex()
+-- =============================================================================
+
+select hex(x'6162');
+→ [{"hex(x'6162')":"6162"}]
+
+-- hex() is uppercase, no separator.
+select hex(x'cafe');
+→ [{"hex(x'cafe')":"CAFE"}]
+
+-- A non-blob argument converts to bytes first, same path as cast(X as blob).
+select hex('abc');
+→ [{"hex('abc')":"616263"}]
+
+-- Same for a number or a boolean: the bytes are the value's text spelling, so
+-- hex(42) is the hex of '4','2' -- not the hex of the integer 42.
+select hex(42);
+→ [{"hex(42)":"3432"}]
+
+select hex(true);
+→ [{"hex(true)":"74727565"}]
+
+-- Strict like blob(), for the same reason: hex() is the blob conversion plus a
+-- spelling, so a JSON document raises rather than answering NULL.
+select hex(json('{"a":1}'));
+-- error: Cannot convert to BLOB for hex()
+
+select hex(null);
+→ [{"hex(null)":null}]
+
+-- Empty blob is a distinct non-null zero-length value, not null.
+select hex(x'');
+→ [{"hex(x'')":""}]
+
+select unhex('6162') = x'6162' as r;
+→ [{"r":true}]
+
+-- Case-insensitive input.
+select unhex('CAFE') = unhex('cafe') as r;
+→ [{"r":true}]
+
+-- Odd number of hex digits -> null, not an error.
+select unhex('616');
+→ [{"unhex('616')":null}]
+
+-- Non-hex characters -> null.
+select unhex('zz');
+→ [{"unhex('zz')":null}]
+
+select unhex(null);
+→ [{"unhex(null)":null}]
+
+-- unhex() reads text only. Anything else -- a number, a blob -- is NULL, not an
+-- error and not a conversion: unhex(x'6162') does NOT round-trip hex(x'6162').
+select unhex(42);
+→ [{"unhex(42)":null}]
+
+select unhex(x'6162');
+→ [{"unhex(x'6162')":null}]
+
+-- Empty string unhexes to the empty blob, not null.
+select unhex('') = x'' as r, unhex('') is null as isnull;
+→ [{"r":true,"isnull":false}]
+
+-- Round trip through hex()/unhex().
+select unhex(hex(x'deadbeef')) = x'deadbeef' as r;
+→ [{"r":true}]
+
+-- =============================================================================
+-- Text-into-BLOB-column write/read-back
+-- =============================================================================
+
+create table blob_write_test (id integer primary key, data blob);
+
+insert into blob_write_test values (1, cast('abc' as blob));
+select id, data = x'616263' as r from blob_write_test where id = 1;
+→ [{"id":1,"r":true}]
+
+insert into blob_write_test values (2, cast('6162' as blob));
+select id, data = x'36313632' as r from blob_write_test where id = 2;
+→ [{"id":2,"r":true}]
+
+drop table blob_write_test;
+
+-- The ALTER retype backfill converts existing rows through the same
+-- BLOB_TYPE.parse the INSERT path uses, so a hex-shaped stored string must come
+-- back as its own UTF-8 bytes rather than being decoded as hex digits.
+create table blob_retype_test (id integer primary key, v text);
+insert into blob_retype_test values (1, 'abc'), (2, '6162');
+-- run
+
+alter table blob_retype_test alter column v set data type blob;
+-- run
+
+select id, v = x'616263' as r from blob_retype_test where id = 1;
+→ [{"id":1,"r":true}]
+
+select id, v = x'36313632' as r from blob_retype_test where id = 2;
+→ [{"id":2,"r":true}]
+
+drop table blob_retype_test;

package/test/logic/06.5.2-scalar-minmax.sqllogic

@@ -0,0 +1,16 @@
+-- adapted from SQLite test/minmax.test
+-- Scalar MIN(x, y, ...) / MAX(x, y, ...) — distinguished from single-arg aggregates by arity.
+-- Quereus does not currently implement multi-argument scalar min/max; only the
+-- single-arg aggregate forms exist. Document the rejection.
+
+select min(10, 20);
+-- error: Function not found: min/2
+
+select max(10, 20);
+-- error: Function not found: max/2
+
+select min(10, 20, 5);
+-- error: Function not found: min/3
+
+select max(10, 20, 5);
+-- error: Function not found: max/3

package/test/logic/06.5.3-undeclared-return-type-comparison.sqllogic

@@ -0,0 +1,244 @@
+-- undeclared-return-type-comparison.sqllogic
+-- A function registered without a declared `returnType` reports ANY (unknown), not REAL.
+-- While the default was REAL, the planner believed every such function returned a number,
+-- so `insertCrossTypeCoercion` cast the TEXT side of a comparison to REAL — the literal
+-- 'object' became 0 and `json_type(j) = 'object'` was FALSE. At the time, most builtins
+-- declared no return type (all of datetime.ts, nearly all of json.ts and string.ts), so
+-- the whole family was affected; ticket 1-scalar-function-default-return-type-any.
+--
+-- Those builtins now declare their real return types (ticket
+-- 2-builtin-scalar-function-declared-return-types), so most of the cases below reach the
+-- right answer by a shorter route than ANY. `json_extract` is the one builtin still
+-- deliberately ANY — genuinely polymorphic — so the ANY behavior stays exercised here.
+--
+-- The user-defined-function half of this (Database.createScalarFunction never passes a
+-- returnType) lives in test/core-api-features.spec.ts — a .sqllogic file cannot register
+-- one.
+--
+-- No `using memory`, so store mode exercises the persisted path too.
+
+create table urt (id integer primary key, j json, d text, n integer);
+insert into urt values (1, '{"a":"x"}', '2024-03-04', 5);
+-- run
+
+-- ===================================
+-- 1. The reproducing comparisons — every one of these was FALSE
+-- ===================================
+select json_type(j) = 'object' as r from urt;
+→ [{"r":true}]
+
+select json_extract(j, '$.a') = 'x' as r from urt;
+→ [{"r":true}]
+
+select strftime('%Y', d) = '2024' as r from urt;
+→ [{"r":true}]
+
+-- json_quote returns the JSON source as TEXT, so this compares two plain strings.
+select json_quote(j) = '{"a":"x"}' as r from urt;
+→ [{"r":true}]
+
+-- Literal on the LEFT is the same coercion, mirrored.
+select 'object' = json_type(j) as r from urt;
+→ [{"r":true}]
+
+-- The complement is honest too (it was TRUE for every row before).
+select json_type(j) <> 'object' as r from urt;
+→ [{"r":false}]
+
+-- Unequal text is still unequal — the fix is not "always true".
+select json_type(j) = 'array' as r from urt;
+→ [{"r":false}]
+
+-- WHERE position, not just the select list.
+select id from urt where json_type(j) = 'object';
+→ [{"id":1}]
+
+select id from urt where strftime('%Y', d) = '2024';
+→ [{"id":1}]
+
+-- ===================================
+-- 2. The other comparison sites agree with `=`
+-- ===================================
+select json_type(j) in ('object') as r from urt;
+→ [{"r":true}]
+
+select case json_type(j) when 'object' then 'yes' else 'no' end as r from urt;
+→ [{"r":"yes"}]
+
+select json_type(j) between 'a' and 'z' as r from urt;
+→ [{"r":true}]
+
+select json_type(j) like 'obj%' as r from urt;
+→ [{"r":true}]
+
+-- An ANY-typed value against a number is simply unequal, not an error.
+select json_type(j) = 3 as r from urt;
+→ [{"r":false}]
+
+-- ===================================
+-- 3. A non-JSON operand vs JSON still takes the object-physical arm of insertCrossTypeCoercion
+-- ===================================
+-- Neither ANY nor TEXT is NULL, so the arm is not skipped: the non-JSON side is cast to
+-- JSON. 'object' is not JSON source, so the lenient cast leaves it as the raw string,
+-- which does not equal the object {"a":"x"}. Pinned deliberately.
+select json_type(j) = j as r from urt;
+→ [{"r":false}]
+
+-- Same shape with a still-ANY operand (json_extract), so the ANY arm stays covered.
+select json_extract(j, '$.a') = j as r from urt;
+→ [{"r":false}]
+
+-- The JSON source text spelled by json_quote DOES parse, so it matches structurally.
+select json_quote(j) = j as r from urt;
+→ [{"r":true}]
+
+-- ===================================
+-- 4. json_type's value still works everywhere else it has always worked
+-- ===================================
+select json_type(j) || '!' as r from urt;
+→ [{"r":"object!"}]
+
+select length(json_type(j)) as r from urt;
+→ [{"r":6}]
+
+select coalesce(json_type(j), 'none') as r from urt;
+→ [{"r":"object"}]
+
+select nullif(json_type(j), 'object') as r from urt;
+→ [{"r":null}]
+
+select cast(json_type(j) as text) = 'object' as r from urt;
+→ [{"r":true}]
+
+select typeof(json_type(j)) as r from urt;
+→ [{"r":"text"}]
+
+-- Identity sites (ORDER BY / GROUP BY / DISTINCT / min / max) rank the value as text,
+-- as they always did.
+insert into urt values (2, '[1]', '2023-01-02', 7);
+-- run
+
+select json_type(j) as r from urt order by json_type(j);
+→ [{"r":"array"},{"r":"object"}]
+
+select min(json_type(j)) as mn, max(json_type(j)) as mx from urt;
+→ [{"mn":"array","mx":"object"}]
+
+select json_type(j) as g, count(*) as c from urt group by json_type(j) order by g;
+→ [{"g":"array","c":1},{"g":"object","c":1}]
+
+select count(*) as c from (select distinct json_type(j) from urt);
+→ [{"c":2}]
+
+-- ===================================
+-- 5. The numeric builtins accept an unclassifiable argument
+-- ===================================
+-- abs/round/sqrt/floor/ceil/clamp gate their argument at plan time on isNumeric. With an
+-- honest ANY default that gate has to mean "numeric, or not yet known"
+-- (isNumericOrUnknownType) or `abs(<undeclared function>)` becomes unusable.
+select abs(json_extract(j, '$.a')) as r from urt where id = 1;
+→ [{"r":null}]
+
+-- ===================================
+-- 6. NULL passes the same gate: abs(null) is null in SQL, not an error
+-- ===================================
+-- These all threw "Invalid argument types for function <name>" before, including at HEAD
+-- before the default changed.
+select abs(null) as r;
+→ [{"r":null}]
+
+select round(null) as r;
+→ [{"r":null}]
+
+select round(null, 1) as r;
+→ [{"r":null}]
+
+select sqrt(null) as r;
+→ [{"r":null}]
+
+select floor(null) as r;
+→ [{"r":null}]
+
+select ceil(null) as r;
+→ [{"r":null}]
+
+select ceiling(null) as r;
+→ [{"r":null}]
+
+-- clamp's implementation reaches Number() for all three arguments at once, so its null
+-- short-circuit is explicit — Number(null) is 0, which would return the lower bound.
+select clamp(null, 1, 2) as r;
+→ [{"r":null}]
+
+select clamp(5, null, 10) as r;
+→ [{"r":null}]
+
+select clamp(5, 1, null) as r;
+→ [{"r":null}]
+
+-- ===================================
+-- 7. A textual argument is still rejected at plan time
+-- ===================================
+-- Widening the gate to ANY and NULL must not widen it to TEXT.
+select abs('abc') as r;
+-- error: Invalid argument types for function abs
+
+select floor('abc') as r;
+-- error: Invalid argument types for function floor
+
+select clamp('a', 1, 2) as r;
+-- error: Invalid argument types for function clamp
+
+select abs(d) as r from urt;
+-- error: Invalid argument types for function abs
+
+-- ===================================
+-- 8. Arithmetic and aggregation over an ANY-typed value
+-- ===================================
+-- These were WRONG under the REAL default, not merely unspecialized: emitArithmeticOp
+-- took its numeric-fast path (`runtime/emit/binary.ts`), which trusts the declared type
+-- and applies the JS operator to the raw value. strftime returns the string '2024', so
+-- `'2024' + 1` concatenated to '20241', failed the Number.isFinite check and came back
+-- NULL. ANY routes to the generic path, which coerces first.
+select strftime('%Y', d) + 1 as r from urt where id = 1;
+→ [{"r":2025}]
+
+-- `abs(strftime(...))` was 2024 while strftime rode the ANY default: the numeric
+-- builtins' plan-time gate accepts "numeric OR unclassifiable", and ANY is
+-- unclassifiable. Ticket 2-builtin-scalar-function-declared-return-types declared
+-- strftime's real return type (TEXT), so the argument is now classifiable and the gate
+-- rejects it — the same rejection `abs(d)` gets in section 7, for the same reason.
+-- Write `abs(integer(strftime(...)))` to convert first.
+select abs(strftime('%Y', d)) as r from urt where id = 1;
+-- error: Invalid argument types for function abs
+
+select abs(integer(strftime('%Y', d))) as r from urt where id = 1;
+→ [{"r":2024}]
+
+-- Aggregates: an ANY-typed argument no longer skips coerceForAggregate
+-- (`computeAggregateSkipCoercion`, runtime/emit/aggregate-setup.ts).
+select sum(strftime('%Y', d)) as s, avg(strftime('%Y', d)) as a from urt;
+→ [{"s":4047,"a":2023.5}]
+
+-- ===================================
+-- 9. The deliberate loss: a numeric-looking STRING no longer coerces
+-- ===================================
+-- Not guessing REAL costs exactly this much. `json_extract(...) = '5'` was TRUE (the
+-- planner cast '5' to REAL 5); it is now FALSE, because an ANY operand gives the
+-- numeric↔textual arm of insertCrossTypeCoercion nothing to key on and the runtime
+-- compares an integer against text — different storage classes. Note this is NOT the gap
+-- bug-numeric-text-coercion-skips-in-and-case closed: that one was about the coercion
+-- being skipped at some comparison SITES; here every site applies it and there is simply
+-- no declared numeric type to key on.
+-- Pinned so the next change to the numeric↔text story is a deliberate one. json_extract
+-- is deliberately still ANY (its result shape depends on the data), so the loss is real
+-- here; every builtin that CAN name a type now does, which restores the coercion — see
+-- 06.5.4-declared-return-type-builtins.sqllogic.
+select json_extract('{"n":5}', '$.n') = '5' as r;
+→ [{"r":false}]
+
+-- Against an actual number it is true, as it always was.
+select json_extract('{"n":5}', '$.n') = 5 as r;
+→ [{"r":true}]
+
+drop table urt;