@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/29.1-column-level-conflict-clause.sqllogic

@@ -0,0 +1,171 @@
+-- Column-level ON CONFLICT directives in DDL (e.g.
+-- `... PRIMARY KEY ON CONFLICT REPLACE`).  Quereus now honors these as the
+-- per-constraint default conflict resolution.  Statement-level OR clauses
+-- still take precedence over the column-level default.
+
+-- ===================================
+-- 1. PRIMARY KEY ON CONFLICT REPLACE — duplicate insert silently replaces
+-- ===================================
+
+create table pk_replace (a integer primary key on conflict replace, b text);
+insert into pk_replace values (1, 'first');
+
+insert into pk_replace values (1, 'second');
+
+select a, b from pk_replace;
+→ [{"a":1,"b":"second"}]
+
+drop table pk_replace;
+
+-- ===================================
+-- 2. PRIMARY KEY ON CONFLICT IGNORE — duplicate insert silently dropped
+-- ===================================
+
+create table pk_ignore (a integer primary key on conflict ignore, b text);
+insert into pk_ignore values (10, 'data');
+
+insert into pk_ignore values (10, 'conflict');
+
+select a, b from pk_ignore;
+→ [{"a":10,"b":"data"}]
+
+drop table pk_ignore;
+
+-- ===================================
+-- 3. UNIQUE ON CONFLICT REPLACE — second insert replaces existing row
+-- ===================================
+
+create table uniq_replace (id integer primary key, email text unique on conflict replace);
+insert into uniq_replace values (1, 'a@x');
+
+insert into uniq_replace values (2, 'a@x');
+
+-- The new row (id=2) wins; the old one is replaced.
+select id, email from uniq_replace order by id;
+→ [{"id":2,"email":"a@x"}]
+
+drop table uniq_replace;
+
+-- ===================================
+-- 4. NOT NULL ON CONFLICT IGNORE — violating row silently skipped
+-- ===================================
+
+create table nn_ignore (id integer primary key, name text not null on conflict ignore);
+insert into nn_ignore values (1, 'valid');
+
+insert into nn_ignore (id) values (2);
+
+select id, name from nn_ignore order by id;
+→ [{"id":1,"name":"valid"}]
+
+drop table nn_ignore;
+
+-- ===================================
+-- 5. CHECK ON CONFLICT IGNORE — parser accepts; violations silently skipped
+-- ===================================
+
+create table ck_ignore (id integer primary key, n integer check (n > 0) on conflict ignore);
+insert into ck_ignore values (1, 10);
+
+-- CHECK violation under column-level IGNORE: row dropped.
+insert into ck_ignore values (2, -5);
+
+select id, n from ck_ignore order by id;
+→ [{"id":1,"n":10}]
+
+drop table ck_ignore;
+
+-- ===================================
+-- 6. Statement-level OR clause overrides column-level ON CONFLICT directive
+-- ===================================
+
+create table override_t (a integer primary key on conflict ignore, b text);
+insert into override_t values (1, 'first');
+
+-- statement-level OR ABORT must beat the column-level IGNORE directive.
+insert or abort into override_t values (1, 'second');
+-- error: UNIQUE constraint failed
+
+-- only original row remains
+select a, b from override_t;
+→ [{"a":1,"b":"first"}]
+
+drop table override_t;
+
+-- ===================================
+-- 7. UPDATE path honors PRIMARY KEY ON CONFLICT REPLACE
+-- ===================================
+
+create table pk_upd_replace (id integer primary key on conflict replace, v text);
+insert into pk_upd_replace values (1, 'a'), (2, 'b');
+
+-- No OR clause on UPDATE — column-level REPLACE should apply.
+update pk_upd_replace set id = 2 where id = 1;
+
+select id, v from pk_upd_replace order by id;
+→ [{"id":2,"v":"a"}]
+
+drop table pk_upd_replace;
+
+-- ===================================
+-- 8. UPDATE path honors PRIMARY KEY ON CONFLICT IGNORE
+-- ===================================
+
+create table pk_upd_ignore (id integer primary key on conflict ignore, v text);
+insert into pk_upd_ignore values (1, 'a'), (2, 'b');
+
+update pk_upd_ignore set id = 2 where id = 1;
+
+select id, v from pk_upd_ignore order by id;
+→ [{"id":1,"v":"a"},{"id":2,"v":"b"}]
+
+drop table pk_upd_ignore;
+
+-- ===================================
+-- 9. UPDATE-with-PK-change under REPLACE cascades FK ON DELETE for evicted row
+-- ===================================
+-- Quereus's default `on update` is `restrict`, so any child of the moved row
+-- would block the update before the eviction can happen. To isolate the
+-- evicted row's cascade, only the row that gets evicted has a child here.
+
+create table parent_evict (id integer primary key on conflict replace, v text);
+create table child_evict (
+	id integer primary key,
+	parent_id integer references parent_evict(id) on delete cascade
+);
+insert into parent_evict values (1, 'one'), (2, 'two');
+insert into child_evict values (20, 2);
+
+-- Move parent id=1 onto id=2; column-level REPLACE evicts the row at id=2.
+update parent_evict set id = 2 where id = 1;
+
+-- The row formerly at id=2 was evicted, so its child (id=20) must be cascaded.
+select id, parent_id from child_evict;
+→ []
+
+select id, v from parent_evict order by id;
+→ [{"id":2,"v":"one"}]
+
+drop table child_evict;
+drop table parent_evict;
+
+-- ===================================
+-- 10. UPDATE-with-PK-change under REPLACE applies ON DELETE SET NULL for evicted row
+-- ===================================
+
+create table p_set_null (id integer primary key on conflict replace, v text);
+create table c_set_null (
+	id integer primary key,
+	parent_id integer null references p_set_null(id) on delete set null
+);
+insert into p_set_null values (1, 'a'), (2, 'b');
+insert into c_set_null values (200, 2);
+
+update p_set_null set id = 2 where id = 1;
+
+-- Evicted parent (2, 'b') triggers SET NULL on its child (200).
+select id, parent_id from c_set_null;
+→ [{"id":200,"parent_id":null}]
+
+drop table c_set_null;
+drop table p_set_null;

