@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/03.8-not-precedence.sqllogic

@@ -0,0 +1,255 @@
+-- 03.8-not-precedence.sqllogic — Prefix-NOT precedence matrix.
+--
+-- Regression lock for github.com/gotchoices/quereus/issues/22: prefix `not`
+-- must bind above every predicate (comparison, IN, BETWEEN, LIKE,
+-- IS [NOT] NULL, EXISTS) but below AND/OR. Each block asserts that
+--   A. `not v <predicate>` (prefix form, parser must group correctly),
+--   B. `v not <predicate>` (postfix form, where SQL exposes one), and
+--   C. `not (v <predicate>)` (explicit parenthesisation)
+-- are semantically identical. If a new predicate is added to the grammar
+-- without recursing under prefix-NOT, the corresponding A row diverges
+-- from B/C and fails loudly.
+--
+-- Probe relation seeds NULL once, so every block also exercises the
+-- three-valued-logic rules: `not (NULL = x)` is NULL (not false),
+-- `not NULL in (...)` is NULL, `not NULL is null` is false.
+
+-- Quereus requires an explicit primary key; `id` is incidental and not
+-- referenced in any predicate below.
+create table p (id integer primary key, v any null);
+insert into p values (1, 5), (2, 10), (3, null);
+
+-- ---------------------------------------------------------------------------
+-- Comparison operators (=, ==, <>, !=, <, <=, >, >=).
+-- No postfix form exists for these. Two assertions per operator (A vs C).
+-- The null row is always excluded — `not (null op 5)` is `not null` = null,
+-- which the WHERE filter treats as not-true.
+-- ---------------------------------------------------------------------------
+
+-- = 5: only v=10 survives `not (v = 5)`.
+select v from p where not v = 5 order by v;
+→ [{"v":10}]
+
+select v from p where not (v = 5) order by v;
+→ [{"v":10}]
+
+-- == 5: synonym of =.
+select v from p where not v == 5 order by v;
+→ [{"v":10}]
+
+select v from p where not (v == 5) order by v;
+→ [{"v":10}]
+
+-- <> 5: only v=5 survives `not (v <> 5)`.
+select v from p where not v <> 5 order by v;
+→ [{"v":5}]
+
+select v from p where not (v <> 5) order by v;
+→ [{"v":5}]
+
+-- != 5: synonym of <>.
+select v from p where not v != 5 order by v;
+→ [{"v":5}]
+
+select v from p where not (v != 5) order by v;
+→ [{"v":5}]
+
+-- < 5: both non-null rows fail v<5, so `not (v<5)` keeps both.
+select v from p where not v < 5 order by v;
+→ [{"v":5},{"v":10}]
+
+select v from p where not (v < 5) order by v;
+→ [{"v":5},{"v":10}]
+
+-- <= 5: v=5 satisfies v<=5 (excluded); v=10 does not (included).
+select v from p where not v <= 5 order by v;
+→ [{"v":10}]
+
+select v from p where not (v <= 5) order by v;
+→ [{"v":10}]
+
+-- > 5: v=10 satisfies v>5 (excluded); v=5 does not (included).
+select v from p where not v > 5 order by v;
+→ [{"v":5}]
+
+select v from p where not (v > 5) order by v;
+→ [{"v":5}]
+
+-- >= 5: both v=5 and v=10 satisfy v>=5 (both excluded); null is excluded.
+select v from p where not v >= 5 order by v;
+→ []
+
+select v from p where not (v >= 5) order by v;
+→ []
+
+-- ---------------------------------------------------------------------------
+-- IN value list.
+-- ---------------------------------------------------------------------------
+
+-- not v in (5,7) — without the precedence fix this would parse as
+-- (not v) in (5,7), which evaluates `not 5`=false / `not 10`=false /
+-- `not null`=null and returns []. Correct: only v=10 survives.
+select v from p where not v in (5, 7) order by v;
+→ [{"v":10}]
+
+select v from p where v not in (5, 7) order by v;
+→ [{"v":10}]
+
+select v from p where not (v in (5, 7)) order by v;
+→ [{"v":10}]
+
+-- ---------------------------------------------------------------------------
+-- IN subquery.
+-- ---------------------------------------------------------------------------
+
+select v from p where not v in (select 5 union all select 7) order by v;
+→ [{"v":10}]
+
+select v from p where v not in (select 5 union all select 7) order by v;
+→ [{"v":10}]
+
+select v from p where not (v in (select 5 union all select 7)) order by v;
+→ [{"v":10}]
+
+-- ---------------------------------------------------------------------------
+-- BETWEEN.
+-- ---------------------------------------------------------------------------
+
+-- v=5 is inside [3,7] (excluded); v=10 outside (included); null excluded.
+select v from p where not v between 3 and 7 order by v;
+→ [{"v":10}]
+
+select v from p where v not between 3 and 7 order by v;
+→ [{"v":10}]
+
+select v from p where not (v between 3 and 7) order by v;
+→ [{"v":10}]
+
+-- ---------------------------------------------------------------------------
+-- LIKE — cast(v as text) so the probe relation stays homogeneous. The cast
+-- of null yields null, and `null like '5'` is null, so the null row is still
+-- excluded by `not`.
+-- ---------------------------------------------------------------------------
+
+select v from p where not cast(v as text) like '5' order by v;
+→ [{"v":10}]
+
+select v from p where cast(v as text) not like '5' order by v;
+→ [{"v":10}]
+
+select v from p where not (cast(v as text) like '5') order by v;
+→ [{"v":10}]
+
+-- ---------------------------------------------------------------------------
+-- GLOB / REGEXP — not currently exposed by the parser (no GLOB/REGEXP
+-- token in lexer.ts; comparison() in parser.ts only matches LIKE among
+-- pattern operators). If/when added, mirror the LIKE block above with the
+-- same three-form pattern.
+-- ---------------------------------------------------------------------------
+
+-- ---------------------------------------------------------------------------
+-- IS NULL.
+-- ---------------------------------------------------------------------------
+
+-- not v is null: both non-null rows pass, null row fails.
+select v from p where not v is null order by v;
+→ [{"v":5},{"v":10}]
+
+select v from p where v is not null order by v;
+→ [{"v":5},{"v":10}]
+
+select v from p where not (v is null) order by v;
+→ [{"v":5},{"v":10}]
+
+-- ---------------------------------------------------------------------------
+-- IS NOT NULL.
+-- The postfix-equivalent of `not v is not null` is `v is null`
+-- (double-negation). Unlike the other predicates, the null row IS the
+-- surviving row here because IS NULL returns true/false (never unknown).
+-- ---------------------------------------------------------------------------
+
+select v from p where not v is not null order by v;
+→ [{"v":null}]
+
+select v from p where v is null order by v;
+→ [{"v":null}]
+
+select v from p where not (v is not null) order by v;
+→ [{"v":null}]
+
+-- ---------------------------------------------------------------------------
+-- EXISTS — no postfix form. The fix matters for `not exists ... and X`
+-- style scoping rather than EXISTS itself, but include the two forms for
+-- completeness.
+-- ---------------------------------------------------------------------------
+
+-- inner select hits v=5 → exists=true → not=false.
+select (not exists (select 1 from p where v = 5)) as r;
+→ [{"r":false}]
+
+select (not (exists (select 1 from p where v = 5))) as r;
+→ [{"r":false}]
+
+-- inner select hits nothing → exists=false → not=true.
+select (not exists (select 1 from p where v = 99)) as r;
+→ [{"r":true}]
+
+select (not (exists (select 1 from p where v = 99))) as r;
+→ [{"r":true}]
+
+-- ---------------------------------------------------------------------------
+-- Stacked NOT — `not not p` must reduce to `p`. Smoke for the two predicate
+-- shapes most affected by the fix (comparison and IN-list).
+-- ---------------------------------------------------------------------------
+
+select v from p where not not v = 5 order by v;
+→ [{"v":5}]
+
+select v from p where v = 5 order by v;
+→ [{"v":5}]
+
+select v from p where not not v in (5, 7) order by v;
+→ [{"v":5}]
+
+select v from p where v in (5, 7) order by v;
+→ [{"v":5}]
+
+-- ---------------------------------------------------------------------------
+-- NOT bound by AND — the fix puts prefix-NOT below AND, so
+-- `not v = 5 and v < 5` must parse as `(not v = 5) and (v < 5)`, NOT as
+-- `not (v = 5 and v < 5)`. The two parses disagree on v=10:
+--   correct: not(false) AND false = true AND false = false → excluded
+--   wrong:   not(false AND false) = not(false) = true → included
+-- Choosing `v < 5` as the second conjunct makes the discriminator sharp:
+-- correct parse keeps nothing, wrong parse would keep two rows.
+-- ---------------------------------------------------------------------------
+
+-- Correct precedence: `(not v = 5) AND (v < 5)`. v=5 fails left, v=10 fails
+-- right, null fails (three-valued AND of nulls). Count = 0.
+select count(*) as c from p where not v = 5 and v < 5;
+→ [{"c":0}]
+
+-- Explicit parenthesised form must match.
+select count(*) as c from p where (not v = 5) and v < 5;
+→ [{"c":0}]
+
+-- Wrong parse equivalent (kept here to prove the discriminator has bite):
+-- `not (v = 5 AND v < 5)` includes v=5 and v=10 (both make the inner AND
+-- false, NOT flips to true). Null row excluded. Count = 2.
+select count(*) as c from p where not (v = 5 and v < 5);
+→ [{"c":2}]
+
+-- ---------------------------------------------------------------------------
+-- De Morgan — `not (A or B)` ≡ `(not A) and (not B)`. Using bare prefix
+-- forms on the right exercises the fix on both A and B in one assertion.
+-- Every non-null row hits one branch (v=5 hits the IN, v=10 hits the =10),
+-- so both forms return []. The null row is null on both sides → excluded.
+-- ---------------------------------------------------------------------------
+
+select v from p where not (v in (5, 7) or v = 10) order by v;
+→ []
+
+select v from p where (not v in (5, 7)) and not v = 10 order by v;
+→ []
+
+drop table p;

