@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/10.5-indexes.sqllogic

@@ -0,0 +1,164 @@
+-- indexes.sqllogic - Testing index creation and usage
+--
+-- requires-capability: standalone-index-ddl
+
+-- Setup base table for index testing
+CREATE TABLE idx_test (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    age INTEGER,
+    city TEXT,
+    score REAL,
+    active INTEGER
+);
+
+INSERT INTO idx_test VALUES
+    (1, 'Alice', 30, 'New York', 95.5, 1),
+    (2, 'Bob', 25, 'London', 87.2, 1),
+    (3, 'Charlie', 35, 'New York', 92.1, 0),
+    (4, 'David', 30, 'Paris', 89.8, 1),
+    (5, 'Eve', 28, 'London', 96.3, 1);
+
+-- Basic CREATE INDEX
+CREATE INDEX idx_name ON idx_test (name);
+
+-- Verify table still works after index creation
+SELECT name FROM idx_test WHERE name = 'Alice';
+→ [{"name":"Alice"}]
+
+-- CREATE INDEX with IF NOT EXISTS
+CREATE INDEX IF NOT EXISTS idx_age ON idx_test (age);
+
+-- Try to create same index again (should succeed with IF NOT EXISTS)
+CREATE INDEX IF NOT EXISTS idx_age ON idx_test (age);
+
+-- Multi-column index
+CREATE INDEX idx_city_age ON idx_test (city, age);
+
+-- Index with DESC ordering
+CREATE INDEX idx_score_desc ON idx_test (score DESC);
+
+-- Index on different data types
+CREATE INDEX idx_active ON idx_test (active);
+
+-- Verify queries still work with indexes
+SELECT id, name FROM idx_test WHERE age = 30 ORDER BY name;
+→ [{"id":1,"name":"Alice"},{"id":4,"name":"David"}]
+
+SELECT name FROM idx_test WHERE city = 'London' ORDER BY age;
+→ [{"name":"Bob"},{"name":"Eve"}]
+
+SELECT name, score FROM idx_test WHERE score > 90 ORDER BY score DESC;
+→ [{"name":"Eve","score":96.3},{"name":"Alice","score":95.5},{"name":"Charlie","score":92.1}]
+
+-- Test UNIQUE index
+CREATE TABLE unique_test (id INTEGER PRIMARY KEY, email TEXT);
+INSERT INTO unique_test VALUES (1, 'alice@example.com'), (2, 'bob@example.com');
+
+CREATE UNIQUE INDEX idx_email_unique ON unique_test (email);
+
+-- Query with unique index
+SELECT id FROM unique_test WHERE email = 'alice@example.com';
+→ [{"id":1}]
+
+-- Test index on NULL values
+CREATE TABLE null_test (id INTEGER PRIMARY KEY, optional_field TEXT NULL);
+INSERT INTO null_test VALUES (1, 'value1'), (2, NULL), (3, 'value3'), (4, NULL);
+
+CREATE INDEX idx_optional ON null_test (optional_field);
+
+-- Query with NULL values
+SELECT id FROM null_test WHERE optional_field IS NULL ORDER BY id;
+→ [{"id":2},{"id":4}]
+
+SELECT id FROM null_test WHERE optional_field = 'value1';
+→ [{"id":1}]
+
+-- Test complex WHERE clauses with indexed columns
+SELECT name, age FROM idx_test WHERE city = 'New York' AND age > 30 ORDER BY name;
+→ [{"name":"Charlie","age":35}]
+
+-- Test JOIN with indexed columns
+CREATE TABLE departments (id INTEGER PRIMARY KEY, name TEXT, city TEXT);
+INSERT INTO departments VALUES (1, 'Engineering', 'New York'), (2, 'Sales', 'London'), (3, 'Marketing', 'Paris');
+
+CREATE INDEX idx_dept_city ON departments (city);
+
+SELECT i.name, d.name as dept FROM idx_test i
+JOIN departments d ON i.city = d.city
+WHERE i.active = 1
+ORDER BY i.name;
+→ [{"name":"Alice","dept":"Engineering"},{"name":"Bob","dept":"Sales"},{"name":"David","dept":"Marketing"},{"name":"Eve","dept":"Sales"}]
+
+-- Test ORDER BY with indexed columns (should be optimized)
+SELECT name FROM idx_test ORDER BY name;
+→ [{"name":"Alice"},{"name":"Bob"},{"name":"Charlie"},{"name":"David"},{"name":"Eve"}]
+
+SELECT name FROM idx_test ORDER BY age, name;
+→ [{"name":"Bob"},{"name":"Eve"},{"name":"Alice"},{"name":"David"},{"name":"Charlie"}]
+
+-- Test range queries on indexed columns
+SELECT name FROM idx_test WHERE age BETWEEN 25 AND 30 ORDER BY age, name;
+→ [{"name":"Bob"},{"name":"Eve"},{"name":"Alice"},{"name":"David"}]
+
+-- Error cases
+
+-- Try to create index on non-existent table
+CREATE INDEX idx_bad_table ON non_existent_table (col);
+-- error: no such table
+
+-- Try to create index on non-existent column
+CREATE INDEX idx_bad_col ON idx_test (non_existent_column);
+-- error: Column 'non_existent_column' not found in table 'idx_test'
+
+-- Try to create duplicate index without IF NOT EXISTS
+CREATE INDEX idx_name ON idx_test (name);
+-- error: Index idx_name already exists
+
+-- ========================================
+-- DROP INDEX tests
+-- ========================================
+
+-- DROP INDEX: basic drop
+CREATE TABLE drop_idx_test (id INTEGER PRIMARY KEY, name TEXT, age INTEGER);
+INSERT INTO drop_idx_test VALUES (1, 'Alice', 30), (2, 'Bob', 25);
+
+CREATE INDEX idx_drop_name ON drop_idx_test (name);
+
+-- Verify index works
+SELECT name FROM drop_idx_test WHERE name = 'Alice';
+→ [{"name":"Alice"}]
+
+-- Drop the index
+DROP INDEX idx_drop_name;
+
+-- Queries should still work after dropping index
+SELECT name FROM drop_idx_test WHERE name = 'Alice';
+→ [{"name":"Alice"}]
+
+-- Re-creating the same index should succeed after drop
+CREATE INDEX idx_drop_name ON drop_idx_test (name);
+DROP INDEX idx_drop_name;
+
+-- DROP INDEX IF EXISTS: index exists
+CREATE INDEX idx_drop_age ON drop_idx_test (age);
+DROP INDEX IF EXISTS idx_drop_age;
+
+-- DROP INDEX IF EXISTS: index does not exist (should be no-op)
+DROP INDEX IF EXISTS idx_nonexistent;
+
+-- DROP INDEX: error when index does not exist (no IF EXISTS)
+DROP INDEX idx_nonexistent;
+-- error: no such index
+
+-- DROP TRIGGER: parser rejects (not a supported object type)
+DROP TRIGGER some_trigger;
+-- error: Expected TABLE, VIEW, MATERIALIZED VIEW, INDEX, or ASSERTION after DROP
+
+DROP TABLE drop_idx_test;
+
+-- Clean up
+DROP TABLE departments;
+DROP TABLE null_test;
+DROP TABLE unique_test;
+DROP TABLE idx_test;

