@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/99-conversion-edge-cases.sqllogic

@@ -0,0 +1,325 @@
+-- 99-conversion-edge-cases.sqllogic
+-- Targeted coverage for uncovered branches in conversion.ts, json-type.ts,
+-- logical-type.ts, and schema.ts:
+-- Type conversion error paths, json() function, schema introspection functions
+
+-- ============================================================
+-- integer() conversion edge cases
+-- ============================================================
+
+-- Null returns null
+SELECT integer(null) as result;
+→ [{"result":null}]
+
+-- Integer from integer (identity)
+SELECT integer(42) as result;
+→ [{"result":42}]
+
+-- Integer from float (truncates/rounds)
+SELECT integer(3.7) as result;
+→ [{"result":3}]
+
+-- Integer from negative float
+SELECT integer(-2.9) as result;
+→ [{"result":-2}]
+
+-- Integer from string
+SELECT integer('123') as result;
+→ [{"result":123}]
+
+-- Integer from negative string
+SELECT integer('-456') as result;
+→ [{"result":-456}]
+
+-- Integer from boolean
+SELECT integer(true) as result;
+→ [{"result":1}]
+
+SELECT integer(false) as result;
+→ [{"result":0}]
+
+-- Integer from zero
+SELECT integer(0) as result;
+→ [{"result":0}]
+
+-- Integer from empty string returns null (not error)
+SELECT integer('') as result;
+→ [{"result":null}]
+
+-- Integer from non-numeric string errors
+SELECT integer('hello');
+-- error: Cannot convert to INTEGER
+
+-- ============================================================
+-- real() conversion edge cases
+-- ============================================================
+
+-- Null
+SELECT real(null) as result;
+→ [{"result":null}]
+
+-- Real from integer
+SELECT real(42) as result;
+→ [{"result":42}]
+
+-- Real from float (identity)
+SELECT real(3.14) as result;
+→ [{"result":3.14}]
+
+-- Real from string
+SELECT real('2.718') as result;
+→ [{"result":2.718}]
+
+-- Real from boolean
+SELECT real(true) as result;
+→ [{"result":1}]
+
+SELECT real(false) as result;
+→ [{"result":0}]
+
+-- Real from empty string returns null
+SELECT real('') as result;
+→ [{"result":null}]
+
+-- Real from non-numeric string errors
+SELECT real('hello');
+-- error: Cannot convert to REAL
+
+-- ============================================================
+-- text() conversion edge cases
+-- ============================================================
+
+-- Null
+SELECT text(null) as result;
+→ [{"result":null}]
+
+-- Text from integer
+SELECT text(42) as result;
+→ [{"result":"42"}]
+
+-- Text from float
+SELECT text(3.14) as result;
+→ [{"result":"3.14"}]
+
+-- Text from boolean
+SELECT text(true) as result;
+→ [{"result":"true"}]
+
+SELECT text(false) as result;
+→ [{"result":"false"}]
+
+-- Text from string (identity)
+SELECT text('hello') as result;
+→ [{"result":"hello"}]
+
+-- Text from empty string
+SELECT text('') as result;
+→ [{"result":""}]
+
+-- ============================================================
+-- boolean() conversion edge cases
+-- ============================================================
+
+-- Null
+SELECT boolean(null) as result;
+→ [{"result":null}]
+
+-- Boolean from boolean (identity)
+SELECT boolean(true) as result;
+→ [{"result":true}]
+
+SELECT boolean(false) as result;
+→ [{"result":false}]
+
+-- Boolean from integer
+SELECT boolean(1) as result;
+→ [{"result":true}]
+
+SELECT boolean(0) as result;
+→ [{"result":false}]
+
+-- Boolean from string
+SELECT boolean('true') as result;
+→ [{"result":true}]
+
+SELECT boolean('false') as result;
+→ [{"result":false}]
+
+SELECT boolean('yes') as result;
+→ [{"result":true}]
+
+SELECT boolean('no') as result;
+→ [{"result":false}]
+
+SELECT boolean('on') as result;
+→ [{"result":true}]
+
+SELECT boolean('off') as result;
+→ [{"result":false}]
+
+-- Boolean from invalid string errors
+SELECT boolean('maybe');
+-- error: Cannot convert to BOOLEAN
+
+SELECT boolean('');
+-- error: Cannot convert to BOOLEAN
+
+-- ============================================================
+-- json() conversion edge cases
+-- ============================================================
+
+-- Null
+SELECT json(null) as result;
+→ [{"result":null}]
+
+-- JSON from valid JSON string
+SELECT json('{"a":1}') as result;
+→ [{"result":{"a":1}}]
+
+-- JSON from array string
+SELECT json('[1,2,3]') as result;
+→ [{"result":[1,2,3]}]
+
+-- JSON from number
+SELECT json(42) as result;
+→ [{"result":42}]
+
+-- JSON from boolean
+SELECT json(true) as result;
+→ [{"result":true}]
+
+-- JSON from 'null' string
+SELECT json('null') as result;
+→ [{"result":null}]
+
+-- JSON from invalid string errors
+SELECT json('not-valid-json');
+-- error: Cannot convert to JSON
+
+-- ============================================================
+-- timespan() conversion error path
+-- ============================================================
+
+-- Valid conversion
+SELECT timespan('PT1H') as result;
+→ [{"result":"PT1H"}]
+
+-- Null
+SELECT timespan(null) as result;
+→ [{"result":null}]
+
+-- Invalid string errors
+SELECT timespan('invalid');
+-- error: Cannot convert to TIMESPAN
+
+-- ============================================================
+-- Schema introspection: schema() function
+-- ============================================================
+
+CREATE TABLE schema_test (id INTEGER PRIMARY KEY, name TEXT, score REAL);
+-- run
+
+-- schema() returns rows with schema info
+SELECT type, name FROM schema() WHERE name = 'schema_test';
+→ [{"type":"table","name":"schema_test"}]
+
+-- table_info() returns column information
+SELECT name, type, pk FROM table_info('schema_test') ORDER BY cid;
+→ [{"name":"id","type":"INTEGER","pk":1},{"name":"name","type":"TEXT","pk":0},{"name":"score","type":"REAL","pk":0}]
+
+-- table_info with non-existent table
+SELECT name FROM table_info('nonexistent_table');
+-- error: not found
+
+DROP TABLE schema_test;
+
+-- ============================================================
+-- function_info() introspection
+-- ============================================================
+
+-- function_info() returns functions (check a known function)
+SELECT name, type FROM function_info('json_valid');
+→ [{"name":"json_valid","type":"scalar"}]
+
+-- function_info with filter
+SELECT name, type FROM function_info('json_extract');
+→ [{"name":"json_extract","type":"scalar"}]
+
+-- function_info without filter returns many rows (just check it works)
+SELECT count(*) > 0 as has_functions FROM function_info();
+→ [{"has_functions":true}]
+
+-- schema() listing an index row alongside its table lives in
+-- 99.0.1-schema-index-listing (it needs standalone CREATE INDEX).
+
+-- ============================================================
+-- Schema: foreign keys
+-- ============================================================
+
+CREATE TABLE fk_parent (id INTEGER PRIMARY KEY, name TEXT);
+CREATE TABLE fk_child (id INTEGER PRIMARY KEY, parent_id INTEGER REFERENCES fk_parent(id));
+-- run
+
+-- foreign_key_info returns FK relationships
+SELECT "from", referenced_table, "to" FROM foreign_key_info('fk_child');
+→ [{"from":"parent_id","referenced_table":"fk_parent","to":"id"}]
+
+-- foreign_key_info on table without FKs returns nothing
+SELECT count(*) as cnt FROM foreign_key_info('fk_parent');
+→ [{"cnt":0}]
+
+-- foreign_key_info on non-existent table errors
+SELECT "from" FROM foreign_key_info('nonexistent');
+-- error: not found
+
+-- Non-string table name errors
+SELECT "from" FROM foreign_key_info(42);
+-- error: requires a table name string
+
+DROP TABLE fk_child;
+DROP TABLE fk_parent;
+
+-- ============================================================
+-- typeof: all types
+-- ============================================================
+
+SELECT typeof(null) as result;
+→ [{"result":"null"}]
+
+SELECT typeof(42) as result;
+→ [{"result":"integer"}]
+
+SELECT typeof(3.14) as result;
+→ [{"result":"real"}]
+
+SELECT typeof('hello') as result;
+→ [{"result":"text"}]
+
+SELECT typeof(true) as result;
+→ [{"result":"integer"}]
+
+SELECT typeof(json_array(1,2)) as result;
+→ [{"result":"json"}]
+
+-- ============================================================
+-- Cross-type conversion chains
+-- ============================================================
+
+-- integer -> text -> integer roundtrip
+SELECT integer(text(42)) as result;
+→ [{"result":42}]
+
+-- real -> text -> real roundtrip
+SELECT real(text(3.14)) as result;
+→ [{"result":3.14}]
+
+-- boolean -> integer -> boolean roundtrip
+SELECT boolean(integer(true)) as result;
+→ [{"result":true}]
+
+SELECT boolean(integer(false)) as result;
+→ [{"result":false}]
+
+-- json -> text -> json roundtrip (via json_extract)
+SELECT json('{"a":1}') as result;
+→ [{"result":{"a":1}}]

