ast-project/part1/results/1/bug_c5b8aff0-e68f-4979-909d-e8b4aad8e1af_logic.md

## 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
ATTACH DATABASE ':memory:' AS aux62;
.width 1 2 3
.progress 3
SAVEPOINT sp6691;
.schema
ATTACH DATABASE ':memory:' AS aux19;
-- PRAGMA encoding = 'UTF-16le';
PRAGMA query_only = '>';
PRAGMA case_sensitive_like = NO;
-- PRAGMA checkpoint_fullsync = OFF;
.open random-json.db
PRAGMA journal_mode = 'WAL';
PRAGMA index_info(idx1);
PRAGMA analysis_limit;
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(json_set(x'05e7ec1070228174d7c828', '$.key', -x'ccb57c'))), likely(timediff(NULL, CAST(json_array_length((-(-(NULL)) * coalesce(NULL, NULL, NULL)), '$') AS CHARACTER(-0)))timediff(NULL, NULL))/cos(octet_length(sqlite_compileoption_get(-sin(x'f5ee330d')))), 0)) + 9999), '{"key": null}')), '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SEleCt b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
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;
UPDATE T SET b == '' WHERE NOT NOT NOT (NOT NOT (rowid = 1)) ;
SELECT TOTAL(b) FROM T;
INSERT AND ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIn T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
DROP INDEX IF EXISTS T;
DETACH DATABASE aux66;
WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<99) SELECT * FROM multi;
COMMIT;
CREATE TEMP  VIEW IF NOT EXISTS v_T_1870 AS SELECT a FROM T;
VACUUM;
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;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
REINDEX T;
UPDATE T SET a = 'x';
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_6537 ON T((b + 1));
INSERT INTO T SELECT * FROM T;
UPDATE T SET c = 45 WHERE c BETWEEN 0 AND 100;
CREATE TABLE T1 (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C INTEGER
);
CREATE TABLE T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10) NOT NULL UNIQUE,
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a LEFT JOIN T1 AS b ON a.rowid = b.rowid;
INSERT INTO T1 DEFAULT VALUES;
SELECT * FROM T;
PRAGMA analysis_limit;
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(0)), 1/0, 0)) + 9999), '{"key": null}')), '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b == '' WHERE NOT NOT (rowid = 1) ;
SELECT TOTAL(b) FROM T;
INSERT or ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T  WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
DROP INDEX IF EXISTS T;
DETACH DATABASE aux66;
WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<99) SELECT * FROM multi;
COMMIT;
CREATE TEMP  VIEW IF NOT EXISTS v_T_1870 AS SELECT a FROM T;
VACUUM;
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;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
REINDEX T;
UPDATE T SET a = 'x';
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_6537 ON T((b + 1));
INSERT INTO T SELECT * FROM T;
UPDATE T SET c = 45 WHERE c BETWEEN 0 AND 100;
CREATE TABLE T1 (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C INTEGER
);
CREATE TABLE T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10) NOT NULL UNIQUE,
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a LEFT JOIN T1 AS b ON a.rowid = b.rowid;
INSERT INTO T1 DEFAULT VALUES;
SELECT * FROM T;
PRAGMA analysis_limit;
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(0)), 1/0, 0)) + 9999), '{"key": null}')), '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b == '' WHERE NOT NOT (rowid = 1) ;
SELECT TOTAL(b) FROM T;
INSERT or ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
DROP INDEX IF EXISTS T;
DETACH DATABASE aux66;
WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<99) SELECT * FROM multi;
COMMIT;
CREATE TEMP  VIEW IF NOT EXISTS v_T_1870 AS SELECT a FROM T;
VACUUM;
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;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
REINDEX T;
UPDATE T SET a = 'x';
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_6537 ON T((b + 1));
INSERT INTO T SELECT * FROM T;
UPDATE T SET c = 45 WHERE c BETWEEN 0 AND 100;
CREATE TABLE T1 (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C INTEGER
);
CREATE TABLE T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10) NOT NULL UNIQUE,
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a LEFT JOIN T1 AS b ON a.rowid = b.rowid;
INSERT INTO T1 DEFAULT VALUES;
SELECT * FROM T;
PRAGMA analysis_limit;
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(0)), 1/0, 0)) + 9999), '{"key": null}')), '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b == '' WHERE NOT NOT (rowid = 1) ;
SELECT TOTAL(b) FROM T;
INSERT or ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED  PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
DROP INDEX IF EXISTS T;
DETACH DATABASE aux66;
WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<99) SELECT * FROM multi;
COMMIT;
CREATE TEMP  VIEW IF NOT EXISTS v_T_1870 AS SELECT a FROM T;
VACUUM;
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;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
REINDEX T;
UPDATE T SET a = 'x';
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_6537 ON T((b + 1));
INSERT INTO T SELECT * FROM T;
UPDATE T SET c = 45 WHERE c BETWEEN 0 AND 100;
CREATE TABLE T1 (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C INTEGER
);
CREATE TABLE T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10) NOT NULL UNIQUE,
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a LEFT JOIN T1 AS b ON a.rowid = b.rowid;
INSERT INTO T1 DEFAULT VALUES;
SELECT * FROM T;
PRAGMA analysis_limit;
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(0)), 1/0, 0)) + 9999), '{"key": null}')), '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b == '' WHERE NOT NOT (rowid = 1) ;
SELECT TOTAL(b) FROM T;
INSERT or ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
.exit jsonb_remove(9999, '$.key')
SAVEPOINT sp3629;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ((jsonb_object('k', 1) * 1),'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
UPDATE T SET b = '' WHERE rowid = 1;
SELECT TOTAL(b) FROM T;
INSERT OR ABORT INTO T VALUES ('', NULL, 'x');
DELETE FROM T WHERE a > (SELECT AVG(a) FROM T);
CREATE TEMP  VIEW IF NOT EXISTS v_T_8716 AS SELECT b FROM T;
ROLLBACK TO sp3629;
RELEASE sp3629;
ALTER TABLE T DROP COLUMN b;
ANALYZE /* jsonb_array({v}) */ T;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA hard_heap_limit = 50000000;
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T ADD COLUMN extra_1002 DOUB DEFAULT NULL;
SELECT * FROM T WHERE b = (SELECT COUNT(*) FROM T);
INSERT INTO T SELECT * FROM T;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T t2 WHERE t2.b = T.b);
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;
PRAGMA read_uncommitted = TRUE;
SELECT SUM(b) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
INSERT INTO T DEFAULT VALUES;
SELECT MAX(a) FROM T;
SELECT * FROM (SELECT * FROM T) AS t1 JOIN (SELECT * FROM T) AS t2 ON t1.a = t2.a;
DROP INDEX IF EXISTS T;
DETACH DATABASE aux66;
WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<99) SELECT * FROM multi;
COMMIT;
CREATE TEMP  VIEW IF NOT EXISTS v_T_1870 AS SELECT a FROM T;
VACUUM;
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;
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
REINDEX T;
UPDATE T SET a = 'x';
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_6537 ON T((b + 1));
INSERT INTO T SELECT * FROM T;
UPDATE T SET c = 45 WHERE c BETWEEN 0 AND 100;
CREATE TABLE T1 (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15) UNIQUE,
  C INTEGER
);
CREATE TABLE T2 (
  X VARCHAR(20) PRIMARY KEY,
  A VARCHAR(10) NOT NULL UNIQUE,
  FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a LEFT JOIN T1 AS b ON a.rowid = b.rowid;
INSERT INTO T1 DEFAULT VALUES;
SELECT * FROM T;
INSERT INTO T VALUES (NULL, NULL, NULL);
ALTER TABLE T1 RENAME TO T1_r7888;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
VACUUM;
SELECT * FROM T2 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T1 RENAME COLUMN A TO A_r1257;
INSERT OR REPLACE INTO T1 VALUES ('x', 0, '');
WITH cte AS (SELECT A FROM T2) SELECT * FROM cte;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_595 AS SELECT c FROM T;
PRAGMA writable_schema = 1;
SELECT COUNT(*) FROM T;
SELECT A, (SELECT MIN(A) FROM T2) AS min_val FROM T2;
SELECT * FROM T;
PRAGMA vdbe_trace = 0;
INSERT INTO T1 SELECT * FROM T1;
SELECT * FROM T CROSS JOIN T;
DELETE FROM T2 WHERE rowid = 48 RETURNING *;
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TEMP  VIEW IF NOT EXISTS v_T_9407 AS SELECT b FROM T;
ALTER TABLE T2 ADD COLUMN extra_5922 SMALLINT COLLATE RTRIM;
DETACH DATABASE aux19;
PRAGMA writable_schema = RESET;
PRAGMA parser_trace = NO;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
ALTER TABLE T DROP COLUMN a;
ANALYZE T2;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<56), filtered AS (SELECT * FROM cnt WHERE x > 28) SELECT * FROM filtered;
SELECT LAG(c, 2, c) OVER (ORDER BY c ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T;
SELECT * FROM (SELECT * FROM T1) AS sub;
INSERT INTO T2 SELECT * FROM T2;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<50) SELECT SUM(x) FROM cnt;
VACUUM main;
SELECT COUNT(*) FROM T1;
INSERT INTO T VALUES (NULL, 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ANALYZE;
PRAGMA recursive_triggers = FALSE;
ALTER TABLE T2 DROP COLUMN A;
CREATE  INDEX IF NOT EXISTS idx_T1_8687 ON T1(B COLLATE NOCASE);
SELECT COUNT(*) FROM T1;
SELECT COUNT(*) FROM T1;
CREATE  VIEW IF NOT EXISTS v_T1_7545 AS SELECT C FROM T1;
SELECT * FROM T WHERE EXISTS (SELECT 1 FROM T);
ALTER TABLE T1 RENAME TO T1_r3037;
SELECT STRING_AGG(B, '|') FROM T1;
INSERT INTO T VALUES (1, 'x', NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE T ADD COLUMN extra_2569 DATETIME DEFAULT CURRENT_TIMESTAMP;
VACUUM main;
PRAGMA full_column_names = 1;
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 T2;
INSERT INTO T2 SELECT * FROM T2;
SELECT COUNT(*) FROM T;
CREATE TABLE T (
  a INTEGER,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE c < 2.0 ORDER BY c;
SELECT TOTAL(A) FROM T1;
INSERT INTO T2 VALUES ('x', 1) ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
INSERT OR ROLLBACK INTO T1 VALUES (-10, '', 0);
UPDATE T2 SET A = json_object('k', A) WHERE A BETWEEN 0 AND 100;
INSERT INTO T1 VALUES (NULL, 1, 'x') ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
RELEASE sp6691;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T2_9665 AS SELECT A FROM T2;
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 T2;
SELECT * FROM T2 WHERE A = (SELECT SUM(A) FROM T2);
SELECT * FROM T1 AS a RIGHT OUTER JOIN T2 AS b ON a.rowid = b.rowid;
SELECT COUNT(*) FROM T;
INSERT INTO T2 DEFAULT VALUES;
UPDATE T1 SET C = 'x' WHERE C BETWEEN 0 AND 100;
INSERT INTO T1 VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
DETACH DATABASE aux62;
DROP INDEX IF EXISTS T2;
INSERT INTO T2 SELECT * FROM T2;
ANALYZE;
```

## Actual output

```sql
ATTACH DATABASE ':memory:' AS aux62;
.width 1 2 3
.progress 3
SAVEPOINT sp6691;
Progress 1
.schema
Progress 2
Progress 3
Progress 4
Progress 5
Progress 6
Progress 7
Progress 8
Progress 9
Progress 10
Progress 11
Progress 12
Progress 13
Progress 14
ATTACH DATABASE ':memory:' AS aux19;
Progress 15
Progress 16
Progress 17
Progress 18
-- PRAGMA encoding = 'UTF-16le';
PRAGMA query_only = '>';
Progress 19
PRAGMA case_sensitive_like = NO;
Progress 20
-- PRAGMA checkpoint_fullsync = OFF;
.open random-json.db
PRAGMA journal_mode = 'WAL';
wal
PRAGMA index_info(idx1);
PRAGMA analysis_limit;
0
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(json_set(x'05e7ec1070228174d7c828', '$.key', -x'ccb57c'))), likely(timediff(NULL, CAST(json_array_length((-(-(NULL)) * coalesce(NULL, NULL, NULL)), '$') AS CHARACTER(-0)))timediff(NULL, NULL))/cos(octet_length(sqlite_compileoption_get(-sin(x'f5ee330d')))), 0)) + 9999), '{"key": null}')), '$.key')
```

## Expectation

```sql
ATTACH DATABASE ':memory:' AS aux62;
.width 1 2 3
.progress 3
SAVEPOINT sp6691;
Progress 1
.schema
Progress 2
Progress 3
Progress 4
Progress 5
Progress 6
Progress 7
Progress 8
Progress 9
Progress 10
Progress 11
Progress 12
Progress 13
Progress 14
Progress 15
Progress 16
ATTACH DATABASE ':memory:' AS aux19;
Progress 17
Progress 18
Progress 19
Progress 20
-- PRAGMA encoding = 'UTF-16le';
PRAGMA query_only = '>';
Progress 21
PRAGMA case_sensitive_like = NO;
Progress 22
-- PRAGMA checkpoint_fullsync = OFF;
.open random-json.db
PRAGMA journal_mode = 'WAL';
wal
PRAGMA index_info(idx1);
PRAGMA analysis_limit;
0
BEGIN DEFERRED;
ATTACH DATABASE ':memory:' AS aux66;
.exit jsonb_remove(exp(json_patch((json_remove(if(-(-(json_set(x'05e7ec1070228174d7c828', '$.key', -x'ccb57c'))), likely(timediff(NULL, CAST(json_array_length((-(-(NULL)) * coalesce(NULL, NULL, NULL)), '$') AS CHARACTER(-0)))timediff(NULL, NULL))/cos(octet_length(sqlite_compileoption_get(-sin(x'f5ee330d')))), 0)) + 9999), '{"key": null}')), '$.key')
```

## Flag

```
-echo
```