## 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
BEGIN DEFERRED TRANSACTION;
ATTACH DATABASE ':memory:' AS aux73;
PRAGMA temp_store_directory;
CREATE TABLE T1 (
  A VARCHAR(-9223372036854775809) PRIMARY KEY,
  X VARCHAR(10) UNIQUE
);
CREATE TABLE main.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;
PRAGMA full_column_names = FALSE;
DETACH DATABASE aux73;
ALTER TABLE T RENAME TO T_r9982;
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 _m;

SELECT COUNT(*) FROM T2;
ANALYZE;
COMMIT;
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 T1 DEFAULT VALUES;
```

## Actual output

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

## Expectation

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

## Flag

```
-version
```