@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/84-asof-scan.sqllogic

@@ -0,0 +1,238 @@
+-- asof-scan.sqllogic — Streaming asof scan correctness via lateral-top-1 rule.
+-- The rule fires only when the left input is monotonic on the match attribute,
+-- so each query wraps the left side in `ORDER BY ts` (per partition or globally).
+-- These cases run with the default `asof.mergeRowThreshold` (10000), keeping
+-- the AsofScanNode on its `'hash'` strategy. The `'merge'` strategy's
+-- equivalence is validated end-to-end in test/optimizer/asof-scan.spec.ts
+-- (with `mergeRowThreshold = 0` forcing the promotion).
+
+-- Setup: trades stream (left) and quotes stream (right, partitioned by symbol).
+CREATE TABLE asof_trades (id INTEGER PRIMARY KEY, symbol TEXT, ts INTEGER);
+CREATE TABLE asof_quotes (ts INTEGER PRIMARY KEY, symbol TEXT, bid REAL);
+
+-- Trades inserted in ts order so the natural PK scan also yields ts-sorted rows
+-- via id, but we still wrap the left in ORDER BY ts to keep the rule's
+-- monotonicOn precondition explicit.
+INSERT INTO asof_trades VALUES
+  (1, 'A', 75),
+  (2, 'A', 100),
+  (3, 'A', 200),
+  (4, 'B', 150),
+  (5, 'C', 500);
+
+INSERT INTO asof_quotes VALUES
+  (50,  'A', 1.0),
+  (150, 'A', 1.5),
+  (180, 'B', 2.0),
+  (250, 'A', 2.5);
+
+-- Plan shape: ASOF SCAN must appear in the plan (when left is sorted on ts).
+SELECT op FROM query_plan('select t.id, q.bid from (select id, symbol, ts from asof_trades order by ts) t left join lateral (select bid from asof_quotes q where q.symbol = t.symbol and q.ts <= t.ts order by q.ts desc limit 1) q on true') WHERE op = 'ASOFSCAN';
+→ [{"op":"ASOFSCAN"}]
+
+-- Partitioned non-strict left lateral. Left is sorted by ts.
+-- t.id=1 (A,75): A quotes ≤ 75 are {50:1.0}. → 1.0
+-- t.id=2 (A,100): {50:1.0}. → 1.0
+-- t.id=3 (A,200): {50:1.0, 150:1.5}. → 1.5
+-- t.id=4 (B,150): no B quote ≤ 150 (only ts=180 in B). → null
+-- t.id=5 (C,500): no C quotes. → null
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":1.5},{"id":4,"bid":null},{"id":5,"bid":null}]
+
+-- Inner cross join lateral drops left rows with no match.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t CROSS JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":1.5}]
+
+-- Strict variant (q.ts < t.ts, no equality at the boundary).
+-- t.id=1 (A,75): A quotes < 75 are {50:1.0}. → 1.0
+-- t.id=2 (A,100): A quotes < 100 are {50:1.0}. → 1.0
+-- t.id=3 (A,200): A quotes < 200 are {50, 150}. → 1.5
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts < t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":1.5},{"id":4,"bid":null},{"id":5,"bid":null}]
+
+-- Boundary tie: when q.ts equals t.ts, non-strict matches; strict skips.
+INSERT INTO asof_quotes VALUES (100, 'A', 9.9);
+
+-- Non-strict (=): t.id=2 (ts=100) sees the tied 9.9.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true WHERE t.id = 2;
+→ [{"id":2,"bid":9.9}]
+
+-- Strict (<): t.id=2 (ts=100) skips the tie; falls back to ts=50, bid=1.0.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts < t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true WHERE t.id = 2;
+→ [{"id":2,"bid":1}]
+
+DELETE FROM asof_quotes WHERE ts = 100;
+
+-- Empty right: outer left-pads, inner drops.
+DELETE FROM asof_quotes;
+
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":null},{"id":2,"bid":null},{"id":3,"bid":null},{"id":4,"bid":null},{"id":5,"bid":null}]
+
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t CROSS JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ORDER BY t.id;
+→ []
+
+-- Restore quotes for the unpartitioned case.
+INSERT INTO asof_quotes VALUES
+  (50,  'A', 1.0),
+  (150, 'A', 1.5),
+  (180, 'B', 2.0),
+  (250, 'A', 2.5);
+
+-- Unpartitioned asof: any latest quote ≤ t.ts regardless of symbol.
+-- Left sorted by ts: t.id=1(75), 2(100), 4(150), 3(200), 5(500)
+-- t.id=1 (75):  ≤75  → 50  → 1.0
+-- t.id=2 (100): ≤100 → 50  → 1.0
+-- t.id=4 (150): ≤150 → 150 → 1.5
+-- t.id=3 (200): ≤200 → 180 → 2.0
+-- t.id=5 (500): ≤500 → 250 → 2.5
+SELECT t.id, q.bid FROM (SELECT id, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":2},{"id":4,"bid":1.5},{"id":5,"bid":2.5}]
+
+-- ASC variant plan-shape: ASOF SCAN must appear (left sorted on ts, q.ts >= t.ts ORDER BY q.ts ASC).
+SELECT op FROM query_plan('select t.id, q.bid from (select id, symbol, ts from asof_trades order by ts) t left join lateral (select bid from asof_quotes q where q.symbol = t.symbol and q.ts >= t.ts order by q.ts asc limit 1) q on true') WHERE op = 'ASOFSCAN';
+→ [{"op":"ASOFSCAN"}]
+
+-- Partitioned non-strict ASC lateral. Left sorted by ts.
+-- A quotes by ts: 50, 150, 250 ; B quotes by ts: 180
+-- t.id=1 (A,75):  earliest A ≥ 75  → 150 → 1.5
+-- t.id=2 (A,100): earliest A ≥ 100 → 150 → 1.5
+-- t.id=4 (B,150): earliest B ≥ 150 → 180 → 2.0
+-- t.id=3 (A,200): earliest A ≥ 200 → 250 → 2.5
+-- t.id=5 (C,500): no C quote → null
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts >= t.ts ORDER BY q.ts ASC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1.5},{"id":2,"bid":1.5},{"id":3,"bid":2.5},{"id":4,"bid":2},{"id":5,"bid":null}]
+
+-- Strict ASC variant (q.ts > t.ts) — boundary tie at q.ts = t.ts is excluded.
+-- Add an exact-match quote to exercise the tie.
+INSERT INTO asof_quotes VALUES (200, 'A', 7.7);
+
+-- Non-strict ASC: t.id=3 (ts=200) sees the tied 7.7.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts >= t.ts ORDER BY q.ts ASC LIMIT 1
+) q ON true WHERE t.id = 3;
+→ [{"id":3,"bid":7.7}]
+
+-- Strict ASC: t.id=3 (ts=200) skips the tie; falls through to ts=250 → 2.5.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts > t.ts ORDER BY q.ts ASC LIMIT 1
+) q ON true WHERE t.id = 3;
+→ [{"id":3,"bid":2.5}]
+
+DELETE FROM asof_quotes WHERE ts = 200 AND bid = 7.7;
+
+-- Inner cross-join lateral (ASC) drops left rows with no match.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades ORDER BY ts) t CROSS JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.symbol = t.symbol AND q.ts >= t.ts ORDER BY q.ts ASC LIMIT 1
+) q ORDER BY t.id;
+→ [{"id":1,"bid":1.5},{"id":2,"bid":1.5},{"id":3,"bid":2.5},{"id":4,"bid":2}]
+
+-- Unpartitioned ASC: any earliest quote ≥ t.ts regardless of symbol.
+-- All quotes by ts: 50, 150, 180, 250
+-- t.id=1 (75):  earliest ≥ 75  → 150 → 1.5
+-- t.id=2 (100): earliest ≥ 100 → 150 → 1.5
+-- t.id=4 (150): earliest ≥ 150 → 150 → 1.5
+-- t.id=3 (200): earliest ≥ 200 → 250 → 2.5
+-- t.id=5 (500): earliest ≥ 500 → none → null
+SELECT t.id, q.bid FROM (SELECT id, ts FROM asof_trades ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes q WHERE q.ts >= t.ts ORDER BY q.ts ASC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1.5},{"id":2,"bid":1.5},{"id":3,"bid":2.5},{"id":4,"bid":1.5},{"id":5,"bid":null}]
+
+-- NOCASE partition: 'A' on the left must match the 'a' bucket on the right.
+CREATE TABLE asof_trades_ci (id INTEGER PRIMARY KEY, symbol TEXT COLLATE NOCASE, ts INTEGER);
+CREATE TABLE asof_quotes_ci (ts INTEGER PRIMARY KEY, symbol TEXT COLLATE NOCASE, bid REAL);
+
+INSERT INTO asof_trades_ci VALUES
+  (1, 'A', 100),
+  (2, 'a', 200),
+  (3, 'B', 150);
+
+-- Right side uses lowercase; under NOCASE these must still bucket together.
+INSERT INTO asof_quotes_ci VALUES
+  (50,  'a', 1.0),
+  (180, 'b', 2.0);
+
+-- Partitioned non-strict desc: each left row finds the right bucket regardless of case.
+-- t.id=1 (A,100): A/a quotes ≤ 100 → 50  → 1.0
+-- t.id=2 (a,200): A/a quotes ≤ 200 → 50  → 1.0
+-- t.id=3 (B,150): B/b quotes ≤ 150 → none (only ts=180) → null
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades_ci ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes_ci q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":null}]
+
+DROP TABLE asof_trades_ci;
+DROP TABLE asof_quotes_ci;
+
+-- RTRIM partition: trailing-space differences must collapse into the same bucket.
+CREATE TABLE asof_trades_rt (id INTEGER PRIMARY KEY, symbol TEXT COLLATE RTRIM, ts INTEGER);
+CREATE TABLE asof_quotes_rt (ts INTEGER PRIMARY KEY, symbol TEXT COLLATE RTRIM, bid REAL);
+
+INSERT INTO asof_trades_rt VALUES
+  (1, 'B ',  100),
+  (2, 'B  ', 200);
+
+INSERT INTO asof_quotes_rt VALUES
+  (50, 'B', 3.0);
+
+-- Both left rows ('B ', 'B  ') match right bucket 'B' under COLLATE RTRIM.
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades_rt ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes_rt q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":3},{"id":2,"bid":3}]
+
+DROP TABLE asof_trades_rt;
+DROP TABLE asof_quotes_rt;
+
+-- Asymmetric partition collation (ticket join-key-collation-resolution-alignment):
+-- ONLY the right (quotes) side declares NOCASE; the left (trades) side defaults to
+-- BINARY. The partition comparison resolves through the shared provenance lattice
+-- to NOCASE (a declared collation outranks a defaulted BINARY) regardless of which
+-- side spells it — so 'A' on the left still buckets with 'a' on the right. The
+-- pre-alignment left-first `leftType.collationName ?? rightType.collationName`
+-- picked the left's defaulted BINARY and the buckets diverged.
+CREATE TABLE asof_trades_mix (id INTEGER PRIMARY KEY, symbol TEXT, ts INTEGER);
+CREATE TABLE asof_quotes_mix (ts INTEGER PRIMARY KEY, symbol TEXT COLLATE NOCASE, bid REAL);
+
+INSERT INTO asof_trades_mix VALUES (1, 'A', 100), (2, 'a', 200), (3, 'B', 150);
+INSERT INTO asof_quotes_mix VALUES (50, 'a', 1.0), (180, 'b', 2.0);
+
+-- This must remain an ASOFSCAN — the partition-collation resolution under review
+-- only runs in the asof emitter; if the plan ever degraded to a generic correlated
+-- subquery the result assertion below would pass vacuously without exercising it.
+SELECT op FROM query_plan('select t.id, q.bid from (select id, symbol, ts from asof_trades_mix order by ts) t left join lateral (select bid from asof_quotes_mix q where q.symbol = t.symbol and q.ts <= t.ts order by q.ts desc limit 1) q on true') WHERE op = 'ASOFSCAN';
+→ [{"op":"ASOFSCAN"}]
+
+-- t.id=1 (A,100): A/a quotes ≤ 100 → ts=50 → 1.0
+-- t.id=2 (a,200): A/a quotes ≤ 200 → ts=50 → 1.0
+-- t.id=3 (B,150): B/b quotes ≤ 150 → none (only ts=180) → null
+SELECT t.id, q.bid FROM (SELECT id, symbol, ts FROM asof_trades_mix ORDER BY ts) t LEFT JOIN LATERAL (
+  SELECT bid FROM asof_quotes_mix q WHERE q.symbol = t.symbol AND q.ts <= t.ts ORDER BY q.ts DESC LIMIT 1
+) q ON true ORDER BY t.id;
+→ [{"id":1,"bid":1},{"id":2,"bid":1},{"id":3,"bid":null}]
+
+DROP TABLE asof_trades_mix;
+DROP TABLE asof_quotes_mix;
+
+-- Cleanup
+DROP TABLE asof_trades;
+DROP TABLE asof_quotes;