package/test/logic/03.9-is-bool-predicate.sqllogic

@@ -0,0 +1,150 @@
+-- 03.9-is-bool-predicate.sqllogic — `expr IS [NOT] TRUE/FALSE` boolean tests.
+--
+-- These four postfix unary predicates are SQLite-compatible and TOTAL: they
+-- never return NULL. Operand truthiness routes through the engine's isTruthy
+-- (same as FilterNode / NOT / logical ops), so non-boolean operands behave
+-- consistently. The defining feature vs `= true/false` is the NULL row:
+--   x = true  on NULL  ⇒ NULL        x IS TRUE on NULL ⇒ false
+-- The 4×3 matrix below pins NULL totality; the non-boolean block pins that
+-- truthiness goes through isTruthy (NOT JS truthiness).
+
+-- ===========================================================================
+-- Totality matrix: {IS TRUE, IS NOT TRUE, IS FALSE, IS NOT FALSE} × {true,
+-- false, null}. Scalar form (aliased) so results are unambiguous booleans.
+-- ===========================================================================
+
+-- IS TRUE: true→true, false→false, null→false.
+select (true is true) as r;
+→ [{"r":true}]
+
+select (false is true) as r;
+→ [{"r":false}]
+
+select (null is true) as r;
+→ [{"r":false}]
+
+-- IS NOT TRUE (≡ NOT (x IS TRUE)): true→false, false→true, null→true.
+select (true is not true) as r;
+→ [{"r":false}]
+
+select (false is not true) as r;
+→ [{"r":true}]
+
+select (null is not true) as r;
+→ [{"r":true}]
+
+-- IS FALSE: true→false, false→true, null→false.
+select (true is false) as r;
+→ [{"r":false}]
+
+select (false is false) as r;
+→ [{"r":true}]
+
+select (null is false) as r;
+→ [{"r":false}]
+
+-- IS NOT FALSE (≡ NOT (x IS FALSE)): true→true, false→false, null→true.
+select (true is not false) as r;
+→ [{"r":true}]
+
+select (false is not false) as r;
+→ [{"r":false}]
+
+select (null is not false) as r;
+→ [{"r":true}]
+
+-- ===========================================================================
+-- Non-boolean operands must route through isTruthy, NOT JS truthiness.
+-- A regression to JS truthiness would make '0' IS TRUE → true and
+-- 'abc' IS TRUE → true; both must be false here.
+-- ===========================================================================
+
+-- Text: numeric-string conversion ('1'→1 truthy, '0'→0 falsey).
+select ('1' is true) as r;
+→ [{"r":true}]
+
+select ('0' is true) as r;
+→ [{"r":false}]
+
+-- Non-numeric text converts to 0 (falsey) — a JS-truthiness regression catcher.
+select ('abc' is true) as r;
+→ [{"r":false}]
+
+select ('abc' is false) as r;
+→ [{"r":true}]
+
+-- Numeric: 0 falsey, non-zero truthy.
+select (2 is true) as r;
+→ [{"r":true}]
+
+select (0 is false) as r;
+→ [{"r":true}]
+
+select (2 is not false) as r;
+→ [{"r":true}]
+
+-- ===========================================================================
+-- Column-reference path over a boolean column with a NULL row.
+-- ===========================================================================
+
+create table feat (id integer primary key, name text, flag any null);
+insert into feat values (1, 'alpha', true);
+insert into feat values (2, 'beta', false);
+insert into feat values (3, 'gamma', null);
+insert into feat values (4, 'delta', true);
+
+-- IS TRUE keeps only the true rows.
+select id from feat where flag is true order by id;
+→ [{"id":1},{"id":4}]
+
+-- IS NOT TRUE keeps false + null rows (totality: null flips into the NOT bucket).
+select id from feat where flag is not true order by id;
+→ [{"id":2},{"id":3}]
+
+-- IS FALSE keeps only the false row (null excluded — never returns true).
+select id from feat where flag is false order by id;
+→ [{"id":2}]
+
+-- IS NOT FALSE keeps true + null rows.
+select id from feat where flag is not false order by id;
+→ [{"id":1},{"id":3},{"id":4}]
+
+-- ===========================================================================
+-- Precedence: prefix NOT binds ABOVE the IS predicate, so
+-- `not flag is true` parses as `NOT (flag IS TRUE)` — identical to the
+-- explicit-parenthesis form and to `flag IS NOT TRUE` (double negation).
+-- A precedence inversion to `(not flag) is true` would diverge here.
+-- ===========================================================================
+
+select id from feat where not flag is true order by id;
+→ [{"id":2},{"id":3}]
+
+select id from feat where not (flag is true) order by id;
+→ [{"id":2},{"id":3}]
+
+-- The partial-index compilation smoke test for these four operators lives in
+-- 03.9.1-is-bool-predicate-partial-index (it needs standalone CREATE INDEX).
+
+drop table feat;
+
+-- ===========================================================================
+-- CHECK constraint using a boolean-test predicate. check-extraction /
+-- assertion-classifier don't special-case these operators (they fall through
+-- to "residual / not specially analyzed"); the constraint is still enforced by
+-- general expression evaluation, and no analysis path throws on the new
+-- operator string. `c IS NOT FALSE` admits true + null, rejects false.
+-- ===========================================================================
+
+create table chk (id integer primary key, c any null, check (c is not false));
+
+insert into chk values (1, true);
+insert into chk values (2, null);
+
+select id from chk order by id;
+→ [{"id":1},{"id":2}]
+
+-- false → `c is not false` is false → violates the CHECK.
+insert into chk values (3, false);
+-- error: CHECK constraint failed
+
+drop table chk;

