@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/44-determinism-validation.sqllogic

@@ -0,0 +1,164 @@
+-- determinism-validation.sqllogic - Testing determinism validation for constraints and defaults
+
+-- === Test 1: Non-deterministic DEFAULT values should be rejected ===
+
+-- Attempt to create table with random() in DEFAULT - should fail
+CREATE TABLE t_random_default (
+    id INTEGER PRIMARY KEY,
+    value INTEGER DEFAULT random()
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Attempt to create table with date('now') in DEFAULT - should fail
+CREATE TABLE t_date_now_default (
+    id INTEGER PRIMARY KEY,
+    created_at TEXT DEFAULT date('now')
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Attempt to create table with datetime('now') in DEFAULT - should fail
+CREATE TABLE t_datetime_now_default (
+    id INTEGER PRIMARY KEY,
+    timestamp TEXT DEFAULT datetime('now')
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Attempt to create table with time('now') in DEFAULT - should fail
+CREATE TABLE t_time_now_default (
+    id INTEGER PRIMARY KEY,
+    current_time TEXT DEFAULT time('now')
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Attempt to create table with julianday('now') in DEFAULT - should fail
+CREATE TABLE t_julianday_now_default (
+    id INTEGER PRIMARY KEY,
+    jd REAL DEFAULT julianday('now')
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- === Test 2: Deterministic DEFAULT values should be accepted ===
+
+-- Create table with constant DEFAULT - should succeed
+CREATE TABLE t_const_default (
+    id INTEGER PRIMARY KEY,
+    name TEXT DEFAULT 'unnamed',
+    value INTEGER DEFAULT 42,
+    computed INTEGER DEFAULT (10 + 20)
+);
+
+-- Insert without specifying defaults
+INSERT INTO t_const_default (id) VALUES (1);
+SELECT * FROM t_const_default WHERE id = 1;
+→ [{"id":1,"name":"unnamed","value":42,"computed":30}]
+
+DROP TABLE t_const_default;
+
+-- Create table with date literal DEFAULT - should succeed
+CREATE TABLE t_date_literal_default (
+    id INTEGER PRIMARY KEY,
+    created_date TEXT DEFAULT '2024-01-01'
+);
+
+INSERT INTO t_date_literal_default (id) VALUES (1);
+SELECT * FROM t_date_literal_default WHERE id = 1;
+→ [{"id":1,"created_date":"2024-01-01"}]
+
+DROP TABLE t_date_literal_default;
+
+-- === Test 3: Non-deterministic CHECK constraints should be rejected ===
+
+-- Attempt to create table with random() in CHECK - should fail
+CREATE TABLE t_random_check (
+    id INTEGER PRIMARY KEY,
+    value INTEGER CHECK(value > random())
+);
+-- error: Non-deterministic expression not allowed in CHECK
+
+-- Attempt to create table with date('now') in CHECK - should fail
+CREATE TABLE t_date_now_check (
+    id INTEGER PRIMARY KEY,
+    created_at TEXT CHECK(created_at < date('now'))
+);
+-- error: Non-deterministic expression not allowed in CHECK
+
+-- === Test 4: Deterministic CHECK constraints should be accepted ===
+
+-- Create table with deterministic CHECK - should succeed
+CREATE TABLE t_deterministic_check (
+    id INTEGER PRIMARY KEY,
+    value INTEGER CHECK(value > 0),
+    name TEXT CHECK(length(name) > 2)
+);
+
+-- Insert valid data
+INSERT INTO t_deterministic_check VALUES (1, 10, 'test');
+SELECT * FROM t_deterministic_check WHERE id = 1;
+→ [{"id":1,"value":10,"name":"test"}]
+
+-- Insert invalid data (violates CHECK)
+INSERT INTO t_deterministic_check VALUES (2, -5, 'ok');
+-- error: CHECK constraint failed
+
+DROP TABLE t_deterministic_check;
+
+-- === Test 5: ALTER TABLE ADD CONSTRAINT with non-deterministic expression ===
+
+CREATE TABLE t_alter (
+    id INTEGER PRIMARY KEY,
+    value INTEGER
+);
+
+-- Add non-deterministic constraint - succeeds at ALTER TABLE time
+-- but will fail when first used (at INSERT/UPDATE time)
+ALTER TABLE t_alter ADD CONSTRAINT random_check CHECK (value > random());
+
+-- Attempt to insert - should fail due to non-deterministic constraint
+INSERT INTO t_alter VALUES (1, 10);
+-- error: Non-deterministic expression not allowed in CHECK
+
+DROP TABLE t_alter;
+
+-- Create table for deterministic constraint test
+CREATE TABLE t_alter2 (
+    id INTEGER PRIMARY KEY,
+    value INTEGER
+);
+
+-- Add deterministic constraint - should succeed
+ALTER TABLE t_alter2 ADD CONSTRAINT positive_check CHECK (value > 0);
+
+-- Verify constraint works
+INSERT INTO t_alter2 VALUES (1, 10);
+SELECT * FROM t_alter2 WHERE id = 1;
+→ [{"id":1,"value":10}]
+
+INSERT INTO t_alter2 VALUES (2, -5);
+-- error: CHECK constraint failed: positive_check
+
+DROP TABLE t_alter2;
+
+-- === Test 6: Nested non-deterministic expressions ===
+
+-- Non-deterministic function nested in expression - should fail
+CREATE TABLE t_nested_random (
+    id INTEGER PRIMARY KEY,
+    value INTEGER DEFAULT (random() + 100)
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Non-deterministic function in complex expression - should fail
+CREATE TABLE t_complex_random (
+    id INTEGER PRIMARY KEY,
+    value INTEGER CHECK(value > (random() * 10))
+);
+-- error: Non-deterministic expression not allowed in CHECK
+
+-- === Test 7: randomblob() should also be rejected ===
+
+CREATE TABLE t_randomblob_default (
+    id INTEGER PRIMARY KEY,
+    data BLOB DEFAULT randomblob(16)
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+

package/test/logic/44-orthogonality.sqllogic

@@ -0,0 +1,146 @@
+-- 44-orthogonality.sqllogic - Testing relational orthogonality with mutating subqueries
+
+-- Setup test tables
+CREATE TABLE users (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    email TEXT UNIQUE
+);
+
+CREATE TABLE audit_log (
+    id INTEGER PRIMARY KEY,
+    action TEXT NOT NULL,
+    user_id INTEGER,
+    timestamp TEXT DEFAULT 'now'
+);
+
+-- Insert initial test data
+INSERT INTO users (id, name, email) VALUES
+    (1, 'Alice', 'alice@example.com'),
+    (2, 'Bob', 'bob@example.com'),
+    (3, 'Charlie', 'charlie@example.com');
+
+-- run
+-- Test 0: INSERT from SELECT, TVF, CTE
+insert into audit_log (action, user_id)
+   select 'user_created', 0;
+-- error: NOT NULL constraint failed: audit_log.id
+
+insert into audit_log (id, action, user_id)
+	SELECT key, 'cte_source', value FROM json_each('[0]') where key is not null;
+
+insert into audit_log (id, action, user_id)
+   select 1, 'test_entry', 0;
+
+delete from audit_log;
+
+-- Test 1: INSERT ... RETURNING as table source
+SELECT new_user.id, new_user.name, 'created' as status
+FROM (
+    INSERT INTO users (id, name, email)
+    VALUES (4, 'David', 'david@example.com')
+    RETURNING id, name
+) AS new_user;
+→ [{ "id": 4, "name": "David", "status": "created" }]
+
+-- Verify the INSERT actually happened
+SELECT name FROM users WHERE id = 4;
+→ [{ "name": "David" }]
+
+-- Test 2: UPDATE ... RETURNING as table source
+SELECT updated.id, updated.name, updated.email, 'modified' as status
+FROM (
+    UPDATE users
+    SET email = 'alice.updated@example.com'
+    WHERE name = 'Alice'
+    RETURNING id, name, email
+) AS updated;
+→ [{ "id": 1, "name": "Alice", "email": "alice.updated@example.com", "status": "modified" }]
+
+-- Verify the UPDATE actually happened
+SELECT email FROM users WHERE name = 'Alice';
+→ [{ "email": "alice.updated@example.com" }]
+
+-- Test 3: DELETE ... RETURNING as table source
+SELECT deleted.id, deleted.name, 'removed' as status
+FROM (
+    DELETE FROM users
+    WHERE name = 'Charlie'
+    RETURNING id, name
+) AS deleted;
+→ [{ "id": 3, "name": "Charlie", "status": "removed" }]
+
+-- Verify the DELETE actually happened
+SELECT count(*) as remaining FROM users WHERE name = 'Charlie';
+→ [{ "remaining": 0 }]
+
+-- Test 4: INSERT from mutating subquery (full orthogonality)
+INSERT INTO audit_log (id, action, user_id)
+SELECT 2, 'user_created', new_user.id
+FROM (
+    INSERT INTO users (id, name, email)
+    VALUES (5, 'Eve', 'eve@example.com')
+    RETURNING id
+) AS new_user;
+
+-- Verify both the INSERT and the audit log
+SELECT name FROM users WHERE id = 5;
+→ [{ "name": "Eve" }]
+
+SELECT action, user_id FROM audit_log WHERE action = 'user_created';
+→ [{ "action": "user_created", "user_id": 5 }]
+
+-- Test 5: JOIN with mutating subquery
+-- TODO: replace this with like operator when that's implemented.
+SELECT u.name, updated.email as new_email
+FROM users u
+JOIN (
+    UPDATE users
+    SET email = name || '@company.com'
+    WHERE like('%@example.com', email)
+    RETURNING id, email
+) AS updated ON u.id = updated.id;
+→ [{ "name": "Alice", "new_email": "Alice@company.com" }, { "name": "Bob", "new_email": "Bob@company.com" }, { "name": "David", "new_email": "David@company.com" }, { "name": "Eve", "new_email": "Eve@company.com" }]
+
+-- Test 6: Multiple column aliases in mutating subquery
+SELECT u.user_id, u.user_name, u.user_email
+FROM (
+    INSERT INTO users (id, name, email)
+    VALUES (6, 'Frank', 'frank@example.com')
+    RETURNING id, name, email
+) AS u(user_id, user_name, user_email);
+→ [{ "user_id": 6, "user_name": "Frank", "user_email": "frank@example.com" }]
+
+-- Test 6b: Mutating subquery with qualified SELECT *
+SELECT r.* FROM (
+    INSERT INTO users (id, name, email)
+    VALUES (60, 'Qualified', 'qualified@example.com')
+    RETURNING id, name
+) AS r;
+→ [{ "id": 60, "name": "Qualified" }]
+
+DELETE FROM users WHERE id = 60;
+
+-- Test 7: Nested mutating subqueries (complex orthogonality)
+SELECT outer_result.total_created
+FROM (
+    SELECT count(*) as total_created
+    FROM (
+        INSERT INTO users (id, name, email)
+        VALUES (7, 'Grace', 'grace@example.com')
+        RETURNING id
+    ) AS inner_insert
+) AS outer_result;
+→ [{ "total_created": 1 }]
+
+-- Test 8: Error case - mutating subquery without RETURNING
+-- This should fail at parse/plan time
+SELECT * FROM (
+    INSERT INTO users (id, name, email)
+    VALUES (8, 'Invalid', 'invalid@example.com')
+) AS invalid_subquery;
+-- error: must have a RETURNING clause
+
+-- Cleanup
+DROP TABLE audit_log;
+DROP TABLE users;

package/test/logic/44.1-nondeterministic-schema.sqllogic

@@ -0,0 +1,316 @@
+-- 44.1-nondeterministic-schema.sqllogic
+-- Exercise the `nondeterministic_schema` database option / PRAGMA: it relaxes
+-- the static prohibition on non-deterministic expressions in DEFAULT, CHECK,
+-- and GENERATED ALWAYS AS clauses. Capture is at the resolved-row frontier
+-- in vtab.update(); replay applies primitives at the module-layer boundary.
+
+-- ===================================
+-- Pragma roundtrip + default value
+-- ===================================
+
+-- Defaults to false (strict rejection — matches 44-determinism-validation).
+PRAGMA nondeterministic_schema;
+→ [{"name":"nondeterministic_schema","value":false}]
+
+-- ===================================
+-- Strict mode (default): rejection paths unchanged
+-- ===================================
+
+CREATE TABLE strict_default (
+    id INTEGER PRIMARY KEY,
+    value INTEGER DEFAULT random()
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+CREATE TABLE strict_check (
+    id INTEGER PRIMARY KEY,
+    value INTEGER CHECK (random() > 0)
+);
+-- error: Non-deterministic expression not allowed in CHECK
+
+-- GENERATED column determinism is validated at CREATE TABLE time, same as
+-- DEFAULT and CHECK — the table is never created.
+CREATE TABLE strict_generated (
+    id INTEGER PRIMARY KEY,
+    v INTEGER,
+    g INTEGER GENERATED ALWAYS AS (random()) STORED
+);
+-- error: Non-deterministic expression not allowed in GENERATED ALWAYS AS
+
+DROP TABLE strict_generated;
+-- error: not found in schema
+
+-- ===================================
+-- Flip the gate and read it back
+-- ===================================
+
+PRAGMA nondeterministic_schema = true;
+
+PRAGMA nondeterministic_schema;
+→ [{"name":"nondeterministic_schema","value":true}]
+
+-- Alias also resolves to the same underlying value (the pragma echoes the
+-- name as written, but the value reflects the canonical option).
+PRAGMA allow_nondeterministic_schema_expressions;
+→ [{"name":"allow_nondeterministic_schema_expressions","value":true}]
+
+-- ===================================
+-- Relaxed mode: DEFAULT random()
+-- ===================================
+
+-- CREATE TABLE no longer rejects. Per-row capture resolves the default into a
+-- literal at INSERT time, so the row stored in the table is fully concrete.
+CREATE TABLE relaxed_default (
+    id INTEGER PRIMARY KEY,
+    rnd INTEGER DEFAULT random()
+);
+
+INSERT INTO relaxed_default (id) VALUES (1);
+INSERT INTO relaxed_default (id) VALUES (2);
+INSERT INTO relaxed_default (id) VALUES (3);
+
+-- Three rows landed; each row's rnd column is concrete (non-null) because the
+-- default fired per row.
+SELECT COUNT(*) AS n, COUNT(rnd) AS non_null_rnd FROM relaxed_default;
+→ [{"n":3,"non_null_rnd":3}]
+
+-- Distinct PKs is independent of the relaxation, but verify the relaxed DEFAULT
+-- doesn't break the regular INSERT path.
+SELECT id FROM relaxed_default ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+DROP TABLE relaxed_default;
+
+-- ===================================
+-- Relaxed mode: DEFAULT datetime('now')
+-- ===================================
+
+CREATE TABLE relaxed_default_now (
+    id INTEGER PRIMARY KEY,
+    ts TEXT DEFAULT datetime('now')
+);
+
+INSERT INTO relaxed_default_now (id) VALUES (1);
+
+-- Captured timestamp is a real string (not null, not the literal "datetime").
+SELECT COUNT(*) AS n, COUNT(ts) AS non_null_ts FROM relaxed_default_now;
+→ [{"n":1,"non_null_ts":1}]
+
+SELECT id FROM relaxed_default_now WHERE ts >= '2020-01-01';
+→ [{"id":1}]
+
+DROP TABLE relaxed_default_now;
+
+-- ===================================
+-- Relaxed mode: immediate CHECK using datetime('now') predicate
+-- This avoids probabilistic flakiness while still exercising the relaxed gate
+-- (the strict validator would reject this CREATE TABLE).
+-- ===================================
+
+CREATE TABLE relaxed_check (
+    id INTEGER PRIMARY KEY,
+    note TEXT,
+    CONSTRAINT after_epoch CHECK (datetime('now') >= '2020-01-01')
+);
+
+INSERT INTO relaxed_check VALUES (1, 'first');
+INSERT INTO relaxed_check VALUES (2, 'second');
+
+SELECT COUNT(*) FROM relaxed_check;
+→ [{"count(*)":2}]
+
+DROP TABLE relaxed_check;
+
+-- ===================================
+-- Relaxed mode: CHECK with random() — pure non-det in a row CHECK
+-- random() returns a BigInt in [MIN_SAFE_INT, MAX_SAFE_INT]; "random() IS NOT NULL"
+-- always passes, so this exercises the relaxed-gate path without probabilistic
+-- flakiness.
+-- ===================================
+
+CREATE TABLE relaxed_check_random (
+    id INTEGER PRIMARY KEY,
+    v INTEGER,
+    CONSTRAINT rnd_nonnull CHECK (random() IS NOT NULL)
+);
+
+INSERT INTO relaxed_check_random VALUES (1, 100);
+INSERT INTO relaxed_check_random VALUES (2, 200);
+
+SELECT COUNT(*) FROM relaxed_check_random;
+→ [{"count(*)":2}]
+
+DROP TABLE relaxed_check_random;
+
+-- ===================================
+-- Relaxed mode: stored GENERATED ALWAYS AS (random())
+-- The expression is evaluated per row before the module write; the resolved
+-- value is captured.
+-- ===================================
+
+CREATE TABLE relaxed_generated (
+    id INTEGER PRIMARY KEY,
+    payload TEXT,
+    g INTEGER GENERATED ALWAYS AS (random()) STORED
+);
+
+INSERT INTO relaxed_generated (id, payload) VALUES (1, 'a');
+INSERT INTO relaxed_generated (id, payload) VALUES (2, 'b');
+
+-- The generated column is materialised with a concrete value per row.
+SELECT COUNT(*) AS n, COUNT(g) AS non_null_g FROM relaxed_generated;
+→ [{"n":2,"non_null_g":2}]
+
+DROP TABLE relaxed_generated;
+
+-- ===================================
+-- Relaxed mode: deferred CHECK via CREATE ASSERTION with non-det
+-- The assertion evaluates once at COMMIT; non-determinism in the body is
+-- replay-safe by transaction atomicity (commit-or-rollback is decided once,
+-- replay applies the module-layer writes).
+-- ===================================
+
+CREATE TABLE assertion_target (id INTEGER PRIMARY KEY, val INTEGER);
+
+CREATE ASSERTION rnd_assertion CHECK (random() IS NOT NULL);
+
+BEGIN;
+INSERT INTO assertion_target VALUES (1, 10);
+COMMIT;
+
+SELECT id, val FROM assertion_target;
+→ [{"id":1,"val":10}]
+
+DROP ASSERTION rnd_assertion;
+
+DROP TABLE assertion_target;
+
+-- ===================================
+-- Pragma scope: turning the gate OFF after creating a relaxed table leaves the
+-- table's schema in place. Validation is re-evaluated at DML build time, so
+-- INSERTs into a table whose stored expressions are non-deterministic require
+-- the gate to be on at the time of compilation; flipping the gate back ON
+-- restores INSERT compilability without re-creating the table.
+-- ===================================
+
+CREATE TABLE keeper (
+    id INTEGER PRIMARY KEY,
+    rnd INTEGER DEFAULT random()
+);
+
+INSERT INTO keeper (id) VALUES (10);
+
+PRAGMA nondeterministic_schema = false;
+
+PRAGMA nondeterministic_schema;
+→ [{"name":"nondeterministic_schema","value":false}]
+
+-- New DDL with non-det is rejected again.
+CREATE TABLE strict_after (
+    id INTEGER PRIMARY KEY,
+    value INTEGER DEFAULT random()
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Existing table's schema is intact (rows already in the table read back fine —
+-- the read path doesn't re-validate stored expressions).
+SELECT COUNT(*) AS n, COUNT(rnd) AS non_null_rnd FROM keeper;
+→ [{"n":1,"non_null_rnd":1}]
+
+-- An INSERT that doesn't fire the non-deterministic DEFAULT (because the
+-- column is supplied explicitly) compiles even under strict mode.
+INSERT INTO keeper (id, rnd) VALUES (11, 99);
+SELECT id, rnd FROM keeper WHERE id = 11;
+→ [{"id":11,"rnd":99}]
+
+-- But an INSERT that *would* fire the DEFAULT re-evaluates determinism against
+-- the current pragma value and is rejected.
+INSERT INTO keeper (id) VALUES (12);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Flipping the gate back on restores INSERT compilability without touching
+-- the table.
+PRAGMA nondeterministic_schema = true;
+
+INSERT INTO keeper (id) VALUES (13);
+SELECT COUNT(*) AS n, COUNT(rnd) AS non_null_rnd FROM keeper;
+→ [{"n":3,"non_null_rnd":3}]
+
+DROP TABLE keeper;
+
+-- ===================================
+-- Scope-check pre-walks remain active even under relaxed mode. Bind parameters
+-- and bare column references in DEFAULT, and bind parameters in CHECK, are
+-- still rejected at CREATE TABLE time regardless of the pragma — these are
+-- scope checks, not determinism checks.
+-- ===================================
+
+PRAGMA nondeterministic_schema = true;
+
+CREATE TABLE relaxed_default_bindparam (
+    id INTEGER PRIMARY KEY,
+    v INTEGER DEFAULT (?)
+);
+-- error: may not reference bind parameters
+
+CREATE TABLE relaxed_default_colref (
+    id INTEGER PRIMARY KEY,
+    a INTEGER,
+    b INTEGER DEFAULT (a)
+);
+-- error: may not reference a bare column
+
+CREATE TABLE relaxed_check_bindparam (
+    id INTEGER PRIMARY KEY,
+    v INTEGER,
+    CHECK (v > ?)
+);
+-- error: may not reference bind parameters
+
+PRAGMA nondeterministic_schema = false;
+
+-- ===================================
+-- new.<column> DEFAULT determinism: the DDL build/determinism check is deferred
+-- to INSERT time (the row scope isn't available at CREATE TABLE), so the
+-- determinism gate is re-evaluated when the row is expanded. A pure `new.<col>`
+-- reference is deterministic; wrapping it around a non-deterministic function is
+-- not — and must be rejected under strict mode but allowed under the relaxed gate.
+-- ===================================
+
+-- Strict mode: a pure new.<col> default is deterministic and inserts cleanly.
+CREATE TABLE newref_det (
+    id INTEGER PRIMARY KEY,
+    x INTEGER,
+    y INTEGER DEFAULT (new.x + 1)
+);
+INSERT INTO newref_det (id, x) VALUES (1, 5);
+SELECT y FROM newref_det WHERE id = 1;
+→ [{"y":6}]
+DROP TABLE newref_det;
+
+-- Strict mode: new.<col> combined with a non-deterministic function is rejected
+-- at INSERT time (the deferred determinism check fires when the default fires).
+CREATE TABLE newref_nondet (
+    id INTEGER PRIMARY KEY,
+    x INTEGER,
+    y INTEGER DEFAULT (new.x + random())
+);
+INSERT INTO newref_nondet (id, x) VALUES (1, 5);
+-- error: Non-deterministic expression not allowed in DEFAULT
+DROP TABLE newref_nondet;
+
+-- Relaxed mode: the same non-deterministic new.<col> default is permitted; the
+-- value is resolved into a concrete literal per row.
+PRAGMA nondeterministic_schema = true;
+
+CREATE TABLE newref_relaxed (
+    id INTEGER PRIMARY KEY,
+    x INTEGER,
+    y INTEGER DEFAULT (new.x + random())
+);
+INSERT INTO newref_relaxed (id, x) VALUES (1, 5);
+SELECT COUNT(*) AS n, COUNT(y) AS non_null_y FROM newref_relaxed;
+→ [{"n":1,"non_null_y":1}]
+DROP TABLE newref_relaxed;
+
+PRAGMA nondeterministic_schema = false;

package/test/logic/45-udf-determinism.sqllogic

@@ -0,0 +1,39 @@
+-- UDF Determinism Tests
+-- Tests that user-defined functions properly declare and propagate determinism
+
+-- Test 1: Non-deterministic UDF in DEFAULT should fail
+-- (This test would require programmatic UDF registration, so we'll skip it for now)
+
+-- Test 2: Verify built-in non-deterministic functions are rejected
+CREATE TABLE t1 (
+    id INTEGER PRIMARY KEY,
+    created_at TEXT DEFAULT datetime('now')
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Test 3: Verify built-in deterministic functions are allowed
+CREATE TABLE t2 (
+    id INTEGER PRIMARY KEY,
+    upper_name TEXT DEFAULT upper('test')
+);
+
+INSERT INTO t2 (id) VALUES (1);
+SELECT * FROM t2;
+→ [{"id":1,"upper_name":"TEST"}]
+
+DROP TABLE t2;
+
+-- Test 4: Verify random() is rejected in DEFAULT
+CREATE TABLE t3 (
+    id INTEGER PRIMARY KEY,
+    random_val REAL DEFAULT random()
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+
+-- Test 5: Verify randomblob() is rejected in DEFAULT
+CREATE TABLE t4 (
+    id INTEGER PRIMARY KEY,
+    random_blob BLOB DEFAULT randomblob(16)
+);
+-- error: Non-deterministic expression not allowed in DEFAULT
+