package/test/logic/84-key-cardinality.sqllogic

@@ -0,0 +1,50 @@
+-- key-cardinality.sqllogic - Key-driven cardinality and DISTINCT elimination tests
+
+-- Setup: customers (PK) and orders (FK → customers)
+CREATE TABLE kc_customers (id INTEGER PRIMARY KEY, name TEXT);
+CREATE TABLE kc_orders (oid INTEGER PRIMARY KEY, customer_id INTEGER, amount INTEGER);
+
+INSERT INTO kc_customers VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Carol');
+INSERT INTO kc_orders VALUES (100, 1, 50), (101, 1, 75), (102, 2, 30), (103, 3, 10);
+
+-- FK→PK join: orders JOIN customers ON customer_id = id
+-- PK side (customers.id) is covered, so uniqueKeys should be preserved
+SELECT o.oid, c.name FROM kc_orders o INNER JOIN kc_customers c ON o.customer_id = c.id ORDER BY o.oid;
+→ [{"oid":100,"name":"Alice"},{"oid":101,"name":"Alice"},{"oid":102,"name":"Bob"},{"oid":103,"name":"Carol"}]
+
+-- Reverse join direction should also work
+SELECT o.oid, c.name FROM kc_customers c INNER JOIN kc_orders o ON c.id = o.customer_id ORDER BY o.oid;
+→ [{"oid":100,"name":"Alice"},{"oid":101,"name":"Alice"},{"oid":102,"name":"Bob"},{"oid":103,"name":"Carol"}]
+
+-- DISTINCT on PK column is redundant — should be eliminated
+SELECT DISTINCT id FROM kc_customers ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- DISTINCT on non-key column is NOT redundant — should still work
+SELECT DISTINCT customer_id FROM kc_orders ORDER BY customer_id;
+→ [{"customer_id":1},{"customer_id":2},{"customer_id":3}]
+
+-- Unique constraint test
+CREATE TABLE kc_users (id INTEGER PRIMARY KEY, email TEXT UNIQUE, name TEXT);
+INSERT INTO kc_users VALUES (1, 'alice@test.com', 'Alice'), (2, 'bob@test.com', 'Bob');
+
+-- Join on unique column: email is a unique key, so PK-like behavior
+CREATE TABLE kc_logins (login_email TEXT, ts INTEGER);
+INSERT INTO kc_logins VALUES ('alice@test.com', 1000), ('bob@test.com', 2000), ('alice@test.com', 3000);
+
+SELECT l.ts, u.name FROM kc_logins l INNER JOIN kc_users u ON l.login_email = u.email ORDER BY l.ts;
+→ [{"ts":1000,"name":"Alice"},{"ts":2000,"name":"Bob"},{"ts":3000,"name":"Alice"}]
+
+-- Multi-table join with keys
+CREATE TABLE kc_products (pid INTEGER PRIMARY KEY, pname TEXT);
+CREATE TABLE kc_order_items (item_id INTEGER PRIMARY KEY, order_id INTEGER, product_id INTEGER);
+
+INSERT INTO kc_products VALUES (1, 'Widget'), (2, 'Gadget');
+INSERT INTO kc_order_items VALUES (1, 100, 1), (2, 100, 2), (3, 101, 1);
+
+SELECT oi.item_id, o.oid, p.pname
+FROM kc_order_items oi
+INNER JOIN kc_orders o ON oi.order_id = o.oid
+INNER JOIN kc_products p ON oi.product_id = p.pid
+ORDER BY oi.item_id;
+→ [{"item_id":1,"oid":100,"pname":"Widget"},{"item_id":2,"oid":100,"pname":"Gadget"},{"item_id":3,"oid":101,"pname":"Widget"}]