package/test/logic/03.9.1-is-bool-predicate-partial-index.sqllogic

@@ -0,0 +1,34 @@
+-- 03.9.1-is-bool-predicate-partial-index.sqllogic — `IS [NOT] TRUE/FALSE` inside a partial-index WHERE.
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 03.9-is-bool-predicate: that file's subject is the four postfix
+-- boolean-test predicates themselves (totality over NULL, isTruthy routing,
+-- precedence, CHECK usage), none of which needs an index. This one block used
+-- standalone `create index ... where` only as a second compilation site for the
+-- same operators, so a backend without first-class CREATE INDEX would have lost
+-- the whole predicate file over it.
+--
+-- Subject: all four operators must compile in a partial-index WHERE clause
+-- (exercises compileUnary in vtab/memory/utils/predicate.ts), and queries must
+-- stay correct regardless of which rows the index covers.
+
+create table feat (id integer primary key, name text, flag any null);
+insert into feat values (1, 'alpha', true);
+insert into feat values (2, 'beta', false);
+insert into feat values (3, 'gamma', null);
+insert into feat values (4, 'delta', true);
+
+create index ix_feat_t  on feat(name) where flag is true;
+create index ix_feat_nt on feat(name) where flag is not true;
+create index ix_feat_f  on feat(name) where flag is false;
+create index ix_feat_nf on feat(name) where flag is not false;
+
+-- Re-query through the now-indexed table; results must be unchanged.
+select id from feat where flag is true order by id;
+→ [{"id":1},{"id":4}]
+
+select id from feat where flag is false order by id;
+→ [{"id":2}]
+
+drop table feat;

