@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/08-views.sqllogic

@@ -0,0 +1,64 @@
+-- views.sqllogic - Testing VIEW functionality
+
+-- -- Setup base table
+CREATE TABLE base_data (id INTEGER PRIMARY KEY, name TEXT, category TEXT, value INTEGER);
+INSERT INTO base_data VALUES (1, 'Alpha', 'A', 100), (2, 'Beta', 'B', 200), (3, 'Gamma', 'A', 150), (4, 'Delta', 'B', 300);
+
+-- Basic view creation
+CREATE VIEW category_a_view AS SELECT id, name, value FROM base_data WHERE category = 'A';
+
+-- Query the view
+SELECT * FROM category_a_view ORDER BY id;
+→ [{"id":1,"name":"Alpha","value":100},{"id":3,"name":"Gamma","value":150}]
+
+-- View with computed columns
+CREATE VIEW summary_view AS SELECT category, count(*) as item_count, sum(value) as total_value FROM base_data GROUP BY category;
+
+SELECT * FROM summary_view ORDER BY category;
+→ [{"category":"A","item_count":2,"total_value":250},{"category":"B","item_count":2,"total_value":500}]
+
+-- View with complex WHERE clause
+CREATE VIEW high_value_view AS SELECT name, value FROM base_data WHERE value > 150;
+
+SELECT * FROM high_value_view ORDER BY value;
+→ [{"name":"Beta","value":200},{"name":"Delta","value":300}]
+
+-- Verify view reflects changes to underlying table
+INSERT INTO base_data VALUES (5, 'Zeta', 'A', 125);
+SELECT * FROM category_a_view ORDER BY id;
+→ [{"id":1,"name":"Alpha","value":100},{"id":3,"name":"Gamma","value":150},{"id":5,"name":"Zeta","value":125}]
+
+-- Test view with alias and qualified SELECT *
+SELECT v.* FROM category_a_view v ORDER BY id;
+→ [{"id":1,"name":"Alpha","value":100},{"id":3,"name":"Gamma","value":150},{"id":5,"name":"Zeta","value":125}]
+
+-- Filter merge: view WHERE + outer WHERE should produce correct results
+CREATE VIEW filtered_items AS SELECT id, name, value FROM base_data WHERE category = 'A';
+SELECT * FROM filtered_items WHERE value > 100 ORDER BY id;
+→ [{"id":3,"name":"Gamma","value":150},{"id":5,"name":"Zeta","value":125}]
+DROP VIEW filtered_items;
+
+-- Predicate pushdown through view alias boundary
+-- id = 1 should push through AliasNode into the view's underlying plan (index seek, no residual FILTER)
+SELECT * FROM category_a_view WHERE id = 1;
+→ [{"id":1,"name":"Alpha","value":100}]
+
+-- Qualified column references should also work after pushdown
+SELECT v.name FROM category_a_view v WHERE v.id = 3;
+→ [{"name":"Gamma"}]
+
+-- Projection pruning: selecting a subset of a wide view should return correct results
+CREATE VIEW wide_view AS SELECT id, name, category, value FROM base_data;
+SELECT name FROM wide_view ORDER BY name;
+→ [{"name":"Alpha"},{"name":"Beta"},{"name":"Delta"},{"name":"Gamma"},{"name":"Zeta"}]
+
+SELECT name, value FROM wide_view WHERE id = 2;
+→ [{"name":"Beta","value":200}]
+DROP VIEW wide_view;
+
+-- Drop views
+DROP VIEW category_a_view;
+DROP VIEW summary_view;
+DROP VIEW high_value_view;
+
+DROP TABLE base_data;

package/test/logic/08.1-semi-anti-join.sqllogic

