## 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;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL,
  d REAL
);
INSERT INTO T VALUES (degrees(1),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
SAVEPOINT sp6556;
SAVEPOINT sp2146;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((-acos(40615069054709235) - 0),'a',1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE +c < 2.0 ORDER BY c;
SAVEPOINT sp4342;
SAVEPOINT sp879;
SAVEPOINT sp2139;
.log stderr
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(timediff(NULL, nan), '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE NOT NOT (+b < 2.0) ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
((SAVEPOINT)) sp6008;
-- PRAGMA pragma_list;

PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(CAST(instr(jsonb_set(10, '$.key', 10), NULL) AS FLOA) AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
CREATE TABLE T (
  A VARCHAR(20),
  B VARCHAR(10),
  PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
PRAGMA read_uncommitted = TRUE;
CREATE TABLE T (
  A VARCHAR(CAST(10 AS DOUB)) PRIMARY KEY,
  B VARCHAR(15) NOT NULL,
  C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
BEGIN DEFERRED;
PRAGMA data_version;
.import random-json.db main
PRAGMA auto_vacuum;
PRAGMA vdbe_listing = FALSE;
PRAGMA foreign_key_check("users");
.shell pwd
CREATE TABLE main.T (
  a INTEGER,
  b REAL,
  c REAL
);
INSERT INTO T VALUES (atan(jsonb_array(-(-(x'73eacfaf0efd9bcdbe694870')), 1, NULL)),1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE +b < 2.0 ORDER BY b;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT INTO T SELECT * FROM T;
END TRANSACTION;
INSERT INTO T DEFAULT VALUES;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_T_6592 AFTER DELETE ON T BEGIN SELECT RAISE(ABORT, 'abort'); END;
PRAGMA vdbe_addoptrace = 1;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_8755 DATETIME DEFAULT NULL;
ROLLBACK TRANSACTION TO SAVEPOINT sp6008;
RELEASE SAVEPOINT sp6008;
CREATE TRIGGER IF NOT EXISTS trg_T_3981 AFTER INSERT ON T BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT a FROM T UNION ALL SELECT a FROM (SELECT * FROM T) AS sub;
ALTER TABLE T DROP COLUMN c;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;

DELETE FROM T WHERE c > (SELECT AVG(c) FROM T) RETURNING *;
SELECT AVG(c) FROM T;
INSERT INTO T SELECT * FROM T;
UPDATE T SET a = CURRENT_TIMESTAMP WHERE a IS NOT NULL;
ALTER TABLE T DROP COLUMN b;
INSERT INTO T VALUES (NULL, NULL, NULL);
ALTER TABLE T RENAME COLUMN c TO c_r5354;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.a = T.a);
SELECT * FROM T;
RELEASE sp2139;
WITH cte AS (SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T WHERE a > 0)) SELECT * FROM cte;
ROLLBACK TRANSACTION TO SAVEPOINT sp879;
RELEASE SAVEPOINT sp879;
ROLLBACK TO sp4342;
RELEASE sp4342;

SELECT COUNT(*) FROM T;
PRAGMA stats;
ROLLBACK TO sp2146;
RELEASE sp2146;
ALTER TABLE T RENAME TO T_r8222;
ANALYZE T;
PRAGMA reverse_unordered_selects = NO;
ROLLBACK TO sp6556;
RELEASE sp6556;
INSERT INTO T SELECT * FROM T;
INSERT INTO T VALUES (NULL, NULL, NULL);
WITH cte AS (SELECT CASE WHEN a IS NULL THEN 0 ELSE a END AS val FROM T) SELECT * FROM cte;
SELECT MIN(c) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT SUM(b) FROM T;
ALTER TABLE T RENAME TO T_r8166;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
INSERT INTO T VALUES (NULL, NULL, NULL);

SELECT COUNT(*) FROM T;

SELECT COUNT(*) FROM T;
CREATE  VIEW IF NOT EXISTS v_T_6877 AS SELECT a FROM T;
ROLLBACK;
```

## 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
```