admin/ast-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

---

Browse Source
This commit is contained in:
[Quy Anh] «Elliot» Nguyen
2026-06-24 13:47:14 +02:00
commit fd930e15cb
2377 changed files with 1213931 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitattributes
+1
View File
@@ -0,0 +1 @@
*.db filter=lfs diff=lfs merge=lfs -text
.gitignore
+9
View File
@@ -0,0 +1,9 @@
.DS_Store
.vscode
**__pycache__**
part1/.env
part1/bugs
part1/shuffle.py
part1/metrics.py
part2/.env
README.md
+2
View File
@@ -0,0 +1,2 @@
# SQLite Fuzzer & Reducer
[263-2815-00L] Automated Software Testing @ ETHZ
[Part 1] Automated Bug Detection in Database Engines.pdf
BIN
View File
Binary file not shown.
[Part 1] FAQ.pdf
BIN
View File
Binary file not shown.
[Part 2] Automated Reduction of Bug-Triggering Queries.pdf
BIN
View File
Binary file not shown.
[Part 2] FAQ.pdf
BIN
View File
Binary file not shown.
part1/Dockerfile
+41
View File
@@ -0,0 +1,41 @@
FROM theosotr/sqlite3-test AS base
FROM python:3.14.4-slim-trixie AS build
USER root
RUN apt-get update
RUN apt-get install build-essential tcl -y
RUN rm -rf /var/lib/apt/lists/*
RUN mkdir /home/test
COPY --from=base /home/test/seeds /home/test/seeds
COPY --from=base /usr/bin/sqlite3 /usr/bin/
COPY --from=base /home/test/sqlite3-src /home/test/sqlite3-src
COPY rot13.c /home/test/sqlite3-src/build/
# Instrument SQLite with gcov
RUN cd /home/test/sqlite3-src/build && ../configure CFLAGS="--coverage -g -O0" && make clean && make -j$(nproc)
RUN cd /home/test/sqlite3-src/build && ../configure CFLAGS="--coverage -g -O0" && gcc -g -fPIC -shared rot13.c -o rot13.so
COPY requirements.txt ./
RUN pip install -r requirements.txt
RUN ln -s /usr/bin/python3 /usr/bin/python 2>/dev/null || true
FROM build
WORKDIR /fuzzer
COPY fuzzer.py mutator_extra_statements.py mutator_corpus_splicing.py mutator_equivalent_rewrites.py mutator_operators.py mutator_values.py mutator.py oracle.py runner.py sqlite_static_helper.py stats.py entrypoint.sh additional.sql *.db ./
RUN echo "SELECT 1;" > commands.sql
# Project Spec: "The executable file of your tool must be called /usr/bin/test-db inside the Docker image."
COPY entrypoint.sh /usr/bin/test-db
RUN chmod +x /usr/bin/test-db
ENTRYPOINT ["/usr/bin/test-db"]
part1/README.md
+41
View File
@@ -0,0 +1,41 @@
## Instructions
### Build
```bash
docker build -t fuzzer .
```
### Fuzz
```bash
docker run -it -v "$(pwd)/bugs:/fuzzer/bugs" fuzzer
```
### Additional Options
#### Get a shell
```bash
docker run -it -v "$(pwd)/bugs:/fuzzer/bugs" --entrypoint bash fuzzer
```
#### Flags
| Flag | Default | Description |
| -------------------- | -------------------------------------- | ------------------------------------------------------------------------- |
| `--seeds` | `/home/test/seeds` | Directory containing seed `.sql` files for mutation |
| `--buggy` | `/home/test/sqlite3-src/build/sqlite3` | Path to the buggy SQLite binary being tested |
| `--reference` | `/usr/bin/sqlite3` | Path to the reference SQLite binary for comparison |
| `--count` | `10000` | Number of queries to generate and execute |
| `--mutate-timeout` | `0.5` | Per-mutation timeout in seconds (prevents hanging mutations) |
| `--max-query-length` | `100000` | Hard character limit for generated queries (longer queries reset to seed) |
| `--workers` | `multiprocessing.cpu_count()` | Number of parallel `check()` worker threads |
| `--validate-seeds` | `False` | Run upfront validation pass on all seeds before fuzzing |
| `--run-baseline` | `False` | Run seeds without mutation (baseline coverage measurement) |
#### Customize the fuzzer, e.g.
```bash
test-db --validate-seeds --count 5000 --mutate-timeout 0.1 --max-query-length 100000
```
part1/Report.pdf
BIN
View File
Binary file not shown.
part1/additional.sql
+501
View File
@@ -0,0 +1,501 @@
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
---
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
---
CREATE TEMPORARY TABLE t0(x, y, z);
SELECT -99999999999999999999999999999999999999999999999999;
SELECT * FROM sqlite_temp_master WHERE sql GLOB '000[]***';
DROP TABLE t0;
---
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
---
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
---
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE c > 0;
---
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
---
CREATE TABLE T (
a INTEGER,
b TEXT,
c INTEGER
);
INSERT INTO T VALUES (1,'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
SELECT *,1 FROM T WHERE c IS NULL
UNION ALL
SELECT T.a,T.b,T.c,d.e+1
FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
---
CREATE TABLE T (
a TEXT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',1.5), ('a','c',-2.25), ('b','b',4.75);
SELECT a,
SUM(CASE WHEN b='b' THEN c ELSE 0 END) AS d,
SUM(CASE WHEN b='c' THEN c ELSE 0 END) AS e
FROM T
GROUP BY a;
---
CREATE TABLE T (
a TEXT,
b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
---
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
---
CREATE TABLE T (
a TEXT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
---
CREATE TABLE T1 (
a INTEGER,
b TEXT
);
CREATE TABLE T2 (
a INTEGER,
b TEXT
);
INSERT INTO T1 VALUES (1,'a'),(2,'b');
INSERT INTO T2 VALUES (1,'c'),(1,'d');
SELECT T1.b,
(
SELECT GROUP_CONCAT(b,',')
FROM T2
WHERE T2.a=T1.a
) AS c
FROM T1;
---
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;
---
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 AND b < 2.0;
---
CREATE TABLE T (
a TEXT,
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;
---
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE c < 2.0 ORDER BY c;
---
CREATE TABLE T (
a TEXT,
b INTEGER,
c REAL
);
INSERT INTO T VALUES ('a',1,2.0), ('a',2,-3.0), ('b',1,4.5);
SELECT a,b,c,
SUM(c) OVER (
PARTITION BY a
ORDER BY b
) AS d
FROM T;
---
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
---
CREATE VIRTUAL TABLE T
USING fts5(a,b);
INSERT INTO T VALUES ('a','b c'), ('d','e f');
SELECT a,b FROM T WHERE T MATCH 'b';
---
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
---
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE b < 2.0 ORDER BY b;
---
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-7.25), (3,0.0);
SELECT a,b FROM T WHERE a >= 2 ORDER BY b;
---
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;
---
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
---
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(30),
C VARCHAR(30),
PRIMARY KEY (A, B),
UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
---
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
---
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15),
C BIGINT,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -9223372036854775808);
INSERT INTO T VALUES ('b', 'q', 4000);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('d', 'r', 9223372036854775807);
INSERT INTO T VALUES ('e', 's', 0);
SELECT A, C FROM T WHERE C > 1200 AND C < 9999999999 ORDER BY C;
---
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;
---
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(10),
PRIMARY KEY (A, B)
);
INSERT INTO T VALUES ('a', 'p');
INSERT INTO T VALUES ('a', 'q');
INSERT INTO T VALUES ('b', 'q');
INSERT INTO T VALUES ('c', 'r');
INSERT INTO T VALUES ('b', 'r');
INSERT INTO T VALUES ('b', 't');
SELECT B, COUNT(DISTINCT A) AS D FROM T GROUP BY B ORDER BY D DESC, B ASC;
---
CREATE TABLE T1 (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(10) PRIMARY KEY,
X VARCHAR(15) NOT NULL,
C BIGINT,
FOREIGN KEY (X) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('p', 'x');
INSERT INTO T1 VALUES ('q', 'y');
INSERT INTO T2 VALUES ('a', 'p', 9223372036854775807);
INSERT INTO T2 VALUES ('b', 'q', -9223372036854775808);
SELECT X, SUM(C) AS D, COUNT(*) AS E FROM T2 GROUP BY X;
---
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C INTEGER
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10) NOT NULL UNIQUE,
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
---
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
---
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
---
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;
---
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
---
CREATE TABLE T1 (
A VARCHAR(20) PRIMARY KEY,
X VARCHAR(10) UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(20) PRIMARY KEY,
Y VARCHAR(10) UNIQUE
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
INSERT INTO T2 VALUES ('c', 'l');
SELECT A FROM T1 INTERSECT SELECT A FROM T2;
---
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10),
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 EXCEPT SELECT A FROM T2;
part1/bug-reproducers/1/README.md
+38
View File
@@ -0,0 +1,38 @@
## 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).-->
We reran the query multiple time, but the output does not change. It is a logic bug because the output is different
## Minimized query
```sql
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (substring(-pi(), random() % if(1, NULL, 100)),'' || ('a'),1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE NOT c < 2.0 ORDER BY c;
ALTER TABLE T RENAME COLUMN c TO c_r522;
INSERT INTO T SELECT * FROM T;
SELECT COUNT(*) FROM T;
```
## Actual output
```sql
0
```
## Expectation
```sql
6
```
## Flag
```
```
part1/bug-reproducers/1/original_test.sql
+11
View File
@@ -0,0 +1,11 @@
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (substring(-pi(), random() % if(1, NULL, 100)),'' || ('a'),1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE NOT c < 2.0 ORDER BY c;
ALTER TABLE T RENAME COLUMN c TO c_r522;
INSERT INTO T SELECT * FROM T;
SELECT COUNT(*) FROM T;
part1/bug-reproducers/1/reduced_test.sql
+7
View File
@@ -0,0 +1,7 @@
CREATE TABLE t(a, b, c);
INSERT INTO t VALUES (1,'a',1.25),(2,'b',-3.5),(3,'c',0.0);
ALTER TABLE t RENAME COLUMN c TO c_new;
INSERT INTO t SELECT * FROM t;
SELECT COUNT(*) FROM t;
part1/bug-reproducers/10/README.md
+64
View File
@@ -0,0 +1,64 @@
## 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).-->
We think that the patched version just ignores the third select statement, and therefore does not print out the second table.
## Minimized query
```sql
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (if(ifnull(x'be83e7457352932f', round(2)), 1, 0, 1, 0, 1),2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
BEGIN IMMEDIATE;
PRAGMA parser_trace = OFF;
PRAGMA empty_result_callbacks = TRUE;
CREATE TABLE t1(a INT, b INT);
CREATE TABLE t2(c INT, d INT);
CREATE TABLE t3(e TEXT, f TEXT);
INSERT INTO t1 VALUES('𝕊𝕢𝕝', 1);
INSERT INTO t2 VALUES(1, 2);
INSERT INTO t3 VALUES('abc', 'def');
SELECT * FROM t1, t2 LEFT JOIN t3 ON (t2.d=1) WHERE t2.c = +t1.a;
SELECT * FROM t1 LEFT JOIN t2 ON (t2.c=+t1.a) LEFT JOIN t3 ON (t2.d IS NULL);
SELECT * FROM t2;
SELECT MIN(b) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t1;
COMMIT;
ALTER TABLE t2 RENAME TO /* PRAGMA count_changes = TRUE; */ t2_r1545;
INSERT OR FAIL INTO t3 VALUES ('x', 0);
ANALYZE;
DELETE FROM t1 WHERE rowid = 15 RETURNING *;
SELECT * FROM T AS a LEFT OUTER JOIN t1 AS b ON a.rowid = b.rowid;
```
## Actual output
```sql
???|1|||abc|def
1|2
1
```
## Expectation
```sql
|21.0
1|-70.875
2|-Inf
𝕊𝕢𝕝|1|||abc|def
1|2
1
|2.0|10.5|𝕊𝕢𝕝|1
1|-3.5|20.25||
2|Inf|-1.0||
```
## Flag
```
```
part1/bug-reproducers/10/original_test.sql
+27
View File
@@ -0,0 +1,27 @@
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (if(ifnull(x'be83e7457352932f', round(2)), 1, 0, 1, 0, 1),2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
BEGIN IMMEDIATE;
PRAGMA parser_trace = OFF;
PRAGMA empty_result_callbacks = TRUE;
CREATE TABLE t1(a INT, b INT);
CREATE TABLE t2(c INT, d INT);
CREATE TABLE t3(e TEXT, f TEXT);
INSERT INTO t1 VALUES('𝕊𝕢𝕝', 1);
INSERT INTO t2 VALUES(1, 2);
INSERT INTO t3 VALUES('abc', 'def');
SELECT * FROM t1, t2 LEFT JOIN t3 ON (t2.d=1) WHERE t2.c = +t1.a;
SELECT * FROM t1 LEFT JOIN t2 ON (t2.c=+t1.a) LEFT JOIN t3 ON (t2.d IS NULL);
SELECT * FROM t2;
SELECT MIN(b) OVER (PARTITION BY b ORDER BY b RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t1;
COMMIT;
ALTER TABLE t2 RENAME TO /* PRAGMA count_changes = TRUE; */ t2_r1545;
INSERT OR FAIL INTO t3 VALUES ('x', 0);
ANALYZE;
DELETE FROM t1 WHERE rowid = 15 RETURNING *;
SELECT * FROM T AS a LEFT OUTER JOIN t1 AS b ON a.rowid = b.rowid;
part1/bug-reproducers/10/reduced_test.sql
+16
View File
@@ -0,0 +1,16 @@
CREATE TABLE t1(a INT, b INT);
CREATE TABLE t2(c INT, d INT);
CREATE TABLE t3(e TEXT, f TEXT);
INSERT INTO t1 VALUES('x',1);
INSERT INTO t2 VALUES(1,2);
SELECT *
FROM t1, t2
LEFT JOIN t3 ON (t2.d=1)
WHERE t2.c = +t1.a;
SELECT *
FROM t1
LEFT JOIN t2 ON (t2.c=+t1.a)
LEFT JOIN t3 ON (t2.d IS NULL);
part1/bug-reproducers/11/README.md
+72
View File
@@ -0,0 +1,72 @@
## 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).-->
We think this is a bug, where it is visible which features were disabled on the patched version, in this case especially with the ASCII flag
## Minimized query
```sql
BEGIN EXCLUSIVE;
PRAGMA case_sensitive_like = ON;
-- typeof(NULL)
PRAGMA full_column_names = NO;
PRAGMA count_changes = 1;
.mode
DROP TABLE IF EXISTS t1;
CREATE TABLE t1 (c0, c1 REAL PRIMARY KEY);
INSERT INTO t1(c0, c1) VALUES (0, 1), (0, 0);
UPDATE t1 SET c0 = NULL;
UPDATE OR REPLACE t1 SET c1 = 1;
SELECT DISTINCT * FROM t1 WHERE NOT NOT ((t1.c0 IS NULL)) ;
PRAGMA integrity_check;
CREATE INDEX IF NOT EXISTS idx_t1_1624 ON t1((c0 + 1)) WHERE +c0 > 0;
SELECT COUNT(c0) FROM t1;
SELECT SUM(c1) FROM t1;
COMMIT TRANSACTION;
CREATE INDEX IF NOT EXISTS idx_t1_2854 ON t1(lower(c1));
ANALYZE t1;
SELECT COUNT(*) FROM t1;
SELECT * FROM t1 WHERE c1 IN (SELECT c1 FROM t1 LIMIT 1);
VACUUM main;
DELETE FROM t1 WHERE c0 > (SELECT AVG(c0) FROM t1) RETURNING *;
```
## Actual output
```sql
current output mode: list
2
2
2
|1.0
ok
0
1.0
1
|1.0
```
## Expectation
```sql
current output mode: list --escape ascii
2
2
2
|1.0
ok
0
1.0
1
|1.0
```
## Flag
```
-noheader
```
part1/bug-reproducers/11/original_test.sql
+27
View File
@@ -0,0 +1,27 @@
BEGIN EXCLUSIVE;
PRAGMA case_sensitive_like = ON;
-- typeof(NULL)
PRAGMA full_column_names = NO;
PRAGMA count_changes = 1;
.mode
DROP TABLE IF EXISTS t1;
CREATE TABLE t1 (c0, c1 REAL PRIMARY KEY);
INSERT INTO t1(c0, c1) VALUES (0, 1), (0, 0);
UPDATE t1 SET c0 = NULL;
UPDATE OR REPLACE t1 SET c1 = 1;
SELECT DISTINCT * FROM t1 WHERE NOT NOT ((t1.c0 IS NULL)) ;
PRAGMA integrity_check;
CREATE INDEX IF NOT EXISTS idx_t1_1624 ON t1((c0 + 1)) WHERE +c0 > 0;
SELECT COUNT(c0) FROM t1;
SELECT SUM(c1) FROM t1;
COMMIT TRANSACTION;
CREATE INDEX IF NOT EXISTS idx_t1_2854 ON t1(lower(c1));
ANALYZE t1;
SELECT COUNT(*) FROM t1;
SELECT * FROM t1 WHERE c1 IN (SELECT c1 FROM t1 LIMIT 1);
VACUUM main;
DELETE FROM t1 WHERE c0 > (SELECT AVG(c0) FROM t1) RETURNING *;
part1/bug-reproducers/11/reduced_test.sql
+12
View File
@@ -0,0 +1,12 @@
CREATE TABLE t1(c0, c1 REAL PRIMARY KEY);
INSERT INTO t1 VALUES (0,1), (0,0);
UPDATE t1 SET c0=NULL;
UPDATE OR REPLACE t1 SET c1=1;
SELECT DISTINCT *
FROM t1
WHERE c0 IS NULL;
SELECT COUNT(*) FROM t1;
part1/bug-reproducers/12/README.md
+34
View File
@@ -0,0 +1,34 @@
## 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).-->
We believe the query is already reduced. The issue for this bug is most likely the "BETWEEN" keyword
## Minimized query
```sql
CREATE TABLE t0(c0);
INSERT INTO t0(c0) VALUES (NULL);
CREATE INDEX i0 ON t0(1) WHERE c0 NOT NULL;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) IS FALSE;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) BETWEEN FALSE AND TRUE;
```
## Actual output
```sql
1
```
## Expectation
```sql
1
1
```
## Flag
```
```
part1/bug-reproducers/12/original_test.sql
+5
View File
@@ -0,0 +1,5 @@
CREATE TABLE t0(c0);
INSERT INTO t0(c0) VALUES (NULL);
CREATE INDEX i0 ON t0(1) WHERE c0 NOT NULL;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) IS FALSE;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) BETWEEN FALSE AND TRUE;
part1/bug-reproducers/12/reduced_test.sql
+5
View File
@@ -0,0 +1,5 @@
CREATE TABLE t0(c0);
INSERT INTO t0(c0) VALUES (NULL);
CREATE INDEX i0 ON t0(1) WHERE c0 NOT NULL;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) IS FALSE;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) BETWEEN FALSE AND TRUE;
part1/bug-reproducers/2/README.md
+213
View File
@@ -0,0 +1,213 @@
## 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).-->
The queries added new columns with 123. Probably "INTERSECT" is wrong. It is a logic bug because the output is different
## Minimized query
```sql
ATTACH DATABASE ':memory:' AS aux12;
PRAGMA fullfsync;
PRAGMA automatic_index = ON;
PRAGMA wal_checkpoint;
.tables
CREATE TABLE t1(c1);
INSERT INTO t1 VALUES(if(2147483647, 12, 0, 12, 0, 12, 12)),(123),(1234),(NULL),('abc');
CREATE TABLE "t2"(c2);
INSERT INTO t2 VALUES(44),(55),(123);
CREATE TABLE t3(c3,c4);
INSERT INTO t3 VALUES(66,1),(123,2),(77,3);
CREATE VIEW t4 AS SELECT c3 FROM t3;
CREATE VIEW t5 AS SELECT c3 FROM t3 ORDER BY c4;
SELECT * FROM t1, t2 WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM t4) AND c1=123;
SELECT * FROM t1, t2 WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM t5) AND c1=123;
SELECT COUNT(*) FROM t1;
ANALYZE;
INSERT OR IGNORE INTO t1 VALUES ('');
SELECT * FROM t1 WHERE c1 = (SELECT SUM(c1) FROM t1);
INSERT INTO t2 DEFAULT VALUES;
SELECT COUNT(*) FROM t1;
ANALYZE;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<63) SELECT * FROM cnt;
ANALYZE;
SELECT COUNT(*) FROM t3;
ANALYZE t2;
ANALYZE;
CREATE TEMP VIEW IF NOT EXISTS v_t1_9829 AS SELECT c1 FROM t1;
WITH cte AS (SELECT c3, LEAD(c3) OVER (ORDER BY c3) AS nxt FROM t3) SELECT * FROM cte;
SELECT * FROM t1 NATURAL JOIN t1;
REINDEX;
PRAGMA foreign_keys = YES;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_t1_6595 BEFORE UPDATE OF c1 ON t1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
DETACH DATABASE aux12;
INSERT INTO t1 DEFAULT VALUES;
```
## Actual output
```sql
0
0|-1|-1
0
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
3
66|77
77|123
123|
```
## Expectation
```sql
0
0|-1|-1
123|123
123|123
5
6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
3
66|77
77|123
123|
12
123
1234
abc
```
## Flag
```
```
part1/bug-reproducers/2/original_test.sql
+40
View File
@@ -0,0 +1,40 @@
ATTACH DATABASE ':memory:' AS aux12;
PRAGMA fullfsync;
PRAGMA automatic_index = ON;
PRAGMA wal_checkpoint;
.tables
CREATE TABLE t1(c1);
INSERT INTO t1 VALUES(if(2147483647, 12, 0, 12, 0, 12, 12)),(123),(1234),(NULL),('abc');
CREATE TABLE "t2"(c2);
INSERT INTO t2 VALUES(44),(55),(123);
CREATE TABLE t3(c3,c4);
INSERT INTO t3 VALUES(66,1),(123,2),(77,3);
CREATE VIEW t4 AS SELECT c3 FROM t3;
CREATE VIEW t5 AS SELECT c3 FROM t3 ORDER BY c4;
SELECT * FROM t1, t2 WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM t4) AND c1=123;
SELECT * FROM t1, t2 WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM t5) AND c1=123;
SELECT COUNT(*) FROM t1;
ANALYZE;
INSERT OR IGNORE INTO t1 VALUES ('');
SELECT * FROM t1 WHERE c1 = (SELECT SUM(c1) FROM t1);
INSERT INTO t2 DEFAULT VALUES;
SELECT COUNT(*) FROM t1;
ANALYZE;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<63) SELECT * FROM cnt;
ANALYZE;
SELECT COUNT(*) FROM t3;
ANALYZE t2;
ANALYZE;
CREATE TEMP VIEW IF NOT EXISTS v_t1_9829 AS SELECT c1 FROM t1;
WITH cte AS (SELECT c3, LEAD(c3) OVER (ORDER BY c3) AS nxt FROM t3) SELECT * FROM cte;
SELECT * FROM t1 NATURAL JOIN t1;
REINDEX;
PRAGMA foreign_keys = YES;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_t1_6595 BEFORE UPDATE OF c1 ON t1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
DETACH DATABASE aux12;
INSERT INTO t1 DEFAULT VALUES;
part1/bug-reproducers/2/reduced_test.sql
+17
View File
@@ -0,0 +1,17 @@
CREATE TABLE t1(c1);
INSERT INTO t1 VALUES(123);
CREATE TABLE t2(c2);
INSERT INTO t2 VALUES(123);
CREATE TABLE t3(c3,c4);
INSERT INTO t3 VALUES(123,2);
CREATE VIEW v1 AS SELECT c3 FROM t3;
CREATE VIEW v2 AS SELECT c3 FROM t3 ORDER BY c4;
SELECT * FROM t1, t2
WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM v1);
SELECT * FROM t1, t2
WHERE c1=(SELECT 123 INTERSECT SELECT c2 FROM v2);
part1/bug-reproducers/3/README.md
+47
View File
@@ -0,0 +1,47 @@
## 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).-->
It is a logic bug because the output is different. We think the bug comes from the "SELECT" statement.
## Minimized query
```sql
SAVEPOINT sp2283;
SAVEPOINT sp8775;
CREATE TABLE t1(c, b, a, PRIMARY KEY(b, a)) WITHOUT ROWID;
INSERT INTO t1 VALUES(atan(-CAST(jsonb_array() AS BOOLEAN)), 2, 3), (4, 5, 6);
ALTER TABLE t1 DROP c;
CREATE TABLE main.x1234(a, b, c PRIMARY KEY) WITHOUT ROWID;
CREATE INDEX i1 ON x1234(b) WHERE ((a+5) % 10)==0;
ALTER TABLE x1234 ADD COLUMN extra_949 FLOAT DEFAULT NULL;
UPDATE t1 SET b = '' RETURNING *;
DELETE FROM t1 WHERE 1;
ALTER TABLE x1234 RENAME TO x1234_r6899;
WITH cte AS (SELECT * FROM t1 WHERE a = (SELECT MAX(a) FROM t1)) SELECT * FROM cte;
PRAGMA fullfsync;
ALTER TABLE t1 RENAME TO t1_r3;
RELEASE sp8775;
ROLLBACK TRANSACTION TO SAVEPOINT sp2283;
RELEASE SAVEPOINT sp2283;
```
## Actual output
```sql
0
```
## Expectation
```sql
|3
|6
0
```
## Flag
```
```
part1/bug-reproducers/3/original_test.sql
+18
View File
@@ -0,0 +1,18 @@
SAVEPOINT sp2283;
SAVEPOINT sp8775;
CREATE TABLE t1(c, b, a, PRIMARY KEY(b, a)) WITHOUT ROWID;
INSERT INTO t1 VALUES(atan(-CAST(jsonb_array() AS BOOLEAN)), 2, 3), (4, 5, 6);
ALTER TABLE t1 DROP c;
CREATE TABLE main.x1234(a, b, c PRIMARY KEY) WITHOUT ROWID;
CREATE INDEX i1 ON x1234(b) WHERE ((a+5) % 10)==0;
ALTER TABLE x1234 ADD COLUMN extra_949 FLOAT DEFAULT NULL;
UPDATE t1 SET b = '' RETURNING *;
DELETE FROM t1 WHERE 1;
ALTER TABLE x1234 RENAME TO x1234_r6899;
WITH cte AS (SELECT * FROM t1 WHERE a = (SELECT MAX(a) FROM t1)) SELECT * FROM cte;
PRAGMA fullfsync;
ALTER TABLE t1 RENAME TO t1_r3;
RELEASE sp8775;
ROLLBACK TRANSACTION TO SAVEPOINT sp2283;
RELEASE SAVEPOINT sp2283;
part1/bug-reproducers/3/reduced_test.sql
+11
View File
@@ -0,0 +1,11 @@
CREATE TABLE t1(c, b, a, PRIMARY KEY(b, a)) WITHOUT ROWID;
INSERT INTO t1 VALUES(atan(-CAST(jsonb_array() AS BOOLEAN)), 2, 3), (4, 5, 6);
ALTER TABLE t1 DROP c;
CREATE TABLE main.x1234(a, b, c PRIMARY KEY) WITHOUT ROWID;
CREATE INDEX i1 ON x1234(b) WHERE ((a+5) % 10)==0;
ALTER TABLE x1234 ADD COLUMN extra_949 FLOAT DEFAULT NULL;
UPDATE t1 SET b = '' RETURNING *;
DELETE FROM t1 WHERE 1;
ALTER TABLE x1234 RENAME TO x1234_r6899;
WITH cte AS (SELECT * FROM t1 WHERE a = (SELECT MAX(a) FROM t1)) SELECT * FROM cte;
part1/bug-reproducers/4/README.md
+69
View File
@@ -0,0 +1,69 @@
## 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).-->
It seems that the patched version does not support json. It is a logic bug because the output is different
## Minimized query
```sql
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
PRAGMA trusted_schema = TRUE;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (concat(json_type(1, '$'), 2, 3),1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 OR b < 2.0;
DROP TABLE t0;
INSERT INTO T DEFAULT VALUES;
PRAGMA full_column_names = TRUE;
WITH cte AS (SELECT * FROM T WHERE b = (SELECT MAX(b) FROM T)) SELECT * FROM cte;
PRAGMA recursive_triggers = ON;
SELECT COUNT(*) FROM T;
```
## Actual output
```sql
a
b
b
1
```
## Expectation
```sql
a
b
b
2|-2.5
3|0.0
integer23|1.5
integer23|1.5
4
```
## Flag
```
```
part1/bug-reproducers/4/original_test.sql
+32
View File
@@ -0,0 +1,32 @@
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
PRAGMA trusted_schema = TRUE;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (concat(json_type(1, '$'), 2, 3),1.5), (2,-2.5), (3,0.0);
CREATE INDEX c
ON T(b);
SELECT * FROM T WHERE b >= -2.5 OR b < 2.0;
DROP TABLE t0;
INSERT INTO T DEFAULT VALUES;
PRAGMA full_column_names = TRUE;
WITH cte AS (SELECT * FROM T WHERE b = (SELECT MAX(b) FROM T)) SELECT * FROM cte;
PRAGMA recursive_triggers = ON;
SELECT COUNT(*) FROM T;
part1/bug-reproducers/4/reduced_test.sql
+16
View File
@@ -0,0 +1,16 @@
CREATE TABLE t(a INTEGER, b REAL);
INSERT INTO t VALUES (1,1.5),(2,-2.5),(3,0.0);
CREATE INDEX idx ON t(b);
SELECT * FROM t
WHERE b >= -2.5 OR b < 2.0;
INSERT INTO t DEFAULT VALUES;
WITH cte AS (
SELECT * FROM t WHERE b=(SELECT MAX(b) FROM t)
)
SELECT * FROM cte;
SELECT COUNT(*) FROM t;
part1/bug-reproducers/5/README.md
+53
View File
@@ -0,0 +1,53 @@
## 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).-->
We think the "INTERSECT SELECT" statement is the issue. It is a logic bug because the output is different
## Minimized query
```sql
.once log.txt
PRAGMA parser_trace = OFF;
PRAGMA wal_checkpoint('RESTART');
PRAGMA trusted_schema;
.imposter off
CREATE TABLE T1 (
A VARCHAR(20) PRIMARY KEY,
X VARCHAR(10) UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(20) PRIMARY KEY,
Y VARCHAR(10) UNIQUE
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
INSERT INTO T2 VALUES ('c', 'l');
SELECT A FROM T1 INTERSECT SELECT A FROM T2;
ALTER TABLE T2 ADD COLUMN extra_8207 CHAR(10);
```
## Actual output
```sql
0|-1|-1
1
b
c
```
## Expectation
```sql
0|-1|-1
0
b
c
```
## Flag
```
```
part1/bug-reproducers/5/original_test.sql
+20
View File
@@ -0,0 +1,20 @@
.once log.txt
PRAGMA parser_trace = OFF;
PRAGMA wal_checkpoint('RESTART');
PRAGMA trusted_schema;
.imposter off
CREATE TABLE T1 (
A VARCHAR(20) PRIMARY KEY,
X VARCHAR(10) UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(20) PRIMARY KEY,
Y VARCHAR(10) UNIQUE
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
INSERT INTO T2 VALUES ('c', 'l');
SELECT A FROM T1 INTERSECT SELECT A FROM T2;
ALTER TABLE T2 ADD COLUMN extra_8207 CHAR(10);
part1/bug-reproducers/5/reduced_test.sql
+11
View File
@@ -0,0 +1,11 @@
CREATE TABLE t1(a PRIMARY KEY, x UNIQUE);
CREATE TABLE t2(a PRIMARY KEY, y UNIQUE);
INSERT INTO t1 VALUES ('a','m'),('b','n'),('c','o');
INSERT INTO t2 VALUES ('b','k'),('c','l');
SELECT a FROM t1
INTERSECT
SELECT a FROM t2;
ALTER TABLE t2 ADD COLUMN extra_col;
part1/bug-reproducers/6/README.md
+64
View File
@@ -0,0 +1,64 @@
## 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).-->
It seems that the markdown flag is supported, but the "COALESCE" is buggy. It is a logic bug because the output is different
## Minimized query
```sql
CREATE TABLE T (
a TEXT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',concat_ws('|', 'a', NULL, 'b')), ('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;
WITH cte(a, b, c) AS (SELECT b, b, b FROM T) SELECT a, b, c FROM cte;
SELECT COUNT(*) FROM T;
SELECT RANK() OVER (ORDER BY c RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T;
CREATE VIEW IF NOT EXISTS v_T_9129 AS SELECT b FROM T;
INSERT INTO T SELECT * FROM T;
```
## Actual output
```sql
| COUNT(*) |
|----------|
| 0 |
```
## Expectation
```sql
| d | e | f |
|---|---|------|
| a | b | 0.0 |
| a | c | -1.0 |
| b | d | 0.0 |
| a | b | c |
|---|---|---|
| b | b | b |
| c | c | c |
| d | d | d |
| COUNT(*) |
|----------|
| 3 |
| RANK() OVER (ORDER BY c RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) |
|--------------------------------------------------------------------|
| 1 |
| 2 |
| 3 |
```
## Flag
```
-markdown
```
part1/bug-reproducers/6/original_test.sql
+18
View File
@@ -0,0 +1,18 @@
CREATE TABLE T (
a TEXT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',concat_ws('|', 'a', NULL, 'b')), ('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;
WITH cte(a, b, c) AS (SELECT b, b, b FROM T) SELECT a, b, c FROM cte;
SELECT COUNT(*) FROM T;
SELECT RANK() OVER (ORDER BY c RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T;
CREATE VIEW IF NOT EXISTS v_T_9129 AS SELECT b FROM T;
INSERT INTO T SELECT * FROM T;
part1/bug-reproducers/6/reduced_test.sql
View File
part1/bug-reproducers/7/README.md
+52
View File
@@ -0,0 +1,52 @@
## 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).-->
We think the "COLLATE" keyword is causing bugs, it is a logic bug because the output is different
## Minimized query
```sql
PRAGMA secure_delete = ON;
CREATE TABLE t0(c0 REAL, c1 REAL GENERATED ALWAYS AS (c0));
INSERT INTO t0(c0) VALUES (-(-(unhex(1))));
SELECT * FROM t0 GROUP BY c0;
CREATE TABLE t1(a, b);
CREATE TABLE t2(c, d);
SELECT max(t1.a), (SELECT 'xyz' FROM (SELECT * FROM t2 WHERE 0) WHERE t1.b=1) FROM t1;
INSERT INTO t1 SELECT * FROM t1;
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-7.25), (3,0.0);
SELECT a,b FROM T WHERE a >= 2 ORDER BY b;
ALTER TABLE t1 ADD COLUMN extra_7155 MEDIUMINT COLLATE RTRIM;
PRAGMA cache_spill = FALSE;
INSERT INTO t0 DEFAULT VALUES;
```
## Actual output
```sql
1
|
2|-7.25
3|0.0
```
## Expectation
```sql
1
|
|
2|-7.25
3|0.0
```
## Flag
```
```
part1/bug-reproducers/7/original_test.sql
+18
View File
@@ -0,0 +1,18 @@
PRAGMA secure_delete = ON;
CREATE TABLE t0(c0 REAL, c1 REAL GENERATED ALWAYS AS (c0));
INSERT INTO t0(c0) VALUES (-(-(unhex(1))));
SELECT * FROM t0 GROUP BY c0;
CREATE TABLE t1(a, b);
CREATE TABLE t2(c, d);
SELECT max(t1.a), (SELECT 'xyz' FROM (SELECT * FROM t2 WHERE 0) WHERE t1.b=1) FROM t1;
INSERT INTO t1 SELECT * FROM t1;
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-7.25), (3,0.0);
SELECT a,b FROM T WHERE a >= 2 ORDER BY b;
ALTER TABLE t1 ADD COLUMN extra_7155 MEDIUMINT COLLATE RTRIM;
PRAGMA cache_spill = FALSE;
INSERT INTO t0 DEFAULT VALUES;
part1/bug-reproducers/7/reduced_test.sql
+10
View File
@@ -0,0 +1,10 @@
CREATE TABLE t0(
c0 REAL,
c1 REAL GENERATED ALWAYS AS (c0)
);
INSERT INTO t0(c0) VALUES (1);
SELECT * FROM t0 GROUP BY c0;
INSERT INTO t0 DEFAULT VALUES;
part1/bug-reproducers/8/README.md
+89
View File
@@ -0,0 +1,89 @@
## 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).-->
We believe that some features of the patched version have been disabled.
## Minimized query
```sql
PRAGMA secure_delete = ON;
PRAGMA foreign_keys = FALSE;
-- sign(1)
PRAGMA cell_size_check = 3370811959573763011;
PRAGMA page_size;
.recover
CREATE TABLE map_integer /**/ (id INT, name);
INSERT INTO map_integer VALUES(1,'a');
CREATE TABLE [map_text] (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE data (id TEXT, name);
INSERT INTO data VALUES(1,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as SELECT * FROM map_integer UNION SELECT * FROM map_text;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_924 AS SELECT id FROM map_integer;
SELECT NTILE(4) OVER (ORDER BY name GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM map_integer;
CREATE VIEW IF NOT EXISTS v_map_integer_8760 AS SELECT name FROM map_integer;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
WITH cte(x) AS (SELECT id FROM map_integer) SELECT x FROM cte;
REINDEX;
ALTER TABLE map_text RENAME COLUMN name TO name_r1633;
WITH cte AS (SELECT name, ROW_NUMBER() OVER (ORDER BY name) AS rn FROM data) SELECT * FROM cte WHERE rn <= 5;
ALTER TABLE data RENAME TO data_r811;
```
## Actual output
```sql
1
4096
PRAGMA foreign_keys=OFF;
BEGIN;
PRAGMA writable_schema = on;
PRAGMA writable_schema = off;
COMMIT;
1|abc|a
1
a|b
1
abc|1
xyz|2
```
## Expectation
```sql
1
4096
.dbconfig defensive off
BEGIN;
PRAGMA writable_schema = on;
PRAGMA foreign_keys = off;
PRAGMA encoding = 'UTF-8';
PRAGMA page_size = '4096';
PRAGMA auto_vacuum = '0';
PRAGMA user_version = '0';
PRAGMA application_id = '0';
PRAGMA writable_schema = off;
COMMIT;
4|xyz|e
1
a|b
1
abc|1
xyz|2
```
## Flag
```
```
part1/bug-reproducers/8/original_test.sql
+32
View File
@@ -0,0 +1,32 @@
PRAGMA secure_delete = ON;
PRAGMA foreign_keys = FALSE;
-- sign(1)
PRAGMA cell_size_check = 3370811959573763011;
PRAGMA page_size;
.recover
CREATE TABLE map_integer /**/ (id INT, name);
INSERT INTO map_integer VALUES(1,'a');
CREATE TABLE [map_text] (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE data (id TEXT, name);
INSERT INTO data VALUES(1,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as SELECT * FROM map_integer UNION SELECT * FROM map_text;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_924 AS SELECT id FROM map_integer;
SELECT NTILE(4) OVER (ORDER BY name GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM map_integer;
CREATE VIEW IF NOT EXISTS v_map_integer_8760 AS SELECT name FROM map_integer;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
WITH cte(x) AS (SELECT id FROM map_integer) SELECT x FROM cte;
REINDEX;
ALTER TABLE map_text RENAME COLUMN name TO name_r1633;
WITH cte AS (SELECT name, ROW_NUMBER() OVER (ORDER BY name) AS rn FROM data) SELECT * FROM cte WHERE rn <= 5;
ALTER TABLE data RENAME TO data_r811;
part1/bug-reproducers/8/reduced_test.sql
+20
View File
@@ -0,0 +1,20 @@
CREATE TABLE map_integer(id INT, name);
INSERT INTO map_integer VALUES(1,'a');
CREATE TABLE map_text(id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE data(id TEXT, name);
INSERT INTO data VALUES(1,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap AS
SELECT * FROM map_integer
UNION
SELECT * FROM map_text;
SELECT * FROM data
JOIN idmap USING(id);
ALTER TABLE map_text
RENAME COLUMN name TO name2;
part1/bug-reproducers/9/README.md
+50
View File
@@ -0,0 +1,50 @@
## 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).-->
We beliebe "timediff" causes the bug. It is a logic bug because the output is different
## Minimized query
```sql
CREATE TABLE t1(a, b);
CREATE /* CHAR(10) */ INDEX i1 ON t1(a);
INSERT INTO t1 VALUES('aaa', tanh(timediff(sign(0), 1)));
INSERT INTO t1 VALUES('ddd', 2);
INSERT INTO t1 VALUES('ccc', 3);
INSERT INTO t1 VALUES('eee', 4);
SELECT b FROM t1 WHERE a IN ('aaa', 'bbb', 'ccc');
SELECT a FROM t1 WHERE rowid IN (1, 3);
ALTER TABLE t1 DROP COLUMN b;
CREATE INDEX IF NOT EXISTS idx_t1_9614 ON t1(a COLLATE NOCASE) WHERE a IS NOT NULL;
SELECT * FROM t1;
```
## Actual output
```sql
3
ddd
eee
ddd
ccc
eee
```
## Expectation
```sql
3
aaa
ccc
aaa
ddd
ccc
eee
```
## Flag
```
```
part1/bug-reproducers/9/original_test.sql
+12
View File
@@ -0,0 +1,12 @@
CREATE TABLE t1(a, b);
CREATE /* CHAR(10) */ INDEX i1 ON t1(a);
INSERT INTO t1 VALUES('aaa', tanh(timediff(sign(0), 1)));
INSERT INTO t1 VALUES('ddd', 2);
INSERT INTO t1 VALUES('ccc', 3);
INSERT INTO t1 VALUES('eee', 4);
SELECT b FROM t1 WHERE a IN ('aaa', 'bbb', 'ccc');
SELECT a FROM t1 WHERE rowid IN (1, 3);
ALTER TABLE t1 DROP COLUMN b;
CREATE INDEX IF NOT EXISTS idx_t1_9614 ON t1(a COLLATE NOCASE) WHERE a IS NOT NULL;
SELECT * FROM t1;
part1/bug-reproducers/9/reduced_test.sql
+17
View File
@@ -0,0 +1,17 @@
CREATE TABLE t1(a, b);
CREATE INDEX i1 ON t1(a);
INSERT INTO t1 VALUES('aaa',1);
INSERT INTO t1 VALUES('ccc',3);
SELECT b FROM t1
WHERE a IN ('aaa','ccc');
ALTER TABLE t1 DROP COLUMN b;
CREATE INDEX idx2
ON t1(a COLLATE NOCASE)
WHERE a IS NOT NULL;
SELECT * FROM t1;
part1/corrupt001.db
LFS
BIN
View File
Binary file not shown.
part1/employee.db
LFS
BIN
View File
Binary file not shown.
part1/entrypoint.sh
+3
View File
@@ -0,0 +1,3 @@
#!/bin/bash
cd /fuzzer
exec python3 /fuzzer/fuzzer.py "$@"
part1/fuzzer.py
+317
View File
@@ -0,0 +1,317 @@
#!/usr/bin/env python3
import argparse
from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
import datetime
import multiprocessing
import os
import random
import signal
import time
from mutator import mutate
from mutator_extra_statements import (
mut_prepend_random_meta_command,
mut_prepend_random_pragma,
)
from oracle import check
from runner import reset_coverage
from stats import create_stats_report
class _MutateTimeout(Exception):
pass
def _timeout_handler(signum, frame):
raise _MutateTimeout()
_HAS_SIGALRM = hasattr(signal, 'SIGALRM') and hasattr(signal, 'setitimer')
if _HAS_SIGALRM:
signal.signal(signal.SIGALRM, _timeout_handler)
def mutate_safe(query: str, timeout: float = 0.5) -> str:
"""
Runs mutate(query) with a real, in-process timeout (no threads).
Returns the mutated query if successful, or the original on timeout/error.
"""
if not _HAS_SIGALRM:
try:
return mutate(query)
except Exception:
return query
signal.setitimer(signal.ITIMER_REAL, timeout)
try:
result = mutate(query)
except _MutateTimeout:
return query
except Exception:
return query
finally:
signal.setitimer(signal.ITIMER_REAL, 0)
return result if isinstance(result, str) else query
def _load_seeds(seeds_dir: str) -> list[str]:
"""Load and deduplicate seeds from disk + additional.sql"""
seeds: list[str] = []
seen: set[str] = set()
if os.path.isdir(seeds_dir):
for fname in os.listdir(seeds_dir):
try:
with open(os.path.join(seeds_dir, fname), 'r', encoding='latin-1') as f:
content = f.read()
except OSError:
continue
if content and content not in seen:
seen.add(content)
seeds.append(content)
try:
with open("additional.sql", "r", encoding='latin-1') as fh:
raw = fh.read()
for q in raw.split('---'):
q = q.strip()
if q and q not in seen:
seen.add(q)
seeds.append(q)
except OSError:
pass
return seeds
def _load_seeds_disk_only(seeds_dir: str) -> list[str]:
"""Load seeds from disk"""
seeds: list[str] = []
if os.path.isdir(seeds_dir):
for fname in os.listdir(seeds_dir):
try:
with open(os.path.join(seeds_dir, fname), 'r', encoding='latin-1') as f:
content = f.read()
except OSError:
continue
seeds.append(content)
return seeds
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--seeds',
default='/home/test/seeds',
help='Directory with seed .sql files')
parser.add_argument('--buggy',
default='/home/test/sqlite3-src/build/sqlite3',
help='Buggy SQLite binary')
parser.add_argument('--reference',
default='/usr/bin/sqlite3',
help='Reference SQLite binary')
parser.add_argument('--count',
type=int,
default=10000,
help='Number of queries to generate')
parser.add_argument('--mutate-timeout',
type=float,
default=0.5,
help='Per-mutation timeout in seconds (default 0.5)')
parser.add_argument(
'--max-query-length',
type=int,
default=100000,
help='Hard cap on a single query in characters (default 100000). Queries '
'that grow past this after mutation are reset back to the original '
'seed for that iteration.')
parser.add_argument('--workers',
type=int,
default=multiprocessing.cpu_count(),
help="""Number of parallel check() workers.""")
parser.add_argument(
'--validate-seeds',
action='store_true',
default=False,
help=
'Run the upfront seed-validation pass (~2N subprocess calls before the main loop). Off by default.'
)
parser.add_argument(
'--run-baseline',
action='store_true',
default=False,
help=
'Run the seeds inside /home/test/seeds only, without applying any mutation.'
)
args = parser.parse_args()
# # #################################################################################################################
if args.run_baseline:
reset_coverage()
seeds = _load_seeds_disk_only(args.seeds)
queries: list[str] = list(seeds) # pyright: ignore[reportRedeclaration]
print(f'{datetime.datetime.now()}: [INFO] Loaded {len(queries)} seeds.')
print(
f'{datetime.datetime.now()}: [INFO] Running {len(queries)} iterations...')
invalid_queries = 0
loop_start = time.perf_counter()
for query in queries:
is_ok = check(args.buggy, args.reference, query, False)
if is_ok == -1:
invalid_queries += 1
loop_end = time.perf_counter()
loop_elapsed = loop_end - loop_start
valid_queries = len(queries) - invalid_queries
print()
create_stats_report(valid_queries,
invalid_queries,
queries,
qpm_gen=-1,
qpm_full=-1,
wall_seconds=loop_elapsed)
else:
seeds = _load_seeds(args.seeds)
queries: list[str] = list(seeds)
if args.validate_seeds:
print(f'{datetime.datetime.now()}: [INFO] Validating seeds...')
queries = []
for seed in seeds:
if check(args.buggy, args.reference, seed, save_bugs=False) != -1:
queries.append(seed)
variants: list[str] = []
for seed in seeds:
modified = mut_prepend_random_pragma(
mut_prepend_random_pragma(
mut_prepend_random_pragma(mut_prepend_random_meta_command(seed))))
variants.append(modified)
queries.extend(variants)
print(f'{datetime.datetime.now()}: [INFO] Loaded {len(queries)} seeds.')
print(
f'{datetime.datetime.now()}: [INFO] Running {args.count} iterations with {args.workers} workers...'
)
reset_coverage()
invalid_queries = 0
actually_executed_queries: list[str] = []
count = int(args.count)
phase1_end = min(300, count)
phase2_end = max(phase1_end, count - 1000)
gen_time_total = 0.0
loop_start = time.perf_counter()
pending: dict[Future[int], tuple[int, str, str, bool]] = {}
pool = ThreadPoolExecutor(max_workers=args.workers)
submitted = 0
def _submit_next():
"""Mutate one query and submit a check() to the worker pool"""
nonlocal gen_time_total, submitted
idx = random.randint(0, len(queries) - 1)
original = queries[idx]
with_flag = (submitted < phase1_end) or (submitted >= phase2_end)
start = time.perf_counter()
query = mutate_safe(original, timeout=args.mutate_timeout)
if len(query) > args.max_query_length:
query = original
end = time.perf_counter()
gen_time_total += end - start
fut = pool.submit(check, args.buggy, args.reference, query, with_flag)
pending[fut] = (idx, query, original, with_flag)
submitted += 1
def _drain_one(fut: Future):
"""Collect one completed future and update state"""
nonlocal invalid_queries
idx, query, original, _with_flag = pending.pop(fut)
try:
is_ok = fut.result()
except Exception:
is_ok = -1
actually_executed_queries.append(query)
if is_ok == -1:
invalid_queries += 1
elif query != original and idx < len(
queries) and queries[idx] == original:
queries[idx] = query
n = len(actually_executed_queries)
if n % 100 == 0:
print(f'{datetime.datetime.now()}: [INFO] Executed {n} queries...')
for _ in range(min(int(args.workers), count)):
_submit_next()
while len(actually_executed_queries) < count:
done, _ = wait(pending.keys(), return_when=FIRST_COMPLETED)
for fut in done:
_drain_one(fut)
if submitted < count:
_submit_next()
if len(actually_executed_queries) >= count:
break
pool.shutdown(wait=True)
loop_end = time.perf_counter()
loop_elapsed = loop_end - loop_start
valid_queries = len(actually_executed_queries) - invalid_queries
qpm_gen = (count / gen_time_total * 60.0) if gen_time_total > 0 else 0.0
qpm_full = (count / loop_elapsed * 60.0) if loop_elapsed > 0 else 0.0
print()
print(f'Wall clock: {loop_elapsed:.2f}s for {count} iterations')
print(f'Generation-only time: {gen_time_total:.2f}s '
f'(≈ {gen_time_total / count * 1000:.2f} ms/query)')
print(f'Throughput (generated): {qpm_gen:.1f} queries/min')
print(f'Throughput (generated + executed): {qpm_full:.1f} queries/min')
create_stats_report(valid_queries,
invalid_queries,
actually_executed_queries,
qpm_gen=qpm_gen,
qpm_full=qpm_full,
wall_seconds=loop_elapsed)
if __name__ == '__main__':
main()
part1/manyblobs-512.db
LFS
BIN
View File
Binary file not shown.
part1/mutator.py
+120
View File
@@ -0,0 +1,120 @@
import random
from typing import Callable
import mutator_corpus_splicing
import mutator_equivalent_rewrites
import mutator_extra_statements
import mutator_operators
import mutator_values
_MUTATORS_WEIGHTED: list[tuple[Callable[[str], str], float]] = [
# # ##############################################################################################
(mutator_values.mut_replace_num_with_edge_int, 3),
(mutator_values.mut_replace_num_with_random_int, 2),
(mutator_values.mut_replace_num_with_edge_float, 2),
(mutator_values.mut_replace_num_with_edge_string, 2),
(mutator_values.mut_replace_num_with_random_hex, 2),
(mutator_values.mut_replace_num_with_null, 2),
(mutator_values.mut_wrap_num_in_cast, 3),
(mutator_values.mut_wrap_num_in_datetime_func, 2),
(mutator_values.mut_wrap_num_in_core_func, 10),
(mutator_values.mut_wrap_num_in_math_func, 5),
(mutator_values.mut_wrap_num_in_json_func, 5),
# # ##############################################################################################
(mutator_operators.mut_swap_comparison, 2),
(mutator_operators.mut_swap_boolean, 2),
(mutator_operators.mut_negate_where, 2),
(mutator_operators.mut_change_type, 2),
(mutator_operators.mut_swap_join_type, 2),
# # ##############################################################################################
(mutator_extra_statements.mut_append_select_star, 6),
(mutator_extra_statements.mut_append_count, 6),
(mutator_extra_statements.mut_append_join, 7),
(mutator_extra_statements.mut_append_subquery, 9),
(mutator_extra_statements.mut_append_cte, 9),
(mutator_extra_statements.mut_append_window, 7),
(mutator_extra_statements.mut_append_filter, 6),
(mutator_extra_statements.mut_append_aggregate, 7),
(mutator_extra_statements.mut_append_update, 6),
(mutator_extra_statements.mut_append_delete, 6),
(mutator_extra_statements.mut_append_index, 6),
(mutator_extra_statements.mut_append_view, 6),
(mutator_extra_statements.mut_append_trigger, 6),
(mutator_extra_statements.mut_wrap_savepoint, 6),
(mutator_extra_statements.mut_wrap_transaction, 6),
(mutator_extra_statements.mut_wrap_attach_detach, 5),
(mutator_extra_statements.mut_append_vacuum, 5),
(mutator_extra_statements.mut_append_analyze, 6),
(mutator_extra_statements.mut_append_reindex, 5),
(mutator_extra_statements.mut_append_null_insert, 6),
(mutator_extra_statements.mut_append_insert_default, 6),
(mutator_extra_statements.mut_append_insert_select, 6),
(mutator_extra_statements.mut_append_insert_or_x, 6),
(mutator_extra_statements.mut_append_upsert, 6),
(mutator_extra_statements.mut_append_alter_rename_table, 5),
(mutator_extra_statements.mut_append_alter_rename_column, 5),
(mutator_extra_statements.mut_append_alter_add_column, 6),
(mutator_extra_statements.mut_append_alter_drop_column, 5),
(mutator_extra_statements.mut_append_alter_drop_table_index_view_trigger, 5),
(mutator_extra_statements.mut_repeat, 6),
(mutator_extra_statements.mut_prepend_random_pragma, 9),
(mutator_extra_statements.mut_append_random_pragma, 6),
(mutator_extra_statements.mut_prepend_random_meta_command, 9),
# # ##############################################################################################
(mutator_corpus_splicing.mut_splice_append, 4),
(mutator_corpus_splicing.mut_splice_prepend, 4),
(mutator_corpus_splicing.mut_splice_intersperse, 4),
(mutator_corpus_splicing.mut_splice_replace, 1),
# # ##############################################################################################
(mutator_equivalent_rewrites.mut_between_to_and, 3),
(mutator_equivalent_rewrites.mut_and_to_between, 3),
(mutator_equivalent_rewrites.mut_in_to_or, 3),
(mutator_equivalent_rewrites.mut_arithmetic_identity, 3),
(mutator_equivalent_rewrites.mut_double_negate, 3),
(mutator_equivalent_rewrites.mut_string_concat_identity, 3),
(mutator_equivalent_rewrites.mut_double_not, 3),
(mutator_equivalent_rewrites.mut_de_morgan, 3),
(mutator_equivalent_rewrites.mut_tautology_and, 3),
(mutator_equivalent_rewrites.mut_tautology_or, 3),
(mutator_equivalent_rewrites.mut_is_null_to_isnull, 2),
(mutator_equivalent_rewrites.mut_eq_to_is, 2),
(mutator_equivalent_rewrites.mut_inject_null_check, 2),
(mutator_equivalent_rewrites.mut_subquery_in_from, 3),
(mutator_equivalent_rewrites.mut_add_indexed_by, 2),
(mutator_equivalent_rewrites.mut_qualify_with_main, 2),
(mutator_equivalent_rewrites.mut_predicate_pushdown_blocker, 2),
(mutator_equivalent_rewrites.mut_force_materialization, 2),
(mutator_equivalent_rewrites.mut_comma_join_to_explicit, 2),
(mutator_equivalent_rewrites.mut_swap_on_to_using, 2),
(mutator_equivalent_rewrites.mut_inject_empty_block_comment, 2),
(mutator_equivalent_rewrites.mut_inject_non_empty_block_comment, 2),
(mutator_equivalent_rewrites.mut_inject_line_comment, 2),
(mutator_equivalent_rewrites.mut_redundant_parens, 2),
(mutator_equivalent_rewrites.mut_quote_identifier, 2),
(mutator_equivalent_rewrites.mut_memeify, 2),
(mutator_equivalent_rewrites.mut_swap_whitespace, 2),
(mutator_equivalent_rewrites.mut_to_case_expr, 2),
(mutator_equivalent_rewrites.mut_iif_to_case, 2),
(mutator_equivalent_rewrites.mut_case_to_iif, 2),
]
MUTATIONS: list[Callable[[str], str]] = [m for m, _ in _MUTATORS_WEIGHTED]
_MUT_FUNCS = MUTATIONS
_MUT_WEIGHTS = [w for _, w in _MUTATORS_WEIGHTED]
def mutate(sql: str) -> str:
n = random.choices([1, 2, 3, 10, 20], weights=[3, 7, 13, 27, 50], k=1)[0]
out = sql
_MUT_SOFT_CAP = 100000
for _ in range(n):
if len(out) > _MUT_SOFT_CAP:
break
m = random.choices(_MUT_FUNCS, weights=_MUT_WEIGHTS, k=1)[0]
try:
new = m(out)
except Exception:
continue
if isinstance(new, str):
out = new
return out
part1/mutator_corpus_splicing.py
+69
View File
@@ -0,0 +1,69 @@
import random
import re
_CORPUS: list[str] = []
def _load_corpus() -> None:
candidate_paths = [
'/fuzzer/additional.sql',
]
for p in candidate_paths:
if not p:
continue
try:
with open(p, 'r', encoding='latin-1') as f:
content = f.read()
except OSError:
continue
chunks = [c.strip() for c in content.split('---') if c.strip()]
chunks = [
c for c in chunks if any(not ln.strip().startswith('--') and ln.strip()
for ln in c.split('\n'))
]
if chunks:
_CORPUS.extend(chunks)
return
_load_corpus()
def mut_splice_append(s: str) -> str:
"""Append a random chunk from the corpus"""
if not _CORPUS:
return s
return s + '\n' + random.choice(_CORPUS)
def mut_splice_prepend(s: str) -> str:
"""Prepend a random chunk from the corpus"""
if not _CORPUS:
return s
return random.choice(_CORPUS) + '\n' + s
def mut_splice_replace(s: str) -> str:
"""Replace s etirely with a random corpus chunk"""
if not _CORPUS:
return s
return random.choice(_CORPUS)
def mut_splice_intersperse(s: str) -> str:
"""Insert a random corpus chunk between two random statements of s"""
if not _CORPUS:
return s
parts = re.split(r'(?<=;)\s*\n', s)
if len(parts) < 2:
return s + '\n' + random.choice(_CORPUS)
i = random.randint(1, len(parts) - 1)
return '\n'.join(parts[:i] + [random.choice(_CORPUS)] + parts[i:])
part1/mutator_equivalent_rewrites.py
+444
View File
@@ -0,0 +1,444 @@
import random
import re
import mutator_extra_statements
from sqlite_static_helper import *
_TOKEN_RE = re.compile(
r"""
(?P<line_comment>--[^\n]*) |
(?P<block_comment>/\*.*?\*/) |
(?P<string>'(?:[^']|'')*') |
(?P<dquoted>"(?:[^"]|"")*") |
(?P<bracket>\[[^\]]*\]) |
(?P<backtick>`(?:[^`]|``)*`) |
(?P<blob>[xX]'[0-9a-fA-F]*') |
(?P<number>\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b) |
(?P<ident>[A-Za-z_][A-Za-z0-9_]*) |
(?P<op>[<>!=]=|<>|\|\||::|->>?|[+\-*/%<>=&|^~,.;()@]) |
(?P<ws>\s+) |
(?P<other>.)
""",
re.VERBOSE | re.DOTALL,
)
_UNSAFE_KINDS = {
"line_comment", "block_comment", "string", "dquoted", "bracket", "backtick",
"blob"
}
def _tokenize(s: str):
return [(m.lastgroup, m.group()) for m in _TOKEN_RE.finditer(s)]
def _sub_in_safe(s: str, pattern: re.Pattern, repl, max_subs: int = 1) -> str:
if max_subs <= 0:
return s
parts: list[str] = []
done = 0
for kind, text in _tokenize(s):
if done >= max_subs or kind in _UNSAFE_KINDS:
parts.append(text)
continue
new_text, n = pattern.subn(repl, text, count=max_subs - done)
parts.append(new_text)
done += n
return ''.join(parts)
_BETWEEN_RE = re.compile(
r'\b([A-Za-z_]\w*)\s+BETWEEN\s+(-?\d+(?:\.\d+)?)\s+AND\s+(-?\d+(?:\.\d+)?)',
re.I,
)
def mut_between_to_and(s: str) -> str:
"""`x BETWEEN a AND b` -> `(x >= a AND x <= b)`."""
def repl(m: re.Match) -> str:
col, lo, hi = m.group(1), m.group(2), m.group(3)
return f'({col} >= {lo} AND {col} <= {hi})'
return _sub_in_safe(s, _BETWEEN_RE, repl, 1)
_RANGE_AND_RE = re.compile(
r'\(\s*([A-Za-z_]\w*)\s*>=\s*(-?\d+(?:\.\d+)?)\s+AND\s+'
r'\1\s*<=\s*(-?\d+(?:\.\d+)?)\s*\)',
re.I,
)
def mut_and_to_between(s: str) -> str:
"""`(x >= a AND x <= b)` -> `x BETWEEN a AND b`."""
def repl(m: re.Match) -> str:
return f'{m.group(1)} BETWEEN {m.group(2)} AND {m.group(3)}'
return _sub_in_safe(s, _RANGE_AND_RE, repl, 1)
_IN_LIST_RE = re.compile(
r'\b([A-Za-z_]\w*)\s+IN\s*\(\s*([^()]*?)\s*\)',
re.I,
)
def mut_in_to_or(s: str) -> str:
"""`x IN (a, b, c)` -> `(x = a OR x = b OR x = c)`"""
def repl(m: re.Match) -> str:
col, body = m.group(1), m.group(2)
if re.search(r'\bSELECT\b', body, re.I):
return m.group(0)
items = [p.strip() for p in body.split(',') if p.strip()]
if not items or len(items) > 16:
return m.group(0)
return '(' + ' OR '.join(f'{col} = {v}' for v in items) + ')'
return _sub_in_safe(s, _IN_LIST_RE, repl, 1)
def mut_arithmetic_identity(s: str) -> str:
"""`<n>` -> `(<n> + 0)` / `(<n> * 1)` / `(<n> - 0)`."""
pat = re.compile(r'\b(-?\d+(?:\.\d+)?)\b')
forms = ['({v} + 0)', '({v} * 1)', '({v} - 0)', '({v} + 0.0)', '(0 + {v})']
def repl(m: re.Match) -> str:
return random.choice(forms).format(v=m.group(1))
return _sub_in_safe(s, pat, repl, 1)
def mut_double_negate(s: str) -> str:
"""`<n>` -> `-(-<n>)`"""
pat = re.compile(r'\b(-?\d+(?:\.\d+)?)\b')
return _sub_in_safe(s, pat, lambda m: f'-(-({m.group(1)}))', 1)
def mut_string_concat_identity(s: str) -> str:
"""`'abc'` -> `('abc' || '')`."""
out: list[str] = []
done = False
for kind, text in _tokenize(s):
if not done and kind == 'string' and len(text) >= 2:
out.append(random.choice([f"({text} || '')", f"'' || ({text})"]))
done = True
else:
out.append(text)
return ''.join(out)
def mut_double_not(s: str) -> str:
"""`WHERE p` -> `WHERE NOT NOT p`"""
m = re.search(
r'\bWHERE\b\s+([^;]+?)(?=\bGROUP\b|\bORDER\b|\bLIMIT\b|\bHAVING\b|\bRETURNING\b|;|$)',
s, re.I)
if not m:
return s
pred = m.group(1).strip()
if not pred:
return s
new = f'WHERE NOT NOT ({pred}) '
return s[:m.start()] + new + s[m.end():]
def mut_de_morgan(s: str) -> str:
"""`NOT (a AND b)` -> `(NOT a OR NOT b)`"""
pat = re.compile(r'NOT\s*\(\s*([^()]+?)\s+AND\s+([^()]+?)\s*\)', re.I)
def repl(m: re.Match) -> str:
return f'(NOT ({m.group(1)}) OR NOT ({m.group(2)}))'
return _sub_in_safe(s, pat, repl, 1)
def mut_tautology_and(s: str) -> str:
"""`WHERE p` -> `WHERE p AND 1=1`"""
if not re.search(r'\bWHERE\b', s, re.I):
return s
pat = re.compile(
r'(\bWHERE\b\s+[^;]+?)(?=\bGROUP\b|\bORDER\b|\bLIMIT\b|\bHAVING\b|\bRETURNING\b|;|$)',
re.I)
tauto = random.choice(['1=1', "'a'='a'", 'NULL IS NULL', 'TRUE'])
return _sub_in_safe(s, pat, lambda m: f'{m.group(1).rstrip()} AND {tauto} ',
1)
def mut_tautology_or(s: str) -> str:
"""`WHERE p` -> `WHERE p OR 1=0`"""
if not re.search(r'\bWHERE\b', s, re.I):
return s
pat = re.compile(
r'(\bWHERE\b\s+[^;]+?)(?=\bGROUP\b|\bORDER\b|\bLIMIT\b|\bHAVING\b|\bRETURNING\b|;|$)',
re.I)
contradiction = random.choice(['1=0', "'a'='b'", 'NULL IS NOT NULL', 'FALSE'])
return _sub_in_safe(s, pat,
lambda m: f'({m.group(1).rstrip()}) OR {contradiction} ',
1)
def mut_is_null_to_isnull(s: str) -> str:
"""`x IS NULL` -> `x ISNULL` or `x IS NOT NULL` -> `x NOTNULL`"""
if random.random() < 0.5:
return _sub_in_safe(s, re.compile(r'\bIS\s+NULL\b', re.I), 'ISNULL', 1)
return _sub_in_safe(s, re.compile(r'\bIS\s+NOT\s+NULL\b', re.I), 'NOTNULL', 1)
def mut_eq_to_is(s: str) -> str:
"""`x = NULL` -> `x IS NULL`"""
return _sub_in_safe(s, re.compile(r'=\s*NULL\b', re.I), 'IS NULL', 1)
def mut_inject_null_check(s: str) -> str:
"""Append `AND <col> IS NOT NULL` to a `WHERE`"""
if not re.search(r'\bWHERE\b', s, re.I):
return s
_, col = mutator_extra_statements._pick_table_col(s)
pat = re.compile(
r'(\bWHERE\b\s+[^;]+?)(?=\bGROUP\b|\bORDER\b|\bLIMIT\b|\bHAVING\b|\bRETURNING\b|;|$)',
re.I)
return _sub_in_safe(s, pat,
lambda m: f'{m.group(1).rstrip()} AND {col} IS NOT NULL ',
1)
def mut_add_indexed_by(s: str) -> str:
"""Tag a table reference with `NOT INDEXED` or `INDEXED BY`"""
schema = mutator_extra_statements.get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
hint = random.choice([
'NOT INDEXED',
f'INDEXED BY sqlite_autoindex_{table}_1',
])
pat = re.compile(rf'\bFROM\s+{re.escape(table)}\b(?!\s+(?:AS|NOT|INDEXED))',
re.I)
return _sub_in_safe(s, pat, lambda m: f'{m.group(0)} {hint}', 1)
def mut_qualify_with_main(s: str) -> str:
"""Qualify a bare table name with `main.` schema prefix."""
schema = mutator_extra_statements.get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
pat = re.compile(rf'(?<![.\w])\b{re.escape(table)}\b', re.I)
return _sub_in_safe(s, pat, lambda m: f'main.{m.group(0)}', 1)
def mut_predicate_pushdown_blocker(s: str) -> str:
"""Prefix a column reference in `WHERE` with `+`"""
span = re.search(r'\bWHERE\b\s+([A-Za-z_]\w*)\s*(=|<|>|<=|>=|<>|!=)', s, re.I)
if not span:
return s
col = span.group(1)
return s[:span.start(1)] + f'+{col}' + s[span.end(1):]
def mut_subquery_in_from(s: str) -> str:
"""`FROM <table>` -> `FROM (SELECT * FROM <table>)`"""
schema = mutator_extra_statements.get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
pat = re.compile(rf'\bFROM\s+{re.escape(table)}\b(?!\s*\.)', re.I)
alias = f't_{random.randint(0, 999)}'
return _sub_in_safe(
s,
pat,
lambda m: f'FROM (SELECT * FROM {table}) AS {alias}',
1,
)
def mut_force_materialization(s: str) -> str:
"""`SELECT * FROM users WHERE age > 18 ORDER BY name;` -> `WITH _m AS MATERIALIZED (SELECT * FROM users) SELECT * FROM _m WHERE age > 18 ORDER BY name;`"""
schema = mutator_extra_statements.get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
pat = re.compile(rf'(\bSELECT\b[^;]*?\bFROM\s+){re.escape(table)}\b', re.I)
cte = (f'WITH _m AS MATERIALIZED (SELECT * FROM {table}) ')
m = pat.search(s)
if not m:
return s
sel_start = s.rfind('SELECT', 0, m.start() + 1)
if sel_start == -1:
sel_start = m.start()
head = s[:sel_start]
tail = s[sel_start:].replace(table, '_m', 1)
return head + cte + tail
def mut_comma_join_to_explicit(s: str) -> str:
"""`FROM a, b WHERE a.x = b.x` -> `FROM a JOIN b ON a.x = b.x`"""
pat = re.compile(r'\bFROM\s+([A-Za-z_]\w*)\s*,\s*([A-Za-z_]\w*)', re.I)
return _sub_in_safe(
s,
pat,
lambda m: f'FROM {m.group(1)} CROSS JOIN {m.group(2)}',
1,
)
def mut_swap_on_to_using(s: str) -> str:
"""`JOIN t ON a.col = b.col` -> `JOIN t USING (col)` when columns match."""
pat = re.compile(
r'JOIN\s+([A-Za-z_]\w*)\s+(?:AS\s+\w+\s+)?ON\s+'
r'(\w+)\.([A-Za-z_]\w*)\s*=\s*(\w+)\.\3\b',
re.I,
)
return _sub_in_safe(s, pat,
lambda m: f'JOIN {m.group(1)} USING ({m.group(3)})', 1)
def mut_inject_empty_block_comment(s: str) -> str:
"""Insert an empty `/**/` between two top-level tokens."""
tokens = _tokenize(s)
if len(tokens) < 4:
return s
candidates = [i for i, (k, _) in enumerate(tokens) if k == 'ws']
if not candidates:
return s
i = random.choice(candidates)
tokens[i] = ('ws', ' /**/ ')
return ''.join(t for _, t in tokens)
def mut_inject_non_empty_block_comment(s: str) -> str:
"""Insert a `/* <value> */` between two top-level tokens."""
tokens = _tokenize(s)
if len(tokens) < 4:
return s
candidates = [i for i, (k, _) in enumerate(tokens) if k == 'ws']
if not candidates:
return s
i = random.choice(candidates)
tokens[i] = ('ws', f' /* {str(random.choice(VALUES))} */ ')
return ''.join(t for _, t in tokens)
def mut_inject_line_comment(s: str) -> str:
"""Insert `-- <comment>;\\n` between two statements."""
if ';' not in s:
return s
pat = re.compile(r';(\s*)')
msg = str(random.choice(VALUES))
return _sub_in_safe(s, pat, lambda m: f';\n-- {msg}\n', 1)
def mut_redundant_parens(s: str) -> str:
"""Wrap a numeric or column reference in extra parens."""
pat = re.compile(r'\b([A-Za-z_]\w*|\d+)\b')
return _sub_in_safe(s, pat, lambda m: f'(({m.group(1)}))', 1)
def mut_quote_identifier(s: str) -> str:
"""Surround a table name with quotes"""
schema = mutator_extra_statements.get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
quote = random.choice(['"', '`', '['])
close = {'"': '"', '`': '`', '[': ']'}[quote]
pat = re.compile(rf'(?<![.\w]){re.escape(table)}\b')
return _sub_in_safe(s, pat, lambda m: f'{quote}{table}{close}', 1)
def mut_memeify(s: str) -> str:
"""Randomly mixed-case a keyword: `SELECT` -> `SeLeCt`"""
keywords = [
'SELECT', 'FROM', 'WHERE', 'ORDER', 'GROUP', 'JOIN', 'UNION', 'INSERT',
'UPDATE', 'DELETE', 'AND', 'OR', 'NOT', 'LIMIT', 'OFFSET', 'HAVING', 'CASE',
'WHEN', 'THEN', 'END'
]
kw = random.choice(keywords)
pat = re.compile(rf'\b{kw}\b', re.I)
def jitter(m: re.Match) -> str:
return ''.join(
c.upper() if random.random() < 0.5 else c.lower() for c in m.group(0))
return _sub_in_safe(s, pat, jitter, 1)
def mut_swap_whitespace(s: str) -> str:
"""Swap one whitespace character with another"""
tokens = _tokenize(s)
candidates = [i for i, (k, t) in enumerate(tokens) if k == 'ws' and ' ' in t]
if not candidates:
return s
i = random.choice(candidates)
repl = random.choice(
['\t', '\n', ' ', '\u00a0' if random.random() < 0.25 else ' '])
tokens[i] = ('ws', tokens[i][1].replace(' ', repl, 1))
return ''.join(t for _, t in tokens)
def mut_to_case_expr(s: str) -> str:
"""`x = a` (in a `SELECT` list) -> `CASE WHEN x = a THEN 1 ELSE 0 END`"""
pat = re.compile(r'\b([A-Za-z_]\w*)\s*=\s*(-?\d+)\b')
return _sub_in_safe(
s,
pat,
lambda m: f'CASE WHEN {m.group(1)} = {m.group(2)} THEN 1 ELSE 0 END',
1,
)
def mut_iif_to_case(s: str) -> str:
"""`IIF(a, b, c)` -> `CASE WHEN a THEN b ELSE c END`."""
pat = re.compile(r'\bIIF\s*\(\s*([^,()]+),\s*([^,()]+),\s*([^,()]+)\s*\)',
re.I)
return _sub_in_safe(
s,
pat,
lambda m: f'CASE WHEN {m.group(1)} THEN {m.group(2)} ELSE {m.group(3)} END',
1,
)
def mut_case_to_iif(s: str) -> str:
"""`CASE WHEN a THEN b ELSE c END` -> `IIF(a, b, c)`."""
pat = re.compile(
r'\bCASE\s+WHEN\s+([^()]+?)\s+THEN\s+([^()]+?)\s+ELSE\s+([^()]+?)\s+END\b',
re.I,
)
return _sub_in_safe(
s,
pat,
lambda m: f'IIF({m.group(1)}, {m.group(2)}, {m.group(3)})',
1,
)
part1/mutator_extra_statements.py
+666
View File
@@ -0,0 +1,666 @@
import random
import re
from sqlite_static_helper import *
_TABLE_HEADER_RE = re.compile(
r'CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?'
r'(?:[\w."`]+\.)?([\w"`]+)\s*\(',
re.I,
)
_CONSTRAINT_HEADS = {'PRIMARY', 'UNIQUE', 'CHECK', 'FOREIGN', 'CONSTRAINT'}
def _split_top_level_commas(body: str) -> list[str]:
depth = 0
cur: list[str] = []
out: list[str] = []
in_str = False
quote = ''
for ch in body:
if in_str:
cur.append(ch)
if ch == quote:
in_str = False
continue
if ch in ("'", '"', '`'):
in_str = True
quote = ch
cur.append(ch)
continue
if ch == '(':
depth += 1
cur.append(ch)
elif ch == ')':
depth -= 1
cur.append(ch)
elif ch == ',' and depth == 0:
out.append(''.join(cur))
cur = []
else:
cur.append(ch)
if cur:
out.append(''.join(cur))
return out
def get_schema(sql: str) -> dict[str, list[str]]:
schema: dict[str, list[str]] = {}
cursor = 0
while True:
m = _TABLE_HEADER_RE.search(sql, cursor)
if not m:
break
name = m.group(1).strip('"`')
start = m.end()
depth = 1
j = start
while j < len(sql) and depth > 0:
c = sql[j]
if c == '(':
depth += 1
elif c == ')':
depth -= 1
j += 1
body = sql[start:j - 1] if depth == 0 else sql[start:]
cols: list[str] = []
for piece in _split_top_level_commas(body):
piece = piece.strip()
if not piece:
continue
head = piece.split()[0].strip(' ,"`[]')
if head.upper() in _CONSTRAINT_HEADS:
continue
if re.fullmatch(r'[A-Za-z_]\w*', head):
cols.append(head)
if cols:
schema[name] = cols
cursor = j
return schema or {}
def _pick_table(sql: str) -> str:
return random.choice(list(get_schema(sql).keys()))
def _pick_table_col(sql: str) -> tuple[str, str]:
schema = get_schema(sql)
table = random.choice(list(schema.keys()))
cols = schema[table] or ['rowid']
return table, random.choice(cols)
def mut_append_select_star(s: str) -> str:
"""Append a SELECT * statement for any existing table in the query"""
return s + '\n' + f'SELECT * FROM {_pick_table(s)};'
def mut_append_count(s: str) -> str:
"""Append a SELECT COUNT(*) statement for any existing table in the query"""
return s + '\n' + f'\nSELECT COUNT(*) FROM {_pick_table(s)};'
def mut_append_join(s: str) -> str:
"""Append a JOIN statement between two existing tables in the query"""
schema = get_schema(s)
if not schema:
return s
tables = list(schema.keys())
t1 = random.choice(tables)
t2 = random.choice(tables)
join_type = random.choice(JOINS)
if 'NATURAL' in join_type or 'CROSS' in join_type:
return s + '\n' + f'SELECT * FROM {t1} {join_type} {t2};'
return s + '\n' + f'SELECT * FROM {t1} AS a {join_type} {t2} AS b ON a.rowid = b.rowid;'
def mut_append_subquery(s: str) -> str:
"""Append a SELECT statement that queries a subquery"""
table, col = _pick_table_col(s)
style = random.choice([
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} t2 WHERE t2.{col} = {table}.{col});',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} t2 WHERE t2.{col} = {table}.{col});',
f'SELECT * FROM {table} WHERE NOT EXISTS (SELECT 1 FROM {table} t2 WHERE t2.{col} = {table}.{col});',
f'SELECT * FROM {table} WHERE {col} = (SELECT {col} FROM {table} t2 WHERE t2.{col} = {table}.{col} LIMIT 1);',
f'SELECT {col}, (SELECT COUNT(*) FROM {table}) AS cnt FROM {table};',
f'SELECT {col}, (SELECT MAX({col}) FROM {table}) AS max_val FROM {table};',
f'SELECT {col}, (SELECT MIN({col}) FROM {table}) AS min_val FROM {table};',
f'SELECT {col}, (SELECT AVG({col}) FROM {table}) AS avg_val FROM {table};',
f'SELECT {col}, (SELECT SUM({col}) FROM {table}) AS sum_val FROM {table};',
f'SELECT {col}, (SELECT {col} FROM {table} LIMIT 1) AS first_val FROM {table};',
f'SELECT * FROM (SELECT * FROM {table}) AS sub;',
f'SELECT * FROM (SELECT {col} FROM {table} WHERE {col} IS NOT NULL) AS sub;',
f'SELECT * FROM (SELECT {col}, COUNT(*) FROM {table} GROUP BY {col}) AS sub;',
f'SELECT * FROM (SELECT * FROM {table} ORDER BY {col}) AS sub LIMIT 10;',
f'SELECT * FROM (SELECT * FROM {table}) AS t1 JOIN (SELECT * FROM {table}) AS t2 ON t1.{col} = t2.{col};',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE {col} > 0);',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE {col} < 0);',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE {col} = NULL);',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE 1 = 0);',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE 1 = 1);',
f'SELECT * FROM {table} WHERE NOT EXISTS (SELECT 1 FROM {table} WHERE 1 = 0);',
f'SELECT * FROM {table} WHERE NOT EXISTS (SELECT 1 FROM {table} WHERE 1 = 1);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE {col} IS NOT NULL);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE {col} IS NULL);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} LIMIT 1);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} LIMIT 0);',
f'SELECT * FROM {table} WHERE {col} NOT IN (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} NOT IN (SELECT {col} FROM {table} WHERE {col} IS NOT NULL);',
f'SELECT * FROM {table} WHERE {col} NOT IN (SELECT {col} FROM {table} WHERE {col} IS NULL);',
f'SELECT * FROM {table} WHERE ({col}) IN (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE ({col}, {col}) IN (SELECT {col}, {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} > ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} < ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} = ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} >= ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} <= ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} <> ANY (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} > ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} < ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} = ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} >= ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} <= ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} <> ALL (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} > (SELECT AVG({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} < (SELECT AVG({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} > (SELECT MAX({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} < (SELECT MIN({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} = (SELECT COUNT(*) FROM {table});',
f'SELECT * FROM {table} WHERE {col} > (SELECT COUNT(*) FROM {table});',
f'SELECT * FROM {table} WHERE {col} = (SELECT SUM({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} = (SELECT GROUP_CONCAT({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE {col} IN (SELECT {col} FROM {table}));',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE EXISTS (SELECT 1 FROM {table}));',
f'SELECT * FROM {table} WHERE {col} = (SELECT MAX({col}) FROM {table} WHERE {col} = (SELECT MAX({col}) FROM {table}));',
f'SELECT * FROM (SELECT * FROM (SELECT * FROM {table}) AS inner1) AS inner2;',
f'SELECT {col}, COUNT(*) FROM {table} GROUP BY {col} HAVING COUNT(*) > (SELECT COUNT(*) FROM {table} LIMIT 1);',
f'SELECT {col}, COUNT(*) FROM {table} GROUP BY {col} HAVING COUNT(*) = (SELECT COUNT(*) FROM {table});',
f'SELECT {col}, COUNT(*) FROM {table} GROUP BY {col} HAVING {col} IN (SELECT {col} FROM {table});',
f'SELECT * FROM {table} t1 JOIN {table} t2 ON t1.{col} = (SELECT {col} FROM {table} LIMIT 1);',
f'SELECT * FROM {table} t1 LEFT JOIN {table} t2 ON t1.{col} = (SELECT {col} FROM {table} WHERE {col} = t1.{col});',
f'SELECT * FROM {table} t1 RIGHT JOIN {table} t2 ON t1.{col} = (SELECT {col} FROM {table} WHERE {col} = t1.{col});',
f'SELECT * FROM {table} t1 JOIN (SELECT * FROM {table}) AS sub ON t1.{col} = sub.{col};',
f'SELECT {col} FROM {table} UNION SELECT {col} FROM (SELECT * FROM {table}) AS sub;',
f'SELECT {col} FROM {table} INTERSECT SELECT {col} FROM (SELECT * FROM {table}) AS sub;',
f'SELECT {col} FROM {table} EXCEPT SELECT {col} FROM (SELECT * FROM {table}) AS sub;',
f'SELECT {col} FROM {table} UNION ALL SELECT {col} FROM (SELECT * FROM {table}) AS sub;',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table}) SELECT * FROM cte WHERE {col} IS NOT NULL;',
f'WITH cte AS (SELECT {col}, COUNT(*) FROM {table} GROUP BY {col}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table}), cte2 AS (SELECT * FROM cte) SELECT * FROM cte2;',
f'WITH RECURSIVE cte AS (SELECT {col} FROM {table} UNION ALL SELECT {col} FROM cte LIMIT 1) SELECT * FROM cte;',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE 1/0 = 0);'
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} LIMIT -1);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} LIMIT 0);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} ORDER BY {col} LIMIT 1 OFFSET 1000);',
f'SELECT * FROM {table} WHERE {col} IN (SELECT DISTINCT {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} IN (SELECT ALL {col} FROM {table});',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE {col} LIKE \"%%\");',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE {col} GLOB \"*\");',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} WHERE ROW_NUMBER() OVER (ORDER BY {col}) = 1);',
f'SELECT * FROM {table} WHERE {col} = (SELECT {col} FROM {table} ORDER BY {col} LIMIT 1 OFFSET (SELECT COUNT(*) FROM {table} / 2));',
f'SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table});',
f'SELECT * FROM (SELECT * FROM {table}) AS sub;',
f'SELECT {col} FROM {table} WHERE {col} = (SELECT MAX({col}) FROM {table});',
f'SELECT * FROM {table} WHERE {col} NOT IN (SELECT {col} FROM {table});',
f'SELECT * FROM {table} WHERE ({col}) IN (SELECT {col} FROM {table});',
])
return s + '\n' + style
def mut_append_cte(s: str) -> str:
"""Append a SELECT statement that queries a CTE"""
table, col = _pick_table_col(s)
n = random.randint(2, 100)
style = random.choice([
f'WITH cte AS (SELECT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table} WHERE {col} IS NOT NULL) SELECT * FROM cte;',
f'WITH cte AS (SELECT DISTINCT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col}, COUNT(*) AS cnt FROM {table} GROUP BY {col}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table} ORDER BY {col} LIMIT 5) SELECT * FROM cte;',
f'WITH cte(x) AS (SELECT {col} FROM {table}) SELECT x FROM cte;',
f'WITH cte(a, b) AS (SELECT {col}, {col} FROM {table}) SELECT a, b FROM cte;',
f'WITH cte(a, b, c) AS (SELECT {col}, {col}, {col} FROM {table}) SELECT a, b, c FROM cte;',
f'WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte;',
f'WITH cte(x, y) AS (VALUES(1,2),(3,4),(5,6)) SELECT * FROM cte;',
f'WITH a AS (SELECT * FROM {table}), b AS (SELECT * FROM a) SELECT * FROM b;',
f'WITH a AS (SELECT {col} FROM {table}), b AS (SELECT {col} FROM a), c AS (SELECT {col} FROM b) SELECT * FROM c;',
f'WITH a AS (SELECT {col} FROM {table}), b AS (SELECT {col} FROM {table}) SELECT * FROM a JOIN b ON a.{col} = b.{col};',
f'WITH a AS (SELECT {col} FROM {table}), b AS (SELECT COUNT(*) AS cnt FROM a) SELECT * FROM b;',
f'WITH a AS (SELECT * FROM {table} WHERE {col} IS NOT NULL), b AS (SELECT * FROM a WHERE {col} > 0), c AS (SELECT * FROM b LIMIT 10) SELECT * FROM c;',
f'WITH a AS (SELECT * FROM {table}), b AS (SELECT * FROM {table}) SELECT * FROM a UNION ALL SELECT * FROM b;',
f'WITH m AS MATERIALIZED (SELECT {col} FROM {table}) SELECT * FROM m;',
f'WITH n AS NOT MATERIALIZED (SELECT {col} FROM {table}) SELECT * FROM n;',
f'WITH m AS MATERIALIZED (SELECT * FROM {table}) SELECT m.{col} FROM m JOIN m AS m2 ON m.{col} = m2.{col};',
f'WITH n AS NOT MATERIALIZED (SELECT * FROM {table}) SELECT * FROM n WHERE {col} > 0;',
f'WITH a AS MATERIALIZED (SELECT * FROM {table}), b AS NOT MATERIALIZED (SELECT * FROM a) SELECT * FROM b;',
f'WITH a AS NOT MATERIALIZED (SELECT * FROM {table}), b AS MATERIALIZED (SELECT * FROM a) SELECT * FROM b;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT * FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT SUM(x) FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT MAX(x) FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT COUNT(*) FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT x FROM cnt WHERE x > {n//2};',
f'WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;',
f'WITH RECURSIVE fib(a,b) AS (VALUES(1,1) UNION ALL SELECT b, a+b FROM fib WHERE b<1000) SELECT a FROM fib;',
f'WITH RECURSIVE fib(a,b,n) AS (VALUES(1,1,1) UNION ALL SELECT b, a+b, n+1 FROM fib WHERE n<{n}) SELECT a, n FROM fib;',
f'WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<{n}) SELECT * FROM tree;',
f'WITH RECURSIVE tree(id, path) AS (VALUES(1, "/1") UNION ALL SELECT id+1, path || "/" || (id+1) FROM tree WHERE id<{n}) SELECT * FROM tree;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION SELECT x+1 FROM cnt WHERE x<{n}) SELECT * FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT * FROM cnt;',
f'WITH RECURSIVE vals(x) AS (SELECT {col} FROM {table} WHERE {col} IS NOT NULL UNION ALL SELECT {col} FROM {table} WHERE {col} IS NOT NULL LIMIT 10) SELECT * FROM vals;',
f'WITH RECURSIVE r AS (SELECT {col} FROM {table} UNION ALL SELECT {col} FROM {table} LIMIT 5) SELECT * FROM r;',
f'WITH RECURSIVE r AS (SELECT {col} FROM {table} WHERE {col} IS NOT NULL UNION ALL SELECT {col} FROM r WHERE {col} > 0 LIMIT 10) SELECT * FROM r;',
f'WITH RECURSIVE r AS (SELECT * FROM {table} LIMIT 1 UNION ALL SELECT t.* FROM {table} t JOIN r ON t.{col} = r.{col} LIMIT 10) SELECT * FROM r;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<1) SELECT * FROM cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<0) SELECT * FROM cnt;',
f'WITH RECURSIVE empty(x) AS (SELECT 1 WHERE 1=0 UNION ALL SELECT x+1 FROM empty WHERE x<10) SELECT * FROM empty;',
f'WITH RECURSIVE inf(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM inf) SELECT * FROM inf LIMIT 10;',
f'WITH RECURSIVE self(x) AS (SELECT 1 UNION ALL SELECT x FROM self) SELECT * FROM self LIMIT 5;',
f'WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-{n}) SELECT * FROM cnt;',
f'WITH RECURSIVE multi(a, b, c) AS (VALUES(1, 2, 3) UNION ALL SELECT a+1, b+1, c+1 FROM multi WHERE a<{n}) SELECT * FROM multi;',
f'WITH RECURSIVE multi(a, b) AS (VALUES(1, "x") UNION ALL SELECT a+1, "x" FROM multi WHERE a<{n}) SELECT * FROM multi;',
f'WITH RECURSIVE multi(a, b) AS (VALUES(1, 1.0) UNION ALL SELECT a+1, b*0.5 FROM multi WHERE a<{n}) SELECT * FROM multi;',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte JOIN {table} ON cte.{col} = {table}.{col};',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte LEFT JOIN {table} ON cte.{col} = {table}.{col};',
f'WITH cte1 AS (SELECT * FROM {table}), cte2 AS (SELECT * FROM {table}) SELECT * FROM cte1 LEFT JOIN cte2 ON cte1.{col} = cte2.{col};',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte c1 JOIN cte c2 ON c1.{col} = c2.{col};',
f'WITH cte AS (SELECT {col}, COUNT(*) AS cnt FROM {table} GROUP BY {col}) SELECT * FROM cte WHERE cnt > 1;',
f'WITH cte AS (SELECT {col}, SUM({col}) AS total FROM {table} GROUP BY {col}) SELECT * FROM cte ORDER BY total DESC;',
f'WITH cte AS (SELECT {col}, AVG({col}) AS avg_val FROM {table} GROUP BY {col} HAVING AVG({col}) > 0) SELECT * FROM cte;',
f'WITH cte AS (SELECT COUNT(*) AS cnt FROM {table}) SELECT * FROM cte WHERE cnt > 0;',
f'WITH cte AS (SELECT {col}, ROW_NUMBER() OVER (ORDER BY {col}) AS rn FROM {table}) SELECT * FROM cte WHERE rn <= 5;',
f'WITH cte AS (SELECT {col}, RANK() OVER (ORDER BY {col}) AS rnk FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col}, SUM({col}) OVER (ORDER BY {col}) AS running FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col}, LAG({col}) OVER (ORDER BY {col}) AS prev FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col}, LEAD({col}) OVER (ORDER BY {col}) AS nxt FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table} WHERE {col} IN (SELECT {col} FROM {table} LIMIT 5)) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table} WHERE {col} = (SELECT MAX({col}) FROM {table})) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table} WHERE EXISTS (SELECT 1 FROM {table} WHERE {col} > 0)) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table} UNION SELECT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table} INTERSECT SELECT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table} EXCEPT SELECT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table} UNION ALL SELECT {col} FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table}) UPDATE {table} SET {col} = (SELECT {col} FROM cte LIMIT 1) WHERE 1=0;',
f'WITH cte AS (SELECT * FROM {table} LIMIT 1) DELETE FROM {table} WHERE {col} IN (SELECT {col} FROM cte) AND 1=0;',
f'WITH cte AS (SELECT 1 AS x) INSERT INTO {table}({col}) SELECT x FROM cte WHERE 1=0;',
f'WITH a AS (SELECT * FROM {table}), RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}) SELECT * FROM a CROSS JOIN cnt;',
f'WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<{n}), filtered AS (SELECT * FROM cnt WHERE x > {n//2}) SELECT * FROM filtered;',
f'WITH a AS (SELECT * FROM {table}), b AS (SELECT * FROM a), c AS (SELECT * FROM b), d AS (SELECT * FROM c) SELECT * FROM d;',
f'WITH a AS (SELECT {col} FROM {table}), b AS (SELECT {col} FROM a WHERE {col} IS NOT NULL), c AS (SELECT COUNT(*) AS cnt FROM b) SELECT cnt FROM c;',
f'WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM cte WHERE x > 1;',
f'WITH cte(a, b) AS (VALUES(1, "a"),(2, "b"),(3, "c")) SELECT * FROM cte;',
f'WITH cte(x) AS (VALUES(1),(2),(3)) SELECT * FROM {table} WHERE {col} IN (SELECT x FROM cte);',
f'WITH cte AS (SELECT NULL AS x) SELECT * FROM cte;',
f'WITH cte AS (SELECT NULL AS x, NULL AS y) SELECT x, y, x IS NULL FROM cte;',
f'WITH cte AS (SELECT {col} FROM {table} WHERE {col} IS NULL) SELECT * FROM cte;',
f'WITH cte(x) AS (VALUES(NULL),(1),(NULL)) SELECT * FROM cte WHERE x IS NOT NULL;',
f'WITH cte AS (SELECT 1 AS x) SELECT x + 0.5 FROM cte;',
f'WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;',
f'WITH cte AS (SELECT 1.5 AS x) SELECT CAST(x AS TEXT) FROM cte;',
f'WITH cte AS (SELECT NULL AS x) SELECT COALESCE(x, 0) FROM cte;',
f'WITH cte AS (SELECT CASE WHEN {col} > 0 THEN "pos" ELSE "neg" END AS sign FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT CASE WHEN {col} IS NULL THEN 0 ELSE {col} END AS val FROM {table}) SELECT * FROM cte;',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte a, cte b WHERE a.{col} = b.{col};',
f'WITH cte AS (SELECT * FROM {table}) SELECT * FROM cte WHERE {col} > 0 UNION ALL SELECT * FROM cte WHERE {col} <= 0;',
f'WITH cte AS (SELECT * FROM {table}) SELECT (SELECT COUNT(*) FROM cte) AS total, * FROM cte LIMIT 1;',
])
return s + '\n' + style
def mut_append_window(s: str) -> str:
"""Append a SELECT statement that applies a window function to an existing table in the query"""
table, col = _pick_table_col(s)
fn = random.choice(WINDOW_FUNCS).format(c=col)
partition = f'PARTITION BY {col} ' if random.random() < 0.5 else ''
order = f'ORDER BY {col}'
frame = random.choice([
'',
' ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW',
' RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING',
' GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING',
' ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW',
' ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP',
' ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES',
' RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS',
])
return s + '\n' + f'SELECT {fn} OVER ({partition}{order}{frame}) FROM {table};'
def mut_append_filter(s: str) -> str:
"""Append a SELECT statement that uses FILTER"""
table, col = _pick_table_col(s)
return s + '\n' + (f'SELECT '
f'COUNT(*) FILTER (WHERE {col} IS NOT NULL), '
f'SUM(rowid) FILTER (WHERE {col} > 0), '
f'COUNT(*) FILTER (WHERE 1=0), '
f'COUNT(*) FILTER (WHERE 1=1), '
f'COUNT(*) FILTER (WHERE NULL), '
f'AVG({col}) FILTER (WHERE {col} > 0 AND {col} < 100), '
f'COUNT(*) FILTER (WHERE typeof({col}) = "text") '
f'FROM {table};')
def mut_append_aggregate(s: str) -> str:
"""Append a SELECT statement that uses an aggregate function"""
table, col = _pick_table_col(s)
fn = random.choice(AGG_FUNCS)
if fn == 'COUNT' and random.random() < 0.5:
agg = 'COUNT(*)'
elif fn == 'GROUP_CONCAT' and random.random() < 0.5:
agg = f"GROUP_CONCAT({col}, '|')"
elif fn == 'STRING_AGG' and random.random() < 0.5:
agg = f"STRING_AGG({col}, '|')"
else:
agg = f"{fn}({col})"
return s + '\n' + f'SELECT {agg} FROM {table};'
def mut_append_update(s: str) -> str:
"""Append an UPDATE statement"""
table, col = _pick_table_col(s)
val = random.choice([
str(random.randint(-100, 100)),
'NULL',
"'x'",
"''",
f'{col} + 1',
'CURRENT_TIMESTAMP',
f"json_object('k', {col})",
])
where = random.choice([
'',
f' WHERE {col} IS NOT NULL',
' WHERE rowid = 1',
' WHERE 1',
f' WHERE {col} BETWEEN 0 AND 100',
])
returning = ' RETURNING *' if random.random() < 0.4 else ''
return s + '\n' + f'UPDATE {table} SET {col} = {val}{where}{returning};'
def mut_append_delete(s: str) -> str:
"""Append a DELETE statement"""
table, col = _pick_table_col(s)
where = random.choice([
f'WHERE rowid = {random.randint(1, 100)}',
f'WHERE {col} IS NULL',
'WHERE 0',
'WHERE 1',
f'WHERE {col} > (SELECT AVG({col}) FROM {table})',
])
returning = ' RETURNING *' if random.random() < 0.4 else ''
return s + '\n' + f'DELETE FROM {table} {where}{returning};'
def mut_append_index(s: str) -> str:
"""Append a CREATE INDEX statement"""
table, col = _pick_table_col(s)
unique = random.choice(['', 'UNIQUE '])
where = random.choice(['', f' WHERE {col} IS NOT NULL', f' WHERE {col} > 0'])
expr = random.choice(
[col, f'lower({col})', f'({col} + 1)', f'{col} COLLATE NOCASE'])
suffix = random.randint(0, 9999)
return s + '\n' + f'CREATE {unique} INDEX IF NOT EXISTS idx_{table}_{suffix} ON {table}({expr}){where};'
def mut_append_view(s: str) -> str:
"""Append a CREATE VIEW statement"""
table, col = _pick_table_col(s)
suffix = random.randint(0, 9999)
temp = random.choice(['', 'TEMP ', 'TEMPORARY '])
return s + '\n' + f'CREATE {temp} VIEW IF NOT EXISTS v_{table}_{suffix} AS SELECT {col} FROM {table};'
def mut_append_trigger(s: str) -> str:
"""Append a CREATE TRIGGER statement"""
table, col = _pick_table_col(s)
when = random.choice(['BEFORE', 'AFTER'])
event = random.choice(['INSERT', 'UPDATE', 'DELETE', f'UPDATE OF {col}'])
suffix = random.randint(0, 9999)
body = random.choice([
"SELECT RAISE(IGNORE)",
"SELECT RAISE(FAIL, 'no')",
"SELECT RAISE(ABORT, 'abort')",
"SELECT RAISE(ROLLBACK, 'rb')",
f"INSERT INTO {table}({col}) VALUES (NULL)",
])
fer = ' FOR EACH ROW' if random.random() < 0.5 else ''
return s + '\n' + f'CREATE TRIGGER IF NOT EXISTS trg_{table}_{suffix} {when} {event} ON {table}{fer} BEGIN {body}; END;'
def mut_wrap_savepoint(s: str) -> str:
"""Wrap the query inside SAVEPOINT-RELEASE/ROLLBACK"""
name = f'sp{random.randint(0, 9999)}'
end = random.choice([
f'RELEASE {name};',
f'ROLLBACK TO {name};\nRELEASE {name};',
f'ROLLBACK TRANSACTION TO SAVEPOINT {name};\nRELEASE SAVEPOINT {name};',
])
return f'SAVEPOINT {name};\n{s}\n{end}'
def mut_wrap_transaction(s: str) -> str:
"""Wrap the query inside a transaction"""
begin = random.choice([
"BEGIN", "BEGIN DEFERRED", "BEGIN IMMEDIATE", "BEGIN EXCLUSIVE",
"BEGIN TRANSACTION", "BEGIN DEFERRED TRANSACTION",
"BEGIN IMMEDIATE TRANSACTION", "BEGIN EXCLUSIVE TRANSACTION"
])
end = random.choice(
['COMMIT;', 'ROLLBACK;', 'END;', 'END TRANSACTION;', 'COMMIT TRANSACTION;'])
return f'{begin};\n{s}\n{end}'
def mut_wrap_attach_detach(s: str) -> str:
"""Wrap the query inside ATTACH and DETACH statements"""
alias = f'aux{random.randint(0, 99)}'
return (f"ATTACH DATABASE ':memory:' AS {alias};\n"
f"{s}\n"
f"DETACH DATABASE {alias};")
def mut_append_vacuum(s: str) -> str:
"""Append a VACUUM statement"""
return s + '\n' + random.choice([
'VACUUM;',
'VACUUM main;',
])
def mut_append_analyze(s: str) -> str:
"""Append an ANALYZE statement"""
table = _pick_table(s)
return s + '\n' + random.choice([
'ANALYZE;',
f'ANALYZE {table};',
])
def mut_append_reindex(s: str) -> str:
"""Append a REINDEX statement"""
table = _pick_table(s)
return s + '\n' + random.choice([
f'REINDEX {table};',
'REINDEX;',
])
def mut_append_null_insert(s: str) -> str:
"""Append an INSERT statement with NULL"""
schema = get_schema(s)
table = random.choice(list(schema.keys()))
cols = schema[table]
if not cols:
return s + '\n' + f'INSERT INTO {table} DEFAULT VALUES;'
vals = ', '.join('NULL' for _ in cols)
return s + '\n' + f'INSERT INTO {table} VALUES ({vals});'
def mut_append_insert_default(s: str) -> str:
"""Append an INSERT statement with DEFAULT VALUES"""
return s + '\n' + f'INSERT INTO {_pick_table(s)} DEFAULT VALUES;'
def mut_append_insert_select(s: str) -> str:
"""Append an INSERT statement that duplicates all rows in the table"""
table = _pick_table(s)
return s + '\n' + f'INSERT INTO {table} SELECT * FROM {table};'
def mut_append_insert_or_x(s: str) -> str:
"""Append an INSERT OR ROLLBACK/ABORT/FAIL/IGNORE/REPLACE statement"""
schema = get_schema(s)
table = random.choice(list(schema.keys()))
cols = schema[table] or ['rowid']
vals = ', '.join(
random.choice(['NULL', '0', "''", "'x'",
str(random.randint(-10, 10))]) for _ in cols)
kind = random.choice(
['OR IGNORE', 'OR REPLACE', 'OR FAIL', 'OR ABORT', 'OR ROLLBACK'])
return s + '\n' + f'INSERT {kind} INTO {table} VALUES ({vals});'
def mut_append_upsert(s: str) -> str:
"""Append an INSERT statement that updates the existing set if there is a conflict"""
schema = get_schema(s)
table = random.choice(list(schema.keys()))
cols = schema[table]
if not cols:
return s
target = cols[0]
upd = ', '.join(f'{c} = excluded.{c}' for c in cols[:3])
vals = ', '.join(random.choice(['NULL', '1', "'x'"]) for _ in cols)
return s + '\n' + f'INSERT INTO {table} VALUES ({vals}) ON CONFLICT({target}) DO UPDATE SET {upd};'
def mut_append_alter_rename_table(s: str) -> str:
"""Append an ALTER statement that renames an existing table"""
table = _pick_table(s)
suffix = random.randint(0, 9999)
return s + '\n' + f'ALTER TABLE {table} RENAME TO {table}_r{suffix};'
def mut_append_alter_rename_column(s: str) -> str:
"""Append an ALTER statement that renames a column of an existing table"""
schema = get_schema(s)
table = random.choice(list(schema.keys()))
cols = schema[table]
if not cols:
return s
col = random.choice(cols)
suffix = random.randint(0, 9999)
return s + '\n' + f'ALTER TABLE {table} RENAME COLUMN {col} TO {col}_r{suffix};'
def mut_append_alter_add_column(s: str) -> str:
"""Append an ALTER statement that adds a column to an existing table"""
table = _pick_table(s)
suffix = random.randint(0, 9999)
type = random.choice(TYPES)
extras = random.choice([
'',
' DEFAULT NULL',
" DEFAULT ''",
' DEFAULT 0',
' DEFAULT CURRENT_TIMESTAMP',
' COLLATE NOCASE',
' NOT NULL DEFAULT 0',
' UNIQUE',
' DEFAULT (random())',
' DEFAULT (abs(random()) % 1000)',
' COLLATE RTRIM',
])
return s + '\n' + f'ALTER TABLE {table} ADD COLUMN extra_{suffix} {type}{extras};'
def mut_append_alter_drop_column(s: str) -> str:
"""Append an ALTER statement that drops a column from an existing table"""
schema = get_schema(s)
table = random.choice(list(schema.keys()))
cols = schema[table]
if not cols:
return s
col = random.choice(cols)
return s + '\n' + f'ALTER TABLE {table} DROP COLUMN {col};'
def mut_append_alter_drop_table_index_view_trigger(s: str) -> str:
"""Append an ALTER statement that drops a table, index, view, or trigger"""
schema = get_schema(s)
if not schema:
return s
table = random.choice(list(schema.keys()))
obj = random.choice(['TABLE', 'INDEX', 'VIEW', 'TRIGGER'])
return s + '\n' + f'DROP {obj} IF EXISTS {table};'
def mut_repeat(s: str) -> str:
"""Repeat the query 1-10 times"""
return f'{s}\n' * random.randint(1, 10)
def mut_prepend_random_pragma(s: str) -> str:
"""Prepend a PRAGMA statement"""
return random.choice(PRAGMAS) + '\n' + s
def mut_append_random_pragma(s: str) -> str:
"""Append a PRAGMA statement"""
return s + '\n' + random.choice(PRAGMAS)
def mut_prepend_random_meta_command(s: str) -> str:
"""Prepend a meta-command"""
return random.choice(META_COMMANDS) + '\n' + s
part1/mutator_operators.py
+123
View File
@@ -0,0 +1,123 @@
import random
import re
from sqlite_static_helper import *
_TOKEN_RE = re.compile(
r"""
(?P<line_comment>--[^\n]*) |
(?P<block_comment>/\*.*?\*/) |
(?P<string>'(?:[^']|'')*') |
(?P<dquoted>"(?:[^"]|"")*") |
(?P<bracket>\[[^\]]*\]) |
(?P<backtick>`(?:[^`]|``)*`) |
(?P<blob>[xX]'[0-9a-fA-F]*') |
(?P<number>\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b) |
(?P<ident>[A-Za-z_][A-Za-z0-9_]*) |
(?P<op>[<>!=]=|<>|\|\||::|->>?|[+\-*/%<>=&|^~,.;()@]) |
(?P<ws>\s+) |
(?P<other>.)
""",
re.VERBOSE | re.DOTALL,
)
_UNSAFE_KINDS = {
"line_comment", "block_comment", "string", "dquoted", "bracket", "backtick",
"blob"
}
def _tokenize(s: str):
return [(m.lastgroup, m.group()) for m in _TOKEN_RE.finditer(s)]
def _sub_in_safe(s: str, pattern: re.Pattern, repl, max_subs: int = 1) -> str:
"""Run `pattern.sub(repl, …)` only outside strings/comments/blob literals."""
if max_subs <= 0:
return s
parts: list[str] = []
done = 0
for kind, text in _tokenize(s):
if done >= max_subs or kind in _UNSAFE_KINDS:
parts.append(text)
continue
new_text, n = pattern.subn(repl, text, count=max_subs - done)
parts.append(new_text)
done += n
return ''.join(parts)
_CMP_RE = re.compile(r'(?<![<>!=])(<=|>=|<>|!=|==|=|<|>)(?!=)')
def mut_swap_comparison(s: str) -> str:
"""Swap the left-most comparison operator with a different one"""
def repl(m: re.Match) -> str:
op = m.group(1)
return random.choice([o for o in CMP_OPS if o != op])
return _sub_in_safe(s, _CMP_RE, repl, 1)
_BOOL_RE = re.compile(r'\b(AND|OR)\b', re.I)
def mut_swap_boolean(s: str) -> str:
"""Swap the left-most boolean operator with a different one"""
def repl(m: re.Match) -> str:
return 'OR' if m.group(1).upper() == 'AND' else 'AND'
return _sub_in_safe(s, _BOOL_RE, repl, 1)
def mut_negate_where(s: str) -> str:
"""Swap the left-most WHERE with WHERE NOT"""
if not re.search(r'\bWHERE\b', s, re.I):
return s
return _sub_in_safe(s, re.compile(r'\bWHERE\b', re.I), 'WHERE NOT', 1)
def mut_change_type(s: str) -> str:
"""Swap the left-most data type with a different one"""
pat = re.compile(
r'\b(' + '|'.join(
re.escape(t)
for t in sorted(TYPES, key=len, reverse=True)) +
r')\b',
re.I,
)
def repl(m: re.Match) -> str:
cur = m.group(1).upper()
return random.choice(
[t for t in TYPES if t.upper() != cur])
return _sub_in_safe(s, pat, repl, 1)
def mut_swap_join_type(s: str) -> str:
"""Swap one join type to a different join type"""
join_pattern = '|'.join(
re.escape(j) for j in sorted(JOINS, key=len, reverse=True))
pat = re.compile(rf'\b({join_pattern})\b', re.I)
m = pat.search(s)
if not m:
return s
matched = m.group(1).upper()
alternatives = [j for j in JOINS if j.upper() != matched]
if not alternatives:
return s
replacement = random.choice(alternatives)
if m.group(1).isupper():
replacement = replacement.upper()
elif m.group(1).islower():
replacement = replacement.lower()
elif m.group(1)[0].isupper() and m.group(1)[1:].islower():
replacement = replacement.title()
return s[:m.start()] + replacement + s[m.end():]
part1/mutator_values.py
+128
View File
@@ -0,0 +1,128 @@
import random
import re
import sqlite_static_helper
def _quote_str(text: str) -> str:
"""O'Reilly -> 'O''Reilly'"""
return "'" + text.replace("'", "''") + "'"
_TOKEN_RE = re.compile(
r"""
(?P<line_comment>--[^\n]*) |
(?P<block_comment>/\*.*?\*/) |
(?P<string>'(?:[^']|'')*') |
(?P<dquoted>"(?:[^"]|"")*") |
(?P<bracket>\[[^\]]*\]) |
(?P<backtick>`(?:[^`]|``)*`) |
(?P<blob>[xX]'[0-9a-fA-F]*') |
(?P<number>\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b) |
(?P<ident>[A-Za-z_][A-Za-z0-9_]*) |
(?P<op>[<>!=]=|<>|\|\||::|->>?|[+\-*/%<>=&|^~,.;()@]) |
(?P<ws>\s+) |
(?P<other>.)
""",
re.VERBOSE | re.DOTALL,
)
def _tokenize(s: str) -> list[tuple[str | None, str]]:
"""[("line_comment", "-- This is a comment!"), ("number", 0), ...]"""
return [(m.lastgroup, m.group()) for m in _TOKEN_RE.finditer(s)]
_UNSAFE_KINDS = {
"line_comment", "block_comment", "string", "dquoted", "bracket", "backtick",
"blob"
}
def _sub_in_safe(s: str, pattern: re.Pattern, repl, max_subs: int = 1) -> str:
"""Run `pattern.sub(repl, …)` only outside strings/comments/blob literals."""
if max_subs <= 0:
return s
parts: list[str] = []
done = 0
for kind, text in _tokenize(s):
if done >= max_subs or kind in _UNSAFE_KINDS:
parts.append(text)
continue
new_text, n = pattern.subn(repl, text, count=max_subs - done)
parts.append(new_text)
done += n
return ''.join(parts)
_NUM_RE = re.compile(r'\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b')
def mut_replace_num_with_edge_int(s: str) -> str:
"""Replace the left-most number with a random edge-case integer"""
return _sub_in_safe(
s, _NUM_RE, lambda m: str(random.choice(sqlite_static_helper.EDGE_INTS)), 1)
def mut_replace_num_with_random_int(s: str) -> str:
"""Replace the left-most number with a random integer"""
return _sub_in_safe(s, _NUM_RE,
lambda m: str(random.randint(-(2**63), 2**63 - 1)), 1)
def mut_replace_num_with_edge_float(s: str) -> str:
"""Replace the left-most number with a random edge-case floating-point number"""
return _sub_in_safe(
s, _NUM_RE, lambda m: repr(random.choice(sqlite_static_helper.EDGE_FLOATS)),
1)
def mut_replace_num_with_edge_string(s: str) -> str:
"""Replace the left-most number with a random edge-case string"""
return _sub_in_safe(
s, _NUM_RE,
lambda m: _quote_str(random.choice(sqlite_static_helper.EDGE_STRINGS)), 1)
def mut_replace_num_with_random_hex(s: str) -> str:
"""Replace the left-most number with a random hex blob"""
n = random.randint(0, 16)
val = "x'" + ''.join(random.choices('0123456789abcdef', k=n * 2)) + "'"
return _sub_in_safe(s, _NUM_RE, lambda m: val, 1)
def mut_replace_num_with_null(s: str) -> str:
"""Replace the left-most number with NULL"""
return _sub_in_safe(s, _NUM_RE, lambda m: 'NULL', 1)
def mut_wrap_num_in_cast(s: str) -> str:
"""Cast the left-most number to a different data type"""
target = random.choice(sqlite_static_helper.TYPES)
return _sub_in_safe(s, _NUM_RE, lambda m: f'CAST({m.group(0)} AS {target})',
1)
def _wrap_value(s: str, templates: list[str]) -> str:
tpl = random.choice(templates)
return _sub_in_safe(s, _NUM_RE, lambda m: tpl.replace('{v}', m.group(0)), 1)
def mut_wrap_num_in_datetime_func(s: str) -> str:
"""Wrap the left-most number in a date/time function"""
return _wrap_value(s, sqlite_static_helper.DATETIME_FUNCS)
def mut_wrap_num_in_core_func(s: str) -> str:
"""Wrap the left-most number in core function"""
return _wrap_value(s, sqlite_static_helper.CORE_FUNCS)
def mut_wrap_num_in_math_func(s: str) -> str:
"""Wrap the left-most number in a math function"""
return _wrap_value(s, sqlite_static_helper.MATH_FUNCS)
def mut_wrap_num_in_json_func(s: str) -> str:
"""Wrap the left-most number in a JSON function"""
return _wrap_value(s, sqlite_static_helper.JSON_VALUE_FUNCS)
part1/oracle.py
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
import random
import subprocess
from runner import run_sql_parallel
from sqlite_static_helper import *
from stats import save_bug
def is_crash(rc: int, _stderr: str) -> bool:
# https://tldp.org/LDP/abs/html/exitcodes.html
if rc > 128 and rc != 130:
return True
return False
def is_unexpected_error(b_rc, _b_err, r_rc, _r_err, _sql):
if b_rc != 0 and r_rc == 0:
return True
return False
def is_valid_sql(r_rc: int, _r_err: str):
if r_rc != 0:
return False
return True
def check(buggy_bin: str,
ref_bin: str,
sql: str,
with_flag: bool = False,
save_bugs: bool = True) -> int:
"""
Returns:
- `-1`: The query was not successfully executed on the reference binary, probably due to syntax issues
- `0`: The query caused a logic bug, crash, or some other unexpected error.
- `1`: The query was successfully executed on both binaries.
"""
flag = '' if not with_flag else random.choice(FLAGS)
try:
b_out, b_err, b_rc, r_out, r_err, r_rc = run_sql_parallel(
buggy_bin, ref_bin, sql, flag)
except subprocess.TimeoutExpired:
return 0
except Exception:
return -1
if not is_valid_sql(r_rc, r_err):
return -1
# # Crash Detection
if is_crash(b_rc, b_err) and not is_crash(r_rc, r_err):
if save_bugs:
save_bug(sql, 'crash', b_out, b_err, flag=flag)
return 0
# # Unexpected Error Detection
elif is_unexpected_error(b_rc, b_err, r_rc, r_err, sql):
if save_bugs:
save_bug(sql, 'unexpected_error', b_out, b_err, flag=flag)
return 0
# # Logic Bug Detection
elif b_rc == 0 and r_rc == 0 and b_out != r_out:
if save_bugs:
save_bug(sql, 'logic', b_out, b_err, r_out, flag=flag)
return 0
return 1
part1/random-json.db
LFS
BIN
View File
Binary file not shown.
part1/requirements.txt
+1
View File
@@ -0,0 +1 @@
gcovr
part1/results/1/bug_009451c9-81ef-4ffb-8289-4d1f0d3ec5ba_logic.md
+158
View File
@@ -0,0 +1,158 @@
## 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
.progress 2
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SeLEct * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
SELECT COUNT(*) FROM T;
INSERT INTO T VALUES (NULL, NULL);
SELECT * FROM T NATURAL JOIN T;
CREATE VIEW IF NOT EXISTS v_T_4597 AS SELECT a FROM T;
ALTER TABLE T RENAME TO T_r6678;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
SELECT COUNT(*) FROM T;
INSERT INTO T VALUES (NULL, NULL);
SELECT * FROM T NATURAL JOIN T;
CREATE VIEW IF NOT EXISTS v_T_4597 AS SELECT a FROM T;
ALTER TABLE T RENAME TO T_r6678;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
SELECT COUNT(*) FROM T;
INSERT INTO T VALUES (NULL, NULL);
SELECT * FROM T NATURAL JOIN T;
CREATE VIEW IF NOT EXISTS v_T_4597 AS SELECT a FROM T;
ALTER TABLE T RENAME TO T_r6678;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
SELECT COUNT(*) FROM T;
INSERT INTO T VALUES (NULL, NULL);
SELECT * FROM T NATURAL JOIN T;
CREATE VIEW IF NOT EXISTS v_T_4597 AS SELECT a FROM T;
ALTER TABLE T RENAME TO T_r6678;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
CREATE TABLE T (
a TEXT,
b TEXT
);
INSERT INTO T VALUES ('a','b'), ('c','d');
SELECT * FROM T WHERE a = REPLACE('a;',';','') AND b = 'b';
SELECT COUNT(*) FROM T;
INSERT INTO T VALUES (NULL, NULL);
SELECT * FROM T NATURAL JOIN T;
CREATE VIEW IF NOT EXISTS v_T_4597 AS SELECT a FROM T;
ALTER TABLE T RENAME TO T_r6678;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
ALTER TABLE T RENAME COLUMN A TO A_r8221;
PRAGMA wal_checkpoint('TRUNCATE');
INSERT INTO T VALUES (NULL, 1, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
ALTER TABLE T RENAME TO T_r7965;
DROP INDEX IF EXISTS T;
```
## Actual output
```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```
## Expectation
```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```
## Flag
```
-version
```
part1/results/1/bug_00a5bee7-b5e7-4ed5-9f14-33a8c2db79d8_unexpected_error.md
+983
View File
@@ -0,0 +1,983 @@
## 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
PRAGMA vdbe_trace = FALSE;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
INSERT INTO t1 SELECT * FROM t1;
SELECT GROUP_CONCAT(b, b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
UPDATE T SET a = json_object('k', a) WHERE 1 RETURNING *;
PRAGMA vdbe_trace = FALSE;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
INSERT INTO t1 SELECT * FROM t1;
SELECT GROUP_CONCAT(b, b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
UPDATE T SET a = json_object('k', a) WHERE 1 RETURNING *;
PRAGMA vdbe_trace = FALSE;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
ATTACH DATABASE (':memory:' || '') AS aux15;
BEGIN EXCLUSIVE TRANSACTION;
PRAGMA foreign_keys;
PRAGMA automatic_index;
PRAGMA case_sensitive_like = TRUE;
PRAGMA auto_vacuum = FULL;
.dbconfig fk off
PRAGMA foreign_keys=ON;
CREATE TABLE t1(x INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(log(100));
INSERT INTO t1 VALUES(101);
CREATE TABLE main.t2(y INTEGER REFERENCES t1 (x));
INSERT INTO t2 VALUES(100);
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',9e999);
WITH d AS (SELECT * FROM T) SELECT * FROM d WHERE +c > 0;
INSERT INTO t2 VALUES(101);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT 1, x FROM _m;
SELECT 2, y FROM t2;
DELETE FROM t2 WHERE 0;
ALTER TABLE t1 RENAME TO t1_r345;
CREATE TRIGGER IF NOT EXISTS trg_t2_4434 BEFORE INSERT ON t2 FOR EACH ROW BEGIN SELECT RAISE(ABORT, 'abort'); END;
INSERT INTO t1 VALUES (NULL);
COMMIT TRANSACTION;
DETACH DATABASE aux15;
INSERT INTO T SELECT * FROM T;
INSERT INTO t1 SELECT * FROM t1;
SELECT GROUP_CONCAT(b, b) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM T;
UPDATE T SET a = json_object('k', a) WHERE 1 RETURNING *;
CREATE INDEX IF NOT EXISTS idx_t1_3395 ON t1(lower(x)) WHERE x IS NOT NULL;
```
## Actual output
```sql
Usage: /home/test/sqlite3-src/build/sqlite3 [OPTIONS] FILENAME [SQL]
FILENAME is the name of an SQLite database. A new database is created
if the file does not previously exist.
OPTIONS include:
-append append the database to the end of the file
-ascii set output mode to 'ascii'
-bail stop after hitting an error
-batch force batch I/O
-box set output mode to 'box'
-column set output mode to 'column'
-cmd COMMAND run "COMMAND" before reading stdin
-csv set output mode to 'csv'
-deserialize open the database using sqlite3_deserialize()
-echo print commands before execution
-init FILENAME read/process named file
-[no]header turn headers on or off
-help show this message
-html set output mode to HTML
-interactive force interactive I/O
-json set output mode to 'json'
-line set output mode to 'line'
-list set output mode to 'list'
-lookaside SIZE N use N entries of SZ bytes for lookaside memory
-markdown set output mode to 'markdown'
-maxsize N maximum size for a --deserialize database
-memtrace trace all memory allocations and deallocations
-mmap N default mmap size set to N
-newline SEP set output row separator. Default: '\n'
-nofollow refuse to open symbolic links to database files
-nonce STRING set the safe-mode escape nonce
-nullvalue TEXT set text string for NULL values. Default ''
-pagecache SIZE N use N slots of SZ bytes each for page cache memory
-quote set output mode to 'quote'
-readonly open the database read-only
-safe enable safe-mode
-separator SEP set output column separator. Default: '|'
-stats print memory stats before each finalize
-table set output mode to 'table'
-tabs set output mode to 'tabs'
-version show SQLite version
-vfs NAME use NAME as the default VFS
```
## Expectation
```sql
```
## Flag
```
-help
```
part1/results/1/bug_00c6ea1e-1b8a-4724-9232-a7b969741e4a_unexpected_error.md
+1226
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_01272b7b-20ba-4d5b-882d-06992530c0d5_unexpected_error.md
+35
View File
@@ -0,0 +1,35 @@
## 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
PRAGMA encoding = 'UTF-16le';
CREATE TABLE [t0](c0);
INSERT INTO t0(c0) VALUES (NULL);
CREATE INDEX i0 ON t0(json_remove(unixepoch(unistr_quote('Hello')), '$')) WHERE NOT c0 NOT NULL;
SELECT 1 FROM /* {"a":1,"b":[1,2,3]} */ t0 WHERE (t0.c0 IS FALSE) IS FALSE;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) BETWEEN FALSE AND TRUE;
ALTER TABLE t0 RENAME TO t0_r5716;
```
## Actual output
```sql
1
1
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_02234c13-82c1-414a-874a-5145aed0ea89_unexpected_error.md
+88
View File
@@ -0,0 +1,88 @@
## 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
SAVEPOINT sp1623;
.timeout
((PRAGMA)) synchronous = '2';
PRAGMA count_changes;
PRAGMA vdbe_listing = CAST(0 AS NATIVE CHARACTER(70)NVARCHAR(100));
.open
CREATE TABLE t1(x INTEGER PRIMARY KEY, y, z);
CREATE TABLE t2(a, b);
CREATE VIEW agg2 AS SELECT a, sum(b) AS m FROM t2 GROUP BY a;
SELECT t1.z, agg2.m FROM t1 JOIN agg2 ON t1.y=agg2.m WHERE t1.x IN (1,2,3);
CREATE TABLE t920(x);
INSERT INTO t920 VALUES(3),(4),(5);
SELECT * FROM t920,(SELECT 0 FROM t920),(VALUES(9)) WHERE 5 IN (x);
SELECT PERCENT_RANK() OVER (ORDER BY a ROWS BETWEEN 2 PRECEDING OR 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t2;
INSERT INTO t920 VALUES (1) ON CONFLICT(x) DO UPDATE SET x = excluded.x;
ALTER TABLE t1 RENAME TO t1_r6222;
SELECT * FROM t1 CROSS JOIN t1;
DELETE FROM t1 WHERE x IS NULL RETURNING *;
ROLLBACK TRANSACTION TO SAVEPOINT sp1623;
RELEASE SAVEPOINT sp1623;
SELECT AVG(y) FILTER (WHERE y != 0) OVER (ORDER BY y ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t1;
```
## Actual output
```sql
Usage: /home/test/sqlite3-src/build/sqlite3 [OPTIONS] FILENAME [SQL]
FILENAME is the name of an SQLite database. A new database is created
if the file does not previously exist.
OPTIONS include:
-append append the database to the end of the file
-ascii set output mode to 'ascii'
-bail stop after hitting an error
-batch force batch I/O
-box set output mode to 'box'
-column set output mode to 'column'
-cmd COMMAND run "COMMAND" before reading stdin
-csv set output mode to 'csv'
-deserialize open the database using sqlite3_deserialize()
-echo print commands before execution
-init FILENAME read/process named file
-[no]header turn headers on or off
-help show this message
-html set output mode to HTML
-interactive force interactive I/O
-json set output mode to 'json'
-line set output mode to 'line'
-list set output mode to 'list'
-lookaside SIZE N use N entries of SZ bytes for lookaside memory
-markdown set output mode to 'markdown'
-maxsize N maximum size for a --deserialize database
-memtrace trace all memory allocations and deallocations
-mmap N default mmap size set to N
-newline SEP set output row separator. Default: '\n'
-nofollow refuse to open symbolic links to database files
-nonce STRING set the safe-mode escape nonce
-nullvalue TEXT set text string for NULL values. Default ''
-pagecache SIZE N use N slots of SZ bytes each for page cache memory
-quote set output mode to 'quote'
-readonly open the database read-only
-safe enable safe-mode
-separator SEP set output column separator. Default: '|'
-stats print memory stats before each finalize
-table set output mode to 'table'
-tabs set output mode to 'tabs'
-version show SQLite version
-vfs NAME use NAME as the default VFS
```
## Expectation
```sql
```
## Flag
```
-help
```
part1/results/1/bug_02275b3a-6b31-490b-a1fc-3d9b31ee3e7c_unexpected_error.md
+689
View File
@@ -0,0 +1,689 @@
## 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
PRAGMA trusted_schema = NO;
ATTACH DATABASE ':memory:' AS aux77;
CREATE TABLE T (
a TEXT,
b REAL
);
INSERT INTO T VALUES ('a',ln(datetime(NULL))), ('b',-CAST(tan(instr(NULL, (concat_ws(',', 1, 2, 3) + 0))) AS REAL)), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
PRAGMA case_sensitive_like == OFF;
BEGIN TRANSACTION;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(substring(printf('%05d', 1), 1) AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); ENd;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES /**/ ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
.quit
((PRAGMA)) vdbe_debug = -concat(log10(CAST(1 AS DOUBLE)), 2, 3);
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE "T" (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO main.T VALUES ('' || ('a'), 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
.quit
((PRAGMA)) vdbe_debug = 0;
PRAGMA secure_delete = ON;
PRAGMA wal_autocheckpoint = 1000;
.once log.txt
CREATE TABLE T (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
ALTER TABLE T DROP COLUMN B;
ALTER TABLE T RENAME TO T_r2338;
ALTER TABLE T RENAME TO T_r2523;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
PRAGMA trusted_schema = OFF;
UPDATE T SET C = 79 RETURNING *;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT C, COUNT(*) FROM T GROUP BY C HAVING C IN (SELECT C FROM T);
REINDEX;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T_9021 ON T(lower(A));
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
ALTER TABLE T RENAME COLUMN B TO B_r4119;
VACUUM main;
CREATE TRIGGER IF NOT EXISTS trg_T_9843 AFTER DELETE ON T BEGIN SELECT RAISE(FAIL, 'no'); END;
PRAGMA vdbe_debug = 1;
VACUUM main;
CREATE INDEX IF NOT EXISTS idx_T_8791 ON T(lower(B)) WHERE B IS NOT NULL;
SELECT * FROM T WHERE B <= ANY (SELECT B FROM T);
WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT * FROM T;
UPDATE T SET A = '';
COMMIT TRANSACTION;
CREATE TABLE T1 (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE `_m` (
A VARCHAR(10) PRIMARY KEY,
X VARCHAR(15) NOT NULL,
C BIGINT,
FOREIGN KEY (X) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('p', 'x');
INSERT INTO T1 VALUES ('q', 'y');
INSERT INTO T2 VALUES ('a', 'p', 9223372036854775807);
INSERT INTO T2 VALUES ('b', 'q', -9223372036854775808);
SELECT X, SUM(C) AS D, COUNT(*) AS E FROM T2 GROUP BY X;
ANALYZE;
REINDEX;
DROP INDEX IF EXISTS T2;
REINDEX T1;
REINDEX T2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C INTEGER
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10) NOT NULL UNIQUE,
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', -2147483648);
INSERT INTO T1 VALUES ('b', 'q', 2147483647);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.B, T1.C FROM T2, T1 WHERE T2.A = T1.A AND T1.C >= 0;
SELECT * FROM T WHERE (C) IN (SELECT C FROM T);
DETACH DATABASE aux77;
SELECT MIN(A) OVER (ORDER BY A RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T;
REINDEX T2;
SELECT COUNT(*) FROM T1;
SELECT SUM(X) FROM T2;
ALTER TABLE T2 DROP COLUMN A;
UPDATE T2 SET A = NULL RETURNING *;
UPDATE T2 SET X = json_object('k', X) WHERE X BETWEEN 0 AND 100;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<52) SELECT COUNT(*) FROM cnt;
SELECT SUM(C) FROM T;
DROP TRIGGER IF EXISTS T2;
CREATE VIEW IF NOT EXISTS v_T_7805 AS SELECT B FROM T;
ALTER TABLE T2 DROP COLUMN A;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
SELECT AVG(A) OVER (PARTITION BY A ORDER BY A) FROM T1;
SELECT LEAD(X, X) OVER (ORDER BY X) FROM T2;
SELECT * FROM T1;
SELECT LAG(A, 2, 'default') OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
SELECT * FROM T2 WHERE X IN (SELECT X FROM T2 LIMIT 1);
SELECT COUNT(*) FROM T1;
SELECT * FROM T AS a RIGHT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
PRAGMA module_list;
ALTER TABLE T2 ADD COLUMN extra_4727 CHARINT COLLATE NOCASE;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
CREATE TRIGGER IF NOT EXISTS trg_T2_8325 BEFORE UPDATE OF X ON T2 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
ALTER TABLE _m DROP COLUMN C;
ALTER TABLE _m RENAME COLUMN A TO A_r8882;
ANALYZE T1;
CREATE TRIGGER IF NOT EXISTS trg__m_3011 AFTER INSERT ON _m BEGIN INSERT INTO _m(C) VALUES (NULL); END;
```
## Actual output
```sql
Parse error near line 7: no such function: concat_ws
,ln(datetime(NULL))), ('b',-CAST(tan(instr(NULL, (concat_ws(',', 1, 2, 3) + 0)
error here ---^
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_023ed30e-c445-4614-9524-9e8a3f10a369_unexpected_error.md
+671
View File
@@ -0,0 +1,671 @@
## 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 aux85;
-- typeof(randomblob(1))
.auth OFF
PRAGMA count_changes = OFF;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a CHARINT PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(tanh(-(-(NULL)))), -concat_ws('|', 'a', NULL, 'b'));
INSERT INTO t1 VALUES (exp(unicode(123)), 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA legacy_alter_table = ON;
CREATE TABLE t1(a DOUB PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (-(-(NULL)), 'Wernher', json_quote(123), 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN EXCLUSIVE;
CREATE TABLE map_integer (id INT, name);
INSERT INTO map_integer VALUES(lower('你好'),'a');
CREATE TABLE map_text (id TEXT, name);
INSERT INTO map_text VALUES('4','e');
CREATE TABLE `data` (id TEXT, name);
INSERT INTO data VALUES(3547739615393531126,'abc');
INSERT INTO data VALUES('4','xyz');
CREATE VIEW idmap as WITH _m AS MATERIALIZED (WITH _m AS MATERIALIZED (SELECT * FROM map_integer) SELECT * FROM map_text) SELECT * FROM _m UNION SELECT * FROM _m;
CREATE TABLE mzed AS SELECT * FROM idmap;
PRAGMA automatic_index=ON;
SELECT * FROM data JOIN idmap USING(id);
SELECT * FROM data AS a LEFT JOIN map_integer AS b ON a.rowid = b.rowid;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_6193 AS SELECT name FROM map_integer;
CREATE VIEW IF NOT EXISTS v_data_9060 AS SELECT name FROM data;
INSERT INTO data SELECT * FROM data;
PRAGMA ignore_check_constraints = 0;
ALTER TABLE data ADD COLUMN extra_9221 TINYINT DEFAULT '';
CREATE TEMPORARY VIEW IF NOT EXISTS v_map_text_5459 AS SELECT name FROM map_text;
COMMIT;
CREATE TABLE T1 (
a INTEGER,
b REAL
);
CREATE TABLE T2 (
a INTEGER,
b REAL
);
INSERT INTO T1 VALUES (1,1.0);
INSERT INTO T2 VALUES (1,-1.0),(2,9e999);
INSERT OR REPLACE INTO T1
SELECT * FROM T2;
SELECT * FROM T1;
CREATE TRIGGER IF NOT EXISTS trg_map_text_8647 AFTER DELETE ON map_text FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
SELECT NTH_VALUE(id, 0) OVER (PARTITION BY id ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM map_integer;
REINDEX map_integer;
DELETE FROM map_integer WHERE NOT NOT (0) ;
UPDATE map_text SET id = 'x' WHERE rowid = 1;
DELETE FROM map_integer WHERE rowid = 41;
CREATE VIEW IF NOT EXISTS v_data_9250 AS SELECT name FROM data;
ALTER TABLE data DROP COLUMN id;
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
INSERT INTO map_text VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
PRAGMA foreign_key_list(users);
SELECT COUNT(*) FROM data;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_7942 AS SELECT C FROM T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_map_text_1196 ON map_text(id) WHERE id > 0;
SELECT COUNT(C) FROM T;
DELETE FROM T WHERE rowid = 20 RETURNING *;
INSERT OR REPLACE INTO data VALUES (-8, 'x');
SELECT * FROM map_text;
WITH a AS (SELECT a FROM T1), b AS (SELECT a FROM a), c AS (SELECT a FROM b) SELECT * FROM c;
REINDEX map_text;
SELECT SUM(id) OVER (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM map_text;
PRAGMA foreign_keys = NO;
VACUUM main;
ALTER TABLE data RENAME TO data_r5580;
DETACH DATABASE aux85;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE t1 RENAME COLUMN d TO d_r9282;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T2_5688 AS SELECT a FROM T2;
SELECT COUNT(*) FILTER (WHERE name IS NOT NULL), SUM(rowid) FILTER (WHERE name > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(name) FILTER (WHERE name > 0 AND name < 100), COUNT(*) FILTER (WHERE typeof(name) = "text") FROM map_integer;
CREATE TEMP VIEW IF NOT EXISTS v_map_integer_262 AS SELECT id FROM map_integer;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|2
von|20|1
Braun|30
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_0293f742-da16-49ea-ba8a-e78142ca6329_logic.md
+42
View File
@@ -0,0 +1,42 @@
## 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 aux41;
SAVEPOINT sp3133;
CREATE TABLE T (
a TEXT,
b REAL
);
INSERT INTO T VALUES ('a',100.0), ('b',-200.5), ('c',9e999);
SELECT a,b,
LEAD(b,1) OVER (ORDER BY b DESC) AS c,
NTILE(2) OVER (ORDER BY b DESC) AS d FROM T;
INSERT INTO T DEFAULT VALUES;
ROLLBACK TO sp3133;
RELEASE sp3133;
REINDEX;
INSERT INTO T VALUES (1, NULL) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b;
DETACH DATABASE aux41;
```
## Actual output
```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```
## Expectation
```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```
## Flag
```
-version
```
part1/results/1/bug_02e45c83-9329-4280-a858-9ea4b422eda4_unexpected_error.md
+121
View File
@@ -0,0 +1,121 @@
## 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
PRAGMA cell_size_check = TRUE;
.headers off
.output
PRAGMA temp_store == 'FILE';
PRAGMA automatic_index = ON;
CREATE TABLE main.t1(a,b,x);
CREATE TABLE main.main.t2(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t2d ON t2(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10000 500');
INSERT INTO sqlite_stat1 VALUES('t2','t2d','10000 500');
ANALYZE sqlite_master;
SELECT * FROM t1, t2 WHERE NOT NOT (+d=b) ;
SELECT * FROM t1, t2 WHERE d>b AND x=y;
CREATE VIEW IF NOT EXISTS v_t2_5713 AS SELECT y FROM t2;
SELECT * FROM t2 WHERE NOT EXISTS (SELECT -ceil((-asin(-(-(9223372036854775806))) + 2147483646)) FROM t2 t2 WHERE t2.d = t2.d);
SELECT * FROM t2 WHERE c = (SELECT SUM(c) FROM t2);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
CREATE VIEW IF NOT EXISTS v_t1_3397 AS SELECT x FROM t1;
WITH RECURSIVE tree(id, parent, depth) AS (VALUES(1, NULL, 0) UNION ALL SELECT id+1, id, depth+1 FROM tree WHERE depth<44) SELECT * FROM tree;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION SELECT x+1 FROM cnt WHERE x<39) SELECT * FROM cnt;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1;
SELECT LEAD(x, 2, 'default') OVER (ORDER BY x) FROM t1;
CREATE INDEX IF NOT EXISTS idx_T_6271 ON T(lower(A)) WHERE A > 0;
UPDATE t2 SET d = -54 WHERE rowid = 1 RETURNING *;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE c < 2.0 ORDER BY c;
INSERT OR IGNORE INTO t2 VALUES (-8, 0, '');
UPDATE t2 SET c = 95 WHERE 1;
PRAGMA checkpoint_fullsync = YES;
SELECT * FROM t2 WHERE d IN (SELECT d FROM t2 WHERE d GLOB "*");
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_5603 AS SELECT a FROM T;
SELECT LAG(x, 0, 'default') OVER (PARTITION BY x ORDER BY x RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t1;
SELECT * FROM t1 WHERE x = (SELECT COUNT(*) FROM t1);
ALTER TABLE t1 ADD COLUMN extra_7009 TINYINT DEFAULT CURRENT_TIMESTAMP;
```
## Actual output
```sql
Usage: /home/test/sqlite3-src/build/sqlite3 [OPTIONS] FILENAME [SQL]
FILENAME is the name of an SQLite database. A new database is created
if the file does not previously exist.
OPTIONS include:
-append append the database to the end of the file
-ascii set output mode to 'ascii'
-bail stop after hitting an error
-batch force batch I/O
-box set output mode to 'box'
-column set output mode to 'column'
-cmd COMMAND run "COMMAND" before reading stdin
-csv set output mode to 'csv'
-deserialize open the database using sqlite3_deserialize()
-echo print commands before execution
-init FILENAME read/process named file
-[no]header turn headers on or off
-help show this message
-html set output mode to HTML
-interactive force interactive I/O
-json set output mode to 'json'
-line set output mode to 'line'
-list set output mode to 'list'
-lookaside SIZE N use N entries of SZ bytes for lookaside memory
-markdown set output mode to 'markdown'
-maxsize N maximum size for a --deserialize database
-memtrace trace all memory allocations and deallocations
-mmap N default mmap size set to N
-newline SEP set output row separator. Default: '\n'
-nofollow refuse to open symbolic links to database files
-nonce STRING set the safe-mode escape nonce
-nullvalue TEXT set text string for NULL values. Default ''
-pagecache SIZE N use N slots of SZ bytes each for page cache memory
-quote set output mode to 'quote'
-readonly open the database read-only
-safe enable safe-mode
-separator SEP set output column separator. Default: '|'
-stats print memory stats before each finalize
-table set output mode to 'table'
-tabs set output mode to 'tabs'
-version show SQLite version
-vfs NAME use NAME as the default VFS
```
## Expectation
```sql
```
## Flag
```
-help
```
part1/results/1/bug_032d3a84-3faf-4c26-a183-16be2803abac_logic.md
+199
View File
@@ -0,0 +1,199 @@
## 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
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
.log ON
BEGIN EXCLUSIVE;
SELECT max(NULL, like('%0%', exp(0), '%'))x0ACB29BM205381;
-- .connection
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
COMMIT TRANSACTION;
```
## Actual output
```sql
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
0
0
ATOMIC_INTRINSICS=1
3.39.0
```
## Expectation
```sql
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
0
0
ATOMIC_INTRINSICS=1
3.51.1
```
## Flag
```
```
part1/results/1/bug_034d142f-e3ac-481d-89b9-fa2d71d8c10a_unexpected_error.md
+1234
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_0363171b-903c-472e-999c-5e04a2cc648d_logic.md
+63
View File
@@ -0,0 +1,63 @@
## 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 aux55;
BEGIN EXCLUSIVE TRANSACTION;
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
WITH _m AS MATERIALIZED (SELECT * FROM T2) SELECT A FROM T1 UNION ALL SELECT A FROM _m ORDER BY A;
SELECT COUNT(*) FROM T1;
SELECT * FROM T1;
CREATE TEMP VIEW IF NOT EXISTS v_T2_1413 AS SELECT A FROM T2;
INSERT INTO T2 DEFAULT VALUES;
WITH cte AS (SELECT A, ROW_NUMBER() OVER (ORDER BY A) AS rn FROM T1) SELECT * FROM cte WHERE NOT NOT (rn <= 5) ;
END TRANSACTION;
SELECT * FROM T2;
INSERT INTO T2 DEFAULT VALUES;
VACUUM main;
DELETE FROM T2 WHERE 1;
DELETE FROM T2 WHERE 0;
ALTER TABLE T2 RENAME COLUMN A TO A_r2332;
SELECT COUNT(A) FILTER (WHERE A IS NOT NULL) OVER (PARTITION BY A ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T1;
SELECT COUNT(*) FROM T2;
INSERT OR FAIL INTO T1 VALUES (1, NULL);
SELECT COUNT(*) FROM T1;
DETACH DATABASE aux55;
```
## Actual output
```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```
## Expectation
```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```
## Flag
```
-version
```
part1/results/1/bug_03b7478f-3df9-4654-a379-487b55b8f7f5_logic.md
+57
View File
@@ -0,0 +1,57 @@
## 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
.dbconfig fk off
CREATE TABLE main.[t1](a, b, c);
-- sqrt({v})
INSERT INTO t1 VALUES(if(json_patch(CAST(0.0 AS CHARINT), 0.0), 1, 1),'aaa','bbb');
INSERT INTO t1 SELECT * FROM t1;
INSERT INTO t1 VALUES(2,'ccc','ddd');
SELECT DISTINCT a AS x, b||c AS y FROM t1 WHERE NOT NOT (y IN ('aaabbb','xxx')) ;
SELECT DISTINCT a AS x, b||c AS y FROM t1 WHERE +y='aaabbb';
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
CREATE TABLE T (
a FLOAT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
DROP TABLE t0;
CREATE TEMPORARY VIEW IF NOT EXISTS v_t1_6630 AS SELECT c FROM t1;
ANALYZE;
UPDATE t1 SET a = '' WHERE 1 RETURNING *;
ANALYZE;
SELECT TOTAL(c) FROM T;
ALTER TABLE t1 RENAME TO t1_r682;
VACUUM;
CREATE VIEW IF NOT EXISTS v_T_9629 AS SELECT c FROM T;
ALTER TABLE T RENAME TO T_r2076;
ALTER TABLE T DROP COLUMN c;
UPDATE T SET b = b + 1 WHERE rowid = 1 RETURNING *;
SELECT LAST_VALUE(b) OVER (PARTITION BY b ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T;
```
## Actual output
```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```
## Expectation
```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```
## Flag
```
-version
```
part1/results/1/bug_03dfbad6-e581-47f4-a29b-9974a3e17be8_logic.md
+132
View File
@@ -0,0 +1,132 @@
## 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
.dbconfig
ATTACH DATABASE ':memory:' AS aux3;
CREATE TABLE main.T (
a MEDIUMINT,
b TEXT,
c REAL
);
INSERT
INTO T VALUES (datetime((0 + 1)),'a',1.25), (2,'b',-3.5), (3,'c',0.0);
SELECT * FROM T WHERE +c < 2.0 ORDER BY c;
ALTER TABLE T RENAME COLUMN a TO a_r5474;
SELECT * FROM T AS a RIGHT OUTER JOIN T AS b ON a.rowid = b.rowid;
INSERT INTO T VALUES (NULL, NULL, NULL);
CREATE TABLE T1 (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(10) PRIMARY KEY,
X VARCHAR(15) NOT NULL,
C BIGINT,
FOREIGN KEY (X) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('p', 'x');
INSERT INTO T1 VALUES ('q', 'y');
INSERT INTO T2 VALUES ('a', 'p', 9223372036854775807);
INSERT INTO T2 VALUES ('b', 'q', -9223372036854775808);
SELECT X, SUM(C) AS D, COUNT(*) AS E FROM T2 GROUP BY X;
DETACH DATABASE aux3;
SELECT c FROM T WHERE c = (SELECT MAX(c) FROM T);
SELECT COUNT(*) FROM T;
ANALYZE;
INSERT INTO T2 VALUES (NULL, 1, 'x') ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X, C = excluded.C;
SELECT AVG(B) FROM T1;
ALTER TABLE T DROP COLUMN b;
SELECT * FROM T;
SELECT COUNT(*) FROM T2;
DELETE FROM T2 WHERE 0;
```
## Actual output
```sql
defensive off
dqs_ddl on
dqs_dml on
enable_fkey off
enable_qpsg off
enable_trigger on
enable_view on
fts3_tokenizer off
legacy_alter_table off
legacy_file_format off
load_extension on
no_ckpt_on_close off
reset_database off
trigger_eqp off
trusted_schema on
writable_schema off
2|b|-3.5
3|c|0.0
-4713-11-25 12:00:00|a|1.25
-4713-11-25 12:00:00|a|1.25|-4713-11-25 12:00:00|a|1.25
2|b|-3.5|2|b|-3.5
3|c|0.0|3|c|0.0
p|9223372036854775807|1
q|-9223372036854775808|1
1.25
4
0.0
-4713-11-25 12:00:00|1.25
2|-3.5
3|0.0
|
3
```
## Expectation
```sql
attach_create on
attach_write on
comments on
defensive on
dqs_ddl off
dqs_dml off
enable_fkey off
enable_qpsg off
enable_trigger on
enable_view on
fts3_tokenizer off
legacy_alter_table off
legacy_file_format off
load_extension on
no_ckpt_on_close off
reset_database off
reverse_scanorder off
stmt_scanstatus off
trigger_eqp off
trusted_schema off
writable_schema off
2|b|-3.5
3|c|0.0
-4713-11-25 12:00:00|a|1.25
-4713-11-25 12:00:00|a|1.25|-4713-11-25 12:00:00|a|1.25
2|b|-3.5|2|b|-3.5
3|c|0.0|3|c|0.0
p|9223372036854775807|1
q|-9223372036854775808|1
1.25
4
0.0
-4713-11-25 12:00:00|1.25
2|-3.5
3|0.0
|
3
```
## Flag
```
```
part1/results/1/bug_03e5b253-5f4e-4d0a-895c-cc4c473b2bae_logic.md
+813
View File
@@ -0,0 +1,813 @@
## 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
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15),
C BIGINT,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -9223372036854775808);
INSERT INTO T VALUES ('b', 'q', 4000);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('d', 'r', 9223372036854775807);
INSERT INTO T VALUES ('e', 's', 0);
SELECT A, C FROM T WHERE C > 1200 AND C < 9999999999 ORDER BY C;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (likelihood(1, 0.0625), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
SAVEPOINT sp2410;
-- replace({v}, '', 'x')
.log ON
ATTACH DATABASE ':memory:' AS aux57;
ATTACH DATABASE '' || (':memory:') AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = '{';
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a MEDIUMINT PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat((1 * 1), 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT NOT (NOT NOT (ABS(c) > 5 OR ABS(d) > 5)) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper; /**/ SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.B = sub.B;
SELECT COUNT(*) FROM T;
PRAGMA vdbe_trace = OFF;
DETACH DATABASE aux57;
ALTER TABLE T RENAME COLUMN B TO B_r974;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.A = sub.A;
SELECT c, (SELECT c FROM abc LIMIT 1) AS first_val FROM abc;
INSERT INTO t1 VALUES (1, 1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
WITH cte AS (SELECT c, COUNT(*) AS cnt FROM t1 GROUP BY c) SELECT * FROM cte;
UPDATE T SET C = NULL RETURNING *;
SELECT RANK() OVER (ORDER BY a RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t1;
VACUUM;
WITH cte AS (SELECT * FROM abc), cte2 AS (SELECT * FROM cte) SELECT * FROM cte2;
SELECT * FROM t1 AS a LEFT OUTER JOIN abc AS b ON a.rowid = b.rowid;
SELECT MIN(C) FROM T;
INSERT INTO T VALUES ('x', 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
INSERT INTO t1 VALUES ('x', 'x', NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
VACUUM;
SELECT * FROM abc WHERE b < ANY (SELECT b FROM abc);
ROLLBACK TRANSACTION TO SAVEPOINT sp2410;
RELEASE SAVEPOINT sp2410;
CREATE VIEW IF NOT EXISTS v_abc_7604 AS SELECT b FROM abc;
PRAGMA vdbe_trace = ON;
CREATE TRIGGER IF NOT EXISTS trg_t1_913 BEFORE UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ALTER TABLE abc RENAME COLUMN a TO a_r6922;
DELETE FROM t1 WHERE 1;
DELETE FROM abc WHERE c IS NULL RETURNING *;
ALTER TABLE t1 DROP COLUMN c;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
UPDATE abc SET c = NULL WHERE 1 RETURNING *;
REINDEX T;
DROP TRIGGER IF EXISTS T;
ALTER TABLE T ADD COLUMN extra_2614 MEDIUMINT COLLATE NOCASE;
REINDEX T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_2917 ON t1(lower(d)) WHERE d IS NOT NULL;
```
## Actual output
```sql
c|1700
b|4000
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
Wernher|10|1
von|20|2
Braun|30
Wernher|10
von|20
```
## Expectation
```sql
c|1700
b|4000
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
Braun|30|3
Wernher|10|1
von|20|2
Braun|30
Wernher|10
von|20
```
## Flag
```
```
part1/results/1/bug_0412bdd4-b725-43f8-9be7-e0cabe0cab75_unexpected_error.md
+83
View File
@@ -0,0 +1,83 @@
## 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
CREATE TABLE T (
a REAL,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',jsonb_patch(sqrt(1.0), 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;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux7;
PRAGMA schema_version;
.progress NULL
.timer format('%s')
PRAGMA /* NTH_VALUE({c}, 1) */ automatic_index = FALSE;
SAVEPOINT sp9691;
PRAGMA cell_size_check = YES;
SELECT json_pretty(atan2((ln(json_remove(0)) * 1), 0), '' || (' '))x0ACB29BM205381;
-- PRAGMA analysis_limit = 50;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT
1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
ROLLBACK TRANSACTION TO SAVEPOINT sp9691;
RELEASE SAVEPOINT sp9691;
VACUUM;
DETACH DATABASE aux7;
DELETE FROM T WHERE 0 RETURNING *;
CREATE TRIGGER IF NOT EXISTS trg_T_2467 AFTER UPDATE ON T FOR EACH ROW BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ALTER TABLE t1 RENAME TO t1_r5091;
DROP TRIGGER IF EXISTS T;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
Wernher|10|1
von|20|2
Braun|30
Wernher|10
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_041b6fa0-843c-489a-87ed-613028d0905a_logic.md
+142
View File
@@ -0,0 +1,142 @@
## 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 aux1;
SAVEPOINT sp9324;
.timer on
PRAGMA parser_trace = FALSE;
ATTACH DATABASE '' || (':memory:') AS aux81;
PRAGMA reverse_unordered_selects = ON;
PRAGMA max_page_count;
PRAGMA case_sensitive_like = OFF;
PRAGMA writable_schema = NO;
.quit
DROP TABLE IF EXISTS t1;
CREATE TABLE t1(a int, b int);
INSERT INTO t1 VALUES(glob(NULL, NULL),NULL),(CAST(CAST(CAST(log10(if('"', cosh((0 + 5035996954804773676)), 1, 5035996954804773676, 5035996954804773676)) AS CLOB) AS UNSIGNED BIG INT) AS SMALLINT),18),(2,19);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT x, y FROM (SELECT 98 AS x, 99 AS y UNION SELECT a AS x, sum(b) AS y FROM _m GROUP BY /* PRAGMA secure_delete = TRUE; */ a) AS w WHERE NOT y>=20 ORDER BY +x;
SELECT x, y FROM (SELECT a AS x, sum(b) AS y FROM t1 GROUP BY a UNION SELECT 98 AS x, 99 AS y) AS w WHERE y>=20 ORDER BY +x;
DROP VIEW IF EXISTS t1;
INSERT INTO t1 VALUES (NULL, NULL);
CREATE TABLE `T1` (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
CREATE TABLE "T" (
A VARCHAR(20),
B VARCHAR(30),
C VARCHAR(30),
PRIMARY KEY (A, B),
UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
INSERT INTO T2 VALUES (NULL, NULL);
ALTER TABLE T2 ADD COLUMN extra_2116 NUMERIC DEFAULT 0;
REINDEX;
UPDATE T2 SET A = 'x' WHERE A IS NOT NULL RETURNING *;
SELECT * FROM (SELECT Y, COUNT(*) FROM T2 GROUP BY Y) AS sub;
ALTER TABLE t1 DROP COLUMN b;
SELECT LAG(X, 0) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T1;
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
SELECT LEAD(X, 1, NULL) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T1;
PRAGMA vdbe_listing = YES;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T1_7197 AS SELECT A FROM T1;
ALTER TABLE T1 DROP COLUMN A;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T1_4345 ON T1((X + 1)) WHERE X IS NOT NULL;
SELECT * FROM T1;
DETACH DATABASE aux81;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE b > 0);
VACUUM main;
SELECT * FROM T2 WHERE A IN (SELECT A FROM T2 WHERE A IS NOT NULL);
ALTER TABLE t1 RENAME TO t1_r6007;
ALTER TABLE T1 RENAME TO T1_r5111;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE a = NULL);
SELECT COUNT(X) OVER (ORDER BY X RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T1;
SELECT NTH_VALUE(b, -1) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t1;
ALTER TABLE t1 DROP COLUMN b;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
SELECT * FROM t1 WHERE b IN (SELECT b FROM t1 WHERE b GLOB "*");
INSERT OR FAIL INTO t1 VALUES (0, 0);
REINDEX;
INSERT INTO T1 VALUES ('x', NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
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;
ANALYZE T2;
WITH m AS MATERIALIZED (SELECT * FROM T2) SELECT m.A FROM m JOIN m AS m2 ON m.A = m2.A;
ALTER TABLE t1 RENAME TO t1_r3665;
DELETE FROM T1 WHERE rowid = 99 RETURNING *;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-10) SELECT * FROM cnt;
INSERT INTO T1 VALUES (NULL, NULL);
REINDEX;
ALTER TABLE T2 RENAME TO T2_r3541;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<23) SELECT COUNT(*) FROM cnt;
SELECT * FROM T WHERE A NOT IN (SELECT A FROM T);
SELECT COUNT(*) FROM T1;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
INSERT INTO T SELECT * FROM T;
CREATE TEMPORARY VIEW IF NOT EXISTS v_t1_2111 AS SELECT a FROM t1;
INSERT INTO T1 SELECT * FROM T1;
SELECT NTH_VALUE(a, 2) OVER (ORDER BY a) FROM t1;
ALTER TABLE t1 RENAME TO t1_r4405;
ROLLBACK TRANSACTION TO SAVEPOINT sp9324;
RELEASE SAVEPOINT sp9324;
INSERT INTO T2 DEFAULT VALUES;
DETACH DATABASE aux1;
SELECT COUNT(*) FROM T;
REINDEX t1;
```
## Actual output
```sql
Run Time: real 0.000 user 0.000000 sys 0.000024
Run Time: real 0.000 user 0.000000 sys 0.000032
Run Time: real 0.000 user 0.000000 sys 0.000004
1073741823
Run Time: real 0.000 user 0.000000 sys 0.000008
Run Time: real 0.000 user 0.000000 sys 0.000005
Run Time: real 0.000 user 0.000000 sys 0.000004
```
## Expectation
```sql
Run Time: real 0.000003 user 0.000011 sys 0.000000
Run Time: real 0.000013 user 0.000013 sys 0.000000
Run Time: real 0.000002 user 0.000002 sys 0.000000
4294967294
Run Time: real 0.000004 user 0.000004 sys 0.000000
Run Time: real 0.000003 user 0.000003 sys 0.000000
Run Time: real 0.000001 user 0.000001 sys 0.000000
```
## Flag
```
```
part1/results/1/bug_041e3cab-94ac-48a0-ace9-5daef8ae4834_unexpected_error.md
+484
View File
@@ -0,0 +1,484 @@
## 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 aux98;
PRAGMA writable_schema = YES;
PRAGMA short_column_names = OFF;
PRAGMA vdbe_trace = YES;
ATTACH DATABASE '' || (':memory:') AS aux22;
BEGIN DEFERRED;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
InsErt INTO t1 VALUES (json_valid(ln(-json_set(sinh(x'01'), '$.key', (log(-(-(9223372036854775809))) * 1))), 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
DROP TABLE IF EXISTS t1;
DROP TABLE IF EXISTS t2;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(-2147483649);
CREATE TABLE t2(y,z);
INSERT INTO t2 VALUES(2,3);
CREATE INDEX t2y ON t2(y);
SELECT * FROM t1,(SELECT * FROM t2 WHERE NOT NOT (NOT NOT (y=2)) ORDER BY y,z);
SELECT GROUP_CONCAT(x, '.') OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
INSERT OR ABORT INTO t2 VALUES (0, 'x');
END;
ANALYZE;
REINDEX;
SELECT * FROM t2;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t2_6543 ON t2(y COLLATE NOCASE) WHERE y > 0;
SELECT * FROM t2 AS a INNER JOIN t1 AS b ON a.rowid = b.rowid;
DROP INDEX IF EXISTS t2;
DETACH DATABASE aux22;
INSERT INTO t2 VALUES (NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t1_9456 AFTER UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS t2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
SELECT COUNT(*) FROM T2;
ALTER TABLE t1 ADD COLUMN extra_7517 FLOA DEFAULT (abs(random()) % 1000);
DROP TABLE IF EXISTS T1;
SELECT COUNT(*) FROM T1;
VACUUM;
ALTER TABLE T1 RENAME TO T1_r4172;
INSERT INTO T1 VALUES (NULL, NULL, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
SELECT GROUP_CONCAT(y, '|') FROM t2;
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;
ALTER TABLE T1 ADD COLUMN extra_7361 BOOLEAN DEFAULT (random());
ALTER TABLE t1 RENAME TO t1_r8174;
DROP TABLE IF EXISTS T2;
PRAGMA reverse_unordered_selects;
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 t1;
SELECT LAG(A, 1, NULL) OVER (PARTITION BY A ORDER BY A) FROM T2;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TRIGGER IF NOT EXISTS trg_T2_9819 AFTER DELETE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT * FROM T1 AS a LEFT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
DELETE FROM t1 WHERE x > (SELECT AVG(x) FROM t1);
INSERT INTO T2 VALUES (NULL, 'x') ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
PRAGMA checkpoint_fullsync = NO;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DETACH DATABASE aux98;
ATTACH DATABASE ':memory:' AS aux98;
PRAGMA writable_schema = YES;
PRAGMA short_column_names = OFF;
PRAGMA vdbe_trace = YES;
ATTACH DATABASE '' || (':memory:') AS aux22;
BEGIN DEFERRED;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
InsErt INTO t1 VALUES (json_valid(ln(-json_set(sinh(x'01'), '$.key', (log(-(-(9223372036854775809))) * 1))), 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
DROP TABLE IF EXISTS t1;
DROP TABLE IF EXISTS t2;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(-2147483649);
CREATE TABLE t2(y,z);
INSERT INTO t2 VALUES(2,3);
CREATE INDEX t2y ON t2(y);
SELECT * FROM t1,(SELECT * FROM t2 WHERE NOT NOT (NOT NOT (y=2)) ORDER BY y,z);
SELECT GROUP_CONCAT(x, '.') OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
INSERT OR ABORT INTO t2 VALUES (0, 'x');
END;
ANALYZE;
REINDEX;
SELECT * FROM t2;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t2_6543 ON t2(y COLLATE NOCASE) WHERE y > 0;
SELECT * FROM t2 AS a INNER JOIN t1 AS b ON a.rowid = b.rowid;
DROP INDEX IF EXISTS t2;
DETACH DATABASE aux22;
INSERT INTO t2 VALUES (NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t1_9456 AFTER UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS t2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
SELECT COUNT(*) FROM T2;
ALTER TABLE t1 ADD COLUMN extra_7517 FLOA DEFAULT (abs(random()) % 1000);
DROP TABLE IF EXISTS T1;
SELECT COUNT(*) FROM T1;
VACUUM;
ALTER TABLE T1 RENAME TO T1_r4172;
INSERT INTO T1 VALUES (NULL, NULL, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
SELECT GROUP_CONCAT(y, '|') FROM t2;
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;
ALTER TABLE T1 ADD COLUMN extra_7361 BOOLEAN DEFAULT (random());
ALTER TABLE t1 RENAME TO t1_r8174;
DROP TABLE IF EXISTS T2;
PRAGMA reverse_unordered_selects;
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 t1;
SELECT LAG(A, 1, NULL) OVER (PARTITION BY A ORDER BY A) FROM T2;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TRIGGER IF NOT EXISTS trg_T2_9819 AFTER DELETE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT * FROM T1 AS a LEFT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
DELETE FROM t1 WHERE x > (SELECT AVG(x) FROM t1);
INSERT INTO T2 VALUES (NULL, 'x') ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
PRAGMA checkpoint_fullsync = NO;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DETACH DATABASE aux98;
ATTACH DATABASE ':memory:' AS aux98;
PRAGMA writable_schema = YES;
PRAGMA short_column_names = OFF;
PRAGMA vdbe_trace = YES;
ATTACH DATABASE '' || (':memory:') AS aux22;
BEGIN DEFERRED;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
InsErt INTO t1 VALUES (json_valid(ln(-json_set(sinh(x'01'), '$.key', (log(-(-(9223372036854775809))) * 1))), 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
DROP TABLE IF EXISTS t1;
DROP TABLE IF EXISTS t2;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(-2147483649);
CREATE TABLE t2(y,z);
INSERT INTO t2 VALUES(2,3);
CREATE INDEX t2y ON t2(y);
SELECT * FROM t1,(SELECT * FROM t2 WHERE NOT NOT (NOT NOT (y=2)) ORDER BY y,z);
SELECT GROUP_CONCAT(x, '.') OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
INSERT OR ABORT INTO t2 VALUES (0, 'x');
END;
ANALYZE;
REINDEX;
SELECT * FROM t2;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t2_6543 ON t2(y COLLATE NOCASE) WHERE y > 0;
SELECT * FROM t2 AS a INNER JOIN t1 AS b ON a.rowid = b.rowid;
DROP INDEX IF EXISTS t2;
DETACH DATABASE aux22;
INSERT INTO t2 VALUES (NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t1_9456 AFTER UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS t2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
SELECT COUNT(*) FROM T2;
ALTER TABLE t1 ADD COLUMN extra_7517 FLOA DEFAULT (abs(random()) % 1000);
DROP TABLE IF EXISTS T1;
SELECT COUNT(*) FROM T1;
VACUUM;
ALTER TABLE T1 RENAME TO T1_r4172;
INSERT INTO T1 VALUES (NULL, NULL, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
SELECT GROUP_CONCAT(y, '|') FROM t2;
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;
ALTER TABLE T1 ADD COLUMN extra_7361 BOOLEAN DEFAULT (random());
ALTER TABLE t1 RENAME TO t1_r8174;
DROP TABLE IF EXISTS T2;
PRAGMA reverse_unordered_selects;
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 t1;
SELECT LAG(A, 1, NULL) OVER (PARTITION BY A ORDER BY A) FROM T2;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TRIGGER IF NOT EXISTS trg_T2_9819 AFTER DELETE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT * FROM T1 AS a LEFT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
DELETE FROM t1 WHERE x > (SELECT AVG(x) FROM t1);
INSERT INTO T2 VALUES (NULL, 'x') ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
PRAGMA checkpoint_fullsync = NO;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DETACH DATABASE aux98;
ATTACH DATABASE ':memory:' AS aux98;
PRAGMA writable_schema = YES;
PRAGMA short_column_names = OFF;
PRAGMA vdbe_trace = YES;
ATTACH DATABASE '' || (':memory:') AS aux22;
BEGIN DEFERRED;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
InsErt INTO t1 VALUES (json_valid(ln(-json_set(sinh(x'01'), '$.key', (log(-(-(9223372036854775809))) * 1))), 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
DROP TABLE IF EXISTS t1;
DROP TABLE IF EXISTS t2;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(-2147483649);
CREATE TABLE t2(y,z);
INSERT INTO t2 VALUES(2,3);
CREATE INDEX t2y ON t2(y);
SELECT * FROM t1,(SELECT * FROM t2 WHERE NOT NOT (NOT NOT (y=2)) ORDER BY y,z);
SELECT GROUP_CONCAT(x, '.') OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
INSERT OR ABORT INTO t2 VALUES (0, 'x');
END;
ANALYZE;
REINDEX;
SELECT * FROM t2;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t2_6543 ON t2(y COLLATE NOCASE) WHERE y > 0;
SELECT * FROM t2 AS a INNER JOIN t1 AS b ON a.rowid = b.rowid;
DROP INDEX IF EXISTS t2;
DETACH DATABASE aux22;
INSERT INTO t2 VALUES (NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t1_9456 AFTER UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS t2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
SELECT COUNT(*) FROM T2;
ALTER TABLE t1 ADD COLUMN extra_7517 FLOA DEFAULT (abs(random()) % 1000);
DROP TABLE IF EXISTS T1;
SELECT COUNT(*) FROM T1;
VACUUM;
ALTER TABLE T1 RENAME TO T1_r4172;
INSERT INTO T1 VALUES (NULL, NULL, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
SELECT GROUP_CONCAT(y, '|') FROM t2;
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;
ALTER TABLE T1 ADD COLUMN extra_7361 BOOLEAN DEFAULT (random());
ALTER TABLE t1 RENAME TO t1_r8174;
DROP TABLE IF EXISTS T2;
PRAGMA reverse_unordered_selects;
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 t1;
SELECT LAG(A, 1, NULL) OVER (PARTITION BY A ORDER BY A) FROM T2;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TRIGGER IF NOT EXISTS trg_T2_9819 AFTER DELETE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT * FROM T1 AS a LEFT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
DELETE FROM t1 WHERE x > (SELECT AVG(x) FROM t1);
INSERT INTO T2 VALUES (NULL, 'x') ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
PRAGMA checkpoint_fullsync = NO;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DETACH DATABASE aux98;
ATTACH DATABASE ':memory:' AS aux98;
PRAGMA writable_schema = YES;
PRAGMA short_column_names = OFF;
PRAGMA vdbe_trace = YES;
ATTACH DATABASE '' || (':memory:') AS aux22;
BEGIN DEFERRED;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
InsErt INTO t1 VALUES (json_valid(ln(-json_set(sinh(x'01'), '$.key', (log(-(-(9223372036854775809))) * 1))), 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
DROP TABLE IF EXISTS t1;
DROP TABLE IF EXISTS t2;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(-2147483649);
CREATE TABLE t2(y,z);
INSERT INTO t2 VALUES(2,3);
CREATE INDEX t2y ON t2(y);
SELECT * FROM t1,(SELECT * FROM t2 WHERE NOT NOT (NOT NOT (y=2)) ORDER BY y,z);
SELECT GROUP_CONCAT(x, '.') OVER (PARTITION BY x ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
INSERT OR ABORT INTO t2 VALUES (0, 'x');
END;
ANALYZE;
REINDEX;
SELECT * FROM t2;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t2_6543 ON t2(y COLLATE NOCASE) WHERE y > 0;
SELECT * FROM t2 AS a INNER JOIN t1 AS b ON a.rowid = b.rowid;
DROP INDEX IF EXISTS t2;
DETACH DATABASE aux22;
INSERT INTO t2 VALUES (NULL, NULL);
CREATE TRIGGER IF NOT EXISTS trg_t1_9456 AFTER UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
DROP TRIGGER IF EXISTS t2;
CREATE TABLE T1 (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) UNIQUE,
C BIGINT
);
CREATE TABLE T2 (
X VARCHAR(20) PRIMARY KEY,
A VARCHAR(10),
FOREIGN KEY (A) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('a', 'p', 9999999999999);
INSERT INTO T1 VALUES ('b', 'q', -9999999999999);
INSERT INTO T2 VALUES ('m', 'a');
INSERT INTO T2 VALUES ('n', 'b');
SELECT T2.X, T1.C FROM T2 INNER JOIN T1 ON T2.A = T1.A WHERE T1.C > -1000000000000;
SELECT COUNT(*) FROM T2;
ALTER TABLE t1 ADD COLUMN extra_7517 FLOA DEFAULT (abs(random()) % 1000);
DROP TABLE IF EXISTS T1;
SELECT COUNT(*) FROM T1;
VACUUM;
ALTER TABLE T1 RENAME TO T1_r4172;
INSERT INTO T1 VALUES (NULL, NULL, NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
SELECT GROUP_CONCAT(y, '|') FROM t2;
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;
ALTER TABLE T1 ADD COLUMN extra_7361 BOOLEAN DEFAULT (random());
ALTER TABLE t1 RENAME TO t1_r8174;
DROP TABLE IF EXISTS T2;
PRAGMA reverse_unordered_selects;
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 t1;
SELECT LAG(A, 1, NULL) OVER (PARTITION BY A ORDER BY A) FROM T2;
WITH RECURSIVE pair(a,b) AS (VALUES(0,1) UNION ALL SELECT b, a+b FROM pair WHERE b<100) SELECT * FROM pair;
CREATE TRIGGER IF NOT EXISTS trg_T2_9819 AFTER DELETE ON T2 BEGIN INSERT INTO T2(A) VALUES (NULL); END;
SELECT * FROM T1 AS a LEFT OUTER JOIN T1 AS b ON a.rowid = b.rowid;
DELETE FROM t1 WHERE x > (SELECT AVG(x) FROM t1);
INSERT INTO T2 VALUES (NULL, 'x') ON CONFLICT(X) DO UPDATE SET X = excluded.X, A = excluded.A;
PRAGMA checkpoint_fullsync = NO;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
DETACH DATABASE aux98;
UPDATE t1 SET x = json_object('k', x) WHERE x BETWEEN 0 AND 100;
ALTER TABLE t1 RENAME TO t1_r3577;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
von|20|2
Braun|30
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_04282da2-20ca-46e3-a553-2c5d80d473c2_unexpected_error.md
+53
View File
@@ -0,0 +1,53 @@
## 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 aux28;
CREATE TABLE main.t1(a ANY, b INT);
INSERT INTO t1(a,b) VALUES('%',null),(null,null),((acos(char(-(-(sinh(jsonb_remove(1, '$.key')))), 2, 3, 4, 5)) + 0) -> 'key',null); /* PRAGMA read_uncommitted = TRUE; */ CREATE UNIQUE INDEX t1b ON t1(abs(b));
SELECT quote(a), /**/ quote(b), '|' FROM t1 GROUP BY a, abs(b);
REINDEX;
UPDATE t1 SET b = json_object('k', b) WHERE b IS NOT NULL RETURNING *;
SELECT STRING_AGG(b, '|') FROM t1;
DETACH DATABASE aux28;
VACUUM main;
CREATE TEMPORARY VIEW IF NOT EXISTS v_t1_9088 AS SELECT b FROM t1;
PRAGMA parser_trace = OFF;
SELECT GROUP_CONCAT(a, a) OVER (PARTITION BY a ORDER BY a ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM t1;
INSERT INTO t1 DEFAULT VALUES;
CREATE TEMP VIEW IF NOT EXISTS v_t1_9991 AS SELECT a FROM t1;
ALTER TABLE t1 RENAME COLUMN a TO a_r7522;
ALTER TABLE t1 ADD COLUMN extra_6255 DECIMAL(10,5) COLLATE NOCASE;
CREATE TABLE T (
a TEXT,
b TEXT,
c REAL
);
INSERT INTO T VALUES ('a','b',5.0), ('a','c',5.0), ('b','d',-8.25);
SELECT a,b,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
```
## Actual output
```sql
a|b|5.0|1
a|c|5.0|1
b|d|-8.25|1
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_04644251-02fc-4d3f-be1d-6cadd01ac691_logic.md
+95
View File
@@ -0,0 +1,95 @@
## 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
.limit
CREATE TABLE T (
A VARCHAR(-6374042461028137888) PRIMARY KEY,
B VARCHAR(30) NOT NULL,
C BIGINT UNIQUE
);
INSERT INTO T VALUES ('a', 'x', -9223372036854775808);
INSERT INTO T VALUES ('b', 'y', -1000000);
INSERT INTO T VALUES ('c', 'y', 0);
INSERT INTO T VALUES ('d', 'y', 42);
INSERT INTO T VALUES ('e', 'x', 9223372036854775807);
INSERT INTO T VALUES ('f', 'z', 2147483648);
SELECT * FROM T WHERE C > 0 ORDER BY C DESC;
SELECT * FROM T;
UPDATE T SET A = NULL WHERE 1 RETURNING *;
DELETE FROM T WHERE B IS NULL;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_5040 AS SELECT A FROM T;
```
## Actual output
```sql
length 1000000000
sql_length 1000000000
column 2000
expr_depth 1000
compound_select 500
vdbe_op 250000000
function_arg 127
attached 10
like_pattern_length 50000
variable_number 32766
trigger_depth 1000
worker_threads 0
e|x|9223372036854775807
f|z|2147483648
d|y|42
a|x|-9223372036854775808
b|y|-1000000
c|y|0
d|y|42
e|x|9223372036854775807
f|z|2147483648
|x|-9223372036854775808
|y|-1000000
|y|0
|y|42
|x|9223372036854775807
|z|2147483648
```
## Expectation
```sql
length 1000000000
sql_length 1000000000
column 2000
expr_depth 1000
compound_select 500
vdbe_op 250000000
function_arg 1000
attached 10
like_pattern_length 50000
variable_number 32766
trigger_depth 1000
worker_threads 0
e|x|9223372036854775807
f|z|2147483648
d|y|42
a|x|-9223372036854775808
b|y|-1000000
c|y|0
d|y|42
e|x|9223372036854775807
f|z|2147483648
|x|-9223372036854775808
|y|-1000000
|y|0
|y|42
|x|9223372036854775807
|z|2147483648
```
## Flag
```
-nonce "n0Nc3"
```
part1/results/1/bug_0498bb16-9527-4016-9de4-f6ae361604dc_logic.md
+295
View File
@@ -0,0 +1,295 @@
## 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
PRAGMA ignore_check_constraints = 1;
SAVEPOINT sp4325;
SAVEPOINT sp5433;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (like('', 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA /**/ writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
ATTACH DATABASE ':memory:' AS aux43;
CREATE TABLE t41(a INTEGER PRIMARY KEY, b INTEGER);
CREATE TABLE t42(d INTEGER PRIMARY KEY, e INTEGER);
CREATE TABLE t43(f INTEGER PRIMARY KEY, g INTEGER);
SELECT * FROM t41 LEFT JOIN (SELECT count(*) AS cnt, x1.d FROM (t42 INNER JOIN t43 ON d=g) AS x1 WHERE x1.d>json_extract(5, '$') GROUP BY x1.d) AS x2 ON t41.b=x2.d;
DETACH DATABASE aux43;
SELECT * FROM (SELECT g FROM t43 WHERE g IS NOT NULL) AS sub;
REINDEX t42;
SELECT COUNT(*) FROM t43;
ALTER TABLE t42 ADD COLUMN extra_4589 TEXT UNIQUE;
SELECT STRING_AGG(g, '|') FROM t43;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FROM t42;
PRAGMA legacy_alter_table = FALSE;
RELEASE sp5433;
SELECT g FROM t43 WHERE +g = (SELECT MAX(g) FROM t43);
RELEASE sp4325;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
Wernher|10|0
von|20|2
Braun|30
Wernher|10
von|20
```
## Expectation
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
Braun|30|3
Wernher|10|0
von|20|2
Braun|30
Wernher|10
von|20
```
## Flag
```
```
part1/results/1/bug_04b369da-dccb-478f-b78b-13735d239d3f_logic.md
+1123
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_06094d85-4cee-49bd-b623-8a4be607dbfe_logic.md
+1423
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_06c630bf-6880-427c-b619-f95968675704_logic.md
+70
View File
@@ -0,0 +1,70 @@
## 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
.recover
PRAGMA checkpoint_fullsync = OFF;
CREATE TABLE T (
a TEXT,
b INTEGER,
c REAL
);
INSERT INTO T VALUES ('a',1,2.0), ('a',2,-3.0), ('b',1,4.5);
SELECT a,b,c,
SUM(c) OVER (
PARTITION BY a
ORDER BY b
) AS d
FROM T;
VACUUM main;
VACUUM;
CREATE INDEX IF NOT EXISTS idx_T_4915 ON T(lower(b)) WHERE b > 0;
ALTER TABLE T RENAME COLUMN c TO c_r7795;
ALTER TABLE T RENAME COLUMN b TO b_r3208;
INSERT OR REPLACE INTO T VALUES ('', NULL, 0);
SELECT GROUP_CONCAT(a, '|') FROM T;
DELETE FROM T WHERE 0;
```
## Actual output
```sql
PRAGMA foreign_keys=OFF;
BEGIN;
PRAGMA writable_schema = on;
PRAGMA writable_schema = off;
COMMIT;
a|1|2.0|2.0
a|2|-3.0|-1.0
b|1|4.5|4.5
a|a|b|
```
## Expectation
```sql
.dbconfig defensive off
BEGIN;
PRAGMA writable_schema = on;
PRAGMA foreign_keys = off;
PRAGMA encoding = 'UTF-8';
PRAGMA page_size = '4096';
PRAGMA auto_vacuum = '0';
PRAGMA user_version = '0';
PRAGMA application_id = '0';
PRAGMA writable_schema = off;
COMMIT;
a|1|2.0|2.0
a|2|-3.0|-1.0
b|1|4.5|4.5
a|a|b|
```
## Flag
```
```
part1/results/1/bug_0714993e-ca1a-465e-a4cc-ecfc175812ae_logic.md
+1582
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_0734b961-a800-4f7f-bec2-a59547c680ae_logic.md
+54
View File
@@ -0,0 +1,54 @@
## 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
PRAGMA trusted_schema = YES;
CREATE TABLE x(id integer primary key, a TEXT NULL);
INSERT INTO x (a) VALUES ('first');
CREATE TABLE tempx(id integer primary key, a TEXT NULL);
INSERT INTO tempx (a) VALUES ('t-first');
CREATE VIEW tv1 AS SELECT x.id, tx.id FROM x JOIN tempx tx ON tx.id=x.id;
CREATE VIEW tv1b AS SELECT x.id, tx.id FROM x JOIN tempx tx on tx.id=x.id;
CREATE VIEW tv2 AS SELECT * FROM tv1 UNION SELECT * FROM tv1b;
SELECT * FROM tv2;
SELECT * FROM tempx;
WITH cte(x) AS (VALUES(CAST(-0 AS NCHAR(55))),(2),(3)) SELECT * FROM cte WHERE x > 1;
PRAGMA automatic_index = 1;
PRAGMA page_size = 4096;
INSERT INTO x VALUES (NULL, NULL);
SELECT RANK() OVER (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM x;
CREATE INDEX IF NOT EXISTS idx_tempx_9401 ON tempx(lower(id)) WHERE id > 0;
```
## Actual output
```sql
1|1
1|t-first
2
3
1
2
```
## Expectation
```sql
1|1
1|t-first
0
2
3
1
2
```
## Flag
```
```
part1/results/1/bug_076723bc-1694-41e2-ac2e-0fe01a5d5409_unexpected_error.md
+46
View File
@@ -0,0 +1,46 @@
## 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
.dump main
PRAGMA secure_delete /**/ = YES;
CREATE TABLE T (
a INTEGER,
b TEXT,
c INTEGER
);
INSERT INTO T VALUES (octet_length(123),'a',NULL), (2,'b',1), (3,'c',2);
WITH RECURSIVE d(a,b,c,e) AS (
SELECT *,1 FROM T WHERE c IS NULL
UNION ALL
SELECT T.a,T.b,T.c,d.e+1
FROM T JOIN d ON T.c=d.a
)
SELECT * FROM d;
ALTER TABLE T ADD COLUMN extra_6942 NUMERIC DEFAULT 0;
INSERT INTO T DEFAULT VALUES;
```
## Actual output
```sql
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
COMMIT;
1
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_07ca080c-d581-45b0-86cc-966afe530c8d_logic.md
+2130
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_07d0ce60-e444-4129-8d6e-700c1229afa2_unexpected_error.md
+41
View File
@@ -0,0 +1,41 @@
## 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
CREATE TABLE one(o);
INSERT INTO one DEFAULT VALUES;
CREATE TABLE t1(x, z);
INSERT INTO t1 VALUES('aaa', unicode(NULL));
INSERT INTO t1 VALUES('aaa', unicode('A'));
CREATE VIEW vvv AS SELECT * FROM t1 UNION ALL SELECT typeof(NULL), unhex(0, ' ') WHERE 0;
SELECT /**/ ( SELECT sum(z) FROM vvv WHERE x='aaa' ) FROM one;
CREATE VIEW IF NOT EXISTS v_t1_7523 AS SELECT x FROM t1;
SELECT COUNT(*) FROM one;
CREATE TEMPORARY VIEW IF NOT EXISTS v_one_9622 AS SELECT o FROM one;
SELECT * FROM one WHERE o IN (SELECT o FROM one WHERE o IN (SELECT o FROM one));
ALTER TABLE t1 RENAME COLUMN z TO z_r2864;
ALTER TABLE one RENAME COLUMN o TO o_r5469;
```
## Actual output
```sql
1
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_08517268-7a57-4a02-bae8-202fe82a34d9_unexpected_error.md
+102
View File
@@ -0,0 +1,102 @@
## 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
PRAGMA vdbe_addoptrace = OFF;
BEGIN DEFERRED TRANSACTION;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES ((-(-(lower('你好'))) * jsonb_insert(asinh(1), '$.key', 1)), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
CREATE TABLE T1 (
A VARCHAR(20) PRIMARY KEY,
X VARCHAR(10) UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(20) PRIMARY KEY,
Y VARCHAR(10) UNIQUE
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T1 VALUES ('c', 'o');
INSERT INTO T2 VALUES ('b', 'k');
INSERT INTO T2 VALUES ('c', 'l');
SELECT A FROM T1 INTERSECT SELECT A FROM T2;
WITH cte AS (SELECT * FROM T2), cte2 AS (SELECT * FROM cte) SELECT * FROM cte2;
ALTER TABLE t1 RENAME COLUMN b TO b_r6813;
CREATE TABLE T1 (
A VARCHAR(15) PRIMARY KEY,
B VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE T2 (
A VARCHAR(10) PRIMARY KEY,
X VARCHAR(15) NOT NULL,
C BIGINT,
FOREIGN KEY (X) REFERENCES T1(A)
);
INSERT INTO T1 VALUES ('p', 'x');
INSERT INTO T1 VALUES ('q', 'y');
INSERT INTO T2 VALUES ('a', 'p', 9223372036854775807);
INSERT INTO T2 VALUES ('b', 'q', -9223372036854775808);
SELECT X, SUM(C) AS D, COUNT(*) AS E FROM T2 GROUP BY X;
SELECT * /**/ FROM T2 WHERE NOT NOT (NOT C < (SELECT MIN(C) FROM T2)) ;
ALTER TABLE T2 RENAME COLUMN X TO X_r945;
DROP TABLE IF EXISTS T1;
COMMIT TRANSACTION;
INSERT INTO t1 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN C TO C_r8599;
SELECT * FROM (SELECT * FROM t1) AS sub;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,1.5,10.0), (2,-2.5,20.0), (3,-9e999,30.0);
SELECT * FROM T WHERE b < 2.0 ORDER BY b;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FROM T1;
ANALYZE t1;
SELECT * FROM T1 AS a JOIN T1 AS b ON a.rowid = b.rowid;
DROP VIEW IF EXISTS t1;
SELECT * FROM T NATURAL JOIN T1;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
von|20|2
Braun|30
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_08955ab6-852f-4692-ba79-cc848c6d4521_logic.md
+52
View File
@@ -0,0 +1,52 @@
## 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
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (1,2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
PRAGMA trusted_schema;
PRAGMA defer_foreign_keys;
PRAGMA synchronous = 'EXTRA';
.nullvalue -(-(2))32327d3-536b-41de-a764-a6301986aeab
CREATE TABLE t0(c0);
INSERT INTO t0(c0) VALUES (NULL);
CREATE INDEX i0 ON t0(1) WHERE c0 NOT NULL;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) IS FALSE;
SELECT 1 FROM t0 WHERE (t0.c0 IS FALSE) BETWEEN FALSE AND TRUE;
```
## Actual output
```sql
1|-49.875
2|-Inf
1
0
1
```
## Expectation
```sql
1|-49.875
2|-Inf
0
0
1
1
```
## Flag
```
```
part1/results/1/bug_08dbb6ad-6951-4626-b97b-ab73cc23bae1_unexpected_error.md
+739
View File
@@ -0,0 +1,739 @@
## 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
.log ON
ATTACH DATABASE ':memory:' AS aux57;
ATTACH DATABASE '' || (':memory:') AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = '{';
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (NOT NOT (ABS(c) > 5 OR ABS(d) > 5)) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.B = sub.B;
SELECT COUNT(*) FROM T;
PRAGMA vdbe_trace = OFF;
DETACH DATABASE aux57;
ALTER TABLE T RENAME COLUMN B TO B_r974;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.A = sub.A;
SELECT c, (SELECT c FROM abc LIMIT 1) AS first_val FROM abc;
INSERT INTO t1 VALUES (1, 1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
WITH cte AS (SELECT c, COUNT(*) AS cnt FROM t1 GROUP BY c) SELECT * FROM cte;
UPDATE T SET C = NULL RETURNING *;
SELECT RANK() OVER (ORDER BY a RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t1;
VACUUM;
WITH cte AS (SELECT * FROM abc), cte2 AS (SELECT * FROM cte) SELECT * FROM cte2;
SELECT * FROM t1 AS a LEFT OUTER JOIN abc AS b ON a.rowid = b.rowid;
SELECT MIN(C) FROM T;
INSERT INTO T VALUES ('x', 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
INSERT INTO t1 VALUES ('x', 'x', NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
```
## Actual output
```sql
https://yewtu.be/watch?v=dQw4w9WgXcQ
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
von|20|2
Braun|30
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_08f5fbbc-c100-4994-87f8-a604bf643a09_unexpected_error.md
+105
View File
@@ -0,0 +1,105 @@
## 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
PRAGMA parser_trace = NO;
ATTACH DATABASE ':memory:' AS aux99;
.print
BEGIN DEFERRED;
CREATE TABLE T (
a INTEGER,
b REAL,
c REAL
);
INSERT INTO T VALUES (jsonb_array(ifnull(sign(0), 1)),2.0,10.5), (1,-3.5,20.25), (2,9e999,-1.0);
WITH d AS (SELECT a,SUM(b*c) AS e FROM T GROUP BY a) SELECT * FROM d;
SAVEPOINT sp9028;
.width
ATTACH DATABASE '' || (':memory:') AS aux68;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d
INT);
INSERT INTO t1 VALUES (NULL, 'Wernher', CAST(ltrim('xxxhelloxxx', 'x') AS TEXT), CAST(100 -> '$[0]' AS DOUB));
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
CREATE TABLE T (
a INTEGER,
b REAL
);
INSERT INTO T VALUES (1,1.5), (2,-7.25), /* PRAGMA vdbe_debug = FALSE; */ (3,0.0);
SELECT a,b FROM T WHERE NOT NOT (a >= 2) ORDER BY b;
ANALYZE 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;
DETACH DATABASE aux68;
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;
SELECT MIN(b) OVER (PARTITION BY b ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t1;
SELECT COUNT(*) FROM t1;
SELECT COUNT(*) OVER (ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE NO OTHERS) FROM t1;
UPDATE t1 SET d = '' WHERE 1;
INSERT OR ABORT INTO t1 VALUES (0, 0, NULL, 7);
ROLLBACK TRANSACTION TO SAVEPOINT sp9028;
RELEASE SAVEPOINT sp9028;
REINDEX T;
ALTER TABLE t1 DROP COLUMN b;
SELECT * FROM t1 AS a FULL JOIN T AS b ON a.rowid = b.rowid;
SELECT COUNT(*) FROM T;
SELECT SUM(b) FROM t1;
SELECT COUNT(*) FROM t1;
SELECT STRING_AGG(b) FROM T;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T_495 AS SELECT a FROM T;
END TRANSACTION;
INSERT INTO t1 SELECT * FROM t1;
DROP TABLE IF EXISTS t1;
DELETE FROM T WHERE rowid = 75 RETURNING *;
ALTER TABLE T ADD COLUMN extra_685 DECIMAL(10,5) NOT NULL DEFAULT 0;
ALTER TABLE T ADD COLUMN extra_8806 TEXT COLLATE RTRIM;
DETACH DATABASE aux99;
PRAGMA journal_size_limit;
SELECT * FROM T WHERE b = (SELECT MAX(b) FROM T WHERE b = (SELECT MAX(b) FROM T));
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_2068 ON t1(b COLLATE NOCASE) WHERE b > 0;
SELECT * FROM t1;
ALTER TABLE T ADD COLUMN extra_4370 INT2 COLLATE RTRIM;
VACUUM main;
```
## Actual output
```sql
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
Wernher|helloxxx|1
von|20|2
Braun|30
Wernher|helloxxx
von|20
```
## Expectation
```sql
```
## Flag
```
```
part1/results/1/bug_08f62622-529b-4b2d-8ddf-e9f0e13f6718_logic.md
+759
View File
@@ -0,0 +1,759 @@
## 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
SAVEPOINT sp1638;
.headers off
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15),
C BIGINT,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -9223372036854775808);
INSERT INTO T VALUES ('b', 'q', 4000);
INSERT INTO T VALUES ('c', 'r', 1700);
INSERT INTO T VALUES ('d', 'r', 9223372036854775807);
INSERT INTO T VALUES ('e', 's', 0);
SELECT A, C FROM T WHERE +C > 1200 AND C < 9999999999 ORDER BY C;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (likelihood(1, 0.0625), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
SAVEPOINT sp2410;
-- replace({v}, '', 'x')
.log ON
ATTACH DATABASE ':memory:' AS aux57;
ATTACH DATABASE '' || (':memory:') AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = '{';
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a MEDIUMINT PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat((1 * 1), 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT NOT (NOT NOT (ABS(c) > 5 OR ABS(d) > 5)) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper; /**/ SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
ATTACH DATABASE ':memory:' AS aux79;
ATTACH DATABASE ':memory:' AS aux15;
.print https://yewtu.be/watch?v=dQw4w9WgXcQ
PRAGMA vdbe_listing = 2147483648;
PRAGMA short_column_names = YES;
SAVEPOINT sp5958;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (concat(1, 1, 1), 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
BEGIN;
create TABLE main.abc(a, b, c, PRIMARY KEY(a, b));
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL,
d REAL
);
INSERT INTO T VALUES (json_valid(1, 4),'a',40.5,-70.0), (2,'b',-10.25,20.5), (3,'c',9e999,-9e999);
CREATE TABLE T (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C DOUBLE PRECISION
);
INSERT INTO T VALUES ('a', 'p', -1.7976931348623157e+308);
INSERT INTO T VALUES ('b', 'q', -0.000000001);
INSERT INTO T VALUES ('c', 'r', 0.0);
INSERT INTO T VALUES ('d', 's', 3.14159265358979);
INSERT INTO T VALUES ('e', 't', 1.7976931348623157e+308);
INSERT INTO T VALUES ('f', 't', 750.25);
SELECT B, AVG(C) AS D, MIN(C) AS E, MAX(C) AS F FROM T GROUP BY B;
SELECT b FROM T WHERE NOT NOT (ABS(c) > 5 OR ABS(d) > 5) ;
INSERT INTO abc VALUES(1, 1, 1);
INSERT INTO abc SELECT a+(select max(a) FROM abc), b+(select max(a) FROM abc), c+(select max(a) FROM abc) FROM abc;
COMMIT;
SELECT count((SELECT a FROM abc WHERE +a = NULL ANd b >= upper.c)) FROM abc AS upper;
SELECT * FROM sqlite_master WHERE rowid=10;
ALTER TABLE T RENAME TO T_r2547;
SELECT b, (SELECT AVG(b) FROM abc) AS avg_val FROM abc;
INSERT INTO T VALUES (NULL, NULL, NULL, NULL);
SELECT AVG(B) FROM T;
SELECT * FROM t1 WHERE c < ANY (SELECT c FROM t1);
SELECT COUNT(*) FROM T;
CREATE TRIGGER IF NOT EXISTS trg_t1_7090 AFTER INSERT ON t1 BEGIN SELECT RAISE(ROLLBACK, 'rb'); END;
ROLLBACK TRANSACTION TO SAVEPOINT sp5958;
RELEASE SAVEPOINT sp5958;
UPDATE abc SET a = NULL WHERE a IS NOT NULL RETURNING *;
DROP VIEW IF EXISTS abc;
DELETE FROM t1 WHERE rowid = 76;
SELECT COUNT(*) FROM t1;
UPDATE T SET A = NULL WHERE 1;
ALTER TABLE T RENAME TO T_r3110;
INSERT INTO t1 VALUES (NULL, NULL, NULL, NULL);
ALTER TABLE abc DROP COLUMN a;
CREATE TRIGGER IF NOT EXISTS trg_abc_1503 BEFORE UPDATE OF a ON abc FOR EACH ROW BEGIN SELECT RAISE(FAIL, 'no'); END;
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 t1;
CREATE UNIQUE INDEX IF NOT EXISTS idx_abc_3299 ON abc(lower(b)) WHERE b IS NOT NULL;
WITH cte AS (SELECT "123" AS x) SELECT x + 0 FROM cte;
INSERT INTO T SELECT * FROM T;
CREATE TRIGGER IF NOT EXISTS trg_abc_3167 BEFORE UPDATE OF c ON abc FOR EACH ROW BEGIN INSERT INTO abc(c) VALUES (NULL); END;
SELECT STRING_AGG(C) FROM T;
INSERT OR IGNORE INTO abc VALUES (NULL, 9, 'x');
SELECT COUNT(*) FROM t1;
SELECT * FROM t1;
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 COUNT(*) FROM t1;
INSERT OR IGNORE INTO t1 VALUES (3, '', 0, -10);
CREATE VIEW IF NOT EXISTS v_T_8516 AS SELECT C FROM T;
CREATE TEMP VIEW IF NOT EXISTS v_t1_5754 AS SELECT b FROM t1;
SELECT COUNT(*) FROM T;
DROP TRIGGER IF EXISTS t1;
SELECT * FROM t1 AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T WHERE B IN (SELECT B FROM T LIMIT 0);
DETACH DATABASE aux15;
WITH cte AS (SELECT * FROM abc LIMIT 1) DELETE FROM abc WHERE a IN (SELECT a FROM cte) AND 1=0;
WITH RECURSIVE vals(x) AS (SELECT C FROM T WHERE C IS NOT NULL UNION ALL SELECT C FROM T WHERE C IS NOT NULL LIMIT 10) SELECT * FROM vals;
ALTER TABLE t1 RENAME COLUMN c TO c_r3776;
DETACH DATABASE aux79;
SELECT * FROM T t1 RIGHT JOIN T t2 ON t1.A = (SELECT A FROM T WHERE A = t1.A);
INSERT OR ABORT INTO T VALUES ('x', 0, NULL);
SELECT GROUP_CONCAT(c, '.') OVER (PARTITION BY c ORDER BY c ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM t1;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.B = sub.B;
SELECT COUNT(*) FROM T;
PRAGMA vdbe_trace = OFF;
DETACH DATABASE aux57;
ALTER TABLE T RENAME COLUMN B TO B_r974;
SELECT * FROM T t1 JOIN (SELECT * FROM T) AS sub ON t1.A = sub.A;
SELECT c, (SELECT c FROM abc LIMIT 1) AS first_val FROM abc;
INSERT INTO t1 VALUES (1, 1, 'x', 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
WITH cte AS (SELECT c, COUNT(*) AS cnt FROM t1 GROUP BY c) SELECT * FROM cte;
UPDATE T SET C = NULL RETURNING *;
SELECT RANK() OVER (ORDER BY a RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t1;
VACUUM;
WITH cte AS (SELECT * FROM abc), cte2 AS (SELECT * FROM cte) SELECT * FROM cte2;
SELECT * FROM t1 AS a LEFT OUTER JOIN abc AS b ON a.rowid = b.rowid;
SELECT MIN(C) FROM T;
INSERT INTO T VALUES ('x', 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
INSERT INTO t1 VALUES ('x', 'x', NULL, 'x') ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
VACUUM;
SELECT * FROM abc WHERE b < ANY (SELECT b FROM abc);
ROLLBACK TRANSACTION TO SAVEPOINT sp2410;
RELEASE SAVEPOINT sp2410;
CREATE VIEW IF NOT EXISTS v_abc_7604 AS SELECT b FROM abc;
PRAGMA vdbe_trace = ON;
CREATE TRIGGER IF NOT EXISTS trg_t1_913 BEFORE UPDATE ON t1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ALTER TABLE abc RENAME COLUMN a TO a_r6922;
DELETE FROM t1 WHERE 1;
DELETE FROM abc WHERE c IS NULL RETURNING *;
ALTER TABLE t1 DROP COLUMN c;
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c INT, d INT);
INSERT INTO t1 VALUES (1, 'Wernher', 10, 100);
INSERT INTO t1 VALUES (2, 'von', 20, 200);
INSERT INTO t1 VALUES (3, 'Braun', 30, 300);
CREATE INDEX t1bc ON t1(b, c);
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(30),
C VARCHAR(30),
PRIMARY KEY (A, B),
UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
PRAGMA writable_schema = ON;
.imposter t1bc t2
SELECT * FROM t2;
SELECT b, c FROM t1 ORDER BY b, c;
.quit
UPDATE abc SET c = NULL WHERE 1 RETURNING *;
REINDEX T;
DROP TRIGGER IF EXISTS T;
ALTER TABLE T ADD COLUMN extra_2614 MEDIUMINT COLLATE NOCASE;
REINDEX T;
CREATE UNIQUE INDEX IF NOT EXISTS idx_t1_2917 ON t1(lower(d)) WHERE d IS NOT NULL;
SELECT LAG(d) OVER (ORDER BY d ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t1;
INSERT INTO abc DEFAULT VALUES;
WITH cte AS (SELECT 1.5 AS x) SELECT CAST(x AS TEXT) FROM cte;
VACUUM;
REINDEX T;
SELECT COUNT(*) FILTER (WHERE C IS NOT NULL), SUM(rowid) FILTER (WHERE C > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(C) FILTER (WHERE C > 0 AND C < 100), COUNT(*) FILTER (WHERE typeof(C) = "text") FROM T;
ALTER TABLE t1 ADD COLUMN extra_5836 DOUBLE DEFAULT (random());
VACUUM main;
SELECT * FROM T;
ROLLBACK TRANSACTION TO SAVEPOINT sp1638;
RELEASE SAVEPOINT sp1638;
SELECT COUNT(*) FROM T;
```
## Actual output
```sql
c|1700
b|4000
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
WARNING: writing to an imposter table will corrupt the "t1bc" index!
Braun|30|3
Wernher|10|1
von|20|2
Braun|30
Wernher|10
von|20
```
## Expectation
```sql
c|1700
b|4000
CREATE TABLE "t2"("b","c","_ROWID_",PRIMARY KEY("b","c","_ROWID_"))WITHOUT ROWID;
Braun|30|3
Wernher|10|1
von|20|2
Braun|30
Wernher|10
von|20
```
## Flag
```
```
part1/results/1/bug_09139e46-c6f9-47dd-adae-83d778e5b972_logic.md
+72
View File
@@ -0,0 +1,72 @@
## 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
PRAGMA count_changes = NO;
PRAGMA trusted_schema = YES;
CREATE TABLE x(id integer primary key, a TEXT NULL);
INSERT INTO x (a) VALUES ('first');
CREATE TABLE tempx(id integer primary key, a TEXT NULL);
INSERT INTO tempx (a) VALUES ('t-first');
CREATE VIEW tv1 AS SELECT x.id, tx.id FROM x JOIN tempx tx ON tx.id=x.id;
CREATE VIEW tv1b AS SELECT x.id, tx.id FROM x JOIN tempx tx on tx.id=x.id;
CREATE VIEW tv2 AS SELECT * FROM tv1 UNION SELECT * FROM tv1b;
SELECT * FROM tv2;
SELECT * FROM tempx;
WITH cte(x) AS (VALUES(CAST(-'𝕊𝕢𝕝' AS NCHAR(9223372036854775806))),(2),(3)) SELECT * FROM cte WHERE NOT NOT (x > 1) ;
PRAGMA automatic_index = 1;
PRAGMA page_size = 4096;
INSERT INTO x VALUES (NULL, NULL);
SELECT RANK() OVER (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM x;
CREATE INDEX IF NOT EXISTS idx_tempx_9401 ON tempx(lower(id)) WHERE id > 0;
UPDATE x SET a = -32 WHERE a IS NOT NULL;
CREATE TABLE T (
a INTEGER,
b TEXT,
c REAL
);
INSERT INTO T VALUES (1,'a',3.14), (1,'b',-7.75), (2,'c',-9e999);
SELECT b,a,c,
RANK() OVER (PARTITION BY a ORDER BY c DESC) AS d FROM T;
ALTER TABLE T DROP COLUMN b;
PRAGMA cache_spill = 1;
```
## Actual output
```sql
1|1
1|t-first
2
3
1
2
a|1|3.14|1
b|1|-7.75|2
c|2|-Inf|1
```
## Expectation
```sql
1|1
1|t-first
0
2
3
1
2
a|1|3.14|1
b|1|-7.75|2
c|2|-Inf|1
```
## Flag
```
-bail
```
part1/results/1/bug_092969a2-8ea9-4eba-ba2c-7c18a19c6050_logic.md
+72
View File
@@ -0,0 +1,72 @@
## 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 aux81;
BEGIN DEFERRED;
.schema !@#$%^&*()qwertyuiop[]\{}|asdfghjkl;':"zxcvbnm,./<>?
CREATE TABLE [T] (
A VARCHAR(10) PRIMARY KEY,
B VARCHAR(15) NOT NULL,
C INTEGER,
UNIQUE (B, C)
);
INSERT INTO T VALUES ('a', 'p', -2147483648);
INSERT INTO T VALUES ('b', 'q', 700);
INSERT INTO T VALUES ('c', 'r', 0);
INSERT INTO T VALUES ('d', 's', 2147483647);
INSERT INTO T VALUES ('e', 't', -1);
INSERT INTO T VALUES ('f', 'u', 1);
SELECT * FROM T WHERE C BETWEEN -1000 AND 1000 ORDER BY C ASC;
PRAGMA trusted_schema = 1;
ATTACH DATABASE ':memory:' AS aux7;
CREATE TABLE artists (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name varchar(255));
CREATE TABLE albums ( id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name varchar(255), artist_id integer REFERENCES artists);
INSERT INTO artists (name) VALUES ('Ar');
INSERT INTO albums (name, artist_id) VALUES ('Al', 1);
SELECT artists.* FROM artists INNER JOIN artists AS b ON (b.id = artists.id) WHERE (artists.id IN ( SELECT albums.artist_id FROM albums WHERE ((name = 'Al') AND (albums.artist_id IS NOT NULL) AND (albums.id IN ( SELECT id FROM ( SELECT albums.id, row_number() OVER (PARTITION BY albums.artist_id ORDER BY name) AS x FROM albums WHERE (name = 'Al') ) AS t1 WHERE (x = 1) )) AND (albums.id IN (1, 2))) ));
DETACH DATABASE aux7;
INSERT INTO artists VALUES (NULL, 1) ON CONFLICT(id) DO UPDATE SET id = excluded.id, name = excluded.name;
CREATE TRIGGER IF NOT EXISTS trg_albums_9678 AFTER DELETE ON albums FOR EACH ROW BEGIN INSERT INTO albums(id) VALUES (NULL); END;
DROP TRIGGER IF EXISTS albums;
CREATE TRIGGER IF NOT EXISTS trg_T_2726 BEFORE INSERT ON T BEGIN SELECT RAISE(IGNORE); END;
ALTER TABLE albums RENAME COLUMN artist_id TO artist_id_r2718;
PRAGMA vdbe_trace = OFF;
SELECT * FROM artists NATURAL JOIN artists;
ANALYZE albums;
ALTER TABLE artists ADD COLUMN extra_4610 SMALLINT DEFAULT 0;
COMMIT;
DETACH DATABASE aux81;
CREATE TRIGGER IF NOT EXISTS trg_artists_5965 AFTER INSERT ON artists BEGIN SELECT RAISE(FAIL, 'no'); END;
DELETE FROM artists WHERE rowid = -CAST('[1,2,3]' AS INT8);
DROP TABLE IF EXISTS albums;
SELECT NTH_VALUE(id, '@') OVER (ORDER BY id) FROM artists;
REINDEX;
SELECT * FROM albums WHERE id > (SELECT MAX(id) FROM albums);
SELECT COUNT(*) FILTER (WHERE artist_id IS NOT NULL), SUM(rowid) FILTER (WHERE artist_id > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(artist_id) FILTER (WHERE artist_id > 0 AND artist_id < 100), COUNT(*) FILTER (WHERE typeof(artist_id) = "text") FROM albums;
REINDEX albums;
SELECT COUNT(*) FILTER (WHERE name IS NOT NULL), SUM(rowid) FILTER (WHERE name > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(name) FILTER (WHERE name > 0 AND name < 100), COUNT(*) FILTER (WHERE typeof(name) = "text") FROM artists;
SELECT COUNT(name) FROM artists;
```
## Actual output
```sql
3.39.0 2022-05-10 23:28:12 764b71267e0b31ff7eaf2a0def7526a1a02dce4d5b456dea060d97ed342ealt1
```
## Expectation
```sql
3.51.1 2025-11-28 17:28:25 281fc0e9afc38674b9b0991943b9e9d1e64c6cbdb133d35f6f5c87ff6af38a88 (64-bit)
```
## Flag
```
-version
```
part1/results/1/bug_0a9fbe75-7a49-4432-bc68-799bc5446b21_unexpected_error.md
+2157
View File
File diff suppressed because it is too large Load Diff
part1/results/1/bug_0aa4298f-40b7-490a-87d0-e34440fcfa8c_logic.md
+136
View File
@@ -0,0 +1,136 @@
## 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
SAVEPOINT sp9324;
.timer on
PRAGMA parser_trace = FALSE;
ATTACH DATABASE '' || (':memory:') AS aux81;
PRAGMA reverse_unordered_selects = ON;
PRAGMA max_page_count;
PRAGMA case_sensitive_like = OFF;
PRAGMA writable_schema = NO;
.quit
DROP TABLE IF EXISTS t1;
CREATE TABLE t1(a int, b int);
INSERT INTO t1 VALUES(glob(NULL, NULL),NULL),(CAST(CAST(CAST(log10(if('"', cosh(5035996954804773676), 1, 5035996954804773676, 5035996954804773676)) AS CLOB) AS UNSIGNED BIG INT) AS SMALLINT),18),(2,19);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT x, y FROM (SELECT 98 AS x, 99 AS y UNION SELECT a AS x, sum(b) AS y FROM _m GROUP BY /* PRAGMA secure_delete = TRUE; */ a) AS w WHERE NOT y>=20 ORDER BY +x;
SELECT x, y FROM (SELECT a AS x, sum(b) AS y FROM t1 GROUP BY a UNION SELECT 98 AS x, 99 AS y) AS w WHERE y>=20 ORDER BY +x;
DROP VIEW IF EXISTS t1;
INSERT INTO t1 VALUES (NULL, NULL);
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
CREATE TABLE "T" (
A VARCHAR(20),
B VARCHAR(30),
C VARCHAR(30),
PRIMARY KEY (A, B),
UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
INSERT INTO T2 VALUES (NULL, NULL);
ALTER TABLE T2 ADD COLUMN extra_2116 NUMERIC DEFAULT 0;
REINDEX;
UPDATE T2 SET A = 'x' WHERE A IS NOT NULL RETURNING *;
SELECT * FROM (SELECT Y, COUNT(*) FROM T2 GROUP BY Y) AS sub;
ALTER TABLE t1 DROP COLUMN b;
SELECT LAG(X, 0) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T1;
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
SELECT LEAD(X, 1, NULL) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T1;
PRAGMA vdbe_listing = YES;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T1_7197 AS SELECT A FROM T1;
ALTER TABLE T1 DROP COLUMN A;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T1_4345 ON T1((X + 1)) WHERE X IS NOT NULL;
SELECT * FROM T1;
DETACH DATABASE aux81;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE b > 0);
VACUUM main;
SELECT * FROM T2 WHERE A IN (SELECT A FROM T2 WHERE A IS NOT NULL);
ALTER TABLE t1 RENAME TO t1_r6007;
ALTER TABLE T1 RENAME TO T1_r5111;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE a = NULL);
SELECT COUNT(X) OVER (ORDER BY X RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T1;
SELECT NTH_VALUE(b, -1) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t1;
ALTER TABLE t1 DROP COLUMN b;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
SELECT * FROM t1 WHERE b IN (SELECT b FROM t1 WHERE b GLOB "*");
INSERT OR FAIL INTO t1 VALUES (0, 0);
REINDEX;
INSERT INTO T1 VALUES ('x', NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
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;
ANALYZE T2;
WITH m AS MATERIALIZED (SELECT * FROM T2) SELECT m.A FROM m JOIN m AS m2 ON m.A = m2.A;
ALTER TABLE t1 RENAME TO t1_r3665;
DELETE FROM T1 WHERE rowid = 99 RETURNING *;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-10) SELECT * FROM cnt;
INSERT INTO T1 VALUES (NULL, NULL);
REINDEX;
ALTER TABLE T2 RENAME TO T2_r3541;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<23) SELECT COUNT(*) FROM cnt;
SELECT * FROM T WHERE A NOT IN (SELECT A FROM T);
SELECT COUNT(*) FROM T1;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
INSERT INTO T SELECT * FROM T;
CREATE TEMPORARY VIEW IF NOT EXISTS v_t1_2111 AS SELECT a FROM t1;
INSERT INTO T1 SELECT * FROM T1;
SELECT NTH_VALUE(a, 2) OVER (ORDER BY a) FROM t1;
ALTER TABLE t1 RENAME TO t1_r4405;
ROLLBACK TRANSACTION TO SAVEPOINT sp9324;
RELEASE SAVEPOINT sp9324;
```
## Actual output
```sql
Run Time: real 0.000 user 0.000000 sys 0.000026
Run Time: real 0.000 user 0.000000 sys 0.000161
Run Time: real 0.000 user 0.000000 sys 0.000005
1073741823
Run Time: real 0.000 user 0.000000 sys 0.000009
Run Time: real 0.000 user 0.000000 sys 0.000006
Run Time: real 0.000 user 0.000000 sys 0.000003
```
## Expectation
```sql
Run Time: real 0.000008 user 0.000021 sys 0.000000
Run Time: real 0.000651 user 0.000105 sys 0.000000
Run Time: real 0.000004 user 0.000004 sys 0.000000
4294967294
Run Time: real 0.000007 user 0.000007 sys 0.000000
Run Time: real 0.000003 user 0.000004 sys 0.000000
Run Time: real 0.000002 user 0.000002 sys 0.000000
```
## Flag
```
```
part1/results/1/bug_0ac8fbb8-e7ba-4f53-a553-750e5f0fae28_logic.md
+122
View File
@@ -0,0 +1,122 @@
## 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
.timer on
PRAGMA parser_trace = FALSE;
ATTACH DATABASE '' || (':memory:') AS aux81;
PRAGMA reverse_unordered_selects = ON;
PRAGMA max_page_count;
PRAGMA case_sensitive_like = OFF;
PRAGMA writable_schema = NO;
.quit
DROP TABLE IF EXISTS t1;
CREATE TABLE t1(a int, b int);
INSERT INTO t1 VALUES(glob(NULL, NULL),NULL),(CAST(CAST(CAST(log10(if(0, 5035996954804773676, 1, 5035996954804773676, 5035996954804773676)) AS CLOB) AS UNSIGNED BIG INT) AS SMALLINT),18),(2,19);
WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT x, y FROM (SELECT 98 AS x, 99 AS y UNION SELECT a AS x, sum(b) AS y FROM _m GROUP BY /* PRAGMA secure_delete = TRUE; */ a) AS w WHERE y>=20 ORDER BY +x;
SELECT x, y FROM (SELECT a AS x, sum(b) AS y FROM t1 GROUP BY a UNION SELECT 98 AS x, 99 AS y) AS w WHERE y>=20 ORDER BY +x;
DROP VIEW IF EXISTS t1;
INSERT INTO t1 VALUES (NULL, NULL);
CREATE TABLE T1 (
A VARCHAR(20),
X VARCHAR(10),
PRIMARY KEY (A, X),
UNIQUE (X)
);
CREATE TABLE T2 (
A VARCHAR(20),
Y VARCHAR(10) UNIQUE,
PRIMARY KEY (A, Y)
);
INSERT INTO T1 VALUES ('a', 'm');
INSERT INTO T1 VALUES ('b', 'n');
INSERT INTO T2 VALUES ('b', 'k');
SELECT A FROM T1 UNION ALL SELECT A FROM T2 ORDER BY A;
CREATE TABLE T (
A VARCHAR(20),
B VARCHAR(30),
C VARCHAR(30),
PRIMARY KEY (A, B),
UNIQUE (A, C)
);
INSERT INTO T VALUES ('a', 'p', 'x');
INSERT INTO T VALUES ('a', 'q', 'y');
INSERT INTO T VALUES ('b', 'p', 'z');
INSERT INTO T VALUES ('c', 'r', 'w');
INSERT INTO T VALUES ('d', 's', 'v');
SELECT A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
INSERT INTO T2 VALUES (NULL, NULL);
ALTER TABLE T2 ADD COLUMN extra_2116 NUMERIC DEFAULT 0;
REINDEX;
UPDATE T2 SET A = 'x' WHERE A IS NOT NULL RETURNING *;
SELECT * FROM (SELECT Y, COUNT(*) FROM T2 GROUP BY Y) AS sub;
ALTER TABLE t1 DROP COLUMN b;
SELECT LAG(X, 0) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM T1;
SELECT 0x0ACB29BM205381;
SELECT sqlite_compileoption_used('我的天你是怎么了');
SELECT 1 >> -999999999999999999999999999;
SELECT sqlite_compileoption_get($1);
SELECT sqlite_version();
SELECT LEAD(X, 1, NULL) OVER (PARTITION BY X ORDER BY X ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM T1;
PRAGMA vdbe_listing = YES;
CREATE TEMPORARY VIEW IF NOT EXISTS v_T1_7197 AS SELECT A FROM T1;
ALTER TABLE T1 DROP COLUMN A;
CREATE UNIQUE INDEX IF NOT EXISTS idx_T1_4345 ON T1((X + 1)) WHERE X IS NOT NULL;
SELECT * FROM T1;
DETACH DATABASE aux81;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE b > 0);
VACUUM main;
SELECT * FROM T2 WHERE A IN (SELECT A FROM T2 WHERE A IS NOT NULL);
ALTER TABLE t1 RENAME TO t1_r6007;
ALTER TABLE T1 RENAME TO T1_r5111;
SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t1 WHERE a = NULL);
SELECT COUNT(X) OVER (ORDER BY X RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T1;
SELECT NTH_VALUE(b, -1) OVER (ORDER BY b GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t1;
ALTER TABLE t1 DROP COLUMN b;
INSERT INTO T1 VALUES (NULL, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
SELECT * FROM t1 WHERE b IN (SELECT b FROM t1 WHERE b GLOB "*");
INSERT OR FAIL INTO t1 VALUES (0, 0);
REINDEX;
INSERT INTO T1 VALUES ('x', NULL) ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
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;
ANALYZE T2;
WITH m AS MATERIALIZED (SELECT * FROM T2) SELECT m.A FROM m JOIN m AS m2 ON m.A = m2.A;
ALTER TABLE t1 RENAME TO t1_r3665;
DELETE FROM T1 WHERE rowid = 99 RETURNING *;
WITH RECURSIVE cnt(x) AS (VALUES(0) UNION ALL SELECT x-1 FROM cnt WHERE x>-10) SELECT * FROM cnt;
INSERT INTO T1 VALUES (NULL, NULL);
REINDEX;
```
## Actual output
```sql
Run Time: real 0.000 user 0.000000 sys 0.000052
Run Time: real 0.000 user 0.000000 sys 0.000133
Run Time: real 0.000 user 0.000000 sys 0.000004
1073741823
Run Time: real 0.000 user 0.000000 sys 0.000009
Run Time: real 0.000 user 0.000000 sys 0.000006
Run Time: real 0.000 user 0.000000 sys 0.000003
```
## Expectation
```sql
Run Time: real 0.000021 user 0.000036 sys 0.000000
Run Time: real 0.000073 user 0.000073 sys 0.000000
Run Time: real 0.000002 user 0.000003 sys 0.000000
4294967294
Run Time: real 0.000006 user 0.000006 sys 0.000000
Run Time: real 0.000003 user 0.000004 sys 0.000000
Run Time: real 0.000002 user 0.000002 sys 0.000000
```
## Flag
```
```

Some files were not shown because too many files have changed in this diff Show More