package/test/logic/99.0.1-schema-index-listing.sqllogic

@@ -0,0 +1,21 @@
+-- 99.0.1-schema-index-listing.sqllogic
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 99-conversion-edge-cases: that file is type-conversion edge cases
+-- plus introspection-function checks, and this was its only index DDL — a table
+-- plus one `create index` existing solely so schema() has an index row to list.
+-- On its own here, the conversion coverage stays runnable on backends without
+-- first-class CREATE INDEX.
+--
+-- Subject: schema() lists an index row alongside the table row that owns it.
+
+CREATE TABLE idx_test (id INTEGER PRIMARY KEY, name TEXT, score REAL);
+CREATE INDEX idx_name ON idx_test (name);
+-- run
+
+-- Should show both table and index in schema
+SELECT type, name FROM schema() WHERE name = 'idx_test' OR name = 'idx_name' ORDER BY type;
+→ [{"type":"index","name":"idx_name"},{"type":"table","name":"idx_test"}]
+
+DROP TABLE idx_test;

package/test/logic/99.1-cast-syntax-extras.sqllogic

@@ -0,0 +1,167 @@
+-- adapted from SQLite test/cast.test, numcast.test, types2.test
+-- Edge cases for CAST and conversion functions: BLOB roundtrips, scientific notation,
+-- whitespace handling, IEEE 754 INF/NaN.
+
+-- =============================================================================
+-- BLOB roundtrips via CAST
+-- =============================================================================
+
+-- CAST text to BLOB preserves bytes
+select cast('hello' as blob) = x'68656c6c6f' as r;
+→ [{"r":true}]
+
+-- BLOB equality after CAST
+select cast(x'0102' as blob) = x'0102' as r;
+→ [{"r":true}]
+
+-- -----------------------------------------------------------------------------
+-- Text-to-binary is literal UTF-8 -- no hex sniffing
+-- -----------------------------------------------------------------------------
+
+-- The round trip this behavior exists for: text(blob) then blob(text) is
+-- lossless for UTF-8-clean bytes.
+select cast(cast(x'6162' as text) as blob) = x'6162' as r;
+→ [{"r":true}]
+
+-- Round-trip is NOT total: a blob that is not valid UTF-8 renders as U+FFFD
+-- on the way to text, so it comes back as the UTF-8 bytes of the replacement
+-- character, not the original byte.
+select cast(cast(x'ff' as text) as blob) = x'efbfbd' as r;
+→ [{"r":true}]
+
+-- A string that looks like hex digits is no longer sniffed as hex -- it
+-- becomes its own UTF-8 bytes, four of them, not the two bytes 0x61 0x62.
+select cast('6162' as blob) = x'36313632' as r;
+→ [{"r":true}]
+
+-- =============================================================================
+-- Scientific notation in conversions
+-- =============================================================================
+
+-- CAST string with positive exponent
+select cast('1.23e+2' as real) as r;
+→ [{"r":123}]
+
+-- CAST string with negative exponent
+select cast('5e-1' as real) as r;
+→ [{"r":0.5}]
+
+-- =============================================================================
+-- Whitespace handling in conversions
+-- =============================================================================
+
+-- Leading whitespace
+select cast('  42' as integer) as r;
+→ [{"r":42}]
+
+select cast('  3.14' as real) as r;
+→ [{"r":3.14}]
+
+-- Trailing whitespace
+select cast('42  ' as integer) as r;
+→ [{"r":42}]
+
+-- =============================================================================
+-- BOOLEAN <-> numeric edge cases
+-- =============================================================================
+
+-- BOOLEAN-typed literal coerced to integer
+select cast(true as integer) + cast(false as integer) as r;
+→ [{"r":1}]
+
+-- Negative integer to boolean: nonzero is true
+select cast(-1 as boolean) as r;
+→ [{"r":true}]
+
+-- Float to boolean
+select cast(0.5 as boolean) as r;
+→ [{"r":true}]
+
+select cast(0.0 as boolean) as r;
+→ [{"r":false}]
+
+-- =============================================================================
+-- A failed CAST yields NULL, never the unconverted operand
+-- =============================================================================
+-- The numeric/text/blob targets keep SQLite's lenient fallbacks (0, '', bytes).
+-- Every other target has no such fallback, so a value it cannot convert simply
+-- has no result: the cast is NULL rather than a value outside the target type.
+
+select cast('junk' as date) as r;
+→ [{"r":null}]
+
+select cast('junk' as time) as r;
+→ [{"r":null}]
+
+select cast('junk' as datetime) as r;
+→ [{"r":null}]
+
+select cast('junk' as timespan) as r;
+→ [{"r":null}]
+
+select cast('junk' as boolean) as r;
+→ [{"r":null}]
+
+-- A blob is not a JSON value under any reading, so the cast has no result.
+select cast(x'0102' as json) as r;
+→ [{"r":null}]
+
+-- But a bare string IS a valid JSON string scalar even though it is not valid
+-- JSON *source text*, so JSON's own validate keeps it.
+select cast('abc' as json) as r;
+→ [{"r":"abc"}]
+
+-- Successful casts are unaffected.
+select cast('2024-03-05' as date) as r;
+→ [{"r":"2024-03-05"}]
+
+select cast('true' as boolean) as r;
+→ [{"r":true}]
+
+-- A blob is not a date under any reading either.
+select cast(x'0102' as date) as r;
+→ [{"r":null}]
+
+-- Numeric/text/blob fallbacks still apply and still produce their own type.
+select cast('junk' as integer) as r;
+→ [{"r":0}]
+
+select cast('junk' as real) as r;
+→ [{"r":0}]
+
+-- Every fallback arm yields a value that inhabits the type the cast advertises.
+-- typeof() reports the storage class, so REAL's 0.0 reads as 'integer'.
+select typeof(cast('junk' as integer)) as i, typeof(cast('junk' as real)) as r,
+	typeof(cast('junk' as numeric)) as n, typeof(cast(x'0102' as text)) as t,
+	typeof(cast('junk' as blob)) as b;
+→ [{"i":"integer","r":"integer","n":"integer","t":"text","b":"blob"}]
+
+-- -----------------------------------------------------------------------------
+-- Write path: the NULL reaches storage as a NULL, not as garbage
+-- -----------------------------------------------------------------------------
+
+create table cast_dt (id integer primary key, dt date null);
+
+insert into cast_dt values (1, cast('junk' as date));
+select id, dt, typeof(dt) as ty from cast_dt where id = 1;
+→ [{"id":1,"dt":null,"ty":"null"}]
+
+-- A successful cast round-trips through storage unchanged.
+insert into cast_dt values (2, cast('2024-03-05' as date));
+select id, dt, typeof(dt) as ty from cast_dt where id = 2;
+→ [{"id":2,"dt":"2024-03-05","ty":"text"}]
+
+-- The stored date still orders as a date, not as the raw operand would have.
+select id from cast_dt where dt > '2000-01-01' order by id;
+→ [{"id":2}]
+
+drop table cast_dt;
+
+-- Columns are NOT NULL by default, so the same insert is rejected outright
+-- instead of storing a value the column's type does not admit.
+create table cast_dt_nn (id integer primary key, dt date not null);
+
+insert into cast_dt_nn values (1, cast('junk' as date));
+-- error: NOT NULL constraint failed
+
+drop table cast_dt_nn;