package/test/logic/85-relational-const-folding.sqllogic

@@ -0,0 +1,51 @@
+-- Tests for relational constant folding
+-- Verifies that constant relational subtrees are folded into TableLiteralNodes
+
+-- Basic VALUES folding: all-literal VALUES should fold to TableLiteral
+SELECT id, name FROM (VALUES (1, 'a'), (2, 'b')) AS t(id, name);
+→ [{"id": 1, "name": "a"}, {"id": 2, "name": "b"}]
+
+-- Constant subquery folding: constant projections over SingleRow
+SELECT * FROM (SELECT 1 + 2 AS x, 'hello' AS y);
+→ [{"x": 3, "y": "hello"}]
+
+-- Nested constant VALUES with expressions
+SELECT num, str FROM (VALUES (1 + 1, 'a' || 'b'), (3 * 2, 'cd')) AS t(num, str);
+→ [{"num": 2, "str": "ab"}, {"num": 6, "str": "cd"}]
+
+-- Table references should NOT be folded
+CREATE TABLE fold_test (id INTEGER PRIMARY KEY, name TEXT) USING memory;
+INSERT INTO fold_test VALUES (1, 'Alice'), (2, 'Bob');
+
+SELECT * FROM fold_test ORDER BY id;
+→ [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
+
+-- Mixed: constant subquery joined with table (table part not folded)
+SELECT f.name, c.val FROM fold_test f JOIN (VALUES (10), (20)) AS c(val) ON f.id = 1 ORDER BY c.val;
+→ [{"name": "Alice", "val": 10}, {"name": "Alice", "val": 20}]
+
+-- Constant expression over VALUES with WHERE clause
+SELECT id, letter FROM (VALUES (1, 'x'), (2, 'y'), (3, 'z')) AS t(id, letter) WHERE id > 1;
+→ [{"id": 2, "letter": "y"}, {"id": 3, "letter": "z"}]
+
+-- Prepared statement re-execution: same results on second run
+SELECT a, b FROM (VALUES (100, 200), (300, 400)) AS t(a, b);
+→ [{"a": 100, "b": 200}, {"a": 300, "b": 400}]
+
+SELECT a, b FROM (VALUES (100, 200), (300, 400)) AS t(a, b);
+→ [{"a": 100, "b": 200}, {"a": 300, "b": 400}]
+
+-- Single-row constant subquery
+SELECT * FROM (SELECT 42 AS answer);
+→ [{"answer": 42}]
+
+-- Constant with null values
+SELECT a, b FROM (VALUES (1, null), (null, 'text')) AS t(a, b);
+→ [{"a": 1, "b": null}, {"a": null, "b": "text"}]
+
+-- Boolean constant folding in VALUES
+SELECT a, b FROM (VALUES (1 > 0, 2 < 1)) AS t(a, b);
+→ [{"a": true, "b": false}]
+
+-- Cleanup
+DROP TABLE fold_test;

package/test/logic/86-scalar-cse.sqllogic

@@ -0,0 +1,42 @@
+-- scalar-cse.sqllogic - Scalar common subexpression elimination tests
+
+CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT, value INTEGER) USING memory;
+INSERT INTO t VALUES (1, 'alpha', 10), (2, 'beta', 20), (3, 'gamma', 5), (4, 'delta', 15);
+
+CREATE TABLE orders (id INTEGER PRIMARY KEY, price INTEGER, qty INTEGER) USING memory;
+INSERT INTO orders VALUES (1, 10, 5), (2, 20, 3), (3, 5, 100), (4, 8, 2);
+
+-- Function shared between projection and filter
+select length(name) as len FROM t WHERE length(name) > 4 ORDER BY id;
+→ [{"len":5},{"len":5},{"len":5}]
+
+-- Arithmetic expression shared across projection, filter, and ORDER BY
+select price * qty as total FROM orders WHERE price * qty > 20 ORDER BY price * qty;
+→ [{"total":50},{"total":60},{"total":500}]
+
+-- Multiple filter conditions sharing same expression
+select length(name) as len FROM t WHERE length(name) > 3 AND length(name) < 6 ORDER BY id;
+→ [{"len":5},{"len":4},{"len":5},{"len":5}]
+
+-- Intra-projection duplicates
+select length(name) as len1, length(name) as len2 FROM t WHERE id = 1;
+→ [{"len1":5,"len2":5}]
+
+-- Expression in projection and ORDER BY
+select value * 2 as doubled FROM t ORDER BY value * 2;
+→ [{"doubled":10},{"doubled":20},{"doubled":30},{"doubled":40}]
+
+-- Bare column references NOT affected (cheap to recompute)
+select name FROM t WHERE name > 'b' ORDER BY name;
+→ [{"name":"beta"},{"name":"delta"},{"name":"gamma"}]
+
+-- Nested function calls with shared subexpression
+select upper(name) as u FROM t WHERE length(upper(name)) > 4 ORDER BY upper(name);
+→ [{"u":"ALPHA"},{"u":"DELTA"},{"u":"GAMMA"}]
+
+-- No duplicates, no transformation needed
+select length(name) as len, value * 2 as doubled FROM t WHERE id = 1;
+→ [{"len":5,"doubled":20}]
+
+DROP TABLE orders;
+DROP TABLE t;

