@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/05.2-cast-seek-correctness.sqllogic

@@ -0,0 +1,124 @@
+-- 05.2-cast-seek-correctness.sqllogic
+-- Regression: a comparison whose column operand is wrapped in a value-changing
+-- CAST must not contribute an index-seek constraint. The constraint extractor
+-- used to strip every CastNode, so `cast(x as integer) = 1` on a TEXT primary
+-- key was pushed down as a seek for the integer 1 against stored text — which
+-- matches nothing under storage-class ordering — and the conjunct was reported
+-- as fully consumed, so no residual filter survived to catch the mistake.
+--
+-- The last group matters most: `insertCrossTypeCoercion` wraps the textual
+-- operand of a numeric comparison in a synthetic cast, so a bare `x = 1` on a
+-- TEXT column hits the same path with no explicit CAST in the SQL.
+--
+-- Every query is paired with the identical predicate over a non-indexed column
+-- of the same declared type; indexed and non-indexed must agree. The TEXT group
+-- is followed by REAL and BLOB keys, whose converting casts (truncation, UTF-8
+-- decode) change the value without crossing into a text/number mismatch.
+--
+-- Plan shapes are pinned separately in `test/plan/cast-seek-blocking.spec.ts`.
+
+PRAGMA default_vtab_module='memory';
+
+-- x is the primary key → the optimizer will try to seek on it.
+CREATE TABLE t (x TEXT PRIMARY KEY);
+INSERT INTO t VALUES ('1'), ('1abc'), ('2');
+
+-- Same rows, but x is an ordinary column (control: was always correct).
+CREATE TABLE u (id INTEGER PRIMARY KEY, x TEXT);
+INSERT INTO u VALUES (1, '1'), (2, '1abc'), (3, '2');
+
+-- Equality through a converting cast, column on the left.
+SELECT x FROM t WHERE CAST(x AS INTEGER) = 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+SELECT x FROM u WHERE CAST(x AS INTEGER) = 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+-- Same, operands flipped.
+SELECT x FROM t WHERE 1 = CAST(x AS INTEGER) ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+SELECT x FROM u WHERE 1 = CAST(x AS INTEGER) ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+-- Degenerate range through a converting cast.
+SELECT x FROM t WHERE CAST(x AS INTEGER) BETWEEN 1 AND 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+SELECT x FROM u WHERE CAST(x AS INTEGER) BETWEEN 1 AND 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+-- IN over a cast condition was already correct (extractInConstraint requires a
+-- bare column reference); pinned so it stays that way.
+SELECT x FROM t WHERE CAST(x AS INTEGER) IN (1) ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+SELECT x FROM u WHERE CAST(x AS INTEGER) IN (1) ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+-- Two-branch OR: the collapse to an IN constraint must not see through the cast.
+SELECT x FROM t WHERE CAST(x AS INTEGER) = 1 OR CAST(x AS INTEGER) = 2 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"},{"x":"2"}]
+
+SELECT x FROM u WHERE CAST(x AS INTEGER) = 1 OR CAST(x AS INTEGER) = 2 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"},{"x":"2"}]
+
+-- Implicit coercion: no CAST written, but the planner inserts one over `x`.
+SELECT x FROM t WHERE x = 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+SELECT x FROM u WHERE x = 1 ORDER BY x;
+→ [{"x":"1"},{"x":"1abc"}]
+
+-- Control: a text-vs-text equality needs no coercion and still seeks.
+SELECT x FROM t WHERE x = '1' ORDER BY x;
+→ [{"x":"1"}]
+
+SELECT x FROM u WHERE x = '1' ORDER BY x;
+→ [{"x":"1"}]
+
+-- A no-op cast is value-preserving and must still fold away (seek preserved).
+SELECT x FROM t WHERE CAST(x AS TEXT) = '1' ORDER BY x;
+→ [{"x":"1"}]
+
+DROP TABLE t;
+DROP TABLE u;
+
+-- Same shape over a REAL primary key: `cast(v as integer)` truncates, so the
+-- seek key differs from the stored value even though both sides are numeric.
+CREATE TABLE r (v REAL PRIMARY KEY);
+INSERT INTO r VALUES (1.0), (1.5), (2.0);
+
+CREATE TABLE s (id INTEGER PRIMARY KEY, v REAL);
+INSERT INTO s VALUES (1, 1.0), (2, 1.5), (3, 2.0);
+
+SELECT v FROM r WHERE CAST(v AS INTEGER) = 1 ORDER BY v;
+→ [{"v":1},{"v":1.5}]
+
+SELECT v FROM s WHERE CAST(v AS INTEGER) = 1 ORDER BY v;
+→ [{"v":1},{"v":1.5}]
+
+-- A no-op cast on the REAL key still folds away.
+SELECT v FROM r WHERE CAST(v AS REAL) = 1.5 ORDER BY v;
+→ [{"v":1.5}]
+
+DROP TABLE r;
+DROP TABLE s;
+
+-- BLOB key: `cast(b as text)` decodes the bytes as UTF-8, so the cast's value is a
+-- string and never the stored blob — it must not become a seek key.
+-- `tag` names the row so the assertion needs no blob-formatting function.
+CREATE TABLE bt (b BLOB PRIMARY KEY, tag TEXT);
+INSERT INTO bt VALUES (x'31', 'one'), (x'32', 'two');
+
+CREATE TABLE bu (id INTEGER PRIMARY KEY, b BLOB, tag TEXT);
+INSERT INTO bu VALUES (1, x'31', 'one'), (2, x'32', 'two');
+
+SELECT tag FROM bt WHERE CAST(b AS TEXT) = '1' ORDER BY tag;
+→ [{"tag":"one"}]
+
+SELECT tag FROM bu WHERE CAST(b AS TEXT) = '1' ORDER BY tag;
+→ [{"tag":"one"}]
+
+DROP TABLE bt;
+DROP TABLE bu;