package/test/logic/drop-unique-index.sqllogic

@@ -0,0 +1,88 @@
+-- DROP INDEX on a UNIQUE index must also remove the synthesized
+-- UniqueConstraintSchema (tagged with derivedFromIndex). Without that, the
+-- mutation manager keeps enforcing the unique check after the index is gone.
+--
+-- requires-capability: standalone-index-ddl
+
+-- =====================================================
+-- 1. Happy path: DROP UNIQUE INDEX clears the uniqueness check
+-- =====================================================
+create table dui_basic (a integer, b integer);
+create unique index ix_dui_basic_a on dui_basic(a);
+
+insert into dui_basic values (1, 10);
+
+-- Duplicate fails while index exists
+insert into dui_basic values (1, 20);
+-- error: UNIQUE constraint failed
+
+select a, b from dui_basic order by a, b;
+→ [{"a":1,"b":10}]
+
+drop index ix_dui_basic_a;
+
+-- After drop, the duplicate is allowed (no stale uniqueConstraint enforcement)
+insert into dui_basic values (1, 20);
+
+select a, b from dui_basic order by a, b;
+→ [{"a":1,"b":10},{"a":1,"b":20}]
+
+drop table dui_basic;
+
+-- =====================================================
+-- 2. Coincident-name preservation: dropping a UNIQUE index does NOT
+--    remove a CREATE-TABLE-time UNIQUE constraint on a different column,
+--    even when their names sit in adjacent namespaces.
+-- =====================================================
+create table dui_coincident (a integer, b integer, constraint u unique(b));
+create unique index u_idx on dui_coincident(a);
+
+insert into dui_coincident values (1, 2);
+
+-- Pre-drop: both constraints enforced
+insert into dui_coincident values (1, 3);
+-- error: UNIQUE constraint failed
+
+insert into dui_coincident values (4, 2);
+-- error: UNIQUE constraint failed
+
+drop index u_idx;
+
+-- After dropping the index, UNIQUE(a) is gone but the declared UNIQUE(b) survives
+insert into dui_coincident values (1, 5);
+
+select a, b from dui_coincident order by a, b;
+→ [{"a":1,"b":2},{"a":1,"b":5}]
+
+-- Declared UNIQUE(b) still rejects duplicates
+insert into dui_coincident values (9, 2);
+-- error: UNIQUE constraint failed
+
+drop table dui_coincident;
+
+-- =====================================================
+-- 3. Partial UNIQUE index round-trip: drop must clear the synthesized
+--    partial constraint, including its predicate.
+-- =====================================================
+create table dui_partial (id integer primary key, status text, code text);
+create unique index ix_dui_partial on dui_partial(code) where status = 'active';
+
+insert into dui_partial values (1, 'active', 'A');
+
+-- Inside scope: duplicate code 'A' is rejected
+insert into dui_partial values (2, 'active', 'A');
+-- error: UNIQUE
+
+-- Outside scope: same code allowed
+insert into dui_partial values (3, 'inactive', 'A');
+
+drop index ix_dui_partial;
+
+-- After drop, the partial unique constraint is gone — duplicate 'A' inside
+-- the (formerly) active scope is allowed.
+insert into dui_partial values (4, 'active', 'A');
+
+select id, status, code from dui_partial order by id;
+→ [{"id":1,"status":"active","code":"A"},{"id":3,"status":"inactive","code":"A"},{"id":4,"status":"active","code":"A"}]
+
+drop table dui_partial;

