@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/42.1-returning-extras.sqllogic

@@ -0,0 +1,232 @@
+-- adapted from SQLite test/returning1.test
+-- RETURNING extras beyond 42-returning.sqllogic basics:
+-- subqueries in RETURNING expressions, INSERT...SELECT with RETURNING,
+-- generated columns, quoted identifiers, RETURNING on no-op upsert.
+
+-- ===================================
+-- 1. RETURNING with scalar subquery in expression list
+-- ===================================
+
+create table tally (id integer primary key, val integer);
+insert into tally values (1, 100), (2, 200);
+
+insert into tally (id, val) values (3, 150)
+   returning id, (select count(*) from tally where val > 150) as higher_count;
+→ [{"id":3,"higher_count":1}]
+
+select count(*) as cnt from tally;
+→ [{"cnt":3}]
+
+drop table tally;
+
+-- ===================================
+-- 2. INSERT ... SELECT with RETURNING (multi-row)
+-- ===================================
+
+create table src_xfer (id integer primary key, val integer);
+create table dst_xfer (id integer primary key, val integer);
+insert into src_xfer values (1, 100), (2, 200), (3, 300);
+
+insert into dst_xfer select id, val from src_xfer returning id, val;
+→ [{"id":1,"val":100},{"id":2,"val":200},{"id":3,"val":300}]
+
+select id, val from dst_xfer order by id;
+→ [{"id":1,"val":100},{"id":2,"val":200},{"id":3,"val":300}]
+
+drop table dst_xfer;
+drop table src_xfer;
+
+-- ===================================
+-- 3. RETURNING with quoted identifier and bracket-quoted column
+-- ===================================
+
+create table quoted_cols (id integer primary key, "Name" text);
+insert into quoted_cols values (1, 'first') returning id, "Name" as name_out;
+→ [{"id":1,"name_out":"first"}]
+
+-- bracket-quoted identifier [Name] in RETURNING projection preserves case
+insert into quoted_cols values (2, 'second') returning id, [Name];
+→ [{"id":2,"Name":"second"}]
+
+drop table quoted_cols;
+
+-- ===================================
+-- 4. RETURNING on no-op UPSERT (DO NOTHING) returns no row
+-- ===================================
+
+create table noop (id integer primary key, val text);
+insert into noop values (1, 'a');
+
+insert into noop values (1, 'b') on conflict do nothing returning id, val;
+→ []
+
+-- existing row unchanged
+select id, val from noop;
+→ [{"id":1,"val":"a"}]
+
+drop table noop;
+
+-- ===================================
+-- 5. RETURNING on INSERT with computed expression and aggregate-style call
+-- ===================================
+
+create table greet (id integer primary key, name text);
+
+insert into greet values (1, 'world')
+   returning id, 'hello, ' || name as msg, length(name) as n;
+→ [{"id":1,"msg":"hello, world","n":5}]
+
+drop table greet;
+
+-- ===================================
+-- 6. RETURNING from generated-column table omits / includes generated col
+-- ===================================
+
+create table gen_t (id integer primary key, name text, display text generated always as (upper(name)));
+
+-- baseline: stored columns return
+insert into gen_t (id, name) values (1, 'alice') returning id, name;
+→ [{"id":1,"name":"alice"}]
+
+-- generated column referenced in RETURNING projection
+insert into gen_t (id, name) values (2, 'bob') returning id, name, display;
+→ [{"id":2,"name":"bob","display":"BOB"}]
+
+drop table gen_t;
+
+-- ===================================
+-- 7. UPDATE OR <action> is intentionally not supported
+-- ===================================
+-- Per-statement conflict overrides on UPDATE are SQLite-only syntax; pinned closed.
+-- See docs/sql.md §11.
+
+create table or_ig (id integer primary key, code text unique);
+insert into or_ig values (1, 'x'), (2, 'y');
+
+update or ignore or_ig set code = 'x' where id = 2 returning id, code;
+-- error: Expected table name
+
+drop table or_ig;
+
+-- ===================================
+-- 8. RETURNING with two scalar subqueries that share a plan subtree.
+-- (Regression: shared-subtree row-context collision under store mode —
+-- see ticket serialize-emit-callbacks-returning-window. The cache rule
+-- deduplicates the two textually-identical derived tables, so both
+-- subqueries iterate the same inner scan; without serialized
+-- evaluation they raced on the shared RowSlot under LevelDB.)
+-- ===================================
+
+create table tr (id integer primary key, v integer);
+insert into tr values (1, 10), (2, 20), (3, 30);
+
+insert into tr values (4, 40)
+returning
+  (select count(*) from (select * from tr where v >= 20) sub1) as count,
+  (select sum(v) from (select * from tr where v >= 20) sub2) as sum;
+→ [{"count":3,"sum":90}]
+
+drop table tr;
+
+-- ===================================
+-- 9. RETURNING * / table.* on a base-table INSERT / UPDATE / DELETE
+-- ===================================
+-- `*` expands to every target column in declaration order; the unqualified
+-- symbols bind the statement's default image (NEW for INSERT/UPDATE, OLD for
+-- DELETE). Output names are the bare column names regardless of qualifier.
+
+create table star_t (id integer primary key, name text, value integer default 100);
+
+-- INSERT ... RETURNING * → full row, declaration order; DEFAULT 100 surfaced.
+insert into star_t (id, name) values (1, 'a') returning *;
+→ [{"id":1,"name":"a","value":100}]
+
+-- INSERT ... RETURNING table.* (qualified by the target table name) → same as *.
+insert into star_t (id, name, value) values (2, 'b', 200) returning star_t.*;
+→ [{"id":2,"name":"b","value":200}]
+
+-- a wrong qualifier errors (not a generic crash, not a silent expand).
+insert into star_t (id, name) values (3, 'c') returning bogus.*;
+-- error: not found
+
+-- the rejected insert made no row (id=3 absent).
+select id from star_t order by id;
+→ [{"id":1},{"id":2}]
+
+-- UPDATE ... RETURNING * → the NEW (post-update) image, full row.
+update star_t set value = 101 where id = 1 returning *;
+→ [{"id":1,"name":"a","value":101}]
+
+-- mixed projection, trailing: * expands in place, the extra `name` keeps its
+-- position and is de-duplicated to `name:1`.
+update star_t set value = 102 where id = 1 returning *, name;
+→ [{"id":1,"name":"a","value":102,"name:1":"a"}]
+
+-- mixed projection, leading: a column before * keeps position (the star copy of
+-- `id` de-duplicates to `id:1`).
+update star_t set value = 103 where id = 1 returning id, *;
+→ [{"id":1,"id:1":1,"name":"a","value":103}]
+
+-- OLD-qualified expression composes with * (which is the NEW image).
+update star_t set value = 200 where id = 1 returning old.value, *;
+→ [{"old.value":103,"id":1,"name":"a","value":200}]
+
+-- DELETE ... RETURNING * → the OLD (deleted) image, full row.
+delete from star_t where id = 2 returning *;
+→ [{"id":2,"name":"b","value":200}]
+
+-- zero-row mutations with * yield an empty result set, not an error.
+update star_t set value = 0 where 1 = 0 returning *;
+→ []
+
+delete from star_t where 1 = 0 returning *;
+→ []
+
+-- relational orthogonality: RETURNING * makes the DML a relation usable in CTE
+-- position (a wider projection). Insert form:
+with ins as (insert into star_t (id, name, value) values (5, 'e', 50) returning *)
+select count(*) as c from ins;
+→ [{"c":1}]
+
+-- ...and delete form.
+with d as (delete from star_t where id = 5 returning *)
+select id, name, value from d;
+→ [{"id":5,"name":"e","value":50}]
+
+-- interaction: a multi-row INSERT ... RETURNING * emits one expanded row per
+-- inserted row (the star is the projection list; the executor supplies the rows).
+insert into star_t (id, name, value) values (10, 'j', 1), (11, 'k', 2) returning *;
+→ [{"id":10,"name":"j","value":1},{"id":11,"name":"k","value":2}]
+
+-- ...and a multi-row UPDATE ... RETURNING * emits one NEW image per updated row.
+update star_t set value = value + 100 where id in (10, 11) returning *;
+→ [{"id":10,"name":"j","value":101},{"id":11,"name":"k","value":102}]
+
+drop table star_t;
+
+-- ===================================
+-- 10. RETURNING * surfaces resolved DEFAULT and generated-column values
+-- ===================================
+
+create table gstar (id integer primary key, name text, qty integer default 7,
+    display text generated always as (upper(name)));
+
+insert into gstar (id, name) values (1, 'alice') returning *;
+→ [{"id":1,"name":"alice","qty":7,"display":"ALICE"}]
+
+drop table gstar;
+
+-- ===================================
+-- 11. RETURNING * over a collated column round-trips the stored value, and the
+--     column's declared collation still drives the WHERE match (the * column
+--     resolves through the same symbol a named column would).
+-- ===================================
+
+create table cstar (id integer primary key, name text collate nocase);
+insert into cstar values (1, 'Hello'), (2, 'WORLD');
+
+-- nocase WHERE matches 'hello' → 'Hello'; * returns the verbatim stored value.
+update cstar set name = name where name = 'hello' returning *;
+→ [{"id":1,"name":"Hello"}]
+
+drop table cstar;