package/test/logic/06-builtin_functions.sqllogic

@@ -0,0 +1,149 @@
+-- builtin_functions.sqllogic - Testing various built-in functions
+
+-- Scalar Functions
+SELECT lower('Quereus'), upper('Quereus'), length('Quereus');
+→ [{"lower('Quereus')":"quereus","upper('Quereus')":"QUEREUS","length('Quereus')":7}]
+SELECT substr('Quereus', 2, 3), substring('Quereus', 4);
+→ [{"substr('Quereus', 2, 3)":"uer","substring('Quereus', 4)":"reus"}]
+SELECT abs(-10), round(12.345, 1), round(12.345);
+→ [{"abs(-10)":10,"round(12.345, 1)":12.3,"round(12.345)":12}]
+SELECT typeof(1), typeof(1.5), typeof('text'), typeof(x'01'), typeof(null), typeof(12345678901234567890);
+→ [{"typeof(1)":"integer","typeof(1.5)":"real","typeof('text')":"text","typeof(x'01')":"blob","typeof(null)":"null","typeof(12345678901234567890)":"integer"}]
+SELECT like('abc%', 'abcde'), glob('a*c', 'abbbc');
+→ [{"like('abc%', 'abcde')":true,"glob('a*c', 'abbbc')":true}]
+
+-- LIKE Operator Tests
+CREATE TABLE like_test (id INT, name TEXT);
+INSERT INTO like_test VALUES (1, 'apple'), (2, 'berry'), (3, 'citrus'), (4, 'orange');
+
+-- Test basic LIKE operator
+SELECT * FROM like_test WHERE name LIKE 'a%' ORDER BY id;
+→ [{"id":1,"name":"apple"}]
+
+-- Test NOT LIKE operator
+SELECT * FROM like_test WHERE name NOT LIKE '%a%' ORDER BY id;
+→ [{"id":2,"name":"berry"},{"id":3,"name":"citrus"}]
+
+-- Test underscore wildcard
+SELECT * FROM like_test WHERE name LIKE '_ra%' ORDER BY id;
+→ [{"id":4,"name":"orange"}]
+
+-- Test literal matching
+SELECT * FROM like_test WHERE name LIKE 'apple';
+→ [{"id":1,"name":"apple"}]
+
+-- Test LIKE with NULL
+SELECT * FROM like_test WHERE NULL LIKE 'a%';
+→ []
+
+-- Test pattern with NULL
+SELECT * FROM like_test WHERE 'apple' LIKE NULL;
+→ []
+
+DROP TABLE like_test;
+
+-- Date/Time Functions (output format depends on default build)
+SELECT date('now') IS NOT NULL;
+→ [true]
+SELECT time('now') IS NOT NULL;
+→ [true]
+SELECT datetime('now') IS NOT NULL;
+→ [true]
+SELECT julianday('2024-01-01') - julianday('2023-01-01');
+→ [365]
+SELECT strftime('%Y-%m-%d', '2024-07-26');
+→ ["2024-07-26"]
+
+-- ISO Validation Functions
+SELECT IsISODate('2024-02-29'), IsISODate('2023-02-29'), IsISODate('2024-13-01'), IsISODate('2024-01-32'), IsISODate('2024-01-01'), IsISODate(NULL);
+→ [{"isisodate('2024-02-29')":true,"isisodate('2023-02-29')":false,"isisodate('2024-13-01')":false,"isisodate('2024-01-32')":false,"isisodate('2024-01-01')":true,"isisodate(null)":false}]
+SELECT IsISODateTime('2024-01-01T00:00'), IsISODateTime('2024-01-01T00:00:00Z'), IsISODateTime('2024-01-01T23:59:59+05:30'), IsISODateTime('2024-01-01 00:00:00'), IsISODateTime('2024-01-01T24:00');
+→ [{"isisodatetime('2024-01-01T00:00')":true,"isisodatetime('2024-01-01T00:00:00Z')":true,"isisodatetime('2024-01-01T23:59:59+05:30')":true,"isisodatetime('2024-01-01 00:00:00')":false,"isisodatetime('2024-01-01T24:00')":false}]
+SELECT IsISODateTime('2024-01-01T10:00:00.123456789'), IsISODateTime('2024-01-01T10:00:00.1234567890');
+→ [{"isisodatetime('2024-01-01T10:00:00.123456789')":true,"isisodatetime('2024-01-01T10:00:00.1234567890')":false}]
+
+-- JSON Functions
+SELECT json_valid('{"a": 1}'), json_valid('{');
+→ [{"json_valid('{\"a\": 1}')":true,"json_valid('{')":false}]
+SELECT json_type('{"a": 1}', '$.a'), json_type('[1, "t", null]', '[1]');
+→ [{"json_type('{\"a\": 1}', '$.a')":"integer","json_type('[1, \"t\", null]', '[1]')":"text"}]
+SELECT json_extract('{"a": [10, 20], "b": "foo"}', '$.a[1]');
+→ [20]
+SELECT json_quote(1), json_quote('text'), json_quote(null);
+→ [{"json_quote(1)":"1","json_quote('text')":"\"text\"","json_quote(null)":"null"}]
+SELECT json_array(1, 'two', null, json_object('x', 3));
+→ [[1,"two",null,{"x":3}]]
+SELECT json_object('a', 1, 'b', json_array(2, 3));
+→ [{"a":1,"b":[2,3]}]
+SELECT json_insert('{"a":1}', '$.b', 2);
+→ [{"a":1,"b":2}]
+SELECT json_replace('{"a":1, "b":2}', '$.a', 99);
+→ [{"a":99,"b":2}]
+SELECT json_set('{"a":1}', '$.a', 99, '$.c', 'new');
+→ [{"a":99,"c":"new"}]
+SELECT json_remove('{"a":1, "b":[2,3]}', '$.b[0]');
+→ [{"a":1,"b":[3]}]
+SELECT json_array_length('[1, 2, 3]');
+→ [3]
+
+-- JSON Schema Validation (using moat-maker TypeScript-like syntax)
+-- Basic type validation
+SELECT json_schema('42', 'number'), json_schema('42.5', 'number');
+→ [{"json_schema('42', 'number')":true,"json_schema('42.5', 'number')":true}]
+SELECT json_schema('"hello"', 'string'), json_schema('true', 'boolean'), json_schema('null', 'null');
+→ [{"json_schema('\"hello\"', 'string')":true,"json_schema('true', 'boolean')":true,"json_schema('null', 'null')":true}]
+
+-- Array validation
+SELECT json_schema('[1, 2, 3]', 'number[]'), json_schema('[1, 2.5, 3]', 'number[]');
+→ [{"json_schema('[1, 2, 3]', 'number[]')":true,"json_schema('[1, 2.5, 3]', 'number[]')":true}]
+SELECT json_schema('["a", "b", "c"]', 'string[]'), json_schema('[1, "mixed"]', 'number[]');
+→ [{"json_schema('[\"a\", \"b\", \"c\"]', 'string[]')":true,"json_schema('[1, \"mixed\"]', 'number[]')":false}]
+
+-- Object validation
+SELECT json_schema('{"x": 42}', '{ x: number }'), json_schema('{"x": 42, "y": 3.14}', '{ x: number, y: number }');
+→ [{"json_schema('{\"x\": 42}', '{ x: number }')":true,"json_schema('{\"x\": 42, \"y\": 3.14}', '{ x: number, y: number }')":true}]
+SELECT json_schema('{"x": "wrong"}', '{ x: number }'), json_schema('{"x": 42}', '{ x: number, y: number }');
+→ [{"json_schema('{\"x\": \"wrong\"}', '{ x: number }')":false,"json_schema('{\"x\": 42}', '{ x: number, y: number }')":false}]
+
+-- Nested structures - array of objects
+SELECT json_schema('[{"x": 1}, {"x": 2}]', '{ x: number }[]'), json_schema('[{"x": 1}, {"x": "wrong"}]', '{ x: number }[]');
+→ [{"json_schema('[{\"x\": 1}, {\"x\": 2}]', '{ x: number }[]')":true,"json_schema('[{\"x\": 1}, {\"x\": \"wrong\"}]', '{ x: number }[]')":false}]
+
+-- Nested structures - object with arrays
+SELECT json_schema('{"items": [1, 2, 3]}', '{ items: number[] }'), json_schema('{"items": [1, "wrong", 3]}', '{ items: number[] }');
+→ [{"json_schema('{\"items\": [1, 2, 3]}', '{ items: number[] }')":true,"json_schema('{\"items\": [1, \"wrong\", 3]}', '{ items: number[] }')":false}]
+
+-- Complex nested structure
+SELECT json_schema('{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}', '{ users: { name: string, age: number }[] }'), json_schema('{"users": [{"name": "Alice", "age": "thirty"}]}', '{ users: { name: string, age: number }[] }');
+→ [{"json_schema('{\"users\": [{\"name\": \"Alice\", \"age\": 30}, {\"name\": \"Bob\", \"age\": 25}]}', '{ users: { name: string, age: number }[] }')":true,"json_schema('{\"users\": [{\"name\": \"Alice\", \"age\": \"thirty\"}]}', '{ users: { name: string, age: number }[] }')":false}]
+
+-- Invalid JSON and schema
+SELECT json_schema('{invalid', 'number'), json_schema('42', 'unknown_type');
+→ [{"json_schema('{invalid', 'number')":false,"json_schema('42', 'unknown_type')":false}]
+
+-- Empty structures
+SELECT json_schema('[]', 'number[]'), json_schema('{}', '{ x: number }'), json_schema('{}', '{}');
+→ [{"json_schema('[]', 'number[]')":true,"json_schema('{}', '{ x: number }')":false,"json_schema('{}', '{}')":true}]
+
+-- Use in CHECK constraint
+CREATE TABLE events (
+  id INTEGER PRIMARY KEY,
+  data JSON CHECK (json_schema(data, '{ x: number }[]'))
+);
+INSERT INTO events VALUES (1, '[{"x": 1}, {"x": 2}]');
+SELECT * FROM events;
+→ [{"id":1,"data":[{"x":1},{"x":2}]}]
+INSERT INTO events VALUES (2, '[{"x": "wrong"}]');
+-- error: CHECK constraint failed
+SELECT * FROM events;
+→ [{"id":1,"data":[{"x":1},{"x":2}]}]
+DROP TABLE events;
+
+-- Aggregate JSON Functions (Need table context)
+CREATE TABLE json_agg_t (id INT, grp TEXT, val TEXT);
+INSERT INTO json_agg_t VALUES (1, 'A', '1'), (2, 'B', 'x'), (3, 'A', '2'), (4, 'B', 'y');
+SELECT grp, json_group_array(val) FROM json_agg_t GROUP BY grp ORDER BY grp;
+→ [{"grp":"A","json_group_array(val)":[1,2]},{"grp":"B","json_group_array(val)":["x","y"]}]
+SELECT grp, json_group_object(val, id) FROM (SELECT * FROM json_agg_t) GROUP BY grp ORDER BY grp;
+→ [{"grp":"A","json_group_object(val, id)":{"1":1,"2":3}},{"grp":"B","json_group_object(val, id)":{"x":2,"y":4}}]
+DROP TABLE json_agg_t;