package/test/logic/29.2-table-level-pk-conflict-clause.sqllogic

@@ -0,0 +1,113 @@
+-- Table-level `PRIMARY KEY (...) ON CONFLICT <action>` directive. Mirrors 29.1
+-- (column-level) but exercises the constraint on a composite PK declared as a
+-- table-level constraint, which previously parsed correctly but had its
+-- `ON CONFLICT` action silently dropped (resolving to ABORT).
+
+-- ===================================
+-- 1. PRIMARY KEY (...) ON CONFLICT IGNORE — duplicate insert silently dropped
+-- ===================================
+
+create table tpk_ignore (a integer, b integer, v text, primary key (a, b) on conflict ignore);
+insert into tpk_ignore values (1, 1, 'first');
+
+insert into tpk_ignore values (1, 1, 'second');
+
+select a, b, v from tpk_ignore;
+→ [{"a":1,"b":1,"v":"first"}]
+
+drop table tpk_ignore;
+
+-- ===================================
+-- 2. PRIMARY KEY (...) ON CONFLICT REPLACE — duplicate insert silently replaces
+-- ===================================
+
+create table tpk_replace (a integer, b integer, v text, primary key (a, b) on conflict replace);
+insert into tpk_replace values (1, 1, 'first');
+
+insert into tpk_replace values (1, 1, 'second');
+
+select a, b, v from tpk_replace;
+→ [{"a":1,"b":1,"v":"second"}]
+
+drop table tpk_replace;
+
+-- ===================================
+-- 3. PRIMARY KEY (...) ON CONFLICT FAIL — duplicate insert errors
+-- ===================================
+
+create table tpk_fail (a integer, b integer, v text, primary key (a, b) on conflict fail);
+insert into tpk_fail values (1, 1, 'first');
+
+insert into tpk_fail values (1, 1, 'second');
+-- error: UNIQUE constraint failed
+
+-- The original row is still there; the conflicting insert errored out.
+select a, b, v from tpk_fail;
+→ [{"a":1,"b":1,"v":"first"}]
+
+drop table tpk_fail;
+
+-- ===================================
+-- 4. PRIMARY KEY (...) ON CONFLICT ROLLBACK — duplicate insert errors
+-- ===================================
+-- The per-constraint ROLLBACK action surfaces as a constraint failure at the
+-- helper layer (statement aborts). Translation into a tx-wide rollback of the
+-- enclosing transaction would require additional runtime wiring beyond the
+-- schema-build + helper scope of this change; see implementer notes.
+
+create table tpk_rb (a integer, b integer, v text, primary key (a, b) on conflict rollback);
+insert into tpk_rb values (1, 1, 'first');
+
+insert into tpk_rb values (1, 1, 'second');
+-- error: UNIQUE constraint failed
+
+select a, b, v from tpk_rb;
+→ [{"a":1,"b":1,"v":"first"}]
+
+drop table tpk_rb;
+
+-- ===================================
+-- 5. Statement-level OR clause overrides table-level ON CONFLICT directive
+-- ===================================
+
+create table tpk_override (a integer, b integer, v text, primary key (a, b) on conflict ignore);
+insert into tpk_override values (1, 1, 'first');
+
+-- statement-level OR ABORT must beat the table-level IGNORE directive.
+insert or abort into tpk_override values (1, 1, 'second');
+-- error: UNIQUE constraint failed
+
+-- only the original row remains
+select a, b, v from tpk_override;
+→ [{"a":1,"b":1,"v":"first"}]
+
+drop table tpk_override;
+
+-- ===================================
+-- 6. UPDATE path honors table-level PRIMARY KEY ON CONFLICT REPLACE
+-- ===================================
+
+create table tpk_upd_replace (a integer, b integer, v text, primary key (a, b) on conflict replace);
+insert into tpk_upd_replace values (1, 1, 'a'), (2, 2, 'b');
+
+-- No OR clause on UPDATE — table-level REPLACE should apply.
+update tpk_upd_replace set a = 2, b = 2 where a = 1 and b = 1;
+
+select a, b, v from tpk_upd_replace order by a, b;
+→ [{"a":2,"b":2,"v":"a"}]
+
+drop table tpk_upd_replace;
+
+-- ===================================
+-- 7. UPDATE path honors table-level PRIMARY KEY ON CONFLICT IGNORE
+-- ===================================
+
+create table tpk_upd_ignore (a integer, b integer, v text, primary key (a, b) on conflict ignore);
+insert into tpk_upd_ignore values (1, 1, 'a'), (2, 2, 'b');
+
+update tpk_upd_ignore set a = 2, b = 2 where a = 1 and b = 1;
+
+select a, b, v from tpk_upd_ignore order by a, b;
+→ [{"a":1,"b":1,"v":"a"},{"a":2,"b":2,"v":"b"}]
+
+drop table tpk_upd_ignore;

