## 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 optimize(asinh(0)x00002);
.nullvalue 232327d3-536b-41de-a764-a6301986aeab
BEGIN DEFERRED TRANSACTION;
CREATE TABLE T (
  A VARCHAR(jsonb_group_array(10)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C INTEGER,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE NOT NOT (C BETWEEN -1000 AND 1000) ORDER BY C ASC;
SAVEPOINT sp3615;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (atan(1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
ATTACH DATABASE ':memory:' AS aux97;
.print
BEGIN DEFERRED TRANSACTION;
.print https://yewtu.be/watch?v==dQw4w9WgXcQ
PRAGMA cell_size_check = mod(CAST((sinh((-(1 -> '$.key' * 1) -> '' || ('$.key') + 0.0)) + 1) AS INT2), 1);
PRAGMA read_uncommitted = NO;
.limit COLUMN (-(-(sqlite_compileoption_get(-NULL))) - json_array(x'b7f3', NULL, json_quote(0)))
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension(('/nonexistent.so' || '')), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.[T2] (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO main.T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE, /**/ C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
PRAGMA freelist_count;
((SAVEPOINT)) sp8971;
PRAGMA busy_timeout = length(randomblob(max(load_extension('/nonexistent.so'), '	')));
-- trim('  hello  ')

PRAGMA trusted_schema;
((PRAGMA)) wal_checkpoint('RESTART');
.databases
SAVEPOINT sp1790;
CREATE TABLE T1 (
  A VARCHAR(concat(jsonb_extract((-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 10), '$.key'))) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C BIGINT
);
CREATE TABLE main.T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10),
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 RIGHT OUTER JOIN T1 ON T2.A = T1.A WHERE NOT T1.C > -1000000000000;
CREATE TABLE t1(x);
CREATE TABLE main.t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (json_array_length(json_extract(jsonb_remove(1, '$.key'), '$.key')) + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a NONE,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T LEFT JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SAVEPOINT sp1790;
CREATE TABLE t1(x);
CREATE TABLE t2(c);
CREATE TRIGGER r1 AFTER INSERT ON t2 BEGIN UPDATE t2 /**/ SET (c)=( EXISTS(SELECT (1 + 0.0) WHERE (WITH cte1(a) AS (SELECT 1 FROM t1 WHERE (SELECT 1 WHERE (WITH cte2(b) AS (VALUES(1))SELECT b FROM cte2)))SELECT a FROM cte1)) ); END;
ALTER TABLE t2 RENAME TO t3;
SELECT name FROM sqlite_schema WHERE sql LIKE '%t2%';
SELECT name FROM sqlite_schema WHERE sql LIKE '%t3%' ORDER BY name;
CREATE TRIGGER IF NOT EXISTS trg_t1_3653 BEFORE UPDATE OF x ON t1 BEGIN SELECT RAISE(ABORT, 'abort'); END;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
REINDEX;
ALTER TABLE t1 ADD COLUMN extra_8646 BIGINT DEFAULT CURRENT_TIMESTAMP;
SELECT COUNT(*) FROM t1;
SELECT MIN(x) FROM t1;
INSERT INTO t2 SELECT * FROM t2;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
ROLLBACK TO sp1790;
RELEASE sp1790;
ANALYZE t2;
SELECT * FROM t2 AS a FULL JOIN t1 AS b ON a.rowid = b.rowid;
ALTER TABLE t1 ADD COLUMN extra_9728 DOUBLE PRECISION DEFAULT (abs(random()) % 1000);
UPDATE t2 SET c = c + 1 WHERE 1;
ALTER TABLE t1 RENAME COLUMN x TO x_r1799;
SELECT TOTAL(a) FROM T;
SELECT AVG(b) FILTER (WHERE b != 0) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW OR UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
SELECT TOTAL(c) FROM t2;
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
CREATE  INDEX IF NOT EXISTS idx_t2_2459 ON t2(lower(c)) WHERE c > 0;
DELETE FROM t1 WHERE x IS NULL;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t2_3569 ON t2(c) WHERE c IS NOT NULL;
SELECT MAX(b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
INSERT INTO t2 VALUES (NULL);
CREATE  VIEW IF NOT EXISTS v_T_6364 AS SELECT a FROM T;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT MIN(C) OVER (ORDER BY C) FROM T1; /* -nullvalue "NU11" */ ALTER TABLE T RENAME TO T_r1908;
INSERT OR ROLLBACK INTO t1 VALUES ('');
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_1878 ON T1(A COLLATE NOCASE) WHERE A > 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 T2;
CREATE TRIGGER IF NOT EXISTS trg_T2_1934 AFTER UPDATE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT COUNT(*) FILTER (WHERE c IS NOT NULL), SUM(rowid) FILTER (WHERE c > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(c) FILTER (WHERE c > 0 AND c < 100), COUNT(*) FILTER (WHERE typeof(c) = "text") FROM t2;
SELECT * FROM T;
ANALYZE t1;
REINDEX t1;
INSERT OR FAIL INTO T2 VALUES (NULL, 0);
ANALYZE T2;
PRAGMA journal_mode = 'WAL';
SELECT * FROM T WHERE A IN (SELECT A FROM T WHERE A GLOB "*");
SELECT LAG(B, 2) OVER (ORDER BY B ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T1;
ALTER TABLE T ADD COLUMN extra_3883 INTEGER COLLATE NOCASE;
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 T1;
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
SELECT * FROM t1;
ANALYZE;
DELETE FROM T WHERE 0;
WITH cte(a, b) AS (SELECT C, C FROM T) SELECT a, b FROM cte;
ANALYZE t1;
WITH RECURSIVE cte AS (SELECT c FROM t2 UNION ALL SELECT c FROM cte LIMIT 1) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp8971;
RELEASE SAVEPOINT sp8971;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_7605 AS SELECT X FROM T2;
SELECT * FROM t2 AS a FULL OUTER JOIN t1 AS b ON a.rowid = b.rowid;
WITH RECURSIVE r AS (SELECT c FROM t2 WHERE c IS NOT NULL UNION ALL SELECT c FROM r WHERE c > 0 LIMIT 10) SELECT * FROM r;
SELECT * FROM T2 AS a FULL OUTER JOIN t2 AS b ON a.rowid = b.rowid;
PRAGMA parser_trace = 1;
WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<65) SELECT * FROM multi;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 DROP COLUMN c;
ALTER TABLE T1 RENAME COLUMN C TO C_r6393;
SELECT * FROM (SELECT * FROM T1 ORDER BY B) AS sub LIMIT 10;
SELECT COUNT(*) FILTER (WHERE C IS NOT NULL), SUM(rowid) FILTER (WHERE C > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(C) FILTER (WHERE C > 0 AND C < 100), COUNT(*) FILTER (WHERE typeof(C) = "text") FROM T1;
ANALYZE T1;
CREATE TRIGGER IF NOT EXISTS trg_T2_2507 AFTER INSERT ON T2 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
INSERT INTO T1 DEFAULT VALUES;
SELECT COUNT(*) FROM T1;
SELECT * FROM t1;
SELECT c FROM t2 INTERSECT SELECT c FROM (SELECT * FROM t2) AS sub;
SELECT COUNT(*) FROM t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8630 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
INSERT OR IGNORE INTO t2 VALUES (NULL);
SELECT * FROM T2 WHERE (X, X) IN (SELECT X, X FROM T2);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t2_6681 BEFORE DELETE ON t2 BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS T1;
VACUUM main;
ALTER TABLE T2 ADD COLUMN extra_7522 BIGINT DEFAULT CURRENT_TIMESTAMP;
CREATE TRIGGER IF NOT EXISTS trg_t2_6509 AFTER UPDATE OF c ON t2 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
UPDATE T1 SET A = A + 1 WHERE A BETWEEN 0 AND 100;
SELECT * FROM T2 WHERE X <= ANY (SELECT X FROM T2);
CREATE TRIGGER IF NOT EXISTS trg_T_3639 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
SELECT x, COUNT(*) FROM t1 GROUP BY x HAVING COUNT(*) > (SELECT COUNT(*) FROM t1 LIMIT 1);
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('æçå¤©ä½ æ¯æä¹äº');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
UPDATE T1 SET B = 'x';
ANALYZE T2;
ALTER TABLE T2 ADD COLUMN extra_4884 INT COLLATE NOCASE;
SELECT * FROM T2;
SELECT COUNT(*) FROM T1;
INSERT INTO t2 VALUES (NULL);
SELECT * FROM t2 AS a INNER JOIN T2 AS b ON a.rowid = b.rowid;
VACUUM;
INSERT INTO T DEFAULT VALUES;
COMMIT TRANSACTION;
INSERT OR REPLACE INTO T VALUES (4, 'x', 0);
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_7210 ON T1((B + 1)) WHERE B IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T1 VALUES ('x', NULL, 'x') ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
VACUUM main;
DETACH DATABASE aux97;
ALTER TABLE T1 DROP COLUMN B;
ANALYZE t1;
UPDATE t1 SET x = json_object('k', x) RETURNING *;
INSERT INTO t1 DEFAULT VALUES;

SELECT COUNT(*) FROM t1;
CREATE  VIEW IF NOT EXISTS v_t1_746 AS SELECT x FROM t1;
SELECT * FROM T;
INSERT INTO t1 DEFAULT VALUES;
ALTER TABLE T1 RENAME TO T1_r8380;
RELEASE sp3615;
DROP INDEX IF EXISTS t2;
SELECT * FROM T2 WHERE EXISTS (SELECT 1 FROM T2 t2 WHERE t2.X = T2.X);
WITH a AS (SELECT A FROM T1), b AS (SELECT A FROM a), c AS (SELECT A FROM b) SELECT * FROM c;
VACUUM main;
INSERT OR REPLACE INTO T1 VALUES ('', 9, 'x');
ALTER TABLE t2 DROP COLUMN c;
CREATE TEMP  VIEW IF NOT EXISTS v_t1_2570 AS SELECT x FROM t1;
COMMIT;
REINDEX;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_t1_1061 ON t1((x + 1)) WHERE x > 0;
ALTER TABLE t1 RENAME TO t1_r9986;
```

## Actual output

```sql
Usage: /home/test/sqlite3-src/build/sqlite3 [OPTIONS] FILENAME [SQL]
FILENAME is the name of an SQLite database. A new database is created
if the file does not previously exist.
OPTIONS include:
   -append              append the database to the end of the file
   -ascii               set output mode to 'ascii'
   -bail                stop after hitting an error
   -batch               force batch I/O
   -box                 set output mode to 'box'
   -column              set output mode to 'column'
   -cmd COMMAND         run "COMMAND" before reading stdin
   -csv                 set output mode to 'csv'
   -deserialize         open the database using sqlite3_deserialize()
   -echo                print commands before execution
   -init FILENAME       read/process named file
   -[no]header          turn headers on or off
   -help                show this message
   -html                set output mode to HTML
   -interactive         force interactive I/O
   -json                set output mode to 'json'
   -line                set output mode to 'line'
   -list                set output mode to 'list'
   -lookaside SIZE N    use N entries of SZ bytes for lookaside memory
   -markdown            set output mode to 'markdown'
   -maxsize N           maximum size for a --deserialize database
   -memtrace            trace all memory allocations and deallocations
   -mmap N              default mmap size set to N
   -newline SEP         set output row separator. Default: '\n'
   -nofollow            refuse to open symbolic links to database files
   -nonce STRING        set the safe-mode escape nonce
   -nullvalue TEXT      set text string for NULL values. Default ''
   -pagecache SIZE N    use N slots of SZ bytes each for page cache memory
   -quote               set output mode to 'quote'
   -readonly            open the database read-only
   -safe                enable safe-mode
   -separator SEP       set output column separator. Default: '|'
   -stats               print memory stats before each finalize
   -table               set output mode to 'table'
   -tabs                set output mode to 'tabs'
   -version             show SQLite version
   -vfs NAME            use NAME as the default VFS
```

## Expectation

```sql

```

## Flag

```
-help
```

