ast-project/part1/results/3/bug_cae17735-9c8e-47d3-8067-7befc6055e5e_unexpected_error.md at main

admin/ast-project

Fork 0

Files

T

admin fd930e15cb ---

2026-06-24 13:47:14 +02:00

59 KiB

Raw Permalink Blame History

Summary

**No review yet**

Minimized query

.log ON
ATTACH DATABASE ':memory:' AS aux9;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(acos(json_remove(0.0)), '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
SAVEPOINT sp1295;
.import corrupt001.db main
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
ATTACH DATABASE ':memory:' AS aux28;
CREATE TEMPORARY TABLE "t0"(x, y, z);
SELECT -concat_ws('|', NULL, NULL, NULL);
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(power(-(-(x'168d8a871af47810')), json_remove(0.0, '$'))));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a NATURAL JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES /**/ ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;
.quit
.filectrl
PRAGMA cache_spill = TRUE;
PRAGMA vdbe_addoptrace = TRUE;
PRAGMA stats;
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -trunc(json_quote(99999999999999999999999999999999999999999999999999));
SELECT * FROM sqlite_temp_master WHERE NOT sql GLOB '000[]***';
DROP TABLE t0;
.timer on
CREATE TABLE t3(x,y);
INSERT INTO t3 VALUES(1,NULL);
CREATE TABLE T (
  a TEXT,
  b TEXT,
  c REAL
);
INSERT INTO T VALUES ('a','b',1.0), ('a','c',-1.0), ('b','d',0.0);
SELECT
COALESCE(a,'e') AS d,
COALESCE(b,'f') AS e,
SUM(c) AS f
FROM T
GROUP BY a,b;
INSERT INTO t3 VALUES(2,NULL);
INSERT INTO t3 VALUES(3,4);
SELECT count(x), y FROM t3 GROUP BY y ORDER BY 1;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE  VIEW IF NOT EXISTS v_t3_1775 AS SELECT y FROM t3;
VACUUM main;
INSERT INTO t3 VALUES (NULL, NULL);
DROP TRIGGER IF EXISTS T;

CREATE TEMP  VIEW IF NOT EXISTS v_t0_2745 AS SELECT y FROM t0;
UPDATE t0 SET y = NULL WHERE 1 RETURNING *;
SELECT * FROM t3;
ANALYZE;
DELETE FROM t3 WHERE 1;
ALTER TABLE t0 DROP COLUMN x;
DELETE FROM t3 WHERE 1;
SELECT * FROM t0 AS a LEFT OUTER JOIN t0 AS b ON a.rowid = b.rowid;
CREATE TABLE T (
  A VARCHAR(10) PRIMARY KEY,
  B VARCHAR(15),
  C BIGINT NOT NULL,
  UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', 3000);
INSERT INTO T VALUES ('b', 'q', 9223372036854775807);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('e', 'q', -9223372036854775808);
INSERT INTO T VALUES ('f', 'r', 0);
SELECT B, COUNT(*) AS D, SUM(C) AS E, AVG(C) AS F FROM T GROUP BY B HAVING SUM(C) > 0;
REINDEX;
SELECT * FROM t0 WHERE y NOT IN (SELECT y FROM t0 WHERE y IS NULL);
DETACH DATABASE aux28;
ALTER TABLE T ADD COLUMN extra_139 ANY DEFAULT 0;
SELECT * FROM T WHERE A <> ALL (SELECT A FROM T);
SELECT COUNT(*) FILTER (WHERE B IS NOT NULL), SUM(rowid) FILTER (WHERE B > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(B) FILTER (WHERE B > 0 AND B < 100), COUNT(*) FILTER (WHERE typeof(B) = "text") FROM T;
DROP INDEX IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE A IS NOT NULL), SUM(rowid) FILTER (WHERE A > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(A) FILTER (WHERE A > 0 AND A < 100), COUNT(*) FILTER (WHERE typeof(A) = "text") FROM T;
CREATE  INDEX IF NOT EXISTS idx_t3_3532 ON t3(x);
INSERT INTO t3 VALUES (1, 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
ALTER TABLE t3 ADD COLUMN extra_6458 VARCHAR(255) DEFAULT (random());
UPDATE t3 SET y = y + 1 WHERE rowid = 1 RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1295;
RELEASE SAVEPOINT sp1295;
SELECT LAG(x, 0, 'default') OVER (ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t3;
ANALYZE t3;
SELECT * FROM T AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
INSERT INTO T DEFAULT VALUES;
ALTER TABLE t3 RENAME COLUMN x TO x_r731;
ALTER TABLE t0 RENAME TO t0_r9792;
SELECT * FROM t3 AS a LEFT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
ALTER TABLE T DROP COLUMN B;
SELECT * FROM t3 t1 RIGHT JOIN t3 t2 ON t1.y = (SELECT y FROM t3 WHERE y = t1.y);
DELETE FROM t0 WHERE 0 RETURNING *;
ALTER TABLE T DROP COLUMN B;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<31) SELECT COUNT(*) FROM cnt;
VACUUM;
SELECT LAG(A, 1, NULL) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
ANALYZE t3;
ALTER TABLE t3 DROP COLUMN y;
INSERT INTO t3 VALUES (NULL, NULL);
ALTER TABLE t3 RENAME TO t3_r7061;
INSERT INTO t0 SELECT * FROM t0;
SELECT * FROM T AS a RIGHT JOIN t3 AS b ON a.rowid = b.rowid;
SELECT * FROM t0;
INSERT INTO T DEFAULT VALUES;
WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;
SELECT * FROM t3 AS a RIGHT OUTER JOIN t3 AS b ON a.rowid = b.rowid;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_5251 ON T(lower(A)) WHERE A > 0;

SELECT * FROM t3 t1 LEFT JOIN t3 t2 ON t1.x = (SELECT x FROM t3 WHERE x = t1.x);

SELECT COUNT(*) FROM t0;
CREATE  VIEW IF NOT EXISTS v_t0_4016 AS SELECT z FROM t0;
INSERT OR ROLLBACK INTO T VALUES (0, '', '');
SELECT TOTAL(y) OVER (ORDER BY y GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t3;
DETACH DATABASE aux9;

Actual output

https://yewtu.be/watch?v=dQw4w9WgXcQ
table|t0|t0|2|CREATE TABLE "t0"(x, y, z)

59 KiB

Raw Permalink Blame History

Summary

Minimized query

Actual output

Expectation

Flag

59 KiB Raw Permalink Blame History

Summary

Minimized query

Actual output

Expectation

Flag

59 KiB

Raw Permalink Blame History