package/test/logic/06.1-string-functions.sqllogic

@@ -0,0 +1,92 @@
+-- string-functions.sqllogic - Testing string functions not covered in 06-builtin_functions
+
+-- trim with custom characters
+select trim('xxhelloxx', 'x');
+→ [{"trim('xxhelloxx', 'x')":"hello"}]
+
+-- ltrim and rtrim (whitespace)
+select ltrim('  hello'), rtrim('hello  ');
+→ [{"ltrim('  hello')":"hello","rtrim('hello  ')":"hello"}]
+
+-- ltrim and rtrim with custom characters
+select ltrim('xxhello', 'x'), rtrim('helloxx', 'x');
+→ [{"ltrim('xxhello', 'x')":"hello","rtrim('helloxx', 'x')":"hello"}]
+
+-- replace
+select replace('hello world', 'world', 'quereus');
+→ [{"replace('hello world', 'world', 'quereus')":"hello quereus"}]
+
+-- replace with empty pattern returns original string
+select replace('hello', '', 'x');
+→ [{"replace('hello', '', 'x')":"hello"}]
+
+-- instr (1-based position for found, 0 for not found)
+select instr('hello world', 'world');
+→ [{"instr('hello world', 'world')":7}]
+
+select instr('hello', 'xyz');
+→ [{"instr('hello', 'xyz')":0}]
+
+-- instr NULL propagation
+select instr(null, 'x'), instr('hello', null);
+→ [{"instr(null, 'x')":null,"instr('hello', null)":null}]
+
+-- reverse
+select reverse('hello');
+→ [{"reverse('hello')":"olleh"}]
+
+-- reverse preserves characters
+select reverse('abc');
+→ [{"reverse('abc')":"cba"}]
+
+-- reverse with emoji (tests Array.from handling)
+select reverse('a😀b');
+→ [{"reverse('a😀b')":"b😀a"}]
+
+-- lpad
+select lpad('hi', 5, '*');
+→ [{"lpad('hi', 5, '*')":"***hi"}]
+
+-- rpad
+select rpad('hi', 5, '*');
+→ [{"rpad('hi', 5, '*')":"hi***"}]
+
+-- lpad with multi-char pad
+select lpad('hi', 7, 'ab');
+→ [{"lpad('hi', 7, 'ab')":"ababahi"}]
+
+-- lpad when string already longer than target
+select lpad('hello', 3, '*');
+→ [{"lpad('hello', 3, '*')":"hello"}]
+
+-- lpad with empty pad returns original string
+select lpad('hi', 5, '');
+→ [{"lpad('hi', 5, '')":"hi"}]
+
+-- NULL propagation for string functions
+select lower(null), upper(null), length(null), trim(null), replace(null, 'a', 'b');
+→ [{"lower(null)":null,"upper(null)":null,"length(null)":null,"trim(null)":null,"replace(null, 'a', 'b')":null}]
+
+-- trim with no characters to remove
+select trim('hello', 'x');
+→ [{"trim('hello', 'x')":"hello"}]
+
+-- ltrim/rtrim with null
+select ltrim(null), rtrim(null);
+→ [{"ltrim(null)":null,"rtrim(null)":null}]
+
+-- reverse of empty string returns empty string
+select reverse('');
+→ [{"reverse('')":""}]
+
+-- replace multiple occurrences
+select replace('aabbcc', 'b', 'x');
+→ [{"replace('aabbcc', 'b', 'x')":"aaxxcc"}]
+
+-- instr with empty substring
+select instr('hello', '');
+→ [{"instr('hello', '')":0}]
+
+-- instr with empty string
+select instr('', 'a');
+→ [{"instr('', 'a')":0}]