package/test/logic/42.2-returning-stored-row.sqllogic

@@ -0,0 +1,165 @@
+-- 42.2-returning-stored-row.sqllogic — RETURNING must report the row the
+-- storage layer actually STORED, not the raw values the statement proposed.
+--
+-- Coercion happens inside vtab.update(), below the DML executor: a `json`
+-- column given the text '{"a":2}' stores a native JSON value, and an
+-- `integer`-affinity column given the text '7' stores the number 7. The
+-- executor used to build RETURNING (and change tracking, and materialized-view
+-- maintenance) from the PRE-coercion row, so the same column had two
+-- observable values depending on which door you looked through.
+--
+-- Every case below is a PARITY assertion: what `returning` reports must equal
+-- what a following `select` reports — value AND typeof. typeof() is what makes
+-- the assertion sharp; a raw '{"a":2}' would report 'text', the stored value
+-- reports 'json'.
+
+-- ===================================
+-- 1. INSERT ... RETURNING reports the coerced row
+-- ===================================
+
+create table sr_ins (id integer primary key, j json, n integer);
+
+insert into sr_ins values (1, '{"a":2}', '7')
+  returning j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+select j, typeof(j) as jt, n, typeof(n) as nt from sr_ins where id = 1;
+→ [{"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+-- RETURNING * takes the same path
+insert into sr_ins values (2, '[1,2]', '8') returning *;
+→ [{"id":2,"j":[1,2],"n":8}]
+
+select * from sr_ins where id = 2;
+→ [{"id":2,"j":[1,2],"n":8}]
+
+-- multi-row INSERT: every emitted row is its own stored row
+insert into sr_ins values (3, '{"b":1}', '9'), (4, '{"c":2}', '10')
+  returning id, j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"id":3,"j":{"b":1},"jt":"json","n":9,"nt":"integer"},{"id":4,"j":{"c":2},"jt":"json","n":10,"nt":"integer"}]
+
+select id, j, typeof(j) as jt, n, typeof(n) as nt from sr_ins where id in (3, 4) order by id;
+→ [{"id":3,"j":{"b":1},"jt":"json","n":9,"nt":"integer"},{"id":4,"j":{"c":2},"jt":"json","n":10,"nt":"integer"}]
+
+drop table sr_ins;
+
+-- ===================================
+-- 2. UPDATE ... RETURNING reports the coerced NEW row; OLD stays the stored
+--    pre-update row.
+-- ===================================
+
+create table sr_upd (id integer primary key, j json, n integer);
+insert into sr_upd values (1, '{"a":1}', 1);
+
+update sr_upd set j = '{"a":2}', n = '7' where id = 1
+  returning j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+select j, typeof(j) as jt, n, typeof(n) as nt from sr_upd where id = 1;
+→ [{"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+-- OLD image is the stored row read from the source scan; NEW is the stored row
+-- handed back by the substrate. Both sides coerced, in one projection.
+update sr_upd set j = '{"a":3}', n = '11' where id = 1
+  returning old.j as oj, typeof(old.j) as ojt, j as nj, typeof(j) as njt,
+            old.n as on_, typeof(old.n) as ont, n as nn, typeof(n) as nnt;
+→ [{"oj":{"a":2},"ojt":"json","nj":{"a":3},"njt":"json","on_":7,"ont":"integer","nn":11,"nnt":"integer"}]
+
+select j, n from sr_upd where id = 1;
+→ [{"j":{"a":3},"n":11}]
+
+-- a no-op-valued UPDATE still reports the stored row (not the raw text)
+update sr_upd set j = '{ "a" : 3 }' where id = 1 returning j, typeof(j) as jt;
+→ [{"j":{"a":3},"jt":"json"}]
+
+select j, typeof(j) as jt from sr_upd where id = 1;
+→ [{"j":{"a":3},"jt":"json"}]
+
+drop table sr_upd;
+
+-- ===================================
+-- 3. UPDATE that MOVES the primary key
+-- ===================================
+-- The key move takes the delete+insert arm of the executor; RETURNING must
+-- still project the stored NEW row and the stored OLD key.
+
+create table sr_move (id integer primary key, j json, n integer);
+insert into sr_move values (1, '{"a":1}', 1);
+
+update sr_move set id = 5, j = '{"a":9}', n = '42' where id = 1
+  returning old.id as old_id, id, j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"old_id":1,"id":5,"j":{"a":9},"jt":"json","n":42,"nt":"integer"}]
+
+select id, j, typeof(j) as jt, n, typeof(n) as nt from sr_move;
+→ [{"id":5,"j":{"a":9},"jt":"json","n":42,"nt":"integer"}]
+
+drop table sr_move;
+
+-- ===================================
+-- 4. INSERT ... ON CONFLICT DO UPDATE ... RETURNING
+-- ===================================
+
+create table sr_ups (id integer primary key, j json, n integer);
+insert into sr_ups values (1, '{"a":1}', 1);
+
+-- conflicting insert takes the DO UPDATE arm
+insert into sr_ups values (1, '{"a":2}', '7')
+  on conflict (id) do update set j = excluded.j, n = excluded.n
+  returning id, j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"id":1,"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+select id, j, typeof(j) as jt, n, typeof(n) as nt from sr_ups;
+→ [{"id":1,"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+-- non-conflicting insert through the same statement shape takes the plain
+-- insert arm, and is equally coerced
+insert into sr_ups values (2, '{"b":3}', '8')
+  on conflict (id) do update set j = excluded.j
+  returning id, j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"id":2,"j":{"b":3},"jt":"json","n":8,"nt":"integer"}]
+
+select id, j, typeof(j) as jt, n, typeof(n) as nt from sr_ups where id = 2;
+→ [{"id":2,"j":{"b":3},"jt":"json","n":8,"nt":"integer"}]
+
+drop table sr_ups;
+
+-- ===================================
+-- 5. INSERT OR REPLACE ... RETURNING
+-- ===================================
+
+create table sr_repl (id integer primary key, j json, n integer);
+insert into sr_repl values (1, '{"a":1}', 1);
+
+insert or replace into sr_repl values (1, '{"a":2}', '7')
+  returning id, j, typeof(j) as jt, n, typeof(n) as nt;
+→ [{"id":1,"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+select id, j, typeof(j) as jt, n, typeof(n) as nt from sr_repl;
+→ [{"id":1,"j":{"a":2},"jt":"json","n":7,"nt":"integer"}]
+
+drop table sr_repl;
+
+-- ===================================
+-- 6. INSERT OR IGNORE on a conflicting row yields NO row
+-- ===================================
+-- Negative pin: the "row was not written" short-circuit runs BEFORE any of the
+-- stored-row plumbing, so an ignored conflict must still emit nothing at all.
+
+create table sr_ign (id integer primary key, j json);
+insert into sr_ign values (1, '{"a":1}');
+
+insert or ignore into sr_ign values (1, '{"a":2}') returning id, j;
+→ []
+
+-- the existing row is untouched
+select id, j from sr_ign;
+→ [{"id":1,"j":{"a":1}}]
+
+-- a non-conflicting OR IGNORE insert does emit its stored row
+insert or ignore into sr_ign values (2, '{"a":2}') returning id, j, typeof(j) as jt;
+→ [{"id":2,"j":{"a":2},"jt":"json"}]
+
+select id, j from sr_ign order by id;
+→ [{"id":1,"j":{"a":1}},{"id":2,"j":{"a":2}}]
+
+drop table sr_ign;

package/test/logic/43-default-nullability.sqllogic

@@ -0,0 +1,131 @@
+-- 43-default-nullability.sqllogic - Testing default NOT NULL column behavior (Third Manifesto alignment)
+
+-- Test default NOT NULL behavior
+CREATE TABLE test_default_notnull (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    age INTEGER
+);
+
+-- Valid insert - should succeed
+INSERT INTO test_default_notnull VALUES (1, 'Alice', 30);
+SELECT * FROM test_default_notnull WHERE id = 1;
+→ [{"id":1,"name":"Alice","age":30}]
+
+-- Insert with NULL name - should fail (NOT NULL by default)
+INSERT INTO test_default_notnull VALUES (2, NULL, 25);
+-- error: NOT NULL constraint failed: test_default_notnull.name
+
+-- Insert with NULL age - should fail (NOT NULL by default)
+INSERT INTO test_default_notnull VALUES (3, 'Bob', NULL);
+-- error: NOT NULL constraint failed: test_default_notnull.age
+
+-- Verify only valid row was inserted
+SELECT COUNT(*) FROM test_default_notnull;
+→ [{"count(*)":1}]
+
+DROP TABLE test_default_notnull;
+
+-- Test explicit NULL override
+CREATE TABLE test_explicit_null (
+    id INTEGER PRIMARY KEY,
+    required_field TEXT,
+    optional_field TEXT NULL
+);
+
+-- Insert with NULL in required field - should fail
+INSERT INTO test_explicit_null VALUES (1, NULL, 'optional');
+-- error: NOT NULL constraint failed: test_explicit_null.required_field
+
+-- Insert with NULL in optional field - should succeed
+INSERT INTO test_explicit_null VALUES (2, 'required', NULL);
+SELECT * FROM test_explicit_null WHERE id = 2;
+→ [{"id":2,"required_field":"required","optional_field":null}]
+
+-- Insert with both fields populated - should succeed
+INSERT INTO test_explicit_null VALUES (3, 'test', 'value');
+SELECT * FROM test_explicit_null WHERE id = 3;
+→ [{"id":3,"required_field":"test","optional_field":"value"}]
+
+DROP TABLE test_explicit_null;
+
+-- Test pragma to revert to SQL standard nullable behavior
+PRAGMA default_column_nullability='nullable';
+
+PRAGMA default_column_nullability;
+→ [{"name": "default_column_nullability", "value": "nullable"}]
+
+CREATE TABLE test_nullable_default (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    value INTEGER
+);
+
+-- Insert with NULL values - should succeed with nullable pragma
+INSERT INTO test_nullable_default VALUES (1, NULL, NULL);
+SELECT * FROM test_nullable_default WHERE id = 1;
+→ [{"id":1,"name":null,"value":null}]
+
+-- Insert with values - should also succeed
+INSERT INTO test_nullable_default VALUES (2, 'test', 42);
+SELECT * FROM test_nullable_default WHERE id = 2;
+→ [{"id":2,"name":"test","value":42}]
+
+DROP TABLE test_nullable_default;
+
+-- Restore default NOT NULL behavior
+PRAGMA default_column_nullability='not_null';
+
+PRAGMA default_column_nullability;
+→ [{"name": "default_column_nullability", "value": "not_null"}]
+
+-- Test that explicit NOT NULL still works
+CREATE TABLE test_explicit_notnull (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    age INTEGER
+);
+
+-- Insert with NULL name - should fail
+INSERT INTO test_explicit_notnull VALUES (1, NULL, 30);
+-- error: NOT NULL constraint failed: test_explicit_notnull.name
+
+-- Insert with NULL age - should fail (default NOT NULL)
+INSERT INTO test_explicit_notnull VALUES (2, 'Alice', NULL);
+-- error: NOT NULL constraint failed: test_explicit_notnull.age
+
+-- Valid insert - should succeed
+INSERT INTO test_explicit_notnull VALUES (3, 'Bob', 25);
+SELECT * FROM test_explicit_notnull WHERE id = 3;
+→ [{"id":3,"name":"Bob","age":25}]
+
+DROP TABLE test_explicit_notnull;
+
+-- Test mixed NULL and NOT NULL columns
+CREATE TABLE test_mixed (
+    id INTEGER PRIMARY KEY,
+    required_name TEXT NOT NULL,
+    optional_desc TEXT NULL,
+    required_count INTEGER,
+    optional_notes TEXT NULL
+);
+
+-- Insert with all required fields, NULL optionals - should succeed
+INSERT INTO test_mixed VALUES (1, 'Item1', NULL, 5, NULL);
+SELECT * FROM test_mixed WHERE id = 1;
+→ [{"id":1,"required_name":"Item1","optional_desc":null,"required_count":5,"optional_notes":null}]
+
+-- Insert with NULL required field - should fail
+INSERT INTO test_mixed VALUES (2, NULL, 'desc', 10, 'notes');
+-- error: NOT NULL constraint failed: test_mixed.required_name
+
+-- Insert with NULL required count - should fail
+INSERT INTO test_mixed VALUES (3, 'Item3', 'desc', NULL, 'notes');
+-- error: NOT NULL constraint failed: test_mixed.required_count
+
+-- Valid insert with all fields - should succeed
+INSERT INTO test_mixed VALUES (4, 'Item4', 'description', 20, 'some notes');
+SELECT * FROM test_mixed WHERE id = 4;
+→ [{"id":4,"required_name":"Item4","optional_desc":"description","required_count":20,"optional_notes":"some notes"}]
+
+DROP TABLE test_mixed;