package/test/logic/10.5.1-partial-indexes.sqllogic

@@ -0,0 +1,526 @@
+-- adapted from SQLite test/index6.test, test/index7.test
+-- partial indexes (CREATE INDEX ... WHERE expr) — both regular and UNIQUE.
+-- Quereus's parser accepts partial indexes; this fixture pins the runtime semantics:
+-- only rows matching the WHERE clause participate in the index, but query results must
+-- remain correct regardless of which rows the index covers.
+--
+-- requires-capability: standalone-index-ddl
+
+-- =====================================================
+-- 1. Basic partial index — rows outside WHERE still queryable
+-- =====================================================
+create table p_basic (id integer primary key, status text, val integer);
+insert into p_basic values (1, 'active', 10);
+insert into p_basic values (2, 'inactive', 20);
+insert into p_basic values (3, 'active', 30);
+insert into p_basic values (4, 'inactive', 5);
+
+create index ix_p_basic_active on p_basic(val) where status = 'active';
+
+-- Query inside the partial scope
+select id from p_basic where status = 'active' order by id;
+→ [{"id":1},{"id":3}]
+
+-- Query outside the partial scope still returns correct rows (index need not apply)
+select id from p_basic where status = 'inactive' order by id;
+→ [{"id":2},{"id":4}]
+
+-- Combined predicate using the partial scope
+select id from p_basic where status = 'active' and val > 15;
+→ [{"id":3}]
+
+drop table p_basic;
+
+-- =====================================================
+-- 2. Partial UNIQUE index — uniqueness limited to WHERE scope
+-- =====================================================
+create table p_uniq (id integer primary key, status text, code text);
+create unique index ix_p_uniq_active_code on p_uniq(code) where status = 'active';
+
+-- First active row claims code 'A'
+insert into p_uniq values (1, 'active', 'A');
+
+-- Same code outside scope: allowed (partial UNIQUE excludes inactive rows)
+insert into p_uniq values (2, 'inactive', 'A');
+
+select id, status, code from p_uniq order by id;
+→ [{"id":1,"status":"active","code":"A"},{"id":2,"status":"inactive","code":"A"}]
+
+-- Same code inside scope: rejected
+insert into p_uniq values (3, 'active', 'A');
+-- error: UNIQUE
+
+-- Update transitioning a row out of scope frees the code
+update p_uniq set status = 'archived' where id = 1;
+insert into p_uniq values (4, 'active', 'A');
+
+select id, status, code from p_uniq order by id;
+→ [{"id":1,"status":"archived","code":"A"},{"id":2,"status":"inactive","code":"A"},{"id":4,"status":"active","code":"A"}]
+
+drop table p_uniq;
+
+-- =====================================================
+-- 3. Partial index with IS NULL / IS NOT NULL predicate
+-- =====================================================
+create table p_null (id integer primary key, name text, deleted_at text null);
+insert into p_null values (1, 'Widget', null);
+insert into p_null values (2, 'Gadget', '2024-06-01');
+insert into p_null values (3, 'Sprocket', null);
+insert into p_null values (4, 'Doohickey', '2025-01-15');
+
+create index ix_p_null_active on p_null(name) where deleted_at is null;
+
+-- Query inside scope (matches the partial predicate)
+select id from p_null where name = 'Widget' and deleted_at is null;
+→ [{"id":1}]
+
+-- Query outside scope (does not match the partial predicate)
+select id from p_null where name = 'Gadget' and deleted_at is not null;
+→ [{"id":2}]
+
+-- Listing all "active" rows
+select id, name from p_null where deleted_at is null order by id;
+→ [{"id":1,"name":"Widget"},{"id":3,"name":"Sprocket"}]
+
+drop table p_null;
+
+-- =====================================================
+-- 4. Partial index with compound WHERE (AND, comparison)
+-- =====================================================
+create table p_cmp (id integer primary key, user_id integer, score real, archived integer);
+insert into p_cmp values (1, 10, 95.5, 0);
+insert into p_cmp values (2, 10, 45.0, 0);
+insert into p_cmp values (3, 20, 88.2, 0);
+insert into p_cmp values (4, 10, 99.0, 1);
+
+create index ix_p_cmp_high on p_cmp(user_id) where archived = 0 and score > 80.0;
+
+-- Query in scope
+select id from p_cmp where archived = 0 and score > 80.0 and user_id = 10;
+→ [{"id":1}]
+
+-- Query that overlaps scope but adds another filter
+select id from p_cmp where user_id = 10 and score > 80.0 order by id;
+→ [{"id":1},{"id":4}]
+
+-- Query strictly outside scope
+select id from p_cmp where archived = 1 order by id;
+→ [{"id":4}]
+
+drop table p_cmp;
+
+-- =====================================================
+-- 5. Partial index updated correctly when a row's WHERE-eligibility changes
+-- =====================================================
+create table p_move (id integer primary key, kind text, label text);
+create index ix_p_move on p_move(label) where kind = 'A';
+
+insert into p_move values (1, 'A', 'one');
+insert into p_move values (2, 'B', 'two');
+insert into p_move values (3, 'A', 'three');
+
+select id from p_move where kind = 'A' and label = 'one';
+→ [{"id":1}]
+
+-- Move id=1 out of scope
+update p_move set kind = 'B' where id = 1;
+
+select id from p_move where kind = 'A' and label = 'one';
+→ []
+
+-- Move id=2 into scope
+update p_move set kind = 'A' where id = 2;
+
+select id from p_move where kind = 'A' order by id;
+→ [{"id":2},{"id":3}]
+
+drop table p_move;
+
+-- =====================================================
+-- 6. Partial UNIQUE index must NOT register as a relation key
+-- (FD-layer soundness — partial UNIQUE only guarantees uniqueness
+--  inside the WHERE scope, so it cannot be promoted to an
+--  unconditional key. Otherwise the FD layer derives
+--  K → all-other-cols over the whole table and silently breaks
+--  DISTINCT elimination, GROUP BY simplification, ORDER BY pruning,
+--  and FK→PK join elimination.)
+-- =====================================================
+create table p_fdkey (id integer primary key, c text not null, status text not null);
+create unique index ix_p_fdkey on p_fdkey(c) where status = 'active';
+insert into p_fdkey values (1, 'A', 'active');
+insert into p_fdkey values (2, 'A', 'inactive');
+insert into p_fdkey values (3, 'B', 'active');
+
+-- DISTINCT must not be eliminated: c is only unique among status='active' rows.
+select c from (select distinct c from p_fdkey) order by c;
+→ [{"c":"A"},{"c":"B"}]
+
+-- Same query, count form — must equal the true distinct count across all rows.
+select count(distinct c) as n from p_fdkey;
+→ [{"n":2}]
+
+-- LEFT JOIN whose right side is the partial-UNIQUE column: join elimination must
+-- not fire — t.c is not an unconditional key, so the join can change row count
+-- (the driver row 'A' matches two p_fdkey rows, not one).
+create table p_fdkey_drv (x integer primary key, c text);
+insert into p_fdkey_drv values (10, 'A');
+select count(*) as n from p_fdkey_drv d left join p_fdkey t on d.c = t.c;
+→ [{"n":2}]
+
+drop table p_fdkey_drv;
+drop table p_fdkey;
+
+-- Positive control: a *full* UNIQUE index on a NOT NULL column on the same
+-- shape still registers as a key and DISTINCT/etc. may safely be eliminated.
+create table p_fdkey_full (id integer primary key, c text not null);
+create unique index ix_p_fdkey_full on p_fdkey_full(c);
+insert into p_fdkey_full values (1, 'A');
+insert into p_fdkey_full values (2, 'B');
+select count(*) as n from (select distinct c from p_fdkey_full);
+→ [{"n":2}]
+drop table p_fdkey_full;
+
+-- =====================================================
+-- 7. Partial UNIQUE index → guarded FD; correctness across filter shapes.
+--
+-- The producer (partial-unique-extraction) emits a guarded FD `K → others | P`
+-- on the table reference. Filter activation discharges the guard when the
+-- surrounding predicate entails P. Observable plan-shape verification of the
+-- activation happens in unit tests (conditional-fds.spec.ts), which inspect
+-- the FilterNode's physical FDs directly. Here we pin runtime correctness:
+-- queries that *should* be safe against duplicates inside the partial scope
+-- must return the right rows whether or not the optimizer chose to eliminate
+-- DISTINCT / GROUP BY.
+-- =====================================================
+create table p7 (id integer primary key, c text not null, status text not null, region text not null, amt integer not null);
+create unique index ix_p7_active on p7(c) where status = 'active';
+insert into p7 values (1, 'A', 'active', 'us', 10);
+insert into p7 values (2, 'A', 'inactive', 'us', 20);
+insert into p7 values (3, 'B', 'active', 'us', 30);
+insert into p7 values (4, 'C', 'active', 'eu', 40);
+
+-- 7a. Direct match: filter exactly equal to the partial predicate.
+select c from p7 where status = 'active' order by c;
+→ [{"c":"A"},{"c":"B"},{"c":"C"}]
+
+-- 7b. DISTINCT is correct whether eliminated or not.
+select distinct c from (select c from p7 where status = 'active') order by c;
+→ [{"c":"A"},{"c":"B"},{"c":"C"}]
+
+-- 7c. Negative — no filter: DISTINCT must dedupe ('A' appears twice).
+select c from (select distinct c from p7) order by c;
+→ [{"c":"A"},{"c":"B"},{"c":"C"}]
+
+-- 7d. Negative — wrong filter: 'A' duplicates outside the partial scope.
+select count(*) as n from (select distinct c from p7 where status = 'inactive');
+→ [{"n":1}]
+
+-- 7e. GROUP BY: one row per group regardless of partial-FD discharge.
+select c, max(amt) as max_amt from p7 where status = 'active' group by c order by c;
+→ [{"c":"A","max_amt":10},{"c":"B","max_amt":30},{"c":"C","max_amt":40}]
+
+drop table p7;
+
+-- 7f. Multi-conjunct partial predicate: correctness when both clauses match,
+-- and when only one does (uniqueness no longer holds).
+create table p7m (id integer primary key, c text not null, status text not null, region text not null);
+create unique index ix_p7m on p7m(c) where status = 'active' and region = 'us';
+insert into p7m values (1, 'A', 'active', 'us');
+insert into p7m values (2, 'A', 'active', 'eu');
+insert into p7m values (3, 'B', 'active', 'us');
+
+-- Both conjuncts present: 'A' appears once (only the 'us' row matches).
+select c from p7m where status = 'active' and region = 'us' order by c;
+→ [{"c":"A"},{"c":"B"}]
+
+-- Single conjunct: 'A' appears twice (two active rows, different regions).
+-- DISTINCT must deduplicate (the partial UC doesn't cover the broader scope).
+select count(*) as n from (select distinct c from p7m where status = 'active');
+→ [{"n":2}]
+
+drop table p7m;
+
+-- 7g. Nullable UC column: NOT-NULL gate suppresses the FD entirely. Even
+-- with a perfectly matching filter, the partial UC doesn't give a key —
+-- nullable c admits duplicate NULLs inside the partial scope.
+create table p7n (id integer primary key, c text null, status text not null);
+create unique index ix_p7n on p7n(c) where status = 'active';
+insert into p7n values (1, 'A', 'active');
+insert into p7n values (2, 'B', 'active');
+insert into p7n values (3, null, 'active');
+
+select count(*) as n from (select distinct c from p7n where status = 'active');
+→ [{"n":3}]
+
+drop table p7n;
+
+-- 7h. Nullable UC column with IS NOT NULL guard: the partial predicate itself
+-- forces the column non-NULL inside scope, so the guarded FD is sound and
+-- DISTINCT should be eliminable when the filter discharges it.
+create table p7h (id integer primary key, email text null);
+create unique index ix_p7h on p7h(email) where email is not null;
+insert into p7h values (1, 'a@x');
+insert into p7h values (2, 'b@x');
+insert into p7h values (3, null);
+
+-- Inside scope: every email is unique; DISTINCT must yield the same count
+-- as without (correctness must hold whether or not the optimizer eliminated
+-- DISTINCT). Two non-null rows.
+select count(*) as n from (select distinct email from p7h where email is not null);
+→ [{"n":2}]
+
+-- Negative: without the IS NOT NULL filter, NULL is part of the result set;
+-- correctness must remain — three distinct values including NULL.
+select count(*) as n from (select distinct email from p7h);
+→ [{"n":3}]
+
+drop table p7h;
+
+-- =====================================================
+-- 7i. Partial UNIQUE with IN-list predicate: producer recognizes
+--     `col IN (lit, …)` as an `or-of [eq-literal …]` guard; the
+--     consumer discharges it when the filter pins the column to a
+--     subset of the OR-set.
+-- =====================================================
+create table p7i (id integer primary key, c text not null, status text not null);
+create unique index ix_p7i on p7i(c) where status in ('active', 'pending');
+
+-- Direct match: c must be unique inside the partial scope.
+insert into p7i values (1, 'A', 'active');
+insert into p7i values (2, 'B', 'pending');
+insert into p7i values (3, 'A', 'inactive');
+-- Different status, same c: allowed (partial UC excludes the row).
+
+select id, c, status from p7i order by id;
+→ [{"id":1,"c":"A","status":"active"},{"id":2,"c":"B","status":"pending"},{"id":3,"c":"A","status":"inactive"}]
+
+-- Duplicate inside scope: rejected.
+insert into p7i values (4, 'A', 'pending');
+-- error: UNIQUE
+
+-- DISTINCT inside scope: c is unique, so the result count equals the
+-- in-scope row count regardless of FD discharge.
+select count(*) as n from (select distinct c from p7i where status in ('active', 'pending'));
+→ [{"n":2}]
+
+-- Negative: a filter outside the scope (status not in OR-set) must still
+-- dedupe correctly when c repeats across scopes.
+select count(*) as n from (select distinct c from p7i);
+→ [{"n":2}]
+
+drop table p7i;
+
+-- =====================================================
+-- 7j. Partial UNIQUE with `NOT col` predicate (declared NOT NULL int):
+--     the producer rewrites `NOT col` to `col = 0` and the consumer
+--     discharges from a filter that pins `col` to 0.
+-- =====================================================
+create table p7j (id integer primary key, c text not null, archived integer not null);
+create unique index ix_p7j on p7j(c) where not archived;
+
+insert into p7j values (1, 'A', 0);
+insert into p7j values (2, 'B', 0);
+insert into p7j values (3, 'A', 1);   -- archived: outside partial scope, dupes allowed.
+
+select id, c, archived from p7j order by id;
+→ [{"id":1,"c":"A","archived":0},{"id":2,"c":"B","archived":0},{"id":3,"c":"A","archived":1}]
+
+-- Duplicate inside the scope (archived=0): rejected.
+insert into p7j values (4, 'A', 0);
+-- error: UNIQUE
+
+-- Correctness: distinct c across the whole table.
+select count(*) as n from (select distinct c from p7j);
+→ [{"n":2}]
+
+-- Inside scope: still distinct (no duplicates among archived=0 rows).
+select count(*) as n from (select distinct c from p7j where archived = 0);
+→ [{"n":2}]
+
+drop table p7j;
+
+-- =====================================================
+-- 7j-NOT-on-TEXT. Regression: `NOT col` on a TEXT column must NOT
+--     yield a `col = 0` rewrite. SQLite's strict sqlValueEquals treats
+--     TEXT '' as unequal to integer 0; the partial UC predicate
+--     `WHERE NOT val` keeps rows with val='' (falsy text), but those
+--     rows are NOT distinguished by val under the rewritten guard.
+--     Before this fix the planner believed `WHERE NOT val` activated
+--     the partial UC and a FILTER-emitted FD c → {…} fired over rows
+--     that actually share c, producing observably wrong results
+--     (DISTINCT / aggregate-elimination misfire).
+-- =====================================================
+create table p7j_text (id integer primary key, c integer not null, val text not null);
+create unique index ix_p7j_text on p7j_text(c) where val = 0;
+
+-- Two rows with identical c and val='' (falsy in SQLite's NOT-truthiness).
+-- The partial UC predicate `val = 0` does not match val='' under strict
+-- equality, so neither row is in the partial scope — duplicates allowed.
+insert into p7j_text values (1, 1, '');
+insert into p7j_text values (2, 1, '');
+
+-- `WHERE NOT val` keeps both rows. They share c=1, so any planner-level
+-- claim "c → others" would be unsound. Pin the count.
+select c, count(*) as n from p7j_text where not val group by c order by c;
+→ [{"c":1,"n":2}]
+
+drop table p7j_text;
+
+-- Mirror: same shape with val INTEGER NOT NULL — `NOT val` correctly
+-- rewrites to `val = 0` and the partial UC still activates. Confirms the
+-- numeric-only gate didn't regress the INT case.
+create table p7j_int (id integer primary key, c integer not null, val integer not null);
+create unique index ix_p7j_int on p7j_int(c) where val = 0;
+
+insert into p7j_int values (1, 1, 0);
+-- Duplicate inside scope (val=0): rejected.
+insert into p7j_int values (2, 1, 0);
+-- error: UNIQUE
+
+-- Outside scope (val != 0): duplicates allowed.
+insert into p7j_int values (3, 1, 1);
+
+select c, count(*) as n from p7j_int where not val group by c order by c;
+→ [{"c":1,"n":1}]
+
+drop table p7j_int;
+
+-- =====================================================
+-- 7k. Partial UNIQUE with top-level OR predicate: producer recognizes
+--     `a OR b` as an `or-of` guard. Either disjunct in a filter
+--     discharges it; an unrelated filter does not.
+-- =====================================================
+create table p7k (id integer primary key, c text not null, status text not null, deleted_at text null);
+create unique index ix_p7k on p7k(c) where deleted_at is null or status = 'archived';
+
+insert into p7k values (1, 'A', 'active', null);
+insert into p7k values (2, 'B', 'archived', '2024-01-01');
+-- Both rows match the partial predicate (different disjuncts) — different c's are fine.
+
+-- Duplicate c when both fall under the partial scope (different disjuncts): rejected.
+insert into p7k values (3, 'A', 'archived', '2025-01-01');
+-- error: UNIQUE
+
+-- A row that satisfies neither disjunct (deleted_at not null AND status != 'archived')
+-- is outside the partial scope and may dupe.
+insert into p7k values (4, 'A', 'active', '2025-06-01');
+
+select id, c, status from p7k order by id;
+→ [{"id":1,"c":"A","status":"active"},{"id":2,"c":"B","status":"archived"},{"id":4,"c":"A","status":"active"}]
+
+drop table p7k;
+
+-- =====================================================
+-- 8. Bare-value predicate truthiness matches the engine (isTruthy).
+--    A bare-column WHERE uses numeric truthiness, so non-numeric text
+--    ('abc') is FALSE (out of scope) while numeric-nonzero text ('1')
+--    is TRUE (in scope) — the same rule the Filter / runtime path uses.
+--    A prior divergence treated any non-empty string as truthy; this
+--    pins the corrected, engine-aligned semantics.
+-- =====================================================
+create table p_bare (id integer primary key, flag text, code text);
+create unique index ix_p_bare on p_bare(code) where flag;
+
+-- 'abc' is non-numeric → predicate FALSE → row is OUT of the partial scope.
+insert into p_bare values (1, 'abc', 'X');
+-- Same code, also out of scope → allowed (would be a UNIQUE error under the old
+-- "any non-empty string is truthy" rule).
+insert into p_bare values (2, 'abc', 'X');
+
+-- '1' coerces to 1 → predicate TRUE → row is IN scope and claims code 'Y'.
+insert into p_bare values (3, '1', 'Y');
+-- Same code inside scope → rejected.
+insert into p_bare values (4, '1', 'Y');
+-- error: UNIQUE
+
+select id, code from p_bare order by id;
+→ [{"id":1,"code":"X"},{"id":2,"code":"X"},{"id":3,"code":"Y"}]
+
+drop table p_bare;
+
+-- =====================================================
+-- 9. Bare-value truthiness through the operator-nested predicateTruthy
+--    call sites (compileUnary NOT, compileBinary AND/OR) and the blob
+--    branch of isTruthy. § 8 pins the top-level bare-value path; these
+--    pin the same isTruthy delegation reached *inside* operators, plus
+--    the blobs-are-falsy rule. Each case is an observable partial-UNIQUE
+--    accept/reject, so a truthiness regression fails loudly.
+-- =====================================================
+
+-- 9a. NOT of a bare text column. `where not flag`:
+--   flag='abc' → isTruthy false → NOT true  → row IN scope
+--   flag='1'   → isTruthy true  → NOT false → row OUT of scope
+create table p_not (id integer primary key, flag text, code text);
+create unique index ix_p_not on p_not(code) where not flag;
+
+-- Two in-scope rows ('abc' is falsy → NOT true) sharing a code: second rejected.
+insert into p_not values (1, 'abc', 'X');
+insert into p_not values (2, 'abc', 'X');
+-- error: UNIQUE
+
+-- Two out-of-scope rows ('1' is truthy → NOT false) sharing a code: both allowed.
+insert into p_not values (3, '1', 'Y');
+insert into p_not values (4, '1', 'Y');
+
+select id, code from p_not order by id;
+→ [{"id":1,"code":"X"},{"id":3,"code":"Y"},{"id":4,"code":"Y"}]
+
+drop table p_not;
+
+-- 9b. Bare column as an AND operand. `where flag and othercol > 0`, with
+--     `othercol > 0` held TRUE so the bare-flag truthiness decides scope:
+--   flag='1'   (truthy) AND true → row IN scope
+--   flag='abc' (falsy)  AND true → row OUT of scope
+create table p_and (id integer primary key, flag text, othercol integer, code text);
+create unique index ix_p_and on p_and(code) where flag and othercol > 0;
+
+-- In scope (flag truthy): duplicate code rejected.
+insert into p_and values (1, '1', 5, 'X');
+insert into p_and values (2, '1', 5, 'X');
+-- error: UNIQUE
+
+-- Out of scope (flag falsy short-circuits the AND): duplicate code allowed.
+insert into p_and values (3, 'abc', 5, 'Y');
+insert into p_and values (4, 'abc', 5, 'Y');
+
+select id, code from p_and order by id;
+→ [{"id":1,"code":"X"},{"id":3,"code":"Y"},{"id":4,"code":"Y"}]
+
+drop table p_and;
+
+-- 9c. Bare column as an OR operand. `where flag or othercol > 0`, with
+--     `othercol > 0` held FALSE (othercol = 0) so the bare-flag truthiness
+--     decides scope:
+--   flag='1'   (truthy) OR false → row IN scope
+--   flag='abc' (falsy)  OR false → row OUT of scope
+create table p_or (id integer primary key, flag text, othercol integer, code text);
+create unique index ix_p_or on p_or(code) where flag or othercol > 0;
+
+-- In scope (flag truthy): duplicate code rejected.
+insert into p_or values (1, '1', 0, 'X');
+insert into p_or values (2, '1', 0, 'X');
+-- error: UNIQUE
+
+-- Out of scope (both disjuncts falsy): duplicate code allowed.
+insert into p_or values (3, 'abc', 0, 'Y');
+insert into p_or values (4, 'abc', 0, 'Y');
+
+select id, code from p_or order by id;
+→ [{"id":1,"code":"X"},{"id":3,"code":"Y"},{"id":4,"code":"Y"}]
+
+drop table p_or;
+
+-- 9d. Bare BLOB value. `where blobcol` with a non-null blob: isTruthy(blob)
+--     is FALSE (util/comparison.ts), so every row is OUT of scope and duplicate
+--     codes are allowed. Under a regression that treated blobs as truthy, these
+--     rows would be IN scope and the second insert would be a UNIQUE error.
+create table p_blob (id integer primary key, blobcol blob, code text);
+create unique index ix_p_blob on p_blob(code) where blobcol;
+
+insert into p_blob values (1, x'00', 'X');
+insert into p_blob values (2, x'01ff', 'X');
+
+select id, code from p_blob order by id;
+→ [{"id":1,"code":"X"},{"id":2,"code":"X"}]
+
+drop table p_blob;