ast-project/part1/results/1/bug_d6f52344-d97d-4ad5-8d3d-018f930d806e_logic.md

## Summary
<!--Explain briefly what goes wrong and explain why you believe this is a bug and not the intended behavior of SQLite (if it is not a crash).-->**No review yet**

## Minimized query

```sql
PRAGMA cell_size_check = ON;
CREATE TABLE T (
  A VARCHAR(15) PRIMARY KEY,
  B VARCHAR(30) NOT NULL,
  C CLOB 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 NOT NOT (C > 0) ORDER BY C DESC;
.output
.progress (1 * 1)
.stats
ATTACH DATABASE ':memory:' AS aux30;
PRAGMA recursive_triggers = TRUE;
ATTACH DATABASE '' || (':memory:') AS aux67;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), -(-(json_extract(format('%f', CAST(('0.0' + 0.0) AS NONE)), '$')))) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE `t1`(x AS (typeof(y)), y);
INSERT INTO t1 WITH _m AS MATERIALIZED (SELECT * FROM t1) SELECT * FROM t0;
SELECT * FROM _m;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
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 t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
.system false && echo "success" || echo "error code: $?"
BEGIN TRANSACTION;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((json_valid(exp(ltrim('hello', NULL)), 4) + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
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;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
.check
((CREATE)) TABLE t0(c0 AS(TYPEOF(c1)), c1);
INSERT INTO t0(c1) VALUES(CAST(ceiling((-(-((0 + 0))) - 0)) AS NATIVE CHARACTER(70)NVARCHAR(100)));
CREATE TABLE t1(x AS (typeof(y)), y);
INSERT INTO t1 SELECT * FROM t0;
SELECT * FROM t1;
ALTER TABLE t0 RENAME TO t0_r2972;
VACUUM main;
SELECT * FROM t0;
ALTER TABLE t1 RENAME COLUMN y TO y_r2090;
DROP TRIGGER IF EXISTS t1;
SELECT MIN(x) FROM t1;
ALTER TABLE t1 ADD COLUMN extra_9124 INT8 DEFAULT NULL;
SELECT * FROM t1 WHERE NOT NOT (x IN (SELECT x FROM t1) LIMIT 0);
SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE 1 IS 1);
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;
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;
REINDEX t1;
INSERT INTO T VALUES (NULL, NULL, NULL);
ANALYZE T;
DELETE FROM t1 WHERE rowid = 6 RETURNING *;
ALTER TABLE T ADD COLUMN extra_3709 NCHAR(55);
ALTER TABLE t1 ADD COLUMN extra_4692 MEDIUMINT DEFAULT NULL;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM 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;
COMMIT TRANSACTION;
SELECT *	FROM T NATURAL JOIN T1;
INSERT INTO t1 DEFAULT VALUES;
SELECT COUNT(*) FILTER (WHERE y IS NOT NULL), SUM(rowid) FILTER (WHERE y > 0), COUNT(*) FILTER (WHERE 1=0), COUNT(*) FILTER (WHERE 1=1), COUNT(*) FILTER (WHERE NULL), AVG(y) FILTER (WHERE y > 0 AND y < 100), COUNT(*) FILTER (WHERE typeof(y) = "text") FROM t1;
INSERT INTO T2 DEFAULT VALUES;
ALTER TABLE T2 RENAME COLUMN A TO A_r9171;
CREATE TRIGGER IF NOT EXISTS trg_T1_6448 AFTER UPDATE ON T1 FOR EACH ROW BEGIN SELECT RAISE(IGNORE); END;
ANALYZE;
SELECT COUNT(*) FROM t1;
INSERT INTO T VALUES ('x', 1, 1) ON CONFLICT(a) DO UPDATE SET a = excluded.a, b = excluded.b, c = excluded.c;
PRAGMA reverse_unordered_selects = NO;
ANALYZE;
ALTER TABLE T RENAME TO T_r8342;
DETACH DATABASE aux67;
INSERT OR IGNORE INTO T2 VALUES (5, '');
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;
SELECT NTH_VALUE(Y, -1) OVER (PARTITION BY Y ORDER BY Y RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM T2;
PRAGMA auto_vacuum = 2;
DROP TRIGGER IF EXISTS T;
SELECT * FROM t1 WHERE y IN (SELECT y FROM t1 t2 WHERE t2.y = t1.y);
INSERT INTO T1 VALUES ('x', 'x') ON CONFLICT(A) DO UPDATE SET A = excluded.A, X = excluded.X;
DROP TRIGGER IF EXISTS T1;
PRAGMA case_sensitive_like = 0;
ALTER TABLE T RENAME COLUMN b TO b_r1066;
ALTER TABLE T2 RENAME TO T2_r7322;
ANALYZE t1;
INSERT INTO t1 VALUES ('x', 'x') ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
INSERT INTO T DEFAULT VALUES;
DELETE FROM t1 WHERE 1;
DETACH DATABASE aux30;
ALTER TABLE t1 ADD COLUMN extra_5805 DECIMAL(10,5) COLLATE RTRIM;
INSERT INTO t1 VALUES ('x', NULL) ON CONFLICT(x) DO UPDATE SET x = excluded.x, y = excluded.y;
SELECT * FROM T;
ALTER TABLE t1 RENAME TO t1_r6215;
SELECT LEAD(A, 0) OVER (ORDER BY A ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM T1;
ALTER TABLE T2 ADD COLUMN extra_1812 UNSIGNED BIG INT COLLATE NOCASE;
ALTER TABLE T DROP COLUMN a;

SELECT COUNT(*) FROM T;
INSERT INTO t1 VALUES (NULL, NULL);
ANALYZE T;
SELECT TOTAL(X) FROM T1;
ALTER TABLE T2 RENAME COLUMN A TO A_r4872;
SELECT * FROM T1;
SELECT * FROM T2 AS a JOIN t1 AS b ON a.rowid = b.rowid;
CREATE  INDEX IF NOT EXISTS idx_T_4410 ON T(a) WHERE a > 0;
ALTER TABLE T RENAME TO T_r6895;
WITH a AS (SELECT b FROM T), b AS (SELECT b FROM T) SELECT * FROM a JOIN b ON a.b = b.b;
INSERT INTO T SELECT * FROM T;
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;
INSERT INTO T1 VALUES (NULL, NULL);
ALTER TABLE T1 DROP COLUMN A;
VACUUM main;
CREATE  INDEX IF NOT EXISTS idx_t1_5818 ON t1(lower(y)) WHERE y > 0;

SELECT COUNT(*) FROM T2;
```

