## 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 aux77;
PRAGMA reverse_unordered_selects = ON;
.trace
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;
.width
creATE VIRTUAL TABLE t0 USING fts3("x", "y", "z");
DROP TABLE t0;
ATTACH DATABASE '' || (':memory:') AS aux2;
BEGIN EXCLUSIVE;
PRAGMA read_uncommitted == YES;
CREATE TABLE T (
  a TEXT,
  b INTEGER,
  c REAL
);
INSERT INTO T VALUES ('' || ('a'),min('z', 'a', 'm'),x'd54570cd40fb5c2b902b79cd'), ('a',CAST(likely(NULL) AS UNSIGNED BIG INT),-substr(('(' - NULL), -2 -> '$.a' ->> 'b')), ('b',1,4.5);
SELECT a,b,c,
SUM(c) OVER (
  PARTITION BY a
  ORDER BY b
) AS d
FROM T;
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WhERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING Or 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);

CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_3308 ON T(C COLLATE NOCASE);
INSERT INTO T SELECT * FROM T;
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;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA user_version = 999;
INSERT INTO T VALUES (NULL, NULL, NULL);
END;
SELECT TOTAL(C) OVER (PARTITION BY C ORDER BY C ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(A) FROM T;
DELETE FROM T WHERE B > (SELECT AVG(B) FROM T) RETURNING *;
BEGIN EXCLUSIVE;
PRAGMA read_uncommitted = YES;
CREATE TABLE T (
  a TEXT,
  b INTEGER,
  c REAL
);
INSERT INTO T VALUES ('' || ('a'),min('z', 'a', 'm'),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;
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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 /* soundex('') */ ('d', 's', 'v');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);

CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_3308 ON T(C COLLATE NOCASE);
INSERT INTO T SELECT * FROM T;
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;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA user_version = 999;
INSERT INTO T VALUES (NULL, NULL, NULL);
END;
SELECT TOTAL(C) OVER (PARTITION BY C ORDER BY C ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(A) FROM T;
DELETE FROM T WHERE B > (SELECT AVG(B) FROM T) RETURNING *;
BEGIN EXCLUSIVE;
PRAGMA read_uncommitted = YES;
CREATE TABLE T (
  a TEXT,
  b INTEGER,
  c REAL
);
INSERT INTO T VALUES ('' || ('a'),min('z', 'a', 'm'),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;
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);

CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_3308 ON T(C COLLATE NOCASE);
INSERT INTO T SELECT * FROM T;
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;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA user_version = 999;
INSERT INTO T VALUES (NULL, NULL, NULL);
END;
SELECT TOTAL(C) OVER (PARTITION BY C ORDER BY C ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(A) FROM T;
DELETE FROM T WHERE B > (SELECT AVG(B) FROM T) RETURNING *;
BEGIN EXCLUSIVE;
PRAGMA read_uncommitted = YES;
CREATE TABLE T (
  a TEXT,
  b INTEGER,
  c REAL
);
INSERT INTO T VALUES ('' || ('a'),min('z', 'a', 'm'),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;
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);
PRAGMA encoding = 'UTF-16le';
.prompt 'IPA eli isopropanoli on loistava puhdistusaine joka irrataa'
.exit
ATTACH DATABASE ':memory:' AS aux39;
CREATE TABLE T (
  A VARCHAR(-(-(json_group_array(-(-(iif(NULL, -9223372036854775807, 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');
WITH _m AS MATERIALIZED (SELECT * FROM T) SELEC_m A, COUNT(DISTINCT B) AS D FROM T GROUP BY A HAVING COUNT(DISTINCT B) >= 1;
CREATE VIRTUAL TABLE t0 USING fts4("x", "y", "z");
DROP TABLE t0;
DETACH DATABASE aux39;
VACUUM main;
UPDATE T SET B = json_object('k', B) RETURNING *;
WITH cte AS (SELECT C, COUNT(*) AS cnt FROM T GROUP BY C) SELECT * FROM cte;
INSERT INTO T DEFAULT VALUES;
ANALYZE T;
SELECT * FROM T;
UPDATE T SET A = json_object('k', A) WHERE A IS NOT NULL;
SELECT DENSE_RANK() OVER (PARTITION BY A ORDER BY A ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(*) FROM T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_7784 AS SELECT C FROM T;
SELECT * FROM T NATURAL JOIN T;
INSERT INTO T DEFAULT VALUES;
PRAGMA journal_mode = 'TRUNCATE';
ALTER TABLE T RENAME TO T_r54;
INSERT INTO T VALUES (NULL, NULL, NULL);
SELECT MIN(B) FROM T;
DELETE FROM T WHERE rowid = 13;
ALTER TABLE T ADD COLUMN extra_1303 REAL DEFAULT (random());
SELECT * FROM T AS a LEFT JOIN T AS b ON a.rowid = b.rowid;
ALTER TABLE T RENAME TO /* PRAGMA vdbe_addoptrace = NO; */ T_r2126;
ALTER TABLE T ADD COLUMN extra_1520 DECIMAL(10,5);

CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_3308 ON T(C COLLATE NOCASE);
INSERT INTO T SELECT * FROM T;
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;
INSERT INTO T VALUES (NULL, NULL, NULL);
PRAGMA user_version = 999;
INSERT INTO T VALUES (NULL, NULL, NULL);
END;
SELECT TOTAL(C) OVER (PARTITION BY C ORDER BY C ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING EXCLUDE CURRENT ROW) FROM T;
SELECT COUNT(A) FROM T;
DELETE FROM T WHERE B > (SELECT AVG(B) FROM T) RETURNING *;

WITH a AS (SELECT C FROM T), b AS (SELECT C FROM a), c AS (SELECT C FROM b) SELECT * FROM c;
DETACH DATABASE aux2;
CREATE TRIGGER IF NOT EXISTS trg_T_2277 BEFORE UPDATE ON T BEGIN INSERT INTO T(C) VALUES (NULL); END;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_2903 AS SELECT A FROM T;
DROP TABLE IF EXISTS T;
VACUUM main;
PRAGMA reverse_unordered_selects = FALSE;
REINDEX;
INSERT INTO T VALUES (NULL, NULL, NULL);
INSERT OR ABORT INTO T VALUES (0, 1, -1);
DROP TRIGGER IF EXISTS T;
SELECT MAX(C) FILTER (WHERE C IS NOT NULL) OVER (PARTITION BY C ORDER BY C GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) 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;
SELECT * FROM T WHERE B NOT IN (SELECT B FROM T WHERE B IS NULL);
UPDATE T SET C = CURRENT_TIMESTAMP;
PRAGMA secure_delete = 1;
DROP VIEW IF EXISTS T;
SELECT * FROM T WHERE C <> ALL (SELECT C FROM T);
ANALYZE T;
DELETE FROM T WHERE 1 RETURNING *;
SELECT * FROM T;
INSERT INTO T SELECT * FROM T;
SELECT * FROM T;
WITH cte AS (SELECT 1 AS x) INSERT INTO T(C) SELECT x FROM cte WHERE 1=0;
SELECT * FROM T;
SELECT * FROM T CROSS JOIN T;
CREATE TEMP  VIEW IF NOT EXISTS v_T_3590 AS SELECT B FROM T;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_7779 ON T(lower(C)) WHERE C > 0;
ALTER TABLE T RENAME COLUMN A TO A_r6589;
ALTER TABLE T ADD COLUMN extra_1307 ANY;
INSERT INTO T DEFAULT VALUES;
PRAGMA query_only = NO;
SELECT * FROM T AS a JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM T;
ALTER TABLE T ADD COLUMN extra_6118 DATETIME DEFAULT 0;
SELECT * FROM T AS a FULL OUTER JOIN T AS b ON a.rowid = b.rowid;
SELECT * FROM (SELECT * FROM T) AS sub;
VACUUM;
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;
INSERT OR REPLACE INTO T VALUES ('', NULL, 0);
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;
ALTER TABLE T RENAME COLUMN B TO B_r8828;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T VALUES (1, 'x', 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
CREATE UNIQUE  INDEX IF NOT EXISTS idx_T_8434 ON T((A + 1)) WHERE A IS NOT NULL;
UPDATE T SET A = A + 1 WHERE 1;
CREATE TEMPORARY  VIEW IF NOT EXISTS v_T_1339 AS SELECT C FROM T;
SELECT * FROM (SELECT * FROM T) AS sub;
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;
INSERT INTO T DEFAULT VALUES;
INSERT INTO T SELECT * FROM T;
INSERT INTO T VALUES (1, 1, 1) ON CONFLICT(A) DO UPDATE SET A = excluded.A, B = excluded.B, C = excluded.C;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION SELECT x+1 FROM cnt WHERE x<67) SELECT * FROM cnt;
PRAGMA trusted_schema = TRUE;
REINDEX;
ALTER TABLE T2 ADD COLUMN extra_1108 UNSIGNED BIG INT COLLATE NOCASE;
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 T1;
ALTER TABLE T2 ADD COLUMN extra_9886 BIGINT COLLATE NOCASE;
DROP TABLE IF EXISTS T;
WITH RECURSIVE cnt(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM cnt WHERE x<80) SELECT SUM(x) FROM cnt;
DETACH DATABASE aux77;
```

## Actual output

```sql
+---+------+
| a |  b   |
+---+------+
| 1 | -1.0 |
| 2 | Inf  |
| 1 | 1.0  |
+---+------+
+---+---+-------------+-----+
| a | b |      c      |  d  |
+---+---+-------------+-----+
| a |   |             |     |
| a | a | ÕEpÍ@û\++yÍ | 0.0 |
| b | 1 | 4.5         | 4.5 |
+---+---+-------------+-----+
```

## Expectation

```sql
+---+------+
| a |  b   |
+---+------+
| 1 | -1.0 |
| 2 | Inf  |
| 1 | 1.0  |
+---+------+
+---+---+--------------+-----+
| a | b |      c       |  d  |
+---+---+--------------+-----+
| a |   |              |     |
| a | a | ÕEpÍ@û\++yÍ | 0.0 |
| b | 1 | 4.5          | 4.5 |
+---+---+--------------+-----+
```

## Flag

```
-table
```