package/test/logic/06.1.3-like-glob-edges.sqllogic

@@ -0,0 +1,53 @@
+-- like-glob-edges.sqllogic - LIKE / GLOB scenarios beyond 06-builtin_functions and
+-- 24-builtin-branches: case-sensitivity invariant, BLOB operands, GLOB character classes.
+-- adapted from SQLite test/like.test and test/like2.test
+-- Notes vs SQLite:
+--   * char() builtin is not present in Quereus; multi-byte LIKE checks via char()
+--     concatenation are dropped here.
+--   * ESCAPE clause for LIKE is not supported; cases dropped.
+
+-- Quereus LIKE is case-SENSITIVE by design (no PRAGMA case_sensitive_like)
+select like('A%', 'apple') as result;
+→ [{"result":false}]
+
+select like('a%', 'apple') as result;
+→ [{"result":true}]
+
+select like('apple', 'APPLE') as result;
+→ [{"result":false}]
+
+-- LIKE with multi-byte UTF-8 literal: `_` should match a single character (code point), not byte
+select like('a_b', 'aäb') as result;
+→ [{"result":true}]
+
+-- LIKE `_` matches a single Unicode code point (non-BMP chars count as one)
+select like('_', '😀') as result;
+→ [{"result":true}]
+
+-- LIKE on numeric: assert observable behavior on a text column
+create table like_num (id integer primary key, n integer);
+insert into like_num values (1, 1234);
+select like('12%', n) from like_num;
+→ [{"like('12%', n)":true}]
+drop table like_num;
+
+-- GLOB is also case-sensitive
+select glob('ABC*', 'abcdef') as result;
+→ [{"result":false}]
+
+select glob('abc*', 'abcdef') as result;
+→ [{"result":true}]
+
+-- GLOB character classes: `[abc]`, `[a-c]`, `[^abc]`
+select glob('[abc]', 'a') as result;
+→ [{"result":true}]
+select glob('[abc]', 'd') as result;
+→ [{"result":false}]
+select glob('[a-c]', 'b') as result;
+→ [{"result":true}]
+select glob('[a-c]', 'd') as result;
+→ [{"result":false}]
+select glob('[^abc]', 'd') as result;
+→ [{"result":true}]
+select glob('[^abc]', 'a') as result;
+→ [{"result":false}]