@@ -0,0 +1,191 @@
+-- semi-anti-join.sqllogic - Semi/anti join decorrelation tests
+
+-- Setup tables
+CREATE TABLE departments (id INTEGER PRIMARY KEY, name TEXT);
+CREATE TABLE employees (id INTEGER PRIMARY KEY, name TEXT, dept_id INTEGER NULL, salary INTEGER);
+CREATE TABLE projects (id INTEGER PRIMARY KEY, title TEXT, lead_id INTEGER NULL);
+
+INSERT INTO departments VALUES (1, 'Engineering'), (2, 'Sales'), (3, 'Marketing'), (4, 'HR');
+INSERT INTO employees VALUES (10, 'Alice', 1, 100), (20, 'Bob', 1, 120), (30, 'Carol', 2, 90), (40, 'Dave', 3, 110), (50, 'Eve', null, 80);
+INSERT INTO projects VALUES (100, 'Alpha', 10), (200, 'Beta', 30), (300, 'Gamma', null);
+
+-- ===== Correlated EXISTS → Semi Join =====
+
+-- Basic correlated EXISTS
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id) ORDER BY d.name;
+→ [{"name":"Engineering"},{"name":"Marketing"},{"name":"Sales"}]
+
+-- EXISTS with inner-only filter (residual preserved)
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id AND e.salary > 100) ORDER BY d.name;
+→ [{"name":"Engineering"},{"name":"Marketing"}]
+
+-- EXISTS returning no matches
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id AND e.salary > 1000) ORDER BY d.name;
+→ []
+
+-- ===== NOT EXISTS → Anti Join =====
+
+-- Basic NOT EXISTS
+SELECT d.name FROM departments d WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id) ORDER BY d.name;
+→ [{"name":"HR"}]
+
+-- NOT EXISTS with inner filter
+SELECT d.name FROM departments d WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id AND e.salary > 100) ORDER BY d.name;
+→ [{"name":"HR"},{"name":"Sales"}]
+
+-- NOT EXISTS where all rows match (empty result for anti)
+SELECT d.name FROM departments d WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id AND e.salary > 0) ORDER BY d.name;
+→ [{"name":"HR"}]
+
+-- ===== IN (correlated subquery) → Semi Join =====
+
+-- Basic correlated IN subquery
+SELECT e.name FROM employees e WHERE e.dept_id IN (SELECT d.id FROM departments d WHERE d.id = e.dept_id) ORDER BY e.name;
+→ [{"name":"Alice"},{"name":"Bob"},{"name":"Carol"},{"name":"Dave"}]
+
+-- IN with additional inner filter
+SELECT e.name FROM employees e WHERE e.dept_id IN (SELECT d.id FROM departments d WHERE d.id = e.dept_id AND d.name = 'Engineering') ORDER BY e.name;
+→ [{"name":"Alice"},{"name":"Bob"}]
+
+-- ===== Multi-column correlation predicates =====
+
+-- Multiple equi-join columns (not yet decorrelated if inner filter isn't simple equi)
+-- Using a self-join pattern
+CREATE TABLE t1 (a INTEGER, b INTEGER, PRIMARY KEY(a, b));
+CREATE TABLE t2 (x INTEGER, y INTEGER, PRIMARY KEY(x, y));
+INSERT INTO t1 VALUES (1, 10), (2, 20), (3, 30);
+INSERT INTO t2 VALUES (1, 10), (2, 99), (3, 30);
+
+SELECT a, b FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE t2.x = t1.a AND t2.y = t1.b) ORDER BY a;
+→ [{"a":1,"b":10},{"a":3,"b":30}]
+
+SELECT a, b FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE t2.x = t1.a AND t2.y = t1.b) ORDER BY a;
+→ [{"a":2,"b":20}]
+
+DROP TABLE t1;
+DROP TABLE t2;
+
+-- ===== NULL handling edge cases =====
+
+-- EXISTS with NULLs in correlation column (NULLs don't match)
+SELECT e.name FROM employees e WHERE EXISTS (SELECT 1 FROM departments d WHERE d.id = e.dept_id) ORDER BY e.name;
+→ [{"name":"Alice"},{"name":"Bob"},{"name":"Carol"},{"name":"Dave"}]
+
+-- Eve has NULL dept_id, so she should not appear
+SELECT e.name FROM employees e WHERE NOT EXISTS (SELECT 1 FROM departments d WHERE d.id = e.dept_id) ORDER BY e.name;
+→ [{"name":"Eve"}]
+
+-- Projects with NULL lead_id
+SELECT p.title FROM projects p WHERE EXISTS (SELECT 1 FROM employees e WHERE e.id = p.lead_id) ORDER BY p.title;
+→ [{"title":"Alpha"},{"title":"Beta"}]
+
+SELECT p.title FROM projects p WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.id = p.lead_id) ORDER BY p.title;
+→ [{"title":"Gamma"}]
+
+-- ===== Mixed predicates: EXISTS AND other_condition =====
+
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id) AND d.id > 1 ORDER BY d.name;
+→ [{"name":"Marketing"},{"name":"Sales"}]
+
+SELECT d.name FROM departments d WHERE d.id < 4 AND EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id AND e.salary >= 100) ORDER BY d.name;
+→ [{"name":"Engineering"},{"name":"Marketing"}]
+
+-- NOT EXISTS AND other_condition
+SELECT d.name FROM departments d WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id) AND d.name != 'HR';
+→ []
+
+-- ===== Uncorrelated subqueries NOT decorrelated =====
+
+-- Uncorrelated EXISTS should remain as-is (not transformed to a join)
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.salary > 1000) ORDER BY d.name;
+→ []
+
+SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.salary > 50) ORDER BY d.name;
+→ [{"name":"Engineering"},{"name":"HR"},{"name":"Marketing"},{"name":"Sales"}]
+
+-- Uncorrelated IN subquery should not be decorrelated
+SELECT d.name FROM departments d WHERE d.id IN (SELECT dept_id FROM employees WHERE salary > 100) ORDER BY d.name;
+→ [{"name":"Engineering"},{"name":"Marketing"}]
+
+-- ===== Scalar subqueries NOT affected =====
+
+-- Scalar subquery in WHERE (not EXISTS/IN pattern)
+SELECT d.name FROM departments d WHERE d.id = (SELECT min(dept_id) FROM employees WHERE dept_id IS NOT NULL);
+→ [{"name":"Engineering"}]
+
+-- ===== query_plan() introspection: verify semi/anti join appears =====
+
+-- Verify correlated EXISTS produces a semi join. The physical node is
+-- backend-dependent: under the memory vtab rule-key-set-seek rewrites the hash
+-- semi join into a KeySetSemiJoin (the module accepts a runtime key-set
+-- multi-seek on the primary key), while the store module declines the
+-- runtime-set probe on its PK arm and keeps the HashJoin. Either way the
+-- joinType stays 'semi', which is what this pins.
+SELECT json_extract(properties, '$.joinType') as jt FROM query_plan('SELECT d.name FROM departments d WHERE EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id)') WHERE node_type IN ('Join', 'HashJoin', 'KeySetSemiJoin') ORDER BY id;
+→ [{"jt":"semi"}]
+
+-- Verify NOT EXISTS produces an anti join
+SELECT node_type, json_extract(properties, '$.joinType') as jt FROM query_plan('SELECT d.name FROM departments d WHERE NOT EXISTS (SELECT 1 FROM employees e WHERE e.dept_id = d.id)') WHERE node_type IN ('Join', 'HashJoin') ORDER BY id;
+→ [{"node_type":"HashJoin","jt":"anti"}]
+
+DROP TABLE projects;
+DROP TABLE employees;
+DROP TABLE departments;
+
+-- ===== Type-coerced correlation: must NOT be decorrelated =====
+
+-- Correlation `outer.real = inner.text` is rewritten as `outer.real = cast(inner.text as real)`.
+-- The cast hides the equi-pattern; the rule must abort decorrelation rather than
+-- leave the correlation conjunct as a residual filter on the inner side
+-- (which would fail at runtime with "no row context for outer column").
+create table tt1 (c_text0 text unique, c_text1 text not null unique);
+create table tt2 (c_int0 integer unique, c_real1 real, c_text2 text not null primary key);
+insert into tt1 values ('a','x'),('b','y');
+insert into tt2 values (1, 1.5, 'p'),(2, 2.5, 'q');
+
+select count(*) as n from tt2 left join tt1 on c_real1 in (select c_text1 from tt1 where tt2.c_real1 = tt1.c_text1) where c_real1 in (select c_text1 from tt1 where tt2.c_real1 = tt1.c_text1) limit 50;
+→ [{"n":0}]
+
+drop table tt1;
+drop table tt2;
+
+-- ===== FK-backed folds through a derived parent table =====
+
+-- rule-anti-join-fk-empty and rule-semi-join-fk-trivial peel a projection off
+-- the parent side and translate the equi columns back to the parent's own
+-- column indices. These pin the ANSWERS; the plan shapes are pinned in
+-- test/plan/subquery-decorrelation.spec.ts.
+
+create table fkp (id integer primary key, other integer);
+create table fkc (id integer primary key, p_id integer not null references fkp(id));
+insert into fkp values (1, 99), (2, 98);
+insert into fkc values (10, 1), (20, 2);
+
+-- Every child row has a parent, so NOT EXISTS is empty — the fold must agree.
+select id from fkc where not exists (select 1 from (select other, id from fkp) d where d.id = fkc.p_id) order by id;
+→ []
+
+-- The same shape equating a NON-referenced parent column. `other` sits at the
+-- derived table's output index 0 — the index the FK references — so an
+-- untranslated comparison would fold to empty and drop every row.
+select id from fkc where not exists (select 1 from (select other, id from fkp) d where d.other = fkc.p_id) order by id;
+→ [{"id":10},{"id":20}]
+
+-- Composite FK: both equi columns translate, and the FK's declared (fa→a,
+-- fb→b) pairing must survive the reordering derived table.
+create table fkp2 (a integer, b integer, extra text, primary key (a, b));
+create table fkc2 (id integer primary key, fa integer not null, fb integer not null, foreign key (fa, fb) references fkp2(a, b));
+insert into fkp2 values (1, 2, 'x'), (3, 4, 'y');
+insert into fkc2 values (10, 1, 2), (20, 3, 4);
+
+select id from fkc2 where exists (select 1 from (select b, a, extra from fkp2) q where q.a = fkc2.fa and q.b = fkc2.fb) order by id;
+→ [{"id":10},{"id":20}]
+
+-- Permuted against the FK's pairing: a different, uncovered inclusion.
+select id from fkc2 where exists (select 1 from (select b, a, extra from fkp2) q where q.a = fkc2.fb and q.b = fkc2.fa) order by id;
+→ []
+
+drop table fkc2;
+drop table fkp2;
+drop table fkc;
+drop table fkp;