package/test/logic/pushdown-test.sqllogic

@@ -0,0 +1,36 @@
+-- Predicate Pushdown Tests
+-- Verify that WHERE clause predicates are pushed down to table access
+
+CREATE TABLE users (id INTEGER, name TEXT, age INTEGER);
+INSERT INTO users VALUES (1, 'Alice', 30), (2, 'Bob', 25), (3, 'Carol', 35);
+
+-- Test simple equality predicate pushdown
+SELECT id, name FROM users WHERE id = 1;
+→ [{"id": 1, "name": "Alice"}]
+
+-- Test inequality predicate pushdown
+SELECT age, name FROM users WHERE age > 25;
+→ [{"age": 30, "name": "Alice"}, {"age": 35, "name": "Carol"}]
+
+-- Test compound predicate (partial pushdown)
+SELECT age, name FROM users WHERE age > 25 AND name LIKE 'A%';
+→ [{"age": 30, "name": "Alice"}]
+
+DROP TABLE users;
+
+-- Regression: pushing a filter below a Project must preserve the projection's
+-- attribute IDs. A computed column was re-assigned a fresh attribute ID on the
+-- rebuild, stranding an outer projection that kept ONLY the computed column
+-- while filtering on a different (pruned) column ("No row context found").
+create table t (id integer primary key, code20 text not null);
+insert into t values (3, 'C1');
+create view v_plain as select id, case code20 when 'A1' then 'A' else 'C' end as code from t;
+
+select code from v_plain where id = 3;
+→ [{"code":"C"}]
+
+select code from (select id, case code20 when 'A1' then 'A' else 'C' end as code from t) where id = 3;
+→ [{"code":"C"}]
+
+drop view v_plain;
+drop table t;