package/test/logic/04-order-by.sqllogic

@@ -0,0 +1,38 @@
+-- Coverage for ORDER BY FD pruning (see rules/sort/rule-orderby-fd-pruning.ts).
+-- The optimizer drops trailing ORDER BY keys functionally determined by the
+-- preceding bare-column keys; result rows must match the pre-pruned reference
+-- output.
+
+-- =============================================================================
+-- PK-driven: trailing keys after a PK column add nothing
+-- =============================================================================
+
+create table pkdriven (pk integer primary key, name text, email text);
+insert into pkdriven values
+  (1, 'beta',  'b@x'),
+  (2, 'alpha', 'a@x'),
+  (3, 'gamma', 'g@x');
+
+-- ORDER BY pk, name → pruned to ORDER BY pk; result is by pk.
+select pk, name from pkdriven order by pk, name;
+→ [{"pk":1,"name":"beta"},{"pk":2,"name":"alpha"},{"pk":3,"name":"gamma"}]
+
+-- ORDER BY pk, name, email → pruned to ORDER BY pk; result still by pk.
+select pk, name, email from pkdriven order by pk, name, email;
+→ [{"pk":1,"name":"beta","email":"b@x"},{"pk":2,"name":"alpha","email":"a@x"},{"pk":3,"name":"gamma","email":"g@x"}]
+
+drop table pkdriven;
+
+-- =============================================================================
+-- EC-driven: a WHERE a = b filter equates the columns, so the second key
+-- functions as a tiebreaker that can never re-order.
+-- =============================================================================
+
+create table ecdriven (a integer, b integer);
+insert into ecdriven values
+  (3, 3), (1, 1), (2, 2);
+
+select a, b from ecdriven where a = b order by a, b;
+→ [{"a":1,"b":1},{"a":2,"b":2},{"a":3,"b":3}]
+
+drop table ecdriven;