package/test/logic/08.1-view-edge-cases.sqllogic

@@ -0,0 +1,118 @@
+-- adapted from SQLite test/view.test
+-- View-feature scenarios beyond basic 08-views.sqllogic.
+
+-- ===================================
+-- 1. Multi-level views (view referencing another view)
+-- ===================================
+
+create table base_v (id integer primary key, cat text, val integer);
+insert into base_v values (1, 'a', 10), (2, 'b', 20), (3, 'a', 30), (4, 'b', 40);
+
+-- v1 filters; v2 aggregates over v1
+create view v1 as select id, cat, val from base_v where val > 15;
+create view v2 as select cat, count(*) as n, sum(val) as s from v1 group by cat;
+
+select * from v2 order by cat;
+→ [{"cat":"a","n":1,"s":30},{"cat":"b","n":2,"s":60}]
+
+-- three-level chain
+create view v3 as select cat from v2 where n > 1;
+
+select * from v3;
+→ [{"cat":"b"}]
+
+drop view v3;
+drop view v2;
+drop view v1;
+drop table base_v;
+
+-- ===================================
+-- 2. View with explicit column-list rename
+-- ===================================
+
+create table cr_base (id integer primary key, name text, val integer);
+insert into cr_base values (1, 'x', 5), (2, 'y', 7);
+
+create view cr_v (k, label, amount) as select id, name, val from cr_base;
+
+select k, label, amount from cr_v order by k;
+→ [{"k":1,"label":"x","amount":5},{"k":2,"label":"y","amount":7}]
+
+drop view cr_v;
+
+create view cr_bad (a, b) as select id, name, val from cr_base;
+-- error: declared columns
+drop view if exists cr_bad;
+
+drop table cr_base;
+
+-- ===================================
+-- 3. View lifecycle
+-- ===================================
+
+create table tv_base (id integer primary key, val integer);
+insert into tv_base values (1, 10), (2, 20);
+
+create view tv_t as select id, val from tv_base where val > 10;
+
+select * from tv_t;
+→ [{"id":2,"val":20}]
+
+drop view tv_t;
+drop table tv_base;
+
+-- ===================================
+-- 4. View over UNION ALL / compound select
+-- ===================================
+
+create table cs_a (id integer primary key, label text);
+create table cs_b (id integer primary key, label text);
+insert into cs_a values (1, 'a1'), (2, 'a2');
+insert into cs_b values (3, 'b1'), (4, 'b2');
+
+create view cs_v as
+	select id, label from cs_a
+	union all
+	select id, label from cs_b;
+
+select * from cs_v order by id;
+→ [{"id":1,"label":"a1"},{"id":2,"label":"a2"},{"id":3,"label":"b1"},{"id":4,"label":"b2"}]
+
+drop view cs_v;
+drop table cs_a;
+drop table cs_b;
+
+-- ===================================
+-- 5. Schema-qualified view (main / temp)
+-- ===================================
+
+create table sq_base (id integer primary key, val integer);
+insert into sq_base values (1, 10), (2, 20);
+
+create view main.sq_v as select id, val from sq_base where val > 10;
+
+select * from main.sq_v;
+→ [{"id":2,"val":20}]
+
+create view temp.sq_tv as select id from sq_base;
+
+drop view temp.sq_tv;
+drop view main.sq_v;
+drop table sq_base;
+
+-- ===================================
+-- 6. View aliases / self-join in view body
+-- ===================================
+
+create table tsj (id integer primary key, parent_id integer null);
+insert into tsj values (1, null), (2, 1), (3, 1);
+
+create view v_sj as
+	select c.id as child, p.id as parent
+	from tsj c left join tsj p on c.parent_id = p.id;
+
+select * from v_sj order by child;
+→ [{"child":1,"parent":null},{"child":2,"parent":1},{"child":3,"parent":1}]
+
+drop view v_sj;
+drop table tsj;

