admin/ast-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fd930e15cb2dd0a6bce83d8c3b01573bfb3987ea
ast-project/part1/results/2/bug_80f4aaad-c6b4-4906-a125-b9f3f99b9b8f_logic.md
T
admin fd930e15cb ---
2026-06-24 13:47:14 +02:00

929 lines
45 KiB
Markdown
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
## 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 aux76;
PRAGMA cache_spill = FALSE;
ATTACH DATABASE ':memory:' AS aux90;
.timer off
ATTACH DATABASE ':memory:' AS aux45;
-- json_array_insert({v}, '$.arr[0]', {v})
PRAGMA writable_schema = TRUE;
PRAGMA reverse_unordered_selects = OFF;
PRAGMA cell_size_check;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE ':memory:' AS aux73;
.print
ATTACH DATABASE ':memory:' AS aux97;
.timer on
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -NULL;
SELECT * FrOm sqlite_temp_master WHERE NOT NOT (NOT sql GLOB '000[]***') ;
DROP TABLE t0;
BEGIN IMMEDIATE;
.exit -log10(radians(json_group_object('k', -(-(json_array(timediff(NULL, length(-timediff(NULL, '-Inf')timediff(NULL, NULL)))timediff(NULL, NULL), NULL, NULL))))))
PRAGMA read_uncommitted;
PRAGMA ignore_check_constraints <> YES;
PRAGMA legacy_alter_table;
.parameter
CREATE TABLE main.t1(a, b, c, d);
CREATE UNIQUE INDEX i1 ON t1(b, c);
CREATE UNIQUE INDEX i2 ON t1(d COLLATE nocase);
CREATE TABLE t2(x DECIMAL('-',(nan + (unicode('你好') + max(x'af5df3e5294acaf5a4f1de6448da', '2', randomblob(-likelihood(NULL, ceiling(NULL))))))) PRIMARY KEY, y);
CREATE TABLE main.t3(c1 PRIMARY KEY NOT NULL, c2 NOT NULL);
CREATE INDEX i3 ON t3(c2);
CREATE TABLE t4(a, b NOT NULL, c NOT NULL, d NOT NULL);
CREATE UNIQUE /* PRAGMA fullsync = 0; */ INDEX t4i1 ON t4(b, c);
CREATE UNIQUE INDEX t4i2 ON t4(d COLLATE nocase);
SELECT DISTINCT c FROM t1 WHERE NOT b = ?;
SELECT DISTINCT c FROM t1 WHERE b IN (x'ab',ifnull(json_patch(json_tree(strftime('%Y-%m-%d', 'abc')), -nan), CAST(nan AS DOUBLE PRECISION)));
SELECT DISTINCT a, b, c COLLATE nocase FROM t1
PRAGMA integrity_check("users");
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_5148 ON t1(lower(c)) WHERE +c > substr(randomblob(-(-(format('%d', max('a', 'b', 'c'))))), 1, 5);
SELECT * FROM t1;
COMMIT;
SELECT COUNT(b) FROM t1;
INSERT INTO t2 DEFAULT VALUES;
WITH cte AS (SELECT * FROM t4) SELECT * FROM cte WHERE c > 0 UNION ALL SELECT * FROM cte WHERE c <= 0;
CREATE TEMP VIEW IF NOT EXISTS v_t1_244 AS SELECT c FROM t1;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 RENAME TO t2_r6544;
INSERT INTO t4 SELECT * FROM t4;
CREATE TRIGGER IF NOT EXISTS trg_t4_4171 BEFORE DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
VACUUM;
CREATE TABLE T (
a FLOA PRECISION,
b TEXT
);
INSERT INTO T VALUES ('a','2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
(julianday('now')-julianday(b))/365.25
AS INTEGER
) AS c
FROM T;
DETACH DATABASE aux97;
SELECT COUNT(*) FILTER (WHERE a IS NOT NULL), SUM(rowid) FILTER (WHERE a > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(a) FILTER (WHERE a > 0 AND a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
SELECT * FROM T;
ALTER TABLE /* PRAGMA defer_foreign_keys = NO; */ t2 ADD COLUMN extra_3261 FLOAT;
UPDATE t0 SET z = z + 1 WHERE 1;
WITH cte AS (SELECT CASE WHEN c IS /* PRAGMA defer_foreign_keys = TRUE; */ NULL THEN 0 ELSE c END AS val FROM t1) SELECT * FROM cte;
PRAGMA page_size = 4096;
CREATE INDEX IF NOT EXISTS idx_t0_8372 ON t0(lower(y)) WHERE y IS NOT NULL;
PRAGMA recursive_triggers = 1;
ALTER TABLE t2 RENAME COLUMN x TO x_r3369;
INSERT OR ABORT INTO t0 VALUES ('x', NULL, '');
INSERT INTO t0 VALUES (NULL, NULL, NULL);
DROP TABLE IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t4_6716 AFTER DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
CREATE TRIGGER IF NOT EXISTS trg_t2_5474 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA checkpoint_fullsync;
INSERT INTO t1 SELECT * FROM t1;
INSERT OR ABORT INTO t4 VALUES ('', 0, 0, -3);
ALTER TABLE t3 RENAME COLUMN c1 TO c1_r9839;
WITH cte AS (SELECT c1 FROM t3 UNION ALL SELECT c1 FROM t3) SELECT * FROM cte;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t0;
PRAGMA max_page_count = 5000000;
CREATE TRIGGER IF NOT EXISTS trg_t4_645 AFTER UPDATE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_t4_7725 BEFORE UPDATE ON t4 BEGIN SELECT RAISE(FAIL, 'no'); END;
DETACH DATABASE aux73;
CREATE INDEX IF NOT EXISTS idx_t2_3331 ON t2(y COLLATE NOCASE) WHERE y IS NOT NULL;
CREATE VIEW IF NOT EXISTS v_T_6672 AS SELECT b FROM T;
REINDEX;
ANALYZE T;
ALTER TABLE t0 ADD COLUMN extra_6804 NATIVE CHARACTER(70)NVARCHAR(100) DEFAULT (abs(random()) % 1000);
ALTER TABLE t0 DROP COLUMN y;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
C INTEGER,
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 100);
INSERT INTO T VALUES ('b', 'r', 200);
INSERT INTO T VALUES ('c', 's', 300);
INSERT INTO T VALUES ('d', 't', 2147483647);
INSERT INTO T VALUES ('b', 't', 50);
SELECT A, COUNT(*) AS D, SUM(C) AS E FROM T GROUP BY A HAVING COUNT(*) > 1;
SELECT GROUP_CONCAT(d) FROM t4;
ANALYZE t2;
ALTER TABLE t1 ADD COLUMN extra_1405 INT8 DEFAULT '';
SELECT * FROM t2 AS a RIGHT jOiN t0 AS b ON a.rowid = b.rowid;
WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<45) SELECT * FROM multi;
DELETE FROM t3 WHERE 1 RETURNING *;
DELETE FROM t3 WHERE c1 > (SELECT AVG(c1) FROM t3);
ANALYZE;
INSERT INTO T SELECT * FROM T;
ALTER TABLE t4 RENAME TO t4_r5482;
SELECT * FROM t3 WHERE c2 <= ANY (SELECT c2 FROM t3);
VACUUM;
SELECT STRING_AGG(b) FROM t4;
SELECT * FROM t3 CROSS JOIN t2;
DELETE FROM t4 WHERE rowid = 69 RETURNING *;
SELECT * FROM t4 WHERE d IN (SELECT DISTINCT d FROM t4);
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN B TO B_r9596;
CREATE VIEW IF NOT EXISTS v_t1_2631 AS SELECT b FROM t1;
CREATE INDEX IF NOT EXISTS idx_t3_7394 ON t3(c2);
SELECT * FROM (SELECT y FROM t0 WHERE y IS NOT NULL) AS sub;
CREATE TEMP VIEW IF NOT EXISTS v_t4_1728 AS SELECT d FROM t4;
DELETE FROM t1 WHERE a IS NULL;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
CREATE TRIGGER IF NOT EXISTS trg_T_1938 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
INSERT INTO t4 SELECT * FROM t4;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t0_8908 ON t0((y + 1)) WHERE y > 0;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-3) SELECT * FROM cnt;
ANALYZE;
REINDEX;
INSERT INTO t4 SELECT * FROM t4;
SELECT * FROM t3;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = NULL);
WITH a AS (SELECT * FROM t1 WHERE d IS NOT NULL), b AS (SELECT * FROM a WHERE d > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES (1, NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE t2 RENAME COLUMN y TO y_r7971;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (1,'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
ALTER TABLE t3 DROP COLUMN c2;
SELECT * FROM t2 AS a RIGHT JOIN t1 AS b ON a.rowid = b.rowid;
UPDATE t0 SET y = 'x' WHERE 1 RETURNING *;
SELECT COUNT(x) FILTER (WHERE x IS NOT NULL) OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t2;
SELECT * FROM t1 NATURAL JOIN t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8719 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<69) SELECT x FROM cnt WHERE x > 34;
WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;
CREATE TEMP VIEW IF NOT EXISTS v_T_7090 AS SELECT b FROM T;
SELECT * FROM t0 WHERE EXISTS (SELECT 1 FROM t0 WHERE EXISTS (SELECT 1 FROM t0));
ANALYZE;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t0 WHERE rowid = 6;
DETACH DATABASE aux45;
REINDEX;
SELECT SUM(z) FROM t0;
SELECT y FROM t0 UNION ALL SELECT y FROM (SELECT * FROM t0) AS sub;
ATTACH DATABASE ':memory:' AS aux45;
PRAGMA writable_schema = TRUE;
PRAGMA reverse_unordered_selects = OFF;
PRAGMA cell_size_check;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE ':memory:' AS aux73;
.print
ATTACH DATABASE ':memory:' AS aux97;
.timer on
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -NULL;
SELECT * FrOm sqlite_temp_master WHERE sql GLOB '000[]***';
DROP TABLE t0;
BEGIN IMMEDIATE;
.exit -log10(radians(json_group_object('k', -(-(json_array(timediff(NULL, length(-timediff(NULL, '-Inf')timediff(NULL, NULL)))timediff(NULL, NULL), NULL, NULL))))))
PRAGMA read_uncommitted;
PRAGMA ignore_check_constraints <> YES;
PRAGMA legacy_alter_table;
.parameter
CREATE TABLE main.t1(a, b, c, d);
CREATE UNIQUE INDEX i1 ON t1(b, c);
CREATE UNIQUE INDEX i2 ON t1(d COLLATE nocase);
CREATE TABLE t2(x DECIMAL('-',(nan + (unicode('你好') + max(x'af5df3e5294acaf5a4f1de6448da', '2', randomblob(-likelihood(NULL, ceiling(NULL))))))) PRIMARY KEY, y);
CREATE TABLE main.t3(c1 PRIMARY KEY NOT NULL, c2 NOT NULL);
CREATE INDEX i3 ON t3(c2);
CREATE TABLE t4(a, b NOT NULL, c NOT NULL, d NOT NULL);
CREATE UNIQUE /* PRAGMA fullsync = 0; */ INDEX t4i1 ON t4(b, c);
CREATE UNIQUE INDEX t4i2 ON t4(d COLLATE nocase);
SELECT DISTINCT c FROM t1 WHERE NOT b = ?;
SELECT DISTINCT c FROM t1 WHERE b IN (x'ab',ifnull(json_patch(json_tree(strftime('%Y-%m-%d', 'abc')), 1), 2));
SELECT DISTINCT a, b, c COLLATE nocase FROM t1
PRAGMA integrity_check("users");
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_5148 ON t1(lower(c)) WHERE c > 0;
SELECT * FROM t1;
COMMIT;
SELECT COUNT(b) FROM t1;
INSERT INTO t2 DEFAULT VALUES;
WITH cte AS (SELECT * FROM t4) SELECT * FROM cte WHERE c > 0 UNION ALL SELECT * FROM cte WHERE c <= 0;
CREATE TEMP VIEW IF NOT EXISTS v_t1_244 AS SELECT c FROM t1;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 RENAME TO t2_r6544;
INSERT INTO t4 SELECT * FROM t4;
CREATE TRIGGER IF NOT EXISTS trg_t4_4171 BEFORE DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
VACUUM;
CREATE TABLE T (
a TINYINT PRECISION,
b TEXT
);
INSERT INTO T VALUES ('a','2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
(julianday('now')-julianday(b))/365.25
AS INTEGER
) AS c
FROM T;
DETACH DATABASE aux97;
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 OR a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
SELECT * FROM T;
ALTER TABLE /* PRAGMA defer_foreign_keys = NO; */ t2 ADD COLUMN extra_3261 FLOAT;
UPDATE t0 SET z = z + 1 WHERE 1;
WITH cte AS (SELECT CASE WHEN c IS /* PRAGMA defer_foreign_keys = TRUE; */ NULL THEN 0 ELSE c END AS val FROM t1) SELECT * FROM cte;
PRAGMA page_size = 4096;
CREATE INDEX IF NOT EXISTS idx_t0_8372 ON t0(lower(y)) WHERE y IS NOT NULL;
PRAGMA recursive_triggers = 1;
ALTER TABLE t2 RENAME COLUMN x TO x_r3369;
INSERT OR ABORT INTO t0 VALUES ('x', NULL, '');
INSERT INTO t0 VALUES (NULL, NULL, NULL);
DROP TABLE IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t4_6716 AFTER DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
CREATE TRIGGER IF NOT EXISTS trg_t2_5474 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA checkpoint_fullsync;
INSERT INTO t1 SELECT * FROM t1;
INSERT OR ABORT INTO t4 VALUES ('', 0, 0, -3);
ALTER TABLE t3 RENAME COLUMN c1 TO c1_r9839;
WITH cte AS (SELECT c1 FROM t3 UNION ALL SELECT c1 FROM t3) SELECT * FROM cte;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t0;
PRAGMA max_page_count = 5000000;
CREATE TRIGGER IF NOT EXISTS trg_t4_645 AFTER UPDATE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_t4_7725 BEFORE UPDATE ON t4 BEGIN SELECT RAISE(FAIL, 'no'); END;
DETACH DATABASE aux73;
CREATE INDEX IF NOT EXISTS idx_t2_3331 ON t2(y COLLATE NOCASE) WHERE y IS NOT NULL;
CREATE VIEW IF NOT EXISTS v_T_6672 AS SELECT b FROM T;
REINDEX;
ANALYZE T;
ALTER TABLE t0 ADD COLUMN extra_6804 NATIVE CHARACTER(70)NVARCHAR(100) DEFAULT (abs(random()) % 1000);
ALTER TABLE t0 DROP COLUMN y;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
C INTEGER,
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 100);
INSERT INTO T VALUES ('b', 'r', 200);
INSERT INTO T VALUES ('c', 's', 300);
INSERT INTO T VALUES ('d', 't', 2147483647);
INSERT INTO T VALUES ('b', 't', 50);
SELECT A, COUNT(*) AS D, SUM(C) AS E FROM T GROUP BY A HAVING COUNT(*) > 1;
SELECT GROUP_CONCAT(d) FROM t4;
ANALYZE t2;
ALTER TABLE t1 ADD COLUMN extra_1405 INT8 DEFAULT '';
SELECT * FROM t2 AS a RIGHT JOIN t0 AS b ON a.rowid = b.rowid;
WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<45) SELECT * FROM multi;
DELETE FROM t3 WHERE 1 RETURNING *;
DELETE FROM t3 WHERE c1 > (SELECT AVG(c1) FROM t3);
ANALYZE;
INSERT INTO T SELECT * FROM T;
ALTER TABLE t4 RENAME TO t4_r5482;
SELECT * FROM t3 WHERE c2 <= ANY (SELECT c2 /* VARCHAR(255) */ FROM t3);
VACUUM;
SELECT STRING_AGG(b) FROM t4;
SELECT * FROM t3 CROSS JOIN t2;
DELETE FROM t4 WHERE rowid = 69 RETURNING *;
SELECT * FROM t4 WHERE d IN (SELECT DISTINCT d FROM t4);
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN B TO B_r9596;
CREATE VIEW IF NOT EXISTS v_t1_2631 AS SELECT b FROM t1;
CREATE INDEX IF NOT EXISTS idx_t3_7394 ON t3(c2);
SELECT * FROM (SELECT y FROM t0 WHERE y IS NOT NULL) AS sub;
CREATE TEMP VIEW IF NOT EXISTS v_t4_1728 AS SELECT d FROM t4;
DELETE FROM t1 WHERE a IS NULL;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
CREATE TRIGGER IF NOT EXISTS trg_T_1938 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
INSERT INTO t4 SELECT * FROM t4;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t0_8908 ON t0((y + 1)) WHERE y > 0;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-3) SELECT * FROM cnt;
ANALYZE;
REINDEX;
INSERT INTO t4 SELECT * FROM t4;
SELECT * FROM t3;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = NULL);
WITH a AS (SELECT * FROM t1 WHERE d IS NOT NULL), b AS (SELECT * FROM a WHERE d > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES (1, NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE t2 RENAME COLUMN y TO y_r7971;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (1,'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
ALTER TABLE t3 DROP COLUMN c2;
SELECT * FROM t2 AS a RIGHT JOIN t1 AS b ON a.rowid = b.rowid;
UPDATE t0 SET y = 'x' WHERE 1 RETURNING *;
SELECT COUNT(x) FILTER (WHERE x IS NOT NULL) OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t2;
SELECT * FROM t1 NATURAL JOIN t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8719 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<69) SELECT x FROM cnt WHERE x > 34;
WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;
CREATE TEMP VIEW IF NOT EXISTS v_T_7090 AS SELECT b FROM T;
SELECT * FROM t0 WHERE EXISTS (SELECT 1 FROM t0 WHERE EXISTS (SELECT 1 FROM t0));
ANALYZE;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t0 WHERE rowid = 6;
DETACH DATABASE aux45;
REINDEX;
SELECT SUM(z) FROM t0;
SELECT y FROM t0 UNION ALL SELECT y FROM (SELECT * FROM t0) AS sub;
ATTACH DATABASE ':memory:' AS aux45;
PRAGMA writable_schema = TRUE;
PRAGMA reverse_unordered_selects = OFF;
PRAGMA cell_size_check;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE ':memory:' AS aux73;
.print
ATTACH DATABASE ':memory:' AS aux97;
.timer on
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -NULL;
SELECT * FrOm sqlite_temp_master WHERE sql GLOB '000[]***';
DROP TABLE t0;
BEGIN IMMEDIATE;
.exit -log10(radians(json_group_object('k', -(-(json_array(timediff(NULL, length(-timediff(NULL, '-Inf')timediff(NULL, NULL)))timediff(NULL, NULL), NULL, NULL))))))
PRAGMA read_uncommitted;
PRAGMA ignore_check_constraints <> YES;
PRAGMA legacy_alter_table;
.parameter
CREATE TABLE main.t1(a, b, c, d);
CREATE UNIQUE INDEX i1 ON t1(b, c);
CREATE UNIQUE INDEX i2 ON t1(d COLLATE nocase);
CREATE TABLE t2(x DECIMAL('-',(nan + (unicode('你好') + max(x'af5df3e5294acaf5a4f1de6448da', '2', randomblob(-likelihood(NULL, ceiling(NULL))))))) PRIMARY KEY, y);
CREATE TABLE main.t3(c1 PRIMARY KEY NOT NULL, c2 NOT NULL);
CREATE INDEX i3 ON t3(c2);
CREATE TABLE t4(a, b NOT NULL, c NOT NULL, d NOT NULL);
CREATE UNIQUE /* PRAGMA fullsync = 0; */ INDEX t4i1 ON t4(b, c);
CREATE UNIQUE INDEX t4i2 ON t4(d COLLATE nocase);
SELECT DISTINCT c FROM t1 WHERE NOT b = ?;
SELECT DISTINCT c FROM t1 WHERE b IN (x'ab',ifnull(json_patch(json_tree(strftime('%Y-%m-%d', 'abc')), 1), 2));
SELECT DISTINCT a, b, c COLLATE nocase FROM t1
PRAGMA integrity_check("users");
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_5148 ON t1(lower(c)) WHERE c > 0;
SELECT * FROM t1;
COMMIT;
SELECT COUNT(b) FROM t1;
INSERT INTO t2 DEFAULT VALUES;
WITH cte AS (SELECT * FROM t4) SELECT * FROM cte WHERE c > 0 UNION ALL SELECT * FROM cte WHERE c <= 0;
CREATE TEMP VIEW IF NOT EXISTS v_t1_244 AS SELECT c FROM t1;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 RENAME TO t2_r6544;
INSERT INTO t4 SELECT * FROM t4;
CREATE TRIGGER IF NOT EXISTS trg_t4_4171 BEFORE DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
VACUUM;
CREATE TABLE T (
a TINYINT PRECISION,
b TEXT
);
INSERT INTO T VALUES ('a','2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
(julianday('now')-julianday(b))/365.25
AS INTEGER
) AS c
FROM T;
DETACH DATABASE aux97;
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 OR a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
SELECT * FROM T;
ALTER TABLE /* PRAGMA defer_foreign_keys = NO; */ t2 ADD COLUMN extra_3261 FLOAT;
UPDATE t0 SET z = z + 1 WHERE 1;
WITH cte AS (SELECT CASE WHEN c IS /* PRAGMA defer_foreign_keys = TRUE; */ NULL THEN 0 ELSE c END AS val FROM t1) SELECT * FROM cte;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
PRAGMA page_size = 4096;
CREATE INDEX IF NOT EXISTS idx_t0_8372 ON t0(lower(y)) WHERE y IS NOT NULL;
PRAGMA recursive_triggers = 1;
ALTER TABLE t2 RENAME COLUMN x TO x_r3369;
INSERT OR ABORT INTO t0 VALUES ('x', NULL, '');
INSERT INTO t0 VALUES (NULL, NULL, NULL);
DROP TABLE IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t4_6716 AFTER DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
CREATE TRIGGER IF NOT EXISTS trg_t2_5474 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA checkpoint_fullsync;
INSERT INTO t1 SELECT * FROM t1;
INSERT OR ABORT INTO t4 VALUES ('', 0, 0, -3);
ALTER TABLE t3 RENAME COLUMN c1 TO c1_r9839;
WITH cte AS (SELECT c1 FROM t3 UNION ALL SELECT c1 FROM t3) SELECT * FROM cte;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t0;
PRAGMA max_page_count = 5000000;
CREATE TRIGGER IF NOT EXISTS trg_t4_645 AFTER UPDATE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_t4_7725 BEFORE UPDATE ON t4 BEGIN SELECT RAISE(FAIL, 'no'); END;
DETACH DATABASE aux73;
CREATE INDEX IF NOT EXISTS idx_t2_3331 ON t2(y COLLATE NOCASE) WHERE y IS NOT NULL;
CREATE VIEW IF NOT EXISTS v_T_6672 AS SELECT b FROM T;
REINDEX;
ANALYZE T;
ALTER TABLE t0 ADD COLUMN extra_6804 NATIVE CHARACTER(70)NVARCHAR(100) DEFAULT (abs(random()) % 1000);
ALTER TABLE t0 DROP COLUMN y;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
C INTEGER,
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 100);
INSERT INTO T VALUES ('b', 'r', 200);
INSERT INTO T VALUES ('c', 's', 300);
INSERT INTO T VALUES ('d', 't', 2147483647);
INSERT INTO T VALUES ('b', 't', 50);
SELECT A, COUNT(*) AS D, SUM(C) AS E FROM T GROUP BY A HAVING COUNT(*) > 1;
SELECT GROUP_CONCAT(d) FROM t4;
ANALYZE t2;
ALTER TABLE t1 ADD COLUMN extra_1405 INT8 DEFAULT '';
SELECT * FROM t2 AS a RIGHT JOIN t0 AS b ON a.rowid = b.rowid;
WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<45) SELECT * FROM multi;
DELETE FROM t3 WHERE 1 RETURNING *;
DELETE FROM t3 WHERE c1 > (SELECT AVG(c1) FROM t3);
ANALYZE;
INSERT INTO T SELECT * FROM T;
ALTER TABLE t4 RENAME TO t4_r5482;
SELECT * FROM t3 WHERE c2 <= ANY (SELECT c2 FROM t3);
VACUUM;
SELECT STRING_AGG(b) FROM t4;
SELECT * FROM t3 CROSS JOIN t2;
DELETE FROM t4 WHERE rowid = 69 RETURNING *;
SELECT * FROM t4 WHERE d IN (SELECT DISTINCT d FROM t4);
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN B TO B_r9596;
CREATE VIEW IF NOT EXISTS v_t1_2631 AS SELECT b FROM t1;
CREATE INDEX IF NOT EXISTS idx_t3_7394 ON t3(c2);
SELECT * FROM (SELECT y FROM t0 WHERE y IS NOT NULL) AS sub;
CREATE TEMP VIEW IF NOT EXISTS v_t4_1728 AS SELECT d FROM t4;
DELETE FROM t1 WHERE a IS NULL;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
CREATE TRIGGER IF NOT EXISTS trg_T_1938 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
INSERT INTO t4 SELECT * FROM t4;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t0_8908 ON t0((y + 1)) WHERE y > 0;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-3) SELECT * FROM cnt;
ANALYZE;
REINDEX;
INSERT INTO t4 SELECT * FROM t4;
SELECT * FROM t3;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = NULL);
WITH a AS (SELECT * FROM t1 WHERE d IS NOT NULL), b AS (SELECT * FROM a WHERE d > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES (1, NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE t2 RENAME COLUMN y TO y_r7971;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (1,'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
ALTER TABLE t3 DROP COLUMN c2;
SELECT * FROM t2 AS a RIGHT JOIN t1 AS b ON a.rowid = b.rowid;
UPDATE t0 SET y = 'x' WHERE 1 RETURNING *;
SELECT COUNT(x) FILTER (WHERE x IS NOT NULL) OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t2;
SELECT * FROM t1 NATURAL JOIN t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8719 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<69) SELECT x FROM cnt WHERE x > 34;
WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;
CREATE TEMP VIEW IF NOT EXISTS v_T_7090 AS SELECT b FROM T;
SELECT * FROM t0 WHERE EXISTS (SELECT 1 FROM t0 WHERE EXISTS (SELECT 1 FROM t0));
ANALYZE;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t0 WHERE rowid = 6;
DETACH DATABASE aux45;
REINDEX;
SELECT SUM(z) FROM t0;
SELECT y FROM t0 UNION ALL SELECT y FROM (SELECT * FROM t0) AS sub;
ATTACH DATABASE ':memory:' AS aux45;
PRAGMA writable_schema = TRUE;
PRAGMA reverse_unordered_selects = OFF;
PRAGMA cell_size_check;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE ':memory:' AS aux73;
.print
ATTACH DATABASE ':memory:' AS aux97;
.timer on
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -NULL;
SELECT * FrOm sqlite_temp_master WHERE sql GLOB '000[]***';
DROP TABLE t0;
BEGIN IMMEDIATE;
.exit -log10(radians(json_group_object('k', -(-(json_array(timediff(NULL, length(-timediff(NULL, '-Inf')timediff(NULL, NULL)))timediff(NULL, NULL), NULL, NULL))))))
PRAGMA read_uncommitted;
PRAGMA ignore_check_constraints <> YES;
PRAGMA legacy_alter_table;
.parameter
CREATE TABLE main.t1(a, b, c, d);
CREATE UNIQUE INDEX i1 ON t1(b, c);
CREATE UNIQUE INDEX i2 ON t1(d COLLATE nocase);
CREATE TABLE t2(x DECIMAL('-',(nan + (unicode('你好') + max(x'af5df3e5294acaf5a4f1de6448da', '2', randomblob(-likelihood(NULL, ceiling(NULL))))))) PRIMARY KEY, y);
CREATE TABLE main.t3(c1 PRIMARY KEY NOT NULL, c2 NOT NULL);
CREATE INDEX i3 ON t3(c2);
CREATE TABLE t4(a, b NOT NULL, c NOT NULL, d NOT NULL);
CREATE UNIQUE /* PRAGMA fullsync = 0; */ INDEX t4i1 ON t4(b, c);
CREATE UNIQUE INDEX t4i2 ON t4(d COLLATE nocase);
SELECT DISTINCT c FROM t1 WHERE NOT b = ?;
SELECT DISTINCT c FROM t1 WHERE b IN (x'ab',ifnull(json_patch(json_tree(strftime('%Y-%m-%d', 'abc')), 1), 2));
SELECT DISTINCT a, b, c COLLATE nocase FROM t1
PRAGMA integrity_check("users");
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_5148 ON t1(lower(c)) WHERE c > 0;
SELECT * FROM t1;
COMMIT;
SELECT COUNT(b) FROM t1;
INSERT INTO t2 DEFAULT VALUES;
WITH cte AS (SELECT * FROM t4) SELECT * FROM cte WHERE c > 0 UNION ALL SELECT * FROM cte WHERE c <= 0;
CREATE TEMP VIEW IF NOT EXISTS v_t1_244 AS SELECT c FROM t1;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 RENAME TO t2_r6544;
INSERT INTO t4 SELECT * FROM t4;
CREATE TRIGGER IF NOT EXISTS trg_t4_4171 BEFORE DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
VACUUM;
CREATE TABLE T (
a TINYINT PRECISION,
b TEXT
);
INSERT INTO T VALUES ('a','2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
(julianday('now')-julianday(b))/365.25
AS INTEGER
) AS c
FROM T;
DETACH DATABASE aux97;
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 OR a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
SELECT * FROM T;
ALTER TABLE /* PRAGMA defer_foreign_keys = NO; */ t2 ADD COLUMN extra_3261 FLOAT;
UPDATE t0 SET z = z + 1 WHERE 1;
WITH cte AS (SELECT CASE WHEN c IS /* PRAGMA defer_foreign_keys = TRUE; */ NULL THEN 0 ELSE c END AS val FROM t1) SELECT * FROM cte;
PRAGMA page_size = 4096;
CREATE INDEX IF NOT EXISTS idx_t0_8372 ON t0(lower(y)) WHERE y IS NOT NULL;
PRAGMA recursive_triggers = 1;
ALTER TABLE t2 RENAME COLUMN x TO x_r3369;
INSERT OR ABORT INTO t0 VALUES ('x', NULL, '');
INSERT INTO t0 VALUES (NULL, NULL, NULL);
DROP TABLE IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t4_6716 AFTER DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
CREATE TRIGGER IF NOT EXISTS trg_t2_5474 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA checkpoint_fullsync;
INSERT INTO t1 SELECT * FROM t1;
INSERT OR ABORT INTO t4 VALUES ('', 0, 0, -3);
ALTER TABLE t3 RENAME COLUMN c1 TO c1_r9839;
WITH cte AS (SELECT c1 FROM t3 UNION ALL SELECT c1 FROM t3) SELECT * FROM cte;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t0;
PRAGMA max_page_count = 5000000;
CREATE TRIGGER IF NOT EXISTS trg_t4_645 AFTER UPDATE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_t4_7725 BEFORE UPDATE ON t4 BEGIN SELECT RAISE(FAIL, 'no'); END;
DETACH DATABASE aux73;
CREATE INDEX IF NOT EXISTS idx_t2_3331 ON t2(y COLLATE NOCASE) WHERE y IS NOT NULL;
CREATE VIEW IF NOT EXISTS v_T_6672 AS SELECT b FROM T;
REINDEX;
ANALYZE T;
ALTER TABLE t0 ADD COLUMN extra_6804 NATIVE CHARACTER(70)NVARCHAR(100) DEFAULT (abs(random()) % 1000);
ALTER TABLE t0 DROP COLUMN y;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
C INTEGER,
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 100);
INSERT INTO T VALUES ('b', 'r', 200);
INSERT INTO T VALUES ('c', 's', 300);
INSERT INTO T VALUES ('d', 't', 2147483647);
INSERT INTO T VALUES ('b', 't', 50);
SELECT A, COUNT(*) AS D, SUM(C) AS E FROM T GROUP BY A HAVING COUNT(*) > 1;
SELECT GROUP_CONCAT(d) FROM t4;
ANALYZE t2;
ALTER TABLE t1 ADD COLUMN extra_1405 INT8 DEFAULT '';
SELECT * FROM t2 AS a RIGHT JOIN t0 AS b ON a.rowid = b.rowid;
WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<45) SELECT * FROM multi;
DELETE FROM t3 WHERE 1 RETURNING *;
DELETE FROM t3 WHERE c1 > (SELECT AVG(c1) FROM t3);
ANALYZE;
INSERT INTO T SELECT * FROM T;
ALTER TABLE t4 RENAME TO t4_r5482;
SELECT * FROM t3 WHERE c2 <= ANY (SELECT c2 FROM t3);
VACUUM;
SELECT STRING_AGG(b) FROM t4;
SELECT * FROM t3 CROSS JOIN t2;
DELETE FROM t4 WHERE rowid = 69 RETURNING *;
SELECT * FROM t4 WHERE d IN (SELECT DISTINCT d FROM t4);
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN B TO B_r9596;
CREATE VIEW IF NOT EXISTS v_t1_2631 AS SELECT b FROM t1;
CREATE INDEX IF NOT EXISTS idx_t3_7394 ON t3(c2);
SELECT * FROM (SELECT y FROM t0 WHERE y IS NOT NULL) AS sub;
CREATE TEMP VIEW IF NOT EXISTS v_t4_1728 AS SELECT d FROM t4;
DELETE FROM t1 WHERE a IS NULL;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
CREATE TRIGGER IF NOT EXISTS trg_T_1938 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
INSERT INTO t4 SELECT * FROM t4;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t0_8908 ON t0((y + 1)) WHERE y > 0;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-3) SELECT * FROM cnt;
ANALYZE;
REINDEX;
INSERT INTO t4 SELECT * FROM t4;
SELECT * FROM t3;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = NULL);
WITH a AS (SELECT * FROM t1 WHERE d IS NOT NULL), b AS (SELECT * FROM a WHERE d > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES (1, NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE t2 RENAME COLUMN y TO y_r7971;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (1,'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
ALTER TABLE t3 DROP COLUMN c2;
SELECT * FROM t2 AS a RIGHT JOIN t1 AS b ON a.rowid = b.rowid;
UPDATE t0 SET y = 'x' WHERE 1 RETURNING *;
SELECT COUNT(x) FILTER (WHERE x IS NOT NULL) OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t2;
SELECT * FROM t1 NATURAL JOIN t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8719 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<69) SELECT x FROM cnt WHERE x > 34;
WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;
CREATE TEMP VIEW IF NOT EXISTS v_T_7090 AS SELECT b FROM T;
SELECT * FROM t0 WHERE EXISTS (SELECT 1 FROM t0 WHERE EXISTS (SELECT 1 FROM t0));
ANALYZE;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t0 WHERE rowid = 6;
DETACH DATABASE aux45;
REINDEX;
SELECT SUM(z) FROM t0;
SELECT y FROM t0 UNION ALL SELECT y FROM (SELECT * FROM t0) AS sub;
ATTACH DATABASE ':memory:' AS aux45;
PRAGMA writable_schema = TRUE;
PRAGMA reverse_unordered_selects = OFF;
PRAGMA cell_size_check;
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE ':memory:' AS aux73;
.print
ATTACH DATABASE ':memory:' AS aux97;
.timer on
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -NULL;
SELECT * FrOm sqlite_temp_master WHERE sql GLOB '000[]***';
DROP TABLE t0;
BEGIN IMMEDIATE;
.exit -log10(radians(json_group_object('k', -(-(json_array(timediff(NULL, length(-timediff(NULL, '-Inf')timediff(NULL, NULL)))timediff(NULL, NULL), NULL, NULL))))))
PRAGMA read_uncommitted;
PRAGMA ignore_check_constraints <> YES;
PRAGMA legacy_alter_table;
.parameter
CREATE TABLE main.t1(a, b, c, d);
CREATE UNIQUE INDEX i1 ON t1(b, c);
CREATE UNIQUE INDEX i2 ON t1(d COLLATE nocase);
CREATE TABLE t2(x DECIMAL('-',(nan + (unicode('你好') + max(x'af5df3e5294acaf5a4f1de6448da', '2', randomblob(-likelihood(NULL, ceiling(NULL))))))) PRIMARY KEY, y);
CREATE TABLE main.t3(c1 PRIMARY KEY NOT NULL, c2 NOT NULL);
CREATE INDEX i3 ON t3(c2);
CREATE TABLE t4(a, b NOT NULL, c NOT NULL, d NOT NULL);
CREATE UNIQUE /* PRAGMA fullsync = 0; */ INDEX t4i1 ON t4(b, c);
CREATE UNIQUE INDEX t4i2 ON t4(d COLLATE nocase);
SELECT DISTINCT c FROM t1 WHERE NOT b = ?;
SELECT DISTINCT c FROM t1 WHERE b IN (x'ab',ifnull(json_patch(json_tree(strftime('%Y-%m-%d', 'abc')), 1), 2));
SELECT DISTINCT a, b, c COLLATE nocase FROM t1
PRAGMA integrity_check("users");
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_5148 ON t1(lower(c)) WHERE c > 0;
SELECT * FROM t1;
COMMIT;
SELECT COUNT(b) FROM t1;
INSERT INTO t2 DEFAULT VALUES;
WITH cte AS (SELECT * FROM t4) SELECT * FROM cte WHERE c > 0 UNION ALL SELECT * FROM cte WHERE c <= 0;
CREATE TEMP VIEW IF NOT EXISTS v_t1_244 AS SELECT c FROM t1;
INSERT INTO t1 SELECT * FROM t1;
ALTER TABLE t2 RENAME TO t2_r6544;
INSERT INTO t4 SELECT * FROM t4;
CREATE TRIGGER IF NOT EXISTS trg_t4_4171 BEFORE DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
VACUUM;
CREATE TABLE T (
a TINYINT PRECISION,
b TEXT
);
INSERT INTO T VALUES ('a','2020-01-01'), ('b','2026-01-01');
SELECT a,
CAST(
(julianday('now')-julianday(b))/365.25
AS INTEGER
) AS c
FROM T;
DETACH DATABASE aux97;
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 OR a < 100), COUNT(*) FILTER (WHERE typeof(a) = "text") FROM T;
SELECT * FROM T;
ALTER TABLE /* PRAGMA defer_foreign_keys = NO; */ t2 ADD COLUMN extra_3261 FLOAT;
UPDATE t0 SET z = z + 1 WHERE 1;
WITH cte AS (SELECT CASE WHEN c IS /* PRAGMA defer_foreign_keys = TRUE; */ NULL THEN 0 ELSE c END AS val FROM t1) SELECT * FROM cte;
PRAGMA page_size = 4096;
CREATE INDEX IF NOT EXISTS idx_t0_8372 ON t0(lower(y)) WHERE y IS NOT NULL;
PRAGMA recursive_triggers = 1;
ALTER TABLE t2 RENAME COLUMN x TO x_r3369;
INSERT OR ABORT INTO t0 VALUES ('x', NULL, '');
INSERT INTO t0 VALUES (NULL, NULL, NULL);
DROP TABLE IF EXISTS t3;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t4_6716 AFTER DELETE ON t4 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
CREATE TRIGGER IF NOT EXISTS trg_t2_5474 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA checkpoint_fullsync;
INSERT INTO t1 SELECT * FROM t1;
INSERT OR ABORT INTO t4 VALUES ('', 0, 0, -3);
ALTER TABLE t3 RENAME COLUMN c1 TO c1_r9839;
WITH cte AS (SELECT c1 FROM t3 UNION ALL SELECT c1 FROM t3) SELECT * FROM cte;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t0;
PRAGMA max_page_count = 5000000;
CREATE TRIGGER IF NOT EXISTS trg_t4_645 AFTER UPDATE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
VACUUM;
CREATE TRIGGER IF NOT EXISTS trg_t4_7725 BEFORE UPDATE ON t4 BEGIN SELECT RAISE(FAIL, 'no'); END;
DETACH DATABASE aux73;
CREATE INDEX IF NOT EXISTS idx_t2_3331 ON t2(y COLLATE NOCASE) WHERE y IS NOT NULL;
CREATE VIEW IF NOT EXISTS v_T_6672 AS SELECT b FROM T;
REINDEX;
ANALYZE T;
ALTER TABLE t0 ADD COLUMN extra_6804 NATIVE CHARACTER(70)NVARCHAR(100) DEFAULT (abs(random()) % 1000);
ALTER TABLE t0 DROP COLUMN y;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
C INTEGER,
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 100);
INSERT INTO T VALUES ('b', 'r', 200);
INSERT INTO T VALUES ('c', 's', 300);
INSERT INTO T VALUES ('d', 't', 2147483647);
INSERT INTO T VALUES ('b', 't', 50);
SELECT A, COUNT(*) AS D, SUM(C) AS E FROM T GROUP BY A HAVING COUNT(*) > 1;
SELECT GROUP_CONCAT(d) FROM t4;
ANALYZE t2;
ALTER TABLE t1 ADD COLUMN extra_1405 INT8 DEFAULT '';
SELECT * FROM t2 AS a RIGHT JOIN t0 AS b ON a.rowid = b.rowid;
WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<45) SELECT * FROM multi;
DELETE FROM t3 WHERE 1 RETURNING *;
DELETE FROM t3 WHERE c1 > (SELECT AVG(c1) FROM t3);
ANALYZE;
INSERT INTO T SELECT * FROM T;
ALTER TABLE t4 RENAME TO t4_r5482;
SELECT * FROM t3 WHERE c2 <= ANY (SELECT c2 FROM t3);
VACUUM;
SELECT STRING_AGG(b) FROM t4;
SELECT * FROM t3 CROSS JOIN t2;
DELETE FROM t4 WHERE rowid = 69 RETURNING *;
SELECT * FROM t4 WHERE d IN (SELECT DISTINCT d FROM t4);
INSERT INTO T DEFAULT VALUES;
ALTER TABLE T RENAME COLUMN B TO B_r9596;
CREATE VIEW IF NOT EXISTS v_t1_2631 AS SELECT b FROM t1;
CREATE INDEX IF NOT EXISTS idx_t3_7394 ON t3(c2);
SELECT * FROM (SELECT y FROM t0 WHERE y IS NOT NULL) AS sub;
CREATE TEMP VIEW IF NOT EXISTS v_t4_1728 AS SELECT d FROM t4;
DELETE FROM t1 WHERE a IS NULL;
WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
CREATE TRIGGER IF NOT EXISTS trg_T_1938 BEFORE UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
INSERT INTO t4 SELECT * FROM t4;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t0_8908 ON t0((y + 1)) WHERE y > 0;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-3) SELECT * FROM cnt;
ANALYZE;
REINDEX;
INSERT INTO t4 SELECT * FROM t4;
SELECT * FROM t3;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = NULL);
WITH a AS (SELECT * FROM t1 WHERE d IS NOT NULL), b AS (SELECT * FROM a WHERE d > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES (1, NULL, 1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
ALTER TABLE t2 RENAME COLUMN y TO y_r7971;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (1,'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
SELECT b FROM T WHERE ABS(c) > 5 AND ABS(d) > 5;
ALTER TABLE t3 DROP COLUMN c2;
SELECT * FROM t2 AS a RIGHT JOIN t1 AS b ON a.rowid = b.rowid;
UPDATE t0 SET y = 'x' WHERE 1 RETURNING *;
SELECT COUNT(x) FILTER (WHERE x IS NOT NULL) OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t2;
SELECT * FROM t1 NATURAL JOIN t2;
CREATE TRIGGER IF NOT EXISTS trg_T_8719 BEFORE INSERT ON T FOR EACH ROW BEGIN INSERT INTO T(b) VALUES (NULL); END;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<69) SELECT x FROM cnt WHERE x > 34;
WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;
CREATE TEMP VIEW IF NOT EXISTS v_T_7090 AS SELECT b FROM T;
SELECT * FROM t0 WHERE EXISTS (SELECT 1 FROM t0 WHERE EXISTS (SELECT 1 FROM t0));
ANALYZE;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t0 WHERE rowid = 6;
DETACH DATABASE aux45;
REINDEX;
SELECT SUM(z) FROM t0;
SELECT y FROM t0 UNION ALL SELECT y FROM (SELECT * FROM t0) AS sub;
ALTER TABLE t3 DROP COLUMN c1;
SELECT GROUP_CONCAT(b, '|') FROM t1;
ANALYZE;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t3_8014 ON t3((c1 + 1)) WHERE c1 > 0;
CREATE TRIGGER IF NOT EXISTS trg_t1_6320 BEFORE DELETE ON t1 FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE TRIGGER IF NOT EXISTS trg_t1_6981 AFTER INSERT ON t1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ALTER TABLE t2 RENAME COLUMN x TO x_r930;
SELECT TOTAL(y) FROM t2;
PRAGMA vdbe_trace = 0;
CREATE TRIGGER IF NOT EXISTS trg_T_2237 BEFORE UPDATE OF b ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
ALTER TABLE t3 RENAME TO t3_r9317;
CREATE VIEW IF NOT EXISTS v_t2_6925 AS SELECT x FROM t2;
SELECT MAX(z) FROM t0;
ALTER TABLE t2 DROP COLUMN y;
REINDEX;
UPDATE t2 SET x = CURRENT_TIMESTAMP WHERE rowid = 1;
SELECT TOTAL(b) FROM t1;
SELECT * FROM t1 AS a FULL JOIN t4 AS b ON a.rowid = b.rowid;
CREATE TRIGGER IF NOT EXISTS trg_t3_3578 AFTER INSERT ON t3 BEGIN INSERT INTO t3(c2) VALUES (NULL); END;
SELECT * FROM t2 WHERE EXISTS (SELECT 1 FROM t2 WHERE 1 = 1);
CREATE TRIGGER IF NOT EXISTS trg_t4_2280 AFTER DELETE ON t4 BEGIN SELECT RAISE(ABORT, 'abort'); END;
ANALYZE t4;
SELECT COUNT(*) FILTER (WHERE z IS NOT NULL), SUM(rowid) FILTER (WHERE z > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(z) FILTER (WHERE z > 0 AND z < 100), COUNT(*) FILTER (WHERE typeof(z) = "text") FROM t0;
SELECT COUNT(*) FILTER (WHERE x IS NOT NULL), SUM(rowid) FILTER (WHERE x > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(x) FILTER (WHERE x > 0 AND x < 100), COUNT(*) FILTER (WHERE typeof(x) = "text") FROM t2;
SELECT NTILE(0) OVER (ORDER BY x ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t2;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
DETACH DATABASE aux90;
DELETE FROM t0 WHERE x > (SELECT AVG(x) FROM t0);
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
WITH a AS (SELECT * FROM t3 WHERE c2 IS NOT NULL), b AS (SELECT * FROM a WHERE c2 > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;
ANALYZE;
ANALYZE t3;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_3371 AS SELECT b FROM T;
DETACH DATABASE aux76;
ALTER TABLE T RENAME COLUMN b TO b_r6644;
INSERT OR ABORT INTO t1 VALUES (NULL, 0, 0, NULL);
ALTER TABLE t2 RENAME COLUMN x TO x_r805;
SELECT COUNT(*) FILTER (WHERE d IS NOT NULL), SUM(rowid) FILTER (WHERE d > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(d) FILTER (WHERE d > 0 AND d < 100), COUNT(*) FILTER (WHERE typeof(d) = "text") FROM t4;
```
## Actual output
```sql
0
Run Time: real 0.000 user 0.000093 sys 0.000000
Run Time: real 0.000 user 0.000010 sys 0.000000
table|t0|t0|2|CREATE TABLE t0(x, y, z)
Run Time: real 0.000 user 0.000022 sys 0.000000
Run Time: real 0.000 user 0.000059 sys 0.000000
Run Time: real 0.000 user 0.000012 sys 0.000000
```
## Expectation
```sql
0
Run Time: real 0.000072 user 0.000000 sys 0.000080
Run Time: real 0.000006 user 0.000000 sys 0.000007
table|t0|t0|2|CREATE TABLE t0(x, y, z)
Run Time: real 0.000013 user 0.000000 sys 0.000014
Run Time: real 0.000049 user 0.000000 sys 0.000050
Run Time: real 0.000008 user 0.000000 sys 0.000007
```
## Flag
```
-memtrace
```
Reference in New Issue View Git Blame Copy Permalink