package/test/logic/06.2-math-functions.sqllogic

@@ -0,0 +1,82 @@
+-- math-functions.sqllogic - Testing math functions not covered in 06-builtin_functions
+
+-- sqrt
+select sqrt(16), sqrt(2), sqrt(0);
+→ [{"sqrt(16)":4,"sqrt(2)":1.4142135623730951,"sqrt(0)":0}]
+
+-- sqrt of negative returns null
+select sqrt(-1);
+→ [{"sqrt(-1)":null}]
+
+-- pow/power
+select pow(2, 10), power(3, 3);
+→ [{"pow(2, 10)":1024,"power(3, 3)":27}]
+
+-- floor and ceil
+select floor(3.7), floor(-3.7), ceil(3.2), ceiling(-3.2);
+→ [{"floor(3.7)":3,"floor(-3.7)":-4,"ceil(3.2)":4,"ceiling(-3.2)":-3}]
+
+-- clamp
+select clamp(5, 1, 10), clamp(-5, 0, 100), clamp(50, 0, 10);
+→ [{"clamp(5, 1, 10)":5,"clamp(-5, 0, 100)":0,"clamp(50, 0, 10)":10}]
+
+-- greatest/least
+select greatest(1, 3, 2), least(1, 3, 2);
+→ [{"greatest(1, 3, 2)":3,"least(1, 3, 2)":1}]
+
+-- greatest/least with strings
+select greatest('apple', 'banana', 'cherry'), least('apple', 'banana', 'cherry');
+→ [{"greatest('apple', 'banana', 'cherry')":"cherry","least('apple', 'banana', 'cherry')":"apple"}]
+
+-- choose (1-based index)
+select choose(2, 'a', 'b', 'c');
+→ [{"choose(2, 'a', 'b', 'c')":"b"}]
+
+-- choose out of range returns null
+select choose(0, 'a', 'b');
+→ [{"choose(0, 'a', 'b')":null}]
+
+select choose(5, 'a', 'b');
+→ [{"choose(5, 'a', 'b')":null}]
+
+-- iif
+select iif(1, 'yes', 'no'), iif(0, 'yes', 'no'), iif(null, 'yes', 'no');
+→ [{"iif(1, 'yes', 'no')":"yes","iif(0, 'yes', 'no')":"no","iif(null, 'yes', 'no')":"no"}]
+
+-- random returns integer type
+select typeof(random());
+→ [{"typeof(random())":"integer"}]
+
+-- NULL propagation for math (through table columns, historically to avoid the plan-time
+-- argument-type gate — a NULL-typed literal now passes it, see
+-- 06.5.3-undeclared-return-type-comparison § 6)
+create table null_math (id integer primary key, v real null);
+insert into null_math values (1, null);
+select abs(v), round(v), sqrt(v), pow(v, 2), floor(v), ceil(v) from null_math;
+→ [{"abs(v)":null,"round(v)":null,"sqrt(v)":null,"pow(v, 2)":null,"floor(v)":null,"ceil(v)":null}]
+drop table null_math;
+
+-- pow with zero exponent
+select pow(5, 0), pow(0, 0);
+→ [{"pow(5, 0)":1,"pow(0, 0)":1}]
+
+-- floor/ceil with integers (no change)
+select floor(5), ceil(5);
+→ [{"floor(5)":5,"ceil(5)":5}]
+
+-- clamp with null (through table column). Propagates NULL like every other math function
+-- above; this asserted 0 until clamp got an explicit null short-circuit, because its three
+-- arguments reach Number() together and Number(null) is 0, which returned the lower bound.
+create table null_clamp (id integer primary key, v real null);
+insert into null_clamp values (1, null);
+select clamp(v, 0, 10) from null_clamp;
+→ [{"clamp(v, 0, 10)":null}]
+drop table null_clamp;
+
+-- greatest/least with single argument
+select greatest(42), least(42);
+→ [{"greatest(42)":42,"least(42)":42}]
+
+-- pow with negative exponent
+select pow(2, -1);
+→ [{"pow(2, -1)":0.5}]