package/test/logic/08.1.1-uncorrelated-in-semijoin.sqllogic

@@ -0,0 +1,251 @@
+-- 08.1.1-uncorrelated-in-semijoin.sqllogic — uncorrelated filter-position
+-- `col IN (subquery)` rewritten to a semi join (rule-subquery-decorrelation,
+-- uncorrelated arm).
+--
+-- All columns here are deliberately NON-indexed, so these cases ride the plain
+-- hash semi join (the sibling 08.4-key-set-semi-join.sqllogic covers the
+-- secondary-indexed KeySetSemiJoin path, including TIMESPAN semantic equality
+-- and NOCASE-indexed targets). Every answer must be identical to what the
+-- runtime set-probe path returns — the rewrite is sound under WHERE only
+-- because a filter collapses IN's NULL result to "drop the row", which is
+-- exactly what a semi join does.
+
+-- Setup: nullable non-indexed columns on both sides.
+CREATE TABLE souter (id INTEGER PRIMARY KEY, x INTEGER NULL, s TEXT NULL);
+CREATE TABLE sinner (id INTEGER PRIMARY KEY, v INTEGER NULL);
+
+INSERT INTO souter VALUES (1, 10, 'p'), (2, 20, 'q'), (3, 30, 'r'), (4, NULL, 's');
+-- 10 appears twice (fan-out check) and one member is NULL.
+INSERT INTO sinner VALUES (1, 10), (2, 10), (3, 99), (4, NULL);
+
+-- ===== NULL and emptiness =====
+
+-- Match against a non-NULL member is kept; NULL outer x (id 4) is dropped;
+-- no-match rows (ids 2, 3) are dropped even though the inner contains a NULL
+-- (IN yields NULL there — WHERE drops it, same as the semi join).
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner) ORDER BY id;
+→ [{"id":1}]
+
+-- Duplicate inner members must not fan the outer out: exactly one row.
+SELECT count(*) AS c FROM souter WHERE x IN (SELECT v FROM sinner);
+→ [{"c":1}]
+
+-- Empty inner ⇒ no rows survive.
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner WHERE v > 1000);
+→ []
+
+-- All-NULL inner ⇒ no rows survive.
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner WHERE v IS NULL);
+→ []
+
+-- ===== Inner shapes used verbatim as the join's right side =====
+
+-- Inner WHERE.
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner WHERE v < 50) ORDER BY id;
+→ [{"id":1}]
+
+-- Inner DISTINCT.
+SELECT id FROM souter WHERE x IN (SELECT DISTINCT v FROM sinner) ORDER BY id;
+→ [{"id":1}]
+
+-- Inner ORDER BY + LIMIT (deterministic subset: the two smallest non-NULL v).
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner WHERE v IS NOT NULL ORDER BY v LIMIT 2) ORDER BY id;
+→ [{"id":1}]
+
+-- VALUES list as the subquery.
+SELECT id FROM souter WHERE x IN (VALUES (10), (20)) ORDER BY id;
+→ [{"id":1},{"id":2}]
+
+-- Set operations.
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner UNION SELECT 20) ORDER BY id;
+→ [{"id":1},{"id":2}]
+
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner UNION ALL SELECT 30) ORDER BY id;
+→ [{"id":1},{"id":3}]
+
+-- CTE reference as the subquery body.
+WITH w AS (SELECT v FROM sinner) SELECT id FROM souter WHERE x IN (SELECT v FROM w) ORDER BY id;
+→ [{"id":1}]
+
+-- Computed single output column (the shape the correlated arm cannot take).
+SELECT id FROM souter WHERE x IN (SELECT v + 10 FROM sinner) ORDER BY id;
+→ [{"id":2}]
+
+-- ===== Multiple conjuncts =====
+
+-- Two uncorrelated IN conjuncts in one WHERE (two stacked semi joins).
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner) AND s IN (SELECT 'p') ORDER BY id;
+→ [{"id":1}]
+
+-- Mixed correlated + uncorrelated IN conjuncts.
+SELECT o.id FROM souter o WHERE o.x IN (SELECT v FROM sinner) AND o.x IN (SELECT i2.v FROM sinner i2 WHERE i2.v = o.x) ORDER BY o.id;
+→ [{"id":1}]
+
+-- IN conjunct next to an ordinary predicate (residual re-wrapped above the join).
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner) AND id < 10 ORDER BY id;
+→ [{"id":1}]
+
+-- ===== Shapes that must NOT rewrite (three-valued answers preserved) =====
+
+-- NOT IN with a NULL in the inner: NULL result for every non-member ⇒ no rows.
+SELECT id FROM souter WHERE x NOT IN (SELECT v FROM sinner) ORDER BY id;
+→ []
+
+-- IN under OR is not a top-level conjunct.
+SELECT id FROM souter WHERE x IN (SELECT v FROM sinner) OR id = 4 ORDER BY id;
+→ [{"id":1},{"id":4}]
+
+-- IS NULL over the IN result observes the three-valued answer:
+-- id 2, 3 (no match, inner has NULL) and id 4 (NULL x) yield NULL.
+SELECT id FROM souter WHERE (x IN (SELECT v FROM sinner)) IS NULL ORDER BY id;
+→ [{"id":2},{"id":3},{"id":4}]
+
+-- Projection position keeps the full three-valued result per row.
+SELECT id, x IN (SELECT v FROM sinner) AS m FROM souter ORDER BY id;
+→ [{"id":1,"m":true},{"id":2,"m":null},{"id":3,"m":null},{"id":4,"m":null}]
+
+-- Expression (non-column) left side stays on the set-probe path; same rows.
+SELECT id FROM souter WHERE x + 0 IN (SELECT v FROM sinner) ORDER BY id;
+→ [{"id":1}]
+
+-- ===== Types and collation =====
+
+-- NOCASE outer column against a default-BINARY inner: resolves NOCASE.
+CREATE TABLE nco (id INTEGER PRIMARY KEY, t TEXT COLLATE NOCASE);
+CREATE TABLE ncb (id INTEGER PRIMARY KEY, t TEXT);
+INSERT INTO nco VALUES (1, 'Apple'), (2, 'BANANA');
+INSERT INTO ncb VALUES (1, 'apple'), (2, 'cherry');
+
+SELECT id FROM nco WHERE t IN (SELECT t FROM ncb) ORDER BY id;
+→ [{"id":1}]
+
+-- And the reverse: default-BINARY outer against a NOCASE inner column.
+SELECT id FROM ncb WHERE t IN (SELECT t FROM nco) ORDER BY id;
+→ [{"id":1}]
+
+-- INTEGER outer against REAL inner: numeric equality, 10 matches 10.0.
+CREATE TABLE reals (id INTEGER PRIMARY KEY, r REAL);
+INSERT INTO reals VALUES (1, 10.0), (2, 20.5);
+SELECT id FROM souter WHERE x IN (SELECT r FROM reals) ORDER BY id;
+→ [{"id":1}]
+
+-- TEXT inner against INTEGER outer matches on the numeric reading, exactly as
+-- `x = '10'` does. The synthesized `=` is reconciled through the same coercion
+-- a hand-written one gets, so the cast wrapper fails the equi-pair gate and the
+-- conjunct declines to the set probe, whose own numeric ↔ textual arm answers.
+-- Pinned so the rewrite and the set probe cannot silently split.
+CREATE TABLE texts (id INTEGER PRIMARY KEY, t TEXT);
+INSERT INTO texts VALUES (1, '10'), (2, '20');
+SELECT id FROM souter WHERE x IN (SELECT t FROM texts) ORDER BY id;
+→ [{"id":1},{"id":2}]
+
+-- Mixed semantic-ordering pair (TIMESPAN outer, TEXT inner): the equi-pair
+-- gate declines, the set probe answers, and its semantic key transform still
+-- matches 'PT1H' against 'PT60M'. (Same-type TIMESPAN pairs go through the
+-- semi join and are pinned in 08.4-key-set-semi-join.sqllogic.)
+CREATE TABLE spans (id INTEGER PRIMARY KEY, d TIMESPAN);
+CREATE TABLE spantext (id INTEGER PRIMARY KEY, t TEXT);
+INSERT INTO spans VALUES (1, timespan('PT1H')), (2, timespan('P1D'));
+INSERT INTO spantext VALUES (1, 'PT60M');
+SELECT id FROM spans WHERE d IN (SELECT t FROM spantext) ORDER BY id;
+→ [{"id":1}]
+
+-- ===== FK-backed IN =====
+
+-- A declared NOT NULL FK covering the join key: rule-semi-join-fk-trivial drops
+-- the semi join (the plan shape is pinned in test/plan/subquery-decorrelation),
+-- so every child row survives without the parent ever being read.
+CREATE TABLE fkdept (id INTEGER PRIMARY KEY, dname TEXT);
+CREATE TABLE fkemp (id INTEGER PRIMARY KEY, dept_id INTEGER NOT NULL REFERENCES fkdept(id));
+INSERT INTO fkdept VALUES (1, 'eng'), (2, 'sales');
+INSERT INTO fkemp VALUES (10, 1), (20, 2);
+SELECT id FROM fkemp WHERE dept_id IN (SELECT id FROM fkdept) ORDER BY id;
+→ [{"id":10},{"id":20}]
+
+-- A nullable FK column folds to `WHERE fk IS NOT NULL` instead: a NULL never
+-- matches under `=`, so the NULL row must not survive.
+CREATE TABLE fkemp_opt (id INTEGER PRIMARY KEY, dept_id INTEGER NULL REFERENCES fkdept(id));
+INSERT INTO fkemp_opt VALUES (10, 1), (20, NULL), (30, 2);
+SELECT id FROM fkemp_opt WHERE dept_id IN (SELECT id FROM fkdept) ORDER BY id;
+→ [{"id":10},{"id":30}]
+
+-- A projection that reorders the parent's columns still folds — the equi
+-- column is translated back to the parent's own column index first.
+SELECT id FROM fkemp WHERE dept_id IN (SELECT id FROM (SELECT dname, id FROM fkdept)) ORDER BY id;
+→ [{"id":10},{"id":20}]
+
+-- ...but a filtered parent must NOT fold: the FK guarantees the parent row
+-- exists, not that it survives the subquery's WHERE.
+SELECT id FROM fkemp WHERE dept_id IN (SELECT id FROM fkdept WHERE dname = 'eng') ORDER BY id;
+→ [{"id":10}]
+
+-- Nor may an equality against a NON-referenced parent column fold. dname is the
+-- subquery's output column 0 — the same index as the referenced column
+-- fkdept.id — so an untranslated index comparison would spuriously align.
+SELECT id FROM fkemp WHERE dept_id IN (SELECT dname FROM fkdept) ORDER BY id;
+→ []
+
+-- Same hazard on the child side: the IN is on fkemp.id, which a reordering
+-- derived table puts at the index the FK column occupies in fkemp.
+SELECT e.id FROM (SELECT dept_id, id FROM fkemp) e WHERE e.id IN (SELECT id FROM fkdept) ORDER BY e.id;
+→ []
+
+-- ===== The one other place an IN decides row fate: CHECK =====
+
+-- A CHECK constraint's IN is a scalar expression on a constraint node, not a
+-- Filter predicate, so the rewrite can never reach it — and must not, because
+-- a CHECK passes on IN's three-valued "unknown". A NULL value is accepted; a
+-- non-member is rejected.
+CREATE TABLE chk_allowed (id INTEGER PRIMARY KEY, code INTEGER);
+INSERT INTO chk_allowed VALUES (1, 1), (2, 2);
+CREATE TABLE chk_t (id INTEGER PRIMARY KEY, code INTEGER NULL, CHECK (code IN (SELECT code FROM chk_allowed)));
+
+INSERT INTO chk_t VALUES (1, NULL), (2, 2);
+SELECT id, code FROM chk_t ORDER BY id;
+→ [{"id":1,"code":null},{"id":2,"code":2}]
+
+INSERT INTO chk_t VALUES (3, 9);
+-- error: CHECK constraint failed
+
+-- ===== DML with the semi join as the mutation source =====
+
+CREATE TABLE dml_t (id INTEGER PRIMARY KEY, x INTEGER NULL, mark INTEGER);
+CREATE TABLE dml_keys (id INTEGER PRIMARY KEY, k INTEGER NULL);
+INSERT INTO dml_t VALUES (1, 10, 0), (2, 20, 0), (3, 30, 0), (4, NULL, 0);
+INSERT INTO dml_keys VALUES (1, 10), (2, 30), (3, NULL);
+
+UPDATE dml_t SET mark = 1 WHERE x IN (SELECT k FROM dml_keys);
+SELECT id, mark FROM dml_t ORDER BY id;
+→ [{"id":1,"mark":1},{"id":2,"mark":0},{"id":3,"mark":1},{"id":4,"mark":0}]
+
+DELETE FROM dml_t WHERE x IN (SELECT k FROM dml_keys);
+SELECT id FROM dml_t ORDER BY id;
+→ [{"id":2},{"id":4}]
+
+-- Self-referencing DELETE on a non-indexed column: the hash build drains the
+-- inner fully before any probe, so membership is decided by the
+-- pre-statement snapshot (same semantics the set probe pinned in
+-- 07.7-in-subquery-caching.sqllogic).
+CREATE TABLE selfd (id INTEGER PRIMARY KEY, x INTEGER NULL, keep INTEGER);
+INSERT INTO selfd VALUES (1, 100, 1), (2, 200, 0), (3, 300, 1), (4, 400, 0);
+DELETE FROM selfd WHERE x IN (SELECT x FROM selfd WHERE keep = 0);
+SELECT id FROM selfd ORDER BY id;
+→ [{"id":1},{"id":3}]
+
+-- Cleanup
+DROP TABLE chk_t;
+DROP TABLE chk_allowed;
+DROP TABLE selfd;
+DROP TABLE dml_keys;
+DROP TABLE dml_t;
+DROP TABLE fkemp_opt;
+DROP TABLE fkemp;
+DROP TABLE fkdept;
+DROP TABLE spantext;
+DROP TABLE spans;
+DROP TABLE texts;
+DROP TABLE reals;
+DROP TABLE ncb;
+DROP TABLE nco;
+DROP TABLE sinner;
+DROP TABLE souter;