package/test/logic/90-error_paths.sqllogic

@@ -0,0 +1,114 @@
+-- error_paths.sqllogic - Testing expected error conditions
+
+-- Syntax Error: Incomplete statement
+SELECT * FROM;
+-- error: Expected table name. (at line 1, column 14)
+
+-- Syntax Error: Misspelled keyword
+CREAT TABLE t_err (a);
+-- error: Expected statement type (SELECT, INSERT, UPDATE, DELETE, VALUES, CREATE, etc.), got 'CREAT'. (at line 1, column 1)
+
+-- Semantic Error: Table not found
+SELECT * FROM non_existent_table;
+-- error: not found in schema path
+
+-- Semantic Error: Column not found
+CREATE TABLE t_err_col (a INTEGER);
+INSERT INTO t_err_col VALUES (1);
+SELECT b FROM t_err_col;
+-- error: Column not found: b
+DROP TABLE t_err_col;
+
+-- Semantic Error: Ambiguous column
+CREATE TABLE t_amb1 (id INTEGER, name TEXT);
+CREATE TABLE t_amb2 (id INTEGER, value TEXT);
+INSERT INTO t_amb1 VALUES (1, 'A');
+INSERT INTO t_amb2 VALUES (1, 'X');
+SELECT id FROM t_amb1 JOIN t_amb2 ON t_amb1.id = t_amb2.id;
+-- error: ambiguous column name: id
+DROP TABLE t_amb1;
+DROP TABLE t_amb2;
+
+-- Semantic Success: Qualified columns resolve correctly in JOIN
+CREATE TABLE t_qual1 (id INTEGER, name TEXT);
+CREATE TABLE t_qual2 (id INTEGER, value TEXT);
+INSERT INTO t_qual1 VALUES (1, 'A'), (2, 'B');
+INSERT INTO t_qual2 VALUES (1, 'X'), (3, 'Y');
+SELECT a.id AS a_id, a.name, b.id AS b_id, b.value FROM t_qual1 a JOIN t_qual2 b ON a.id = b.id ORDER BY a.id;
+→ [{"a_id":1,"name":"A","b_id":1,"value":"X"}]
+DROP TABLE t_qual1;
+DROP TABLE t_qual2;
+
+-- Semantic Success: Projection alias shadows input columns in ORDER BY
+CREATE TABLE t_order_shadow (id INTEGER, name TEXT);
+INSERT INTO t_order_shadow VALUES (1, 'Z'), (2, 'A'), (3, 'M');
+SELECT id AS name, name AS id FROM t_order_shadow ORDER BY name;
+→ [{"name":1,"id":"Z"},{"name":2,"id":"A"},{"name":3,"id":"M"}]
+SELECT id AS name, name AS id FROM t_order_shadow ORDER BY name DESC;
+→ [{"name":3,"id":"M"},{"name":2,"id":"A"},{"name":1,"id":"Z"}]
+DROP TABLE t_order_shadow;
+
+-- Semantic Success: CTE name shadows table name
+CREATE TABLE t_cte_shadow (id INTEGER, name TEXT);
+INSERT INTO t_cte_shadow VALUES (1, 'Table'), (2, 'Data');
+WITH t_cte_shadow AS (SELECT 10 AS id, 'CTE' AS name)
+SELECT * FROM t_cte_shadow ORDER BY id;
+→ [{"id":10,"name":"CTE"}]
+SELECT * FROM t_cte_shadow ORDER BY id;
+→ [{"id":1,"name":"Table"},{"id":2,"name":"Data"}]
+DROP TABLE t_cte_shadow;
+
+-- Semantic Error: Function not found
+SELECT non_existent_function(1);
+-- error: Function not found: non_existent_function/1
+
+-- Runtime Error: Division by zero (SQLite returns NULL)
+SELECT 1 / 0;
+→ [{"1 / 0":null}]
+
+-- Runtime Error: CAST behavior (SQLite tries to convert)
+SELECT cast(x'01' as INTEGER);
+→ [{"cast(x'01' as integer)":0}]
+
+-- Constraint Error: Primary Key Violation (when enforced)
+CREATE TABLE t_pk (id INTEGER PRIMARY KEY);
+INSERT INTO t_pk VALUES (1);
+INSERT INTO t_pk VALUES (1);
+-- error: UNIQUE constraint failed: t_pk PK.
+DROP TABLE t_pk;
+
+-- Subquery Error: Multiple rows returned where one expected
+CREATE TABLE t_sub (id INTEGER, val TEXT);
+INSERT INTO t_sub VALUES (1, 'a'), (2, 'b');
+SELECT (SELECT val FROM t_sub);
+-- error: subquery returned more than one row
+DROP TABLE t_sub;
+
+-- Type Error: Invalid type conversion in strict context
+SELECT CAST('not_a_number' AS INTEGER) WHERE 0;
+-- May succeed with value 0 depending on implementation
+
+-- Parse error with location info on multi-line statement
+SELECT
+  *
+  FROM
+  WHERE 1;
+-- error: Expected table name.
+
+-- NOT NULL constraint via UPDATE to NULL
+CREATE TABLE t_nn_upd (id INTEGER PRIMARY KEY, name TEXT);
+INSERT INTO t_nn_upd VALUES (1, 'hello');
+UPDATE t_nn_upd SET name = NULL WHERE id = 1;
+-- error: NOT NULL constraint failed: t_nn_upd.name
+DROP TABLE t_nn_upd;
+
+-- CHECK constraint violation
+CREATE TABLE t_chk (id INTEGER PRIMARY KEY, val INTEGER CHECK (val > 0));
+INSERT INTO t_chk VALUES (1, 10);
+INSERT INTO t_chk VALUES (2, -5);
+-- error: CHECK constraint failed
+DROP TABLE t_chk;
+
+-- Misuse Error: Trying to use closed DB (cannot test directly in sqllogic)
+
+-- Misuse Error: Using finalized statement (cannot test directly in sqllogic)