package/test/logic/06.3-schema.sqllogic

@@ -0,0 +1,48 @@
+-- schema-indexes.sqllogic - Testing schema() introspection for indexes
+--
+-- requires-capability: standalone-index-ddl
+
+CREATE TABLE products (
+	id INTEGER PRIMARY KEY,
+	name TEXT,
+	category TEXT
+);
+
+CREATE INDEX idx_category ON products(category);
+
+CREATE INDEX idx_name ON products(name);
+
+-- Verify indexes are returned in schema()
+SELECT type, name, tbl_name, sql FROM schema() WHERE type = 'index' ORDER BY name;
+→ [{"type":"index","name":"idx_category","tbl_name":"products","sql":"CREATE INDEX \"idx_category\" ON \"main\".\"products\" (\"category\" COLLATE BINARY)"},{"type":"index","name":"idx_name","tbl_name":"products","sql":"CREATE INDEX \"idx_name\" ON \"main\".\"products\" (\"name\" COLLATE BINARY)"}]
+
+-- Verify 'index' is in the list of schema object types
+SELECT DISTINCT type FROM schema() ORDER BY type;
+→ [{"type":"function"},{"type":"index"},{"type":"table"}]
+
+-- Test with composite index
+CREATE TABLE orders (
+	id INTEGER PRIMARY KEY,
+	customer_id INTEGER,
+	status TEXT
+);
+
+CREATE INDEX idx_customer_status ON orders(customer_id, status);
+
+SELECT name, tbl_name, sql FROM schema() WHERE type = 'index' AND tbl_name = 'orders';
+→ [{"name":"idx_customer_status","tbl_name":"orders","sql":"CREATE INDEX \"idx_customer_status\" ON \"main\".\"orders\" (\"customer_id\" COLLATE BINARY, \"status\" COLLATE BINARY)"}]
+
+-- Test with DESC index
+CREATE TABLE events (
+	id INTEGER PRIMARY KEY,
+	created_at TEXT
+);
+
+CREATE INDEX idx_created_desc ON events(created_at DESC);
+
+SELECT sql FROM schema() WHERE type = 'index' AND name = 'idx_created_desc';
+→ [{"sql":"CREATE INDEX \"idx_created_desc\" ON \"main\".\"events\" (\"created_at\" COLLATE BINARY DESC)"}]
+
+-- The view-shaped schema() assertions (view row, view sql preserved, 'view' in the
+-- type list) need no index and live in 06.3.6-schema-views, so a backend that skips
+-- this file over its index DDL still runs them.

