## 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
CREATE TABLE T (
  a INTEGER,
  b REAL
);
INSERT INTO T VALUES (-CAST(sqlite_compileoption_get('𝕊𝕢𝕝') AS NCHAR(55)),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;
.width
BEGIN EXCLUSIVE;
SAVEPOINT sp6033;
ATTACH DATABASE (':memory:' || '') AS aux49;
PRAGMA trusted_schema;
ATTACH DATABASE ':memory:' AS aux17;
PRAGMA count_changes = OFF;
ATTACH DATABASE ('' || '') || (':memory:') AS aux67;
.check
CREATE TABLE `T` (
  A VARCHAR(CAST(like(json_array(-trunc(json_quote('true'))), '') AS NUMERIC)) PRIMARY KEY,
  B VARCHAR(-(hex('') + unistr_quote(json_array_insert(9223372036854775807, '$.arr[0]', 9223372036854775807)) -> '$.a' -> '$.b')),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m /* .filectrl */ B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
DELETE FROM T WHERE NOT NOT (NOT NOT (0)) RETURNING *;
DELETE FROM T WHERE +A > (SELECT AVG(A) FROM T);
ANALYZE;
DROP TABLE IF EXISTS T;
SELECT * FROM (SELECT * FROM T) AS sub;
UPDATE T SET A = NULL WHERE A BETWEEN 0 OR 100 RETURNING *;
ANALYZE T;
DETACH DATABASE aux67;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
PRAGMA temp_store = '1';
PRAGMA temp_store = 'FILE';
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DROP TRIGGER IF EXISTS 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 COUNT(*) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE A = (SELECT MAX(A) FROM T WHERE A = (SELECT MAX(A) FROM T));
PRAGMA synchronous;
DETACH DATABASE aux17;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_1028 BEFORE UPDATE OF C ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA parser_trace = TRUE;
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM T WHERE C IN (SELECT x FROM cte);
UPDATE T SET c = json_object('k', c) WHERE c IS NOT NULL;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_8093 AS SELECT a FROM T;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM T
GROUP BY a;
VACUUM;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
ALTER TABLE T RENAME TO T_r2091;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA defer_foreign_keys = YES;
DROP TRIGGER IF EXISTS T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a BETWEEN 0 AND 100;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
CREATE  VIEW IF NOT EXISTS v_T_7910 AS SELECT a FROM T;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM a), c AS (SELECT b FROM b) SELECT * FROM c;
REINDEX;
REINDEX T;
VACUUM main;
ALTER TABLE T DROP COLUMN c;

SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE a < ALL (SELECT a FROM T);
SELECT * FROM T;
SELECT TOTAL(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
INSERT INTO T SELECT * FROM T;
ANALYZE T;
DETACH DATABASE aux49;
SELECT AVG(c) FROM T;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
ANALYZE T;
ROLLBACK TO sp6033;
RELEASE sp6033;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
SAVEPOINT sp6033;
ATTACH DATABASE ':memory:' AS aux49;
PRAGMA trusted_schema;
ATTACH DATABASE ':memory:' AS aux17;
PRAGMA count_changes = OFF;
ATTACH DATABASE ('' || '') || (':memory:') AS aux67;
.check
CREATE TABLE `T` (
  A VARCHAR(CAST(like(json_array(-trunc(json_quote('true'))), '') AS NUMERIC)) PRIMARY KEY,
  B VARCHAR(-(hex('') + unistr_quote(json_array_insert(9223372036854775807, '$.arr[0]', 9223372036854775807)) -> '$.a' -> '$.b')),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m /* .filectrl */ B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
DELETE FROM T WHERE NOT NOT (NOT NOT (0)) RETURNING *;
DELETE FROM T WHERE +A > (SELECT AVG(A) FROM T);
ANALYZE;
DROP TABLE IF EXISTS T;
SELECT * FROM (SELECT * FROM T) AS sub;
UPDATE T SET A = NULL WHERE A BETWEEN 0 AND 100 RETURNING *;
ANALYZE T;
DETACH DATABASE aux67;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
PRAGMA temp_store = '1';
PRAGMA temp_store = 'FILE';
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DROP TRIGGER IF EXISTS 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 COUNT(*) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE A = (SELECT MAX(A) FROM T WHERE A = (SELECT MAX(A) FROM T));
PRAGMA synchronous;
DETACH DATABASE aux17;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_1028 BEFORE UPDATE OF C ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA parser_trace = TRUE;
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM T WHERE C IN (SELECT x FROM cte);
UPDATE T SET c = json_object('k', c) WHERE c IS NOT NULL;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_8093 AS SELECT a FROM T;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM /* abc */ T
GROUP BY a;
VACUUM;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
ALTER TABLE T RENAME TO T_r2091;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA defer_foreign_keys = YES;
DROP TRIGGER IF EXISTS T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a BETWEEN 0 AND 100;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
CREATE  VIEW IF NOT EXISTS v_T_7910 AS SELECT a FROM T;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM a), c AS (SELECT b FROM b) SELECT * FROM c;
REINDEX;
REINDEX T;
VACUUM main;
ALTER TABLE T DROP COLUMN c;

SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE a < ALL (SELECT a FROM T);
SELECT * FROM T;
SELECT TOTAL(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
INSERT INTO T SELECT * FROM T;
ANALYZE T;
DETACH DATABASE aux49;
SELECT AVG(c) FROM T;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE T;
ROLLBACK TO sp6033;
RELEASE sp6033;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
SAVEPOINT sp6033;
ATTACH DATABASE ':memory:' AS aux49;
PRAGMA trusted_schema;
ATTACH DATABASE ':memory:' AS aux17;
PRAGMA count_changes = OFF;
ATTACH DATABASE ('' || '') || (':memory:') AS aux67;
.check
CREATE TABLE `T` (
  A VARCHAR(CAST(like(json_array(-trunc(json_quote('true'))), '') AS NUMERIC)) PRIMARY KEY,
  B VARCHAR(-(hex('') + unistr_quote(json_array_insert(9223372036854775807, '$.arr[0]', 9223372036854775807)) -> '$.a' -> '$.b')),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m /* .filectrl */ B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
DELETE FROM T WHERE NOT NOT (NOT NOT (0)) RETURNING *;
DELETE FROM T WHERE +A > (SELECT AVG(A) FROM T);
ANALYZE;
DROP TABLE IF EXISTS T;
SELECT * FROM (SELECT * FROM T) AS sub;
UPDATE T SET A = NULL WHERE A BETWEEN 0 AND 100 RETURNING *;
ANALYZE T;
DETACH DATABASE aux67;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
PRAGMA temp_store = '1';
PRAGMA temp_store = 'FILE';
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DROP TRIGGER IF EXISTS 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 COUNT(*) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE A = (SELECT MAX(A) FROM T WHERE A = (SELECT MAX(A) FROM T));
PRAGMA synchronous;
DETACH DATABASE aux17;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_1028 BEFORE UPDATE OF C ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA parser_trace = TRUE;
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM T WHERE C IN (SELECT x FROM cte);
UPDATE T SET c = json_object('k', c) WHERE c IS NOT NULL;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_8093 AS SELECT a FROM T;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM T
GROUP BY a;
VACUUM;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
ALTER TABLE T RENAME TO T_r2091;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA defer_foreign_keys = YES;
DROP TRIGGER IF EXISTS T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a BETWEEN 0 AND 100;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
CREATE  VIEW IF NOT EXISTS v_T_7910 AS SELECT a FROM T;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM a), c AS (SELECT b FROM b) SELECT * FROM c;
REINDEX;
REINDEX T;
VACUUM main;
ALTER TABLE T DROP COLUMN c;

SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE a < ALL (SELECT a FROM T);
SELECT * FROM T;
SELECT TOTAL(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
INSERT INTO T SELECT * FROM T;
ANALYZE T;
DETACH DATABASE aux49;
SELECT AVG(c) FROM T;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE T;
ROLLBACK TO sp6033;
RELEASE sp6033;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
SAVEPOINT sp6033;
ATTACH DATABASE ':memory:' AS aux49;
PRAGMA trusted_schema;
ATTACH DATABASE ':memory:' AS aux17;
PRAGMA count_changes = OFF;
ATTACH DATABASE ('' || '') || (':memory:') AS aux67;
.check
CREATE TABLE `T` (
  A VARCHAR(CAST(like(json_array(-trunc(json_quote('true'))), '') AS NUMERIC)) PRIMARY KEY,
  B VARCHAR(-(hex('') + unistr_quote(json_array_insert(9223372036854775807, '$.arr[0]', 9223372036854775807)) -> '$.a' -> '$.b')),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m /* .filectrl */ B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
DELETE FROM T WHERE NOT NOT (NOT NOT (0)) RETURNING *;
DELETE FROM T WHERE +A > (SELECT AVG(A) FROM T);
ANALYZE;
DROP TABLE IF EXISTS T;
SELECT * FROM (SELECT * FROM T) AS sub;
UPDATE T SET A = NULL WHERE A BETWEEN 0 AND 100 RETURNING *;
ANALYZE T;
DETACH DATABASE aux67;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
PRAGMA temp_store = '1';
PRAGMA temp_store = 'FILE';
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DROP TRIGGER IF EXISTS 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 COUNT(*) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE A = (SELECT MAX(A) FROM T WHERE A = (SELECT MAX(A) FROM T));
PRAGMA synchronous;
DETACH DATABASE aux17;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_1028 BEFORE UPDATE OF C ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA parser_trace = TRUE;
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM T WHERE C IN (SELECT x FROM cte);
UPDATE T SET c = json_object('k', c) WHERE c IS NOT NULL;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_8093 AS SELECT a FROM T;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM T
GROUP BY a;
VACUUM;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
ALTER TABLE T RENAME TO T_r2091;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA defer_foreign_keys = YES;
DROP TRIGGER IF EXISTS T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a BETWEEN 0 AND 100;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
CREATE  VIEW IF NOT EXISTS v_T_7910 AS SELECT a FROM T;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM a), c AS (SELECT b FROM b) SELECT * FROM c;
REINDEX;
REINDEX T;
VACUUM main;
ALTER TABLE T DROP COLUMN c;

SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE a < ALL (SELECT a FROM T);
SELECT * FROM T;
SELECT TOTAL(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
INSERT INTO T SELECT * FROM T;
ANALYZE T;
DETACH DATABASE aux49;
SELECT AVG(c) FROM T;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE T;
ROLLBACK TO sp6033;
RELEASE sp6033;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
SAVEPOINT sp6033;
ATTACH DATABASE ':memory:' AS aux49;
PRAGMA trusted_schema;
ATTACH DATABASE ':memory:' AS aux17;
PRAGMA count_changes = OFF;
ATTACH DATABASE ('' || '') || (':memory:') AS aux67;
.check
CREATE TABLE `T` (
  A VARCHAR(CAST(like(json_array(-trunc(json_quote('true'))), '') AS NUMERIC)) PRIMARY KEY,
  B VARCHAR(-(hex('') + unistr_quote(json_array_insert(9223372036854775807, '$.arr[0]', 9223372036854775807)) -> '$.a' -> '$.b')),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m /* .filectrl */ B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
DELETE FROM T WHERE NOT NOT (NOT NOT (0)) RETURNING *;
DELETE FROM T WHERE +A > (SELECT AVG(A) FROM T);
ANALYZE;
DROP TABLE IF EXISTS T;
SELECT * FROM (SELECT * FROM T) AS sub;
UPDATE T SET A = NULL WHERE A BETWEEN 0 AND 100 RETURNING *;
ANALYZE T;
DETACH DATABASE aux67;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T DEFAULT VALUES;
PRAGMA temp_store = '1';
PRAGMA temp_store = 'FILE';
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DROP TRIGGER IF EXISTS 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 COUNT(*) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE A = (SELECT MAX(A) FROM T WHERE A = (SELECT MAX(A) FROM T));
PRAGMA synchronous;
DETACH DATABASE aux17;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_1028 BEFORE UPDATE OF C ON T FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA parser_trace = TRUE;
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM T WHERE C IN (SELECT x FROM cte);
UPDATE T SET c = json_object('k', c) WHERE c IS NOT NULL;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_8093 AS SELECT a FROM T;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM T
GROUP BY a;
VACUUM;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
ALTER TABLE T RENAME TO T_r2091;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA defer_foreign_keys = YES;
DROP TRIGGER IF EXISTS T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a BETWEEN 0 AND 100;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
CREATE  VIEW IF NOT EXISTS v_T_7910 AS SELECT a FROM T;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM a), c AS (SELECT b FROM b) SELECT * FROM c;
REINDEX;
REINDEX T;
VACUUM main;
ALTER TABLE T DROP COLUMN c;

SELECT COUNT(*) FROM T;
SELECT * FROM T WHERE a < ALL (SELECT a FROM T);
SELECT * FROM T;
SELECT TOTAL(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
INSERT INTO T SELECT * FROM T;
ANALYZE T;
DETACH DATABASE aux49;
SELECT AVG(c) FROM T;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ANALYZE T;
ROLLBACK TO sp6033;
RELEASE sp6033;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;

INSERT INTO T DEFAULT VALUES;
INSERT INTO T VALUES (NULL, NULL, NULL);
ALTER TABLE T ADD COLUMN extra_534 NATIVE CHARACTER(70)NVARCHAR(100) COLLATE NOCASE;
END;
INSERT INTO T VALUES (NULL, NULL, NULL);

DROP INDEX IF EXISTS T;
SELECT NTILE(c) OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
VACUUM main;
ALTER TABLE T ADD COLUMN extra_1373 TINYINT COLLATE RTRIM;
ALTER TABLE T RENAME COLUMN a TO a_r6242;
SELECT * FROM T NATURAL JOIN T;
DELETE FROM T WHERE rowid = 54;
CREATE TABLE T1 (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE T2 (
  A VARCHAR(10) PRIMARY KEY,
  X VARCHAR(15) NOT NULL,
  C BIGINT,
  FOREIGN KEY (X) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('p', 'x');
INSERT INTO T1 VALUES ('q', 'y');
INSERT INTO T2 VALUES ('a', 'p', 9223372036854775807);
INSERT INTO T2 VALUES ('b', 'q', -9223372036854775808);
SELECT X, SUM(C) AS D, COUNT(*) AS E FROM T2 GROUP BY X;
WITH cte AS (SELECT a, COUNT(*) FROM T GROUP BY a) SELECT * FROM cte;
ALTER TABLE T RENAME TO T_r4410;
INSERT INTO T DEFAULT VALUES;
```

## Actual output

```sql
3|0.0

0|1.5

1
```

## Expectation

```sql
3|0.0

0|1.5

0
```

## Flag

```
-newline "

"
```