package/test/logic/90.1-parse-errors.sqllogic

@@ -0,0 +1,77 @@
+-- 90.1-parse-errors.sqllogic - Parser/syntax error edge cases
+-- Tests parse errors not already covered in 90-error_paths.sqllogic
+
+-- Unterminated parenthesis in function call
+SELECT abs(1
+-- error: Unterminated '('
+
+-- CTE: missing name
+WITH AS (SELECT 1) SELECT 1;
+-- error: Expected CTE name
+
+-- CTE: missing AS keyword
+WITH c SELECT * FROM c;
+-- error: Expected 'AS' after CTE name
+
+-- CTE: non-identifier in column list
+WITH c (1) AS (SELECT 1) SELECT * FROM c;
+-- error: Expected column name in CTE definition
+
+-- CTE: missing opening paren for query
+WITH c AS SELECT 1;
+-- error: Expected '(' before CTE query
+
+-- Unterminated string literal
+SELECT 'unterminated;
+-- error: Unterminated string
+
+-- Incomplete CREATE statement
+CREATE;
+-- error: Expected TABLE,
+
+-- Incomplete INSERT (missing table name)
+INSERT INTO;
+-- error: Expected table name
+
+-- Incomplete UPDATE (missing table name)
+UPDATE;
+-- error: Expected table name
+
+-- Incomplete DELETE (missing table)
+DELETE;
+-- error: Expected table name
+
+-- Missing column list or VALUES in CREATE TABLE
+CREATE TABLE t_parse_empty ();
+-- error: Expected column
+
+-- DROP with unsupported object type
+DROP TRIGGER some_trigger;
+-- error: Expected TABLE, VIEW, MATERIALIZED VIEW, INDEX, or ASSERTION after DROP
+
+-- Incomplete CASE expression
+SELECT CASE WHEN 1 THEN 2;
+-- error: Expected 'END'
+
+-- Missing expression after WHERE
+CREATE TABLE t_parse_where (id INTEGER);
+-- run
+
+SELECT * FROM t_parse_where WHERE;
+-- error: Expected expression
+
+DROP TABLE t_parse_where;
+-- run
+
+-- @-prefixed parameter form (not supported in Quereus; lexer rejects)
+SELECT 1 WHERE 1 = @x;
+-- error: Unexpected character
+
+-- ?-followed-by-digit (sqlite ?N form not supported; ? is consumed
+-- as positional placeholder, leaving the digit as a stray token)
+SELECT 1 WHERE 1 = ?1;
+-- error:
+
+-- Named parameter prefix with neither identifier nor integer
+SELECT :;
+-- error: Expected identifier or number after parameter prefix

package/test/logic/90.2-alter-table-errors.sqllogic

@@ -0,0 +1,53 @@
+-- 90.2-alter-table-errors.sqllogic - ALTER TABLE error paths
+-- Tests ALTER TABLE error conditions not already covered in 41-alter-table.sqllogic
+
+-- Setup
+CREATE TABLE t_alt_rename (a INTEGER, b INTEGER);
+-- run
+
+-- RENAME COLUMN: source column not found
+ALTER TABLE t_alt_rename RENAME COLUMN c TO d;
+-- error: Column 'c' not found in table 't_alt_rename'
+
+-- RENAME COLUMN: target column name already exists
+ALTER TABLE t_alt_rename RENAME COLUMN a TO b;
+-- error: Column 'b' already exists in table 't_alt_rename'
+
+DROP TABLE t_alt_rename;
+-- run
+
+-- DROP COLUMN: column not found
+CREATE TABLE t_alt_drop (a INTEGER, b INTEGER);
+-- run
+
+ALTER TABLE t_alt_drop DROP COLUMN c;
+-- error: Column 'c' not found
+
+-- DROP COLUMN: cannot drop primary key column
+DROP TABLE t_alt_drop;
+CREATE TABLE t_alt_pk (id INTEGER PRIMARY KEY, val INTEGER);
+-- run
+
+ALTER TABLE t_alt_pk DROP COLUMN id;
+-- error: Cannot drop PRIMARY KEY column
+
+-- DROP COLUMN: single column is implicitly PK in key-based system
+DROP TABLE t_alt_pk;
+CREATE TABLE t_alt_single (only_col INTEGER);
+-- run
+
+ALTER TABLE t_alt_single DROP COLUMN only_col;
+-- error: Cannot drop PRIMARY KEY column
+
+-- RENAME TABLE: target table already exists
+DROP TABLE t_alt_single;
+CREATE TABLE t_alt_src (a INTEGER);
+CREATE TABLE t_alt_dst (b INTEGER);
+-- run
+
+ALTER TABLE t_alt_src RENAME TO t_alt_dst;
+-- error: Table 't_alt_dst' already exists
+
+-- Cleanup
+DROP TABLE t_alt_src;
+DROP TABLE t_alt_dst;

package/test/logic/90.2.1-alter-extra-errors.sqllogic

@@ -0,0 +1,51 @@
+-- adapted from SQLite test/alter*.test
+-- Additional ALTER TABLE error paths beyond 90.2-alter-table-errors.
+
+-- ===================================
+-- 1. ALTER on non-existent table
+-- ===================================
+
+alter table no_such_table rename to other;
+-- error: not found
+
+alter table no_such_table add column x integer null;
+-- error: not found
+
+alter table no_such_table drop column x;
+-- error: not found
+
+-- ===================================
+-- 2. ALTER TABLE with non-constant DEFAULT in ADD COLUMN
+-- ===================================
+-- Quereus rejects non-deterministic / parameterized defaults at DDL time
+-- per the determinism rule. Constant numeric and string defaults work.
+
+create table t_alt_nc (id integer primary key, a integer not null);
+insert into t_alt_nc values (1, 1);
+
+-- bind parameter in DEFAULT rejected
+alter table t_alt_nc add column p text default (:foo);
+-- error:
+
+-- column reference in DEFAULT rejected
+alter table t_alt_nc add column q integer default (a + 1);
+-- error:
+
+drop table t_alt_nc;
+
+-- ===================================
+-- 3. ADD COLUMN whose backfill default would violate a CHECK
+-- ===================================
+
+create table t_bf (id integer primary key, a integer not null);
+insert into t_bf values (1, 5), (2, 0);
+
+-- default 0 backfilled into 'd', but CHECK requires d <> 0 → ALTER fails
+alter table t_bf add column d integer not null default 0 check (d <> 0);
+-- error:
+
+-- table unchanged
+select * from t_bf order by id;
+→ [{"id":1,"a":5},{"id":2,"a":0}]
+
+drop table t_bf;