## 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 temp_store_directory;
CREATE TABLE T1 (
  A VARCHAR(20) PRIMARY KEY,
  X VARCHAR(10) UNIQUE
);
CREATE TABLE T2 (
  A VARCHAR(20) PRIMARY KEY,
  Y VARCHAR(10) UNIQUE
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
INSERT INTO T2 VALUES ('c', 'l');
SELECT A FROM T1 INTERSECT SELECT A FROM T2;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (datetime(1.7976931348623157e+308, '+1 day') + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T RIGHT JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE "T1" (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (0 + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (0 + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (0 + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (0 + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;
.parameter
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
-- .clone

INSERT INTO T VALUES ((if(NULL, (0 + 0)) + 1),'' || ('a'),40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE NOT NOT (NOT ABS(c) > 5 AND ABS(d) > 5) ;
PRAGMA optimize;
PRAGMA read_uncommitted = ON;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime(('%s' || ''), unixepoch(x'd2778de55190649f19')) * (atan2(printf('%d', '+'), unlikely(-(-(0)))) + 1)),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
  SELECT *,1 FROM T WHERE NOT NOT (c IS NULL
  UNION ALL
  SELECT T.a,T.b,T.c,d.e+1
  FROM T JOIN /* PRAGMA query_only = OFF) ; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO	T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE _m (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN /**/ IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
BEGIN IMMEDIATE;
.quit
.echo on
BEGIN IMMEDIATE TRANSACTION;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c INTEGER
);
INSERT INTO T VALUES ((strftime('%s', unixepoch(1)) * 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 /* PRAGMA query_only = OFF; */ d ON T.c=d.a
)
SELECT * FROM d;
ROLLBACK;
SELECT /**/ COUNT(*) FROM T;
ANALYZE;
SELECT MAX(b) FROM T;
INSERT INTO T SELECT * FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK;
DELETE FROM T WHERE b > (SELECT AVG(b) FROM T);
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
SELECT NTH_VALUE(a, -1) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM T;
INSERT INTO T SELECT * FROM T;
SELECT RANK() OVER (ORDER BY c ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T;
ALTER TABLE T DROP COLUMN c;
SELECT * FROM T;
SELECT * FROM T;
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;
SELECT AVG(c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
DELETE FROM T WHERE 0;
ALTER TABLE T ADD COLUMN extra_9438 DECIMAL(10,5) COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN c TO c_r5491;
REINDEX T;
PRAGMA vdbe_debug = YES;
INSERT INTO T DEFAULT VALUES;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
VACUUM main;
ALTER TABLE T RENAME TO T_r5026;
PRAGMA writable_schema = RESET;
CREATE TRIGGER IF NOT EXISTS trg_T_944 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(a) VALUES (NULL); END;
SELECT SUM(c) FROM T;
PRAGMA defer_foreign_keys = OFF;
CREATE  INDEX IF NOT EXISTS idx_T_2801 ON T(a) WHERE a > 0;
DROP TRIGGER IF EXISTS T;
INSERT OR ABORT INTO T VALUES (2, 'x', NULL);
UPDATE T SET b = 'x' WHERE 1 RETURNING *;
SELECT * FROM T NATURAL JOIN T;
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 T;
SELECT * FROM T AS a INNER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE;
SELECT MAX(a) FROM T;
REINDEX T;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
WITH cte(a, b) AS (SELECT b, b FROM T2) SELECT a, b FROM cte;
SELECT * FROM T1;
SELECT NTILE(1) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _m;
ALTER TABLE _m RENAME COLUMN a TO a_r7255;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<92) SELECT * FROM tree;
ALTER TABLE _m RENAME COLUMN b TO b_r7607;
PRAGMA vdbe_trace = 0;
REINDEX;

INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T1_409 ON T1((a + 1)) WHERE a > 0;
SELECT * FROM _m;
INSERT INTO _m VALUES (NULL, NULL);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(30),
  C VARCHAR(30),
  PRIMARY KEY (A, B),
  UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
SELECT LEAD(b) OVER (PARTITION BY b ORDER BY b ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM _m;
SELECT ROW_NUMBER() OVER (ORDER BY b ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T1;
SELECT * FROM T1;
WITH RECURSIVE empty(x) AS (SELECT 1 WHERE 1=0 UNION ALL SELECT x+1 FROM empty WHERE x<10) SELECT * FROM empty;
SELECT * FROM T;
SELECT * FROM T2 WHERE (A) IN (SELECT A FROM T2);
PRAGMA empty_result_callbacks = OFF;
ALTER TABLE T ADD COLUMN extra_1154 NATIVE CHARACTER(70)NVARCHAR(100) COLLATE NOCASE;
```

## Actual output

```sql
b
c
.parameter CMD ...       Manage SQL parameter bindings
   clear                   Erase all bindings
   init                    Initialize the TEMP table that holds bindings
   list                    List the current parameter bindings
   set PARAMETER VALUE     Given SQL parameter PARAMETER a value of VALUE
                           PARAMETER should start with one of: $ : @ ?
   unset PARAMETER         Remove PARAMETER from the binding table
```

## Expectation

```sql

```

## Flag

```

```