## 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
.read commands.sql
CREATE TABLE T1 (
  a INTEGER,
  b REAL
);
CREATE TABLE T2 (
  a INTEGER,
  b REAL
);
INSERT INTO T1 VALUES (glob(NULL, sqlite_compileoption_used(('UNKNOWN_OPTION' || ''))),NULL);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
SAVEPOINT sp3726;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;

CREATE VIRTUAL TABLE t0 USING fts4("x", "y",	"z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;

CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;

CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
.check
PRAGMA synchronous = 'FULL';
.log stdout
BEGIN DEFERRED TRANSACTION;
SELECT (x'7933d886f723d94ae4daafa168938983' - substr(NULL, CAST((length('') - '|') AS DATE)))x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT timediff(NULL, -6750343002861710485)timediff(NULL, NULL) >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
COMMIT;
PRAGMA temp_store = 'MEMORY';
PRAGMA empty_result_callbacks = ON;
VACUUM;
VACUUM main;


ROLLBACK TO sp3726;
RELEASE sp3726;
PRAGMA secure_delete = 1;
VACUUM main;

SELECT COUNT(*) FROM T2;
CREATE  INDEX IF NOT EXISTS idx_T2_9064 ON T2(b) WHERE NOT NOT (b > 0) ;
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 T2;
SELECT COUNT(*) OVER (ORDER BY a) FROM T1;
DELETE FROM T1 WHERE 0;
INSERT INTO T1 VALUES (1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
UPDATE T1 SET a = NULL WHERE 1;
INSERT INTO T2 VALUES ('x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
INSERT OR ABORT INTO T2 VALUES (NULL, 'x');
DROP INDEX IF EXISTS T1;
UPDATE T2 SET a = '' WHERE rowid = 1;
SELECT * FROM T2;
INSERT INTO T2 DEFAULT VALUES;
INSERT INTO T2 SELECT * FROM T2;
```

## Actual output

```sql
SQLite version 3.39.0 2022-05-10 23:28:12
Enter ".help" for usage hints.
sqlite> 1
sqlite>    ...>    ...>    ...> sqlite>    ...>    ...>    ...> sqlite> sqlite> sqlite>    ...> sqlite> |
1|-1.0
2|Inf
sqlite> sqlite> sqlite> sqlite>
```

## Expectation

```sql
SQLite version 3.51.1 2025-11-28 17:28:25
Enter ".help" for usage hints.
sqlite> 1
sqlite> (x1...> (x1...> (x1...> sqlite> (x1...> (x1...> (x1...> sqlite> sqlite> sqlite>    ...> sqlite> |
1|-1.0
2|Inf
sqlite> sqlite> sqlite> sqlite>
```

## Flag

```
-interactive
```