package/test/logic/06.3.1-schema-all-schemas.sqllogic

@@ -0,0 +1,39 @@
+-- Schema() TVF: schema column and non-default schema enumeration
+
+-- Setup: create a table in main
+CREATE TABLE main_t (id INTEGER PRIMARY KEY, val TEXT);
+
+-- Test 1: schema column exists and shows 'main' for main-schema objects
+SELECT schema, type, name FROM schema() WHERE name = 'main_t';
+→ [{"schema":"main","type":"table","name":"main_t"}]
+
+-- Test 2: all rows have a non-null schema column
+SELECT count(*) as bad FROM schema() WHERE schema IS NULL;
+→ [{"bad":0}]
+
+-- Test 3: create a non-default schema with a table, verify it appears
+declare schema myschema {
+	table other_t {
+		id INTEGER PRIMARY KEY,
+		label TEXT
+	}
+}
+
+apply schema myschema;
+
+-- run
+
+SELECT schema, type, name FROM schema() WHERE name = 'other_t';
+→ [{"schema":"myschema","type":"table","name":"other_t"}]
+
+-- Test 4: both main and myschema tables appear together
+SELECT schema, name FROM schema() WHERE type = 'table' AND name IN ('main_t', 'other_t') ORDER BY schema, name;
+→ [{"schema":"main","name":"main_t"},{"schema":"myschema","name":"other_t"}]
+
+-- Test 5: functions from all schemas appear (built-in functions are in main)
+SELECT DISTINCT schema FROM schema() WHERE type = 'function' ORDER BY schema;
+→ [{"schema":"main"}]
+
+-- Cleanup
+DROP TABLE main_t;
+DROP TABLE myschema.other_t;