## Actual output

```sql
'e','x','9223372036854775807'
'd','y','42'
'f','z','2147483648'
Memory Used:                         85672 (max 99584) bytes
Number of Outstanding Allocations:   159 (max 189)
Number of Pcache Overflow Bytes:     25648 (max 25648) bytes
Largest Allocation:                  48000 bytes
Largest Pcache Allocation:           4360 bytes
Lookaside Slots Used:                32 (max 92)
Successful lookaside attempts:       423
Lookaside failures due to size:      0
Lookaside failures due to OOM:       0
Pager Heap Usage:                    22280 bytes
Page cache hits:                     33
Page cache misses:                   0
Page cache writes:                   0
Page cache spills:                   0
Schema Heap Usage:                   1496 bytes
Statement Heap/Lookaside Usage:      0 bytes
Bytes received by read():            10665
Bytes sent to write():               64
Read() system calls:                 14
Write() system calls:                1
Bytes read from storage:             0
Bytes written to storage:            0
Cancelled write bytes:               0
Progress 1
Progress 2
Progress 3
Progress 4
Progress 5
Progress 6
Progress 7
Progress 8
Progress 9
Progress 10
Progress 11
Progress 12
Progress 13
Progress 14
Progress 15
Progress 16
Progress 17
Progress 18
Progress 19
Progress 20
Progress 21
Progress 22
Progress 23
Progress 24
Progress 25
Progress 26
Progress 27
Progress 28
Progress 29
Progress 30
Progress 31
Progress 32
Progress 33
Progress 34
Progress 35
error code: 1
Progress 36
Progress 37
```

## Expectation

```sql
'e','x','9223372036854775807'
'd','y','42'
'f','z','2147483648'
Memory Used:                         86312 (max 100128) bytes
Number of Outstanding Allocations:   169 (max 199)
Number of Pcache Overflow Bytes:     25672 (max 25672) bytes
Largest Allocation:                  48000 bytes
Largest Pcache Allocation:           4368 bytes
Lookaside Slots Used:                48 (max 101)
Successful lookaside attempts:       428
Lookaside failures due to size:      0
Lookaside failures due to OOM:       0
Pager Heap Usage:                    22312 bytes
Page cache hits:                     33
Page cache misses:                   0
Page cache writes:                   0
Page cache spills:                   0
Temporary data spilled to disk:      0
Schema Heap Usage:                   1328 bytes
Statement Heap/Lookaside Usage:      0 bytes
Bytes received by read():            11185
Bytes sent to write():               64
Read() system calls:                 14
Write() system calls:                1
Bytes read from storage:             0
Bytes written to storage:            0
Cancelled write bytes:               0
Progress 1
Progress 2
Progress 3
Progress 4
Progress 5
Progress 6
Progress 7
Progress 8
Progress 9
Progress 10
Progress 11
Progress 12
Progress 13
Progress 14
Progress 15
Progress 16
Progress 17
Progress 18
Progress 19
Progress 20
Progress 21
Progress 22
Progress 23
Progress 24
Progress 25
Progress 26
Progress 27
Progress 28
Progress 29
Progress 30
Progress 31
Progress 32
Progress 33
Progress 34
Progress 35
Progress 36
Progress 37
error code: 1
Progress 38
Progress 39
Progress 40
```

## Flag

```
-quote
```