package/test/logic/40-constraints.sqllogic

@@ -0,0 +1,418 @@
+-- constraints.sqllogic - Testing integrity constraints
+
+-- Basic table creation (without constraint enforcement)
+CREATE TABLE t_basic (
+    id INTEGER PRIMARY KEY,
+    name TEXT,
+    value INTEGER
+);
+
+INSERT INTO t_basic VALUES (1, 'test', 100);
+SELECT * FROM t_basic;
+→ [{"id":1,"name":"test","value":100}]
+
+DROP TABLE t_basic;
+
+-- === NOT NULL Constraints ===
+
+CREATE TABLE t_notnull (
+    id INTEGER PRIMARY KEY,
+    req TEXT NOT NULL,
+    opt TEXT NULL
+);
+
+-- Insert valid row
+INSERT INTO t_notnull (id, req, opt) VALUES (1, 'required', 'optional');
+SELECT req, opt FROM t_notnull WHERE id = 1;
+→ [{"req":"required","opt":"optional"}]
+
+-- Insert omitting NOT NULL column (no default)
+INSERT INTO t_notnull (id, opt) VALUES (2, 'no_req');
+-- error: NOT NULL constraint failed: t_notnull.req
+
+-- Insert explicit NULL into NOT NULL column
+INSERT INTO t_notnull (id, req) VALUES (3, NULL);
+-- error: NOT NULL constraint failed: t_notnull.req
+
+-- Update optional to NULL (allowed)
+UPDATE t_notnull SET opt = NULL WHERE id = 1;
+SELECT opt FROM t_notnull WHERE id = 1;
+→ [{"opt":null}]
+
+-- Update required to NULL (fail)
+UPDATE t_notnull SET req = NULL WHERE id = 1;
+-- error: NOT NULL constraint failed: t_notnull.req
+
+-- Verify state after failed update
+SELECT req FROM t_notnull WHERE id = 1;
+→ [{"req":"required"}]
+
+DROP TABLE t_notnull;
+
+-- === Simple CHECK Constraints (Default ON INSERT, UPDATE) ===
+
+CREATE TABLE t_check (
+    id INTEGER PRIMARY KEY,
+    pos INT CHECK(pos > 0),
+    bal REAL CHECK(bal >= 0)
+);
+
+-- Insert valid
+INSERT INTO t_check VALUES (1, 10, 100.5);
+SELECT pos, bal FROM t_check WHERE id = 1;
+→ [{"pos":10,"bal":100.5}]
+
+-- Insert invalid pos
+INSERT INTO t_check VALUES (2, -5, 50);
+-- error: CHECK constraint failed: _check_pos
+
+-- Insert invalid bal
+INSERT INTO t_check VALUES (3, 5, -0.01);
+-- error: CHECK constraint failed: _check_bal
+
+-- Update valid to valid
+UPDATE t_check SET pos = 20, bal = 99.9 WHERE id = 1;
+SELECT pos, bal FROM t_check WHERE id = 1;
+→ [{"pos":20,"bal":99.9}]
+
+-- Update valid to invalid pos
+UPDATE t_check SET pos = 0 WHERE id = 1;
+-- error: CHECK constraint failed: _check_pos
+
+-- Update valid to invalid bal
+UPDATE t_check SET bal = -10 WHERE id = 1;
+-- error: CHECK constraint failed: _check_bal
+
+-- Verify state after failed updates
+SELECT pos, bal FROM t_check WHERE id = 1;
+→ [{"pos":20,"bal":99.9}]
+
+DROP TABLE t_check;
+
+-- === Row-Level CHECK ON ... Constraints ===
+
+CREATE TABLE t_check_on (
+    id INTEGER PRIMARY KEY,
+    status TEXT CHECK ON INSERT (status IN ('active', 'inactive')),
+    val INTEGER,
+    CONSTRAINT positive_val CHECK ON UPDATE (NEW.val >= 0),
+    CONSTRAINT no_delete CHECK ON DELETE (FALSE)
+);
+
+-- Insert valid (status check applies)
+INSERT INTO t_check_on (id, status, val) VALUES (1, 'active', 100);
+SELECT status, val FROM t_check_on WHERE id = 1;
+→ [{"status":"active","val":100}]
+
+-- Insert invalid status
+INSERT INTO t_check_on (id, status, val) VALUES (2, 'pending', 200);
+-- error: CHECK constraint failed: _check_status
+
+-- Update status (check does NOT apply on UPDATE)
+UPDATE t_check_on SET status = 'archived' WHERE id = 1;
+SELECT status FROM t_check_on WHERE id = 1;
+→ [{"status":"archived"}]
+
+-- Update val valid (positive_val check applies)
+UPDATE t_check_on SET val = 50 WHERE id = 1;
+SELECT val FROM t_check_on WHERE id = 1;
+→ [{"val":50}]
+
+-- Update val invalid (positive_val check applies)
+UPDATE t_check_on SET val = -1 WHERE id = 1;
+-- error: CHECK constraint failed: positive_val
+
+-- Verify state after failed update
+SELECT val FROM t_check_on WHERE id = 1;
+→ [{"val":50}]
+
+-- Attempt DELETE (no_delete check applies)
+DELETE FROM t_check_on WHERE id = 1;
+-- error: CHECK constraint failed: no_delete
+
+-- Verify state after failed delete
+SELECT count(*) FROM t_check_on WHERE id = 1;
+→ [{"count(*)":1}]
+
+DROP TABLE t_check_on;
+
+-- === CHECK ON with NEW/OLD aliases ===
+
+CREATE TABLE t_check_alias (
+    id INTEGER PRIMARY KEY,
+    version INTEGER DEFAULT 1,
+    payload TEXT,
+    CONSTRAINT version_increase CHECK ON UPDATE (NEW.version > OLD.version)
+);
+
+INSERT INTO t_check_alias (id, payload) VALUES (10, 'initial data');
+SELECT version FROM t_check_alias WHERE id = 10;
+→ [{"version":1}]
+
+-- Valid update (increasing version)
+UPDATE t_check_alias SET version = 2, payload = 'updated data' WHERE id = 10;
+SELECT version, payload FROM t_check_alias WHERE id = 10;
+→ [{"version":2,"payload":"updated data"}]
+
+-- Invalid update (same version)
+UPDATE t_check_alias SET version = 2, payload = 'no change' WHERE id = 10;
+-- error: CHECK constraint failed: version_increase
+
+-- Invalid update (decreasing version)
+UPDATE t_check_alias SET version = 1, payload = 'revert?' WHERE id = 10;
+-- error: CHECK constraint failed: version_increase
+
+-- Verify state after failed updates
+SELECT version, payload FROM t_check_alias WHERE id = 10;
+→ [{"version":2,"payload":"updated data"}]
+
+DROP TABLE t_check_alias;
+
+-- === CHECK ON with Subquery ===
+
+CREATE TABLE products (sku TEXT PRIMARY KEY, price REAL);
+CREATE TABLE inventory (loc TEXT, sku TEXT, qty INTEGER CHECK(qty >= 0) /* Simple check */,
+    FOREIGN KEY (sku) REFERENCES products(sku));
+ALTER TABLE inventory ADD CONSTRAINT enough_stock CHECK ON UPDATE (
+        new.qty <= (SELECT sum(s.qty) FROM inventory s WHERE s.sku = NEW.sku)
+    );
+ALTER TABLE inventory ADD CONSTRAINT no_delete_if_positive CHECK ON DELETE (
+        old.qty <= 0
+    );
+
+INSERT INTO products VALUES ('A1', 10.0), ('B2', 20.0);
+INSERT INTO inventory VALUES ('W1', 'A1', 50), ('W2', 'A1', 30), ('W1', 'B2', 100);
+
+SELECT sku, sum(qty) FROM inventory GROUP BY sku ORDER BY sku;
+→ [{"sku":"A1","sum(qty)":80},{"sku":"B2","sum(qty)":100}]
+
+-- Valid update (decreasing stock is allowed by enough_stock on update)
+UPDATE inventory SET qty = 25 WHERE loc = 'W1' AND sku = 'A1';
+SELECT qty FROM inventory WHERE loc = 'W1' AND sku = 'A1';
+→ [{"qty":25}]
+
+-- Invalid update (cannot set negative simple check)
+UPDATE inventory SET qty = -5 WHERE loc = 'W1' AND sku = 'A1';
+-- error: CHECK constraint failed: _check_qty
+
+-- Attempt to delete row with positive quantity
+DELETE FROM inventory WHERE loc = 'W1' AND sku = 'A1';
+-- error: CHECK constraint failed: no_delete_if_positive
+
+-- Set quantity to 0
+UPDATE inventory SET qty = 0 WHERE loc = 'W1' AND sku = 'A1';
+SELECT qty FROM inventory WHERE loc = 'W1' AND sku = 'A1';
+→ [{"qty":0}]
+
+-- Now delete should work
+DELETE FROM inventory WHERE loc = 'W1' AND sku = 'A1';
+SELECT count(*) FROM inventory WHERE loc = 'W1' AND sku = 'A1';
+→ [{"count(*)":0}]
+
+DROP TABLE inventory;
+DROP TABLE products;
+
+-- === CHECK with EXISTS subquery referencing another table (INSERT/UPDATE) ===
+
+CREATE TABLE ref_table (
+    id TEXT PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE dependent (
+    id INTEGER PRIMARY KEY,
+    ref_id TEXT,
+    CONSTRAINT ref_must_exist CHECK ON INSERT, UPDATE (
+        EXISTS (SELECT 1 FROM ref_table WHERE ref_table.id = NEW.ref_id)
+    )
+);
+
+-- Insert into empty dependent table should fail (ref_table is empty)
+INSERT INTO dependent (id, ref_id) VALUES (1, 'abc');
+-- error: CHECK constraint failed: ref_must_exist
+
+-- Populate ref_table
+INSERT INTO ref_table VALUES ('abc', 'Valid Reference');
+SELECT * FROM ref_table;
+→ [{"id":"abc","name":"Valid Reference"}]
+
+-- Now insert should succeed
+INSERT INTO dependent (id, ref_id) VALUES (1, 'abc');
+SELECT * FROM dependent;
+→ [{"id":1,"ref_id":"abc"}]
+
+-- Try to update to non-existent reference
+UPDATE dependent SET ref_id = 'xyz' WHERE id = 1;
+-- error: CHECK constraint failed: ref_must_exist
+
+-- Verify state unchanged
+SELECT ref_id FROM dependent WHERE id = 1;
+→ [{"ref_id":"abc"}]
+
+-- Add another valid reference
+INSERT INTO ref_table VALUES ('xyz', 'Another Valid');
+
+-- Now update should succeed
+UPDATE dependent SET ref_id = 'xyz' WHERE id = 1;
+SELECT ref_id FROM dependent WHERE id = 1;
+→ [{"ref_id":"xyz"}]
+
+DROP TABLE dependent;
+DROP TABLE ref_table;
+
+-- === Deferred row-level CHECK (EXISTS) commit-time enforcement ===
+
+-- Recreate tables
+CREATE TABLE ref_table (
+    id TEXT PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE dependent (
+    id INTEGER PRIMARY KEY,
+    ref_id TEXT,
+    CONSTRAINT ref_must_exist CHECK ON INSERT, UPDATE (
+        EXISTS (SELECT 1 FROM ref_table WHERE ref_table.id = NEW.ref_id)
+    )
+);
+
+-- Case A: Violation allowed within transaction, rejected at COMMIT
+BEGIN;
+INSERT INTO dependent (id, ref_id) VALUES (100, 'missing');
+COMMIT;
+-- error: CHECK constraint failed: ref_must_exist
+
+-- Ensure nothing was committed
+SELECT count(*) FROM dependent WHERE id = 100;
+→ [{"count(*)":0}]
+
+-- Case B: Fix violation before COMMIT → succeeds
+BEGIN;
+INSERT INTO dependent (id, ref_id) VALUES (101, 'later');
+INSERT INTO ref_table VALUES ('later', 'OK');
+COMMIT;
+SELECT ref_id FROM dependent WHERE id = 101;
+→ [{"ref_id":"later"}]
+
+-- Case C: Savepoint rollback of violating change → COMMIT succeeds
+BEGIN;
+SAVEPOINT sp;
+INSERT INTO dependent (id, ref_id) VALUES (102, 'nope');
+ROLLBACK TO SAVEPOINT sp;
+COMMIT;
+SELECT count(*) FROM dependent WHERE id = 102;
+→ [{"count(*)":0}]
+
+DROP TABLE dependent;
+DROP TABLE ref_table;
+
+-- === ALTER TABLE ADD CONSTRAINT ===
+
+CREATE TABLE t_alter(x INT, y TEXT);
+
+-- Add a simple CHECK constraint
+ALTER TABLE t_alter ADD CONSTRAINT positive_x CHECK (x > 0);
+
+-- Test that the constraint is enforced on INSERT
+INSERT INTO t_alter VALUES (5, 'valid');
+SELECT * FROM t_alter;
+→ [{"x":5,"y":"valid"}]
+
+-- Test constraint failure
+INSERT INTO t_alter VALUES (-1, 'invalid');
+-- error: CHECK constraint failed: positive_x
+
+-- Verify state after failed insert
+SELECT * FROM t_alter;
+→ [{"x":5,"y":"valid"}]
+
+-- Add constraint with operation specifier
+ALTER TABLE t_alter ADD CONSTRAINT y_on_update CHECK ON UPDATE (length(y) > 2);
+
+-- Test UPDATE constraint
+UPDATE t_alter SET y = 'good' WHERE x = 5;
+SELECT * FROM t_alter;
+→ [{"x":5,"y":"good"}]
+
+-- Test UPDATE constraint failure
+UPDATE t_alter SET y = 'no' WHERE x = 5;
+-- error: CHECK constraint failed: y_on_update
+
+-- Verify state after failed update
+SELECT * FROM t_alter;
+→ [{"x":5,"y":"good"}]
+
+-- Test that INSERT is not affected by UPDATE-only constraint
+INSERT INTO t_alter VALUES (10, 'hi');
+SELECT * FROM t_alter ORDER BY x;
+→ [{"x":5,"y":"good"},{"x":10,"y":"hi"}]
+
+DROP TABLE t_alter;
+
+-- === NOT EXISTS constraint (lowercase operators) ===
+
+CREATE TABLE other_table (
+    id INTEGER PRIMARY KEY,
+    value TEXT
+);
+
+CREATE TABLE main_table (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+-- Add constraint with lowercase 'not exists'
+ALTER TABLE main_table ADD CONSTRAINT is_valid CHECK (not exists (select 1 from other_table));
+
+-- Insert should succeed when other_table is empty
+INSERT INTO main_table VALUES (1, 'first');
+SELECT * FROM main_table;
+→ [{"id":1,"name":"first"}]
+
+-- Insert into other_table
+INSERT INTO other_table VALUES (1, 'data');
+
+-- Now insert into main_table should fail (other_table is not empty)
+INSERT INTO main_table VALUES (2, 'second');
+-- error: CHECK constraint failed: is_valid
+
+-- Clear other_table
+DELETE FROM other_table WHERE id = 1;
+
+-- Now insert should succeed again
+INSERT INTO main_table VALUES (2, 'second');
+SELECT count(*) FROM main_table;
+→ [{"count(*)":2}]
+
+DROP TABLE main_table;
+DROP TABLE other_table;
+
+-- === Lowercase logical operators in constraints ===
+
+CREATE TABLE t_lowercase (
+    id INTEGER PRIMARY KEY,
+    value INTEGER,
+    name TEXT,
+    CONSTRAINT check_and CHECK (value > 0 and value < 100),
+    CONSTRAINT check_like CHECK (name like 'test%')
+);
+
+-- Test AND constraint
+INSERT INTO t_lowercase VALUES (1, 50, 'test1');
+
+-- Test AND constraint failure (value too high)
+INSERT INTO t_lowercase VALUES (2, 150, 'test2');
+-- error: CHECK constraint failed: check_and (value > 0 and value < 100)
+
+-- Test AND constraint failure (value too low)
+INSERT INTO t_lowercase VALUES (3, -5, 'test3');
+-- error: CHECK constraint failed: check_and (value > 0 and value < 100)
+
+-- Test LIKE constraint
+INSERT INTO t_lowercase VALUES (5, 75, 'testing');
+
+-- Test LIKE constraint failure
+INSERT INTO t_lowercase VALUES (6, 30, 'invalid');
+-- error: CHECK constraint failed: check_like (name like 'test%')
+
+DROP TABLE t_lowercase;