## Summary
<!--Explain briefly what goes wrong and explain why you believe this is a bug and not the intended behavior of SQLite (if it is not a crash).-->**No review yet**

## Minimized query

```sql
((PRAGMA)) schema_version;
BEGIN DEFERRED;
PRAGMA temp_store_directory;
BEGIN EXCLUSIVE;
PRAGMA count_changes = TRUE;
PRAGMA automatic_index = ON;
CREATE TABLE "T" (
  a NATIVE CHARACTER(json_object('k1', CAST(jsonb(x'479ac13bb3f9da7a4c') AS NONE), 'k2', hex('hello')))NVARCHAR(100),
  b TEXT
);
INSERT INTO T VALUES (('' || ('a') || ''),'2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
  (julianday('now')-julianday(b))/randomblob('@')
  AS INTEGER
) AS c
FROM T;
BEGIN TRANSACTION;
BEGIN IMMEDIATE;
PRAGMA checkpoint_fullsync;
ATTACH DATABASE ((':memory:' || '') || '') AS aux82;
.import employee.db main
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(CAST(-'' AS TINYINT), (CAST(if(NULL, if(replace('%abc%', sign('10'), (jsonb_array((x'' + strftime('%s', 0))) - 0)), 2.718281828459045, 1/0), 1, 0) AS INT) + 1), 1);
INSERT INTO abc WITH _m AS MATERIALIZED (SELECT * FROM abc) SELECT a+(select max(a) FROM _m), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE NOT NOT (NOT a = NULL AND b >= upper.c)) FROM abc AS upper) ;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc main.t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
SELECT * FROM abc;
ALTER TABLE abc RENAME TO abc_r2235;
ANALYZE abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_9872 AFTER INSERT ON abc BEGIN SELECT RAISE(ABORT, 'abort'); END;
ALTER TABLE abc RENAME COLUMN c TO c_r7012;
UPDATE abc SET b = NULL WHERE rowid = 1;
VACUUM;
UPDATE abc SET a = NULL WHERE a IS NOT NULL;
SELECT * FROM abc AS a LEFT JOIN abc AS b ON a.rowid = b.rowid;
INSERT INTO abc SELECT * FROM abc;
SELECT COUNT(*) FROM abc;
CREATE  VIEW IF NOT EXISTS v_abc_836 AS SELECT c FROM abc;
PRAGMA checkpoint_fullsync;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(CAST(-'' AS TINYINT), (CAST(if(0, 0, 1, 0) AS INT) + 1), 1);
INSERT INTO abc WITH _m AS MATERIALIZED (SELECT * FROM abc) SELECT a+(select max(a) FROM _m), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
CREATE TABLE T (
  a TEXT,
  b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
SELECT * FROM abc;
ALTER TABLE abc RENAME TO abc_r2235;
ANALYZE abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_9872 AFTER INSERT ON abc BEGIN SELECT RAISE(ABORT, 'abort'); END;
ALTER TABLE abc RENAME COLUMN c TO c_r7012;
UPDATE abc SET b = NULL WHERE rowid = 1;
VACUUM;
UPDATE abc SET a = NULL WHERE a IS NOT NULL;
SELECT * FROM abc AS a LEFT JOIN abc AS b ON a.rowid = b.rowid;
INSERT INTO abc SELECT * FROM abc;
SELECT COUNT(*) FROM abc;
CREATE  VIEW IF NOT EXISTS v_abc_836 AS SELECT c FROM abc;
PRAGMA checkpoint_fullsync;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(CAST(-'' AS TINYINT), (CAST(if(0, 0, 1, 0) AS INT) + 1), 1);
INSERT INTO abc WITH _m AS MATERIALIZED (SELECT * FROM abc) SELECT a+(select max(a) FROM _m), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
SELECT * FROM abc;
ALTER TABLE abc RENAME TO abc_r2235;
ANALYZE abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_9872 AFTER INSERT ON abc BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T1 (
  A VARCHAR(20),
  X VARCHAR(10),
  PRIMARY KEY (A, X),
  UNIQUE (X)
);
CREATE TABLE T2 (
  A VARCHAR(20),
  Y VARCHAR(10) UNIQUE,
  PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
ALTER TABLE abc RENAME COLUMN c TO c_r7012;
UPDATE abc SET b = NULL WHERE rowid = 1;
VACUUM;
UPDATE abc SET a = NULL WHERE a IS NOT NULL;
SELECT * FROM abc AS a LEFT JOIN abc AS b ON a.rowid = b.rowid;
INSERT INTO abc SELECT * FROM abc;
SELECT COUNT(*) FROM abc;
CREATE  VIEW IF NOT EXISTS v_abc_836 AS SELECT c FROM abc;
PRAGMA checkpoint_fullsync;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(CAST(-'' AS TINYINT), (CAST(if(0, 0, 1, 0) AS INT) + 1), 1);
INSERT INTO abc WITH _m AS MATERIALIZED (SELECT * FROM abc) SELECT a+(select max(a) FROM _m), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, /**/ NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
SELECT * FROM abc;
ALTER TABLE  abc RENAME TO abc_r2235;
ANALYZE abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_9872 AFTER INSERT ON abc BEGIN SELECT RAISE(ABORT, 'abort'); END;
ALTER TABLE abc RENAME COLUMN c TO c_r7012;
UPDATE abc SET b = NULL WHERE rowid = 1;
VACUUM;
UPDATE abc SET a = NULL WHERE a IS NOT NULL;
SELECT * FROM abc AS a LEFT JOIN abc AS b ON a.rowid = b.rowid;
INSERT INTO abc SELECT * FROM abc;
SELECT COUNT(*) FROM abc;
CREATE  VIEW IF NOT EXISTS v_abc_836 AS SELECT c FROM abc;
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE b < 2.0 ORDER BY b;
PRAGMA checkpoint_fullsync;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(CAST(-'' AS TINYINT), (CAST(if(0, 0, 1, 0) AS INT) + 1), 1);
INSERT INTO abc WITH _m AS MATERIALIZED (SELECT * FROM abc) SELECT a+(select max(a) FROM _m), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
ATTACH DATABASE ':memory:' AS aux82;
.import employee.db main
BEGIN;
create TABLE abc(a, b, c, PRIMARY KEY(a, b));
INSERT INTO abc  VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE a = NULL OR b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
SELECT * FROM abc WHERE NOT EXISTS (SELECT 1 FROM abc t2 WHERE t2.c = abc.c);
REINDEX /* json_array({v}, {v}) */ abc;
DETACH DATABASE aux82;
REINDEX;
SELECT * FROM abc;
ALTER TABLE abc RENAME TO abc_r2235;
ANALYZE abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_9872 AFTER INSERT ON abc BEGIN SELECT RAISE(ABORT, 'abort'); END;
ALTER TABLE abc RENAME COLUMN c TO c_r7012;
UPDATE abc SET b = NULL WHERE rowid = 1;
VACUUM;
UPDATE abc SET a = NULL WHERE a IS NOT NULL;
SELECT * FROM abc AS a LEFT JOIN abc AS b ON a.rowid = b.rowid;
INSERT INTO abc SELECT * FROM abc;
SELECT COUNT(*) FROM abc;
CREATE  VIEW IF NOT EXISTS v_abc_836 AS SELECT c FROM abc;
COMMIT;
SELECT AVG(a) FROM abc;
SELECT * FROM abc WHERE EXISTS (SELECT 1 FROM abc WHERE 1 = 0);
SELECT COUNT(*) FROM abc;
SELECT b FROM abc WHERE b = (SELECT MAX(b) FROM abc);
INSERT INTO abc VALUES (NULL, NULL, NULL);
PRAGMA parser_trace = OFF;
INSERT INTO abc SELECT * FROM abc;
INSERT INTO abc VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
SELECT LAG(c, 0, 'default') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM abc;
CREATE TRIGGER IF NOT EXISTS trg_abc_8553 AFTER DELETE ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
ALTER TABLE abc ADD COLUMN extra_9687 NUMERIC COLLATE RTRIM;
INSERT INTO abc SELECT * FROM abc;
SELECT * FROM abc AS a LEFT OUTER JOIN abc AS b ON a.rowid = b.rowid;
CREATE TRIGGER IF NOT EXISTS trg_T_3547 AFTER UPDATE ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
SELECT AVG(a) OVER (ORDER BY a GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
DELETE FROM T WHERE 0;
SELECT COUNT(*) FILTER (WHERE a IS NOT NULL), SUM(rowid) FILTER (WHERE a > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(a) FILTER (WHERE a > 0 AND a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
COMMIT;
REINDEX;
ALTER TABLE T DROP COLUMN b;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_8574 ON T(b COLLATE NOCASE) WHERE b IS NOT NULL;
ALTER TABLE T RENAME COLUMN b TO b_r9656;
SELECT * FROM T;
INSERT INTO T VALUES (NULL, NULL, NULL);
DELETE FROM abc WHERE a IS NULL;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT SUM(a) FROM T;
CREATE  INDEX IF NOT EXISTS idx_T_442 ON T(a COLLATE NOCASE) WHERE a > 0;
SELECT * /* PRAGMA recursive_triggers = NO; */ FROM abc;
ALTER TABLE T DROP COLUMN a;
ALTER TABLE T1 DROP COLUMN A;
VACUUM main;
ANALYZE;
ALTER TABLE T ADD COLUMN extra_444 CHAR(10) UNIQUE;
CREATE  INDEX IF NOT EXISTS idx_T2_3366 ON T2(Y COLLATE NOCASE) WHERE Y > 0;
INSERT INTO abc VALUES (NULL, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
VACUUM;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
SELECT ROW_NUMBER() OVER (PARTITION BY a ORDER BY a ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM abc;
ALTER TABLE abc RENAME TO abc_r9419;
VACUUM;
SELECT * FROM T1 AS a JOIN abc AS b ON a.rowid = b.rowid;

PRAGMA defer_foreign_keys = 0;
SELECT * FROM T1;
CREATE  INDEX IF NOT EXISTS idx_abc_663 ON abc(c COLLATE NOCASE) WHERE c IS NOT NULL;
CREATE TRIGGER IF NOT EXISTS trg_T1_472 AFTER UPDATE ON T1 BEGIN SELECT RAISE(FAIL, 'no'); END;
SELECT COUNT(*) FILTER (WHERE b IS NOT NULL), SUM(rowid) FILTER (WHERE b > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(b) FILTER (WHERE b > 0 AND b < 100), COUNT(*) FILTER (WHERE typeof(b) = "text") FROM abc;
ALTER TABLE T1 ADD COLUMN extra_4229 INT NOT NULL DEFAULT 0;
SELECT * FROM abc AS a FULL OUTER JOIN T2 AS b ON a.rowid = b.rowid;
WITH cte1 AS (SELECT * FROM abc), cte2 AS (SELECT * FROM abc) SELECT * FROM cte1 LEFT JOIN cte2 ON cte1.b = cte2.b;
WITH a AS (SELECT * FROM T), RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<16) SELECT * FROM a CROSS JOIN cnt;
COMMIT;
SELECT * FROM T1 AS a INNER JOIN abc AS b ON a.rowid = b.rowid;
ANALYZE;
INSERT OR REPLACE INTO abc VALUES (6, NULL, '');
DELETE FROM T1 WHERE 1;
ALTER TABLE T2 ADD COLUMN extra_6566 INT DEFAULT (abs(random()) % 1000);
COMMIT;
SELECT MAX(Y) FROM T2;
ALTER TABLE T ADD COLUMN extra_1103 CLOB NOT NULL DEFAULT 0;
INSERT INTO abc SELECT * FROM abc;
ALTER TABLE T2 RENAME COLUMN Y TO Y_r7637;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(30),
  C VARCHAR(30),
  PRIMARY KEY (A, B),
  UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
REINDEX;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_abc_2457 ON abc(c) WHERE c > 0;
SELECT * FROM T1 WHERE (A) IN (SELECT A FROM T1);
DROP TRIGGER IF EXISTS T1;
```

## Actual output

```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```

## Expectation

```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```

## Flag

```
-version
```