## 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
.schema !@#$%^&*()qwertyuiop[]\{}|asdfghjkl;':"zxcvbnm,./<>?
PRAGMA empty_result_callbacks;
ATTACH DATABASE ':memory:' AS aux68;
.vfsname
.exit
SAVEPOINT sp2072;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA vdbe_debug = NO;
.archive
ATTACH DATABASE ':memory:' AS aux4;
CREATE TABLE main.T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
INSERT INTO T VALUES (max(NULL, datetime(acos(datetime(likelihood(x'dea81ec9ae77', 0.0625), '+1 day')))),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m b FROM T WHERE NOT ABS(c) > 5 AND ABS(d) > 5;
SAVEPOINT sp7457;
.import employee.db main
.filectrl
PRAGMA fullfsync;
PRAGMA legacy_alter_table = TRUE;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-('' || ('') - x'87bf7bea')),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T gROup BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(2992705818220233921));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS
(SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
   PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
.echo on
SAVEPOINT sp1834;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA short_column_names = YES;
PRAGMA cache_spill = YES;
.stats on
BEGIN IMMEDIATE TRANSACTION;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(NULL),
  B VARCHAR(-1),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
CREATE TABLE T (
  A VARCHAR(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 C BETWEEN -1000 AND 1000 ORDER /**/ BY C ASC;
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x",	"y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
PRAGMA reverse_unordered_selects = TRUE;
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
SAVEPOINT sp7014;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = x'91aebb6f9ec19c9f8e1752';
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = json_object('k', json(4096));
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA recursive_triggers = YES;
PRAGMA page_size = 4096;
PRAGMA analysis_limit;
.import employee.db main
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
VACUUM;
ROLLBACK TRANSACTION TO SAVEPOINT sp7014;
RELEASE SAVEPOINT sp7014;
INSERT INTO T SELECT * FROM T;
SELECT SUM(B) FROM T;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_391 AS SELECT B FROM T;
WITH cte(x) AS (SELECT B FROM T) SELECT x FROM cte;
END TRANSACTION;
CREATE  INDEX IF NOT EXISTS idx_T_2869 ON T((B + 1)) WHERE NOT NOT (B > 0) ;
SELECT * FROM T LEFT JOIN T;
CREATE TABLE T (
  a MEDIUMINT,
  b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN b TO b_r1775;
DROP INDEX IF EXISTS T;
ALTER TABLE T RENAME COLUMN a TO a_r6691;
PRAGMA auto_vacuum = FULL;
SELECT LEAD(b, 2, b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;
COMMIT TRANSACTION;
ROLLBACK TO sp1834;
RELEASE sp1834;
SELECT MAX(a) FROM T;
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 T;
INSERT INTO T VALUES (NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
CREATE TEMP  VIEW IF NOT EXISTS v_T_6795 AS SELECT a FROM T;
CREATE  INDEX IF NOT EXISTS idx_T_8344 ON T(lower(a)) WHERE a > 0;
ANALYZE;
SELECT TOTAL(a) FROM T;
ALTER TABLE T RENAME TO T_r689;
ALTER TABLE T DROP COLUMN a;
PRAGMA cache_size = -2000;
CREATE  INDEX IF NOT EXISTS idx_T_3552 ON T(b COLLATE NOCASE) WHERE b IS NOT NULL;
VACUUM;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ROLLBACK TO sp7457;
RELEASE sp7457;
ANALYZE;
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;
ALTER TABLE T RENAME COLUMN b TO b_r9671;
DETACH DATABASE aux4;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_6714 AS SELECT a FROM T;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_3117 ON T(b COLLATE NOCASE);
INSERT INTO T VALUES ('x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;

SELECT COUNT(*) FROM T;
ALTER TABLE T RENAME TO T_r6686;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
REINDEX;
INSERT OR ROLLBACK INTO T VALUES (-5, 0);
REINDEX;
ALTER TABLE T RENAME TO T_r6094;
CREATE TRIGGER IF NOT EXISTS trg_T_2188 AFTER UPDATE OF b ON T FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT MAX(b) FROM T;
COMMIT TRANSACTION;
ANALYZE T;
ROLLBACK TO sp2072;
RELEASE sp2072;

SELECT COUNT(*) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T SELECT * FROM T;
CREATE  INDEX IF NOT EXISTS idx_T_4933 ON T((a + 1)) WHERE a IS NOT NULL;
WITH cte AS (SELECT b FROM T) SELECT * FROM cte WHERE b IS NOT NULL;
SELECT LAG(b, 2) OVER (PARTITION BY b ORDER BY b) FROM T;
INSERT INTO T VALUES (1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T) RETURNING *;
SELECT * FROM T;
ALTER TABLE T DROP COLUMN b;
SELECT * FROM T WHERE a <= ALL (SELECT a FROM T);
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 T;
DETACH DATABASE aux68;

SELECT COUNT(*) FROM T;
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 T;
WITH m AS MATERIALIZED (SELECT a FROM T) SELECT * FROM m;
PRAGMA short_column_names = 0;
ALTER TABLE T RENAME TO T_r9059;
```

## Actual output

```sql
0
```

## Expectation

```sql
Page cache size increased to 1296 to accommodate the 272-byte headers
0
```

## Flag

```
-pagecache 1024 5
```