Add files using upload-large-folder tool

local-test-sqlite3-delta-03/afc-sqlite3/test/alterfault.test

@@ -0,0 +1,41 @@
+# 2021 November 16
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix alterfault
+
+# If SQLITE_OMIT_ALTERTABLE is defined, omit this file.
+ifcapable !altertable {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a);                 
+}
+faultsim_save_and_close
+
+do_faultsim_test 1.1 -faults oom* -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql {
+    ALTER TABLE t1 ADD COLUMN b CHECK (a!=1)
+  }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/altertab.test

@@ -0,0 +1,1002 @@
+# 2018 August 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix altertab
+
+# If SQLITE_OMIT_ALTERTABLE is defined, omit this file.
+ifcapable !altertable {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, CHECK(t1.a != t1.b));
+
+  CREATE TABLE t2(a, b);
+  CREATE INDEX t2expr ON t2(a) WHERE t2.b>0;
+}
+
+do_execsql_test 1.1 {
+  SELECT sql FROM sqlite_master
+} {
+  {CREATE TABLE t1(a, b, CHECK(t1.a != t1.b))}
+  {CREATE TABLE t2(a, b)}
+  {CREATE INDEX t2expr ON t2(a) WHERE t2.b>0}
+}
+
+do_execsql_test 1.2 {
+  ALTER TABLE t1 RENAME TO t1new;
+}
+
+do_execsql_test 1.3 {
+  CREATE TABLE t3(c, d);
+  ALTER TABLE t3 RENAME TO t3new;
+  DROP TABLE t3new;
+}
+
+do_execsql_test 1.4 {
+  SELECT sql FROM sqlite_master
+} {
+  {CREATE TABLE "t1new"(a, b, CHECK("t1new".a != "t1new".b))}
+  {CREATE TABLE t2(a, b)}
+  {CREATE INDEX t2expr ON t2(a) WHERE t2.b>0}
+}
+
+
+do_execsql_test 1.3 {
+  ALTER TABLE t2 RENAME TO t2new;
+}
+do_execsql_test 1.4 {
+  SELECT sql FROM sqlite_master
+} {
+  {CREATE TABLE "t1new"(a, b, CHECK("t1new".a != "t1new".b))}
+  {CREATE TABLE "t2new"(a, b)}
+  {CREATE INDEX t2expr ON "t2new"(a) WHERE "t2new".b>0}
+}
+
+
+#-------------------------------------------------------------------------
+reset_db
+ifcapable vtab {
+  register_echo_module db
+
+  do_execsql_test 2.0 {
+    CREATE TABLE abc(a, b, c);
+    INSERT INTO abc VALUES(1, 2, 3);
+    CREATE VIRTUAL TABLE eee USING echo('abc');
+    SELECT * FROM eee;
+  } {1 2 3}
+
+  do_execsql_test 2.1 {
+    ALTER TABLE eee RENAME TO fff;
+    SELECT * FROM fff;
+  } {1 2 3}
+
+  db close
+  sqlite3 db test.db
+
+  do_catchsql_test 2.2 {
+    ALTER TABLE fff RENAME TO ggg;
+  } {1 {no such module: echo}}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+
+do_execsql_test 3.0 {
+  CREATE TABLE txx(a, b, c);
+  INSERT INTO txx VALUES(1, 2, 3);
+  CREATE VIEW vvv AS SELECT main.txx.a, txx.b, c FROM txx;
+  CREATE VIEW uuu AS SELECT main.one.a, one.b, c FROM txx AS one;
+  CREATE VIEW temp.ttt AS SELECT main.txx.a, txx.b, one.b, main.one.a FROM txx AS one, txx;
+}
+
+do_execsql_test 3.1.1 {
+  SELECT * FROM vvv;
+} {1 2 3}
+do_execsql_test 3.1.2 {
+  ALTER TABLE txx RENAME TO "t xx";
+  SELECT * FROM vvv;
+} {1 2 3}
+do_execsql_test 3.1.3 {
+  SELECT sql FROM sqlite_master WHERE name='vvv';
+} {{CREATE VIEW vvv AS SELECT main."t xx".a, "t xx".b, c FROM "t xx"}}
+
+
+do_execsql_test 3.2.1 {
+  SELECT * FROM uuu;
+} {1 2 3}
+do_execsql_test 3.2.2 {
+  SELECT sql FROM sqlite_master WHERE name='uuu';;
+} {{CREATE VIEW uuu AS SELECT main.one.a, one.b, c FROM "t xx" AS one}}
+
+do_execsql_test 3.3.1 {
+  SELECT * FROM ttt;
+} {1 2 2 1}
+do_execsql_test 3.3.2 {
+  SELECT sql FROM sqlite_temp_master WHERE name='ttt';
+} {{CREATE VIEW ttt AS SELECT main."t xx".a, "t xx".b, one.b, main.one.a FROM "t xx" AS one, "t xx"}}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 4.0 {
+  CREATE table t1(x, y);
+  CREATE table t2(a, b);
+
+  CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN
+    SELECT t1.x, * FROM t1, t2;
+    INSERT INTO t2 VALUES(new.x, new.y);
+  END;
+}
+
+do_execsql_test 4.1 {
+  INSERT INTO t1 VALUES(1, 1);
+  ALTER TABLE t1 RENAME TO t11;
+  INSERT INTO t11 VALUES(2, 2);
+  ALTER TABLE t2 RENAME TO t22;
+  INSERT INTO t11 VALUES(3, 3);
+}
+
+proc squish {a} {
+  string trim [regsub -all {[[:space:]][[:space:]]*} $a { }]
+}
+db func squish squish
+do_test 4.2 {
+  execsql { SELECT squish(sql) FROM sqlite_master WHERE name = 'tr1' }
+} [list [squish {
+  CREATE TRIGGER tr1 AFTER INSERT ON "t11" BEGIN
+    SELECT "t11".x, * FROM "t11", "t22";
+    INSERT INTO "t22" VALUES(new.x, new.y);
+  END
+}]]
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 5.0 {
+  CREATE TABLE t9(a, b, c);
+  CREATE TABLE t10(a, b, c);
+  CREATE TEMP TABLE t9(a, b, c);
+
+  CREATE TRIGGER temp.t9t AFTER INSERT ON temp.t9 BEGIN
+    INSERT INTO t10 VALUES(new.a, new.b, new.c);
+  END;
+
+  INSERT INTO temp.t9 VALUES(1, 2, 3);
+  SELECT * FROM t10;
+} {1 2 3}
+
+do_execsql_test 5.1 {
+  ALTER TABLE temp.t9 RENAME TO 't1234567890'
+}
+
+do_execsql_test 5.2 {
+  CREATE TABLE t1(a, b);
+  CREATE TABLE t2(a, b);
+  INSERT INTO t1 VALUES(1, 2);
+  INSERT INTO t2 VALUES(3, 4);
+  CREATE VIEW v AS SELECT one.a, one.b, t2.a, t2.b FROM t1 AS one, t2;
+  SELECT * FROM v;
+} {1 2 3 4}
+
+do_catchsql_test 5.3 {
+  ALTER TABLE t2 RENAME TO one;
+} {1 {error in view v after rename: ambiguous column name: one.a}}
+
+do_execsql_test 5.4 {
+  SELECT  *  FROM v
+} {1 2 3 4}
+
+do_execsql_test 5.5 {
+  DROP VIEW v;
+  CREATE VIEW temp.vv AS SELECT one.a, one.b, t2.a, t2.b FROM t1 AS one, t2;
+  SELECT * FROM vv;
+} {1 2 3 4}
+
+do_catchsql_test 5.6 {
+  ALTER TABLE t2 RENAME TO one;
+} {1 {error in view vv after rename: ambiguous column name: one.a}}
+
+#-------------------------------------------------------------------------
+
+ifcapable vtab {
+  register_tcl_module db
+  proc tcl_command {method args} {
+    switch -- $method {
+      xConnect {
+        return "CREATE TABLE t1(a, b, c)"
+      }
+    }
+    return {}
+  }
+  
+  do_execsql_test 6.0 {
+    CREATE VIRTUAL TABLE x1 USING tcl(tcl_command);
+  }
+  
+  do_execsql_test 6.1 {
+    ALTER TABLE x1 RENAME TO x2;
+    SELECT sql FROM sqlite_master WHERE name = 'x2'
+  } {{CREATE VIRTUAL TABLE "x2" USING tcl(tcl_command)}}
+  
+  do_execsql_test 7.1 {
+    CREATE TABLE ddd(db, sql, zOld, zNew, bTemp);
+    INSERT INTO ddd VALUES(
+        'main', 'CREATE TABLE x1(i INTEGER, t TEXT)', 'ddd', NULL, 0
+    ), (
+        'main', 'CREATE TABLE x1(i INTEGER, t TEXT)', NULL, 'eee', 0
+    ), (
+        'main', NULL, 'ddd', 'eee', 0
+    );
+  } {}
+  
+  sqlite3_test_control SQLITE_TESTCTRL_INTERNAL_FUNCTIONS db
+  do_execsql_test 7.2 {
+    SELECT 
+    sqlite_rename_table(db, 0, 0, sql, zOld, zNew, bTemp)
+    FROM ddd;
+  } {{} {} {}}
+  sqlite3_test_control SQLITE_TESTCTRL_INTERNAL_FUNCTIONS db
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+forcedelete test.db2
+do_execsql_test 8.1 {
+  ATTACH 'test.db2' AS aux;
+  PRAGMA foreign_keys = on;
+  CREATE TABLE aux.p1(a INTEGER PRIMARY KEY, b);
+  CREATE TABLE aux.c1(x INTEGER PRIMARY KEY, y REFERENCES p1(a));
+  INSERT INTO aux.p1 VALUES(1, 1);
+  INSERT INTO aux.p1 VALUES(2, 2);
+  INSERT INTO aux.c1 VALUES(NULL, 2);
+  CREATE TABLE aux.c2(x INTEGER PRIMARY KEY, y REFERENCES c1(a));
+}
+
+do_execsql_test 8.2 {
+  ALTER TABLE aux.p1 RENAME TO ppp;
+}
+
+do_execsql_test 8.2 {
+  INSERT INTO aux.c1 VALUES(NULL, 1);
+  SELECT sql FROM aux.sqlite_master WHERE name = 'c1';
+} {{CREATE TABLE c1(x INTEGER PRIMARY KEY, y REFERENCES "ppp"(a))}}
+
+reset_db
+do_execsql_test 9.0 {
+  CREATE TABLE t1(a, b, c);
+  CREATE VIEW v1 AS SELECT * FROM t2;
+}
+do_catchsql_test 9.1 {
+  ALTER TABLE t1 RENAME TO t3;
+} {1 {error in view v1: no such table: main.t2}}
+do_execsql_test 9.2 {
+  DROP VIEW v1;
+  CREATE TRIGGER tr AFTER INSERT ON t1 BEGIN
+    INSERT INTO t2 VALUES(new.a);
+  END;
+}
+do_catchsql_test 9.3 {
+  ALTER TABLE t1 RENAME TO t3;
+} {1 {error in trigger tr: no such table: main.t2}}
+
+forcedelete test.db2
+do_execsql_test 9.4 {
+  DROP TRIGGER tr;
+
+  ATTACH 'test.db2' AS aux;
+  CREATE TRIGGER tr AFTER INSERT ON t1 WHEN new.a IS NULL BEGIN SELECT 1, 2, 3; END;
+
+  CREATE TABLE aux.t1(x);
+  CREATE TEMP TRIGGER tr AFTER INSERT ON aux.t1 BEGIN SELECT 1, 2, 3; END;
+}
+do_execsql_test 9.5 {
+  ALTER TABLE main.t1 RENAME TO t3;
+}
+do_execsql_test 9.6 {
+  SELECT sql FROM sqlite_temp_master;
+  SELECT sql FROM sqlite_master WHERE type='trigger';
+} {
+  {CREATE TRIGGER tr AFTER INSERT ON aux.t1 BEGIN SELECT 1, 2, 3; END}
+  {CREATE TRIGGER tr AFTER INSERT ON "t3" WHEN new.a IS NULL BEGIN SELECT 1, 2, 3; END}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+ifcapable fts5 {
+  do_execsql_test 10.0 {
+    CREATE VIRTUAL TABLE fff USING fts5(x, y, z);
+  }
+
+  do_execsql_test 10.1 {
+    BEGIN;
+      INSERT INTO fff VALUES('a', 'b', 'c');
+      ALTER TABLE fff RENAME TO ggg;
+    COMMIT;
+  }
+
+  do_execsql_test 10.2 {
+    SELECT * FROM ggg;
+  } {a b c}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+forcedelete test.db2
+db func trigger trigger
+set ::trigger [list]
+proc trigger {args} {
+  lappend ::trigger $args
+}
+do_execsql_test 11.0 {
+  ATTACH 'test.db2' AS aux;
+  CREATE TABLE aux.t1(a, b, c);
+  CREATE TABLE main.t1(a, b, c);
+  CREATE TEMP TRIGGER tr AFTER INSERT ON aux.t1 BEGIN
+    SELECT trigger(new.a, new.b, new.c);
+  END;
+}
+
+do_execsql_test 11.1 {
+  INSERT INTO main.t1 VALUES(1, 2, 3);
+  INSERT INTO aux.t1 VALUES(4, 5, 6);
+}
+do_test 11.2 { set ::trigger } {{4 5 6}}
+
+do_execsql_test 11.3 {
+  SELECT name, tbl_name FROM sqlite_temp_master;
+} {tr t1}
+
+do_execsql_test 11.4 {
+  ALTER TABLE main.t1 RENAME TO t2;
+  SELECT name, tbl_name FROM sqlite_temp_master;
+} {tr t1}
+
+do_execsql_test 11.5 {
+  ALTER TABLE aux.t1 RENAME TO t2;
+  SELECT name, tbl_name FROM sqlite_temp_master;
+} {tr t2}
+
+do_execsql_test 11.6 {
+  INSERT INTO aux.t2 VALUES(7, 8, 9);
+}
+do_test 11.7 { set ::trigger } {{4 5 6} {7 8 9}}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 12.0 {
+  CREATE TABLE t1(a);
+  CREATE TABLE t2(w);
+  CREATE TRIGGER temp.r1 AFTER INSERT ON main.t2 BEGIN
+    INSERT INTO t1(a) VALUES(new.w);
+  END;
+  CREATE TEMP TABLE t2(x);
+}
+
+do_execsql_test 12.1 {
+  ALTER TABLE main.t2 RENAME TO t3;
+}
+
+do_execsql_test 12.2 {
+  INSERT INTO t3 VALUES('WWW');
+  SELECT * FROM t1;
+} {WWW}
+
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 13.0 {
+  CREATE TABLE t1(x, y);
+  CREATE TABLE t2(a, b);
+  CREATE TABLE log(c);
+  CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN
+    INSERT INTO log SELECT y FROM t1, t2;
+  END;
+}
+
+do_execsql_test 13.1 {
+  INSERT INTO t1 VALUES(1, 2);
+}
+
+do_catchsql_test 13.2 {
+  ALTER TABLE t2 RENAME b TO y;
+} {1 {error in trigger tr1 after rename: ambiguous column name: y}}
+
+#-------------------------------------------------------------------------
+reset_db
+
+ifcapable rtree {
+  do_execsql_test 14.0 {
+    CREATE VIRTUAL TABLE rt USING rtree(id, minx, maxx, miny, maxy);
+
+    CREATE TABLE "mytable" ( "fid" INTEGER PRIMARY KEY, "geom" BLOB);
+
+    CREATE TRIGGER tr1 AFTER UPDATE OF "geom" ON "mytable" 
+          WHEN OLD."fid" = NEW."fid" AND NEW."geom" IS NULL BEGIN 
+      DELETE FROM rt WHERE id = OLD."fid"; 
+    END;
+
+    INSERT INTO mytable VALUES(1, X'abcd');
+  }
+
+  do_execsql_test 14.1 {
+    UPDATE mytable SET geom = X'1234'
+  }
+
+  do_execsql_test 14.2 {
+    ALTER TABLE mytable RENAME TO mytable_renamed;
+  }
+
+  do_execsql_test 14.3 {
+    CREATE TRIGGER tr2 AFTER INSERT ON mytable_renamed BEGIN
+      DELETE FROM rt WHERE id=(SELECT min(id) FROM rt);
+    END;
+  }
+
+  do_execsql_test 14.4 {
+    ALTER TABLE mytable_renamed RENAME TO mytable2;
+  }
+}
+
+reset_db
+do_execsql_test 14.5 {
+  CREATE TABLE t1(a, b, c);
+  CREATE VIEW v1 AS SELECT * FROM t1;
+  CREATE TRIGGER xyz AFTER INSERT ON t1 BEGIN
+    SELECT a, b FROM v1;
+  END;
+}
+do_execsql_test 14.6 {
+  ALTER TABLE t1 RENAME TO tt1;
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 15.0 {
+  CREATE TABLE t1(a integer NOT NULL PRIMARY KEY);
+  CREATE VIEW v1 AS SELECT a FROM t1;
+  CREATE TRIGGER tr1 INSTEAD OF INSERT ON v1 BEGIN 
+    UPDATE t1 SET a = NEW.a;
+  END;
+  CREATE TRIGGER tr2 INSTEAD OF INSERT ON v1 BEGIN 
+    SELECT new.a;
+  END;
+  CREATE TABLE t2 (b);
+}
+
+do_execsql_test 15.1 {
+  INSERT INTO v1 VALUES(1);
+  ALTER TABLE t2 RENAME TO t3;
+}
+
+do_execsql_test 15.2 {
+  CREATE TABLE x(f1 integer NOT NULL);
+  CREATE VIEW y AS SELECT f1 AS f1 FROM x;
+  CREATE TRIGGER t INSTEAD OF UPDATE OF f1 ON y BEGIN 
+    UPDATE x SET f1 = NEW.f1; 
+  END;
+  CREATE TABLE z (f1 integer NOT NULL PRIMARY KEY);
+  ALTER TABLE z RENAME TO z2;
+}
+
+do_execsql_test 15.3 {
+  INSERT INTO x VALUES(1), (2), (3);
+  ALTER TABLE x RENAME f1 TO f2;
+  SELECT * FROM x;
+} {1 2 3}
+
+do_execsql_test 15.4 {
+  UPDATE y SET f1 = 'x' WHERE f1 = 1;
+  SELECT * FROM x;
+} {x x x}
+
+do_execsql_test 15.5 {
+  SELECT sql FROM sqlite_master WHERE name = 'y';
+} {{CREATE VIEW y AS SELECT f2 AS f1 FROM x}}
+
+#-------------------------------------------------------------------------
+# Test that it is not possible to rename a shadow table in DEFENSIVE mode.
+#
+ifcapable fts3 {
+  proc vtab_command {method args} {
+    switch -- $method {
+      xConnect {
+        if {[info exists ::vtab_connect_sql]} {
+          execsql $::vtab_connect_sql
+        }
+        return "CREATE TABLE t1(a, b, c)"
+      }
+
+      xBestIndex {
+        set clist [lindex $args 0]
+        if {[llength $clist]!=1} { error "unexpected constraint list" }
+        catch { array unset C }
+        array set C [lindex $clist 0]
+        if {$C(usable)} {
+          return "omit 0 cost 0 rows 1 idxnum 555 idxstr eq!"
+        } else {
+          return "cost 1000000 rows 0 idxnum 0 idxstr scan..."
+        }
+      }
+    }
+
+    return {}
+  }
+
+  register_tcl_module db
+
+  sqlite3_db_config db DEFENSIVE 1
+
+  do_execsql_test 16.0 {
+    CREATE VIRTUAL TABLE y1 USING fts3;
+    VACUUM;
+  }
+
+  do_catchsql_test 16.10 {
+    INSERT INTO y1_segments VALUES(1, X'1234567890');
+  } {1 {table y1_segments may not be modified}}
+
+  do_catchsql_test 16.20 {
+    DROP TABLE y1_segments;
+  } {1 {table y1_segments may not be dropped}}
+
+  do_catchsql_test 16.20 {
+    ALTER TABLE y1_segments RENAME TO abc;
+  } {1 {table y1_segments may not be altered}}
+  sqlite3_db_config db DEFENSIVE 0
+  do_catchsql_test 16.22 {
+    ALTER TABLE y1_segments RENAME TO abc;
+  } {0 {}}
+  sqlite3_db_config db DEFENSIVE 1
+  do_catchsql_test 16.23 {
+    CREATE TABLE y1_segments AS SELECT * FROM abc;
+  } {1 {object name reserved for internal use: y1_segments}}
+  do_catchsql_test 16.24 {
+    CREATE VIEW y1_segments AS SELECT * FROM abc;
+  } {1 {object name reserved for internal use: y1_segments}}
+  sqlite3_db_config db DEFENSIVE 0
+  do_catchsql_test 16.25 {
+    ALTER TABLE abc RENAME TO y1_segments;
+  } {0 {}}
+  sqlite3_db_config db DEFENSIVE 1
+
+  do_execsql_test 16.30 {
+    ALTER TABLE y1 RENAME TO z1;
+  }
+
+  do_execsql_test 16.40 {
+    SELECT * FROM z1_segments;
+  }
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 17.0 {
+  CREATE TABLE sqlite1234 (id integer);
+  ALTER TABLE sqlite1234 RENAME TO User;
+  SELECT name, sql FROM sqlite_master WHERE sql IS NOT NULL;
+} {
+  User {CREATE TABLE "User" (id integer)}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 18.1.0 {
+  CREATE TABLE t0 (c0 INTEGER, PRIMARY KEY(c0)) WITHOUT ROWID;
+}
+do_execsql_test 18.1.1 {
+  ALTER TABLE t0 RENAME COLUMN c0 TO c1;
+}
+do_execsql_test 18.1.2 {
+  SELECT sql FROM sqlite_master;
+} {{CREATE TABLE t0 (c1 INTEGER, PRIMARY KEY(c1)) WITHOUT ROWID}}
+
+reset_db
+do_execsql_test 18.2.0 {
+  CREATE TABLE t0 (c0 INTEGER, PRIMARY KEY(c0));
+}
+do_execsql_test 18.2.1 {
+  ALTER TABLE t0 RENAME COLUMN c0 TO c1;
+}
+do_execsql_test 18.2.2 {
+  SELECT sql FROM sqlite_master;
+} {{CREATE TABLE t0 (c1 INTEGER, PRIMARY KEY(c1))}}
+
+# 2020-02-23 ticket f50af3e8a565776b
+reset_db
+do_execsql_test 19.100 {
+  CREATE TABLE t1(x);
+  CREATE VIEW t2 AS SELECT 1 FROM t1, (t1 AS a0, t1);
+  ALTER TABLE t1 RENAME TO t3;
+  SELECT sql FROM sqlite_master;
+} {{CREATE TABLE "t3"(x)} {CREATE VIEW t2 AS SELECT 1 FROM "t3", ("t3" AS a0, "t3")}}
+do_execsql_test 19.110 {
+  INSERT INTO t3(x) VALUES(123);
+  SELECT * FROM t2;
+} {1}
+do_execsql_test 19.120 {
+  INSERT INTO t3(x) VALUES('xyz');
+  SELECT * FROM t2;
+} {1 1 1 1 1 1 1 1}
+
+# Ticket 4722bdab08cb14
+reset_db
+do_execsql_test 20.0 {
+  CREATE TABLE a(a);
+  CREATE VIEW b AS SELECT(SELECT *FROM c JOIN a USING(d, a, a, a) JOIN a) IN();
+}
+do_execsql_test 20.1 {
+  ALTER TABLE a RENAME a TO e;
+} {}
+
+reset_db
+do_execsql_test 21.0 {
+  CREATE TABLE a(b);
+  CREATE VIEW c AS 
+      SELECT NULL INTERSECT 
+      SELECT NULL ORDER BY
+      likelihood(NULL, (d, (SELECT c)));
+} {}
+do_catchsql_test 21.1 {
+  SELECT likelihood(NULL, (d, (SELECT c)));
+} {1 {second argument to likelihood() must be a constant between 0.0 and 1.0}}
+do_catchsql_test 21.2 {
+  SELECT * FROM c;
+} {1 {1st ORDER BY term does not match any column in the result set}}
+
+do_catchsql_test 21.3 {
+  ALTER TABLE a RENAME TO e;
+} {1 {error in view c: 1st ORDER BY term does not match any column in the result set}}
+
+# After forum thread https://sqlite.org/forum/forumpost/ddbe1c7efa
+# Ensure that PRAGMA schema_version=N causes a full schema reload.
+#
+reset_db
+do_execsql_test 22.0 {
+  CREATE TABLE t1(a INT, b TEXT NOT NULL);
+  INSERT INTO t1 VALUES(1,2),('a','b');
+  BEGIN;
+  PRAGMA writable_schema=ON;
+  UPDATE sqlite_schema SET sql='CREATE TABLE t1(a INT, b TEXT)' WHERE name LIKE 't1';
+  PRAGMA schema_version=1234;
+  COMMIT;
+  PRAGMA integrity_check;
+} {ok}
+do_execsql_test 22.1 {
+  ALTER TABLE t1 ADD COLUMN c INT DEFAULT 78;
+  SELECT * FROM t1;
+} {1 2 78 a b 78}
+
+#-------------------------------------------------------------------------
+reset_db
+db collate compare64 compare64
+
+do_execsql_test 23.1 {
+  CREATE TABLE gigo(a text);
+  CREATE TABLE idx(x text COLLATE compare64);
+  CREATE VIEW v1 AS SELECT * FROM idx WHERE x='abc';
+}
+db close
+sqlite3 db test.db
+
+do_execsql_test 23.2 {
+  alter table gigo rename to ggiiggoo;
+  alter table idx rename to idx2;
+}
+
+do_execsql_test 23.3 {
+  SELECT sql FROM sqlite_master;
+} {
+  {CREATE TABLE "ggiiggoo"(a text)} 
+  {CREATE TABLE "idx2"(x text COLLATE compare64)}
+  {CREATE VIEW v1 AS SELECT * FROM "idx2" WHERE x='abc'}
+}
+
+do_execsql_test 23.4 {
+  ALTER TABLE idx2 RENAME x TO y;
+  SELECT sql FROM sqlite_master;
+} {
+  {CREATE TABLE "ggiiggoo"(a text)} 
+  {CREATE TABLE "idx2"(y text COLLATE compare64)}
+  {CREATE VIEW v1 AS SELECT * FROM "idx2" WHERE y='abc'}
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 24.1.0 {
+  CREATE TABLE t1(a, b);
+  CREATE TRIGGER AFTER INSERT ON t1 BEGIN
+    INSERT INTO nosuchtable VALUES(new.a) ON CONFLICT(a) DO NOTHING;
+  END;
+}
+do_catchsql_test 24.1.1 {
+  ALTER TABLE t1 RENAME TO t2;
+} {1 {error in trigger AFTER: no such table: main.nosuchtable}}
+
+reset_db
+do_execsql_test 24.2.0 {
+  CREATE TABLE t1(a, b);
+  CREATE TRIGGER AFTER INSERT ON t1 BEGIN
+    INSERT INTO v1 VALUES(new.a) ON CONFLICT(a) DO NOTHING;
+  END;
+  CREATE VIEW v1 AS SELECT * FROM nosuchtable;
+}
+do_catchsql_test 24.2.1 {
+  ALTER TABLE t1 RENAME TO t2;
+} {1 {error in trigger AFTER: no such table: main.nosuchtable}}
+
+#--------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 25.1 {
+  CREATE TABLE xx(x);
+  CREATE VIEW v3(b) AS WITH b AS (SELECT b FROM (SELECT * FROM t2)) VALUES(1);
+}
+
+ifcapable json1&&vtab {
+  do_catchsql_test 25.2 {
+    ALTER TABLE json_each RENAME TO t4;
+  } {1 {table json_each may not be altered}}
+}
+
+# 2021-05-01 dbsqlfuzz bc17a306a09329bba0ecc61547077f6178bcf321
+# Remove a NEVER() inserted on 2019-12-09 that is reachable after all.
+#
+reset_db
+do_execsql_test 26.1 {
+  CREATE TABLE t1(k,v);
+  CREATE TABLE t2_a(k,v);
+  CREATE VIEW t2 AS SELECT * FROM t2_a;
+  CREATE TRIGGER r2 AFTER INSERT ON t1 BEGIN
+    UPDATE t1 
+       SET (k,v)=((WITH cte1(a) AS (SELECT 1 FROM t2) SELECT t2.k FROM t2, cte1),1);
+  END;
+  ALTER TABLE t1 RENAME TO t1x;
+  INSERT INTO t2_a VALUES(2,3);
+  INSERT INTO t1x VALUES(98,99);
+  SELECT * FROM t1x;
+} {2 1}
+
+#-------------------------------------------------------------------------
+reset_db
+
+do_execsql_test 27.1 {
+
+ create table t_sa (
+ c_muyat INTEGER NOT NULL,
+ c_d4u TEXT 
+ );
+
+ create table t2 ( abc );
+
+ CREATE TRIGGER trig AFTER DELETE ON t_sa
+   BEGIN
+   DELETE FROM t_sa WHERE (
+       SELECT 123 FROM t2
+       WINDOW oamat7fzf AS ( PARTITION BY t_sa.c_d4u )
+   );
+   END;
+}
+
+do_execsql_test 27.2 {
+  alter table t_sa rename column c_muyat to c_dg;
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 29.1 {
+  CREATE TABLE t1(a, b, c);
+  INSERT INTO t1 VALUES('a', 'b', 'c');
+
+  CREATE VIEW v0 AS
+    WITH p AS ( SELECT 1 FROM t1 ),
+         g AS ( SELECT 1 FROM p, t1 )
+    SELECT 1 FROM g;
+}
+
+do_execsql_test 29.2 {
+  SELECT * FROM v0
+} 1
+
+do_execsql_test 29.2 {
+  ALTER TABLE t1 RENAME TO t2
+} 
+
+do_execsql_test 29.3 {
+  SELECT sql FROM sqlite_schema WHERE name='v0'
+} {{CREATE VIEW v0 AS
+    WITH p AS ( SELECT 1 FROM "t2" ),
+         g AS ( SELECT 1 FROM p, "t2" )
+    SELECT 1 FROM g}}
+
+do_execsql_test 29.4 {
+  CREATE VIEW v2 AS
+    WITH p AS ( SELECT 1 FROM t2 ),
+         g AS ( SELECT 1 FROM (
+           WITH i AS (SELECT 1 FROM p, t2)
+           SELECT * FROM i
+         )
+    )
+    SELECT 1 FROM g;
+}
+
+do_execsql_test 29.4 {
+    SELECT * FROM v2;
+} 1
+
+do_execsql_test 29.5 {
+  ALTER TABLE t2 RENAME TO t3;
+} 
+
+do_execsql_test 29.5 {
+  SELECT sql FROM sqlite_schema WHERE name='v2'
+} {{CREATE VIEW v2 AS
+    WITH p AS ( SELECT 1 FROM "t3" ),
+         g AS ( SELECT 1 FROM (
+           WITH i AS (SELECT 1 FROM p, "t3")
+           SELECT * FROM i
+         )
+    )
+    SELECT 1 FROM g}}
+
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 28.1 {
+  CREATE TABLE t1(a);
+  CREATE TABLE t2(b,c);
+  CREATE TABLE t4(b,c);
+  INSERT INTO t2 VALUES(1,2),(1,3),(2,5);
+  INSERT INTO t4 VALUES(1,2),(1,3),(2,5);
+
+  CREATE VIEW v3 AS 
+    WITH RECURSIVE t3(x,y,z) AS (
+        SELECT b,c,NULL FROM t4
+        UNION
+        SELECT x,y,NULL FROM t3, t2
+    )
+  SELECT * FROM t3 AS xyz;
+}
+
+do_execsql_test 28.2 {
+  SELECT * FROM v3
+} {
+  1 2 {} 1 3 {} 2 5 {}
+}
+
+do_execsql_test 28.3 {
+  ALTER TABLE t1 RENAME a TO a2; -- fails in v3
+} 
+
+do_execsql_test 28.4 {
+  ALTER TABLE t2 RENAME TO t5;
+} 
+
+do_execsql_test 28.5 {
+  SELECT sql FROM sqlite_schema WHERE name='v3'
+} {{CREATE VIEW v3 AS 
+    WITH RECURSIVE t3(x,y,z) AS (
+        SELECT b,c,NULL FROM t4
+        UNION
+        SELECT x,y,NULL FROM t3, "t5"
+    )
+  SELECT * FROM t3 AS xyz}}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 30.0 {
+  CREATE TABLE t1(a,b,c,d,e,f);
+  CREATE TABLE t2(a,b,c);
+  CREATE INDEX t1abc ON t1(a,b,c+d+e);
+  CREATE VIEW v1(x,y) AS 
+    SELECT t1.b,t2.b FROM t1,t2 WHERE t1.a=t2.a 
+      GROUP BY 1 HAVING t2.c NOT NULL LIMIT 10;
+  CREATE TRIGGER r1 AFTER INSERT ON t1 WHEN 'no' NOT NULL BEGIN
+    INSERT INTO t2(a,a,b,c) VALUES(new.b,new.a,new.c-7);
+    WITH c1(x) AS (
+      VALUES(0) 
+        UNION ALL 
+      SELECT current_time+x FROM c1 WHERE x 
+        UNION ALL 
+      SELECT 1+x FROM c1 WHERE x<1
+    ), c2(x) AS (VALUES(0),(1))
+    SELECT * FROM c1 AS x1, c2 AS x2, (
+      SELECT x+1 FROM c1 WHERE x IS NOT TRUE 
+        UNION ALL 
+      SELECT 1+x FROM c1 WHERE 1<x
+    ) AS x3, c2 x5;
+  END;
+}
+
+do_execsql_test 30.1 {
+  ALTER TABLE t1 RENAME TO t1x;
+}
+
+do_execsql_test 30.2 {
+  SELECT sql FROM sqlite_schema ORDER BY rowid
+} {
+  {CREATE TABLE "t1x"(a,b,c,d,e,f)} 
+  {CREATE TABLE t2(a,b,c)}
+  {CREATE INDEX t1abc ON "t1x"(a,b,c+d+e)}
+  {CREATE VIEW v1(x,y) AS 
+    SELECT "t1x".b,t2.b FROM "t1x",t2 WHERE "t1x".a=t2.a 
+      GROUP BY 1 HAVING t2.c NOT NULL LIMIT 10}
+  {CREATE TRIGGER r1 AFTER INSERT ON "t1x" WHEN 'no' NOT NULL BEGIN
+    INSERT INTO t2(a,a,b,c) VALUES(new.b,new.a,new.c-7);
+    WITH c1(x) AS (
+      VALUES(0) 
+        UNION ALL 
+      SELECT current_time+x FROM c1 WHERE x 
+        UNION ALL 
+      SELECT 1+x FROM c1 WHERE x<1
+    ), c2(x) AS (VALUES(0),(1))
+    SELECT * FROM c1 AS x1, c2 AS x2, (
+      SELECT x+1 FROM c1 WHERE x IS NOT TRUE 
+        UNION ALL 
+      SELECT 1+x FROM c1 WHERE 1<x
+    ) AS x3, c2 x5;
+  END}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 31.0 {
+  CREATE TABLE t1(q);
+  CREATE VIEW vvv AS WITH x AS (WITH y AS (SELECT * FROM x) SELECT 1) SELECT 1;
+}
+
+do_execsql_test 31.1 {
+  SELECT * FROM vvv;
+} {1}
+
+do_execsql_test 31.2 {
+  ALTER TABLE t1 RENAME TO t1x;
+}
+
+do_execsql_test 31.3 {
+  ALTER TABLE t1x RENAME q TO x;
+}
+
+# 2021-07-02 OSSFuzz https://oss-fuzz.com/testcase-detail/5517690440646656
+# Bad assert() statement
+#
+reset_db
+do_catchsql_test 32.0 {
+  CREATE TABLE t1(x);
+  CREATE TRIGGER r1 BEFORE INSERT ON t1 BEGIN 
+    UPDATE t1 SET x=x FROM (SELECT*);
+  END;
+  ALTER TABLE t1 RENAME TO x;
+} {1 {error in trigger r1: no tables specified}}
+
+# 2023-04-13 https://sqlite.org/forum/forumpost/ff3840145a
+#
+reset_db
+do_execsql_test 33.0 {
+  CREATE TABLE t1(a TEXT);
+  INSERT INTO t1(a) VALUES('abc'),('def'),(NULL);
+  CREATE TABLE t2(b TEXT);
+  CREATE TRIGGER r3 AFTER INSERT ON t1 BEGIN
+   UPDATE t2 SET (b,a)=(SELECT 1) FROM t1 JOIN t2 ON (SELECT * FROM (SELECT a));
+  END;
+}
+do_catchsql_test 33.1 {
+  ALTER TABLE t1 RENAME COLUMN a TO b;
+} {1 {error in trigger r3 after rename: no such column: a}}
+do_execsql_test 33.2 {
+  SELECT quote(a) FROM t1 ORDER BY +a;
+} {NULL 'abc' 'def'}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/analyze.test

@@ -0,0 +1,399 @@
+# 2005 July 22
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+# This file implements tests for the ANALYZE command.
+#
+# $Id: analyze.test,v 1.9 2008/08/11 18:44:58 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# There is nothing to test if ANALYZE is disable for this build.
+#
+ifcapable {!analyze} {
+  finish_test
+  return
+}
+
+# Basic sanity checks.
+#
+do_test analyze-1.1 {
+  catchsql {
+    ANALYZE no_such_table
+  }
+} {1 {no such table: no_such_table}}
+do_test analyze-1.2 {
+  execsql {
+    SELECT count(*) FROM sqlite_master WHERE name='sqlite_stat1'
+  }
+} {0}
+do_test analyze-1.3 {
+  catchsql {
+    ANALYZE no_such_db.no_such_table
+  }
+} {1 {unknown database no_such_db}}
+do_test analyze-1.4 {
+  execsql {
+    SELECT count(*) FROM sqlite_master WHERE name='sqlite_stat1'
+  }
+} {0}
+do_test analyze-1.5.1 {
+  catchsql {
+    ANALYZE
+  }
+} {0 {}}
+do_test analyze-1.5.2 {
+  catchsql {
+    PRAGMA empty_result_callbacks=1;
+    ANALYZE
+  }
+} {0 {}}
+do_test analyze-1.6 {
+  execsql {
+    SELECT count(*) FROM sqlite_master WHERE name='sqlite_stat1'
+  }
+} {1}
+do_test analyze-1.6.2 {
+  catchsql {
+    CREATE INDEX stat1idx ON sqlite_stat1(idx);
+  }
+} {1 {table sqlite_stat1 may not be indexed}}
+do_test analyze-1.6.3 {
+  catchsql {
+    CREATE INDEX main.stat1idx ON SQLite_stat1(idx);
+  }
+} {1 {table sqlite_stat1 may not be indexed}}
+do_test analyze-1.7 {
+  execsql {
+    SELECT * FROM sqlite_stat1 WHERE idx NOT NULL
+  }
+} {}
+do_test analyze-1.8 {
+  catchsql {
+    ANALYZE main
+  }
+} {0 {}}
+do_test analyze-1.9 {
+  execsql {
+    SELECT * FROM sqlite_stat1 WHERE idx NOT NULL
+  }
+} {}
+do_test analyze-1.10 {
+  catchsql {
+    CREATE TABLE t1(a,b);
+    ANALYZE main.t1;
+  }
+} {0 {}}
+do_test analyze-1.11 {
+  execsql {
+    SELECT * FROM sqlite_stat1
+  }
+} {}
+do_test analyze-1.12 {
+  catchsql {
+    ANALYZE t1;
+  }
+} {0 {}}
+do_test analyze-1.13 {
+  execsql {
+    SELECT * FROM sqlite_stat1
+  }
+} {}
+
+# Create some indices that can be analyzed.  But do not yet add
+# data.  Without data in the tables, no analysis is done.
+#
+do_test analyze-2.1 {
+  execsql {
+    CREATE INDEX t1i1 ON t1(a);
+    ANALYZE main.t1;
+    SELECT * FROM sqlite_stat1 ORDER BY idx;
+  }
+} {}
+do_test analyze-2.2 {
+  execsql {
+    CREATE INDEX t1i2 ON t1(b);
+    ANALYZE t1;
+    SELECT * FROM sqlite_stat1 ORDER BY idx;
+  }
+} {}
+do_test analyze-2.3 {
+  execsql {
+    CREATE INDEX t1i3 ON t1(a,b);
+    ANALYZE main;
+    SELECT * FROM sqlite_stat1 ORDER BY idx;
+  }
+} {}
+
+# Start adding data to the table.  Verify that the analysis
+# is done correctly.
+#
+do_test analyze-3.1 {
+  execsql {
+    INSERT INTO t1 VALUES(1,2);
+    INSERT INTO t1 VALUES(1,3);
+    ANALYZE main.t1;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {2 2} t1i2 {2 1} t1i3 {2 2 1}}
+do_test analyze-3.2 {
+  execsql {
+    INSERT INTO t1 VALUES(1,4);
+    INSERT INTO t1 VALUES(1,5);
+    ANALYZE t1;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {4 4} t1i2 {4 1} t1i3 {4 4 1}}
+do_test analyze-3.3 {
+  execsql {
+    INSERT INTO t1 VALUES(2,5);
+    ANALYZE main;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {5 3} t1i2 {5 2} t1i3 {5 3 1}}
+do_test analyze-3.4 {
+  execsql {
+    CREATE TABLE t2 AS SELECT * FROM t1;
+    CREATE INDEX t2i1 ON t2(a);
+    CREATE INDEX t2i2 ON t2(b);
+    CREATE INDEX t2i3 ON t2(a,b);
+    ANALYZE;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {5 3} t1i2 {5 2} t1i3 {5 3 1} t2i1 {5 3} t2i2 {5 2} t2i3 {5 3 1}}
+do_test analyze-3.5 {
+  execsql {
+    DROP INDEX t2i3;
+    ANALYZE t1;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {5 3} t1i2 {5 2} t1i3 {5 3 1} t2i1 {5 3} t2i2 {5 2}}
+do_test analyze-3.6 {
+  execsql {
+    ANALYZE t2;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {5 3} t1i2 {5 2} t1i3 {5 3 1} t2i1 {5 3} t2i2 {5 2}}
+do_test analyze-3.7 {
+  execsql {
+    DROP INDEX t2i2;
+    ANALYZE t2;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t1i1 {5 3} t1i2 {5 2} t1i3 {5 3 1} t2i1 {5 3}}
+do_test analyze-3.8 {
+  execsql {
+    CREATE TABLE t3 AS SELECT a, b, rowid AS c, 'hi' AS d FROM t1;
+    CREATE INDEX t3i1 ON t3(a);
+    CREATE INDEX t3i2 ON t3(a,b,c,d);
+    CREATE INDEX t3i3 ON t3(d,b,c,a);
+    DROP TABLE t1;
+    DROP TABLE t2;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {}
+do_test analyze-3.9 {
+  execsql {
+    ANALYZE;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t3i1 {5 3} t3i2 {5 3 1 1 1} t3i3 {5 5 2 1 1}}
+
+do_test analyze-3.10 {
+  execsql {
+    CREATE TABLE [silly " name](a, b, c);
+    CREATE INDEX 'foolish '' name' ON [silly " name](a, b);
+    CREATE INDEX 'another foolish '' name' ON [silly " name](c);
+    INSERT INTO [silly " name] VALUES(1, 2, 3);
+    INSERT INTO [silly " name] VALUES(4, 5, 6);
+    ANALYZE;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {{another foolish ' name} {2 1} {foolish ' name} {2 1 1} t3i1 {5 3} t3i2 {5 3 1 1 1} t3i3 {5 5 2 1 1}}
+do_test analyze-3.11 {
+  execsql {
+    DROP INDEX "foolish ' name";
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {{another foolish ' name} {2 1} t3i1 {5 3} t3i2 {5 3 1 1 1} t3i3 {5 5 2 1 1}}
+do_test analyze-3.11 {
+  execsql {
+    DROP TABLE "silly "" name";
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t3i1 {5 3} t3i2 {5 3 1 1 1} t3i3 {5 5 2 1 1}}
+
+# Try corrupting the sqlite_stat1 table and make sure the
+# database is still able to function.
+#
+do_test analyze-4.0 {
+  sqlite3 db2 test.db
+  db2 eval {
+    CREATE TABLE t4(x,y,z);
+    CREATE INDEX t4i1 ON t4(x);
+    CREATE INDEX t4i2 ON t4(y);
+    INSERT INTO t4 SELECT a,b,c FROM t3;
+  }
+  db2 close
+  db close
+  sqlite3 db test.db
+  execsql {
+    ANALYZE;
+    SELECT idx, stat FROM sqlite_stat1 ORDER BY idx;
+  }
+} {t3i1 {5 3} t3i2 {5 3 1 1 1} t3i3 {5 5 2 1 1} t4i1 {5 3} t4i2 {5 2}}
+do_test analyze-4.1 {
+  execsql {
+    PRAGMA writable_schema=on;
+    INSERT INTO sqlite_stat1 VALUES(null,null,null);
+    PRAGMA writable_schema=off;
+  }
+  db close
+  sqlite3 db test.db
+  execsql {
+    SELECT * FROM t4 WHERE x=1234;
+  }
+} {}
+do_test analyze-4.2 {
+  execsql {
+    PRAGMA writable_schema=on;
+    DELETE FROM sqlite_stat1;
+    INSERT INTO sqlite_stat1 VALUES('t4','t4i1','nonsense');
+    INSERT INTO sqlite_stat1 VALUES('t4','t4i2','120897349817238741092873198273409187234918720394817209384710928374109827172901827349871928741910');
+    PRAGMA writable_schema=off;
+  }
+  db close
+  sqlite3 db test.db
+  execsql {
+    SELECT * FROM t4 WHERE x=1234;
+  }
+} {}
+do_test analyze-4.3 {
+  execsql {
+    INSERT INTO sqlite_stat1 VALUES('t4','xyzzy','0 1 2 3');
+  }
+  db close
+  sqlite3 db test.db
+  execsql {
+    SELECT * FROM t4 WHERE x=1234;
+  }
+} {}
+
+# Verify that DROP TABLE and DROP INDEX remove entries from the 
+# sqlite_stat1 and sqlite_stat4 tables.
+#
+do_test analyze-5.0 {
+  execsql {
+    DELETE FROM t3;
+    DELETE FROM t4;
+    INSERT INTO t3 VALUES(1,2,3,4);
+    INSERT INTO t3 VALUES(5,6,7,8);
+    INSERT INTO t3 SELECT a+8, b+8, c+8, d+8 FROM t3;
+    INSERT INTO t3 SELECT a+16, b+16, c+16, d+16 FROM t3;
+    INSERT INTO t3 SELECT a+32, b+32, c+32, d+32 FROM t3;
+    INSERT INTO t3 SELECT a+64, b+64, c+64, d+64 FROM t3;
+    INSERT INTO t4 SELECT a, b, c FROM t3;
+    ANALYZE;
+    SELECT DISTINCT idx FROM sqlite_stat1 ORDER BY 1;
+    SELECT DISTINCT tbl FROM sqlite_stat1 ORDER BY 1;
+  }
+} {t3i1 t3i2 t3i3 t4i1 t4i2 t3 t4}
+ifcapable stat4 {
+  do_test analyze-5.1 {
+    execsql {
+      SELECT DISTINCT idx FROM sqlite_stat4 ORDER BY 1;
+      SELECT DISTINCT tbl FROM sqlite_stat4 ORDER BY 1;
+    }
+  } {t3i1 t3i2 t3i3 t4i1 t4i2 t3 t4}
+}
+do_test analyze-5.2 {
+  execsql {
+    DROP INDEX t3i2;
+    SELECT DISTINCT idx FROM sqlite_stat1 ORDER BY 1;
+    SELECT DISTINCT tbl FROM sqlite_stat1 ORDER BY 1;
+  }
+} {t3i1 t3i3 t4i1 t4i2 t3 t4}
+ifcapable stat4 {
+  do_test analyze-5.3 {
+    execsql {
+      SELECT DISTINCT idx FROM sqlite_stat4 ORDER BY 1;
+      SELECT DISTINCT tbl FROM sqlite_stat4 ORDER BY 1;
+    }
+  } {t3i1 t3i3 t4i1 t4i2 t3 t4}
+}
+do_test analyze-5.4 {
+  execsql {
+    DROP TABLE t3;
+    SELECT DISTINCT idx FROM sqlite_stat1 ORDER BY 1;
+    SELECT DISTINCT tbl FROM sqlite_stat1 ORDER BY 1;
+  }
+} {t4i1 t4i2 t4}
+ifcapable stat4 {
+  do_test analyze-5.5 {
+    execsql {
+      SELECT DISTINCT idx FROM sqlite_stat4 ORDER BY 1;
+      SELECT DISTINCT tbl FROM sqlite_stat4 ORDER BY 1;
+    }
+  } {t4i1 t4i2 t4}
+}
+
+# This test corrupts the database file so it must be the last test
+# in the series.
+#
+do_test analyze-5.99 {
+  sqlite3_db_config db DEFENSIVE 0
+  execsql {
+    PRAGMA writable_schema=on;
+    UPDATE sqlite_master SET sql='nonsense' WHERE name='sqlite_stat1';
+  }
+  db close
+  catch { sqlite3 db test.db }
+  catchsql {
+    ANALYZE
+  }
+} {1 {malformed database schema (sqlite_stat1)}}
+
+# Verify that tables whose names begin with "sqlite" but not
+# "sqlite_" are analyzed.
+#
+db close
+sqlite3 db :memory:
+do_execsql_test analyze-6.1 {
+  CREATE TABLE sqliteDemo(a);
+  INSERT INTO sqliteDemo(a) VALUES(1),(2),(3),(4),(5);
+  CREATE TABLE SQLiteDemo2(a INTEGER PRIMARY KEY AUTOINCREMENT);
+  INSERT INTO SQLiteDemo2 SELECT * FROM sqliteDemo;
+  CREATE TABLE t1(b);
+  INSERT INTO t1(b) SELECT a FROM sqliteDemo;
+  ANALYZE;
+  SELECT tbl FROM sqlite_stat1 WHERE idx IS NULL ORDER BY tbl;
+} {SQLiteDemo2 sqliteDemo t1}
+
+# The following caused a small buffer overread in STAT4 processing prior
+# to check-in [b99135288b157044].
+#
+ifcapable stat4 {
+  reset_db
+  database_may_be_corrupt
+  do_execsql_test analyze-7.1 {
+    CREATE TABLE t1(a INTEGER PRIMARY KEY, b INTEGER);
+    INSERT INTO t1 VALUES(1, 7223372036854775);
+    INSERT INTO t1 VALUES(2, 7223372036854776);
+    INSERT INTO t1 VALUES(3, 7223372036854777);
+    CREATE INDEX i1 ON t1(b);
+    ANALYZE;
+    UPDATE sqlite_stat4 SET sample = substr(sample, 0, 4);
+    ANALYZE sqlite_schema;
+    SELECT * FROM t1 WHERE b>7223372036854775
+  } {2 7223372036854776 3 7223372036854777}
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/auth2.test

@@ -0,0 +1,160 @@
+# 2006 Aug 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the sqlite3_set_authorizer() API
+# and related functionality.
+#
+# $Id: auth2.test,v 1.3 2008/07/02 13:13:53 danielk1977 Exp $
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# disable this test if the SQLITE_OMIT_AUTHORIZATION macro is
+# defined during compilation.
+if {[catch {db auth {}} msg]} {
+  finish_test
+  return
+}
+
+do_test auth2-1.1 {
+  execsql {
+    CREATE TABLE t1(a,b,c);
+    INSERT INTO t1 VALUES(1,2,3);
+  }
+  set ::flist {}
+  proc auth {code arg1 arg2 arg3 arg4 args} {
+    if {$code=="SQLITE_FUNCTION"} {
+      lappend ::flist $arg2
+      if {$arg2=="max"} {
+        return SQLITE_DENY
+      } elseif {$arg2=="min"} {
+        return SQLITE_IGNORE
+      } else {
+        return SQLITE_OK
+      }
+    }
+    return SQLITE_OK
+  }
+  db authorizer ::auth
+  catchsql {SELECT max(a,b,c) FROM t1}
+} {1 {not authorized to use function: max}}
+do_test auth2-1.2 {
+  set ::flist
+} max
+do_test auth2-1.3 {
+  set ::flist {}
+  catchsql {SELECT min(a,b,c) FROM t1}
+} {0 {{}}}
+do_test auth2-1.4 {
+  set ::flist
+} min
+do_test auth2-1.5 {
+  set ::flist {}
+  catchsql {SELECT coalesce(min(a,b,c),999) FROM t1}
+} {0 999}
+do_test auth2-1.6 {
+  set ::flist
+} {coalesce min}
+do_test auth2-1.7 {
+  set ::flist {}
+  catchsql {SELECT coalesce(a,b,c) FROM t1}
+} {0 1}
+do_test auth2-1.8 {
+  set ::flist
+} coalesce
+
+# Make sure the authorizer is not called when parsing the schema
+# and when computing the result set of a view.
+#
+db close
+sqlite3 db test.db
+sqlite3 db2 test.db
+proc auth {args} {
+  global authargs
+  append authargs [lrange $args 0 4]\n
+  return SQLITE_OK
+}
+db auth auth
+do_test auth2-2.1 {
+  set ::authargs {}
+  db eval {
+    CREATE TABLE t2(x,y,z);
+  }
+  set ::authargs
+} {SQLITE_INSERT sqlite_master {} main {}
+SQLITE_CREATE_TABLE t2 {} main {}
+SQLITE_UPDATE sqlite_master type main {}
+SQLITE_UPDATE sqlite_master name main {}
+SQLITE_UPDATE sqlite_master tbl_name main {}
+SQLITE_UPDATE sqlite_master rootpage main {}
+SQLITE_UPDATE sqlite_master sql main {}
+SQLITE_READ sqlite_master ROWID main {}
+}
+do_test auth2-2.2 {
+  set ::authargs {}
+  db eval {
+    CREATE VIEW v2 AS SELECT x+y AS a, y+z AS b from t2;
+  }
+  set ::authargs
+} {SQLITE_INSERT sqlite_master {} main {}
+SQLITE_CREATE_VIEW v2 {} main {}
+SQLITE_UPDATE sqlite_master type main {}
+SQLITE_UPDATE sqlite_master name main {}
+SQLITE_UPDATE sqlite_master tbl_name main {}
+SQLITE_UPDATE sqlite_master rootpage main {}
+SQLITE_UPDATE sqlite_master sql main {}
+SQLITE_READ sqlite_master ROWID main {}
+}
+do_test auth2-2.3 {
+  set ::authargs {}
+  db eval {
+    SELECT a, b FROM v2;
+  }
+  set ::authargs
+} {SQLITE_SELECT {} {} {} {}
+SQLITE_READ t2 x main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 z main v2
+SQLITE_READ v2 a main {}
+SQLITE_READ v2 b main {}
+SQLITE_SELECT {} {} {} v2
+}
+do_test auth2-2.4 {
+  db2 eval {
+    CREATE TABLE t3(p,q,r);
+  }
+  set ::authargs {}
+  db eval {
+    SELECT b, a FROM v2;
+  }
+  set ::authargs
+} {SQLITE_SELECT {} {} {} {}
+SQLITE_READ t2 x main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 z main v2
+SQLITE_READ v2 b main {}
+SQLITE_READ v2 a main {}
+SQLITE_SELECT {} {} {} v2
+SQLITE_SELECT {} {} {} {}
+SQLITE_READ t2 x main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 y main v2
+SQLITE_READ t2 z main v2
+SQLITE_READ v2 b main {}
+SQLITE_READ v2 a main {}
+SQLITE_SELECT {} {} {} v2
+}
+db2 close
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/autoindex2.test

@@ -0,0 +1,232 @@
+# 2014-06-17
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+#
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing automatic index creation logic.
+#
+# This file contains a single real-world test case that was giving
+# suboptimal performance because of over-use of automatic indexes.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+
+do_execsql_test autoindex2-100 {
+  CREATE TABLE t1(
+    t1_id largeint,
+    did char(9),
+    ptime largeint,
+    exbyte char(4),
+    pe_id int,
+    field_id int,
+    mass float,
+    param10 float,
+    param11 float,
+    exmass float,
+    deviation float,
+    trange float,
+    vstatus int,
+    commit_status int,
+    formula char(329),
+    tier int DEFAULT 2,
+    ssid int DEFAULT 0,
+    last_operation largeint DEFAULT 0,
+    admin_uuid int DEFAULT 0,
+    previous_value float,
+    job_id largeint,
+    last_t1 largeint DEFAULT 0,
+    data_t1 int,
+    previous_date largeint DEFAULT 0,
+    flg8 int DEFAULT 1,
+    failed_fields char(100)
+  );
+  CREATE INDEX t1x0 on t1 (t1_id);
+  CREATE INDEX t1x1 on t1 (ptime, vstatus);
+  CREATE INDEX t1x2 on t1 (did, ssid, ptime, vstatus, exbyte, t1_id);
+  CREATE INDEX t1x3 on t1 (job_id);
+  
+  CREATE TABLE t2(
+    did char(9),
+    client_did char(30),
+    description char(49),
+    uid int,
+    tzid int,
+    privilege int,
+    param2 int,
+    type char(30),
+    subtype char(32),
+    dparam1 char(7) DEFAULT '',
+    param5 char(3) DEFAULT '',
+    notional float DEFAULT 0.000000,
+    create_time largeint,
+    sample_time largeint DEFAULT 0,
+    param6 largeint,
+    frequency int,
+    expiration largeint,
+    uw_status int,
+    next_sample largeint,
+    last_sample largeint,
+    reserve1 char(29) DEFAULT '',
+    reserve2 char(29) DEFAULT '',
+    reserve3 char(29) DEFAULT '',
+    bxcdr char(19) DEFAULT 'XY',
+    ssid int DEFAULT 1,
+    last_t1_id largeint,
+    reserve4 char(29) DEFAULT '',
+    reserve5 char(29) DEFAULT '',
+    param12 int DEFAULT 0,
+    long_did char(100) DEFAULT '',
+    gr_code int DEFAULT 0,
+    drx char(100) DEFAULT '',
+    parent_id char(9) DEFAULT '',
+    param13 int DEFAULT 0,
+    position float DEFAULT 1.000000,
+    client_did3 char(100) DEFAULT '',
+    client_did4 char(100) DEFAULT '',
+    dlib_id char(9) DEFAULT ''
+  );
+  CREATE INDEX t2x0 on t2 (did);
+  CREATE INDEX t2x1 on t2 (client_did);
+  CREATE INDEX t2x2 on t2 (long_did);
+  CREATE INDEX t2x3 on t2 (uid);
+  CREATE INDEX t2x4 on t2 (param2);
+  CREATE INDEX t2x5 on t2 (type);
+  CREATE INDEX t2x6 on t2 (subtype);
+  CREATE INDEX t2x7 on t2 (last_sample);
+  CREATE INDEX t2x8 on t2 (param6);
+  CREATE INDEX t2x9 on t2 (frequency);
+  CREATE INDEX t2x10 on t2 (privilege);
+  CREATE INDEX t2x11 on t2 (sample_time);
+  CREATE INDEX t2x12 on t2 (notional);
+  CREATE INDEX t2x13 on t2 (tzid);
+  CREATE INDEX t2x14 on t2 (gr_code);
+  CREATE INDEX t2x15 on t2 (parent_id);
+  
+  CREATE TABLE t3(
+    uid int,
+    param3 int,
+    uuid int,
+    acc_id int,
+    cust_num int,
+    numerix_id int,
+    pfy char(29),
+    param4 char(29),
+    param15 int DEFAULT 0,
+    flg7 int DEFAULT 0,
+    param21 int DEFAULT 0,
+    bxcdr char(2) DEFAULT 'PC',
+    c31 int DEFAULT 0,
+    c33 int DEFAULT 0,
+    c35 int DEFAULT 0,
+    c37 int,
+    mgr_uuid int,
+    back_up_uuid int,
+    priv_mars int DEFAULT 0,
+    is_qc int DEFAULT 0,
+    c41 int DEFAULT 0,
+    deleted int DEFAULT 0,
+    c47 int DEFAULT 1
+  );
+  CREATE INDEX t3x0 on t3 (uid);
+  CREATE INDEX t3x1 on t3 (param3);
+  CREATE INDEX t3x2 on t3 (uuid);
+  CREATE INDEX t3x3 on t3 (acc_id);
+  CREATE INDEX t3x4 on t3 (param4);
+  CREATE INDEX t3x5 on t3 (pfy);
+  CREATE INDEX t3x6 on t3 (is_qc);
+  SELECT count(*) FROM sqlite_master;
+} {30}
+do_execsql_test autoindex2-110 {
+  ANALYZE sqlite_master;
+  INSERT INTO sqlite_stat1 VALUES('t1','t1x3','10747267 260');
+  INSERT INTO sqlite_stat1 VALUES('t1','t1x2','10747267 121 113 2 2 2 1');
+  INSERT INTO sqlite_stat1 VALUES('t1','t1x1','10747267 50 40');
+  INSERT INTO sqlite_stat1 VALUES('t1','t1x0','10747267 1');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x15','39667 253');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x14','39667 19834');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x13','39667 13223');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x12','39667 7');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x11','39667 17');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x10','39667 19834');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x9','39667 7934');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x8','39667 11');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x7','39667 5');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x6','39667 242');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x5','39667 1984');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x4','39667 4408');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x3','39667 81');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x2','39667 551');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x1','39667 2');
+  INSERT INTO sqlite_stat1 VALUES('t2','t2x0','39667 1');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x6','569 285');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x5','569 2');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x4','569 2');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x3','569 5');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x2','569 3');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x1','569 6');
+  INSERT INTO sqlite_stat1 VALUES('t3','t3x0','569 1');
+  ANALYZE sqlite_master;
+} {}
+do_execsql_test autoindex2-120 {
+  EXPLAIN QUERY PLAN
+  SELECT
+     t1_id,
+     t1.did,
+     param2,
+     param3,
+     t1.ptime,
+     t1.trange,
+     t1.exmass,
+     t1.mass,
+     t1.vstatus,
+     type,
+     subtype,
+     t1.deviation,
+     t1.formula,
+     dparam1,
+     reserve1,
+     reserve2,
+     param4,
+     t1.last_operation,
+     t1.admin_uuid,
+     t1.previous_value,
+     t1.job_id,
+     client_did, 
+     t1.last_t1,
+     t1.data_t1,
+     t1.previous_date,
+     param5,
+     param6,
+     mgr_uuid
+  FROM
+     t1,
+     t2,
+     t3
+  WHERE
+     t1.ptime > 1393520400
+     AND param3<>9001
+     AND t3.flg7 = 1
+     AND t1.did = t2.did
+     AND t2.uid = t3.uid
+  ORDER BY t1.ptime desc LIMIT 500;
+} {~/AUTO/}
+#
+# ^^^--- Before being fixed, the above was using an automatic covering
+# on t3 and reordering the tables so that t3 was in the outer loop and
+# implementing the ORDER BY clause using a B-Tree.
+#
+# This test is sanitized data received from a user.  The original unsanitized
+# data and STAT4 data is found in the th3private test repository.  See one of
+# the th3private check-ins on 2016-02-25.  The test is much more accurate when
+# STAT4 data is used.
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/bestindexB.test

@@ -0,0 +1,87 @@
+# 2023-10-26
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# 
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix bestindexB
+
+ifcapable !vtab {
+  finish_test
+  return
+}
+
+register_tcl_module db
+
+proc vtab_command {method args} {
+  switch -- $method {
+    xConnect {
+      return "CREATE TABLE t1(a, b, c)"
+    }
+
+    xBestIndex {
+      set hdl [lindex $args 0]
+      set clist [$hdl constraints]
+      set orderby [$hdl orderby]
+
+      if {[info exists ::xbestindex_sql]} { 
+        explain_i $::xbestindex_sql 
+        set ::xbestindex_res [ execsql $::xbestindex_sql ]
+      }
+
+      return "cost 1000000 rows 1000000 idxnum 0 idxstr hello"
+    }
+
+    xFilter {
+      return "sql {SELECT 0, 1, 2, 3}"
+    }
+  }
+
+  return {}
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE x1 USING tcl(vtab_command);
+  CREATE TABLE y1(a, b);
+  CREATE TABLE y2(a, b);
+} {}
+
+do_execsql_test 1.1 {
+  SELECT * FROM x1
+} {1 2 3}
+
+do_execsql_test 1.2 {
+  INSERT INTO y1 VALUES(1, 2) RETURNING rowid;
+} {1}
+
+do_execsql_test 1.3 {
+  CREATE TRIGGER y1tr BEFORE INSERT ON y1 BEGIN
+    SELECT * FROM x1;
+  END;
+  INSERT INTO y1 VALUES(3, 4) RETURNING rowid;
+} {2}
+
+
+# This time, rig the xBestIndex() method of the vtab to invoke an SQL
+# statement that uses RETURNING.
+set ::xbestindex_sql {
+  INSERT INTO y2 VALUES(NULL, NULL) RETURNING rowid;
+}
+do_execsql_test 1.4 {
+  INSERT INTO y1 VALUES(5, 6) RETURNING rowid;
+} {3}
+
+do_test 1.5 {
+  set ::xbestindex_res
+} {1}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/bestindexC.test

@@ -0,0 +1,352 @@
+# 2024-04-26
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# 
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix bestindexC
+
+ifcapable !vtab {
+  finish_test
+  return
+}
+
+register_tcl_module db
+
+proc vtab_command {lVal method args} {
+  switch -- $method {
+    xConnect {
+      return "CREATE TABLE t1(a)"
+    }
+
+    xBestIndex {
+      set hdl [lindex $args 0]
+      set clist [$hdl constraints]
+      set orderby [$hdl orderby]
+
+      set idxstr [list]
+      set res [list]
+
+      set idx 0
+      foreach c $clist {
+        array set a $c
+        if {$a(usable)==0} continue
+        if {$a(op)=="limit" && ![info exists ::do_not_use_limit]} { 
+          lappend idxstr limit
+          lappend res omit $idx
+        }
+        if {$a(op)=="offset" && ![info exists ::do_not_use_offset]} { 
+          lappend idxstr offset
+          lappend res omit $idx
+        }
+        incr idx
+      }
+
+      return "cost 1000000 rows 1000000 idxnum 0 idxstr {$idxstr} $res"
+    }
+
+    xFilter {
+      set idxstr [lindex $args 1]
+      set LIMIT ""
+      foreach a $idxstr b [lindex $args 2] {
+        set x($a) $b
+      }
+
+      if {![info exists x(limit)]} { set x(limit) -1 }
+      if {![info exists x(offset)]} { set x(offset) -1 }
+      set LIMIT " LIMIT $x(limit) OFFSET $x(offset)"
+
+      set idx 1
+      foreach v $lVal {
+        lappend lRow "($idx, '$v')"
+        incr idx
+      }
+
+      return [list sql "
+        SELECT * FROM ( VALUES [join $lRow ,]) $LIMIT
+      "]
+    }
+  }
+
+  return {}
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE x1 USING tcl(vtab_command "a b c d e f");
+  CREATE VIRTUAL TABLE x2 USING tcl(vtab_command "A B C D E F a b");
+} {}
+
+do_execsql_test 1.1 {
+  CREATE TEMP TABLE t_unionall AS 
+    SELECT * FROM x1 UNION ALL SELECT * FROM x2;
+
+  CREATE TEMP TABLE t_intersect AS 
+    SELECT * FROM x1 INTERSECT SELECT * FROM x2;
+
+  CREATE TEMP TABLE t_union AS 
+    SELECT * FROM x1 UNION SELECT * FROM x2;
+
+  CREATE TEMP TABLE t_except AS 
+    SELECT * FROM x1 EXCEPT SELECT * FROM x2;
+}
+
+foreach {tn limit} {
+  1 "LIMIT 8" 
+  2 "LIMIT 4" 
+  3 "LIMIT 4 OFFSET 2" 
+  4 "LIMIT 8 OFFSET 4" 
+} {
+
+  foreach {op tbl} {
+    "UNION ALL" t_unionall
+    "UNION"     t_union
+    "INTERSECT" t_intersect
+    "EXCEPT"    t_except
+  } {
+
+    set expect [execsql "SELECT * FROM $tbl $limit"]
+    do_execsql_test 1.2.$tbl.$tn "SELECT * FROM (
+      SELECT * FROM x1 $op SELECT * FROM x2
+    ) $limit" $expect
+
+  }
+
+}
+
+#-------------------------------------------------------------------------
+reset_db
+register_tcl_module db
+
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE x1 USING tcl(vtab_command "a b c d e f");
+  CREATE VIRTUAL TABLE x2 USING tcl(vtab_command "a b e f");
+} {}
+
+do_execsql_test 2.1 {
+  SELECT * FROM x1 
+    EXCEPT
+  SELECT * FROM x2
+  LIMIT 3
+} {c d}
+
+#-------------------------------------------------------------------------
+reset_db
+register_tcl_module db
+do_execsql_test 3.0 {
+  CREATE VIRTUAL TABLE y1 USING tcl(vtab_command "1 2 3 4 5 6 7 8 9 10");
+} {}
+
+do_execsql_test 3.1 {
+  SELECT * FROM y1 WHERE a = COALESCE('8', a) LIMIT 3
+} {8}
+
+do_execsql_test 3.2 {
+  SELECT * FROM y1 WHERE a = '2' LIMIT 3
+} {2}
+
+load_static_extension db series
+do_execsql_test 3.3 {
+  SELECT * FROM generate_series(1, 5) WHERE value = (value & 14) LIMIT 3
+} {2 4}
+
+do_execsql_test 3.4 {
+  SELECT value FROM generate_series(1,10) WHERE value>2 LIMIT 4 OFFSET 1;
+} {4 5 6 7}
+
+set ::do_not_use_limit 1
+do_execsql_test 3.5 {
+  SELECT * FROM y1 LIMIT 5 OFFSET 3
+} {4 5 6 7 8}
+unset ::do_not_use_limit
+set ::do_not_use_offset 1
+do_execsql_test 3.6 {
+  SELECT * FROM y1 LIMIT 5 OFFSET 3
+} {4 5 6 7 8}
+unset ::do_not_use_offset
+
+#-------------------------------------------------------------------------
+reset_db
+proc vtab_command {lVal method args} {
+  switch -- $method {
+    xConnect { error "not happy!" }
+  }
+
+  return {}
+}
+
+register_tcl_module db
+do_catchsql_test 4.0 {
+  CREATE VIRTUAL TABLE y1 USING tcl(vtab_command 1);
+} {1 {not happy!}}
+do_test 4.1 {
+  sqlite3_errcode db
+} SQLITE_ERROR
+
+proc vtab_command {lVal method args} {
+  switch -- $method {
+    xConnect {
+      return $lVal
+    }
+  }
+  return {}
+}
+
+do_catchsql_test 4.2 {
+  CREATE VIRTUAL TABLE y1 USING tcl(vtab_command "PRAGMA page_size=1024");
+} {1 {declare_vtab: syntax error}}
+do_catchsql_test 4.3 {
+  CREATE VIRTUAL TABLE y1 USING tcl(vtab_command "CREATE TABLE x1(");
+} {1 {declare_vtab: incomplete input}}
+do_catchsql_test 4.4 {
+  CREATE VIRTUAL TABLE y1 USING tcl(vtab_command "CREATE TABLE x1(insert)");
+} {1 {declare_vtab: near "insert": syntax error}}
+
+#-------------------------------------------------------------------------
+reset_db
+register_tcl_module db
+
+proc quote {str} {
+  return "'[string map {' ''} $str]'"
+}
+
+proc vtab_command {lVal method args} {
+  switch -- $method {
+    xConnect {
+      return "CREATE TABLE t1(a, b, c, d)"
+    }
+
+    xBestIndex {
+      set hdl [lindex $args 0]
+      set clist [$hdl constraints]
+
+      set res [list]
+      set idx 0
+      set idxnum 0
+
+      set cols(0) a
+      set cols(1) b
+      set cols(2) c
+
+      set lCons [list]
+
+      foreach c $clist {
+        array set a $c
+        if {$a(usable)==0} continue
+
+        if {($a(op)=="eq" || $a(op)=="is") && [info exists cols($a(column))]} {
+          lappend res omit $idx
+          set coll [$hdl collation $idx]
+          lappend lCons "$cols($a(column)) = %[llength $lCons]% COLLATE $coll"
+
+          set idxnum [expr {$idx + (1 << $a(column))}]
+          catch { unset cols($a(column)) }
+        }
+
+        incr idx
+      }
+
+      if {[llength [array names cols]]>0} {
+        set missing [list]
+        for {set i 0} {$i < 3} {incr i} {
+          catch { lappend missing $cols($i) }
+        }
+        set msg "missing required constraints: [join $missing ,]"
+        return [list constraint $msg]
+      }
+
+      set idxstr [join $lCons " AND "]
+      return "cost 1000 rows 1000 idxnum $idxnum $res idxstr {$idxstr}"
+    }
+
+    xFilter {
+      foreach {idxnum idxstr lArg} $args {}
+      set i 0
+      set where $idxstr
+      foreach a $lArg {
+        set where [string map [list %$i% [quote $a]] $where]
+        incr i
+      }
+   #   puts $where
+      return [list sql "SELECT rowid, * FROM $lVal WHERE $where"]
+    }
+  }
+
+  return {}
+}
+
+do_execsql_test 5.1 {
+  CREATE VIRTUAL TABLE x1 USING tcl(vtab_command t1);
+  CREATE TABLE t1(a, b, c, d);
+}
+
+foreach {tn where ok} {
+  0    "WHERE a=? AND b=? AND c=? AND c=?"              1
+  1    "WHERE a=? AND b=? AND c=?"                      1
+  2    "WHERE a=? AND b=? AND (c=? OR c=?)"             1
+  3    "WHERE a=? AND b=? AND (c=? OR c=? OR c=?)"      1
+  4    "WHERE a=? AND b=? AND (c IS ? OR c IS ?)"       1
+  5    "WHERE a=? AND ((b=? AND c=?) OR (c=? AND b=?))" 1
+  6    "WHERE a=? AND ((b=? AND c=?) OR (c=?))"         0
+} {
+  do_test 5.2.$tn {
+    catch { execsql "SELECT * FROM x1 $::where" } msg
+#    if {$tn==0 || $tn==2 || $tn==3} { puts "MSG: $msg" }
+  } [expr !$ok]
+}
+
+do_execsql_test 5.3 {
+  SELECT * FROM x1 WHERE (a, b, c) = (?, ?, ?);
+}
+
+do_execsql_test 5.4 {
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(1, 'x', 'y', 'z', 'one');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(2, 'X', 'Y', 'Z', 'two');
+  SELECT * FROM x1 WHERE (a, b, c) = ('X', 'Y', 'Z');
+} {X Y Z two}
+do_execsql_test 5.5 {
+  SELECT * FROM x1 WHERE a='x' AND b='y' AND c='z';
+} {x y z one}
+do_execsql_test 5.6 {
+  SELECT * FROM x1 
+  WHERE a='x' COLLATE nocase AND b='y' COLLATE nocase AND c='z'COLLATE nocase;
+} {x y z one X Y Z two}
+
+do_execsql_test 5.7 {
+  DELETE FROM t1;
+
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(0, 'x', 'y', 'z', 'zero');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(1, 'x', 'y', 'Z', 'one');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(2, 'x', 'Y', 'z', 'two');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(3, 'x', 'Y', 'Z', 'three');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(4, 'X', 'y', 'z', 'four');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(5, 'X', 'y', 'Z', 'five');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(6, 'X', 'Y', 'z', 'six');
+  INSERT INTO t1(rowid, a, b, c, d) VALUES(7, 'X', 'Y', 'z', 'seven');
+}
+
+do_execsql_test 5.8 {
+  SELECT d FROM x1 
+  WHERE a='x' AND ((b='y' AND c='z') OR (b='Y' AND c='z' COLLATE nocase))
+} {
+  zero two three
+}
+
+do_execsql_test 5.9 {
+  SELECT d FROM x1 
+  WHERE a='x' COLLATE nocase 
+  AND ((b='y' AND c='z') OR (b='Y' AND c='z' COLLATE nocase))
+} {
+  zero four two
+  three six seven
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/bloom1.test

@@ -0,0 +1,188 @@
+# 2022 October 06
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests for queries that use bloom filters
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+
+set testprefix bloom1
+
+# Tests 1.*  verify that the bloom filter code correctly handles the
+# case where the RHS of an (<ipk-column> = ?) expression must be coerced
+# to an integer before the comparison made.
+#
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b);
+  CREATE TABLE t2(c INTEGER PRIMARY KEY, d);
+}
+
+do_execsql_test 1.1 {
+  INSERT INTO t1 VALUES('hello', 'world');
+  INSERT INTO t2 VALUES(14, 'fourteen');
+}
+
+do_execsql_test 1.2 {
+  ANALYZE sqlite_schema;
+  INSERT INTO sqlite_stat1 VALUES('t2','idx1','6 6');
+  ANALYZE sqlite_schema;
+}
+
+do_execsql_test 1.3 {
+  SELECT 'affinity!' FROM t1 CROSS JOIN t2 WHERE t2.c = '14';
+} {affinity!}
+
+
+reset_db
+do_execsql_test 1.4 {
+  CREATE TABLE t1(a, b TEXT);
+  CREATE TABLE t2(c INTEGER PRIMARY KEY, d);
+  CREATE TABLE t3(e INTEGER PRIMARY KEY, f);
+
+  ANALYZE sqlite_schema;
+  INSERT INTO sqlite_stat1 VALUES('t1','idx1','600 6');
+  INSERT INTO sqlite_stat1 VALUES('t2','idx1','6 6');
+  INSERT INTO sqlite_stat1 VALUES('t3','idx2','6 6');
+  ANALYZE sqlite_schema;
+
+  INSERT INTO t1 VALUES(1, '123');
+  INSERT INTO t2 VALUES(123, 'one');
+  INSERT INTO t3 VALUES(123, 'two');
+}
+
+do_execsql_test 1.5 {
+  SELECT 'result' FROM t1, t2, t3 
+  WHERE t2.c=t1.b AND t2.d!='silly'
+    AND t3.e=t1.b AND t3.f!='silly'
+} {result}
+
+# 2023-02-05
+# https://sqlite.org/forum/forumpost/56de336385
+#
+# Do not employ a Bloom filter if the table being filtered or any table
+# wo the left of the table being filtered lacks STAT1 data, since we
+# cannot make a good Bloom filter usefulness determination without STAT1
+# data.
+#
+reset_db
+do_execsql_test 2.0 {
+  CREATE TABLE objs(c INTEGER, s INTEGER, p INTEGER, o INTEGER);
+  CREATE UNIQUE INDEX objs_cspo ON objs(o,p,c,s);
+  ANALYZE;
+  DELETE FROM sqlite_stat1;
+  INSERT INTO sqlite_stat1 VALUES('objs','objs_cspo','520138 21 20 19 1');
+  ANALYZE sqlite_schema;
+}
+do_eqp_test 2.1 {
+  WITH RECURSIVE transit(x) AS (
+     SELECT s FROM objs WHERE p=9 AND o=32805
+     UNION
+     SELECT objs.s FROM objs, transit WHERE objs.p=9 AND objs.o=transit.x
+  )
+  SELECT x FROM transit;
+} {
+  QUERY PLAN
+  |--CO-ROUTINE transit
+  |  |--SETUP
+  |  |  `--SEARCH objs USING COVERING INDEX objs_cspo (o=? AND p=?)
+  |  `--RECURSIVE STEP
+  |     |--SCAN transit
+  |     `--SEARCH objs USING COVERING INDEX objs_cspo (o=? AND p=?)
+  `--SCAN transit
+}
+
+# 2023-02-28
+# https://sqlite.org/forum/forumpost/0846211821
+#
+# Bloom filter gives an incorrect result if the collating sequence is
+# anything other than binary.
+#
+reset_db
+do_execsql_test 3.1 {
+  CREATE TABLE t0(x TEXT COLLATE rtrim);
+  INSERT INTO t0(x) VALUES ('a'), ('b'), ('c');
+  CREATE VIEW v0(y) AS SELECT DISTINCT x FROM t0;
+  SELECT count(*) FROM t0, v0 WHERE x='b ';
+} 3
+do_eqp_test 3.2 {
+  SELECT count(*) FROM t0, v0 WHERE x='b ';
+} {
+  QUERY PLAN
+  |--CO-ROUTINE v0
+  |  |--SCAN t0
+  |  `--USE TEMP B-TREE FOR DISTINCT
+  |--SCAN v0
+  `--SEARCH t0 USING AUTOMATIC PARTIAL COVERING INDEX (x=?)
+}
+# ^^^^^--- The key feature in the previous result is that no Bloom filter
+# is used.  In the following, a Bloom filter is used because the data type
+# is INT instead of TEXT.
+do_execsql_test 3.3 {
+  CREATE TABLE t1(x INT COLLATE rtrim);
+  INSERT INTO t1(x) VALUES ('a'), ('b'), ('c');
+  CREATE VIEW v1(y) AS SELECT DISTINCT x FROM t1;
+  SELECT count(*) FROM t1, v1 WHERE x='b ';
+} 3
+do_eqp_test 3.4 {
+  SELECT count(*) FROM t1, v1 WHERE x='b ';
+} {
+  QUERY PLAN
+  |--CO-ROUTINE v1
+  |  |--SCAN t1
+  |  `--USE TEMP B-TREE FOR DISTINCT
+  |--SCAN v1
+  |--BLOOM FILTER ON t1 (x=?)
+  `--SEARCH t1 USING AUTOMATIC PARTIAL COVERING INDEX (x=?)
+}
+
+# 2023-03-14 
+# https://sqlite.org/forum/forumpost/d47a0e8e3a
+# https://sqlite.org/forum/forumpost/2e427099d5
+#
+# Both reports are for the same problem - using a Bloom filter on an
+# expression index can cause issues.
+#
+reset_db
+do_execsql_test 4.1 {
+  CREATE TABLE t1(x TEXT, y INT, z TEXT);
+  INSERT INTO t1(rowid,x,y,z) VALUES(12,'aa','bb','aa');
+  CREATE INDEX i1x ON t1(1 IS true,z);
+  CREATE TABLE t0(x TEXT);
+  INSERT INTO t0(rowid,x) VALUES(4,'aa');
+  ANALYZE sqlite_schema;
+  INSERT INTO sqlite_stat1 VALUES('t0',NULL,'20');
+  INSERT INTO sqlite_stat1 VALUES('t1','i1x','18 18 2');
+  ANALYZE sqlite_schema;
+}
+do_execsql_test 4.2 {
+  SELECT * FROM t0 NATURAL JOIN t1 WHERE z=t1.x;
+} {aa bb aa}
+do_execsql_test 4.3 {
+  DROP TABLE t0;
+  CREATE TABLE t0(a TEXT);
+  INSERT INTO t0 VALUES ('xyz');
+  CREATE INDEX t0x ON t0(a IS FALSE) WHERE false;
+  DROP TABLE t1;
+  CREATE TABLE t1(b INT);
+  INSERT INTO t1 VALUES('aaa'),('bbb'),('ccc'),('ddd'),(NULL);
+  CREATE TABLE t2(c REAL);
+  INSERT INTO t2 VALUES(7);
+  ANALYZE;
+  CREATE INDEX t2x ON t2(true IN ());
+}
+do_execsql_test 4.4 {
+  SELECT * FROM t0 LEFT JOIN t1 LEFT JOIN t2 ON (b NOTNULL)==(c IN ()) WHERE c;
+} {xyz {} 7.0}
+ 
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/boundary1.tcl

@@ -0,0 +1,289 @@
+puts {# 2008 December 11
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file is automatically generated from a separate TCL script.
+# This file seeks to exercise integer boundary values.
+#
+# $Id: boundary1.tcl,v 1.3 2009/01/02 15:45:48 shane Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Many of the boundary tests depend on a working 64-bit implementation.
+if {![working_64bit_int]} { finish_test; return }
+}
+
+expr srand(0)
+
+# Generate interesting boundary numbers
+#
+foreach x {
+  0
+  1
+  0x7f
+  0x7fff
+  0x7fffff
+  0x7fffffff
+  0x7fffffffff
+  0x7fffffffffff
+  0x7fffffffffffff
+  0x7fffffffffffffff
+} {
+  set x [expr {wide($x)}]
+  set boundarynum($x) 1
+  set boundarynum([expr {$x+1}]) 1
+  set boundarynum([expr {-($x+1)}]) 1
+  set boundarynum([expr {-($x+2)}]) 1
+  set boundarynum([expr {$x+$x+1}]) 1
+  set boundarynum([expr {$x+$x+2}]) 1
+}
+set x [expr {wide(127)}]
+for {set i 1} {$i<=9} {incr i} {
+  set boundarynum($x) 1
+  set boundarynum([expr {$x+1}]) 1
+  set x [expr {wide($x*128 + 127)}]
+}
+
+# Scramble the $inlist into a random order.
+#
+proc scramble {inlist} {
+  set y {}
+  foreach x $inlist {
+    lappend y [list [expr {rand()}] $x]
+  }
+  set y [lsort $y]
+  set outlist {}
+  foreach x $y {
+    lappend outlist [lindex $x 1]
+  }
+  return $outlist
+}
+
+# A simple selection sort.  Not trying to be efficient.
+#
+proc sort {inlist} {
+  set outlist {}
+  set mn [lindex $inlist 0]
+  foreach x $inlist {
+    if {$x<$mn} {set mn $x}
+  }
+  set outlist $mn
+  set mx $mn
+  while {1} {
+    set valid 0
+    foreach x $inlist {
+      if {$x>$mx && (!$valid || $mn>$x)} {
+        set mn $x
+        set valid 1
+      }
+    }
+    if {!$valid} break
+    lappend outlist $mn
+    set mx $mn
+  }
+  return $outlist
+}
+
+# Reverse the order of a list
+#
+proc reverse {inlist} {
+  set i [llength $inlist]
+  set outlist {}
+  for {incr i -1} {$i>=0} {incr i -1} {
+    lappend outlist [lindex $inlist $i]
+  }
+  return $outlist
+}
+
+set nums1 [scramble [array names boundarynum]]
+set nums2 [scramble [array names boundarynum]]
+
+set tname boundary1
+puts "do_test $tname-1.1 \173"
+puts "  db eval \173"
+puts "    CREATE TABLE t1(a,x);"
+set a 0
+foreach r $nums1 {
+  incr a
+  set t1ra($r) $a
+  set t1ar($a) $r
+  set x [format %08x%08x [expr {wide($r)>>32}] $r]
+  set t1rx($r) $x
+  set t1xr($x) $r
+  puts "    INSERT INTO t1(oid,a,x) VALUES($r,$a,'$x');"
+}
+puts "    CREATE INDEX t1i1 ON t1(a);"
+puts "    CREATE INDEX t1i2 ON t1(x);"
+puts "  \175"
+puts "\175 {}"
+
+puts "do_test $tname-1.2 \173"
+puts "  db eval \173"
+puts "    SELECT count(*) FROM t1"
+puts "  \175"
+puts "\175 {64}"
+
+set nums3 $nums2
+lappend nums3 9.22337303685477580800e+18
+lappend nums3 -9.22337303685477580800e+18
+
+set i 0
+foreach r $nums3 {
+  incr i
+
+  if {abs($r)<9.22337203685477580800e+18} {
+    set x $t1rx($r)
+    set a $t1ra($r)
+    set r5 $r.5
+    set r0 $r.0
+    puts "do_test $tname-2.$i.1 \173"
+    puts "  db eval \173"
+    puts "    SELECT * FROM t1 WHERE rowid=$r"
+    puts "  \175"
+    puts "\175 {$a $x}"
+    puts "do_test $tname-2.$i.2 \173"
+    puts "  db eval \173"
+    puts "    SELECT rowid, a FROM t1 WHERE x='$x'"
+    puts "  \175"
+    puts "\175 {$r $a}"
+    puts "do_test $tname-2.$i.3 \173"
+    puts "  db eval \173"
+    puts "    SELECT rowid, x FROM t1 WHERE a=$a"
+    puts "  \175"
+    puts "\175 {$r $x}"
+  }
+
+  foreach op {> >= < <=} subno {gt ge lt le} {
+
+    ################################################################ 2.x.y.1
+    set rset {}
+    set aset {}
+    foreach rx $nums2 {
+      if "\$rx $op \$r" {
+        lappend rset $rx
+        lappend aset $t1ra($rx)
+      }
+    }
+    puts "do_test $tname-2.$i.$subno.1 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r ORDER BY a"
+    puts "  \175"
+    puts "\175 {[sort $aset]}"
+  
+    ################################################################ 2.x.y.2
+    puts "do_test $tname-2.$i.$subno.2 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r ORDER BY a DESC"
+    puts "  \175"
+    puts "\175 {[reverse [sort $aset]]}"
+  
+    ################################################################ 2.x.y.3
+    set aset {}
+    foreach rx [sort $rset] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.3 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r ORDER BY rowid"
+    puts "  \175"
+    puts "\175 {$aset}"
+  
+    ################################################################ 2.x.y.4
+    set aset {}
+    foreach rx [reverse [sort $rset]] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.4 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r ORDER BY rowid DESC"
+    puts "  \175"
+    puts "\175 {$aset}"
+  
+    ################################################################ 2.x.y.5
+    set aset {}
+    set xset {}
+    foreach rx $rset {
+      lappend xset $t1rx($rx)
+    }
+    foreach x [sort $xset] {
+      set rx $t1xr($x)
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.5 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r ORDER BY x"
+    puts "  \175"
+    puts "\175 {$aset}"
+  
+    ################################################################ 2.x.y.10
+    if {abs($r)>9223372036854775808 || [string length $r5]>15} continue
+    set rset {}
+    set aset {}
+    foreach rx $nums2 {
+      if "\$rx $op \$r0" {
+        lappend rset $rx
+      }
+    }
+    foreach rx [sort $rset] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.10 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r0 ORDER BY rowid"
+    puts "  \175"
+    puts "\175 {$aset}"
+  
+    ################################################################ 2.x.y.11
+    set aset {}
+    foreach rx [reverse [sort $rset]] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.11 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r0 ORDER BY rowid DESC"
+    puts "  \175"
+    puts "\175 {$aset}"
+
+
+    ################################################################ 2.x.y.12
+    set rset {}
+    set aset {}
+    foreach rx $nums2 {
+      if "\$rx $op \$r5" {
+        lappend rset $rx
+      }
+    }
+    foreach rx [sort $rset] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.12 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r5 ORDER BY rowid"
+    puts "  \175"
+    puts "\175 {$aset}"
+  
+    ################################################################ 2.x.y.13
+    set aset {}
+    foreach rx [reverse [sort $rset]] {
+      lappend aset $t1ra($rx)
+    }
+    puts "do_test $tname-2.$i.$subno.13 \173"
+    puts "  db eval \173"
+    puts "    SELECT a FROM t1 WHERE rowid $op $r5 ORDER BY rowid DESC"
+    puts "  \175"
+    puts "\175 {$aset}"
+  }
+  
+}
+
+
+puts {finish_test}

local-test-sqlite3-delta-03/afc-sqlite3/test/busy.test

@@ -0,0 +1,139 @@
+# 2005 july 8
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file test the busy handler
+#
+
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix busy
+
+do_test busy-1.1 {
+  sqlite3 db2 test.db
+  execsql {
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES(1);
+    SELECT * FROM t1
+  }
+} 1
+proc busy x {
+  lappend ::busyargs $x
+  if {$x>2} {return 1}
+  return 0
+}
+set busyargs {}
+do_test busy-1.2 {
+  db busy busy
+  db2 eval {BEGIN EXCLUSIVE}
+  catchsql {BEGIN IMMEDIATE}
+} {1 {database is locked}}
+do_test busy-1.3 {
+  set busyargs
+} {0 1 2 3}
+do_test busy-1.4 {
+  set busyargs {}
+  catchsql {BEGIN IMMEDIATE}
+  set busyargs
+} {0 1 2 3}
+
+do_test busy-2.1 {
+  db2 eval {COMMIT}
+  db eval {BEGIN; INSERT INTO t1 VALUES(5)}
+  db2 eval {BEGIN; SELECT * FROM t1}
+  set busyargs {}
+  catchsql COMMIT
+} {1 {database is locked}}
+do_test busy-2.2 {
+  set busyargs
+} {0 1 2 3}
+
+db2 close
+
+#-------------------------------------------------------------------------
+# Test that the busy-handler is invoked correctly for "PRAGMA optimize"
+# and ANALYZE commnds.
+ifcapable pragma&&analyze&&!stat4 {
+
+reset_db
+
+do_execsql_test 3.1 {
+  CREATE TABLE t1(x);
+  CREATE TABLE t2(y);
+  CREATE TABLE t3(z);
+
+  CREATE INDEX i1 ON t1(x);
+  CREATE INDEX i2 ON t2(y);
+
+  INSERT INTO t1 VALUES(1);
+  INSERT INTO t2 VALUES(1);
+  ANALYZE;
+
+  SELECT * FROM t1 WHERE x=1;
+  SELECT * FROM t2 WHERE y=1;
+} {1 1}
+
+do_test 3.2 {
+  sqlite3 db2 test.db
+  execsql { BEGIN EXCLUSIVE } db2
+  catchsql { PRAGMA optimize }
+} {1 {database is locked}}
+
+proc busy_handler {n} {
+  if {$n>1000} { execsql { COMMIT } db2 }
+  return 0
+}
+db busy busy_handler
+
+do_test 3.3 {
+  catchsql { PRAGMA optimize }
+} {0 {}}
+
+do_test 3.4 {
+  execsql {
+    BEGIN;
+    SELECT count(*) FROM sqlite_master;
+  } db2
+} {6}
+
+proc busy_handler {n} { return 1 }
+do_test 3.5 {
+  catchsql { PRAGMA optimize }
+} {1 {database is locked}}
+
+do_test 3.6 {
+  execsql { COMMIT } db2
+  execsql {
+    WITH s(i) AS (
+      SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<1000
+    )
+    INSERT INTO t1 SELECT i FROM s;
+  }
+  execsql {
+    BEGIN;
+    SELECT count(*) FROM sqlite_master;
+  } db2
+} {6}
+
+do_test 3.7 {
+  catchsql { PRAGMA optimize }
+} {1 {database is locked}}
+
+proc busy_handler {n} {
+  if {$n>1000} { execsql { COMMIT } db2 }
+  return 0
+}
+do_test 3.8 {
+  catchsql { PRAGMA optimize }
+} {0 {}}
+
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/capi2.test

@@ -0,0 +1,803 @@
+# 2003 January 29
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script testing the callback-free C/C++ API.
+#
+# $Id: capi2.test,v 1.37 2008/12/30 17:55:00 drh Exp $
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Return the text values from the current row pointed at by STMT as a list.
+proc get_row_values {STMT} {
+  set VALUES [list]
+  for {set i 0} {$i < [sqlite3_data_count $STMT]} {incr i} {
+    lappend VALUES [sqlite3_column_text $STMT $i]
+  }
+  return $VALUES
+}
+
+# Return the column names followed by declaration types for the result set
+# of the SQL statement STMT.
+#
+# i.e. for:
+# CREATE TABLE abc(a text, b integer); 
+# SELECT * FROM abc;
+#
+# The result is {a b text integer}
+proc get_column_names {STMT} {
+  set VALUES [list]
+  for {set i 0} {$i < [sqlite3_column_count $STMT]} {incr i} {
+    lappend VALUES [sqlite3_column_name $STMT $i]
+  }
+  for {set i 0} {$i < [sqlite3_column_count $STMT]} {incr i} {
+    lappend VALUES [sqlite3_column_decltype $STMT $i]
+  }
+  return $VALUES
+}
+
+# Check basic functionality
+#
+do_test capi2-1.1 {
+  set DB [sqlite3_connection_pointer db]
+  execsql {CREATE TABLE t1(a,b,c)}
+  set VM [sqlite3_prepare $DB {SELECT name, rowid FROM sqlite_master} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-1.2 {
+  sqlite3_step $VM
+} {SQLITE_ROW}
+do_test capi2-1.3 {
+  sqlite3_data_count $VM
+} {2}
+do_test capi2-1.4 {
+  get_row_values $VM
+} {t1 1}
+do_test capi2-1.5 {
+  get_column_names $VM
+} {name rowid TEXT INTEGER}
+do_test capi2-1.6 {
+  sqlite3_step $VM 
+} {SQLITE_DONE}
+do_test capi2-1.7 {
+  list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
+} {2 {} {name rowid TEXT INTEGER}}
+
+# This used to be SQLITE_MISUSE.  But now we automatically reset prepared
+# statements.
+ifcapable autoreset {
+  do_test capi2-1.8 {
+    sqlite3_step $VM
+  } {SQLITE_ROW}
+} else {
+  do_test capi2-1.8 {
+    sqlite3_step $VM
+  } {SQLITE_MISUSE}
+}
+
+# Update: In v2, once SQLITE_MISUSE is returned the statement handle cannot
+# be interrogated for more information. However in v3, since the column
+# count, names and types are determined at compile time, these are still
+# accessible after an SQLITE_MISUSE error.
+do_test capi2-1.9 {
+  sqlite3_reset $VM
+  list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
+} {2 {} {name rowid TEXT INTEGER}}
+do_test capi2-1.10 {
+  sqlite3_data_count $VM
+} {0}
+
+do_test capi2-1.11 {
+  sqlite3_finalize $VM
+} {SQLITE_OK}
+
+# Check to make sure that the "tail" of a multi-statement SQL script
+# is returned by sqlite3_prepare.
+#
+do_test capi2-2.1 {
+  set SQL {
+    SELECT name, rowid FROM sqlite_master;
+    SELECT name, rowid FROM sqlite_master WHERE 0;
+    -- A comment at the end
+  }
+  set VM [sqlite3_prepare $DB $SQL -1 SQL]
+  set SQL
+} {
+    SELECT name, rowid FROM sqlite_master WHERE 0;
+    -- A comment at the end
+  }
+do_test capi2-2.2 {
+  set r [sqlite3_step $VM]
+  lappend r [sqlite3_column_count $VM] \
+            [get_row_values $VM] \
+            [get_column_names $VM]
+} {SQLITE_ROW 2 {t1 1} {name rowid TEXT INTEGER}}
+do_test capi2-2.3 {
+  set r [sqlite3_step $VM]
+  lappend r [sqlite3_column_count $VM] \
+            [get_row_values $VM] \
+            [get_column_names $VM]
+} {SQLITE_DONE 2 {} {name rowid TEXT INTEGER}}
+do_test capi2-2.4 {
+  sqlite3_finalize $VM
+} {SQLITE_OK}
+do_test capi2-2.5 {
+  set VM [sqlite3_prepare $DB $SQL -1 SQL]
+  set SQL
+} {
+    -- A comment at the end
+  }
+do_test capi2-2.6 {
+  set r [sqlite3_step $VM]
+  lappend r [sqlite3_column_count $VM] \
+            [get_row_values $VM] \
+            [get_column_names $VM]
+} {SQLITE_DONE 2 {} {name rowid TEXT INTEGER}}
+do_test capi2-2.7 {
+  sqlite3_finalize $VM
+} {SQLITE_OK}
+do_test capi2-2.8 {
+  set VM [sqlite3_prepare $DB $SQL -1 SQL]
+  list $SQL $VM
+} {{} {}}
+
+# Check the error handling.
+#
+do_test capi2-3.1 {
+  set rc [catch {
+      sqlite3_prepare $DB {select bogus from sqlite_master} -1 TAIL
+  } msg]
+  lappend rc $msg $TAIL
+} {1 {(1) no such column: bogus} {}}
+do_test capi2-3.2 {
+  set rc [catch {
+      sqlite3_prepare $DB {select bogus from } -1 TAIL
+  } msg]
+  lappend rc $msg $TAIL
+} {1 {(1) incomplete input} {}}
+do_test capi2-3.3 {
+  set rc [catch {
+      sqlite3_prepare $DB {;;;;select bogus from sqlite_master} -1 TAIL
+  } msg]
+  lappend rc $msg $TAIL
+} {1 {(1) no such column: bogus} {}}
+do_test capi2-3.4 {
+  set rc [catch {
+      sqlite3_prepare $DB {select bogus from sqlite_master;x;} -1 TAIL
+  } msg]
+  lappend rc $msg $TAIL
+} {1 {(1) no such column: bogus} {x;}}
+do_test capi2-3.5 {
+  set rc [catch {
+      sqlite3_prepare $DB {select bogus from sqlite_master;;;x;} -1 TAIL
+  } msg]
+  lappend rc $msg $TAIL
+} {1 {(1) no such column: bogus} {;;x;}}
+do_test capi2-3.6 {
+  set rc [catch {
+      sqlite3_prepare $DB {select 5/0;} -1 TAIL
+  } VM]
+  lappend rc $TAIL
+} {0 {}}
+do_test capi2-3.7 {
+  list [sqlite3_step $VM] \
+       [sqlite3_column_count $VM] \
+       [get_row_values $VM] \
+       [get_column_names $VM]
+} {SQLITE_ROW 1 {{}} {5/0 {}}}
+do_test capi2-3.8 {
+  sqlite3_finalize $VM
+} {SQLITE_OK}
+do_test capi2-3.9 {
+  execsql {CREATE UNIQUE INDEX i1 ON t1(a)}
+  set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,2,3)} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-3.9b {db changes} {0}
+do_test capi2-3.10 {
+  list [sqlite3_step $VM] \
+       [sqlite3_column_count $VM] \
+       [get_row_values $VM] \
+       [get_column_names $VM]
+} {SQLITE_DONE 0 {} {}}
+
+# Update for v3 - the change has not actually happened until the query is
+# finalized. Is this going to cause trouble for anyone? Lee Nelson maybe?
+# (Later:) The change now happens just before SQLITE_DONE is returned.
+do_test capi2-3.10b {db changes} {1}
+do_test capi2-3.11 {
+  sqlite3_finalize $VM
+} {SQLITE_OK}
+do_test capi2-3.11b {db changes} {1}
+#do_test capi2-3.12-misuse {
+#  sqlite3_finalize $VM
+#} {SQLITE_MISUSE}
+do_test capi2-3.13 {
+  set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,3,4)} -1 TAIL]
+  list [sqlite3_step $VM] \
+       [sqlite3_column_count $VM] \
+       [get_row_values $VM] \
+       [get_column_names $VM]
+} {SQLITE_ERROR 0 {} {}}
+
+# Update for v3: Preparing a statement does not affect the change counter.
+# (Test result changes from 0 to 1).  (Later:) change counter updates occur
+# when sqlite3_step returns, not at finalize time.
+do_test capi2-3.13b {db changes} {0}
+
+do_test capi2-3.14 {
+  list [sqlite3_finalize $VM] [sqlite3_errmsg $DB] \
+       [sqlite3_extended_errcode $DB]
+} {SQLITE_CONSTRAINT {UNIQUE constraint failed: t1.a} SQLITE_CONSTRAINT_UNIQUE}
+do_test capi2-3.15 {
+  set VM [sqlite3_prepare $DB {CREATE TABLE t2(a NOT NULL, b)} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-3.16 {
+  list [sqlite3_step $VM] \
+       [sqlite3_column_count $VM] \
+       [get_row_values $VM] \
+       [get_column_names $VM]
+} {SQLITE_DONE 0 {} {}}
+do_test capi2-3.17 {
+  list [sqlite3_finalize $VM] [sqlite3_errmsg $DB]
+} {SQLITE_OK {not an error}}
+do_test capi2-3.18 {
+  set VM [sqlite3_prepare $DB {INSERT INTO t2 VALUES(NULL,2)} -1 TAIL]
+  list [sqlite3_step $VM] \
+       [sqlite3_column_count $VM] \
+       [get_row_values $VM] \
+       [get_column_names $VM]
+} {SQLITE_ERROR 0 {} {}}
+do_test capi2-3.19 {
+  list [sqlite3_finalize $VM] [sqlite3_errmsg $DB] \
+       [sqlite3_extended_errcode $DB]
+} {SQLITE_CONSTRAINT {NOT NULL constraint failed: t2.a} SQLITE_CONSTRAINT_NOTNULL}
+
+do_test capi2-3.20 {
+  execsql {
+    CREATE TABLE a1(message_id, name , UNIQUE(message_id, name) );
+    INSERT INTO a1 VALUES(1, 1);
+  }
+} {}
+do_test capi2-3.21 {
+  set VM [sqlite3_prepare $DB {INSERT INTO a1 VALUES(1, 1)} -1 TAIL]
+  sqlite3_step $VM
+} {SQLITE_ERROR}
+do_test capi2-3.22 {
+  sqlite3_errcode $DB
+} {SQLITE_ERROR}
+do_test capi2-3.23 {
+  sqlite3_finalize $VM
+} {SQLITE_CONSTRAINT}
+do_test capi2-3.24 {
+  list [sqlite3_errcode $DB] [sqlite3_extended_errcode $DB]
+} {SQLITE_CONSTRAINT SQLITE_CONSTRAINT_UNIQUE}
+
+# Two or more virtual machines exists at the same time.
+#
+do_test capi2-4.1 {
+  set VM1 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(1,2)} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-4.2 {
+  set VM2 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(2,3)} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-4.3 {
+  set VM3 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(3,4)} -1 TAIL]
+  set TAIL
+} {}
+do_test capi2-4.4 {
+  list [sqlite3_step $VM2] \
+       [sqlite3_column_count $VM2] \
+       [get_row_values $VM2] \
+       [get_column_names $VM2]
+} {SQLITE_DONE 0 {} {}}
+do_test capi2-4.5 {
+  execsql {SELECT * FROM t2 ORDER BY a}
+} {2 3}
+do_test capi2-4.6 {
+  sqlite3_finalize $VM2
+} {SQLITE_OK}
+do_test capi2-4.7 {
+  list [sqlite3_step $VM3] \
+       [sqlite3_column_count $VM3] \
+       [get_row_values $VM3] \
+       [get_column_names $VM3]
+} {SQLITE_DONE 0 {} {}}
+do_test capi2-4.8 {
+  execsql {SELECT * FROM t2 ORDER BY a}
+} {2 3 3 4}
+do_test capi2-4.9 {
+  sqlite3_finalize $VM3
+} {SQLITE_OK}
+do_test capi2-4.10 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_DONE 0 {} {}}
+do_test capi2-4.11 {
+  execsql {SELECT * FROM t2 ORDER BY a}
+} {1 2 2 3 3 4}
+do_test capi2-4.12 {
+  sqlite3_finalize $VM1
+} {SQLITE_OK}
+
+# Interleaved SELECTs
+#
+do_test capi2-5.1 {
+  set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
+  set VM2 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
+  set VM3 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 2 {2 3} {a b {} {}}}
+do_test capi2-5.2 {
+  list [sqlite3_step $VM2] \
+       [sqlite3_column_count $VM2] \
+       [get_row_values $VM2] \
+       [get_column_names $VM2]
+} {SQLITE_ROW 2 {2 3} {a b {} {}}}
+do_test capi2-5.3 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 2 {3 4} {a b {} {}}}
+do_test capi2-5.4 {
+  list [sqlite3_step $VM3] \
+       [sqlite3_column_count $VM3] \
+       [get_row_values $VM3] \
+       [get_column_names $VM3]
+} {SQLITE_ROW 2 {2 3} {a b {} {}}}
+do_test capi2-5.5 {
+  list [sqlite3_step $VM3] \
+       [sqlite3_column_count $VM3] \
+       [get_row_values $VM3] \
+       [get_column_names $VM3]
+} {SQLITE_ROW 2 {3 4} {a b {} {}}}
+do_test capi2-5.6 {
+  list [sqlite3_step $VM3] \
+       [sqlite3_column_count $VM3] \
+       [get_row_values $VM3] \
+       [get_column_names $VM3]
+} {SQLITE_ROW 2 {1 2} {a b {} {}}}
+do_test capi2-5.7 {
+  list [sqlite3_step $VM3] \
+       [sqlite3_column_count $VM3] \
+       [get_row_values $VM3] \
+       [get_column_names $VM3]
+} {SQLITE_DONE 2 {} {a b {} {}}}
+do_test capi2-5.8 {
+  sqlite3_finalize $VM3
+} {SQLITE_OK}
+do_test capi2-5.9 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 2 {1 2} {a b {} {}}}
+do_test capi2-5.10 {
+  sqlite3_finalize $VM1
+} {SQLITE_OK}
+do_test capi2-5.11 {
+  list [sqlite3_step $VM2] \
+       [sqlite3_column_count $VM2] \
+       [get_row_values $VM2] \
+       [get_column_names $VM2]
+} {SQLITE_ROW 2 {3 4} {a b {} {}}}
+do_test capi2-5.12 {
+  list [sqlite3_step $VM2] \
+       [sqlite3_column_count $VM2] \
+       [get_row_values $VM2] \
+       [get_column_names $VM2]
+} {SQLITE_ROW 2 {1 2} {a b {} {}}}
+do_test capi2-5.11 {
+  sqlite3_finalize $VM2
+} {SQLITE_OK}
+
+# Check for proper SQLITE_BUSY returns.
+#
+do_test capi2-6.1 {
+  execsql {
+    BEGIN;
+    CREATE TABLE t3(x counter);
+    INSERT INTO t3 VALUES(1);
+    INSERT INTO t3 VALUES(2);
+    INSERT INTO t3 SELECT x+2 FROM t3;
+    INSERT INTO t3 SELECT x+4 FROM t3;
+    INSERT INTO t3 SELECT x+8 FROM t3;
+    COMMIT;
+  }
+  set VM1 [sqlite3_prepare $DB {SELECT * FROM t3} -1 TAIL]
+  sqlite3 db2 test.db
+  execsql {BEGIN} db2
+} {}
+# Update for v3: BEGIN doesn't write-lock the database. It is quite
+# difficult to get v3 to write-lock the database, which causes a few
+# problems for test scripts.
+#
+# do_test capi2-6.2 {
+#   list [sqlite3_step $VM1] \
+#        [sqlite3_column_count $VM1] \
+#        [get_row_values $VM1] \
+#        [get_column_names $VM1]
+# } {SQLITE_BUSY 0 {} {}}
+do_test capi2-6.3 {
+  execsql {COMMIT} db2
+} {}
+do_test capi2-6.4 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 1 {x counter}}
+do_test capi2-6.5 {
+  catchsql {INSERT INTO t3 VALUES(10);} db2
+} {1 {database is locked}}
+do_test capi2-6.6 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 2 {x counter}}
+do_test capi2-6.7 {
+  execsql {SELECT * FROM t2} db2
+} {2 3 3 4 1 2}
+do_test capi2-6.8 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 3 {x counter}}
+do_test capi2-6.9 {
+  execsql {SELECT * FROM t2} 
+} {2 3 3 4 1 2}
+do_test capi2-6.10 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 4 {x counter}}
+do_test capi2-6.11 {
+  execsql {BEGIN}
+} {}
+do_test capi2-6.12 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 5 {x counter}}
+
+# A read no longer blocks a write in the same connection.
+#do_test capi2-6.13 {
+#  catchsql {UPDATE t3 SET x=x+1}
+#} {1 {database table is locked}}
+
+do_test capi2-6.14 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 6 {x counter}}
+do_test capi2-6.15 {
+  execsql {SELECT * FROM t1}
+} {1 2 3}
+do_test capi2-6.16 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 7 {x counter}}
+do_test capi2-6.17 {
+  catchsql {UPDATE t1 SET b=b+1}
+} {0 {}}
+do_test capi2-6.18 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 8 {x counter}}
+do_test capi2-6.19 {
+  execsql {SELECT * FROM t1}
+} {1 3 3}
+do_test capi2-6.20 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 9 {x counter}}
+#do_test capi2-6.21 {
+#  execsql {ROLLBACK; SELECT * FROM t1}
+#} {1 2 3}
+do_test capi2-6.22 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 10 {x counter}}
+#do_test capi2-6.23 {
+#  execsql {BEGIN TRANSACTION;}
+#} {}
+do_test capi2-6.24 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 11 {x counter}}
+do_test capi2-6.25 {
+  execsql {
+    INSERT INTO t1 VALUES(2,3,4);
+    SELECT * FROM t1;
+  }
+} {1 3 3 2 3 4}
+do_test capi2-6.26 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 12 {x counter}}
+do_test capi2-6.27 {
+  catchsql {
+    INSERT INTO t1 VALUES(2,4,5);
+    SELECT * FROM t1;
+  }
+} {1 {UNIQUE constraint failed: t1.a}}
+do_test capi2-6.28 {
+  list [sqlite3_step $VM1] \
+       [sqlite3_column_count $VM1] \
+       [get_row_values $VM1] \
+       [get_column_names $VM1]
+} {SQLITE_ROW 1 13 {x counter}}
+do_test capi2-6.99 {
+  sqlite3_finalize $VM1
+} {SQLITE_OK}
+catchsql {ROLLBACK}
+
+do_test capi2-7.1 {
+  stepsql $DB {
+    SELECT * FROM t1
+  }
+} {0 1 2 3}
+do_test capi2-7.2 {
+  stepsql $DB {
+    PRAGMA count_changes=on
+  }
+} {0}
+do_test capi2-7.3 {
+  stepsql $DB {
+    UPDATE t1 SET a=a+10;
+  }
+} {0 1}
+do_test capi2-7.4 {
+  stepsql $DB {
+    INSERT INTO t1 SELECT a+1,b+1,c+1 FROM t1;
+  }
+} {0 1}
+do_test capi2-7.4b {sqlite3_changes $DB} {1}
+do_test capi2-7.5 {
+  stepsql $DB {
+    UPDATE t1 SET a=a+10;
+  }
+} {0 2}
+do_test capi2-7.5b {sqlite3_changes $DB} {2}
+do_test capi2-7.6 {
+  stepsql $DB {
+    SELECT * FROM t1;
+  }
+} {0 21 2 3 22 3 4}
+do_test capi2-7.7 {
+  stepsql $DB {
+    INSERT INTO t1 SELECT a+2,b+2,c+2 FROM t1;
+  }
+} {0 2}
+do_test capi2-7.8 {
+  sqlite3_changes $DB
+} {2}
+do_test capi2-7.9 {
+  stepsql $DB {
+    SELECT * FROM t1;
+  }
+} {0 21 2 3 22 3 4 23 4 5 24 5 6}
+do_test capi2-7.10 {
+  stepsql $DB {
+    UPDATE t1 SET a=a-20;
+    SELECT * FROM t1;
+  }
+} {0 4 1 2 3 2 3 4 3 4 5 4 5 6}
+
+# Update for version 3: A SELECT statement no longer resets the change
+# counter (Test result changes from 0 to 4).
+do_test capi2-7.11 {
+  sqlite3_changes $DB
+} {4}
+do_test capi2-7.11a {
+  execsql {SELECT count(*) FROM t1}
+} {4}
+
+ifcapable {explain} {
+  do_test capi2-7.12 {
+    set x [stepsql $DB {EXPLAIN SELECT * FROM t1}]
+    lindex $x 0
+  } {0}
+}
+
+# Ticket #261 - make sure we can finalize before the end of a query.
+#
+do_test capi2-8.1 {
+  set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
+  sqlite3_finalize $VM1
+} {SQLITE_OK}
+  
+# Tickets #384 and #385 - make sure the TAIL argument to sqlite3_prepare
+# and all of the return pointers in sqlite_step can be null.
+#
+do_test capi2-9.1 {
+  set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 DUMMY]
+  sqlite3_step $VM1
+  sqlite3_finalize $VM1
+} {SQLITE_OK}
+
+# Test that passing a NULL pointer to sqlite3_finalize() or sqlite3_reset
+# does not cause an error.
+do_test capi2-10.1 {
+  sqlite3_finalize 0
+} {SQLITE_OK}
+do_test capi2-10.2 {
+  sqlite3_reset 0
+} {SQLITE_OK}
+
+#---------------------------------------------------------------------------
+# The following tests - capi2-11.* - test the "column origin" APIs.
+#
+#   sqlite3_column_origin_name()
+#   sqlite3_column_database_name()
+#   sqlite3_column_table_name()
+#
+
+ifcapable columnmetadata {
+
+# This proc uses the database handle $::DB to compile the SQL statement passed
+# as a parameter. The return value of this procedure is a list with one
+# element for each column returned by the compiled statement. Each element of
+# this list is itself a list of length three, consisting of the origin
+# database, table and column for the corresponding returned column.
+proc check_origins {sql} {
+  set ret [list]
+  set ::STMT [sqlite3_prepare $::DB $sql -1 dummy]
+  for {set i 0} {$i < [sqlite3_column_count $::STMT]} {incr i} {
+    lappend ret [list                           \
+      [sqlite3_column_database_name $::STMT $i] \
+      [sqlite3_column_table_name $::STMT $i]    \
+      [sqlite3_column_origin_name $::STMT $i]   \
+    ]
+  }
+  sqlite3_finalize $::STMT
+  return $ret
+}
+do_test capi2-11.1 {
+  execsql {
+    CREATE TABLE tab1(col1, col2);
+  }
+} {}
+do_test capi2-11.2 {
+  check_origins {SELECT col2, col1 FROM tab1}
+} [list {main tab1 col2} {main tab1 col1}]
+do_test capi2-11.3 {
+  check_origins {SELECT col2 AS hello, col1 AS world FROM tab1}
+} [list {main tab1 col2} {main tab1 col1}]
+
+ifcapable subquery {
+  do_test capi2-11.4 {
+    check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM tab1)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-11.5 {
+    check_origins {SELECT (SELECT col2 FROM tab1), (SELECT col1 FROM tab1)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-11.6 {
+    check_origins {SELECT (SELECT col2), (SELECT col1) FROM tab1}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-11.7 {
+    check_origins {SELECT * FROM tab1}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-11.8 {
+    check_origins {SELECT * FROM (SELECT * FROM tab1)}
+  } [list {main tab1 col1} {main tab1 col2}]
+}
+
+ifcapable view&&subquery {
+  do_test capi2-12.1 {
+    execsql {
+      CREATE VIEW view1 AS SELECT * FROM  tab1;
+    }
+  } {}
+  do_test capi2-12.2 {
+    check_origins {SELECT col2, col1 FROM view1}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-12.3 {
+    check_origins {SELECT col2 AS hello, col1 AS world FROM view1}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-12.4 {
+    check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM view1)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-12.5 {
+    check_origins {SELECT (SELECT col2 FROM view1), (SELECT col1 FROM view1)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-12.6 {
+    check_origins {SELECT (SELECT col2), (SELECT col1) FROM view1}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-12.7 {
+    check_origins {SELECT * FROM view1}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-12.8 {
+    check_origins {select * from (select * from view1)}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-12.9 {
+    check_origins {select * from (select * from (select * from view1))}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-12.10 {
+    db close
+    sqlite3 db test.db
+    set ::DB [sqlite3_connection_pointer db]
+    check_origins {select * from (select * from (select * from view1))}
+  } [list {main tab1 col1} {main tab1 col2}]
+  
+  # This view will thwart the flattening optimization.
+  do_test capi2-13.1 {
+    execsql {
+      CREATE VIEW view2 AS SELECT * FROM tab1 limit 10 offset 10;
+    }
+  } {}
+  do_test capi2-13.2 {
+    check_origins {SELECT col2, col1 FROM view2}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-13.3 {
+    check_origins {SELECT col2 AS hello, col1 AS world FROM view2}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-13.4 {
+    check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM view2)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-13.5 {
+    check_origins {SELECT (SELECT col2 FROM view2), (SELECT col1 FROM view2)}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-13.6 {
+    check_origins {SELECT (SELECT col2), (SELECT col1) FROM view2}
+  } [list {main tab1 col2} {main tab1 col1}]
+  do_test capi2-13.7 {
+    check_origins {SELECT * FROM view2}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-13.8 {
+    check_origins {select * from (select * from view2)}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-13.9 {
+    check_origins {select * from (select * from (select * from view2))}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-13.10 {
+    db close
+    sqlite3 db test.db
+    set ::DB [sqlite3_connection_pointer db]
+    check_origins {select * from (select * from (select * from view2))}
+  } [list {main tab1 col1} {main tab1 col2}]
+  do_test capi2-13.11 {
+    check_origins {select * from (select * from tab1 limit 10 offset 10)}
+  } [list {main tab1 col1} {main tab1 col2}]
+}
+
+
+} ;# ifcapable columnmetadata
+
+db2 close
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/carray01.test

@@ -0,0 +1,159 @@
+# 2020-11-17
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# 
+# This file implements tests for CARRAY extension
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix carray01
+
+ifcapable !vtab {
+  finish_test
+  return
+}
+load_static_extension db carray
+
+# Parameter $stmt must be a prepared statement created using
+# the sqlite3_prepare_v2 command and with parameters fully bound.
+# This routine simply runs the statement, gathers the result, and
+# returns a list containing the result.
+#
+# If the optional second argument is true, then the stmt is finalized
+# after it is run.
+#
+proc run_stmt {stmt} {
+  set r {}
+  while {[sqlite3_step $stmt]=="SQLITE_ROW"} {
+    for {set i 0} {$i<[sqlite3_data_count $stmt]} {incr i} {
+      lappend r [sqlite3_column_text $stmt $i]
+    }
+  }
+  sqlite3_reset $stmt
+  return $r
+}
+
+do_test 100 {
+  set STMT [sqlite3_prepare_v2 db {SELECT 5 IN carray(?3)} -1]
+  sqlite3_carray_bind $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 101 {
+  sqlite3_carray_bind -static $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 102 {
+  set STMT2 [sqlite3_prepare_v2 db {
+       SELECT DISTINCT typeof(value) FROM carray(?3)} -1]
+  sqlite3_carray_bind $STMT2 3 1 2 3 4 5 6 7
+  run_stmt $STMT2
+} {integer}
+do_test 110 {
+  sqlite3_carray_bind $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 120 {
+  sqlite3_carray_bind -int64 $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 120b {
+  sqlite3_carray_bind -int64 $STMT2 3 1 2 3 4 5 6 7
+  run_stmt $STMT2
+} {integer}
+do_test 121 {
+  sqlite3_carray_bind -int64 -transient $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 122 {
+  sqlite3_carray_bind -int64 -static $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 123 {
+  sqlite3_carray_bind -int32 -transient $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 124 {
+  sqlite3_carray_bind -int32 -static $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 125 {
+  sqlite3_carray_bind -int32 $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 130 {
+  sqlite3_carray_bind -int64 $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 131 {
+  sqlite3_carray_bind -int64 -transient $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 131 {
+  sqlite3_carray_bind -int64 -static $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 140 {
+  sqlite3_carray_bind -double $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 141 {
+  sqlite3_carray_bind -double -transient $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 142 {
+  sqlite3_carray_bind -double -static $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 143 {
+  sqlite3_carray_bind -double $STMT2 3 1 2 3 4 5 6 7
+  run_stmt $STMT2
+} {real}
+do_test 150 {
+  sqlite3_carray_bind -double $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 160 {
+  sqlite3_carray_bind -double $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {1}
+do_test 170 {
+  sqlite3_carray_bind -text -static $STMT 3 1 2 3 4 6 7
+  run_stmt $STMT
+} {0}
+do_test 171 {
+  sqlite3_carray_bind -text -static $STMT2 3 1 2 3 4 6 7
+  run_stmt $STMT2
+} {text}
+do_test 180 {
+  sqlite3_carray_bind -text -transient $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {0}
+do_test 190 {
+  sqlite3_carray_bind -blob -static $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {0}
+do_test 191 {
+  sqlite3_carray_bind -blob -static $STMT2 3 1 2 3 4 5 6 7
+  run_stmt $STMT2
+} {blob}
+do_test 200 {
+  sqlite3_carray_bind -blob -transient $STMT 3 1 2 3 4 5 6 7
+  run_stmt $STMT
+} {0}
+do_test 300 {
+  sqlite3_carray_bind $STMT 3
+  run_stmt $STMT
+} {0}
+
+sqlite3_finalize $STMT
+sqlite3_finalize $STMT2
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/coalesce.test

@@ -0,0 +1,84 @@
+# 2009 November 10
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# Additional test cases for the COALESCE() and IFNULL() functions.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+
+do_test coalesce-1.0 {
+  db eval {
+    CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
+    INSERT INTO t1 VALUES(1, null, null, null);
+    INSERT INTO t1 VALUES(2, 2, 99, 99);
+    INSERT INTO t1 VALUES(3, null, 3, 99);
+    INSERT INTO t1 VALUES(4, null, null, 4);
+    INSERT INTO t1 VALUES(5, null, null, null);
+    INSERT INTO t1 VALUES(6, 22, 99, 99);
+    INSERT INTO t1 VALUES(7, null, 33, 99);
+    INSERT INTO t1 VALUES(8, null, null, 44);
+
+    SELECT coalesce(b,c,d) FROM t1 ORDER BY a;
+  }
+} {{} 2 3 4 {} 22 33 44}
+do_test coalesce-1.1 {
+  db eval {
+    SELECT coalesce(d+c+b,d+c,d) FROM t1 ORDER BY a;
+  }
+} {{} 200 102 4 {} 220 132 44}
+do_test coalesce-1.2 {
+  db eval {
+    SELECT ifnull(d+c+b,ifnull(d+c,d)) FROM t1 ORDER BY a;
+  }
+} {{} 200 102 4 {} 220 132 44}
+do_test coalesce-1.3 {
+  db eval {
+    SELECT ifnull(ifnull(d+c+b,d+c),d) FROM t1 ORDER BY a;
+  }
+} {{} 200 102 4 {} 220 132 44}
+do_test coalesce-1.4 {
+  db eval {
+    SELECT ifnull(ifnull(b,c),d) FROM t1 ORDER BY a;
+  }
+} {{} 2 3 4 {} 22 33 44}
+do_test coalesce-1.5 {
+  db eval {
+    SELECT ifnull(b,ifnull(c,d)) FROM t1 ORDER BY a;
+  }
+} {{} 2 3 4 {} 22 33 44}
+do_test coalesce-1.6 {
+  db eval {
+    SELECT coalesce(b,NOT b,-b,abs(b),lower(b),length(b),min(b,5),b*123,c)
+      FROM t1 ORDER BY a;
+  }
+} {{} 2 3 {} {} 22 33 {}}
+do_test coalesce-1.7 {
+  db eval {
+    SELECT ifnull(nullif(a,4),99)
+      FROM t1 ORDER BY a;
+  }
+} {1 2 3 99 5 6 7 8}
+do_test coalesce-1.8 {
+  db eval {
+pragma vdbe_listing=on;
+    SELECT coalesce(
+      CASE WHEN b=2 THEN 123 END,
+      CASE WHEN b=3 THEN 234 END,
+      CASE WHEN c=3 THEN 345 WHEN c=33 THEN 456 END,
+      d
+    )
+    FROM t1 ORDER BY a;
+  }
+} {{} 123 345 4 {} 99 456 44}
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/collateB.test

@@ -0,0 +1,77 @@
+# 2016-07-01
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# Test cases for a crash bug.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix collateB
+
+do_execsql_test collateB-1.1 {
+  CREATE TABLE t1(a INTEGER PRIMARY KEY);
+  CREATE TABLE t2(b INTEGER PRIMARY KEY, x1 INT COLLATE NOCASE);
+  CREATE TABLE t3(x2 INT);
+  SELECT * FROM t3, t2, t1 WHERE x2=b AND x1=a AND a=1;
+} {}
+do_execsql_test collateB-1.2 {
+  INSERT INTO t1(a) VALUES(1),(2),(3);
+  INSERT INTO t2(b,x1) VALUES(11,1),(22,2),(33,3);
+  INSERT INTO t3(x2) VALUES(11),(22),(33);
+  SELECT *,'|' FROM t3, t2, t1 WHERE x2=b AND x1=a AND a=1;
+} {11 11 1 1 |}
+do_execsql_test collateB-1.3 {
+  SELECT *,'|' FROM t3, t1, t2 WHERE x2=b AND x1=a AND a=1;
+} {11 1 11 1 |}
+do_execsql_test collateB-1.4 {
+  SELECT *,'|' FROM t2, t3, t1 WHERE x2=b AND x1=a AND a=1;
+} {11 1 11 1 |}
+do_execsql_test collateB-1.5 {
+  SELECT *,'|' FROM t2, t1, t3 WHERE x2=b AND x1=a AND a=1;
+} {11 1 1 11 |}
+do_execsql_test collateB-1.6 {
+  SELECT *,'|' FROM t1, t2, t3 WHERE x2=b AND x1=a AND a=1;
+} {1 11 1 11 |}
+do_execsql_test collateB-1.7 {
+  SELECT *,'|' FROM t1, t2, t3 WHERE x2=b AND x1=a AND a=1;
+} {1 11 1 11 |}
+do_execsql_test collateB-1.12 {
+  SELECT *,'|' FROM t3, t2, t1 WHERE b=x2 AND a=x1 AND 1=a;
+} {11 11 1 1 |}
+do_execsql_test collateB-1.13 {
+  SELECT *,'|' FROM t3, t1, t2 WHERE b=x2 AND a=x1 AND 1=a;
+} {11 1 11 1 |}
+do_execsql_test collateB-1.14 {
+  SELECT *,'|' FROM t2, t3, t1 WHERE b=x2 AND a=x1 AND 1=a;
+} {11 1 11 1 |}
+do_execsql_test collateB-1.15 {
+  SELECT *,'|' FROM t2, t1, t3 WHERE b=x2 AND a=x1 AND 1=a;
+} {11 1 1 11 |}
+do_execsql_test collateB-1.16 {
+  SELECT *,'|' FROM t1, t2, t3 WHERE b=x2 AND a=x1 AND 1=a;
+} {1 11 1 11 |}
+do_execsql_test collateB-1.17 {
+  SELECT *,'|' FROM t1, t2, t3 WHERE b=x2 AND a=x1 AND 1=a;
+} {1 11 1 11 |}
+
+#-------------------------------------------------------------------------
+# Test an assert() failure that was occuring if an index were created
+# on a column explicitly declared "COLLATE binary".
+reset_db
+do_execsql_test 2.1 {
+  CREATE TABLE t4(a COLLATE binary);
+  CREATE INDEX i4 ON t4(a);
+  INSERT INTO t4 VALUES('one'), ('two'), ('three');
+  VACUUM;
+} 
+
+integrity_check 2.2
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/corrupt4.test

@@ -0,0 +1,149 @@
+# 2007 Sept 7
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests to make sure SQLite does not crash or
+# segfault if it sees a corrupt database file.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix corrupt4
+
+# This module uses hard-coded offsets which do not work if the reserved_bytes
+# value is nonzero.
+if {[nonzero_reserved_bytes]} {finish_test; return;}
+
+# These tests deal with corrupt database files
+#
+database_may_be_corrupt
+
+# We must have the page_size pragma for these tests to work.
+#
+ifcapable !pager_pragmas {
+  finish_test
+  return
+}
+
+# Create a database with a freelist containing at least two pages.
+#
+do_test corrupt4-1.1 {
+  set bigstring [string repeat 0123456789 200]
+  execsql {
+    PRAGMA auto_vacuum=OFF;
+    PRAGMA page_size=1024;
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES($bigstring);
+    CREATE TABLE t2(y);
+    INSERT INTO t2 VALUES(1);
+    DROP TABLE t1;
+  }
+  file size test.db
+} [expr {1024*4}]
+
+# Verify that there are two pages on the freelist.
+#
+do_test corrupt4-1.2 {
+  execsql {PRAGMA freelist_count}
+} {2}
+
+# Get the page number for the trunk of the freelist.
+#
+set trunkpgno [hexio_get_int [hexio_read test.db 32 4]]
+set baseaddr [expr {($trunkpgno-1)*1024}]
+
+# Verify that the trunk of the freelist has exactly one
+# leaf.
+#
+do_test corrupt4-1.3 {
+  hexio_get_int [hexio_read test.db [expr {$::baseaddr+4}] 4]
+} {1}
+
+# Insert a negative number as the number of leaves on the trunk.
+# Then try to add a new element to the freelist.
+#
+do_test corrupt4-1.4 {
+  hexio_write test.db [expr {$::baseaddr+4}] [hexio_render_int32 -100000000]
+  db close
+  sqlite3 db test.db
+  catchsql {
+    DROP TABLE t2
+  }
+} {1 {database disk image is malformed}}
+
+#-------------------------------------------------------------------------
+
+reset_db
+do_execsql_test 2.0 {
+  PRAGMA page_size = 512;
+  CREATE TABLE t1(a, b, c);
+}
+
+# Create a database with a schema so large that the root of the 
+# sqlite_schema table is the grandparent of its leaves.
+#
+set nView 1000
+do_test 2.1 {
+  execsql BEGIN
+  for {set ii 0} {$ii<$nView} {incr ii} {
+    execsql " CREATE VIEW v$ii AS SELECT a, b, c FROM t1 "
+  }
+  execsql COMMIT
+} {}
+db close
+
+proc get2byte {fd offset} {
+  seek $fd $offset
+  set bin [read $fd 2]
+  binary scan $bin S val
+  set val
+}
+proc get4byte {fd offset} {
+  seek $fd $offset
+  set bin [read $fd 4]
+  binary scan $bin I val
+  set val
+}
+proc put4byte {fd offset val} {
+  seek $fd $offset
+  set bin [binary format I $val]
+  puts -nonewline $fd $bin
+}
+
+# Page 1 is now the grandparent of its leaves. Corrupt the database by setting 
+# the second rightmost child page number of page 1 to 1.
+#
+set fd [open test.db r+]
+fconfigure $fd -translation binary
+set nChild [get2byte $fd 103]
+set offChild [get2byte $fd [expr 100+12+($nChild-2)*2]]
+set pgnoChild [get4byte $fd $offChild]
+put4byte $fd $offChild 1
+close $fd
+
+if {![info exists ::G(perm:presql)]} {
+  sqlite3 db test.db
+
+  do_catchsql_test 2.2 {
+    PRAGMA writable_schema = 1;
+    SELECT * FROM sqlite_schema;
+  } {1 {database disk image is malformed}}
+
+  do_test 2.3 {
+    list [catch {
+      for {set ii $nView} {$ii<$nView*2} {incr ii} {
+        execsql "INSERT INTO sqlite_master VALUES(1, 2, 3, 4, 5)"
+      }
+    } msg] $msg
+  } {1 {database disk image is malformed}}
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/crash6.test

@@ -0,0 +1,118 @@
+# 2001 September 15
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file tests that rollback journals for databases that use a 
+# page-size other than the default page-size can be rolled back Ok.
+#
+# $Id: crash6.test,v 1.2 2008/04/14 15:27:19 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !crashtest {
+  finish_test
+  return
+}
+
+for {set ii 0} {$ii < 10} {incr ii} {
+  catch {db close}
+  forcedelete test.db test.db-journal
+  crashsql -delay 2 -file test.db {
+    PRAGMA auto_vacuum=OFF;
+    PRAGMA page_size=4096;
+    BEGIN;
+    CREATE TABLE abc AS SELECT 1 AS a, 2 AS b, 3 AS c;
+    COMMIT;
+    BEGIN;
+    CREATE TABLE def AS SELECT 1 AS d, 2 AS e, 3 AS f;
+    COMMIT;
+  }
+  sqlite3 db test.db
+  integrity_check crash6-1.$ii
+}
+
+for {set ii 0} {$ii < 10} {incr ii} {
+  catch {db close}
+  forcedelete test.db test.db-journal
+  sqlite3 db test.db
+  execsql {
+    PRAGMA auto_vacuum=OFF;
+    PRAGMA page_size=2048;
+    BEGIN;
+    CREATE TABLE abc AS SELECT 1 AS a, 2 AS b, 3 AS c;
+    COMMIT;
+  }
+  db close
+  crashsql -delay 1 -file test.db {
+    INSERT INTO abc VALUES(5, 6, 7);
+  }
+  sqlite3 db test.db
+  integrity_check crash6-2.$ii
+}
+
+proc signature {} {
+  return [db eval {SELECT count(*), md5sum(a), md5sum(b), md5sum(c) FROM abc}]
+}
+
+# Test case for crashing during database sync with page-size values 
+# from 1024 to 8192.
+#
+for {set ii 0} {$ii < 30} {incr ii} {
+  db close
+  forcedelete test.db
+  sqlite3 db test.db
+
+  set pagesize [expr 1024 << ($ii % 4)]
+  if {$pagesize>$::SQLITE_MAX_PAGE_SIZE} {
+    set pagesize $::SQLITE_MAX_PAGE_SIZE
+  }
+  do_test crash6-3.$ii.0 {
+    execsql "pragma page_size = $pagesize"
+    execsql "pragma page_size"
+  } $pagesize
+
+  do_test crash6-3.$ii.1 {
+  
+    execsql BEGIN
+    execsql {CREATE TABLE abc(a, b, c)}
+    for {set n 0} {$n < 1000} {incr n} {
+      execsql "INSERT INTO abc VALUES($n, [expr 2*$n], [expr 3*$n])"
+    }
+    execsql {
+      INSERT INTO abc SELECT * FROM abc;
+      INSERT INTO abc SELECT * FROM abc;
+      INSERT INTO abc SELECT * FROM abc;
+      INSERT INTO abc SELECT * FROM abc;
+      INSERT INTO abc SELECT * FROM abc;
+    }
+    execsql COMMIT
+    expr ([file size test.db] / 1024) > 450
+  } {1}
+
+  set sig [signature]
+  db close
+
+  do_test crash6-3.$ii.2 {
+     crashsql -file test.db "
+       BEGIN;
+       SELECT random() FROM abc LIMIT $ii;
+       INSERT INTO abc SELECT randstr(10,10), 0, 0 FROM abc WHERE random()%2==0;
+       DELETE FROM abc WHERE random()%2!=0;
+       COMMIT;
+     "
+  } {1 {child process exited abnormally}}
+
+  do_test crash6-3.$ii.3 {
+    sqlite3 db test.db
+    signature
+  } $sig
+} 
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/crashM.test

@@ -0,0 +1,80 @@
+# 2015 Mar 13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Crash tests for the multiplex module with 8.3 filenames enabled.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix crashM
+
+ifcapable !crashtest||!8_3_names {
+  finish_test
+  return
+}
+
+db close
+sqlite3_shutdown
+sqlite3_config_uri 1
+
+foreach f [glob -nocomplain test1.* test2.*] { forcedelete $f }
+sqlite3_multiplex_initialize "" 1
+sqlite3 db file:test1.db?8_3_names=1
+sqlite3_multiplex_control db main chunk_size [expr 64*1024]
+
+do_execsql_test 1.0 {
+  ATTACH 'file:test2.db?8_3_names=1' AS aux;
+
+  CREATE TABLE t1(x, y);
+  CREATE INDEX t1x ON t1(x);
+  CREATE INDEX t1y ON t1(y);
+
+  CREATE TABLE aux.t2(x, y);
+  CREATE INDEX aux.t2x ON t2(x);
+  CREATE INDEX aux.t2y ON t2(y);
+
+  WITH s(a) AS (
+    SELECT 1 UNION ALL SELECT a+1 FROM s WHERE a<1000
+  )
+  INSERT INTO t1 SELECT a, randomblob(500) FROM s;
+
+  WITH s(a) AS (
+    SELECT 1 UNION ALL SELECT a+1 FROM s WHERE a<1000
+  )
+  INSERT INTO t2 SELECT a, randomblob(500) FROM s;
+} {}
+
+for {set i 0} {$i < 20} {incr i} {
+  do_test 2.$i.1 {
+    crashsql -delay 1 -file test1.db -opendb {
+      sqlite3_shutdown
+      sqlite3_config_uri 1
+      sqlite3_multiplex_initialize crash 1
+      sqlite3 db file:test1.db?8_3_names=1
+      sqlite3_multiplex_control db main chunk_size [expr 64*1024]
+    } {
+      ATTACH 'file:test2.db?8_3_names=1' AS aux;
+      BEGIN;
+        UPDATE t1 SET y = randomblob(500) WHERE (x%10)==0;
+        UPDATE t2 SET y = randomblob(500) WHERE (x%10)==0;
+      COMMIT;
+    }
+  } {1 {child process exited abnormally}}
+
+  do_execsql_test 2.$i.2 {
+    PRAGMA main.integrity_check;
+    PRAGMA aux.integrity_check;
+  } {ok ok}
+}
+
+catch { db close }
+sqlite3_multiplex_shutdown
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/ctime.test

@@ -0,0 +1,259 @@
+# 2009 February 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for the compile time diagnostic 
+# functions.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Test organization:
+#
+# ctime-1.*: Test pragma support.
+# ctime-2.*: Test function support.
+#
+
+ifcapable !pragma||!compileoption_diags {
+  finish_test
+  return
+}
+
+#####################
+# ctime-1.*: Test pragma support.
+
+do_test ctime-1.1.1 {
+  catchsql {
+    PRAGMA compile_options();
+  }
+} {1 {near ")": syntax error}}
+do_test ctime-1.1.2 {
+  catchsql {
+    PRAGMA compile_options(NULL);
+  }
+} {1 {near "NULL": syntax error}}
+do_test ctime-1.1.3 {
+  catchsql {
+    PRAGMA compile_options *;
+  }
+} {1 {near "*": syntax error}}
+
+do_test ctime-1.2.1 {
+  set ans [ catchsql {
+    PRAGMA compile_options;
+  } ]
+  list [ lindex $ans 0 ]
+} {0}
+# the results should be in sorted order already
+do_test ctime-1.2.2 {
+  set ans [ catchsql {
+    PRAGMA compile_options;
+  } ]
+  list [ lindex $ans 0 ] [ expr { [lsort [lindex $ans 1]]==[lindex $ans 1] } ]
+} {0 1}
+
+# Check the THREADSAFE option for SQLITE_THREADSAFE=2 builds (there are
+# a couple of these configurations in releasetest.tcl).
+#
+ifcapable threadsafe2 {
+  foreach {tn opt res} {
+    1 SQLITE_THREADSAFE     1
+    2 THREADSAFE            1
+    3 THREADSAFE=0          0
+    4 THREADSAFE=1          0
+    5 THREADSAFE=2          1
+    6 THREADSAFE=           0
+  } {
+    do_execsql_test ctime-1.3.$tn {
+      SELECT sqlite_compileoption_used($opt)
+    } $res
+  }
+}
+
+# SQLITE_THREADSAFE should pretty much always be defined
+# one way or the other, and it must have a value of 0 or 1.
+sqlite3_db_config db SQLITE_DBCONFIG_DQS_DML 1
+do_test ctime-1.4.1 {
+  catchsql {
+    SELECT sqlite_compileoption_used('SQLITE_THREADSAFE');
+  }
+} {0 1}
+do_test ctime-1.4.2 {
+  catchsql {
+    SELECT sqlite_compileoption_used('THREADSAFE');
+  }
+} {0 1}
+do_test ctime-1.4.3 {
+  catchsql {
+    SELECT sqlite_compileoption_used("THREADSAFE");
+  }
+} {0 1}
+
+do_test ctime-1.5 {
+  set ans1 [ catchsql {
+    SELECT sqlite_compileoption_used('THREADSAFE=0');
+  } ]
+  set ans2 [ catchsql {
+    SELECT sqlite_compileoption_used('THREADSAFE=1');
+  } ]
+  set ans3 [ catchsql {
+    SELECT sqlite_compileoption_used('THREADSAFE=2');
+  } ]
+  lsort [ list $ans1 $ans2 $ans3 ]
+} {{0 0} {0 0} {0 1}}
+
+do_test ctime-1.6 {
+  execsql {
+    SELECT sqlite_compileoption_used('THREADSAFE=');
+  }
+} {0}
+
+do_test ctime-1.7.1 {
+  execsql {
+    SELECT sqlite_compileoption_used('SQLITE_OMIT_COMPILEOPTION_DIAGS');
+  }
+} {0}
+do_test ctime-1.7.2 {
+  execsql {
+    SELECT sqlite_compileoption_used('OMIT_COMPILEOPTION_DIAGS');
+  }
+} {0}
+
+#####################
+# ctime-2.*: Test function support.
+
+do_test ctime-2.1.1 {
+  catchsql {
+    SELECT sqlite_compileoption_used();
+  }
+} {1 {wrong number of arguments to function sqlite_compileoption_used()}}
+do_test ctime-2.1.2 {
+  catchsql {
+    SELECT sqlite_compileoption_used(NULL);
+  }
+} {0 {{}}}
+do_test ctime-2.1.3 {
+  catchsql {
+    SELECT sqlite_compileoption_used("");
+  }
+} {0 0}
+do_test ctime-2.1.4 {
+  catchsql {
+    SELECT sqlite_compileoption_used('');
+  }
+} {0 0}
+do_test ctime-2.1.5 {
+  catchsql {
+    SELECT sqlite_compileoption_used(foo);
+  }
+} {1 {no such column: foo}}
+do_test ctime-2.1.6 {
+  catchsql {
+    SELECT sqlite_compileoption_used('THREADSAFE', 0);
+  }
+} {1 {wrong number of arguments to function sqlite_compileoption_used()}}
+do_test ctime-2.1.7 {
+  catchsql {
+    SELECT sqlite_compileoption_used(0);
+  }
+} {0 0}
+do_test ctime-2.1.8 {
+  catchsql {
+    SELECT sqlite_compileoption_used('0');
+  }
+} {0 0}
+do_test ctime-2.1.9 {
+  catchsql {
+    SELECT sqlite_compileoption_used(1.0);
+  }
+} {0 0}
+
+do_test ctime-2.2.1 {
+  catchsql {
+    SELECT sqlite_compileoption_get();
+  }
+} {1 {wrong number of arguments to function sqlite_compileoption_get()}}
+do_test ctime-2.2.2 {
+  catchsql {
+    SELECT sqlite_compileoption_get(0, 0);
+  }
+} {1 {wrong number of arguments to function sqlite_compileoption_get()}}
+
+# This assumes there is at least 1 compile time option
+# (see SQLITE_THREADSAFE above).
+do_test ctime-2.3 {
+  catchsql {
+    SELECT sqlite_compileoption_used(sqlite_compileoption_get(0));
+  }
+} {0 1}
+
+# This assumes there is at least 1 compile time option
+# (see SQLITE_THREADSAFE above).
+do_test ctime-2.4 {
+  set ans [ catchsql {
+    SELECT sqlite_compileoption_get(0);
+  } ]
+  list [lindex $ans 0]
+} {0}
+
+# Get the list of defines using the pragma,
+# then try querying each one with the functions.
+set ans [ catchsql {
+  PRAGMA compile_options;
+} ]
+set opts [ lindex $ans 1 ]
+set tc 1
+foreach opt $opts {
+  do_test ctime-2.5.$tc {
+    set N [ expr {$tc-1} ]
+    set ans1 [catch {db one {
+      SELECT sqlite_compileoption_get($N);
+    }} msg]
+    lappend ans1 $msg
+    set ans2 [ catchsql {
+      SELECT sqlite_compileoption_used($opt);
+    } ]
+    list [ lindex $ans1 0 ] [ expr { [lindex $ans1 1]==$opt } ] \
+         [ expr { $ans2 } ]
+  } {0 1 {0 1}}
+  incr tc 1
+}
+# test 1 past array bounds
+do_test ctime-2.5.$tc {
+  set N [ expr {$tc-1} ]
+  set ans [ catchsql {
+    SELECT sqlite_compileoption_get($N);
+  } ]
+} {0 {{}}}
+incr tc 1
+# test 1 before array bounds (N=-1)
+do_test ctime-2.5.$tc {
+  set N -1
+  set ans [ catchsql {
+    SELECT sqlite_compileoption_get($N);
+  } ]
+} {0 {{}}}
+
+#--------------------------------------------------------------------------
+# Test that SQLITE_DIRECT_OVERFLOW_READ is reflected in the output of
+# "PRAGMA compile_options".
+#
+ifcapable direct_read {
+  set res 1
+} else {
+  set res 0
+}
+do_test ctime-3.0.1 {
+  expr [lsearch [db eval {PRAGMA compile_options}] DIRECT_OVERFLOW_READ]>=0
+} $res
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/date4.test

@@ -0,0 +1,38 @@
+# 2023-08-29
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Test cases for the strftime() SQL function.  Comparisons against the
+# C-library strftime() function.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Skip this whole file if date and time functions are omitted
+# at compile-time
+#
+ifcapable {!datetime} {
+  finish_test
+  return
+}
+
+if {$tcl_platform(os)=="Linux"} {
+  set FMT {%d,%e,%F,%H,%k,%I,%l,%j,%m,%M,%u,%w,%W,%Y,%%,%P,%p,%U,%V,%G,%g}
+} else {
+  set FMT {%d,%e,%F,%H,%I,%j,%p,%R,%u,%w,%W,%%}
+}
+for {set i 0} {$i<=24858} {incr i} {
+  set TS [expr {$i*86390}]
+  do_execsql_test date4-$i {
+    SELECT strftime($::FMT,$::TS,'unixepoch');
+  } [list [strftime $FMT $TS]]
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/dbdata.test

@@ -0,0 +1,115 @@
+# 2019-04-11
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the sqlite_dbpage virtual table.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix dbdata
+
+ifcapable !vtab||!compound {
+  finish_test
+  return
+}
+if { [catch { db enable_load_extension 1 }]
+  || [catch { db eval { SELECT load_extension('../dbdata') } }] 
+} {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE TABLE T1(a, b);
+  INSERT INTO t1(rowid, a ,b) VALUES(5, 'v', 'five');
+  INSERT INTO t1(rowid, a, b) VALUES(10, 'x', 'ten');
+}
+
+do_execsql_test 1.1 {
+  SELECT pgno, cell, field, quote(value) FROM sqlite_dbdata WHERE pgno=2;
+} {
+  2 0 -1 5 
+  2 0  0 'v' 
+  2 0  1 'five' 
+  2 1 -1 10 
+  2 1  0 'x' 
+  2 1  1 'ten'
+}
+
+breakpoint
+do_execsql_test 1.2 {
+  SELECT pgno, cell, field, quote(value) FROM sqlite_dbdata;
+} {
+  1 0 -1 1 
+  1 0 0 'table' 
+  1 0 1 'T1' 
+  1 0 2 'T1' 
+  1 0 3 2 
+  1 0 4 {'CREATE TABLE T1(a, b)'}
+  2 0 -1 5 
+  2 0  0 'v' 
+  2 0  1 'five' 
+  2 1 -1 10 
+  2 1  0 'x' 
+  2 1  1 'ten'
+}
+
+set big [string repeat big 2000]
+do_execsql_test 1.3 {
+  INSERT INTO t1 VALUES(NULL, $big);
+  SELECT value FROM sqlite_dbdata WHERE pgno=2 AND cell=2 AND field=1;
+} $big
+
+do_execsql_test 1.4 {
+  DELETE FROM t1;
+  INSERT INTO t1 VALUES(NULL, randomblob(5050));
+}
+do_test 1.5 {
+  execsql {
+    SELECT quote(value) FROM sqlite_dbdata WHERE pgno=2 AND cell=0 AND field=1;
+  }
+} [db one {SELECT quote(b) FROM t1}]
+
+#-------------------------------------------------------------------------
+reset_db
+db enable_load_extension 1
+db eval { SELECT load_extension('../dbdata') }
+
+do_execsql_test 2.0 {
+  CREATE TABLE t1(a);
+  CREATE INDEX i1 ON t1(a);
+  WITH s(i) AS (
+    SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<10
+  )
+  INSERT INTO t1 SELECT randomblob(900) FROM s;
+}
+
+do_execsql_test 2.1 {
+  SELECT * FROM sqlite_dbptr WHERE pgno=2;
+} {
+  2 25   2 6   2 7   2 9   2 11   2 13   2 15   2 17   2 19   2 21
+}
+
+do_execsql_test 2.2 {
+  SELECT * FROM sqlite_dbptr WHERE pgno=3;
+} {
+  3 24   3 23
+}
+
+do_execsql_test 2.3 {
+  SELECT * FROM sqlite_dbptr
+} {
+  2 25   2 6   2 7   2 9   2 11   2 13   2 15   2 17   2 19   2 21
+  3 24   3 23
+}
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/dbfuzz001.test

@@ -0,0 +1,397 @@
+# 2012-12-13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Test cases for corrupt database files.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !deserialize {
+  finish_test
+  return
+}
+database_may_be_corrupt
+
+# In the following database file, there is 384 bytes of free space
+# on page 8 that does not appear on the freeblock list.
+#
+do_test dbfuzz001-100 {
+  sqlite3 db {}
+  db deserialize [decode_hexdb {
+    | size 5632 pagesize 512 filename c4.db
+    | page 1 offset 0
+    |      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
+    |     16: 02 00 01 01 00 40 20 20 00 00 00 02 00 00 00 0b   .....@  ........
+    |     32: 00 00 00 06 00 00 00 01 00 00 00 28 00 00 00 04   ...........(....
+    |     48: 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 00   ................
+    |     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02   ................
+    |     96: 00 2e 30 38 0d 00 00 00 06 01 06 00 01 da 01 b0   ..08............
+    |    112: 01 56 01 86 01 2a 01 06 00 00 00 00 00 00 00 00   .V...*..........
+    |    256: 00 00 00 00 00 00 22 07 06 17 11 11 01 31 74 61   ......"......1ta
+    |    272: 62 6c 65 74 34 74 34 07 43 52 45 41 54 45 20 54   blet4t4.CREATE T
+    |    288: 41 42 4c 45 20 74 34 28 78 29 2a 06 06 17 13 11   ABLE t4(x)*.....
+    |    304: 01 3f 69 6e 64 65 78 00 00 00 00 00 00 00 00 00   .?index.........
+    |    336: 20 74 33 28 78 29 2e 04 06 17 15 11 01 45 69 6e    t3(x).......Ein
+    |    352: 64 65 78 74 32 63 64 74 32 05 43 52 45 41 54 45   dext2cdt2.CREATE
+    |    368: 20 49 4e 44 45 58 20 74 32 63 64 20 4f 4e 20 74    INDEX t2cd ON t
+    |    384: 32 28 63 2c 64 29 28 05 06 17 11 11 01 3d 74 61   2(c,d)(......=ta
+    |    400: 62 6c 65 74 33 74 33 04 43 52 45 41 54 45 20 54   blet3t3.CREATE T
+    |    416: 41 42 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29   ABLE t3(c,x,e,f)
+    |    432: 28 02 06 17 11 11 01 3d 74 61 62 6c 65 74 32 74   (......=tablet2t
+    |    448: 32 03 43 52 45 41 54 45 20 54 41 42 4c 45 20 74   2.CREATE TABLE t
+    |    464: 32 28 63 2c 64 2c 65 2c 66 29 24 01 06 17 11 11   2(c,d,e,f)$.....
+    |    480: 01 35 74 61 62 6c 65 74 31 74 31 02 43 52 45 41   .5tablet1t1.CREA
+    |    496: 54 45 20 54 41 42 4c 45 20 74 31 28 61 2c 62 29   TE TABLE t1(a,b)
+    | page 2 offset 512
+    |      0: 0d 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00   ................
+    | page 3 offset 1024
+    |      0: 0d 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00   ................
+    | page 4 offset 1536
+    |      0: 05 00 00 00 03 01 f1 00 00 00 00 0b 01 fb 01 f6   ................
+    |     16: 01 f1 00 16 00 00 09 06 05 01 01 01 01 04 04 03   ................
+    |     32: 03 07 05 05 01 01 09 09 02 02 19 04 05 17 17 17   ................
+    |     48: 17 73 65 76 65 6e 65 69 67 68 74 65 69 67 68 74   .seveneighteight
+    |     64: 73 65 76 65 6e 25 03 05 07 07 07 07 40 14 00 00   seven%......@...
+    |     80: 00 00 00 00 40 18 00 00 00 00 00 00 40 18 00 00   ....@.......@...
+    |     96: 00 00 00 00 40 14 00 00 00 00 00 00 09 02 05 01   ....@...........
+    |    112: 01 01 01 03 04 04 03 07 01 05 09 01 01 09 02 02   ................
+    |    352: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1a   ................
+    |    496: 00 00 00 00 0a 3e 00 00 00 09 21 00 00 00 08 06   .....>....!.....
+    | page 5 offset 2048
+    |      0: 0a 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00   ................
+    | page 7 offset 3072
+    |      0: 0d 00 00 00 08 01 c2 00 01 fb 01 f6 01 f1 01 ec   ................
+    |     16: 01 e0 01 d4 01 cb 01 c2 00 00 00 00 00 00 00 00   ................
+    |     96: 00 00 00 00 13 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    224: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02   ................
+    |    288: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03   ................
+    |    448: 00 00 07 08 02 17 65 69 67 68 74 07 07 02 17 65   ......eight....e
+    |    464: 69 67 68 74 0a 06 02 07 40 18 00 00 00 00 00 00   ight....@.......
+    |    480: 0a 05 02 07 40 18 00 00 00 00 00 00 03 04 02 01   ....@...........
+    |    496: 04 03 03 02 01 04 03 02 02 01 02 03 01 02 01 02   ................
+    | page 8 offset 3584
+    |      0: 0d 00 21 00 01 00 16 00 00 16 00 16 00 16 00 16   ..!.............
+    |     16: 00 16 00 16 00 00 09 06 05 01 01 01 01 04 04 03   ................
+    |     32: 03 00 00 00 5f 01 09 09 02 02 00 00 00 56 17 17   ...._........V..
+    |     48: 17 73 65 76 65 6e 65 69 67 68 74 65 69 67 68 74   .seveneighteight
+    |     64: 73 65 76 65 6e 00 00 00 3b 07 07 07 40 14 00 00   seven...;...@...
+    |     80: 00 00 00 00 40 18 00 00 00 00 00 00 40 18 00 00   ....@.......@...
+    |     96: 00 00 00 00 40 14 00 00 00 00 00 00 00 00 00 14   ....@...........
+    |    112: 01 01 01 03 04 04 03 00 00 00 09 01 01 09 02 02   ................
+    |    352: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1a   ................
+    | page 9 offset 4096
+    |      0: 0d 00 00 00 1b 00 47 00 01 d9 01 be 01 af 01 a0   ......G.........
+    |     16: 01 91 01 82 01 73 01 64 01 55 01 46 01 37 01 28   .....s.d.U.F.7.(
+    |     32: 01 19 01 0a 00 fb 00 ec 00 dd 00 ce 00 bf 00 b0   ................
+    |     48: 00 a1 00 92 00 83 00 74 00 65 00 56 00 47 00 00   .......t.e.V.G..
+    |     64: 00 00 00 00 00 00 00 0d 21 00 00 48 01 54 00 01   ........!..H.T..
+    |     80: f7 01 ec 01 c5 01 0d 20 00 00 48 01 54 00 01 f7   ....... ..H.T...
+    |     96: 01 ec 01 c5 01 0d 1f 00 00 48 01 54 00 01 f7 01   .........H.T....
+    |    112: ec 01 c5 01 0d 1e 00 00 48 01 54 00 01 f7 01 ec   ........H.T.....
+    |    128: 01 c5 01 0d 1d 00 00 48 01 54 00 01 f7 01 ec 01   .......H.T......
+    |    144: c5 01 0d 1c 00 00 48 01 54 00 01 f7 01 ec 01 c5   ......H.T.......
+    |    160: 01 0d 1b 00 00 48 01 54 00 01 f7 01 ec 01 c5 01   .....H.T........
+    |    176: 0d 1a 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d   ....H.T.........
+    |    192: 19 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 18   ...H.T..........
+    |    208: 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 17 00   ..H.T...........
+    |    224: 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 16 00 00   .H.T............
+    |    240: 48 01 54 00 01 f7 01 ec 01 c5 01 0d 15 00 00 48   H.T............H
+    |    256: 01 54 00 01 f7 01 ec 01 c5 01 0d 14 00 00 48 01   .T............H.
+    |    272: 54 00 01 f7 01 ec 01 c5 01 0d 13 00 00 48 01 54   T............H.T
+    |    288: 00 01 f7 01 ec 01 c5 01 0d 12 00 00 48 01 54 00   ............H.T.
+    |    304: 01 f7 01 ec 01 c5 01 0d 11 00 00 48 01 54 00 01   ...........H.T..
+    |    320: f7 01 ec 01 c5 01 0d 10 00 00 48 01 54 00 01 f7   ..........H.T...
+    |    336: 01 ec 01 c5 01 0d 0f 00 00 48 01 54 00 01 f7 01   .........H.T....
+    |    352: ec 01 c5 01 0d 0e 00 00 48 01 54 00 01 f7 01 ec   ........H.T.....
+    |    368: 01 c5 01 0d 0d 00 00 48 01 54 00 01 f7 01 ec 01   .......H.T......
+    |    384: c5 01 0d 0c 00 00 48 01 54 00 01 f7 01 ec 01 c5   ......H.T.......
+    |    400: 01 0d 0b 00 00 48 01 54 00 01 f7 01 ec 01 c5 01   .....H.T........
+    |    416: 0d 0a 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d   ....H.T.........
+    |    432: 09 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 19 08   ...H.T..........
+    |    448: 05 17 17 17 17 65 69 67 68 74 65 69 67 68 74 73   .....eighteights
+    |    464: 65 76 65 6e 73 65 76 65 6e 25 07 05 07 07 07 07   evenseven%......
+    |    480: 40 18 00 00 00 00 00 00 40 18 00 00 00 00 00 00   @.......@.......
+    |    496: 40 14 00 00 00 00 00 00 40 14 00 00 00 00 00 00   @.......@.......
+    | page 10 offset 4608
+    |      0: 0d 00 00 00 1d 00 4d 00 01 f1 01 e2 01 d3 01 c4   ......M.........
+    |     16: 01 b5 01 a6 01 97 01 88 01 79 01 6a 01 5b 01 4c   .........y.j.[.L
+    |     32: 01 3d 01 2e 01 1f 01 10 01 01 00 f2 00 e3 00 d4   .=..............
+    |     48: 00 c5 00 b6 00 a7 00 98 00 89 00 7a 00 6b 00 5c   ...........z.k.\
+    |     64: 00 4d 00 00 00 00 00 00 00 00 00 00 00 0d 3e 00   .M............>.
+    |     80: 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 3d 00 00   .H.T.........=..
+    |     96: 48 01 54 00 01 f7 01 ec 01 c5 01 0d 3c 00 00 48   H.T.........<..H
+    |    112: 01 54 00 01 f7 01 ec 01 c5 01 0d 3b 00 00 48 01   .T.........;..H.
+    |    128: 54 00 01 f7 01 ec 01 c5 01 0d 3a 00 00 48 01 54   T.........:..H.T
+    |    144: 00 01 f7 01 ec 01 c5 01 0d 39 00 00 48 01 54 00   .........9..H.T.
+    |    160: 01 f7 01 ec 01 c5 01 0d 38 00 00 48 01 54 00 01   ........8..H.T..
+    |    176: f7 01 ec 01 c5 01 0d 37 00 00 48 01 54 00 01 f7   .......7..H.T...
+    |    192: 01 ec 01 c5 01 0d 36 00 00 48 01 54 00 01 f7 01   ......6..H.T....
+    |    208: ec 01 c5 01 0d 35 00 00 48 01 54 00 01 f7 01 ec   .....5..H.T.....
+    |    224: 01 c5 01 0d 34 00 00 48 01 54 00 01 f7 01 ec 01   ....4..H.T......
+    |    240: c5 01 0d 33 00 00 48 01 54 00 01 f7 01 ec 01 c5   ...3..H.T.......
+    |    256: 01 0d 32 00 00 48 01 54 00 01 f7 01 ec 01 c5 01   ..2..H.T........
+    |    272: 0d 31 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d   .1..H.T.........
+    |    288: 30 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 2f   0..H.T........./
+    |    304: 00 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 2e 00   ..H.T...........
+    |    320: 00 48 01 54 00 01 f7 01 ec 01 c5 01 0d 2d 00 00   .H.T.........-..
+    |    336: 48 01 54 00 01 f7 01 ec 01 c5 01 0d 2c 00 00 48   H.T.........,..H
+    |    352: 01 54 00 01 f7 01 ec 01 c5 01 0d 2b 00 00 48 01   .T.........+..H.
+    |    368: 54 00 01 f7 01 ec 01 c5 01 0d 2a 00 00 48 01 54   T.........*..H.T
+    |    384: 00 01 f7 01 ec 01 c5 01 0d 29 00 00 48 01 54 00   .........)..H.T.
+    |    400: 01 f7 01 ec 01 c5 01 0d 28 00 00 48 01 54 00 01   ........(..H.T..
+    |    416: f7 01 ec 01 c5 01 0d 27 00 00 48 01 54 00 01 f7   .......'..H.T...
+    |    432: 01 ec 01 c5 01 0d 26 00 00 48 01 54 00 01 f7 01   ......&..H.T....
+    |    448: ec 01 c5 01 0d 25 00 00 48 01 54 00 01 f7 01 ec   .....%..H.T.....
+    |    464: 01 c5 01 0d 24 00 00 48 01 54 00 01 f7 01 ec 01   ....$..H.T......
+    |    480: c5 01 0d 23 00 00 48 01 54 00 01 f7 01 ec 01 c5   ...#..H.T.......
+    |    496: 01 0d 22 00 00 48 01 54 00 01 f7 01 ec 01 c5 01   .."..H.T........
+    | page 11 offset 5120
+    |      0: 0d 00 00 00 0a 01 6a 00 01 f1 01 e2 01 d3 01 c4   ......j.........
+    |     16: 01 b5 01 a6 01 97 01 88 01 79 01 6a 00 00 00 00   .........y.j....
+    |    352: 00 00 00 00 00 00 00 00 00 00 0d 48 00 00 48 01   ...........H..H.
+    |    368: 54 00 01 f7 01 ec 01 c5 01 0d 47 00 00 48 01 54   T.........G..H.T
+    |    384: 00 01 f7 01 ec 01 c5 01 0d 46 00 00 48 01 54 00   .........F..H.T.
+    |    400: 01 f7 01 ec 01 c5 01 0d 45 00 00 48 01 54 00 01   ........E..H.T..
+    |    416: f7 01 ec 01 c5 01 0d 44 00 00 48 01 54 00 01 f7   .......D..H.T...
+    |    432: 01 ec 01 c5 01 0d 43 00 00 48 01 54 00 01 f7 01   ......C..H.T....
+    |    448: ec 01 c5 01 0d 42 00 00 48 01 54 00 01 f7 01 ec   .....B..H.T.....
+    |    464: 01 c5 01 0d 41 00 00 48 01 54 00 01 f7 01 ec 01   ....A..H.T......
+    |    480: c5 01 0d 40 00 00 48 01 54 00 01 f7 01 ec 01 c5   ...@..H.T.......
+    |    496: 01 0d 3f 00 00 48 01 54 00 01 f7 01 ec 01 c5 01   ..?..H.T........
+    | end c4.db
+  }]
+} {}
+
+ifcapable !oversize_cell_check {
+  # Non SQLITE_ENABLE_OVERSIZE_CELL_CHECK builds:
+  do_test dbfuzz001-101a {
+    db eval {PRAGMA writable_schema=on; PRAGMA integrity_check}
+  } {/Fragmentation of 384 bytes reported as 0 on page 8/}
+} else {
+  # SQLITE_ENABLE_OVERSIZE_CELL_CHECK builds:
+  do_catchsql_test dbfuzz001-101b {
+    PRAGMA writable_schema=on; 
+    PRAGMA integrity_check;
+  } {1 {database disk image is malformed}}
+}
+
+# The DELETE query below deletes the very last cell from page 8.
+# Prior to a certain fix to sqlite3BtreeDelete() and because of the
+# corruption to the freeblock list on page 8, this would fail to
+# cause a rebalance operation, which would leave the btree in a weird
+# state that would lead to segfaults and or assertion faults.
+#
+do_execsql_test dbfuzz001-110 {
+  DELETE FROM t3 WHERE x IS NOT NULL AND +rowid=6;
+} {}
+
+# This is a dbfuzz2-generate test case that can cause a page with
+# pPage->nCell==0 to enter the balancer.
+#
+do_test dbfuzz001-200 {
+  db deserialize [decode_hexdb {
+    | size 3076 pagesize 512 filename c03.db
+    | page 1 offset 0
+    |      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
+    |     16: 02 00 01 01 00 40 20 20 00 00 00 0c 00 00 00 07   .....@  ........
+    |     32: 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 04   ................
+    |     48: 00 00 00 00 00 00 00 03 e8 00 00 01 00 00 00 00   ................
+    |     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c   ................
+    |     96: 00 2e 2c 50 0d 00 00 00 06 01 06 00 01 da 01 b0   ..,P............
+    |    112: 01 56 01 86 01 2a 01 06 00 00 00 00 00 00 00 00   .V...*..........
+    |    128: 00 00 00 00 00 00 00 00 ef 00 00 00 00 00 00 00   ................
+    |    192: 00 7f 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    224: 00 00 00 00 00 00 00 00 00 00 00 00 00 ff e9 00   ................
+    |    256: 00 00 00 00 00 00 22 07 06 17 11 11 01 31 74 61   ......"......1ta
+    |    272: 62 6c 65 74 34 74 34 07 43 52 45 41 54 45 20 54   blet4t4.CREATE T
+    |    288: 41 42 4c 45 20 74 34 28 78 29 2a 06 06 17 13 11   ABLE t4(x)*.....
+    |    304: 01 3f 69 6e 64 65 78 74 33 78 74 33 06 43 52 45   .?indext3xt3.CRE
+    |    320: 41 54 45 20 49 4e 44 45 58 20 74 33 64 20 4f 4e   ATE INDEX t3d ON
+    |    336: 20 74 33 28 78 29 2e 04 06 17 15 11 01 45 69 6e    t3(x).......Ein
+    |    352: 64 65 78 74 32 63 64 74 32 05 43 52 45 41 54 45   dext2cdt2.CREATE
+    |    368: 20 49 4e 44 45 58 20 74 32 63 64 20 4f 4e 20 74    INDEX t2cd ON t
+    |    384: 32 28 63 2c 64 29 28 05 06 17 11 11 01 3d 74 61   2(c,d)(......=ta
+    |    400: 62 6c 65 74 33 74 33 04 43 52 45 41 54 45 20 54   blet3t3.CREATE T
+    |    416: 41 42 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29   ABLE t3(c,x,e,f)
+    |    432: 28 02 06 17 11 11 01 3d 74 61 62 6c 65 74 32 74   (......=tablet2t
+    |    448: 32 03 43 52 45 41 54 45 20 54 41 42 4c 45 20 74   2.CREATE TABLE t
+    |    464: 32 28 63 2c 64 2c 65 2c 66 29 24 01 06 17 11 11   2(c,d,e,f)$.....
+    |    480: 01 35 74 61 62 6c 65 74 31 74 31 02 43 52 45 41   .5tablet1t1.CREA
+    |    496: 54 45 20 54 41 42 4c 45 20 74 31 28 61 2c 62 29   TE TABLE t1(a,b)
+    | page 2 offset 512
+    |      0: 0d 00 00 00 04 01 cf 00 01 fa 01 f3 01 de 01 cf   ................
+    |    176: 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    256: 00 00 14 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    368: 00 00 00 00 00 00 00 00 00 00 00 00 1e 00 00 00   ................
+    |    416: 00 00 00 1b 00 00 00 00 04 00 00 00 00 00 00 00   ................
+    |    448: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0d   ................
+    |    464: 04 03 17 17 73 65 76 65 6e 65 69 67 68 74 13 03   ....seveneight..
+    |    480: 03 07 07 40 14 00 00 00 00 00 00 40 18 00 00 00   ...@.......@....
+    |    496: 00 00 00 05 02 03 01 01 03 04 04 01 03 09 01 02   ................
+    | page 3 offset 1024
+    |      0: 0d 00 00 00 08 01 54 00 01 f7 01 ec 01 c5 01 aa   ......T.........
+    |     16: 01 a1 01 96 01 6f 01 54 00 00 00 00 00 00 00 00   .....o.T........
+    |     32: 00 00 00 00 00 00 00 03 e8 00 00 00 00 00 00 00   ................
+    |    336: 00 00 00 00 19 08 05 16 17 17 17 65 69 67 68 74   ...........eight
+    |    352: 65 69 67 68 74 73 65 76 65 6e 73 65 76 ff ff ff   eightsevensev...
+    |    368: 0e 05 07 07 07 07 40 18 00 00 00 00 00 00 40 18   ......@.......@.
+    |    384: 00 00 00 00 00 00 40 14 00 00 00 00 00 00 40 14   ......@.......@.
+    |    400: 00 00 00 00 00 00 09 06 05 01 01 01 01 04 04 03   ................
+    |    416: 03 07 05 05 01 01 09 09 02 02 19 04 05 17 17 17   ................
+    |    432: 17 73 65 6f 65 6e 65 69 67 68 74 65 69 67 68 74   .seoeneighteight
+    |    448: 73 65 76 65 6e 25 03 05 07 07 07 07 40 14 00 00   seven%......@...
+    |    464: 00 00 00 00 40 18 00 00 00 00 00 00 40 18 00 00   ....@.......@...
+    |    480: 00 00 00 00 40 14 00 00 00 00 00 00 09 02 05 01   ....@...........
+    |    496: 01 01 01 03 04 04 03 07 01 05 09 01 01 09 02 02   ................
+    | page 4 offset 1536
+    |      0: 0d 00 00 00 00 00 10 00 00 00 00 00 00 00 00 00   ................
+    |    160: 00 00 00 ea 00 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    336: 00 00 00 00 00 00 00 00 00 00 00 00 20 00 00 00   ............ ...
+    | page 5 offset 2048
+    |      0: 0a 00 00 00 08 01 96 00 01 fa 01 c4 01 f2 01 bc   ................
+    |     16: 01 dc 01 a6 01 96 01 cc 00 00 00 00 00 00 00 00   ................
+    |     48: 00 00 00 00 00 00 00 00 00 00 10 00 00 00 00 00   ................
+    |    288: 00 00 00 00 00 00 00 00 00 64 00 00 00 2b 00 00   .........d...+..
+    |    400: 00 00 00 00 00 00 0f 04 17 17 01 65 69 67 68 74   ...........eight
+    |    416: 65 69 6f 68 74 08 15 04 07 07 01 40 18 00 00 00   eioht......@....
+    |    432: 00 00 00 40 18 00 00 00 00 00 00 07 07 04 01 01   ...@............
+    |    448: 01 04 04 06 07 04 01 01 01 02 02 05 0f 04 17 17   ................
+    |    464: 01 73 65 76 65 6e 65 69 67 68 74 04 15 04 07 07   .seveneight.....
+    |    480: 01 40 14 00 00 00 00 00 00 40 18 00 00 00 00 00   .@.......@......
+    |    496: 00 03 07 04 01 01 01 03 04 02 05 04 09 01 09 02   ................
+    | page 6 offset 2560
+    |      0: 0a 00 00 00 00 02 00 00 00 00 00 00 00 0d 00 00   ................
+    |     16: 00 08 01 c2 00 01 fb 01 f6 01 f1 01 ec 01 e0 01   ................
+    |     32: d4 01 cb 01 c2 00 00 00 00 00 00 00 00 00 00 00   ................
+    |    160: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 04 00   ................
+    |    448: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 07   ................
+    |    464: 08 02 17 65 69 67 68 74 07 07 02 17 65 69 67 68   ...eight....eigh
+    |    480: 74 0a 06 02 07 40 18 00 00 00 00 00 00 0a 05 02   t....@..........
+    |    496: 07 40 18 00 04 02 01 04 03 03 02 01 04 03 02 02   .@..............
+    | end x/c03.db
+  }]
+  catchsql {INSERT INTO t3 SELECT * FROM t2;}
+} {1 {database disk image is malformed}}
+
+
+do_test dbfuzz001-310 {
+  sqlite3 db {}
+  db deserialize [decode_hexdb {
+| size 3584 pagesize 512 filename x/c02.db
+| page 1 offset 0
+|      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
+|     16: 02 00 01 01 00 40 20 20 00 00 00 0c 00 00 00 07   .....@  ........
+|     32: 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 04   ................
+|     48: 00 00 00 00 00 00 00 04 00 00 00 01 00 00 00 00   ................
+|     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c   ................
+|     96: 00 2e 2c 50 0d 00 00 00 06 01 06 00 01 da 01 b0   ..,P............
+|    112: 01 56 01 86 01 2a 01 06 00 00 00 00 00 00 00 00   .V...*..........
+|    256: 00 00 00 00 00 00 22 07 06 17 11 11 01 31 74 61   ......"......1ta
+|    272: 62 6c 65 74 34 74 34 07 43 52 45 41 54 45 20 54   blet4t4.CREATE T
+|    288: 41 42 4c 45 20 74 34 28 78 29 2a 06 06 17 13 11   ABLE t4(x)*.....
+|    304: 01 3f 69 6e 64 65 78 74 33 78 74 33 05 43 52 45   .?indext3xt3.CRE
+|    320: 41 54 45 20 49 4e 44 45 58 20 74 33 78 20 4f 4e   ATE INDEX t3x ON
+|    336: 20 74 33 28 78 29 2e 04 06 17 15 11 01 45 69 6e    t3(x).......Ein
+|    352: 64 65 78 74 32 63 64 74 32 05 43 52 45 41 54 45   dext2cdt2.CREATE
+|    368: 20 49 4e 44 45 58 20 74 32 63 64 20 4f 4e 20 74    INDEX t2cd ON t
+|    384: 32 28 63 2c 64 29 28 05 06 17 11 11 01 3d 74 61   2(c,d)(......=ta
+|    400: 62 6c 65 74 33 74 33 07 43 52 45 41 54 45 20 54   blet3t3.CREATE T
+|    416: 41 42 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29   ABLE t3(c,x,e,f)
+|    432: 28 02 06 17 11 11 01 3d 74 61 62 6c 65 74 32 74   (......=tablet2t
+|    448: 32 32 43 52 45 41 54 45 20 54 41 42 4c 45 20 74   22CREATE TABLE t
+|    464: 32 28 63 2c 64 2c 65 2c 66 29 24 01 06 17 11 11   2(c,d,e,f)$.....
+|    480: 01 35 74 61 62 6c 65 74 31 74 31 02 43 52 45 41   .5tablet1t1.CREA
+|    496: 54 45 20 54 41 42 4c 45 20 74 31 28 61 2c 62 29   TE TABLE t1(a,b)
+| page 2 offset 512
+|      0: 0d 00 00 00 04 01 cf 00 01 fa 01 f3 01 de 01 cf   ................
+|    160: 00 00 20 00 00 00 00 00 00 00 00 00 00 00 00 00   .. .............
+|    448: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0d   ................
+|    464: 04 03 17 17 73 65 76 65 6e 65 69 67 68 74 13 03   ....seveneight..
+|    480: 03 07 07 40 14 00 00 00 00 00 00 40 18 00 00 00   ...@.......@....
+|    496: 00 00 00 05 02 03 01 01 03 04 04 01 03 09 01 02   ................
+| page 3 offset 1024
+|      0: 0d 00 00 00 08 01 54 00 01 f7 01 ec 01 c5 01 aa   ......T.........
+|     16: 01 a1 01 96 01 6f 01 54 00 00 00 00 00 00 00 00   .....o.T........
+|    112: 00 00 dd 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
+|    336: 00 00 00 00 19 08 05 17 17 17 17 65 69 67 68 74   ...........eight
+|    352: 65 69 67 68 74 73 65 76 65 6e 73 65 76 65 6e 25   eightsevenseven%
+|    368: 07 05 07 07 07 07 40 18 00 00 00 00 00 00 40 18   ......@.......@.
+|    384: 00 00 00 00 00 00 40 14 00 00 00 00 00 00 40 14   ......@.......@.
+|    400: 00 00 00 00 00 00 09 06 05 01 01 01 01 04 04 03   ................
+|    416: 03 07 05 05 01 01 09 09 02 02 19 04 05 17 17 17   ................
+|    432: 17 73 65 76 65 6e 65 69 67 68 74 65 69 67 68 74   .seveneighteight
+|    448: 73 65 76 65 6e 25 03 05 07 07 07 07 40 14 00 00   seven%......@...
+|    464: 00 00 00 00 40 18 00 00 00 00 00 00 40 18 00 00   ....@.......@...
+|    480: 00 00 00 00 40 14 00 00 00 00 00 00 09 02 05 01   ....@...........
+|    496: 01 01 01 03 04 04 03 07 01 05 09 01 01 09 02 02   ................
+| page 4 offset 1536
+|      0: 0d 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00   ................
+|    192: 00 00 00 00 00 00 7f 00 00 00 00 00 00 00 00 00   ................
+|    208: 00 e5 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
+| page 5 offset 2048
+|      0: 0a 00 00 00 08 01 96 00 01 fa 01 c4 01 f2 01 bc   ................
+|     16: 01 dc 01 a6 01 96 01 cc 00 00 00 00 00 00 00 00   ................
+|    240: 00 00 00 00 00 00 00 00 00 00 00 00 00 0e 00 00   ................
+|    400: 00 00 00 00 00 00 0f 04 17 07 01 65 69 67 68 74   ...........eight
+|    416: 65 69 67 68 74 08 15 04 07 07 01 40 18 00 00 00   eight......@....
+|    432: 00 00 00 40 18 00 00 00 00 00 00 07 07 04 01 01   ...@............
+|    448: 01 04 04 06 07 04 01 01 01 02 02 05 0f 04 17 17   ................
+|    464: 01 73 65 76 65 6e 65 69 67 68 74 04 15 04 07 07   .seveneight.....
+|    480: 01 40 14 00 00 00 00 00 00 40 18 00 00 00 00 00   .@.......@......
+|    496: 00 03 07 04 01 01 01 03 04 02 05 04 09 01 09 02   ................
+| page 6 offset 2560
+|      0: 0a 00 00 00 00 02 00 00 00 00 00 00 00 00 00 00   ................
+|    464: 00 00 00 00 00 00 00 00 00 00 7f 00 00 00 00 00   ................
+| page 7 offset 3072
+|      0: 0d 00 00 00 08 01 c2 00 01 fb 01 f6 01 f1 01 ec   ................
+|     16: 01 e0 01 d4 01 cb 01 c2 00 00 00 00 00 00 00 00   ................
+|    448: 00 00 07 08 02 17 65 69 67 68 74 07 07 02 17 65   ......eight....e
+|    464: 69 67 68 74 0a 06 02 07 40 18 00 00 00 00 00 00   ight....@.......
+|    480: 0a 05 02 07 40 18 00 00 00 00 00 00 03 04 02 01   ....@...........
+|    496: 04 03 03 02 01 04 03 02 02 01 02 03 01 02 01 02   ................
+| end x/c02.db
+  }]
+} {}
+
+extra_schema_checks 0
+do_catchsql_test dbfuzz001-320 {
+  PRAGMA integrity_check;
+} {1 {database disk image is malformed}}
+
+do_catchsql_test dbfuzz001-330 {
+  DELETE FROM t3 WHERE x IN (SELECT x FROM t4);
+} {1 {database disk image is malformed}}
+extra_schema_checks 1
+
+#-------------------------------------------------------------------------
+reset_db
+
+do_execsql_test dbfuzz001-430 {
+  CREATE TABLE t1(a INTEGER, b INT, c DEFAULT 0);
+}
+
+do_execsql_test dbfuzz001-420 {
+  PRAGMA locking_mode=EXCLUSIVE;
+  PRAGMA journal_mode = memory;
+  INSERT INTO t1 VALUES(1,2,3);
+  PRAGMA journal_mode=PERSIST;
+} {exclusive memory persist}
+
+do_execsql_test dbfuzz001-430 {
+  INSERT INTO t1 VALUES(4, 5, 6);
+}
+
+do_execsql_test dbfuzz001-440 {
+  PRAGMA journal_mode=MEMORY;
+  INSERT INTO t1 VALUES(7, 8, 9);
+} {memory}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/e_blobclose.test

@@ -0,0 +1,175 @@
+# 2014 October 30
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix e_blobclose
+
+ifcapable !incrblob {
+  finish_test
+  return
+}
+
+set dots [string repeat . 40]
+do_execsql_test 1.0 {
+  CREATE TABLE x1(a INTEGER PRIMARY KEY, b DOTS);
+  INSERT INTO x1 VALUES(-1, $dots);
+  INSERT INTO x1 VALUES(-10, $dots);
+  INSERT INTO x1 VALUES(-100, $dots);
+  INSERT INTO x1 VALUES(-1000, $dots);
+  INSERT INTO x1 VALUES(-10000, $dots);
+}
+
+# EVIDENCE-OF: R-03145-46390 This function closes an open BLOB handle.
+#
+#   It's not clear how to test that a blob handle really is closed.
+#   Attempting to use a closed blob handle will likely crash the process.
+#   Assume here that if the SHARED lock on the db file is released,
+#   the blob handle has been closed.
+#
+do_execsql_test 1.1 { PRAGMA lock_status } {main unlocked temp closed}
+sqlite3_blob_open db main x1 b -1 0 B
+do_execsql_test 1.2 { PRAGMA lock_status } {main shared temp closed}
+sqlite3_blob_close $B
+do_execsql_test 1.3 { PRAGMA lock_status } {main unlocked temp closed}
+
+
+# EVIDENCE-OF: R-34027-00617 If the blob handle being closed was opened
+# for read-write access, and if the database is in auto-commit mode and
+# there are no other open read-write blob handles or active write
+# statements, the current transaction is committed.
+#
+#   2.1.*: Transaction is not committed if there are other open 
+#          read-write blob handles.
+#
+#   2.2.*: Transaction is not committed if not in auto-commit mode.
+#
+#   2.3.*: Active write statements.
+#
+do_test 2.1.1 {
+  sqlite3_blob_open db main x1 b -100 1 B1
+  sqlite3_blob_open db main x1 b -1000 1 B2
+  sqlite3_blob_open db main x1 b -10000 1 B3
+  sqlite3_blob_open db main x1 b -10000 0 B4      ;# B4 is read-only!
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.1.2 {
+  sqlite3_blob_close $B1 
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.1.3 {
+  sqlite3_blob_close $B2 
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.1.4 {
+  sqlite3_blob_close $B3 
+  execsql { PRAGMA lock_status }
+} {main shared temp closed}
+do_test 2.1.5 {
+  sqlite3_blob_close $B4 
+  execsql { PRAGMA lock_status }
+} {main unlocked temp closed}
+
+do_test 2.2.1 {
+  sqlite3_blob_open db main x1 b -100 1 B1
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.2.2 {
+  execsql { BEGIN }
+  sqlite3_blob_close $B1 
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.2.3 {
+  execsql { COMMIT }
+  execsql { PRAGMA lock_status }
+} {main unlocked temp closed}
+
+proc val {} { 
+  sqlite3_blob_close $::B 
+  db eval { PRAGMA lock_status }
+}
+db func val val
+do_test 2.3.1 {
+  sqlite3_blob_open db main x1 b -100 1 B
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.3.2 {
+  execsql { INSERT INTO x1 VALUES(15, val()) }
+  execsql { PRAGMA lock_status }
+} {main unlocked temp closed}
+do_test 2.3.3 {
+  execsql { SELECT * FROM x1 WHERE a = 15 }
+} {15 {main reserved temp closed}}
+
+# A reader does not inhibit commit.
+do_test 2.3.4 {
+  sqlite3_blob_open db main x1 b -100 1 B
+  execsql { PRAGMA lock_status }
+} {main reserved temp closed}
+do_test 2.3.5 {
+  execsql { SELECT a, val() FROM x1 LIMIT 1 }
+} {-10000 {main shared temp closed}}
+
+
+do_test 3.1 {
+  sqlite3_blob_open db main x1 b -10 1 B
+  execsql {
+    INSERT INTO x1 VALUES(1, 'abc');
+    SELECT * FROM x1 WHERE a=1;
+  }
+} {1 abc}
+do_test 3.2 {
+  sqlite3_blob_write $B 0 "abcdefghij" 10
+  execsql { SELECT * FROM x1 WHERE a=-10 }
+} {-10 abcdefghij..............................}
+
+do_test 3.3 {
+  sqlite3 db2 test.db
+  execsql { BEGIN ; SELECT * FROM x1 } db2
+  sqlite3_blob_close $B 
+} {SQLITE_BUSY}
+
+# EVIDENCE-OF: R-41959-38737 Otherwise, if this function is passed a
+# valid open blob handle, the values returned by the sqlite3_errcode()
+# and sqlite3_errmsg() functions are set before returning.
+#
+do_test 3.4 {
+  list [sqlite3_errcode db] [sqlite3_errmsg db]
+} {SQLITE_BUSY {database is locked}}
+
+# EVIDENCE-OF: R-37801-37633 The BLOB handle is closed unconditionally.
+# Even if this routine returns an error code, the handle is still
+# closed.
+#
+#   Test that the lock has been released. Assume this means the handle
+#   is closed, even though blob_close() returned SQLITE_BUSY.
+#
+do_execsql_test 3.4 { PRAGMA lock_status } {main unlocked temp closed}
+
+# EVIDENCE-OF: R-35111-05628 If an error occurs while committing the
+# transaction, an error code is returned and the transaction rolled
+# back.
+#
+#   Row 1 is removed (it was inserted this transaction) and row -10
+#   is restored to its original state. Transaction has been rolled back.
+#
+do_execsql_test 3.5 {
+  SELECT * FROM x1 WHERE a IN (1, -10);
+} {-10 ........................................}
+
+# EVIDENCE-OF: R-25894-51060 Calling this routine with a null pointer
+# (such as would be returned by a failed call to sqlite3_blob_open()) is
+# a harmless no-op.
+#
+do_test 4.0 { sqlite3_blob_close 0 } {}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/e_vacuum.test

@@ -0,0 +1,347 @@
+# 2010 September 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests to verify that the "testable statements" in 
+# the lang_vacuum.html document are correct.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+sqlite3_test_control_pending_byte 0x1000000
+
+proc create_db {{sql ""}} {
+  catch { db close }
+  forcedelete test.db
+  sqlite3 db test.db
+
+  db transaction {
+    execsql { PRAGMA page_size = 1024; }
+    execsql $sql
+    execsql {
+      CREATE TABLE t1(a PRIMARY KEY, b UNIQUE);
+      INSERT INTO t1 VALUES(1, randomblob(400));
+      INSERT INTO t1 SELECT a+1,  randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+2,  randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+4,  randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+8,  randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+16, randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+32, randomblob(400) FROM t1;
+      INSERT INTO t1 SELECT a+64, randomblob(400) FROM t1;
+
+      CREATE TABLE t2(a PRIMARY KEY, b UNIQUE);
+      INSERT INTO t2 SELECT * FROM t1;
+    }
+  }
+
+  return [expr {[file size test.db] / 1024}]
+}
+
+# This proc returns the number of contiguous blocks of pages that make up
+# the table or index named by the only argument. For example, if the table
+# occupies database pages 3, 4, 8 and 9, then this command returns 2 (there
+# are 2 fragments - one consisting of pages 3 and 4, the other of fragments
+# 8 and 9).
+#
+proc fragment_count {name} {
+  execsql { CREATE VIRTUAL TABLE temp.stat USING dbstat }
+  set nFrag 1
+  db eval {SELECT pageno FROM stat WHERE name = 't1' ORDER BY pageno} {
+    if {[info exists prevpageno] && $prevpageno != $pageno-1} {
+      incr nFrag
+    }
+    set prevpageno $pageno
+  }
+  execsql { DROP TABLE temp.stat }
+  set nFrag
+}
+
+
+# -- syntax diagram vacuum-stmt
+#
+do_execsql_test e_vacuum-0.1 { VACUUM } {}
+
+# EVIDENCE-OF: R-51469-36013 Unless SQLite is running in
+# "auto_vacuum=FULL" mode, when a large amount of data is deleted from
+# the database file it leaves behind empty space, or "free" database
+# pages.
+#
+# EVIDENCE-OF: R-60541-63059 Running VACUUM to rebuild the database
+# reclaims this space and reduces the size of the database file.
+#
+foreach {tn avmode sz} {
+  1 none        7 
+  2 full        8 
+  3 incremental 8
+} {
+  set nPage [create_db "PRAGMA auto_vacuum = $avmode"]
+
+  do_execsql_test e_vacuum-1.1.$tn.1 {
+    DELETE FROM t1;
+    DELETE FROM t2;
+  } {}
+
+  if {$avmode == "full"} {
+    # This branch tests the "unless ... auto_vacuum=FULL" in the requirement
+    # above. If auto_vacuum is set to FULL, then no empty space is left in
+    # the database file.
+    do_execsql_test e_vacuum-1.1.$tn.2 {PRAGMA freelist_count} 0
+  } else {
+    set freelist [expr {$nPage - $sz}]
+    if {$avmode == "incremental"} { 
+      # The page size is 1024 bytes. Therefore, assuming the database contains
+      # somewhere between 207 and 411 pages (it does), there are 2 pointer-map
+      # pages.
+      incr freelist -2
+    }
+    do_execsql_test e_vacuum-1.1.$tn.3 {PRAGMA freelist_count} $freelist
+    do_execsql_test e_vacuum-1.1.$tn.4 {VACUUM} {}
+  }
+
+  do_test e_vacuum-1.1.$tn.5 { expr {[file size test.db] / 1024} } $sz
+}
+
+# EVIDENCE-OF: R-50943-18433 Frequent inserts, updates, and deletes can
+# cause the database file to become fragmented - where data for a single
+# table or index is scattered around the database file.
+#
+# EVIDENCE-OF: R-05791-54928 Running VACUUM ensures that each table and
+# index is largely stored contiguously within the database file.
+#
+#   e_vacuum-1.2.1 - Perform many INSERT, UPDATE and DELETE ops on table t1.
+#   e_vacuum-1.2.2 - Verify that t1 and its indexes are now quite fragmented.
+#   e_vacuum-1.2.3 - Run VACUUM.
+#   e_vacuum-1.2.4 - Verify that t1 and its indexes are now much 
+#                    less fragmented.
+#
+ifcapable vtab&&compound {
+  create_db 
+  register_dbstat_vtab db
+  do_execsql_test e_vacuum-1.2.1 {
+    DELETE FROM t1 WHERE a%2;
+    INSERT INTO t1 SELECT b, a FROM t2 WHERE a%2;
+    UPDATE t1 SET b=randomblob(600) WHERE (a%2)==0;
+  } {}
+  
+  do_test e_vacuum-1.2.2.1 { expr [fragment_count t1]>100 } 1
+  do_test e_vacuum-1.2.2.2 { expr [fragment_count sqlite_autoindex_t1_1]>100 } 1
+  do_test e_vacuum-1.2.2.3 { expr [fragment_count sqlite_autoindex_t1_2]>100 } 1
+  
+  do_execsql_test e_vacuum-1.2.3 { VACUUM } {}
+  
+  # In practice, the tables and indexes each end up stored as two fragments -
+  # one containing the root page and another containing all other pages.
+  #
+  do_test e_vacuum-1.2.4.1 { fragment_count t1 }                    2
+  do_test e_vacuum-1.2.4.2 { fragment_count sqlite_autoindex_t1_1 } 2
+  do_test e_vacuum-1.2.4.3 { fragment_count sqlite_autoindex_t1_2 } 2
+}
+
+# EVIDENCE-OF: R-20474-44465 Normally, the database page_size and
+# whether or not the database supports auto_vacuum must be configured
+# before the database file is actually created.
+#
+do_test e_vacuum-1.3.1.1 {
+  create_db "PRAGMA page_size = 1024 ; PRAGMA auto_vacuum = FULL"
+  execsql { PRAGMA page_size ; PRAGMA auto_vacuum }
+} {1024 1}
+do_test e_vacuum-1.3.1.2 {
+  execsql { PRAGMA page_size = 2048 }
+  execsql { PRAGMA auto_vacuum = NONE }
+  execsql { PRAGMA page_size ; PRAGMA auto_vacuum }
+} {1024 1}
+
+if {![nonzero_reserved_bytes]} {
+  # EVIDENCE-OF: R-08570-19916 However, when not in write-ahead log mode,
+  # the page_size and/or auto_vacuum properties of an existing database
+  # may be changed by using the page_size and/or pragma auto_vacuum
+  # pragmas and then immediately VACUUMing the database.
+  #
+  do_test e_vacuum-1.3.2.1 {
+    execsql { PRAGMA journal_mode = delete }
+    execsql { PRAGMA page_size = 2048 }
+    execsql { PRAGMA auto_vacuum = NONE }
+    execsql VACUUM
+    execsql { PRAGMA page_size ; PRAGMA auto_vacuum }
+  } {2048 0}
+  
+  # EVIDENCE-OF: R-48521-51450 When in write-ahead log mode, only the
+  # auto_vacuum support property can be changed using VACUUM.
+  #
+  if {[wal_is_capable]} {
+    do_test e_vacuum-1.3.3.1 {
+      execsql { PRAGMA journal_mode = wal }
+      execsql { PRAGMA page_size ; PRAGMA auto_vacuum }
+    } {2048 0}
+    do_test e_vacuum-1.3.3.2 {
+      execsql { PRAGMA page_size = 1024 }
+      execsql { PRAGMA auto_vacuum = FULL }
+      execsql VACUUM
+      execsql { PRAGMA page_size ; PRAGMA auto_vacuum }
+    } {2048 1}
+  }
+}
+  
+# EVIDENCE-OF: R-40347-36128 By default, VACUUM operates on the main
+# database.
+forcedelete test.db2
+create_db { PRAGMA auto_vacuum = NONE }
+do_execsql_test e_vacuum-2.1.1 {
+  ATTACH 'test.db2' AS aux;
+  PRAGMA aux.page_size = 1024;
+  CREATE TABLE aux.t3 AS SELECT * FROM t1;
+  DELETE FROM t3;
+} {}
+set original_size [file size test.db2]
+
+# Vacuuming the main database does not affect aux
+do_execsql_test e_vacuum-2.1.3 { VACUUM } {}
+do_test e_vacuum-2.1.6 { expr {[file size test.db2]==$::original_size} } 1
+
+# EVIDENCE-OF: R-36598-60500 Attached databases can be vacuumed by
+# appending the appropriate schema-name to the VACUUM statement.
+do_execsql_test e_vacuum-2.1.7 { VACUUM aux; } {}
+do_test e_vacuum-2.1.8 { expr {[file size test.db2]<$::original_size} } 1
+
+# EVIDENCE-OF: R-17495-17419 The VACUUM command may change the ROWIDs of
+# entries in any tables that do not have an explicit INTEGER PRIMARY
+# KEY.
+#
+#   Tests e_vacuum-3.1.1 - 3.1.2 demonstrate that rowids can change when
+#   a database is VACUUMed. Tests e_vacuum-3.1.3 - 3.1.4 show that adding
+#   an INTEGER PRIMARY KEY column to a table stops this from happening.
+#
+#   Update 2019-01-07:  Rowids are now preserved by VACUUM.
+#
+do_execsql_test e_vacuum-3.1.1 {
+  CREATE TABLE t4(x);
+  INSERT INTO t4(x) VALUES('x');
+  INSERT INTO t4(x) VALUES('y');
+  INSERT INTO t4(x) VALUES('z');
+  DELETE FROM t4 WHERE x = 'y';
+  SELECT rowid, x FROM t4;
+} {1 x 3 z}
+do_execsql_test e_vacuum-3.1.2 {
+  VACUUM;
+  SELECT rowid, x FROM t4;
+} {1 x 2 z}
+
+# Rowids are preserved if an INTEGER PRIMARY KEY is used
+do_execsql_test e_vacuum-3.1.3 {
+  CREATE TABLE t5(x, y INTEGER PRIMARY KEY);
+  INSERT INTO t5(x) VALUES('x');
+  INSERT INTO t5(x) VALUES('y');
+  INSERT INTO t5(x) VALUES('z');
+  DELETE FROM t5 WHERE x = 'y';
+  SELECT rowid, x FROM t5;
+} {1 x 3 z}
+do_execsql_test e_vacuum-3.1.4 {
+  VACUUM;
+  SELECT rowid, x FROM t5;
+} {1 x 3 z}
+
+# Rowid is preserved for VACUUM INTO
+do_execsql_test e_vacuum-3.1.5 {
+  DROP TABLE t5;
+  CREATE TABLE t5(x);
+  INSERT INTO t5(x) VALUES('x');
+  INSERT INTO t5(x) VALUES('y');
+  INSERT INTO t5(x) VALUES('z');
+  DELETE FROM t5 WHERE x = 'y';
+  SELECT rowid, x FROM t5;
+} {1 x 3 z}
+forcedelete test2.db
+do_execsql_test e_vacuum-3.1.6 {
+  VACUUM INTO 'test2.db';
+  ATTACH 'test2.db' AS aux1;
+  SELECT rowid, x FROM aux1.t5;
+  DETACH aux1;
+} {1 x 3 z}
+
+# Rowids are not renumbered if the table being vacuumed
+# has indexes.
+do_execsql_test e_vacuum-3.1.7 {
+  DROP TABLE t5;
+  CREATE TABLE t5(x,y,z);
+  INSERT INTO t5(x) VALUES('x');
+  INSERT INTO t5(x) VALUES('y');
+  INSERT INTO t5(x) VALUES('z');
+  UPDATE t5 SET y=x, z=random();
+  DELETE FROM t5 WHERE x = 'y';
+  CREATE INDEX t5x ON t5(x);
+  CREATE UNIQUE INDEX t5y ON t5(y);
+  CREATE INDEX t5zxy ON t5(z,x,y);
+  SELECT rowid, x FROM t5;
+} {1 x 3 z}
+do_execsql_test e_vacuum-3.1.8 {
+  VACUUM;
+  SELECT rowid, x FROM t5;
+} {1 x 3 z}
+
+# EVIDENCE-OF: R-12218-18073 A VACUUM will fail if there is an open
+# transaction on the database connection that is attempting to run the
+# VACUUM.
+#
+do_execsql_test  e_vacuum-3.2.1.1 { BEGIN } {}
+do_catchsql_test e_vacuum-3.2.1.2 { 
+  VACUUM 
+} {1 {cannot VACUUM from within a transaction}}
+do_execsql_test  e_vacuum-3.2.1.3 { COMMIT } {}
+do_execsql_test  e_vacuum-3.2.1.4 { VACUUM } {}
+do_execsql_test  e_vacuum-3.2.1.5 { SAVEPOINT x } {}
+do_catchsql_test e_vacuum-3.2.1.6 { 
+  VACUUM 
+} {1 {cannot VACUUM from within a transaction}}
+do_execsql_test  e_vacuum-3.2.1.7 { COMMIT } {}
+do_execsql_test  e_vacuum-3.2.1.8 { VACUUM } {}
+
+create_db
+do_test e_vacuum-3.2.2.1 {
+  set res ""
+  db eval { SELECT a FROM t1 } {
+    if {$a == 10} { set res [catchsql VACUUM] }
+  }
+  set res
+} {1 {cannot VACUUM - SQL statements in progress}}
+
+
+# EVIDENCE-OF: R-55138-13241 An alternative to using the VACUUM command
+# to reclaim space after data has been deleted is auto-vacuum mode,
+# enabled using the auto_vacuum pragma.
+#
+do_test e_vacuum-3.3.1 {
+  create_db { PRAGMA auto_vacuum = FULL }
+  execsql { PRAGMA auto_vacuum }
+} {1}
+
+# EVIDENCE-OF: R-64844-34873 When auto_vacuum is enabled for a database
+# free pages may be reclaimed after deleting data, causing the file to
+# shrink, without rebuilding the entire database using VACUUM.
+#
+do_test e_vacuum-3.3.2.1 {
+  create_db { PRAGMA auto_vacuum = FULL }
+  execsql {
+    DELETE FROM t1;
+    DELETE FROM t2;
+  }
+  expr {[file size test.db] / 1024}
+} {8}
+do_test e_vacuum-3.3.2.2 {
+  create_db { PRAGMA auto_vacuum = INCREMENTAL }
+  execsql {
+    DELETE FROM t1;
+    DELETE FROM t2;
+    PRAGMA incremental_vacuum;
+  }
+  expr {[file size test.db] / 1024}
+} {8}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/e_walauto.test

@@ -0,0 +1,214 @@
+# 2014 December 04
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/wal_common.tcl
+set testprefix e_walauto
+
+# Do not run this test on OpenBSD, as it depends on read() and mmap both
+# accessing the same coherent view of the "test.db-shm" file. This doesn't
+# work on OpenBSD.
+#
+if {$tcl_platform(os) == "OpenBSD"} {
+  finish_test
+  return
+}
+
+# This module uses hard-coded offsets which do not work if the reserved_bytes
+# value is nonzero.
+if {[nonzero_reserved_bytes]} {finish_test; return;}
+
+
+proc read_nbackfill {} {
+  seek $::shmfd 96
+  binary scan [read $::shmfd 4] n nBackfill
+  set nBackfill
+}
+proc read_mxframe {} {
+  seek $::shmfd 16
+  binary scan [read $::shmfd 4] n mxFrame
+  set mxFrame
+}
+
+# Assuming that the main db for database handle
+#
+proc do_autocommit_threshold_test {tn value} {
+
+  set nBackfillSaved [read_nbackfill]
+  while {1} {
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    if {[read_mxframe] >= $value} break
+  }
+  
+  set nBackfillNew [read_nbackfill]
+  uplevel [list do_test $tn "expr $nBackfillNew > $nBackfillSaved" 1]
+}
+
+# EVIDENCE-OF: R-30135-06439 The wal_autocheckpoint pragma can be used
+# to invoke this interface from SQL.
+#
+#   All tests in this file are run twice - once using the
+#   sqlite3_wal_autocheckpoint() API, and once using "PRAGMA
+#   wal_autocheckpoint".
+#
+foreach {tn code} {
+  1 {
+    proc autocheckpoint {db value} {
+      uplevel [list $db eval "PRAGMA wal_autocheckpoint = $value"]
+    }
+  }
+
+  2 {
+    proc autocheckpoint {db value} {
+      uplevel [list sqlite3_wal_autocheckpoint $db $value]
+      return $value
+    }
+  }
+} {
+
+  eval $code
+
+  reset_db
+  execsql { PRAGMA auto_vacuum = 0 }
+  do_execsql_test 1.$tn.0 { PRAGMA journal_mode = WAL } {wal}
+  do_execsql_test 1.$tn.1 { CREATE TABLE t1(a, b) }
+  set shmfd [open "test.db-shm" rb]
+
+  # EVIDENCE-OF: R-41531-51083 Every new database connection defaults to
+  # having the auto-checkpoint enabled with a threshold of 1000 or
+  # SQLITE_DEFAULT_WAL_AUTOCHECKPOINT pages.
+  #
+  do_autocommit_threshold_test 1.$tn.2 1000
+  db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+  do_autocommit_threshold_test 1.$tn.3 1000
+
+  # EVIDENCE-OF: R-38128-34102 The sqlite3_wal_autocheckpoint(D,N) is a
+  # wrapper around sqlite3_wal_hook() that causes any database on database
+  # connection D to automatically checkpoint after committing a
+  # transaction if there are N or more frames in the write-ahead log file.
+  #
+  do_test 1.$tn.4 {
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    autocheckpoint db 100
+  } {100}
+  do_autocommit_threshold_test 1.$tn.5 100
+
+  do_test 1.$tn.6 {
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    autocheckpoint db 500
+  } {500}
+  do_autocommit_threshold_test 1.$tn.7 500
+
+  # EVIDENCE-OF: R-26993-43540 Passing zero or a negative value as the
+  # nFrame parameter disables automatic checkpoints entirely.
+  #
+  do_test 1.$tn.7 {
+    autocheckpoint db 0    ;# Set to zero
+    for {set i 0} {$i < 10000} {incr i} {
+      db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    }
+    expr {[file size test.db-wal] > (5 * 1024 * 1024)}
+  } 1
+  do_test 1.$tn.8 {
+    sqlite3_wal_checkpoint_v2 db truncate
+    file size test.db-wal
+  } 0
+  do_test 1.$tn.9 {
+    autocheckpoint db -4    ;# Set to a negative value
+    for {set i 0} {$i < 10000} {incr i} {
+      db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    }
+    expr {[file size test.db-wal] > (5 * 1024 * 1024)}
+  } 1
+
+  # EVIDENCE-OF: R-10203-42688 The callback registered by this function
+  # replaces any existing callback registered using sqlite3_wal_hook().
+  #
+  set ::wal_hook_callback 0
+  proc wal_hook_callback {args} { incr ::wal_hook_callback ; return 0 }
+  do_test 1.$tn.10.1 {
+    db wal_hook wal_hook_callback
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    set ::wal_hook_callback
+  } 2
+  do_test 1.$tn.10.2 {
+    autocheckpoint db 100
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    set ::wal_hook_callback
+  } 2
+
+  # EVIDENCE-OF: R-17497-43474 Likewise, registering a callback using
+  # sqlite3_wal_hook() disables the automatic checkpoint mechanism
+  # configured by this function.
+  do_test 1.$tn.11.1 {
+    sqlite3_wal_checkpoint_v2 db truncate
+    file size test.db-wal
+  } 0
+  do_test 1.$tn.11.2 {
+    autocheckpoint db 100 
+    for {set i 0} {$i < 1000} {incr i} {
+      db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    }
+    expr {[file size test.db-wal] < (1 * 1024 * 1024)}
+  } 1
+  do_test 1.$tn.11.3 {
+    db wal_hook wal_hook_callback
+    for {set i 0} {$i < 1000} {incr i} {
+      db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    }
+    expr {[file size test.db-wal] < (1 * 1024 * 1024)}
+  } 0
+
+  # EVIDENCE-OF: R-33080-59193 Checkpoints initiated by this mechanism 
+  # are PASSIVE.
+  #
+  set ::busy_callback_count 0
+  proc busy_callback {args} {
+    incr ::busy_callback_count
+    return 0
+  }
+  do_test 1.$tn.12.1 {
+    sqlite3_wal_checkpoint_v2 db truncate
+    autocheckpoint db 100 
+    db busy busy_callback
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+  } {}
+  do_test 1.$tn.12.2 {
+    sqlite3 db2 test.db
+    db2 eval { BEGIN; SELECT * FROM t1 LIMIT 10; }
+    read_nbackfill
+  } {0}
+  do_test 1.$tn.12.3 {
+    for {set i 0} {$i < 1000} {incr i} {
+      db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    }
+    read_nbackfill
+  } {2}
+  do_test 1.$tn.12.4 {
+    set ::busy_callback_count
+  } {0}
+  db2 close
+
+  do_test 1.$tn.12.5 {
+    db eval { INSERT INTO t1 VALUES(randomblob(100), randomblob(100)) }
+    read_nbackfill
+  } {1559}
+
+  db close
+  close $shmfd
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/enc3.test

@@ -0,0 +1,107 @@
+# 2002 May 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library. 
+#
+# The focus of this file is testing of the proper handling of conversions
+# to the native text representation.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable {utf16} {
+  do_test enc3-1.1 {
+    execsql {
+      PRAGMA encoding=utf16le;
+      PRAGMA encoding;
+    }
+  } {UTF-16le}
+}
+do_test enc3-1.2 {
+  execsql {
+    CREATE TABLE t1(x,y);
+    INSERT INTO t1 VALUES('abc''123',5);
+    SELECT * FROM t1
+  }
+} {abc'123 5}
+do_test enc3-1.3 {
+  execsql {
+    SELECT quote(x) || ' ' || quote(y) FROM t1
+  }
+} {{'abc''123' 5}}
+ifcapable {bloblit} {
+  do_test enc3-1.4 {
+    execsql {
+      DELETE FROM t1;
+      INSERT INTO t1 VALUES(x'616263646566',NULL);
+      SELECT * FROM t1
+    }
+  } {abcdef {}}
+  do_test enc3-1.5 {
+    execsql {
+      SELECT quote(x) || ' ' || quote(y) FROM t1
+    }
+  } {{X'616263646566' NULL}}
+}
+ifcapable {bloblit && utf16} {
+  do_test enc3-2.1 {
+    execsql {
+      PRAGMA encoding
+    }
+  } {UTF-16le}
+  do_test enc3-2.2 {
+    execsql {
+      CREATE TABLE t2(a);
+      INSERT INTO t2 VALUES(x'61006200630064006500');
+      SELECT CAST(a AS text) FROM t2 WHERE CAST(a AS text) LIKE 'abc%';
+    }
+  } {abcde}
+  do_test enc3-2.3 {
+    execsql {
+      SELECT CAST(x'61006200630064006500' AS text);
+    }
+  } {abcde}
+  do_test enc3-2.4 {
+    execsql {
+      SELECT rowid FROM t2
+       WHERE CAST(a AS text) LIKE CAST(x'610062002500' AS text);
+    }
+  } {1}
+}
+
+# Try to attach a database with a different encoding.
+#
+ifcapable {utf16 && shared_cache} {
+  db close
+  forcedelete test8.db test8.db-journal
+  set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
+  sqlite3 dbaux test8.db
+  sqlite3 db test.db
+  db eval {SELECT 1 FROM sqlite_master LIMIT 1}
+  do_test enc3-3.1 {
+    dbaux eval {
+      PRAGMA encoding='utf8';
+      CREATE TABLE t1(x);
+      PRAGMA encoding
+    }
+  } {UTF-8}
+  do_test enc3-3.2 {
+    catchsql {
+      ATTACH 'test.db' AS utf16;
+      SELECT 1 FROM utf16.sqlite_master LIMIT 1;
+    } dbaux
+  } {1 {attached databases must use the same text encoding as main database}}
+  dbaux close
+  forcedelete test8.db test8.db-journal
+  sqlite3_enable_shared_cache $::enable_shared_cache
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/extraquick.test

@@ -0,0 +1,16 @@
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file runs most of the tests run by veryquick.test except for those
+# that take a long time.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/permutations.test
+
+run_test_suite extraquick
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3auto.test

@@ -0,0 +1,717 @@
+# 2011 June 10
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# If this build does not include FTS3, skip the tests in this file.
+#
+ifcapable !fts3 { finish_test ; return }
+source $testdir/fts3_common.tcl
+source $testdir/malloc_common.tcl
+
+set testprefix fts3auto
+set sfep $sqlite_fts3_enable_parentheses
+set sqlite_fts3_enable_parentheses 1
+
+#--------------------------------------------------------------------------
+# Start of Tcl infrastructure used by tests. The entry points are:
+#
+#   do_fts3query_test
+#   fts3_make_deferrable
+#   fts3_zero_long_segments 
+#
+
+#
+#    do_fts3query_test TESTNAME ?OPTIONS? TABLE MATCHEXPR
+#
+# This proc runs several test cases on FTS3/4 table $TABLE using match
+# expression $MATCHEXPR. All documents in $TABLE must be formatted so that
+# they can be "tokenized" using the Tcl list commands (llength, lindex etc.).
+# The name and column names used by $TABLE must not require any quoting or
+# escaping when used in SQL statements.
+#
+# $MATCHINFO may be any expression accepted by the FTS4 MATCH operator, 
+# except that the "<column-name>:token" syntax is not supported. Tcl list
+# commands are used to tokenize the expression. Any parenthesis must appear
+# either as separate list elements, or as the first (for opening) or last
+# (for closing) character of a list element. i.e. the expression "(a OR b)c"
+# will not be parsed correctly, but "( a OR b) c" will.
+#
+# Available OPTIONS are:
+#
+#     -deferred TOKENLIST
+#
+# If the "deferred" option is supplied, it is passed a list of tokens that
+# are deferred by FTS and result in the relevant matchinfo() stats being an
+# approximation. 
+#
+set sqlite_fts3_enable_parentheses 1
+proc do_fts3query_test {tn args} {
+
+  set nArg [llength $args]
+  if {$nArg < 2 || ($nArg % 2)} {
+    set cmd do_fts3query_test
+    error "wrong # args: should be \"$cmd ?-deferred LIST? TABLE MATCHEXPR\""
+  }
+  set tbl   [lindex $args [expr $nArg-2]]
+  set match [lindex $args [expr $nArg-1]]
+  set deferred [list]
+
+  foreach {k v} [lrange $args 0 [expr $nArg-3]] {
+    switch -- $k {
+      -deferred {
+        ifcapable fts4_deferred { set deferred $v }
+      }
+      default {
+        error "bad option \"$k\": must be -deferred"
+      }
+    }
+  }
+
+  get_near_results $tbl $match $deferred aHit
+  get_near_results $tbl [string map {AND OR} $match] $deferred aMatchinfo
+
+  set matchinfo_asc [list]
+  foreach docid [lsort -integer -incr [array names aHit]] {
+    lappend matchinfo_asc $docid $aMatchinfo($docid)
+  }
+  set matchinfo_desc [list]
+  foreach docid [lsort -integer -decr [array names aHit]] {
+    lappend matchinfo_desc $docid $aMatchinfo($docid)
+  }
+
+  set title "(\"$match\" -> [llength [array names aHit]] rows)"
+
+  do_execsql_test $tn$title.1 "
+    SELECT docid FROM $tbl WHERE $tbl MATCH '$match' ORDER BY docid ASC
+  " [lsort -integer -incr [array names aHit]] 
+
+  do_execsql_test $tn$title.2 "
+    SELECT docid FROM $tbl WHERE $tbl MATCH '$match' ORDER BY docid DESC
+  " [lsort -integer -decr [array names aHit]] 
+
+  do_execsql_test $tn$title.3 "
+    SELECT docid, mit(matchinfo($tbl, 'x')) FROM $tbl 
+    WHERE $tbl MATCH '$match' ORDER BY docid DESC
+  " $matchinfo_desc
+
+  do_execsql_test $tn$title.4 "
+    SELECT docid, mit(matchinfo($tbl, 'x')) FROM $tbl 
+    WHERE $tbl MATCH '$match' ORDER BY docid ASC
+  " $matchinfo_asc
+}
+
+#    fts3_make_deferrable TABLE TOKEN ?NROW?
+#
+proc fts3_make_deferrable {tbl token {nRow 0}} {
+
+  set stmt [sqlite3_prepare db "SELECT * FROM $tbl" -1 dummy]
+  set name [sqlite3_column_name $stmt 0]
+  sqlite3_finalize $stmt
+
+  if {$nRow==0} {
+    set nRow [db one "SELECT count(*) FROM $tbl"]
+  }
+  set pgsz [db one "PRAGMA page_size"]
+  execsql BEGIN
+  for {set i 0} {$i < ($nRow * $pgsz * 1.2)/100} {incr i} {
+    set doc [string repeat "$token " 100]
+    execsql "INSERT INTO $tbl ($name) VALUES(\$doc)"
+  }
+  execsql "INSERT INTO $tbl ($name) VALUES('aaaaaaa ${token}aaaaa')"
+  execsql COMMIT
+
+  return [expr $nRow*$pgsz]
+}
+
+#    fts3_zero_long_segments TABLE ?LIMIT?
+#
+proc fts3_zero_long_segments {tbl limit} {
+  sqlite3_db_config db DEFENSIVE 0
+  execsql " 
+    UPDATE ${tbl}_segments 
+    SET block = zeroblob(length(block)) 
+    WHERE length(block)>$limit
+  "
+  return [db changes]
+}
+
+
+proc mit {blob} {
+  set scan(littleEndian) i*
+  set scan(bigEndian) I*
+  binary scan $blob $scan($::tcl_platform(byteOrder)) r
+  return $r
+}
+db func mit mit
+
+proc fix_phrase_expr {cols expr colfiltervar} {
+  upvar $colfiltervar iColFilter
+
+  set out [list]
+  foreach t $expr {
+    if {[string match *:* $t]} {
+      set col [lindex [split $t :] 0]
+      set t   [lindex [split $t :] 1]
+      set iCol [lsearch $cols $col]
+      if {$iCol<0} { error "unknown column: $col" }
+      if {$iColFilter < 0} {
+        set iColFilter $iCol
+      } elseif {$iColFilter != $iCol} {
+        set iColFilter [llength $cols]
+      }
+    }
+    lappend out $t
+  }
+
+  return $out
+}
+
+proc fix_near_expr {cols expr colfiltervar} { 
+  upvar $colfiltervar iColFilter
+ 
+  set iColFilter -1
+
+  set out [list]
+  lappend out [fix_phrase_expr $cols [lindex $expr 0] iColFilter]
+  foreach {a b} [lrange $expr 1 end] {
+    if {[string match -nocase near $a]}   { set a 10 }
+    if {[string match -nocase near/* $a]} { set a [string range $a 5 end] }
+    lappend out $a
+    lappend out [fix_phrase_expr $cols $b iColFilter]
+  }
+  return $out
+}
+
+proc get_single_near_results {tbl expr deferred arrayvar nullvar} {
+  upvar $arrayvar aMatchinfo
+  upvar $nullvar nullentry
+  catch {array unset aMatchinfo}
+
+  set cols [list]
+  set miss [list]
+  db eval "PRAGMA table_info($tbl)" A { lappend cols $A(name) ; lappend miss 0 }
+  set expr [fix_near_expr $cols $expr iColFilter]
+
+  # Calculate the expected results using [fts3_near_match]. The following
+  # loop populates the "hits" and "counts" arrays as follows:
+  # 
+  #   1. For each document in the table that matches the NEAR expression,
+  #      hits($docid) is set to 1. The set of docids that match the expression
+  #      can therefore be found using [array names hits].
+  #
+  #   2. For each column of each document in the table, counts($docid,$iCol)
+  #      is set to the -phrasecountvar output.
+  #
+  set res [list]
+  catch { array unset hits }
+  db eval "SELECT docid, * FROM $tbl" d {
+    set iCol 0
+    foreach col [lrange $d(*) 1 end] {
+      set docid $d(docid)
+      if {$iColFilter<0 || $iCol==$iColFilter} {
+        set hit [fts3_near_match $d($col) $expr -p counts($docid,$iCol)]
+        if {$hit} { set hits($docid) 1 }
+      } else {
+        set counts($docid,$iCol) $miss
+      }
+      incr iCol
+    }
+  }
+  set nPhrase [expr ([llength $expr]+1)/2]
+  set nCol $iCol
+
+  # This block populates the nHit and nDoc arrays. For each phrase/column
+  # in the query/table, array elements are set as follows:
+  #
+  #   nHit($iPhrase,$iCol) - Total number of hits for phrase $iPhrase in 
+  #                          column $iCol.
+  #
+  #   nDoc($iPhrase,$iCol) - Number of documents with at least one hit for
+  #                          phrase $iPhrase in column $iCol.
+  #
+  for {set iPhrase 0} {$iPhrase < $nPhrase} {incr iPhrase} {
+    for {set iCol 0} {$iCol < $nCol} {incr iCol} {
+      set nHit($iPhrase,$iCol) 0
+      set nDoc($iPhrase,$iCol) 0
+    }
+  }
+  foreach key [array names counts] {
+    set iCol [lindex [split $key ,] 1]
+    set iPhrase 0
+    foreach c $counts($key) {
+      if {$c>0} { incr nDoc($iPhrase,$iCol) 1 }
+      incr nHit($iPhrase,$iCol) $c
+      incr iPhrase
+    }
+  }
+
+  if {[llength $deferred] && [llength $expr]==1} {
+    set phrase [lindex $expr 0]
+    set rewritten [list]
+    set partial 0
+    foreach tok $phrase {
+      if {[lsearch $deferred $tok]>=0} {
+        lappend rewritten *
+      } else {
+        lappend rewritten $tok
+        set partial 1
+      }
+    }
+    if {$partial==0} {
+      set tblsize [db one "SELECT count(*) FROM $tbl"]
+      for {set iCol 0} {$iCol < $nCol} {incr iCol} {
+        set nHit(0,$iCol) $tblsize
+        set nDoc(0,$iCol) $tblsize
+      }
+    } elseif {$rewritten != $phrase} {
+      while {[lindex $rewritten end] == "*"} {
+        set rewritten [lrange $rewritten 0 end-1]
+      }
+      while {[lindex $rewritten 0] == "*"} {
+        set rewritten [lrange $rewritten 1 end]
+      }
+      get_single_near_results $tbl [list $rewritten] {} aRewrite nullentry
+      foreach docid [array names hits] {
+        set aMatchinfo($docid) $aRewrite($docid)
+      }
+      return
+    }
+  }
+
+  # Set up the aMatchinfo array. For each document, set aMatchinfo($docid) to
+  # contain the output of matchinfo('x') for the document.
+  #
+  foreach docid [array names hits] {
+    set mi [list]
+    for {set iPhrase 0} {$iPhrase<$nPhrase} {incr iPhrase} {
+      for {set iCol 0} {$iCol<$nCol} {incr iCol} {
+        lappend mi [lindex $counts($docid,$iCol) $iPhrase]
+        lappend mi $nHit($iPhrase,$iCol)
+        lappend mi $nDoc($iPhrase,$iCol)
+      }
+    }
+    set aMatchinfo($docid) $mi
+  }
+
+  # Set up the nullentry output.
+  #
+  set nullentry [list]
+  for {set iPhrase 0} {$iPhrase<$nPhrase} {incr iPhrase} {
+    for {set iCol 0} {$iCol<$nCol} {incr iCol} {
+      lappend nullentry 0 $nHit($iPhrase,$iCol) $nDoc($iPhrase,$iCol)
+    }
+  }
+}
+
+
+proc matching_brackets {expr} {
+  if {[string range $expr 0 0]!="(" || [string range $expr end end] !=")"} { 
+    return 0 
+  }
+
+  set iBracket 1
+  set nExpr [string length $expr]
+  for {set i 1} {$iBracket && $i < $nExpr} {incr i} {
+    set c [string range $expr $i $i]
+    if {$c == "("} {incr iBracket}
+    if {$c == ")"} {incr iBracket -1}
+  }
+
+  return [expr ($iBracket==0 && $i==$nExpr)]
+}
+
+proc get_near_results {tbl expr deferred arrayvar {nullvar ""}} {
+  upvar $arrayvar aMatchinfo
+  if {$nullvar != ""} { upvar $nullvar nullentry }
+
+  set expr [string trim $expr]
+  while { [matching_brackets $expr] } {
+    set expr [string trim [string range $expr 1 end-1]]
+  }
+
+  set prec(NOT) 1
+  set prec(AND) 2
+  set prec(OR)  3
+
+  set currentprec 0
+  set iBracket 0
+  set expr_length [llength $expr]
+  for {set i 0} {$i < $expr_length} {incr i} {
+    set op [lindex $expr $i]
+    if {$iBracket==0 && [info exists prec($op)] && $prec($op)>=$currentprec } {
+      set opidx $i
+      set currentprec $prec($op)
+    } else {
+      for {set j 0} {$j < [string length $op]} {incr j} {
+        set c [string range $op $j $j]
+        if {$c == "("} { incr iBracket +1 }
+        if {$c == ")"} { incr iBracket -1 }
+      }
+    }
+  }
+  if {$iBracket!=0} { error "mismatched brackets in: $expr" }
+
+  if {[info exists opidx]==0} {
+    get_single_near_results $tbl $expr $deferred aMatchinfo nullentry
+  } else {
+    set eLeft  [lrange $expr 0 [expr $opidx-1]]
+    set eRight [lrange $expr [expr $opidx+1] end]
+
+    get_near_results $tbl $eLeft  $deferred aLeft  nullleft
+    get_near_results $tbl $eRight $deferred aRight nullright
+
+    switch -- [lindex $expr $opidx] {
+      "NOT" {
+        foreach hit [array names aLeft] {
+          if {0==[info exists aRight($hit)]} {
+            set aMatchinfo($hit) $aLeft($hit)
+          }
+        }
+        set nullentry $nullleft
+      }
+
+      "AND" {
+        foreach hit [array names aLeft] {
+          if {[info exists aRight($hit)]} {
+            set aMatchinfo($hit) [concat $aLeft($hit) $aRight($hit)]
+          }
+        }
+        set nullentry [concat $nullleft $nullright]
+      }
+
+      "OR" {
+        foreach hit [array names aLeft] {
+          if {[info exists aRight($hit)]} {
+            set aMatchinfo($hit) [concat $aLeft($hit) $aRight($hit)]
+            unset aRight($hit)
+          } else {
+            set aMatchinfo($hit) [concat $aLeft($hit) $nullright]
+          }
+        }
+        foreach hit [array names aRight] {
+          set aMatchinfo($hit) [concat $nullleft $aRight($hit)]
+        }
+
+        set nullentry [concat $nullleft $nullright]
+      }
+    }
+  }
+}
+
+
+# End of test procs. Actual tests are below this line.
+#--------------------------------------------------------------------------
+
+#--------------------------------------------------------------------------
+# The following test cases - fts3auto-1.* - focus on testing the Tcl 
+# command [fts3_near_match], which is used by other tests in this file.
+#
+proc test_fts3_near_match {tn doc expr res} {
+  fts3_near_match $doc $expr -phrasecountvar p
+  uplevel do_test [list $tn] [list [list set {} $p]] [list $res]
+}
+
+test_fts3_near_match 1.1.1 {a b c a b} a                   {2}
+test_fts3_near_match 1.1.2 {a b c a b} {a 5 b 6 c}         {2 2 1}
+test_fts3_near_match 1.1.3 {a b c a b} {"a b"}             {2}
+test_fts3_near_match 1.1.4 {a b c a b} {"b c"}             {1}
+test_fts3_near_match 1.1.5 {a b c a b} {"c c"}             {0}
+
+test_fts3_near_match 1.2.1 "a b c d e f g" {b 2 f}         {0 0}
+test_fts3_near_match 1.2.2 "a b c d e f g" {b 3 f}         {1 1}
+test_fts3_near_match 1.2.3 "a b c d e f g" {f 2 b}         {0 0}
+test_fts3_near_match 1.2.4 "a b c d e f g" {f 3 b}         {1 1}
+test_fts3_near_match 1.2.5 "a b c d e f g" {"a b" 2 "f g"} {0 0}
+test_fts3_near_match 1.2.6 "a b c d e f g" {"a b" 3 "f g"} {1 1}
+
+set A "a b c d e f g h i j k l m n o p q r s t u v w x y z"
+test_fts3_near_match 1.3.1 $A {"c d" 5 "i j" 1 "e f"}      {0 0 0}
+test_fts3_near_match 1.3.2 $A {"c d" 5 "i j" 2 "e f"}      {1 1 1}
+
+#--------------------------------------------------------------------------
+# Test cases fts3auto-2.* run some simple tests using the 
+# [do_fts3query_test] proc.
+#
+foreach {tn create} {
+  1    "fts4(a, b)"
+  2    "fts4(a, b, order=DESC)"
+  3    "fts4(a, b, order=ASC)"
+  4    "fts4(a, b, prefix=1)"
+  5    "fts4(a, b, order=DESC, prefix=1)"
+  6    "fts4(a, b, order=ASC, prefix=1)"
+} {
+  do_test 2.$tn.1 {
+    catchsql { DROP TABLE t1 }
+    execsql  "CREATE VIRTUAL TABLE t1 USING $create"
+    for {set i 0} {$i<32} {incr i} {
+      set doc [list]
+      if {$i&0x01} {lappend doc one}
+      if {$i&0x02} {lappend doc two}
+      if {$i&0x04} {lappend doc three}
+      if {$i&0x08} {lappend doc four}
+      if {$i&0x10} {lappend doc five}
+      execsql { INSERT INTO t1 VALUES($doc, null) }
+    }
+  } {}
+
+  foreach {tn2 expr} {
+    1     {one}
+    2     {one NEAR/1 five}
+    3     {t*}
+    4     {t* NEAR/0 five}
+    5     {o* NEAR/1 f*}
+    6     {one NEAR five NEAR two NEAR four NEAR three}
+    7     {one NEAR xyz}
+    8     {one OR two}
+    9     {one AND two}
+    10    {one NOT two}
+    11    {one AND two OR three}
+    12    {three OR one AND two}
+    13    {(three OR one) AND two}
+    14    {(three OR one) AND two NOT (five NOT four)}
+    15    {"one two"}
+    16    {"one two" NOT "three four"}
+  } {
+    do_fts3query_test 2.$tn.2.$tn2 t1 $expr
+  }
+}
+
+#--------------------------------------------------------------------------
+# Some test cases involving deferred tokens.
+#
+
+foreach {tn create} {
+  1    "fts4(x)"
+  2    "fts4(x, order=DESC)"
+} {
+  catchsql { DROP TABLE t1 }
+  execsql  "CREATE VIRTUAL TABLE t1 USING $create"
+  do_execsql_test 3.$tn.1 {
+    INSERT INTO t1(docid, x) VALUES(-2, 'a b c d e f g h i j k');
+    INSERT INTO t1(docid, x) VALUES(-1, 'b c d e f g h i j k a');
+    INSERT INTO t1(docid, x) VALUES(0, 'c d e f g h i j k a b');
+    INSERT INTO t1(docid, x) VALUES(1, 'd e f g h i j k a b c');
+    INSERT INTO t1(docid, x) VALUES(2, 'e f g h i j k a b c d');
+    INSERT INTO t1(docid, x) VALUES(3, 'f g h i j k a b c d e');
+    INSERT INTO t1(docid, x) VALUES(4, 'a c e g i k');
+    INSERT INTO t1(docid, x) VALUES(5, 'a d g j');
+    INSERT INTO t1(docid, x) VALUES(6, 'c a b');
+  }
+
+  set limit [fts3_make_deferrable t1 c]
+
+  do_fts3query_test 3.$tn.2.1 t1 {a OR c}
+
+  ifcapable fts4_deferred {
+    do_test 3.$tn.3 { fts3_zero_long_segments t1 $limit } {1}
+  }
+
+  foreach {tn2 expr def} {
+    1     {a NEAR c}            {}
+    2     {a AND c}             c
+    3     {"a c"}               c
+    4     {"c a"}               c
+    5     {"a c" NEAR/1 g}      {}
+    6     {"a c" NEAR/0 g}      {}
+  } {
+    do_fts3query_test 3.$tn.4.$tn2 -deferred $def t1 $expr
+  }
+}
+
+#--------------------------------------------------------------------------
+# 
+foreach {tn create} {
+  1    "fts4(x, y)"
+  2    "fts4(x, y, order=DESC)"
+  3    "fts4(x, y, order=DESC, prefix=2)"
+} {
+
+  execsql [subst {
+    DROP TABLE t1;
+    CREATE VIRTUAL TABLE t1 USING $create;
+    INSERT INTO t1 VALUES('one two five four five', '');
+    INSERT INTO t1 VALUES('', 'one two five four five');
+    INSERT INTO t1 VALUES('one two', 'five four five');
+  }]
+
+  do_fts3query_test 4.$tn.1.1 t1 {one AND five}
+  do_fts3query_test 4.$tn.1.2 t1 {one NEAR five}
+  do_fts3query_test 4.$tn.1.3 t1 {one NEAR/1 five}
+  do_fts3query_test 4.$tn.1.4 t1 {one NEAR/2 five}
+  do_fts3query_test 4.$tn.1.5 t1 {one NEAR/3 five}
+
+  do_test 4.$tn.2 { 
+    set limit [fts3_make_deferrable t1 five]
+    execsql { INSERT INTO t1(t1) VALUES('optimize') }
+    ifcapable fts4_deferred {
+      expr {[fts3_zero_long_segments t1 $limit]>0}
+    } else {
+      expr 1
+    }
+  } {1}
+
+  do_fts3query_test 4.$tn.3.1 -deferred five t1 {one AND five}
+  do_fts3query_test 4.$tn.3.2 -deferred five t1 {one NEAR five}
+  do_fts3query_test 4.$tn.3.3 -deferred five t1 {one NEAR/1 five}
+  do_fts3query_test 4.$tn.3.4 -deferred five t1 {one NEAR/2 five}
+
+  do_fts3query_test 4.$tn.3.5 -deferred five t1 {one NEAR/3 five}
+
+  do_fts3query_test 4.$tn.4.1 -deferred fi* t1 {on* AND fi*}
+  do_fts3query_test 4.$tn.4.2 -deferred fi* t1 {on* NEAR fi*}
+  do_fts3query_test 4.$tn.4.3 -deferred fi* t1 {on* NEAR/1 fi*}
+  do_fts3query_test 4.$tn.4.4 -deferred fi* t1 {on* NEAR/2 fi*}
+  do_fts3query_test 4.$tn.4.5 -deferred fi* t1 {on* NEAR/3 fi*}
+
+  ifcapable fts4_deferred {
+    db eval {UPDATE t1_stat SET value=x'' WHERE id=0}
+    do_catchsql_test 4.$tn.4.6 {
+      SELECT docid FROM t1 WHERE t1 MATCH 'on* NEAR/3 fi*'
+    } {1 {database disk image is malformed}}
+  }
+}
+
+#--------------------------------------------------------------------------
+# The following test cases - fts3auto-5.* - focus on using prefix indexes.
+#
+set chunkconfig [fts3_configure_incr_load 1 1]
+foreach {tn create pending} {
+  1    "fts4(a, b)"                                  1
+  2    "fts4(a, b, order=ASC, prefix=1)"             1
+  3    "fts4(a, b, order=ASC,  prefix=\"1,3\")"      0
+  4    "fts4(a, b, order=DESC, prefix=\"2,4\")"      0
+  5    "fts4(a, b, order=DESC, prefix=\"1\")"        0
+  6    "fts4(a, b, order=ASC,  prefix=\"1,3\")"      0
+} {
+
+  execsql [subst {
+    DROP TABLE IF EXISTS t1;
+    CREATE VIRTUAL TABLE t1 USING $create;
+  }]
+
+  if {$pending} {execsql BEGIN}
+
+  foreach {a b} {
+    "the song of songs which is solomons"
+    "let him kiss me with the kisses of his mouth for thy love is better than wine"
+    "because of the savour of thy good ointments thy name is as ointment poured forth therefore do the virgins love thee"
+    "draw me we will run after thee the king hath brought me into his chambers we will be glad and rejoice in thee we will remember thy love more than wine the upright love thee"
+    "i am black but comely o ye daughters of jerusalem as the tents of kedar as the curtains of solomon"
+    "look not upon me because i am black because the sun hath looked upon me my mothers children were angry with me they made me the keeper of the vineyards but mine own vineyard have i not kept"
+    "tell me o thou whom my soul loveth where thou feedest where thou makest thy flock to rest at noon for why should i be as one that turneth aside by the flocks of thy companions?"
+    "if thou know not o thou fairest among women go thy way forth by the footsteps of the flock and feed thy kids beside the shepherds tents"
+    "i have compared thee o my love to a company of horses in pharaohs chariots"
+    "thy cheeks are comely with rows of jewels thy neck with chains of gold"
+    "we will make thee borders of gold with studs of silver"
+    "while the king sitteth at his table my spikenard sendeth forth the smell thereof"
+    "a bundle of myrrh is my wellbeloved unto me he shall lie all night betwixt my breasts"
+    "my beloved is unto me as a cluster of camphire in the vineyards of en gedi"
+    "behold thou art fair my love behold thou art fair thou hast doves eyes"
+    "behold thou art fair my beloved yea pleasant also our bed is green"
+    "the beams of our house are cedar and our rafters of fir"
+  } {
+    execsql {INSERT INTO t1(a, b) VALUES($a, $b)}
+  }
+
+
+  do_fts3query_test 5.$tn.1.1 t1 {s*}
+  do_fts3query_test 5.$tn.1.2 t1 {so*}
+  do_fts3query_test 5.$tn.1.3 t1 {"s* o*"}
+  do_fts3query_test 5.$tn.1.4 t1 {b* NEAR/3 a*}
+  do_fts3query_test 5.$tn.1.5 t1 {a*}
+  do_fts3query_test 5.$tn.1.6 t1 {th* NEAR/5 a* NEAR/5 w*}
+  do_fts3query_test 5.$tn.1.7 t1 {"b* th* art* fair*"}
+
+  if {$pending} {execsql COMMIT}
+}
+eval fts3_configure_incr_load $chunkconfig
+
+foreach {tn pending create} {
+  1    0 "fts4(a, b, c, d)"
+  2    1 "fts4(a, b, c, d)"
+  3    0 "fts4(a, b, c, d, order=DESC)"
+  4    1 "fts4(a, b, c, d, order=DESC)"
+} {
+  execsql [subst {
+    DROP TABLE IF EXISTS t1;
+    CREATE VIRTUAL TABLE t1 USING $create;
+  }]
+
+
+  if {$pending} { execsql BEGIN }
+
+  foreach {a b c d} {
+    "A B C" "D E F" "G H I" "J K L"
+    "B C D" "E F G" "H I J" "K L A"
+    "C D E" "F G H" "I J K" "L A B"
+    "D E F" "G H I" "J K L" "A B C"
+    "E F G" "H I J" "K L A" "B C D"
+    "F G H" "I J K" "L A B" "C D E"
+  } {
+    execsql { INSERT INTO t1 VALUES($a, $b, $c, $d) }
+  }
+
+  do_fts3query_test 6.$tn.1 t1 {b:G}
+  do_fts3query_test 6.$tn.2 t1 {b:G AND c:I}
+  do_fts3query_test 6.$tn.3 t1 {b:G NEAR c:I}
+  do_fts3query_test 6.$tn.4 t1 {a:C OR b:G OR c:K OR d:C}
+
+  do_fts3query_test 6.$tn.5 t1 {a:G OR b:G}
+
+  catchsql { COMMIT }
+}
+
+foreach {tn create} {
+  1    "fts4(x)"
+  2    "fts4(x, order=DESC)"
+} {
+  execsql [subst {
+    DROP TABLE IF EXISTS t1;
+    CREATE VIRTUAL TABLE t1 USING $create;
+  }]
+
+  foreach {x} {
+    "F E N O T K X V A X I E X A P G Q V H U"
+    "R V A E T C V Q N I E L O N U G J K L U"
+    "U Y I G W M V F J L X I D C H F P J Q B"
+    "S G D Z X R P G S S Y B K A S G A I L L"
+    "L S I C H T Z S R Q P R N K J X L F M J"
+    "C C C D P X B Z C M A D A C X S B T X V"
+    "W Y J M D R G V R K B X S A W R I T N C"
+    "P K L W T M S P O Y Y V V O E H Q A I R"
+    "C D Y I C Z F H J C O Y A Q F L S B D K"
+    "P G S C Y C Y V I M B D S Z D D Y W I E"
+    "Z K Z U E E S F Y X T U A L W O U J C Q"
+    "P A T Z S W L P L Q V Y Y I P W U X S S"
+    "I U I H U O F Z F R H R F T N D X A G M"
+    "N A B M S H K X S O Y D T X S B R Y H Z"
+    "L U D A S K I L S V Z J P U B E B Y H M"
+  } {
+    execsql { INSERT INTO t1 VALUES($x) }
+  }
+
+  # Add extra documents to the database such that token "B" will be considered
+  # deferrable if considering the other tokens means that 2 or fewer documents
+  # will be loaded into memory.
+  #
+  fts3_make_deferrable t1 B 2
+
+  # B is not deferred in either of the first two tests below, since filtering
+  # on "M" or "D" returns 10 documents or so. But filtering on "M * D" only
+  # returns 2, so B is deferred in this case.
+  #
+  do_fts3query_test 7.$tn.1             t1 {"M B"}
+  do_fts3query_test 7.$tn.2             t1 {"B D"}
+  do_fts3query_test 7.$tn.3 -deferred B t1 {"M B D"}
+}
+
+set sqlite_fts3_enable_parentheses $sfep
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3cov.test

@@ -0,0 +1,434 @@
+# 2009 December 03
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# The tests in this file are structural coverage tests for FTS3.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# If this build does not include FTS3, skip the tests in this file.
+#
+ifcapable !fts3 { finish_test ; return }
+source $testdir/fts3_common.tcl
+source $testdir/malloc_common.tcl
+
+set DO_MALLOC_TEST 0
+set testprefix fts3cov
+
+#--------------------------------------------------------------------------
+# When it first needs to read a block from the %_segments table, the FTS3 
+# module compiles an SQL statement for that purpose. The statement is 
+# stored and reused each subsequent time a block is read. This test case 
+# tests the effects of an OOM error occuring while compiling the statement.
+#
+# Similarly, when FTS3 first needs to scan through a set of segment leaves
+# to find a set of documents that matches a term, it allocates a string
+# containing the text of the required SQL, and compiles one or more 
+# statements to traverse the leaves. This test case tests that OOM errors
+# that occur while allocating this string and statement are handled correctly
+# also.
+#
+do_test fts3cov-1.1 {
+  execsql { 
+    CREATE VIRTUAL TABLE t1 USING fts3(x);
+    INSERT INTO t1(t1) VALUES('nodesize=24');
+    BEGIN;
+      INSERT INTO t1 VALUES('Is the night chilly and dark?');
+      INSERT INTO t1 VALUES('The night is chilly, but not dark.');
+      INSERT INTO t1 VALUES('The thin gray cloud is spread on high,');
+      INSERT INTO t1 VALUES('It covers but not hides the sky.');
+    COMMIT;
+    SELECT count(*)>0 FROM t1_segments;
+  }
+} {1}
+
+set DO_MALLOC_TEST 1
+do_restart_select_test fts3cov-1.2 {
+  SELECT docid FROM t1 WHERE t1 MATCH 'chilly';
+} {1 2}
+set DO_MALLOC_TEST 0
+
+#--------------------------------------------------------------------------
+# When querying the full-text index, if an expected internal node block is 
+# missing from the %_segments table, or if a NULL value is stored in the 
+# %_segments table instead of a binary blob, database corruption should be 
+# reported.
+#
+# Even with tiny 24 byte nodes, it takes a fair bit of data to produce a
+# segment b-tree that uses the %_segments table to store internal nodes. 
+#
+do_test fts3cov-2.1 {
+  execsql {
+    INSERT INTO t1(t1) VALUES('nodesize=24');
+    BEGIN;
+      INSERT INTO t1 VALUES('The moon is behind, and at the full;');
+      INSERT INTO t1 VALUES('And yet she looks both small and dull.');
+      INSERT INTO t1 VALUES('The night is chill, the cloud is gray:');
+      INSERT INTO t1 VALUES('''T is a month before the month of May,');
+      INSERT INTO t1 VALUES('And the Spring comes slowly up this way.');
+      INSERT INTO t1 VALUES('The lovely lady, Christabel,');
+      INSERT INTO t1 VALUES('Whom her father loves so well,');
+      INSERT INTO t1 VALUES('What makes her in the wood so late,');
+      INSERT INTO t1 VALUES('A furlong from the castle gate?');
+      INSERT INTO t1 VALUES('She had dreams all yesternight');
+      INSERT INTO t1 VALUES('Of her own betrothed knight;');
+      INSERT INTO t1 VALUES('And she in the midnight wood will pray');
+      INSERT INTO t1 VALUES('For the weal of her lover that''s far away.');
+    COMMIT;
+  }
+  execsql {
+    INSERT INTO t1(t1) VALUES('optimize');
+    SELECT substr(hex(root), 1, 2) FROM t1_segdir;
+  }
+} {03}
+
+# Test the "missing entry" case:
+sqlite3_db_config db DEFENSIVE 0
+do_test fts3cov-2.2 {
+  set root [db one {SELECT root FROM t1_segdir}]
+  read_fts3varint [string range $root 1 end] left_child
+  execsql { DELETE FROM t1_segments WHERE blockid = $left_child }
+} {}
+do_error_test fts3cov-2.3 {
+  SELECT * FROM t1 WHERE t1 MATCH 'c*'
+} {database disk image is malformed}
+
+# Test the "replaced with NULL" case:
+do_test fts3cov-2.4 {
+  execsql { INSERT INTO t1_segments VALUES($left_child, NULL) }
+} {}
+do_error_test fts3cov-2.5 {
+  SELECT * FROM t1 WHERE t1 MATCH 'cloud'
+} {database disk image is malformed}
+
+#--------------------------------------------------------------------------
+# The following tests are to test the effects of OOM errors while storing
+# terms in the pending-hash table. Specifically, while creating doclist
+# blobs to store in the table. More specifically, to test OOM errors while
+# appending column numbers to doclists. For example, if a doclist consists
+# of:
+#
+#   <docid> <column 0 offset-list> 0x01 <column N> <column N offset-list>
+#
+# The following tests check that malloc errors encountered while appending
+# the "0x01 <column N>" data to the dynamically growable blob used to 
+# accumulate the doclist in memory are handled correctly.
+#
+do_test fts3cov-3.1 {
+  set cols [list]
+  set vals [list]
+  for {set i 0} {$i < 120} {incr i} {
+    lappend cols "col$i"
+    lappend vals "'word'"
+  }
+  execsql "CREATE VIRTUAL TABLE t2 USING fts3([join $cols ,])"
+} {}
+set DO_MALLOC_TEST 1 
+do_write_test fts3cov-3.2 t2_content "
+  INSERT INTO t2(docid, [join $cols ,]) VALUES(1, [join $vals ,])
+"
+do_write_test fts3cov-3.3 t2_content "
+  INSERT INTO t2(docid, [join $cols ,]) VALUES(200, [join $vals ,])
+"
+do_write_test fts3cov-3.4 t2_content "
+  INSERT INTO t2(docid, [join $cols ,]) VALUES(60000, [join $vals ,])
+"
+
+#-------------------------------------------------------------------------
+# If too much data accumulates in the pending-terms hash table, it is
+# flushed to the database automatically, even if the transaction has not
+# finished. The following tests check the effects of encountering an OOM 
+# while doing this.
+#
+do_test fts3cov-4.1 {
+  execsql {
+    CREATE VIRTUAL TABLE t3 USING fts3(x);
+    INSERT INTO t3(t3) VALUES('nodesize=24');
+    INSERT INTO t3(t3) VALUES('maxpending=100');
+  }
+} {}
+set DO_MALLOC_TEST 1 
+do_write_test fts3cov-4.2 t3_content {
+  INSERT INTO t3(docid, x)
+    SELECT 1, 'Then Christabel stretched forth her hand,' UNION ALL
+    SELECT 3, 'And comforted fair Geraldine:'             UNION ALL
+    SELECT 4, '''O well, bright dame, may you command'    UNION ALL
+    SELECT 5, 'The service of Sir Leoline;'               UNION ALL
+    SELECT 2, 'And gladly our stout chivalry'             UNION ALL
+    SELECT 7, 'Will he send forth, and friends withal,'   UNION ALL
+    SELECT 8, 'To guide and guard you safe and free'      UNION ALL
+    SELECT 6, 'Home to your noble father''s hall.'''
+}
+
+#-------------------------------------------------------------------------
+# When building the internal tree structure for each segment b-tree, FTS3
+# assumes that the content of each internal node will be less than
+# $nodesize bytes, where $nodesize is the advisory node size. If this turns
+# out to be untrue, then an extra buffer must be malloc'd for each term.
+# This test case tests these paths and the effects of said mallocs failing
+# by inserting insert a document with some fairly large terms into a
+# full-text table with a very small node-size. 
+#
+# Test this handling of large terms in three contexts:
+#
+#   1. When flushing the pending-terms table.
+#   2. When optimizing the data structures using the INSERT syntax. 
+#   2. When optimizing the data structures using the deprecated SELECT syntax. 
+#
+do_test fts3cov-5.1 {
+  execsql {
+    CREATE VIRTUAL TABLE t4 USING fts3(x);
+    INSERT INTO t4(t4) VALUES('nodesize=24');
+  }
+} {}
+set DO_MALLOC_TEST 1
+
+# Test when flushing pending-terms table.
+do_write_test fts3cov-5.2 t4_content {
+  INSERT INTO t4
+    SELECT 'ItisanancientMarinerAndhestoppethoneofthreeAA' UNION ALL
+    SELECT 'ItisanancientMarinerAndhestoppethoneofthreeBB' UNION ALL
+    SELECT 'ItisanancientMarinerAndhestoppethoneofthreeCC' UNION ALL
+    SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstAA' UNION ALL
+    SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstBB' UNION ALL
+    SELECT 'BythylonggreybeardandglitteringeyeNowwhereforestoppstCC'
+}
+
+# Test when optimizing via INSERT.
+do_test fts3cov-5.3 { execsql { INSERT INTO t4 VALUES('extra!') } } {}
+do_write_test fts3cov-5.2 t4_segments { INSERT INTO t4(t4) VALUES('optimize') }
+
+# Test when optimizing via SELECT.
+do_test fts3cov-5.5 { execsql { INSERT INTO t4 VALUES('more extra!') } } {}
+do_write_test fts3cov-5.6 t4_segments {
+  SELECT * FROM (SELECT optimize(t4) FROM t4 LIMIT 1)
+  EXCEPT SELECT 'Index optimized'
+}
+
+#-------------------------------------------------------------------------
+# When merging all segments at a given level to create a single segment
+# at level+1, FTS3 runs a query of the form:
+#
+#   SELECT count(*) FROM %_segdir WHERE level = ?
+#
+# The query is compiled the first time this operation is required and
+# reused thereafter. This test aims to test the effects of an OOM while
+# preparing and executing this query for the first time.
+#
+# Then, keep inserting rows into the table so that the effects of an OOM
+# while re-executing the same query can also be tested.
+#
+do_test fts3cov-6.1 {
+  execsql { CREATE VIRTUAL TABLE t5 USING fts3(x) }
+  for {set i 0} {$i<16} {incr i} { execsql "INSERT INTO t5 VALUES('term$i')" }
+  execsql { SELECT count(*) FROM t5_segdir }
+} {16}
+
+# First time.
+db close
+sqlite3 db test.db
+do_write_test fts3cov-6.2 t5_content {
+  INSERT INTO t5 VALUES('segment number 16!');
+}
+
+# Second time.
+do_test fts3cov-6.3 {
+  for {set i 1} {$i<16} {incr i} { execsql "INSERT INTO t5 VALUES('term$i')" }
+  execsql { SELECT count(*) FROM t5_segdir }
+} {17}
+do_write_test fts3cov-6.4 t5_content {
+  INSERT INTO t5 VALUES('segment number 16!');
+}
+
+#-------------------------------------------------------------------------
+# Update the docid of a row. Test this in two scenarios:
+#
+#   1. When the row being updated is the only row in the table.
+#   2. When it is not.
+#
+# The two cases above take different paths because in case 1 all data 
+# structures can simply be emptied before inserting the new row record.
+# In case 2, the data structures actually have to be updated.
+#
+do_test fts3cov-7.1 {
+  execsql {
+    CREATE VIRTUAL TABLE t7 USING fts3(a, b, c);
+    INSERT INTO t7 VALUES('A', 'B', 'C');
+    UPDATE t7 SET docid = 5;
+    SELECT docid, * FROM t7;
+  }
+} {5 A B C}
+do_test fts3cov-7.2 {
+  execsql {
+    INSERT INTO t7 VALUES('D', 'E', 'F');
+    UPDATE t7 SET docid = 1 WHERE docid = 6;
+    SELECT docid, * FROM t7;
+  }
+} {1 D E F 5 A B C}
+
+#-------------------------------------------------------------------------
+# If a set of documents are modified within a transaction, the 
+# pending-terms table must be flushed each time a document with a docid
+# less than or equal to the previous docid is modified. 
+#
+# This test checks the effects of an OOM error occuring when the 
+# pending-terms table is flushed for this reason as part of a DELETE 
+# statement.
+#
+do_malloc_test fts3cov-8 -sqlprep {
+  BEGIN;
+    CREATE VIRTUAL TABLE t8 USING fts3;
+    INSERT INTO t8 VALUES('the output of each batch run');
+    INSERT INTO t8 VALUES('(possibly a day''s work)');
+    INSERT INTO t8 VALUES('was written to two separate disks');
+  COMMIT;
+} -sqlbody {
+  BEGIN;
+    DELETE FROM t8 WHERE rowid = 3;
+    DELETE FROM t8 WHERE rowid = 2;
+    DELETE FROM t8 WHERE rowid = 1;
+  COMMIT;
+}
+
+#-------------------------------------------------------------------------
+# Test some branches in the code that handles "special" inserts like:
+#
+#   INSERT INTO t1(t1) VALUES('optimize');
+#
+# Also test that an optimize (INSERT method) works on an empty table.
+#
+set DO_MALLOC_TEST 0
+do_test fts3cov-9.1 {
+  execsql { CREATE VIRTUAL TABLE xx USING fts3 }
+} {}
+do_error_test fts3cov-9.2 {
+  INSERT INTO xx(xx) VALUES('optimise');   -- British spelling
+} {SQL logic error}
+do_error_test fts3cov-9.3 {
+  INSERT INTO xx(xx) VALUES('short');
+} {SQL logic error}
+do_error_test fts3cov-9.4 {
+  INSERT INTO xx(xx) VALUES('waytoolongtobecorrect');
+} {SQL logic error}
+do_test fts3cov-9.5 {
+  execsql { INSERT INTO xx(xx) VALUES('optimize') }
+} {}
+
+#-------------------------------------------------------------------------
+# Test that a table can be optimized in the middle of a transaction when
+# the pending-terms table is non-empty. This case involves some extra
+# branches because data must be read not only from the database, but
+# also from the pending-terms table.
+#
+do_malloc_test fts3cov-10 -sqlprep {
+  CREATE VIRTUAL TABLE t10 USING fts3;
+  INSERT INTO t10 VALUES('Optimising images for the web is a tricky business');
+  BEGIN;
+    INSERT INTO t10 VALUES('You have to get the right balance between');
+} -sqlbody {
+  INSERT INTO t10(t10) VALUES('optimize');
+}
+
+#-------------------------------------------------------------------------
+# Test a full-text query for a term that was once in the index, but is
+# no longer.
+#
+do_test fts3cov-11.1 {
+  execsql { 
+    CREATE VIRTUAL TABLE xx USING fts3;
+    INSERT INTO xx VALUES('one two three');
+    INSERT INTO xx VALUES('four five six');
+    DELETE FROM xx WHERE docid = 1;
+  }
+  execsql { SELECT * FROM xx WHERE xx MATCH 'two' }
+} {}
+
+
+do_malloc_test fts3cov-12 -sqlprep {
+  CREATE VIRTUAL TABLE t12 USING fts3;
+  INSERT INTO t12 VALUES('is one of the two togther');
+  BEGIN;
+    INSERT INTO t12 VALUES('one which was appropriate at the time');
+} -sqlbody {
+  SELECT * FROM t12 WHERE t12 MATCH 'one'
+}
+
+do_malloc_test fts3cov-13 -sqlprep {
+  PRAGMA encoding = 'UTF-16';
+  CREATE VIRTUAL TABLE t13 USING fts3;
+  INSERT INTO t13 VALUES('two scalar functions');
+  INSERT INTO t13 VALUES('scalar two functions');
+  INSERT INTO t13 VALUES('functions scalar two');
+} -sqlbody {
+  SELECT snippet(t13, '%%', '%%', '#') FROM t13 WHERE t13 MATCH 'two';
+  SELECT snippet(t13, '%%', '%%') FROM t13 WHERE t13 MATCH 'two';
+  SELECT snippet(t13, '%%') FROM t13 WHERE t13 MATCH 'two';
+}
+
+do_execsql_test 14.0 {
+  CREATE VIRTUAL TABLE t14 USING fts4(a, b);
+  INSERT INTO t14 VALUES('one two three', 'one three four');
+  INSERT INTO t14 VALUES('a b c', 'd e a');
+}
+do_execsql_test 14.1 {
+  SELECT rowid FROM t14 WHERE t14 MATCH '"one two three"'
+} {1}
+do_execsql_test 14.2 {
+  SELECT rowid FROM t14 WHERE t14 MATCH '"one four"'
+} {}
+do_execsql_test 14.3 {
+  SELECT rowid FROM t14 WHERE t14 MATCH '"e a"'
+} {2}
+do_execsql_test 14.5 {
+  SELECT rowid FROM t14 WHERE t14 MATCH '"e b"'
+} {}
+do_catchsql_test 14.6 {
+  SELECT rowid FROM t14 WHERE rowid MATCH 'one'
+} {1 {unable to use function MATCH in the requested context}}
+do_catchsql_test 14.7 {
+  SELECT rowid FROM t14 WHERE docid MATCH 'one'
+} {1 {unable to use function MATCH in the requested context}}
+
+do_execsql_test 15.0 {
+  CREATE VIRTUAL TABLE t15 USING fts4(a, b, c);
+  INSERT INTO t15 VALUES('abc def ghi', 'abc2 def2 ghi2', 'abc3 def3 ghi3');
+  INSERT INTO t15 VALUES('abc2 def2 ghi2', 'abc2 def2 ghi2', 'abc def3 ghi3');
+}
+do_execsql_test 15.1 {
+  SELECT rowid FROM t15 WHERE t15 MATCH '"abc* def2"'
+} {1 2}
+
+# Test a corruption case.
+#
+sqlite3_db_config db DEFENSIVE 0
+do_execsql_test 16.1 {
+  CREATE VIRTUAL TABLE t16 USING fts4;
+  INSERT INTO t16 VALUES('theoretical work to examine the relationship');
+  INSERT INTO t16 VALUES('solution of our problems on the invisible');
+  DELETE FROM t16_content WHERE rowid = 2;
+}
+do_catchsql_test 16.2 {
+  SELECT * FROM t16 WHERE t16 MATCH 'invisible'
+} {1 {database disk image is malformed}}
+
+# And another corruption test case.
+#
+do_execsql_test 17.1 {
+  CREATE VIRTUAL TABLE t17 USING fts4;
+  INSERT INTO t17(content) VALUES('one one one');
+  UPDATE t17_segdir SET root = X'00036F6E65FFFFFFFFFFFFFFFFFFFFFF02030300'
+} {}
+do_catchsql_test 17.2 {
+  SELECT * FROM t17 WHERE t17 MATCH 'one'
+} {1 {database disk image is malformed}}
+
+
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3e.test

@@ -0,0 +1,125 @@
+# 2008 July 29
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# These tests exercise the various types of fts3 cursors.
+#
+# $Id: fts3e.test,v 1.1 2008/07/29 20:24:46 shess Exp $
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# If SQLITE_ENABLE_FTS3 is not defined, omit this file.
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+#*************************************************************************
+# Test table scan (QUERY_GENERIC).  This kind of query happens for
+# queries with no WHERE clause, or for WHERE clauses which cannot be
+# satisfied by an index.
+db eval {
+  DROP TABLE IF EXISTS t1;
+  CREATE VIRTUAL TABLE t1 USING fts3(c);
+  INSERT INTO t1 (docid, c) VALUES (1, 'This is a test');
+  INSERT INTO t1 (docid, c) VALUES (2, 'That was a test');
+  INSERT INTO t1 (docid, c) VALUES (3, 'This is a test');
+}
+
+do_test fts3e-1.1 {
+  execsql {
+    SELECT docid FROM t1 ORDER BY docid;
+  }
+} {1 2 3}
+
+do_test fts3e-1.2 {
+  execsql {
+    SELECT docid FROM t1 WHERE c LIKE '%test' ORDER BY docid;
+  }
+} {1 2 3}
+
+do_test fts3e-1.3 {
+  execsql {
+    SELECT docid FROM t1 WHERE c LIKE 'That%' ORDER BY docid;
+  }
+} {2}
+
+#*************************************************************************
+# Test lookup by docid (QUERY_DOCID).  This kind of query happens for
+# queries which select by the docid/rowid implicit index.
+db eval {
+  DROP TABLE IF EXISTS t1;
+  DROP TABLE IF EXISTS t2;
+  CREATE VIRTUAL TABLE t1 USING fts3(c);
+  CREATE TABLE t2(id INTEGER PRIMARY KEY AUTOINCREMENT, weight INTEGER UNIQUE);
+  INSERT INTO t2 VALUES (null, 10);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'This is a test');
+  INSERT INTO t2 VALUES (null, 5);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'That was a test');
+  INSERT INTO t2 VALUES (null, 20);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'This is a test');
+}
+
+# TODO(shess): This actually is doing QUERY_GENERIC?  I'd have
+# expected QUERY_DOCID in this case, as for a very large table the
+# full scan is less efficient.
+do_test fts3e-2.1 {
+  execsql {
+    SELECT docid FROM t1 WHERE docid in (1, 2, 10);
+    SELECT rowid FROM t1 WHERE rowid in (1, 2, 10);
+  }
+} {1 2 1 2}
+
+do_test fts3e-2.2 {
+  execsql {
+    SELECT docid, weight FROM t1, t2 WHERE t2.id = t1.docid ORDER BY weight;
+    SELECT t1.rowid, weight FROM t1, t2 WHERE t2.id = t1.rowid ORDER BY weight;
+  }
+} {2 5 1 10 3 20 2 5 1 10 3 20}
+
+do_test fts3e-2.3 {
+  execsql {
+    SELECT docid, weight FROM t1, t2
+           WHERE t2.weight>5 AND t2.id = t1.docid ORDER BY weight;
+    SELECT t1.rowid, weight FROM t1, t2
+           WHERE t2.weight>5 AND t2.id = t1.rowid ORDER BY weight;
+  }
+} {1 10 3 20 1 10 3 20}
+
+#*************************************************************************
+# Test lookup by MATCH (QUERY_FULLTEXT).  This is the fulltext index.
+db eval {
+  DROP TABLE IF EXISTS t1;
+  DROP TABLE IF EXISTS t2;
+  CREATE VIRTUAL TABLE t1 USING fts3(c);
+  CREATE TABLE t2(id INTEGER PRIMARY KEY AUTOINCREMENT, weight INTEGER UNIQUE);
+  INSERT INTO t2 VALUES (null, 10);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'This is a test');
+  INSERT INTO t2 VALUES (null, 5);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'That was a test');
+  INSERT INTO t2 VALUES (null, 20);
+  INSERT INTO t1 (docid, c) VALUES (last_insert_rowid(), 'This is a test');
+}
+
+do_test fts3e-3.1 {
+  execsql {
+    SELECT docid FROM t1 WHERE t1 MATCH 'this' ORDER BY docid;
+  }
+} {1 3}
+
+do_test fts3e-3.2 {
+  execsql {
+    SELECT docid, weight FROM t1, t2
+     WHERE t1 MATCH 'this' AND t1.docid = t2.id ORDER BY weight;
+  }
+} {1 10 3 20}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3fault.test

@@ -0,0 +1,263 @@
+# 2010 June 15
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+set ::testprefix fts3fault
+
+# If SQLITE_ENABLE_FTS3 is not defined, omit this file.
+ifcapable !fts3 { finish_test ; return }
+
+set ::TMPDBERROR [list 1 \
+  {unable to open a temporary database file for storing temporary tables}
+]
+
+# Test error handling in the sqlite3Fts3Init() function. This is the 
+# function that registers the FTS3 module and various support functions
+# with SQLite.
+#
+do_faultsim_test 1 -body { 
+  sqlite3 db test.db 
+  expr 0
+} -test {
+  catch { db close }
+}
+
+# Test error handling in an "ALTER TABLE ... RENAME TO" statement on an
+# FTS3 table. Specifically, test renaming the table within a transaction
+# after it has been written to.
+#
+faultsim_delete_and_reopen
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE t1 USING fts3;
+  INSERT INTO t1 VALUES('test renaming the table');
+  INSERT INTO t1 VALUES(' after it has been written');
+}
+do_faultsim_test 2 -prep { 
+  sqlite3 db test.db
+  execsql {
+    BEGIN;
+      INSERT INTO t1 VALUES('registers the FTS3 module');
+      INSERT INTO t1 VALUES('various support functions');
+  }
+} -body {
+  execsql { ALTER TABLE t1 RENAME TO t2 }
+} -test {
+  faultsim_test_result {0 {}} $::TMPDBERROR
+}
+
+# Test error handling in the special case where a single prefix query 
+# matches terms that reside on a large range of leaf nodes.
+#
+do_test fts3fault-3.0 {
+  sqlite3 db test.db
+  execsql { CREATE VIRTUAL TABLE t3 USING fts4; }
+  execsql { INSERT INTO t3(t3) VALUES('nodesize=50') }
+  execsql { BEGIN }
+  for {set i 0} {$i < 1000} {incr i} {
+    execsql { INSERT INTO t3 VALUES('aaa' || $i) }
+  }
+  execsql { COMMIT }
+} {}
+
+do_faultsim_test 3 -faults oom-transient -prep { 
+  sqlite3 db test.db
+  execsql { SELECT * FROM t3 WHERE t3 MATCH 'x' }
+} -body {
+  execsql { SELECT count(rowid) FROM t3 WHERE t3 MATCH 'aa*' }
+} -test {
+  faultsim_test_result {0 1000} 
+}
+
+do_test fts3fault-4.0 {
+  faultsim_delete_and_reopen
+  execsql { 
+    CREATE VIRTUAL TABLE t4 USING fts4; 
+    INSERT INTO t4 VALUES('The British Government called on');
+    INSERT INTO t4 VALUES('as pesetas then became much');
+  }
+} {}
+faultsim_save_and_close
+do_faultsim_test 4 -prep { 
+  faultsim_restore_and_reopen
+  execsql { SELECT content FROM t4 }
+} -body {
+  execsql { SELECT optimize(t4) FROM t4 LIMIT 1 }
+} -test {
+  faultsim_test_result {0 {{Index optimized}}}
+}
+
+do_test fts3fault-5.0 {
+  faultsim_delete_and_reopen
+  execsql { 
+    CREATE VIRTUAL TABLE t5 USING fts4; 
+    INSERT INTO t5 VALUES('The British Government called on');
+    INSERT INTO t5 VALUES('as pesetas then became much');
+  }
+} {}
+faultsim_save_and_close
+do_faultsim_test 5 -prep { 
+  faultsim_restore_and_reopen
+  execsql { 
+    BEGIN;
+      INSERT INTO t5 VALUES('influential in shaping his future outlook');
+      INSERT INTO t5 VALUES('might be acceptable to the British electorate');
+  }
+} -body {
+  execsql { SELECT rowid FROM t5 WHERE t5 MATCH 'british' }
+} -test {
+  faultsim_test_result {0 {1 4}}
+}
+
+do_test fts3fault-6.0 {
+  faultsim_delete_and_reopen
+  execsql { CREATE VIRTUAL TABLE t6 USING fts4 }
+} {}
+faultsim_save_and_close
+do_faultsim_test 6 -prep { 
+  faultsim_restore_and_reopen
+  execsql { SELECT rowid FROM t6 }
+} -body {
+  execsql { DROP TABLE t6 }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+# Test various malloc failures while processing FTS4 parameters.
+#
+do_faultsim_test 7.1 -prep { 
+  faultsim_delete_and_reopen
+} -body {
+  execsql { CREATE VIRTUAL TABLE t1 USING fts4(a, b, matchinfo=fts3) }
+} -test {
+  faultsim_test_result {0 {}}
+}
+do_faultsim_test 7.2 -prep { 
+  faultsim_delete_and_reopen
+} -body {
+  execsql { CREATE VIRTUAL TABLE t1 USING fts4(a, b, matchinfo=fs3) }
+} -test {
+  faultsim_test_result {1 {unrecognized matchinfo: fs3}} \
+                       {1 {vtable constructor failed: t1}} \
+                       {1 {SQL logic error}}
+}
+do_faultsim_test 7.3 -prep { 
+  faultsim_delete_and_reopen
+} -body {
+  execsql { CREATE VIRTUAL TABLE t1 USING fts4(a, b, matchnfo=fts3) }
+} -test {
+  faultsim_test_result {1 {unrecognized parameter: matchnfo=fts3}} \
+                       {1 {vtable constructor failed: t1}} \
+                       {1 {SQL logic error}}
+}
+
+
+proc mit {blob} {
+  set scan(littleEndian) i*
+  set scan(bigEndian) I*
+  binary scan $blob $scan($::tcl_platform(byteOrder)) r
+  return $r
+}
+
+do_test 8.0 {
+  faultsim_delete_and_reopen
+  execsql { CREATE VIRTUAL TABLE t8 USING fts4 }
+  execsql "INSERT INTO t8 VALUES('a b c')"
+  execsql "INSERT INTO t8 VALUES('b b b')"
+  execsql "INSERT INTO t8 VALUES('[string repeat {c } 50000]')"
+  execsql "INSERT INTO t8 VALUES('d d d')"
+  execsql "INSERT INTO t8 VALUES('e e e')"
+  execsql "INSERT INTO t8(t8) VALUES('optimize')"
+  faultsim_save_and_close
+} {}
+
+ifcapable fts4_deferred {
+  do_faultsim_test 8.1 -faults oom-t* -prep { 
+    faultsim_restore_and_reopen
+    db func mit mit
+  } -body {
+    execsql { SELECT mit(matchinfo(t8, 'x')) FROM t8 WHERE t8 MATCH 'a b c' }
+  } -test {
+    faultsim_test_result {0 {{1 1 1 1 4 2 1 5 5}}}
+  }
+}
+
+do_faultsim_test 8.2 -faults oom-t* -prep { 
+  faultsim_restore_and_reopen
+  db func mit mit
+} -body {
+  execsql { SELECT mit(matchinfo(t8, 's')) FROM t8 WHERE t8 MATCH 'a b c' }
+} -test {
+  faultsim_test_result {0 3} $::TMPDBERROR
+}
+do_faultsim_test 8.3 -prep { 
+  faultsim_restore_and_reopen
+  db func mit mit
+} -body {
+  execsql { SELECT mit(matchinfo(t8, 'a')) FROM t8 WHERE t8 MATCH 'a b c' }
+} -test {
+  faultsim_test_result {0 10002}
+}
+do_faultsim_test 8.4 -prep { 
+  faultsim_restore_and_reopen
+  db func mit mit
+} -body {
+  execsql { SELECT mit(matchinfo(t8, 'l')) FROM t8 WHERE t8 MATCH 'a b c' }
+} -test {
+  faultsim_test_result {0 3}
+}
+
+do_test 9.0 {
+  faultsim_delete_and_reopen
+  execsql {
+    CREATE VIRTUAL TABLE t9 USING fts4(tokenize=porter);
+    INSERT INTO t9 VALUES(
+      'this record is used toooooooooooooooooooooooooooooooooooooo try to'
+    );
+    SELECT offsets(t9) FROM t9 WHERE t9 MATCH 'to*';
+  }
+  faultsim_save_and_close
+} {}
+do_faultsim_test 9.1 -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { SELECT offsets(t9) FROM t9 WHERE t9 MATCH 'to*' }
+} -test {
+  faultsim_test_result {0 {{0 0 20 39 0 0 64 2}}}
+}
+
+do_faultsim_test 10.1 -prep {
+  faultsim_delete_and_reopen
+} -body {
+  execsql { CREATE VIRTUAL TABLE t1 USING fts4(a, b, languageid=d) }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 11.0 {
+  CREATE VIRTUAL TABLE t1 USING fts3(a, b);
+}
+faultsim_save_and_close
+
+do_faultsim_test 11 -faults oom* -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { DROP TABLE t1 }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3misc.test

@@ -0,0 +1,326 @@
+# 2017 March 22
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS3 module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix fts3misc
+
+# If SQLITE_ENABLE_FTS3 is defined, omit this file.
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+#-------------------------------------------------------------------------
+# A self-join.
+#
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts3(a, b);
+  INSERT INTO t1 VALUES('one', 'i');
+  INSERT INTO t1 VALUES('one', 'ii');
+  INSERT INTO t1 VALUES('two', 'i');
+  INSERT INTO t1 VALUES('two', 'ii');
+}
+
+do_execsql_test 1.1 {
+  SELECT a.a, b.b FROM t1 a, t1 b WHERE a.t1 MATCH 'two' AND b.t1 MATCH 'i'
+} {two i two i two i two i}
+
+#-------------------------------------------------------------------------
+# FTS tables with 128 or more columns.
+#
+proc v1 {v} {
+  set vector [list a b c d e f g h]
+  set res [list]
+  for {set i 0} {$i<8} {incr i} {
+    if {$v & (1 << $i)} { lappend res [lindex $vector $i] }
+  }
+  set res
+}
+proc v2 {v} {
+  set vector [list d e f g h i j k]
+  set res [list]
+  for {set i 0} {$i<8} {incr i} {
+    if {$v & (1 << $i)} { lappend res [lindex $vector $i] }
+  }
+  set res
+}
+db func v1 v1
+db func v2 v2
+
+do_test 2.0 {
+  set cols [list]
+  for {set i 0} {$i<200} {incr i} {
+    lappend cols "c$i"
+  }
+  execsql "CREATE VIRTUAL TABLE t2 USING fts3([join $cols ,])"
+  execsql {
+    WITH data(i) AS (
+      SELECT 1 UNION ALL SELECT i+1 FROM data WHERE i<200
+    )
+    INSERT INTO t2(c198, c199) SELECT v1(i), v2(i) FROM data;
+  }
+} {}
+do_execsql_test 2.1 {
+  SELECT rowid FROM t2 WHERE t2 MATCH '"a b c"'
+} {
+  7 15 23 31 39 47 55 63 71 79 87 95 103 111 
+  119 127 135 143 151 159 167 175 183 191 199
+}
+do_execsql_test 2.2 {
+  SELECT rowid FROM t2 WHERE t2 MATCH '"g h i"'
+} {
+  56 57 58 59 60 61 62 63 120 121 122 123 124 
+  125 126 127 184 185 186 187 188 189 190 191
+}
+do_execsql_test 2.3 {
+  SELECT rowid FROM t2 WHERE t2 MATCH '"i h"'
+} {
+}
+do_execsql_test 2.4 {
+  SELECT rowid FROM t2 WHERE t2 MATCH '"f e"'
+} {
+}
+do_execsql_test 2.5 {
+  SELECT rowid FROM t2 WHERE t2 MATCH '"e f"'
+} {
+  6 7 14 15 22 23 30 31 38 39 46 47 48 49 50 51 52 53 54 55 56 
+  57 58 59 60 61 62 63 70 71 78 79 86 87 94 95 102 103 110 
+  111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
+  134 135 142 143 150 151 158 159 166 167 174 175 176 177 178 179 180 
+  181 182 183 184 185 186 187 188 189 190 191 198 199
+}
+
+#-------------------------------------------------------------------------
+# Range constraints on the docid using non-integer values.
+#
+do_execsql_test 2.6 {
+  SELECT rowid FROM t2 WHERE t2 MATCH 'e' AND rowid BETWEEN NULL AND 45;
+} {}
+do_execsql_test 2.7 {
+  SELECT rowid FROM t2 WHERE t2 MATCH 'e' AND rowid BETWEEN 11.5 AND 48.2;
+} {
+  14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
+  29 30 31 34 35 38 39 42 43 46 47 48
+}
+do_execsql_test 2.8 {
+  SELECT rowid FROM t2 WHERE t2 MATCH 'e' AND rowid BETWEEN '11.5' AND '48.2';
+} {
+  14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
+  29 30 31 34 35 38 39 42 43 46 47 48
+}
+
+#-------------------------------------------------------------------------
+# Phrase query tests. 
+#
+do_execsql_test 3.1.1 {
+  CREATE VIRTUAL TABLE t3 USING fts3;
+  INSERT INTO t3 VALUES('a b c');
+  INSERT INTO t3 VALUES('d e f');
+  INSERT INTO t3 VALUES('a b d');
+  INSERT INTO t3 VALUES('1 2 3 4 5 6 7 8 9 10 11');
+}
+do_execsql_test 3.1.2 {
+  SELECT * FROM t3 WHERE t3 MATCH '"a b x y"' ORDER BY docid DESC
+}
+do_execsql_test 3.1.3 {
+  SELECT * FROM t3 WHERE t3 MATCH '"a b c" OR "a b x y"' ORDER BY docid DESC
+} {{a b c}}
+do_execsql_test 3.1.4 {
+  SELECT * FROM t3 WHERE t3 MATCH '"a* b* x* a*"'
+}
+do_execsql_test 3.1.5 {
+  SELECT rowid FROM t3 WHERE t3 MATCH '"2 3 4 5 6 7 8 9"'
+} {4}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+ifcapable fts4_deferred {
+  do_execsql_test 4.0 {
+    PRAGMA page_size = 512;
+    CREATE VIRTUAL TABLE t4 USING fts4;
+    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<8000 )
+    INSERT INTO t4 SELECT 'a b c a b c a b c' FROM s;
+  }
+  do_execsql_test 4.1 {
+    SELECT count(*) FROM t4 WHERE t4 MATCH '"a b c" OR "c a b"'
+  } {8000}
+  do_execsql_test 4.2 {
+    SELECT quote(value) from t4_stat where id=0
+  } {X'C03EC0B204C0A608'}
+  sqlite3_db_config db DEFENSIVE 0
+  do_execsql_test 4.3 {
+    UPDATE t4_stat SET value = X'C03EC0B204C0A60800' WHERE id=0;
+  }
+  do_catchsql_test 4.4 {
+    SELECT count(*) FROM t4 WHERE t4 MATCH '"a b c" OR "c a b"'
+  } {1 {database disk image is malformed}}
+  do_execsql_test 4.5 {
+    UPDATE t4_stat SET value = X'00C03EC0B204C0A608' WHERE id=0;
+  }
+  do_catchsql_test 4.6 {
+    SELECT count(*) FROM t4 WHERE t4 MATCH '"a b c" OR "c a b"'
+  } {1 {database disk image is malformed}}
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 5.0 {
+  CREATE VIRTUAL TABLE t5 USING fts4;
+  INSERT INTO t5 VALUES('a x x x x b x x x x c');
+  INSERT INTO t5 VALUES('a x x x x b x x x x c');
+  INSERT INTO t5 VALUES('a x x x x b x x x x c');
+}
+do_execsql_test 5.1 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'a NEAR/4 b NEAR/4 c'
+} {1 2 3}
+do_execsql_test 5.2 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'a NEAR/3 b NEAR/4 c'
+} {}
+do_execsql_test 5.3 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'a NEAR/4 b NEAR/3 c'
+} {}
+do_execsql_test 5.4 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'y NEAR/4 b NEAR/4 c'
+} {}
+do_execsql_test 5.5 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'x OR a NEAR/3 b NEAR/3 c'
+} {1 2 3}
+do_execsql_test 5.5 {
+  SELECT rowid FROM t5 WHERE t5 MATCH 'x OR y NEAR/3 b NEAR/3 c'
+} {1 2 3}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 6.0 {
+  CREATE VIRTUAL TABLE t6 USING fts4;
+
+  BEGIN;
+  WITH s(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<50000)
+    INSERT INTO t6 SELECT 'x x x x x x x x x x x' FROM s;
+
+  INSERT INTO t6 VALUES('x x x x x x x x x x x A');
+  INSERT INTO t6 VALUES('x x x x x x x x x x x B');
+  INSERT INTO t6 VALUES('x x x x x x x x x x x A');
+  INSERT INTO t6 VALUES('x x x x x x x x x x x B');
+
+  WITH s(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<50000)
+    INSERT INTO t6 SELECT 'x x x x x x x x x x x' FROM s;
+  COMMIT;
+}
+do_execsql_test 6.1 {
+  SELECT rowid FROM t6 WHERE t6 MATCH 'b OR "x a"'
+} {50001 50002 50003 50004}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 7.0 {
+  CREATE VIRTUAL TABLE vt0 USING fts3(c0);
+  INSERT INTO vt0 VALUES (x'00');
+}
+do_execsql_test 7.1 {
+  INSERT INTO vt0(vt0) VALUES('integrity-check');
+}
+
+#-------------------------------------------------------------------------
+# Ticket [8a6fa2bb].
+#
+reset_db
+do_execsql_test 7.0.1 {
+  CREATE VIRTUAL TABLE vt0 USING fts4(c0, order=DESC);
+  INSERT INTO vt0(c0) VALUES (0), (0);
+}
+do_execsql_test 7.0.2 {
+  INSERT INTO vt0(vt0) VALUES('integrity-check');
+}
+reset_db
+do_execsql_test 7.1.1 {
+  CREATE VIRTUAL TABLE vt0 USING fts4(c0, order=ASC);
+  INSERT INTO vt0(c0) VALUES (0), (0);
+}
+do_execsql_test 7.1.2 {
+  INSERT INTO vt0(vt0) VALUES('integrity-check');
+}
+do_execsql_test 7.2.1 {
+  CREATE VIRTUAL TABLE ft USING fts4(c0, c1, order=DESC, prefix=1);
+  INSERT INTO ft VALUES('a b c d', 'hello world');
+  INSERT INTO ft VALUES('negative', 'positive');
+  INSERT INTO ft VALUES('hello world', 'a b c d');
+}
+do_execsql_test 7.2.2 {
+  INSERT INTO vt0(vt0) VALUES('integrity-check');
+}
+
+#-------------------------------------------------------------------------
+# Ticket [745f1abc].
+#
+reset_db
+do_execsql_test 8.1 {
+  CREATE VIRTUAL TABLE vt0 USING fts4(c0, prefix=1);
+}
+do_execsql_test 8.2 {
+  BEGIN;
+    INSERT INTO vt0 VALUES (0);
+    INSERT INTO vt0(vt0) VALUES('optimize');
+  COMMIT;
+}
+do_execsql_test 8.3 {
+  INSERT INTO vt0(vt0) VALUES('integrity-check');
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 9.0 {
+  CREATE VIRTUAL TABLE t1 using fts4(mailcontent);
+  insert into t1(rowid, mailcontent) values
+      (-4764623217061966105, 'we are going to upgrade'),
+      (8324454597464624651, 'we are going to upgrade');
+}
+
+do_execsql_test 9.1 {
+  INSERT INTO t1(t1) VALUES('integrity-check');
+}
+
+do_execsql_test 9.2 {
+  SELECT rowid FROM t1 WHERE t1 MATCH 'upgrade';
+} {
+  -4764623217061966105 8324454597464624651
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 10.0 {
+  CREATE VIRTUAL TABLE f USING fts3(a,b);
+  CREATE TABLE 'f_stat'(id INTEGER PRIMARY KEY, value BLOB);
+  INSERT INTO f_stat VALUES (1,x'3b3b3b3b3b3b3b28ffffffffffffffffff1807f9073481f1d43bc93b3b3b3b3b3b3b3b3b3b18073b3b3b3b3b3b3b9b003b');
+} {}
+
+do_catchsql_test 10.1 {
+  INSERT INTO f(f) VALUES ('merge=69,59');
+} {1 {database disk image is malformed}}
+
+#-------------------------------------------------------------------------
+do_execsql_test 11.0 {
+  CREATE VIRTUAL TABLE xyz USING fts3();
+}
+do_execsql_test 11.1 {
+  SELECT * FROM xyz WHERE xyz MATCH 'a NEAR/4294836224 a';
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3prefix2.test

@@ -0,0 +1,61 @@
+# 2012 January 25
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS3 module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix fts3prefix2
+
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 { PRAGMA page_size = 512 }
+do_execsql_test 1.1 { 
+  CREATE VIRTUAL TABLE t1 USING fts4(x, prefix="2,3");
+
+  BEGIN;
+    INSERT INTO t1 VALUES('T TX T TX T TX T TX T TX');
+    INSERT INTO t1 SELECT * FROM t1;                       -- 2
+    INSERT INTO t1 SELECT * FROM t1;                       -- 4
+    INSERT INTO t1 SELECT * FROM t1;                       -- 8
+    INSERT INTO t1 SELECT * FROM t1;                       -- 16
+    INSERT INTO t1 SELECT * FROM t1;                       -- 32
+    INSERT INTO t1 SELECT * FROM t1;                       -- 64
+    INSERT INTO t1 SELECT * FROM t1;                       -- 128
+    INSERT INTO t1 SELECT * FROM t1;                       -- 256
+    INSERT INTO t1 SELECT * FROM t1;                       -- 512
+    INSERT INTO t1 SELECT * FROM t1;                       -- 1024
+    INSERT INTO t1 SELECT * FROM t1;                       -- 2048
+  COMMIT;
+}
+
+do_execsql_test 1.2 {
+  INSERT INTO t1 SELECT * FROM t1 LIMIT 10;
+  INSERT INTO t1 SELECT * FROM t1 LIMIT 10;
+  INSERT INTO t1 SELECT * FROM t1 LIMIT 10;
+  DELETE FROM t1 WHERE docid > 5;
+}
+
+do_execsql_test 1.3 {
+  SELECT * FROM t1 WHERE t1 MATCH 'T*';
+} {
+  {T TX T TX T TX T TX T TX}
+  {T TX T TX T TX T TX T TX}
+  {T TX T TX T TX T TX T TX}
+  {T TX T TX T TX T TX T TX}
+  {T TX T TX T TX T TX T TX}
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts3varint.test

@@ -0,0 +1,121 @@
+# 2007 November 23
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file runs all tests.
+#
+# $Id: fts3.test,v 1.2 2008/07/23 18:17:32 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix fts3varint
+
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+proc test_list {list} {
+  foreach n $list { fts3_test_varint $n }
+}
+
+proc do_fts3_varint_test {tn list} {
+  uplevel [list do_test $tn [list test_list $list] {}]
+}
+
+do_fts3_varint_test 1.0 {
+  1 10 100 1000 10000 100000 1000000 
+  10000000 100000000 1000000000 10000000000
+  100000000000 1000000000000 10000000000000
+}
+
+do_fts3_varint_test 1.1 {
+  -1 -10 -100 -1000 -10000 -100000 -1000000 
+  -10000000 -100000000 -1000000000 -10000000000
+  -100000000000 -1000000000000 -10000000000000
+}
+
+do_fts3_varint_test 2.0 { 0 1 2 }
+do_fts3_varint_test 2.1 { 1 2 3 }
+do_fts3_varint_test 2.2 { 3 4 5 }
+do_fts3_varint_test 2.3 { 7 8 9 }
+do_fts3_varint_test 2.4 { 15 16 17 }
+do_fts3_varint_test 2.5 { 31 32 33 }
+do_fts3_varint_test 2.6 { 63 64 65 }
+do_fts3_varint_test 2.7 { 127 128 129 }
+do_fts3_varint_test 2.8 { 255 256 257 }
+do_fts3_varint_test 2.9 { 511 512 513 }
+do_fts3_varint_test 2.10 { 1023 1024 1025 }
+do_fts3_varint_test 2.11 { 2047 2048 2049 }
+do_fts3_varint_test 2.12 { 4095 4096 4097 }
+do_fts3_varint_test 2.13 { 8191 8192 8193 }
+do_fts3_varint_test 2.14 { 16383 16384 16385 }
+do_fts3_varint_test 2.15 { 32767 32768 32769 }
+do_fts3_varint_test 2.16 { 65535 65536 65537 }
+do_fts3_varint_test 2.17 { 131071 131072 131073 }
+do_fts3_varint_test 2.18 { 262143 262144 262145 }
+do_fts3_varint_test 2.19 { 524287 524288 524289 }
+do_fts3_varint_test 2.20 { 1048575 1048576 1048577 }
+do_fts3_varint_test 2.21 { 2097151 2097152 2097153 }
+do_fts3_varint_test 2.22 { 4194303 4194304 4194305 }
+do_fts3_varint_test 2.23 { 8388607 8388608 8388609 }
+do_fts3_varint_test 2.24 { 16777215 16777216 16777217 }
+do_fts3_varint_test 2.25 { 33554431 33554432 33554433 }
+do_fts3_varint_test 2.26 { 67108863 67108864 67108865 }
+do_fts3_varint_test 2.27 { 134217727 134217728 134217729 }
+do_fts3_varint_test 2.28 { 268435455 268435456 268435457 }
+do_fts3_varint_test 2.29 { 536870911 536870912 536870913 }
+do_fts3_varint_test 2.30 { 1073741823 1073741824 1073741825 }
+do_fts3_varint_test 2.31 { 2147483647 2147483648 2147483649 }
+do_fts3_varint_test 2.32 { 4294967295 4294967296 4294967297 }
+do_fts3_varint_test 2.33 { 8589934591 8589934592 8589934593 }
+do_fts3_varint_test 2.34 { 17179869183 17179869184 17179869185 }
+do_fts3_varint_test 2.35 { 34359738367 34359738368 34359738369 }
+do_fts3_varint_test 2.36 { 68719476735 68719476736 68719476737 }
+do_fts3_varint_test 2.37 { 137438953471 137438953472 137438953473 }
+do_fts3_varint_test 2.38 { 274877906943 274877906944 274877906945 }
+do_fts3_varint_test 2.39 { 549755813887 549755813888 549755813889 }
+do_fts3_varint_test 2.40 { 1099511627775 1099511627776 1099511627777 }
+do_fts3_varint_test 2.41 { 2199023255551 2199023255552 2199023255553 }
+do_fts3_varint_test 2.42 { 4398046511103 4398046511104 4398046511105 }
+do_fts3_varint_test 2.43 { 8796093022207 8796093022208 8796093022209 }
+do_fts3_varint_test 2.44 { 17592186044415 17592186044416 17592186044417 }
+do_fts3_varint_test 2.45 { 35184372088831 35184372088832 35184372088833 }
+do_fts3_varint_test 2.46 { 70368744177663 70368744177664 70368744177665 }
+do_fts3_varint_test 2.47 { 140737488355327 140737488355328 140737488355329 }
+do_fts3_varint_test 2.48 { 281474976710655 281474976710656 281474976710657 }
+do_fts3_varint_test 2.49 { 562949953421311 562949953421312 562949953421313 }
+do_fts3_varint_test 2.50 { 1125899906842623 1125899906842624 1125899906842625 }
+do_fts3_varint_test 2.51 { 2251799813685247 2251799813685248 2251799813685249 }
+do_fts3_varint_test 2.52 { 4503599627370495 4503599627370496 4503599627370497 }
+do_fts3_varint_test 2.53 { 9007199254740991 9007199254740992 9007199254740993 }
+do_fts3_varint_test 2.54 { 
+    18014398509481983 18014398509481984 18014398509481985 }
+do_fts3_varint_test 2.55 { 
+    36028797018963967 36028797018963968 36028797018963969 }
+do_fts3_varint_test 2.56 { 
+    72057594037927935 72057594037927936 72057594037927937 }
+do_fts3_varint_test 2.57 { 
+    144115188075855871 144115188075855872 144115188075855873 }
+do_fts3_varint_test 2.58 { 
+    288230376151711743 288230376151711744 288230376151711745 }
+do_fts3_varint_test 2.59 { 
+    576460752303423487 576460752303423488 576460752303423489 }
+do_fts3_varint_test 2.60 { 
+    1152921504606846975 1152921504606846976 1152921504606846977 }
+do_fts3_varint_test 2.61 { 
+    2305843009213693951 2305843009213693952 2305843009213693953 }
+do_fts3_varint_test 2.62 { 
+    4611686018427387903 4611686018427387904 4611686018427387905 }
+
+if {![catch {fts3_test_varint 18446744073709551615}]} {
+  do_fts3_varint_test 2.63 { 
+      9223372036854775807 9223372036854775808 9223372036854775809 }
+
+  do_fts3_varint_test 3.0 { 18446744073709551615 -18446744073709551615 }
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts4aa.test

@@ -0,0 +1,256 @@
+# 2010 February 02
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS4 module.
+#
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# If SQLITE_ENABLE_FTS3 is defined, omit this file.
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+# Create the fts_kjv_genesis procedure which fills and FTS3/4 table with
+# the complete text of the Book of Genesis.
+#
+source $testdir/genesis.tcl
+
+# The following is a list of queries to perform against the above
+# FTS3/FTS4 database.  We will be trying these queries in various
+# configurations to ensure that they always return the same answers.
+#
+set fts4aa_queries {
+  {abraham}
+  {the king}
+  {"the king"}
+  {abraham OR joseph}
+  {ab* OR jos*}
+  {lived t*}
+  {spake hebrew}
+  {melchizedek}
+  {t* melchizedek}
+  {melchizedek t*}
+}
+unset -nocomplain fts4aa_res
+
+# Set up the baseline results
+#
+do_test fts4aa-1.0 {
+  db eval {
+    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
+  }
+  fts_kjv_genesis
+  foreach q $::fts4aa_queries {
+    set r [db eval {SELECT docid FROM t1 WHERE words MATCH $q ORDER BY docid}]
+    set ::fts4aa_res($q) $r
+  }
+} {}
+
+# Legacy test cases
+#
+do_test fts4aa-1.1 {
+  db eval {
+    SELECT docid FROM t1 EXCEPT SELECT docid FROM t1_docsize
+  }
+} {}
+do_test fts4aa-1.2 {
+  db eval {
+    SELECT docid FROM t1_docsize EXCEPT SELECT docid FROM t1
+  }
+} {}
+
+proc mit {blob} {
+  set scan(littleEndian) i*
+  set scan(bigEndian) I*
+  binary scan $blob $scan($::tcl_platform(byteOrder)) r
+  return $r
+}
+db func mit mit
+
+do_test fts4aa-1.3 {
+  db eval {
+    SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1 WHERE t1 MATCH 'melchizedek';
+  }
+} {1014018 {1 1 1 1 1 1533 25 20}}
+do_test fts4aa-1.4 {
+  db eval {
+    SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
+     WHERE t1 MATCH 'spake hebrew'
+     ORDER BY docid;
+  }
+} {1039014 {2 1 1 40 40 1 6 6 1533 25 42} 1039017 {2 1 1 40 40 1 6 6 1533 25 26}}
+do_test fts4aa-1.5 {
+  db eval {
+    SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
+     WHERE t1 MATCH 'laban overtook jacob'
+     ORDER BY docid;
+  }
+} {1031025 {3 1 2 54 46 1 3 3 2 181 160 1533 25 24}}
+
+do_test fts4aa-1.6 {
+  db eval {
+    DELETE FROM t1 WHERE docid!=1050026;
+    SELECT hex(size) FROM t1_docsize;
+    SELECT hex(value) FROM t1_stat;
+  }
+} {17 01176F}
+
+do_test fts4aa-1.7 {
+  db eval {
+    SELECT docid FROM t1 EXCEPT SELECT docid FROM t1_docsize
+  }
+} {}
+do_test fts4aa-1.8 {
+  db eval {
+    SELECT docid FROM t1_docsize EXCEPT SELECT docid FROM t1
+  }
+} {}
+ifcapable fts4_deferred {
+  do_test fts4aa-1.9 {
+    # Note: Token 'in' is being deferred in the following query. 
+    db eval {
+      SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
+       WHERE t1 MATCH 'joseph died in egypt'
+       ORDER BY docid;
+    }
+  } {1050026 {4 1 1 1 1 1 1 1 2 1 1 1 1 1 1 23 23}}
+}
+
+# Should get the same search results from FTS3
+#
+do_test fts4aa-2.0 {
+  db eval {
+    DROP TABLE t1;
+    CREATE VIRTUAL TABLE t1 USING fts3(words, tokenize porter);
+  }
+  fts_kjv_genesis
+} {}
+unset -nocomplain ii
+set ii 0
+foreach {q r} [array get fts4aa_res] {
+  incr ii
+  do_test fts4aa-2.$ii {
+    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
+  } $r
+}
+
+# Should get the same search results when the page size is very large
+#
+do_test fts4aa-3.0 {
+  db close
+  forcedelete test.db
+  sqlite3 db test.db
+  db eval {
+    PRAGMA page_size=65536;
+    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
+  }
+  fts_kjv_genesis
+} {}
+unset -nocomplain ii
+set ii 0
+foreach {q r} [array get fts4aa_res] {
+  incr ii
+  do_test fts4aa-3.$ii {
+    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
+  } $r
+}
+
+# Should get the same search results when an authorizer prevents
+# all PRAGMA statements.
+#
+proc no_pragma_auth {code arg1 arg2 arg3 arg4 args} {
+  if {$code=="SQLITE_PRAGMA"} {return SQLITE_DENY}
+  return SQLITE_OK;
+}
+do_test fts4aa-4.0 {
+  db auth ::no_pragma_auth
+  db eval {
+    DROP TABLE t1;
+    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
+  }
+  fts_kjv_genesis
+} {}
+unset -nocomplain ii
+set ii 0
+foreach {q r} [array get fts4aa_res] {
+  incr ii
+  do_test fts4aa-4.$ii {
+    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
+  } $r
+}
+
+# 2019-11-16 https://bugs.chromium.org/p/chromium/issues/detail?id=1025472
+#
+db close
+sqlite3 db :memory:
+do_execsql_test fts4aa-5.10 {
+  CREATE VIRTUAL TABLE t1 USING fts4(a, b, c, d, e,f,g,h,i,j,k,l,m,n,o,p,q,r);
+  INSERT INTO t1 VALUES('X Y', '2', '3', '4', '5', '6', '7', '8', '9', '0',
+                        'a','b','c','d','e','f','g','h');
+  UPDATE t1_docsize SET size=x'88' WHERE docid=1;
+} {}
+do_catchsql_test fts4aa-5.20 {
+  SELECT quote(matchinfo(t1, 'l')) FROM t1 WHERE t1 MATCH 'X Y';
+} {1 {database disk image is malformed}}
+do_execsql_test fts4aa-5.30 {
+  DROP TABLE t1;
+  CREATE VIRTUAL TABLE t1 USING fts4(a,b,c,d);
+  INSERT INTO t1 VALUES('one two','three four','five six','seven eight');
+} {}
+do_catchsql_test fts4aa-5.40 {
+  UPDATE t1_stat SET value=x'01010101' WHERE id=0;
+  SELECT quote(matchinfo(t1,'a')) FROM t1 WHERE t1 MATCH 'one two';
+} {1 {database disk image is malformed}}
+do_catchsql_test fts4aa-5.50 {
+  UPDATE t1_stat SET value=x'010101' WHERE id=0;
+  SELECT quote(matchinfo(t1,'a')) FROM t1 WHERE t1 MATCH 'one two';
+} {1 {database disk image is malformed}}
+do_catchsql_test fts4aa-5.60 {
+  UPDATE t1_stat SET value=x'01' WHERE id=0;
+  SELECT quote(matchinfo(t1,'a')) FROM t1 WHERE t1 MATCH 'one two';
+} {1 {database disk image is malformed}}
+do_catchsql_test fts4aa-5.70 {
+  UPDATE t1_stat SET value=x'' WHERE id=0;
+  SELECT quote(matchinfo(t1,'a')) FROM t1 WHERE t1 MATCH 'one two';
+} {1 {database disk image is malformed}}
+
+# 2019-11-18 https://bugs.chromium.org/p/chromium/issues/detail?id=1025467
+db close
+sqlite3 db :memory:
+if {$tcl_platform(byteOrder)=="littleEndian"} {
+  set res {X'0200000000000000000000000E0000000E00000001000000010000000100000001000000'}
+} else {
+  set res {X'0000000200000000000000000000000E0000000E00000001000000010000000100000001'}
+}
+do_catchsql_test fts4aa-6.10 {
+  CREATE VIRTUAL TABLE f USING fts4();
+  INSERT INTO f_segdir VALUES (77,91,0,0,'255 77',x'0001308000004d5c4ddddddd4d4d7b4d4d4d614d8019ff4d05000001204d4d2e4d6e4d4d4d4b4d6c4d004d4d4d4d4d4d3d000000004d5d4d4d645d4d004d4d4d4d4d4d4d4d4d454d6910004d05ffff054d646c4d004d5d4d4d4d4d3d000000004d4d4d4d4d4d4d4d4d4d4d69624d4d4d04004d4d4d4d4d604d4ce1404d554d45');
+  INSERT INTO f_segdir VALUES (77,108,0,0,'255 77',x'0001310000fa64004d4d4d3c5d4d654d4d4d614d8000ff4d05000001204d4d2e4d6e4d4d4dff4d4d4d4d4d4d00104d4d4d4d000000004d4d4d0400311d4d4d4d4d4d4d4d4d4d684d6910004d05ffff054d4d6c4d004d4d4d4d4d4d3d000000004d4d4d4d644d4d4d4d4d4d69624d4d4d03ed4d4d4d4d4d604d4ce1404d550080');
+  INSERT INTO f_stat VALUES (0,x'80808080100000000064004d4d4d3c4d4d654d4d4d614d8000ff4df6ff1a00204d4d2e4d6e4d4d4d104d4d4d4d4d4d00104d4d4d4d4d4d69574d4d4d000031044d4d4d3e4d4d4c4d05004d6910');
+  SELECT quote(matchinfo(f,'pnax')) from f where f match '0 1';
+} {1 {database disk image is malformed}}
+
+# 2019-11-18 Detect infinite loop in fts3SelectLeaf()
+db close
+sqlite3 db :memory:
+do_catchsql_test fts4aa-7.10 {
+  CREATE VIRTUAL TABLE f USING fts4();
+  INSERT INTO f_segdir VALUES (63,60,60,60,'60 60',x'3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c483c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c20003c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c283c3c3c3c3c3c3c3c3c3c3c223c3c3c3c3c3c3c3c3c');
+  INSERT INTO f_segments VALUES (60,x'3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c5a3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2a3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c5e3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c803c3c3c3c3c3c233c3c3c3c1c3c3c3c3c3c3c3c3c3c3c3c1b3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c273c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c1a3c3c3c3c3c3c000200003c3c3c3c3c3c3c3c3c3c3c3c3c383c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d898d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d3c3c3c3c3c3c3c3c3c3cba3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c1c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c00023c3c3c3c3c3c383c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3cbc3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2c3c3c3c403c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c16161616161616163c3c3c3c3c3c3c3c3c3c3c3c3c583c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2b3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c1c013c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c20003c3c3c3c3c3c3c3c3c3c3c800000003c3c3c3c3c3c3c2c3c3c3c3c3c3c353c08080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808f4080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808083c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c323c3c3c3c3c3c3c3c3c3c3c4f3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3cfcfcfcfcfcfcfcfcfcfcfc10fcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfd02fcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfc03e8fcfcfcfc3c3c3c3c3c3c8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c553c3c3c3c3c3c3c3c3c3c3c3c3c573c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c000000803c3c4dd5d5a6d52cf3d5d5d5d5d5d5d5d5d5d5d5d5d5d53c3c3c3c3f3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2d3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c013c3c3c3c00643c3c3c3ce93c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c263c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c363c3c3c3c3c3c3c3c3c3c3c3c3c3c543c3c3c3c3c3c3c3c3c3c273c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c330000003c3c3c3c3c3c3c3c3c3c3c3c3c3c4d3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c000010003c3c3c3c3c3c413c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c1c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c403c3c3c3c3c3c3c3c3c3c3c3cec0000fa3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2d3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c4c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c5e3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c1b3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c593c3c3c3c3c3c243c3c373c3c3c3c3cff3c3c3c3c3c3c3c3c3c3c3c3c3c000080003c3c3c3c3c3c3c3c3c3c353c3c3c3c3c3d3c3c3c3c3c3c3c3c3c3c3c3c4d3c3c3c3c3c3c3c3c3c3c3c3c3c40003c3c3c3c3c293c3c3c3c3c3c3c3c3c3d3c3c3c3c3c3c3c3c353c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c4f3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3f3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3cff7f3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c2d3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3ca43c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3cbf3c3c3c3c3c3c3c3c3c008000003c3c3c3c3c3c3c3c343c3c373c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c593c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c3c');
+  SELECT * from f where f match '0';
+} {1 {database disk image is malformed}}
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts4growth.test

@@ -0,0 +1,441 @@
+# 2014 May 12
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS4 module.
+#
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix fts4growth
+
+# If SQLITE_ENABLE_FTS3 is defined, omit this file.
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+source $testdir/genesis.tcl
+
+sqlite3_db_config db DEFENSIVE 0
+do_execsql_test 1.1 { CREATE VIRTUAL TABLE x1 USING fts3; }
+
+do_test 1.2 {
+  foreach L {
+    {"See here, young man," said Mulga Bill, "from Walgett to the sea,}
+    {From Conroy's Gap to Castlereagh, there's none can ride like me.}
+    {I'm good all round at everything as everybody knows,}
+    {Although I'm not the one to talk -- I hate a man that blows.}
+  } {
+    execsql { INSERT INTO x1 VALUES($L) }
+  }
+  execsql { SELECT end_block, length(root) FROM x1_segdir }
+} {{0 114} 114 {0 118} 118 {0 95} 95 {0 115} 115}
+
+do_execsql_test 1.3 {
+  INSERT INTO x1(x1) VALUES('optimize');
+  SELECT level, end_block, length(root) FROM x1_segdir;
+} {0 {0 394} 394}
+
+do_test 1.4 {
+  foreach L {
+    {But riding is my special gift, my chiefest, sole delight;}
+    {Just ask a wild duck can it swim, a wildcat can it fight.}
+    {There's nothing clothed in hair or hide, or built of flesh or steel,}
+    {There's nothing walks or jumps, or runs, on axle, hoof, or wheel,}
+    {But what I'll sit, while hide will hold and girths and straps are tight:}
+    {I'll ride this here two-wheeled concern right straight away at sight."}
+  } {
+    execsql { INSERT INTO x1 VALUES($L) }
+  }
+  execsql { 
+    INSERT INTO x1(x1) VALUES('merge=4,4');
+    SELECT level, end_block, length(root) FROM x1_segdir;
+  }
+} {1 {224 921} 2}
+
+do_execsql_test 1.5 {
+  SELECT length(block) FROM x1_segments;
+} {921 {}}
+
+do_test 1.6 {
+  foreach L {
+    {'Twas Mulga Bill, from Eaglehawk, that sought his own abode,}
+    {That perched above Dead Man's Creek, beside the mountain road.}
+    {He turned the cycle down the hill and mounted for the fray,}
+    {But 'ere he'd gone a dozen yards it bolted clean away.}
+
+    {It left the track, and through the trees, just like a silver steak,}
+    {It whistled down the awful slope towards the Dead Man's Creek.}
+    {It shaved a stump by half an inch, it dodged a big white-box:}
+    {The very wallaroos in fright went scrambling up the rocks,}
+
+    {The wombats hiding in their caves dug deeper underground,}
+    {As Mulga Bill, as white as chalk, sat tight to every bound.}
+    {It struck a stone and gave a spring that cleared a fallen tree,}
+    {It raced beside a precipice as close as close could be;}
+
+    {And then as Mulga Bill let out one last despairing shriek}
+    {It made a leap of twenty feet into the Dead Man's Creek.}
+    {It shaved a stump by half an inch, it dodged a big white-box:}
+    {The very wallaroos in fright went scrambling up the rocks,}
+    {The wombats hiding in their caves dug deeper underground,}
+  } {
+    execsql { INSERT INTO x1 VALUES($L) }
+  }
+  execsql { 
+    SELECT level, end_block, length(root) FROM x1_segdir;
+  }
+} {1 {224 921} 2 1 {226 1230} 7 0 {0 98} 98}
+
+do_execsql_test 1.7 {
+  SELECT sum(length(block)) FROM x1_segments WHERE blockid IN (224,225,226)
+} {1230}
+
+#-------------------------------------------------------------------------
+#
+do_execsql_test 2.1 { 
+  CREATE TABLE t1(docid, words);
+  CREATE VIRTUAL TABLE x2 USING fts4;
+}
+fts_kjv_genesis 
+do_test 2.2 {
+  foreach id [db eval {SELECT docid FROM t1}] {
+    execsql {
+      INSERT INTO x2(docid, content) SELECT $id, words FROM t1 WHERE docid=$id
+    }
+  }
+  foreach id [db eval {SELECT docid FROM t1}] {
+    execsql {
+      INSERT INTO x2(docid, content) SELECT NULL, words FROM t1 WHERE docid=$id
+    }
+    if {[db one {SELECT count(*) FROM x2_segdir WHERE level<2}]==2} break
+  }
+} {}
+
+do_execsql_test 2.3 { 
+  SELECT count(*) FROM x2_segdir WHERE level=2;
+  SELECT count(*) FROM x2_segdir WHERE level=3;
+} {6 0}
+
+do_execsql_test 2.4 { 
+  INSERT INTO x2(x2) VALUES('merge=4,4');
+  SELECT count(*) FROM x2_segdir WHERE level=2;
+  SELECT count(*) FROM x2_segdir WHERE level=3;
+} {6 1}
+
+do_execsql_test 2.5 { 
+  SELECT end_block FROM x2_segdir WHERE level=3;
+  INSERT INTO x2(x2) VALUES('merge=4,4');
+  SELECT end_block FROM x2_segdir WHERE level=3;
+  INSERT INTO x2(x2) VALUES('merge=4,4');
+  SELECT end_block FROM x2_segdir WHERE level=3;
+} {{5588 -3950} {5588 -11766} {5588 -15541}}
+
+do_execsql_test 2.6 {
+  SELECT sum(length(block)) FROM x2_segdir, x2_segments WHERE 
+    blockid BETWEEN start_block AND leaves_end_block
+    AND level=3
+} {15541}
+
+do_execsql_test 2.7 { 
+  INSERT INTO x2(x2) VALUES('merge=1000,4');
+  SELECT end_block FROM x2_segdir WHERE level=3;
+} {{5588 127563}}
+
+do_execsql_test 2.8 {
+  SELECT sum(length(block)) FROM x2_segdir, x2_segments WHERE 
+    blockid BETWEEN start_block AND leaves_end_block
+    AND level=3
+} {127563}
+
+#--------------------------------------------------------------------------
+# Test that delete markers are removed from FTS segments when possible.
+# It is only possible to remove delete markers when the output of the
+# merge operation will become the oldest segment in the index.
+#
+#   3.1 - when the oldest segment is created by an 'optimize'.
+#   3.2 - when the oldest segment is created by an incremental merge.
+#   3.3 - by a crisis merge.
+#
+
+proc insert_doc {args} {
+  foreach iDoc $args {
+    set L [lindex {
+      {In your eagerness to engage the Trojans,}
+      {don’t any of you charge ahead of others,}
+      {trusting in your strength and horsemanship.}
+      {And don’t lag behind. That will hurt our charge.}
+      {Any man whose chariot confronts an enemy’s}
+      {should thrust with his spear at him from there.}
+      {That’s the most effective tactic, the way}
+      {men wiped out city strongholds long ago —}
+      {their chests full of that style and spirit.}
+    } [expr $iDoc%9]]
+    execsql { REPLACE INTO x3(docid, content) VALUES($iDoc, $L) }
+  }
+}
+
+proc delete_doc {args} {
+  foreach iDoc $args {
+    execsql { DELETE FROM x3 WHERE docid = $iDoc }
+  }
+}
+
+proc second {x} { lindex $x 1 }
+db func second second
+
+do_execsql_test 3.0 { CREATE VIRTUAL TABLE x3 USING fts4 }
+
+do_test 3.1.1 {
+  db transaction { insert_doc 1 2 3 4 5 6 }
+  execsql { SELECT level, idx, second(end_block) FROM x3_segdir }
+} {0 0 412}
+do_test 3.1.2 {
+  delete_doc 1 2 3 4 5 6
+  execsql { SELECT count(*) FROM x3_segdir }
+} {0}
+do_test 3.1.3 {
+  db transaction { 
+    insert_doc 1 2 3 4 5 6 7 8 9
+    delete_doc 9 8 7
+  }
+  execsql { SELECT level, idx, second(end_block) FROM x3_segdir }
+} {0 0 591 0 1 65 0 2 72 0 3 76}
+do_test 3.1.4 {
+  execsql { INSERT INTO x3(x3) VALUES('optimize') }
+  execsql { SELECT level, idx, second(end_block) FROM x3_segdir }
+} {0 0 412}
+
+do_test 3.2.1 {
+  execsql { DELETE FROM x3 }
+  insert_doc 8 7 6 5 4 3 2 1
+  delete_doc 7 8
+  execsql { SELECT count(*) FROM x3_segdir }
+} {10}
+do_test 3.2.2 {
+  execsql { INSERT INTO x3(x3) VALUES('merge=500,10') }
+  execsql { SELECT level, idx, second(end_block) FROM x3_segdir }
+} {1 0 412}
+
+# This assumes the crisis merge happens when there are already 16 
+# segments and one more is added.
+#
+do_test 3.3.1 {
+  execsql { DELETE FROM x3 }
+  insert_doc 1 2 3 4 5 6  7 8 9 10 11
+  delete_doc 11 10 9 8 7
+  execsql { SELECT count(*) FROM x3_segdir }
+} {16}
+
+do_test 3.3.2 {
+  insert_doc 12
+  execsql { SELECT level, idx, second(end_block) FROM x3_segdir WHERE level=1 }
+} {1 0 412}
+
+#--------------------------------------------------------------------------
+# Check a theory on a bug in fts4 - that segments with idx==0 were not 
+# being incrementally merged correctly. Theory turned out to be false.
+#
+do_execsql_test 4.1 {
+  DROP TABLE IF EXISTS x4;
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(docid, words);
+  CREATE VIRTUAL TABLE x4 USING fts4(words);
+}
+do_test 4.2 {
+  fts_kjv_genesis 
+  execsql { INSERT INTO x4 SELECT words FROM t1 }
+  execsql { INSERT INTO x4 SELECT words FROM t1 }
+} {}
+
+do_execsql_test 4.3 {
+  SELECT level, idx, second(end_block) FROM x4_segdir 
+} {0 0 117483 0 1 118006}
+
+do_execsql_test 4.4 {
+  INSERT INTO x4(x4) VALUES('merge=10,2');
+  SELECT count(*) FROM x4_segdir;
+} {3}
+
+do_execsql_test 4.5 {
+  INSERT INTO x4(x4) VALUES('merge=10,2');
+  SELECT count(*) FROM x4_segdir;
+} {3}
+
+do_execsql_test 4.6 {
+  INSERT INTO x4(x4) VALUES('merge=1000,2');
+  SELECT count(*) FROM x4_segdir;
+} {1}
+
+
+
+#--------------------------------------------------------------------------
+# Check that segments are not promoted if the "end_block" field does not
+# contain a size.
+#
+do_execsql_test 5.1 {
+  DROP TABLE IF EXISTS x2;
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(docid, words);
+  CREATE VIRTUAL TABLE x2 USING fts4;
+}
+fts_kjv_genesis 
+
+proc first {L} {lindex $L 0}
+db func first first
+
+do_test 5.2 {
+  foreach r [db eval { SELECT rowid FROM t1 }] {
+    execsql {
+      INSERT INTO x2(docid, content) SELECT docid, words FROM t1 WHERE rowid=$r
+    }
+  }
+  foreach d [db eval { SELECT docid FROM t1 LIMIT -1 OFFSET 20 }] {
+    execsql { DELETE FROM x2 WHERE docid = $d }
+  }
+
+  execsql {
+    INSERT INTO x2(x2) VALUES('optimize');
+    SELECT level, idx, end_block FROM x2_segdir
+  }
+} {2 0 {752 1926}}
+
+do_execsql_test 5.3 {
+  UPDATE x2_segdir SET end_block = CAST( first(end_block) AS INTEGER );
+  SELECT end_block, typeof(end_block) FROM x2_segdir;
+} {752 integer}
+
+do_execsql_test 5.4 {
+  INSERT INTO x2 SELECT words FROM t1 LIMIT 50;
+  SELECT level, idx, end_block FROM x2_segdir
+} {2 0 752 0 0 {758 5174}}
+
+do_execsql_test 5.5 {
+  UPDATE x2_segdir SET end_block = end_block || ' 1926' WHERE level=2;
+  INSERT INTO x2 SELECT words FROM t1 LIMIT 40;
+  SELECT level, idx, end_block FROM x2_segdir
+} {0 0 {752 1926} 0 1 {758 5174} 0 2 {763 4170}}
+
+proc t1_to_x2 {} {
+  foreach id [db eval {SELECT docid FROM t1 LIMIT 2}] {
+    execsql {
+      DELETE FROM x2 WHERE docid=$id;
+      INSERT INTO x2(docid, content) SELECT $id, words FROM t1 WHERE docid=$id;
+    }
+  }
+}
+
+#--------------------------------------------------------------------------
+# Check that segments created by auto-merge are not promoted until they
+# are completed.
+#
+
+do_execsql_test 6.1 {
+  CREATE VIRTUAL TABLE x5 USING fts4;
+  INSERT INTO x5 SELECT words FROM t1 LIMIT 100 OFFSET 0;
+  INSERT INTO x5 SELECT words FROM t1 LIMIT 100 OFFSET 25;
+  INSERT INTO x5 SELECT words FROM t1 LIMIT 100 OFFSET 50;
+  INSERT INTO x5 SELECT words FROM t1 LIMIT 100 OFFSET 75;
+  SELECT count(*) FROM x5_segdir
+} {4}
+
+do_execsql_test 6.2 {
+  INSERT INTO x5(x5) VALUES('merge=2,4');
+  SELECT level, idx, end_block FROM x5_segdir;
+} {0 0 {10 9216} 0 1 {21 9330} 0 2 {31 8850} 0 3 {40 8689} 1 0 {1320 -3117}}
+
+do_execsql_test 6.3 {
+  INSERT INTO x5 SELECT words FROM t1 LIMIT 100 OFFSET 100;
+  SELECT level, idx, end_block FROM x5_segdir;
+} {
+  0 0 {10 9216} 0 1 {21 9330} 0 2 {31 8850} 
+  0 3 {40 8689} 1 0 {1320 -3117} 0 4 {1329 8297}
+}
+
+do_execsql_test 6.4 {
+  INSERT INTO x5(x5) VALUES('merge=200,4');
+  SELECT level, idx, end_block FROM x5_segdir;
+} {0 0 {1329 8297} 1 0 {1320 28009}}
+
+do_execsql_test 6.5 {
+  INSERT INTO x5 SELECT words FROM t1;
+  SELECT level, idx, end_block FROM x5_segdir;
+} {
+  0 1 {1329 8297} 0 0 {1320 28009} 0 2 {1449 118006}
+}
+
+#--------------------------------------------------------------------------
+# Ensure that if part of an incremental merge is performed by an old
+# version that does not support storing segment sizes in the end_block
+# field, no size is stored in the final segment (as it would be incorrect).
+#
+do_execsql_test 7.1 {
+  CREATE VIRTUAL TABLE x6 USING fts4;
+  INSERT INTO x6 SELECT words FROM t1;
+  INSERT INTO x6 SELECT words FROM t1;
+  INSERT INTO x6 SELECT words FROM t1;
+  INSERT INTO x6 SELECT words FROM t1;
+  INSERT INTO x6 SELECT words FROM t1;
+  INSERT INTO x6 SELECT words FROM t1;
+  SELECT level, idx, end_block FROM x6_segdir;
+} {
+  0 0 {118 117483} 0 1 {238 118006} 0 2 {358 118006} 
+  0 3 {478 118006} 0 4 {598 118006} 0 5 {718 118006}
+}
+
+do_execsql_test 7.2 {
+  INSERT INTO x6(x6) VALUES('merge=25,4');
+  SELECT level, idx, end_block FROM x6_segdir;
+} {
+  0 0 {118 117483} 0 1 {238 118006} 0 2 {358 118006} 
+  0 3 {478 118006} 0 4 {598 118006} 0 5 {718 118006}
+  1 0 {23694 -69477}
+}
+
+do_execsql_test 7.3 {
+  UPDATE x6_segdir SET end_block = first(end_block) WHERE level=1;
+  SELECT level, idx, end_block FROM x6_segdir;
+} {
+  0 0 {118 117483} 0 1 {238 118006} 0 2 {358 118006} 
+  0 3 {478 118006} 0 4 {598 118006} 0 5 {718 118006}
+  1 0 23694
+}
+
+do_execsql_test 7.4 {
+  INSERT INTO x6(x6) VALUES('merge=25,4');
+  SELECT level, idx, end_block FROM x6_segdir;
+} {
+  0 0 {118 117483} 0 1 {238 118006} 0 2 {358 118006} 
+  0 3 {478 118006} 0 4 {598 118006} 0 5 {718 118006}
+  1 0 23694
+}
+
+do_execsql_test 7.5 {
+  INSERT INTO x6(x6) VALUES('merge=2500,4');
+  SELECT level, idx, start_block, leaves_end_block, end_block FROM x6_segdir;
+} {
+  1 0 719 1171 23694
+}
+
+do_execsql_test 7.6 {
+  INSERT INTO x6(x6) VALUES('merge=2500,2');
+  SELECT level, idx, start_block, leaves_end_block, end_block FROM x6_segdir;
+} {
+  1 0 719 1171 23694
+}
+
+do_execsql_test 7.7 {
+  SELECT sum(length(block)) FROM x6_segments 
+} {635247}
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fts4merge5.test

@@ -0,0 +1,58 @@
+# 2019 October 02
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS4 module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix fts4merge5
+
+# If SQLITE_ENABLE_FTS3 is defined, omit this file.
+ifcapable !fts3 {
+  finish_test
+  return
+}
+
+source $testdir/genesis.tcl
+
+do_execsql_test 1.1 { 
+  CREATE TABLE t1(docid, words);
+}
+fts_kjv_genesis
+
+do_execsql_test 1.2 {
+  CREATE VIRTUAL TABLE x1 USING fts3; 
+  INSERT INTO x1(x1) VALUES('nodesize=64');
+  INSERT INTO x1(x1) VALUES('maxpending=64');
+}
+
+do_execsql_test 1.3 {
+  INSERT INTO x1(docid, content) SELECT * FROM t1;
+}
+
+for {set tn 1} {1} {incr tn} {
+  set tc1 [db total_changes]
+  do_execsql_test 1.4.$tn.1 {
+    INSERT INTO x1(x1) VALUES('merge=1,2');
+  }
+  set tc2 [db total_changes]
+
+  if {($tc2 - $tc1)<2} break
+
+  do_execsql_test 1.4.$tn.1 {
+    INSERT INTO x1(x1) VALUES('integrity-check');
+  }
+}
+
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/fuzzer2.test

@@ -0,0 +1,72 @@
+# 2016 February 4
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# The focus of the tests is the word-fuzzer virtual table. The tests
+# in this file are slower than those in fuzzer1.test. So this file does
+# not run as part of veryquick.test etc.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !vtab {
+  finish_test
+  return
+}
+
+set ::testprefix fuzzer2
+load_static_extension db fuzzer
+
+#-------------------------------------------------------------------------
+# This test uses a fuzzer table with many rules. There is one rule to
+# map each possible two character string, where characters are lower-case
+# letters used in the English language, to all other possible two character
+# strings. In total, (26^4)-(26^2) mappings (the subtracted term represents
+# the no-op mappings discarded automatically by the fuzzer).
+#
+#
+do_execsql_test 1.1.1 {
+  DROP TABLE IF EXISTS x1;
+  DROP TABLE IF EXISTS x1_rules;
+  CREATE TABLE x1_rules(ruleset, cFrom, cTo, cost);
+}
+puts "This test is slow - perhaps around 7 seconds on an average pc"
+do_test 1.1.2 {
+  set LETTERS {a b c d e f g h i j k l m n o p q r s t u v w x y z}
+  set cost 1
+  db transaction {
+    foreach c1 $LETTERS { 
+      foreach c2 $LETTERS { 
+        foreach c3 $LETTERS { 
+          foreach c4 $LETTERS { 
+            db eval {INSERT INTO x1_rules VALUES(0, $c1||$c2, $c3||$c4, $cost)}
+            set cost [expr ($cost%1000) + 1]
+          }
+        }
+      }
+    }
+    db eval {UPDATE x1_rules SET cost = 20 WHERE cost<20 AND cFrom!='xx'}
+  }
+} {}
+
+do_execsql_test 1.2 {
+  SELECT count(*) FROM x1_rules WHERE cTo!=cFrom;
+} [expr 26*26*26*26 - 26*26]
+
+do_execsql_test 1.2.1 {
+  CREATE VIRTUAL TABLE x1 USING fuzzer(x1_rules);
+  SELECT word FROM x1 WHERE word MATCH 'xx' LIMIT 10;
+} {xx hw hx hy hz ia ib ic id ie}
+do_execsql_test 1.2.2 {
+  SELECT cTo FROM x1_rules WHERE cFrom='xx' 
+  ORDER BY cost asc, rowid asc LIMIT 9;
+} {hw hx hy hz ia ib ic id ie}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/incrvacuum.test

@@ -0,0 +1,892 @@
+# 2007 April 26
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the incremental vacuum feature.
+#
+# Note: There are also some tests for incremental vacuum and IO 
+# errors in incrvacuum_ioerr.test.
+#
+# $Id: incrvacuum.test,v 1.23 2009/02/18 20:31:18 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# If this build of the library does not support auto-vacuum, omit this
+# whole file.
+ifcapable {!autovacuum || !pragma} {
+  finish_test
+  return
+}
+
+#---------------------------------------------------------------------
+# Test the pragma on an empty database.
+#
+do_test incrvacuum-1.1 {
+  execsql {
+    pragma auto_vacuum;
+  }
+} $sqlite_options(default_autovacuum)
+do_test incrvacuum-1.2.0 {
+  # File size is sometimes 1 instead of 0 due to the hack we put in
+  # to work around ticket #3260.  Search for comments on #3260 in
+  # os_unix.c.
+  expr {[file size test.db] > 1}
+} {0}
+do_test incrvacuum-1.2 {
+  # This command will create the database.
+  execsql {
+    pragma auto_vacuum = 'full';
+    pragma auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-1.2.1 {
+  expr {[file size test.db] > 0}
+} {1}
+do_test incrvacuum-1.3 {
+  execsql {
+    pragma auto_vacuum = 'incremental';
+    pragma auto_vacuum;
+  }
+} {2}
+do_test incrvacuum-1.4 {
+  # In this case the invalid value is ignored and the auto_vacuum
+  # setting remains unchanged.
+  execsql {
+    pragma auto_vacuum = 'invalid';
+    pragma auto_vacuum;
+  }
+} {2}
+do_test incrvacuum-1.5 {
+  execsql {
+    pragma auto_vacuum = 1;
+    pragma auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-1.6 {
+  execsql {
+    pragma auto_vacuum = '2';
+    pragma auto_vacuum;
+  }
+} {2}
+do_test incrvacuum-1.7 {
+  # Invalid value. auto_vacuum setting remains unchanged.
+  execsql {
+    pragma auto_vacuum = 5;
+    pragma auto_vacuum;
+  }
+} {2}
+
+#---------------------------------------------------------------------
+# Test the pragma on a non-empty database. It is possible to toggle
+# the connection between "full" and "incremental" mode, but not to
+# change from either of these to "none", or from "none" to "full" or
+# "incremental".
+#
+do_test incrvacuum-2.1 {
+  execsql {
+    pragma auto_vacuum = 1;
+    CREATE TABLE abc(a, b, c);
+  }
+} {}
+do_test incrvacuum-2.2 {
+  execsql {
+    pragma auto_vacuum = 'none';
+    pragma auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-2.2.1 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    pragma auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-2.3 {
+  execsql {
+    pragma auto_vacuum = 'incremental';
+    pragma auto_vacuum;
+  }
+} {2}
+do_test incrvacuum-2.4 {
+  execsql {
+    pragma auto_vacuum = 'full';
+    pragma auto_vacuum;
+  }
+} {1}
+
+#---------------------------------------------------------------------
+# Test that when the auto_vacuum mode is "incremental", the database
+# does not shrink when pages are removed from it. But it does if
+# the mode is set to "full".
+#
+do_test incrvacuum-3.1 {
+  execsql {
+    pragma auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-3.2 {
+  set ::str [string repeat 1234567890 110]
+  execsql {
+    PRAGMA auto_vacuum = 2;
+    BEGIN;
+    CREATE TABLE tbl2(str);
+    INSERT INTO tbl2 VALUES($::str);
+    COMMIT;
+  }
+  # 5 pages:
+  #
+  #   1 -> database header
+  #   2 -> first back-pointer page
+  #   3 -> table abc
+  #   4 -> table tbl2
+  #   5 -> table tbl2 overflow page.
+  #
+  expr {[file size test.db] / 1024}
+} {5}
+do_test incrvacuum-3.3 {
+  execsql {
+    DROP TABLE abc;
+    DELETE FROM tbl2;
+  }
+  expr {[file size test.db] / 1024}
+} {5}
+do_test incrvacuum-3.4 {
+  execsql {
+    PRAGMA auto_vacuum = 1;
+    INSERT INTO tbl2 VALUES('hello world');
+  }
+  expr {[file size test.db] / 1024}
+} {3}
+
+#---------------------------------------------------------------------
+# Try to run a very simple incremental vacuum. Also verify that 
+# PRAGMA incremental_vacuum is a harmless no-op against a database that
+# does not support auto-vacuum.
+#
+do_test incrvacuum-4.1 {
+  set ::str [string repeat 1234567890 110]
+  execsql {
+    PRAGMA auto_vacuum = 2;
+    INSERT INTO tbl2 VALUES($::str);
+    CREATE TABLE tbl1(a, b, c);
+  }
+  expr {[file size test.db] / 1024}
+} {5}
+do_test incrvacuum-4.2 {
+  execsql {
+    DELETE FROM tbl2;
+    DROP TABLE tbl1;
+  }
+  expr {[file size test.db] / 1024}
+} {5}
+do_test incrvacuum-4.3 {
+  set ::nStep 0
+  db eval {pragma incremental_vacuum(10)} {
+    incr ::nStep
+  }
+  list [expr {[file size test.db] / 1024}] $::nStep
+} {3 2}
+
+#---------------------------------------------------------------------
+# The following tests - incrvacuum-5.* - test incremental vacuum
+# from within a transaction.
+#
+do_test incrvacuum-5.1.1 {
+  expr {[file size test.db] / 1024}
+} {3}
+do_test incrvacuum-5.1.2 {
+  execsql {
+    BEGIN;
+    DROP TABLE tbl2;
+    PRAGMA incremental_vacuum;
+    COMMIT;
+  }
+  expr {[file size test.db] / 1024}
+} {1}
+
+do_test incrvacuum-5.2.1 {
+  set ::str [string repeat abcdefghij 110]
+  execsql {
+    BEGIN;
+    CREATE TABLE tbl1(a);
+    INSERT INTO tbl1 VALUES($::str);
+    PRAGMA incremental_vacuum;                 -- this is a no-op.
+    COMMIT;
+  }
+  expr {[file size test.db] / 1024}
+} {4}
+do_test incrvacuum-5.2.2 {
+  set ::str [string repeat abcdefghij 110]
+  execsql {
+    BEGIN;
+    INSERT INTO tbl1 VALUES($::str);
+    INSERT INTO tbl1 SELECT * FROM tbl1;
+    DELETE FROM tbl1 WHERE oid%2;        -- Put 2 overflow pages on free-list.
+    COMMIT;
+  }
+  expr {[file size test.db] / 1024}
+} {7}
+do_test incrvacuum-5.2.3 {
+  execsql {
+    BEGIN;
+    PRAGMA incremental_vacuum;           -- Vacuum up the two pages.
+    CREATE TABLE tbl2(b);                -- Use one free page as a table root.
+    INSERT INTO tbl2 VALUES('a nice string');
+    COMMIT;
+  }
+  expr {[file size test.db] / 1024}
+} {6}
+do_test incrvacuum-5.2.4 {
+  execsql {
+    SELECT * FROM tbl2;
+  }
+} {{a nice string}}
+do_test incrvacuum-5.2.5 {
+  execsql {
+    DROP TABLE tbl1;
+    DROP TABLE tbl2;
+    PRAGMA incremental_vacuum;
+  }
+  expr {[file size test.db] / 1024}
+} {1}
+
+
+# Test cases incrvacuum-5.3.* use the following list as input data.
+# Two new databases are opened, one with incremental vacuum enabled,
+# the other with no auto-vacuum completely disabled. After executing
+# each element of the following list on both databases, test that
+# the integrity-check passes and the contents of each are identical.
+# 
+set TestScriptList [list {
+  BEGIN;
+  CREATE TABLE t1(a, b);
+  CREATE TABLE t2(a, b);
+  CREATE INDEX t1_i ON t1(a);
+  CREATE INDEX t2_i ON t2(a);
+} {
+  INSERT INTO t1 VALUES($::str1, $::str2);
+  INSERT INTO t1 VALUES($::str1||$::str2, $::str2||$::str1);
+  INSERT INTO t2 SELECT b, a FROM t1;
+  INSERT INTO t2 SELECT a, b FROM t1;
+  INSERT INTO t1 SELECT b, a FROM t2;
+  UPDATE t2 SET b = '';
+  PRAGMA incremental_vacuum;
+} {
+  UPDATE t2 SET b = (SELECT b FROM t1 WHERE t1.oid = t2.oid);
+  PRAGMA incremental_vacuum;
+} {
+  CREATE TABLE t3(a, b);
+  INSERT INTO t3 SELECT * FROM t2;
+  DROP TABLE t2;
+  PRAGMA incremental_vacuum;
+} {
+  CREATE INDEX t3_i ON t3(a);
+  COMMIT;
+} {
+  BEGIN;
+  DROP INDEX t3_i;
+  PRAGMA incremental_vacuum;
+  INSERT INTO t3 VALUES('hello', 'world');
+  ROLLBACK;
+} {
+  INSERT INTO t3 VALUES('hello', 'world');
+}
+]
+
+# If this build omits subqueries, step 2 in the above list will not
+# work. Replace it with "" in this case. 
+#
+ifcapable !subquery { lset TestScriptList 2 "" }
+
+# Compare the contents of databases $A and $B.
+#
+proc compare_dbs {A B tname} {
+  set tbl_list [execsql {
+    SELECT tbl_name FROM sqlite_master WHERE type = 'table'
+  } $A]
+
+  do_test ${tname}.1 [subst {
+    execsql {
+      SELECT tbl_name FROM sqlite_master WHERE type = 'table'
+    } $B
+  }] $tbl_list
+
+  set tn 1
+  foreach tbl $tbl_list {
+    set control [execsql "SELECT * FROM $tbl" $A]
+    do_test ${tname}.[incr tn] [subst {
+      execsql "SELECT * FROM $tbl" $B
+    }] $control
+  }
+}
+
+set ::str1 [string repeat abcdefghij 130]
+set ::str2 [string repeat 1234567890 105]
+
+forcedelete test1.db test1.db-journal test2.db test2.db-journal
+sqlite3 db1 test1.db
+sqlite3 db2 test2.db
+execsql { PRAGMA auto_vacuum = 'none' } db1
+execsql { PRAGMA auto_vacuum = 'incremental' } db2
+
+set tn 1
+foreach sql $::TestScriptList {
+  execsql $sql db1
+  execsql $sql db2
+
+  compare_dbs db1 db2 incrvacuum-5.3.${tn}
+  do_test incrvacuum-5.3.${tn}.integrity1 {
+    execsql { PRAGMA integrity_check; } db1
+  } {ok}
+  do_test incrvacuum-5.3.${tn}.integrity2 {
+    execsql { PRAGMA integrity_check; } db2
+  } {ok}
+  incr tn
+}
+db1 close
+db2 close
+#
+# End of test cases 5.3.*
+
+#---------------------------------------------------------------------
+# The following tests - incrvacuum-6.* - test running incremental 
+# vacuum while another statement (a read) is being executed.
+#
+for {set jj 0} {$jj < 10} {incr jj} {
+  # Build some test data. Two tables are created in an empty
+  # database. tbl1 data is a contiguous block starting at page 5 (pages
+  # 3 and 4 are the table roots). tbl2 is a contiguous block starting 
+  # right after tbl1.
+  #
+  # Then drop tbl1 so that when an incr vacuum is run the pages
+  # of tbl2 have to be moved to fill the gap.
+  #
+  do_test incrvacuum-6.${jj}.1 {
+    execsql {
+      DROP TABLE IF EXISTS tbl1;
+      DROP TABLE IF EXISTS tbl2;
+      PRAGMA incremental_vacuum;
+      CREATE TABLE tbl1(a, b);
+      CREATE TABLE tbl2(a, b);
+      BEGIN;
+    }
+    for {set ii 0} {$ii < 1000} {incr ii} {
+      db eval {INSERT INTO tbl1 VALUES($ii, $ii || $ii)}
+    }
+    execsql {
+      INSERT INTO tbl2 SELECT * FROM tbl1;
+      COMMIT;
+      DROP TABLE tbl1;
+    }
+    expr {[file size test.db] / 1024}
+  } {36}
+
+  # Run a linear scan query on tbl2. After reading ($jj*100) rows, 
+  # run the incremental vacuum to shrink the database.
+  #
+  do_test incrvacuum-6.${jj}.2 {
+    set ::nRow 0
+    db eval {SELECT a FROM tbl2} {} {
+      if {$a == [expr $jj*100]} {
+        db eval {PRAGMA incremental_vacuum}
+      }
+      incr ::nRow
+    }
+    list [expr {[file size test.db] / 1024}] $nRow
+  } {19 1000}
+}
+
+#---------------------------------------------------------------------
+# This test - incrvacuum-7.* - is to check that the database can be
+# written in the middle of an incremental vacuum.
+#
+set ::iWrite 1
+while 1 {
+  do_test incrvacuum-7.${::iWrite}.1 {
+    execsql {
+      DROP TABLE IF EXISTS tbl1;
+      DROP TABLE IF EXISTS tbl2;
+      PRAGMA incremental_vacuum;
+      CREATE TABLE tbl1(a, b);
+      CREATE TABLE tbl2(a, b);
+      BEGIN;
+    }
+    for {set ii 0} {$ii < 1000} {incr ii} {
+      db eval {INSERT INTO tbl1 VALUES($ii, $ii || $ii)}
+    }
+    execsql {
+      INSERT INTO tbl2 SELECT * FROM tbl1;
+      COMMIT;
+      DROP TABLE tbl1;
+    }
+    expr {[file size test.db] / 1024}
+  } {36}
+
+  do_test incrvacuum-7.${::iWrite}.2 {
+    set ::nRow 0
+    db eval {PRAGMA incremental_vacuum} {
+      incr ::nRow
+      if {$::nRow == $::iWrite} {
+        db eval {
+          CREATE TABLE tbl1(a, b);
+          INSERT INTO tbl1 VALUES('hello', 'world');
+        }
+      }
+    }
+    list [expr {[file size test.db] / 1024}]
+  } {20}
+
+  do_test incrvacuum-7.${::iWrite}.3 {
+    execsql {
+      SELECT * FROM tbl1;
+    }
+  } {hello world}
+
+  if {$::nRow == $::iWrite} break
+  incr ::iWrite
+}
+
+#---------------------------------------------------------------------
+# This test - incrvacuum-8.* - is to check that nothing goes wrong
+# with an incremental-vacuum if it is the first statement executed
+# after an existing database is opened.
+#
+# At one point, this would always return SQLITE_SCHEMA (which 
+# causes an infinite loop in tclsqlite.c if using the Tcl interface).
+#
+do_test incrvacuum-8.1 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    PRAGMA incremental_vacuum(50);
+  }
+} {}
+
+#---------------------------------------------------------------------
+# At one point this test case was causing an assert() to fail.
+#
+do_test incrvacuum-9.1 {
+  db close
+  forcedelete test.db test.db-journal
+  sqlite3 db test.db
+
+  execsql {
+    PRAGMA auto_vacuum = 'incremental';
+    CREATE TABLE t1(a, b, c);
+    CREATE TABLE t2(a, b, c);
+    INSERT INTO t2 VALUES(randstr(500,500),randstr(500,500),randstr(500,500));
+    INSERT INTO t1 VALUES(1, 2, 3);
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+    INSERT INTO t1 SELECT a||a, b||b, c||c FROM t1;
+  }
+} {}
+
+do_test incrvacuum-9.2 {
+  execsql {
+    PRAGMA synchronous = 'OFF';
+    BEGIN;
+    UPDATE t1 SET a = a, b = b, c = c;
+    DROP TABLE t2;
+    PRAGMA incremental_vacuum(10);
+    ROLLBACK;
+  }
+} {}
+
+do_test incrvacuum-9.3 {
+  execsql {
+    PRAGMA cache_size = 10;
+    BEGIN;
+    UPDATE t1 SET a = a, b = b, c = c;
+    DROP TABLE t2;
+    PRAGMA incremental_vacuum(10);
+    ROLLBACK;
+  }
+} {}
+
+#---------------------------------------------------------------------
+# Test that the parameter to the incremental_vacuum pragma works. That
+# is, if the user executes "PRAGMA incremental_vacuum(N)", at most
+# N pages are vacuumed.
+#
+do_test incrvacuum-10.1 {
+  execsql {
+    DROP TABLE t1;
+    DROP TABLE t2;
+  }
+  expr [file size test.db] / 1024
+} {29}
+
+do_test incrvacuum-10.2 {
+  execsql {
+    PRAGMA incremental_vacuum(1);
+  }
+  expr [file size test.db] / 1024
+} {28}
+
+do_test incrvacuum-10.3 {
+  execsql {
+    PRAGMA incremental_vacuum(5);
+  }
+  expr [file size test.db] / 1024
+} {23}
+
+do_test incrvacuum-10.4 {
+  execsql {
+    PRAGMA incremental_vacuum('1');
+  }
+  expr [file size test.db] / 1024
+} {22}
+
+do_test incrvacuum-10.5 {
+  execsql {
+    PRAGMA incremental_vacuum("+3");
+  }
+  expr [file size test.db] / 1024
+} {19}
+
+do_test incrvacuum-10.6 {
+  execsql {
+    PRAGMA incremental_vacuum = 1;
+  }
+  expr [file size test.db] / 1024
+} {18}
+
+do_test incrvacuum-10.7 {
+  # Use a really big number as an argument to incremetal_vacuum. Should
+  # be interpreted as "free all possible space".
+  execsql {
+    PRAGMA incremental_vacuum(2147483649);
+  }
+  expr [file size test.db] / 1024
+} {1}
+
+do_test incrvacuum-10.8 {
+  execsql {
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES(hex(randomblob(1000)));
+    DROP TABLE t1;
+  }
+  # A negative number means free all possible space.
+  execsql {
+    PRAGMA incremental_vacuum=-1;
+  }
+  expr [file size test.db] / 1024
+} {1}
+
+#----------------------------------------------------------------
+# Test that if we set the auto_vacuum mode to 'incremental', then
+# create a database, thereafter that database defaults to incremental 
+# vacuum mode.
+#
+db close
+forcedelete test.db test.db-journal
+sqlite3 db test.db
+
+ifcapable default_autovacuum {
+  do_test incrvacuum-11.1-av-dflt-on {
+    execsql {
+      PRAGMA auto_vacuum;
+    }
+  } $AUTOVACUUM
+} else {
+  do_test incrvacuum-11.1-av-dflt-off {
+    execsql {
+      PRAGMA auto_vacuum;
+    }
+  } {0}
+}
+do_test incrvacuum-11.2 {
+  execsql {
+    PRAGMA auto_vacuum = incremental;
+  }
+} {}
+do_test incrvacuum-11.3 {
+  execsql {
+    PRAGMA auto_vacuum;
+  }
+} {2}
+do_test incrvacuum-11.4 {
+  # The database has now been created.
+  expr {[file size test.db]>0}
+} {1}
+do_test incrvacuum-11.5 {
+  # Close and reopen the connection.
+  db close
+  sqlite3 db test.db
+
+  # Test we are still in incremental vacuum mode.
+  execsql { PRAGMA auto_vacuum; }
+} {2}
+do_test incrvacuum-11.6 {
+  execsql {
+    PRAGMA auto_vacuum = 'full';
+    PRAGMA auto_vacuum;
+  }
+} {1}
+do_test incrvacuum-11.7 {
+  # Close and reopen the connection.
+  db close
+  sqlite3 db test.db
+
+  # Test we are still in "full" auto-vacuum mode.
+  execsql { PRAGMA auto_vacuum; }
+} {1}
+
+#----------------------------------------------------------------------
+# Special case: What happens if the database is locked when a "PRAGMA
+# auto_vacuum = XXX" statement is executed.
+#
+db close
+forcedelete test.db test.db-journal
+sqlite3 db test.db
+
+do_test incrvacuum-12.1 {
+  execsql {
+    PRAGMA auto_vacuum = 1;
+  }
+  expr {[file size test.db]>0}
+} {1}
+
+# Try to change the auto-vacuum from "full" to "incremental" while the
+# database is locked. Nothing should change.
+#
+do_test incrvacuum-12.2 {
+  sqlite3 db2 test.db
+  execsql { BEGIN EXCLUSIVE; } db2
+  catchsql { PRAGMA auto_vacuum = 2; }
+} {1 {database is locked}}
+
+do_test incrvacuum-12.3 {
+  execsql { ROLLBACK; } db2
+  execsql { PRAGMA auto_vacuum }
+} {2}   ;# Still 2 because PRAGMA auto_vacuum setting held in case of vacuum
+do_test incrvacuum-12.4 {
+  db close
+  sqlite3 db test.db
+  execsql { PRAGMA auto_vacuum }
+} {1}   ;# Revert to 1 because the database file did not change
+
+do_test incrvacuum-12.5 {
+  execsql { SELECT * FROM sqlite_master }
+  execsql { PRAGMA auto_vacuum }
+} {1}
+
+#----------------------------------------------------------------------
+# Special case #2: What if one process prepares a "PRAGMA auto_vacuum = XXX"
+# statement when the database is empty, but doesn't execute it until
+# after some other process has created the database.
+#
+db2 close
+db close
+forcedelete test.db test.db-journal
+sqlite3 db test.db  ;  set ::DB [sqlite3_connection_pointer db]
+sqlite3 db2 test.db
+
+do_test incrvacuum-13.1 {
+  # File size is sometimes 1 instead of 0 due to the hack we put in
+  # to work around ticket #3260.  Search for comments on #3260 in
+  # os_unix.c.
+  expr {[file size test.db]>1}
+} {0}
+do_test incrvacuum-13.2 {
+  set ::STMT [sqlite3_prepare $::DB {PRAGMA auto_vacuum = 2} -1 DUMMY]
+  execsql {
+    PRAGMA auto_vacuum = none;
+    PRAGMA default_cache_size = 1024;
+    PRAGMA auto_vacuum;
+  } db2
+} {0}
+do_test incrvacuum-13.3 {
+  expr {[file size test.db]>0}
+} {1}
+do_test incrvacuum-13.4 {
+  set rc [sqlite3_step $::STMT]
+  list $rc [sqlite3_finalize $::STMT]
+} {SQLITE_DONE SQLITE_OK}
+do_test incrvacuum-13.5 {
+  execsql {
+    PRAGMA auto_vacuum;
+  }
+} {0}
+
+
+# Verify that the incremental_vacuum pragma fails gracefully if it
+# is used against an invalid database file.
+#
+if {[permutation] == ""} {
+  do_test incrvacuum-14.1 {
+    set out [open invalid.db w]
+    puts $out "This is not an SQLite database file"
+    close $out
+    sqlite3 db3 invalid.db
+    catchsql {
+      PRAGMA incremental_vacuum(10);
+    } db3
+  } {1 {file is not a database}}
+  db3 close
+}
+
+do_test incrvacuum-15.1 {
+  db close
+  db2 close
+  forcedelete test.db
+  sqlite3 db test.db
+
+  set str [string repeat "abcdefghij" 500]
+
+  execsql {
+    PRAGMA cache_size = 10;
+    PRAGMA auto_vacuum = incremental;
+    CREATE TABLE t1(x, y);
+    INSERT INTO t1 VALUES('a', $str);
+    INSERT INTO t1 VALUES('b', $str);
+    INSERT INTO t1 VALUES('c', $str);
+    INSERT INTO t1 VALUES('d', $str);
+    INSERT INTO t1 VALUES('e', $str);
+    INSERT INTO t1 VALUES('f', $str);
+    INSERT INTO t1 VALUES('g', $str);
+    INSERT INTO t1 VALUES('h', $str);
+    INSERT INTO t1 VALUES('i', $str);
+    INSERT INTO t1 VALUES('j', $str);
+    INSERT INTO t1 VALUES('j', $str);
+
+    CREATE TABLE t2(x PRIMARY KEY, y);
+    INSERT INTO t2 VALUES('a', $str);
+    INSERT INTO t2 VALUES('b', $str);
+    INSERT INTO t2 VALUES('c', $str);
+    INSERT INTO t2 VALUES('d', $str);
+
+    BEGIN;
+      DELETE FROM t2;
+      PRAGMA incremental_vacuum;
+  }
+
+  catchsql {INSERT INTO t2 SELECT * FROM t1}
+
+  execsql { 
+    COMMIT;
+    PRAGMA integrity_check;
+  }
+} {ok}
+
+#-------------------------------------------------------------------------
+# At one point it was unsafe to truncate a db file on windows while there
+# were outstanding xFetch() references. This test case attempts to hit
+# that case.
+#
+ifcapable mmap {
+  reset_db
+  do_execsql_test incrvacuum-16.0 {
+    PRAGMA auto_vacuum = 2;
+    CREATE TABLE t3(a);
+    INSERT INTO t3 VALUES(1), (2), (3), (4);
+  
+    CREATE TABLE t2(x);
+    INSERT INTO t2 VALUES( randomblob(1000) );
+    INSERT INTO t2 VALUES( randomblob(1000) );
+    INSERT INTO t2 VALUES( randomblob(1000) );
+    INSERT INTO t2 VALUES( randomblob(1000) );
+    INSERT INTO t2 VALUES( randomblob(1000) );
+    INSERT INTO t2 VALUES( randomblob(1000) );
+  } {}
+  
+  # Reopen db to ensure the page-cache is empty.
+  #
+  db close
+  sqlite3 db test.db
+  
+  # Open db in mmap-mode. Open a transaction, delete some data, then run
+  # incremental-vacuum. Do not commit the transaction. 
+  #
+  do_execsql_test incrvacuum-16.1 {
+    PRAGMA mmap_size = 1000000;
+    BEGIN;
+    DELETE FROM t2;
+    PRAGMA incremental_vacuum = 1000;
+  } {1000000}
+
+  # Scan through table t3 (which is all clean pages - so mmap is used). Then,
+  # midway through, commit the transaction. This causes the db to be truncated
+  # while there are outstanding xFetch pages.
+  #
+  do_test incrvacuum-16.2 {
+    set res [list]
+    db eval { SELECT a FROM t3 } {
+      if {$a==3} { db eval COMMIT }
+      lappend res $a
+    }
+    set res
+  } {1 2 3 4}
+}
+
+# 2021-04-05 dbsqlfuzz cced0668cfd4da4eb2382cb9dd26c17c64aaff76
+#
+# This is an incremental vacuum database that has one free page that
+# needs to be filled.  After removing the last page from the end of
+# the database file to fill the free page slot, the last page that
+# is left is the tail of an overflow chain.
+#
+# But the size of the database file is shorter than the actual data
+# so that after incremental vacuum runs, the file is actually too
+# small to hold the last page of the overflow chain.
+#
+# At one point this caused an assertion fault in 
+# sqlite3PagerTruncateImage().
+#
+do_test incrvacuum-17.0 {
+  sqlite3 db {}
+  database_may_be_corrupt
+  db deserialize [decode_hexdb {
+| size 20480 pagesize 4096 filename x2.db
+| page 1 offset 0
+|      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
+|     16: 10 00 01 01 00 40 20 20 00 00 00 05 00 00 00 07   .....@  ........
+|     32: 00 00 00 04 00 00 00 01 00 00 00 03 00 00 00 04   ................
+|     48: 00 00 00 00 00 00 00 03 00 00 00 01 00 00 00 00   ................
+|     64: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00   ................
+|     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05   ................
+|     96: 00 2e 53 60 0d 0f dc 00 01 0f b8 00 0f b8 0f b8   ..S`............
+|   4016: 00 00 00 00 00 00 00 00 22 02 06 17 11 11 01 31   ...............1
+|   4032: 74 61 62 6c 65 74 32 74 32 03 43 52 45 41 54 45   tablet2t2.CREATE
+|   4048: 20 54 41 42 4c 45 20 74 32 28 79 29 00 00 00 24    TABLE t2(y)...$
+|   4064: 11 11 01 31 74 61 62 6c 65 74 31 74 31 03 43 52   ...1tablet1t1.CR
+|   4080: 45 41 54 45 20 54 41 42 4c 45 20 74 31 28 78 29   EATE TABLE t1(x)
+| page 2 offset 4096
+|      0: 01 00 00 00 00 02 00 00 00 00 03 00 00 00 03 04   ................
+|     16: 00 00 00 05 03 00 00 00 03 00 00 00 00 00 00 00   ................
+| page 3 offset 8192
+|      0: 0d 00 00 00 02 05 47 00 08 dd 05 47 00 00 00 00   ......G....G....
+|   1344: 00 00 00 00 00 00 00 a7 0b 02 03 ce 1c 00 00 00   ................
+|   2256: 00 00 00 00 00 00 00 00 00 00 00 00 07 ce 14 01   ................
+|   2272: 04 81 9c 2c 00 00 00 00 00 00 00 00 00 00 00 00   ...,............
+|   4080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05   ................
+| page 4 offset 12288
+|      0: 00 00 00 00 00 00 00 00 08 dd 05 47 00 00 00 00   ...........G....
+|   1344: 00 00 00 00 00 00 00 a7 0b 02 03 ce 1c 00 00 00   ................
+|   2256: 00 00 00 00 00 00 00 00 00 00 00 00 07 ce 14 01   ................
+|   2272: 04 81 9c 2c 00 00 00 00 00 00 00 00 00 00 00 00   ...,............
+|   4080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05   ................
+| page 5 offset 16384
+|      0: 00 00 00 06 00 00 00 00 00 00 00 00 00 00 00 00   ................
+| end x2.db
+}]} {}
+do_catchsql_test incrvacuum-17.1 {
+  PRAGMA writable_schema=ON;
+  PRAGMA incremental_vacuum(10);
+} {0 {}}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/join3.test

@@ -0,0 +1,62 @@
+# 2002 May 24
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for joins, including outer joins, where
+# there are a large number of tables involved in the join.
+#
+# $Id: join3.test,v 1.4 2005/01/19 23:24:51 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# An unrestricted join
+#
+catch {unset ::result}
+set result {}
+for {set N 1} {$N<=$bitmask_size} {incr N} {
+  lappend result $N
+  do_test join3-1.$N {
+    execsql "CREATE TABLE t${N}(x);"
+    execsql "INSERT INTO t$N VALUES($N)"
+    set sql "SELECT * FROM t1"
+    for {set i 2} {$i<=$N} {incr i} {append sql ", t$i"}
+    execsql $sql
+  } $result
+}
+
+# Joins with a comparison
+#
+set result {}
+for {set N 1} {$N<=$bitmask_size} {incr N} {
+  lappend result $N
+  do_test join3-2.$N {
+    set sql "SELECT * FROM t1"
+    for {set i 2} {$i<=$N} {incr i} {append sql ", t$i"}
+    set sep WHERE
+    for {set i 1} {$i<$N} {incr i} {
+      append sql " $sep t[expr {$i+1}].x==t$i.x+1"
+      set sep AND
+    }
+    execsql $sql
+  } $result
+}
+
+# Error of too many tables in the join
+#
+do_test join3-3.1 {
+  set sql "SELECT * FROM t1 AS t0, t1"
+  for {set i 2} {$i<=$bitmask_size} {incr i} {append sql ", t$i"}
+  catchsql $sql
+} [list 1 "at most $bitmask_size tables in a join"]
+
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/joinF.test

@@ -0,0 +1,613 @@
+# 2022-05-31
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests for JOINs
+#
+# The test case output is (mostly) all generated by PostgreSQL 14.  This
+# test module was created as follows:
+#
+#   1.   Run a TCL script (included at the bottom of this file) that
+#        generates an input script for "psql" that will run man
+#        diverse tests on joins.
+#
+#   2.   Run the script from step (1) through psql and collect the
+#        output.
+#
+#   3.   Make a few minor global search-and-replace operations to convert
+#        the psql output into a form suitable for this test module.
+#
+#   4.   Add this header, and the script content at the footer.
+#
+# A few extra tests that were not generated from postgresql output are
+# added at the end.
+#
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+db nullvalue -
+db eval {
+  CREATE TABLE t1(x INT);
+  CREATE TABLE t2(y INT);
+  CREATE TABLE t3(z INT);
+  CREATE TABLE t4(w INT);
+  INSERT INTO t1 VALUES(10);
+  INSERT INTO t3 VALUES(20),(30);
+  INSERT INTO t4 VALUES(50);
+}
+do_execsql_test joinF-1 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-2 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-3 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-4 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-5 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - - 50
+}
+do_execsql_test joinF-6 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-7 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-8 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-9 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-10 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-11 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - - 50
+}
+do_execsql_test joinF-12 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-13 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-14 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-15 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-16 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-17 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-18 {
+  SELECT *
+  FROM t1 INNER JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-19 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-20 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-21 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-22 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-23 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - - 50
+}
+do_execsql_test joinF-24 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-25 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  10 - - 50
+}
+do_execsql_test joinF-26 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-27 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  10 - - 50
+}
+do_execsql_test joinF-28 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-29 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  10 - - 50
+}
+do_execsql_test joinF-30 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-31 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-32 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-33 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-34 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-35 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-36 {
+  SELECT *
+  FROM t1 LEFT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-37 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-38 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-39 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-40 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-41 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - - 50
+}
+do_execsql_test joinF-42 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  INNER JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-43 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-44 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-45 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-46 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-47 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - - 50
+}
+do_execsql_test joinF-48 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  LEFT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+}
+do_execsql_test joinF-49 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-50 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  INNER JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-51 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-52 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  LEFT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-53 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+do_execsql_test joinF-54 {
+  SELECT *
+  FROM t1 RIGHT JOIN t2 ON true
+  RIGHT JOIN t3 ON t2.y IS NOT NULL
+  RIGHT JOIN t4 ON true
+  WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)
+  ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);
+} {
+  - - 20 50
+  - - 30 50
+}
+finish_test
+
+############################################################################
+# This is the TCL script used to generate the psql script that generated
+# the data above.
+#
+# puts "
+# \\pset border off
+# \\pset tuples_only on
+# \\pset null -
+# 
+# DROP TABLE IF EXISTS t1;
+# DROP TABLE IF EXISTS t2;
+# DROP TABLE IF EXISTS t3;
+# DROP TABLE IF EXISTS t4;
+# CREATE TABLE t1(x INT);
+# CREATE TABLE t2(y INT);
+# CREATE TABLE t3(z INT);
+# CREATE TABLE t4(w INT);
+# INSERT INTO t1 VALUES(10);
+# INSERT INTO t3 VALUES(20),(30);
+# INSERT INTO t4 VALUES(50);
+# "
+# 
+# proc echo {prefix txt} {
+#   regsub -all {\n} $txt \n$prefix txt
+#   puts "$prefix$txt"
+# }
+# 
+# set n 0
+# foreach j1 {INNER LEFT RIGHT} {
+#   foreach j2 {INNER LEFT RIGHT} {
+#     foreach j3 {INNER LEFT RIGHT} {
+# 
+# incr n
+# set q1 ""
+# append q1 "SELECT *\n"
+# append q1 "  FROM t1 $j1 JOIN t2 ON true\n"
+# append q1 "          $j2 JOIN t3 ON t2.y IS NOT NULL\n"
+# append q1 "          $j3 JOIN t4 ON true\n"
+# append q1 " ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);"
+# 
+# echo "\\qecho " "do_execsql_test joinF-$n \{"
+# echo "\\qecho X  " $q1
+# echo "\\qecho " "\} \{"
+# puts $q1
+# echo "\\qecho " "\}"
+# 
+# incr n
+# set q1 ""
+# append q1 "SELECT *\n"
+# append q1 "  FROM t1 $j1 JOIN t2 ON true\n"
+# append q1 "          $j2 JOIN t3 ON t2.y IS NOT NULL\n"
+# append q1 "          $j3 JOIN t4 ON true\n"
+# append q1 " WHERE (t3.z!=400 AND t3.z!=500 AND t3.z!=600)\n"
+# append q1 " ORDER BY coalesce(t1.x,t2.y,t3.z,t4.w,0);"
+# 
+# echo "\\qecho " "do_execsql_test joinF-$n \{"
+# echo "\\qecho X  " $q1
+# echo "\\qecho " "\} \{"
+# puts $q1
+# echo "\\qecho " "\}"
+# 
+#     }
+#   }
+# }
+#

local-test-sqlite3-delta-03/afc-sqlite3/test/lastinsert.test

@@ -0,0 +1,377 @@
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests to make sure that value returned by last_insert_rowid() (LIRID)
+# is updated properly, especially inside triggers
+#
+# Note 1: insert into table is now the only statement which changes LIRID
+# Note 2: upon entry into before or instead of triggers,
+#           LIRID is unchanged (rather than -1)
+# Note 3: LIRID is changed within the context of a trigger,
+#           but is restored once the trigger exits
+# Note 4: LIRID is not changed by an insert into a view (since everything
+#           is done within instead of trigger context)
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# ----------------------------------------------------------------------------
+# 1.x - basic tests (no triggers)
+
+# LIRID changed properly after an insert into a table
+do_test lastinsert-1.1 {
+    catchsql {
+        create table t1 (k integer primary key);
+        insert into t1 values (1);
+        insert into t1 values (NULL);
+        insert into t1 values (NULL);
+        select last_insert_rowid();
+    }
+} {0 3}
+
+# EVIDENCE-OF: R-47220-63683 The sqlite3_last_insert_rowid() function
+# does not work for WITHOUT ROWID tables.
+#
+do_test lastinsert-1.1w {
+    catchsql {
+        create table t1w (k integer primary key) WITHOUT ROWID;
+        insert into t1w values (123456);
+        select last_insert_rowid(); -- returns 3 from above.
+    }
+} {0 3}
+
+# LIRID unchanged after an update on a table
+do_test lastinsert-1.2 {
+    catchsql {
+        update t1 set k=4 where k=2;
+        select last_insert_rowid();
+    }
+} {0 3}
+
+# LIRID unchanged after a delete from a table
+do_test lastinsert-1.3 {
+    catchsql {
+        delete from t1 where k=4;
+        select last_insert_rowid();
+    }
+} {0 3}
+
+# LIRID unchanged after create table/view statements
+do_test lastinsert-1.4.1 {
+    catchsql {
+        create table t2 (k integer primary key, val1, val2, val3);
+        select last_insert_rowid();
+    }
+} {0 3}
+ifcapable view {
+do_test lastinsert-1.4.2 {
+    catchsql {
+        create view v as select * from t1;
+        select last_insert_rowid();
+    }
+} {0 3}
+} ;# ifcapable view
+
+# All remaining tests involve triggers.  Skip them if triggers are not
+# supported in this build.
+#
+ifcapable {!trigger} {
+  finish_test
+  return
+}
+
+# ----------------------------------------------------------------------------
+# 2.x - tests with after insert trigger
+
+# LIRID changed properly after an insert into table containing an after trigger
+do_test lastinsert-2.1 {
+    catchsql {
+        delete from t2;
+        create trigger r1 after insert on t1 for each row begin
+            insert into t2 values (NEW.k*2, last_insert_rowid(), NULL, NULL);
+            update t2 set k=k+10, val2=100+last_insert_rowid();
+            update t2 set val3=1000+last_insert_rowid();
+        end;
+        insert into t1 values (13);
+        select last_insert_rowid();
+    }
+} {0 13}
+
+# LIRID equals NEW.k upon entry into after insert trigger
+do_test lastinsert-2.2 {
+    catchsql {
+        select val1 from t2;
+    }
+} {0 13}
+
+# LIRID changed properly by insert within context of after insert trigger
+do_test lastinsert-2.3 {
+    catchsql {
+        select val2 from t2;
+    }
+} {0 126}
+
+# LIRID unchanged by update within context of after insert trigger
+do_test lastinsert-2.4 {
+    catchsql {
+        select val3 from t2;
+    }
+} {0 1026}
+
+# ----------------------------------------------------------------------------
+# 3.x - tests with after update trigger
+
+# LIRID not changed after an update onto a table containing an after trigger
+do_test lastinsert-3.1 {
+    catchsql {
+        delete from t2;
+        drop trigger r1;
+        create trigger r1 after update on t1 for each row begin
+            insert into t2 values (NEW.k*2, last_insert_rowid(), NULL, NULL);
+            update t2 set k=k+10, val2=100+last_insert_rowid();
+            update t2 set val3=1000+last_insert_rowid();
+        end;
+        update t1 set k=14 where k=3;
+        select last_insert_rowid();
+    }
+} {0 13}
+
+# LIRID unchanged upon entry into after update trigger
+do_test lastinsert-3.2 {
+    catchsql {
+        select val1 from t2;
+    }
+} {0 13}
+
+# LIRID changed properly by insert within context of after update trigger
+do_test lastinsert-3.3 {
+    catchsql {
+        select val2 from t2;
+    }
+} {0 128}
+
+# LIRID unchanged by update within context of after update trigger
+do_test lastinsert-3.4 {
+    catchsql {
+        select val3 from t2;
+    }
+} {0 1028}
+
+# ----------------------------------------------------------------------------
+# 4.x - tests with instead of insert trigger
+# These may not be run if either views or triggers were disabled at 
+# compile-time
+
+ifcapable {view && trigger} {
+# LIRID not changed after an insert into view containing an instead of trigger
+do_test lastinsert-4.1 {
+    catchsql {
+        delete from t2;
+        drop trigger r1;
+        create trigger r1 instead of insert on v for each row begin
+            insert into t2 values (NEW.k*2, last_insert_rowid(), NULL, NULL);
+            update t2 set k=k+10, val2=100+last_insert_rowid();
+            update t2 set val3=1000+last_insert_rowid();
+        end;
+        insert into v values (15);
+        select last_insert_rowid();
+    }
+} {0 13}
+
+# LIRID unchanged upon entry into instead of trigger
+do_test lastinsert-4.2 {
+    catchsql {
+        select val1 from t2;
+    }
+} {0 13}
+
+# LIRID changed properly by insert within context of instead of trigger
+do_test lastinsert-4.3 {
+    catchsql {
+        select val2 from t2;
+    }
+} {0 130}
+
+# LIRID unchanged by update within context of instead of trigger
+do_test lastinsert-4.4 {
+    catchsql {
+        select val3 from t2;
+    }
+} {0 1030}
+} ;# ifcapable (view && trigger)
+
+# ----------------------------------------------------------------------------
+# 5.x - tests with before delete trigger
+
+# LIRID not changed after a delete on a table containing a before trigger
+do_test lastinsert-5.1 {
+    catchsql {
+      drop trigger r1;  -- This was not created if views are disabled.
+    }
+    catchsql {
+        delete from t2;
+        create trigger r1 before delete on t1 for each row begin
+            insert into t2 values (77, last_insert_rowid(), NULL, NULL);
+            update t2 set k=k+10, val2=100+last_insert_rowid();
+            update t2 set val3=1000+last_insert_rowid();
+        end;
+        delete from t1 where k=1;
+        select last_insert_rowid();
+    }
+} {0 13}
+
+# LIRID unchanged upon entry into delete trigger
+do_test lastinsert-5.2 {
+    catchsql {
+        select val1 from t2;
+    }
+} {0 13}
+
+# LIRID changed properly by insert within context of delete trigger
+do_test lastinsert-5.3 {
+    catchsql {
+        select val2 from t2;
+    }
+} {0 177}
+
+# LIRID unchanged by update within context of delete trigger
+do_test lastinsert-5.4 {
+    catchsql {
+        select val3 from t2;
+    }
+} {0 1077}
+
+# ----------------------------------------------------------------------------
+# 6.x - tests with instead of update trigger
+# These tests may not run if either views or triggers are disabled.
+
+ifcapable {view && trigger} {
+# LIRID not changed after an update on a view containing an instead of trigger
+do_test lastinsert-6.1 {
+    catchsql {
+        delete from t2;
+        drop trigger r1;
+        create trigger r1 instead of update on v for each row begin
+            insert into t2 values (NEW.k*2, last_insert_rowid(), NULL, NULL);
+            update t2 set k=k+10, val2=100+last_insert_rowid();
+            update t2 set val3=1000+last_insert_rowid();
+        end;
+        update v set k=16 where k=14;
+        select last_insert_rowid();
+    }
+} {0 13}
+
+# LIRID unchanged upon entry into instead of trigger
+do_test lastinsert-6.2 {
+    catchsql {
+        select val1 from t2;
+    }
+} {0 13}
+
+# LIRID changed properly by insert within context of instead of trigger
+do_test lastinsert-6.3 {
+    catchsql {
+        select val2 from t2;
+    }
+} {0 132}
+
+# LIRID unchanged by update within context of instead of trigger
+do_test lastinsert-6.4 {
+    catchsql {
+        select val3 from t2;
+    }
+} {0 1032}
+} ;# ifcapable (view && trigger)
+
+# ----------------------------------------------------------------------------
+# 7.x - complex tests with temporary tables and nested instead of triggers
+# These do not run if views or triggers are disabled.
+
+ifcapable {trigger && view && tempdb} {
+do_test lastinsert-7.1 {
+    catchsql {
+        drop table t1; drop table t2; drop trigger r1;
+        create temp table t1 (k integer primary key);
+        create temp table t2 (k integer primary key);
+        create temp view v1 as select * from t1;
+        create temp view v2 as select * from t2;
+        create temp table rid (k integer primary key, rin, rout);
+        insert into rid values (1, NULL, NULL);
+        insert into rid values (2, NULL, NULL);
+        create temp trigger r1 instead of insert on v1 for each row begin
+            update rid set rin=last_insert_rowid() where k=1;
+            insert into t1 values (100+NEW.k);
+            insert into v2 values (100+last_insert_rowid());
+            update rid set rout=last_insert_rowid() where k=1;
+        end;
+        create temp trigger r2 instead of insert on v2 for each row begin
+            update rid set rin=last_insert_rowid() where k=2;
+            insert into t2 values (1000+NEW.k);
+            update rid set rout=last_insert_rowid() where k=2;
+        end;
+        insert into t1 values (77);
+        select last_insert_rowid();
+    }
+} {0 77}
+
+do_test lastinsert-7.2 {
+    catchsql {
+        insert into v1 values (5);
+        select last_insert_rowid();
+    }
+} {0 77}
+
+do_test lastinsert-7.3 {
+    catchsql {
+        select rin from rid where k=1;
+    }
+} {0 77}
+
+do_test lastinsert-7.4 {
+    catchsql {
+        select rout from rid where k=1;
+    }
+} {0 105}
+
+do_test lastinsert-7.5 {
+    catchsql {
+        select rin from rid where k=2;
+    }
+} {0 105}
+
+do_test lastinsert-7.6 {
+    catchsql {
+        select rout from rid where k=2;
+    }
+} {0 1205}
+
+do_test lastinsert-8.1 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    CREATE TABLE t2(x INTEGER PRIMARY KEY, y);
+    CREATE TABLE t3(a, b);
+    CREATE TRIGGER after_t2 AFTER INSERT ON t2 BEGIN
+      INSERT INTO t3 VALUES(new.x, new.y);
+    END;
+    INSERT INTO t2 VALUES(5000000000, 1);
+    SELECT last_insert_rowid();
+  }
+} 5000000000
+
+do_test lastinsert-9.1 {
+  db eval {INSERT INTO t2 VALUES(123456789012345,0)}
+  db last_insert_rowid
+} {123456789012345}
+
+
+} ;# ifcapable (view && trigger)
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/laststmtchanges.test

@@ -0,0 +1,331 @@
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests to make sure that values returned by changes() and total_changes()
+# are updated properly, especially inside triggers
+#
+# Note 1: changes() remains constant within a statement and only updates
+#         once the statement is finished (triggers count as part of
+#         statement).
+# Note 2: changes() is changed within the context of a trigger much like 
+#         last_insert_rowid() (see lastinsert.test), but is restored once
+#         the trigger exits.
+# Note 3: changes() is not changed by a change to a view (since everything
+#         is done within instead of trigger context).
+#
+# $Id: laststmtchanges.test,v 1.7 2008/10/27 13:59:34 danielk1977 Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# ----------------------------------------------------------------------------
+# 1.x - basic tests (no triggers)
+
+# changes() set properly after insert
+do_test laststmtchanges-1.1 {
+    catchsql {
+        create table t0 (x);
+        insert into t0 values (1);
+        insert into t0 values (1);
+        insert into t0 values (2);
+        insert into t0 values (2);
+        insert into t0 values (1);
+        insert into t0 values (1);
+        insert into t0 values (1);
+        insert into t0 values (2);
+        select changes(), total_changes();
+    }
+} {0 {1 8}}
+
+# changes() set properly after update
+do_test laststmtchanges-1.2 {
+    catchsql {
+        update t0 set x=3 where x=1;
+        select changes(), total_changes();
+    }
+} {0 {5 13}}
+
+# There was some goofy change-counting logic in sqlite3_exec() that
+# appears to have been left over from SQLite version 2.  This test
+# makes sure it has been removed.
+#
+do_test laststmtchanges-1.2.1 {
+    db cache flush
+    sqlite3_exec_printf db {update t0 set x=4 where x=3; select 1;} {}
+    execsql {select changes()}
+} {5}
+
+# changes() unchanged within an update statement
+do_test laststmtchanges-1.3 {
+    execsql {update t0 set x=3 where x=4}
+    catchsql {
+        update t0 set x=x+changes() where x=3;
+        select count() from t0 where x=8;
+    }
+} {0 5}
+
+# changes() set properly after update on table where no rows changed
+do_test laststmtchanges-1.4 {
+    catchsql {
+        update t0 set x=77 where x=88;
+        select changes();
+    }
+} {0 0}
+
+# changes() set properly after delete from table
+do_test laststmtchanges-1.5 {
+    catchsql {
+        delete from t0 where x=2;
+        select changes();
+    }
+} {0 3}
+
+# All remaining tests involve triggers.  Skip them if triggers are not
+# supported in this build.
+#
+ifcapable {!trigger} {
+  finish_test
+  return
+}
+
+
+# ----------------------------------------------------------------------------
+# 2.x - tests with after insert trigger
+
+# changes() changed properly after insert into table containing after trigger
+do_test laststmtchanges-2.1 {
+    set ::tc [db total_changes]
+    catchsql {
+        create table t1 (k integer primary key);
+        create table t2 (k integer primary key, v1, v2);
+        create trigger r1 after insert on t1 for each row begin
+            insert into t2 values (NULL, changes(), NULL);
+            update t0 set x=x;
+            update t2 set v2=changes();
+        end;
+        insert into t1 values (77);
+        select changes();
+    }
+} {0 1}
+
+# changes() unchanged upon entry into after insert trigger
+do_test laststmtchanges-2.2 {
+    catchsql {
+        select v1 from t2;
+    }
+} {0 3}
+
+# changes() changed properly by update within context of after insert trigger
+do_test laststmtchanges-2.3 {
+    catchsql {
+        select v2 from t2;
+    }
+} {0 5}
+
+# Total changes caused by firing the trigger above:
+#
+#   1 from "insert into t1 values(77)" + 
+#   1 from "insert into t2 values (NULL, changes(), NULL);" +
+#   5 from "update t0 set x=x;" +
+#   1 from "update t2 set v2=changes();"
+#
+do_test laststmtchanges-2.4 {
+  expr [db total_changes] - $::tc
+} {8}
+
+# ----------------------------------------------------------------------------
+# 3.x - tests with after update trigger
+
+# changes() changed properly after update into table containing after trigger
+do_test laststmtchanges-3.1 {
+    catchsql {
+        drop trigger r1;
+        delete from t2; delete from t2;
+        create trigger r1 after update on t1 for each row begin
+            insert into t2 values (NULL, changes(), NULL);
+            delete from t0 where oid=1 or oid=2;
+            update t2 set v2=changes();
+        end;
+        update t1 set k=k;
+        select changes();
+    }
+} {0 1}
+
+# changes() unchanged upon entry into after update trigger
+do_test laststmtchanges-3.2 {
+    catchsql {
+        select v1 from t2;
+    }
+} {0 0}
+
+# changes() changed properly by delete within context of after update trigger
+do_test laststmtchanges-3.3 {
+    catchsql {
+        select v2 from t2;
+    }
+} {0 2}
+
+# ----------------------------------------------------------------------------
+# 4.x - tests with before delete trigger
+
+# changes() changed properly on delete from table containing before trigger
+do_test laststmtchanges-4.1 {
+    catchsql {
+        drop trigger r1;
+        delete from t2; delete from t2;
+        create trigger r1 before delete on t1 for each row begin
+            insert into t2 values (NULL, changes(), NULL);
+            insert into t0 values (5);
+            update t2 set v2=changes();
+        end;
+        delete from t1;
+        select changes();
+    }
+} {0 1}
+
+# changes() unchanged upon entry into before delete trigger
+do_test laststmtchanges-4.2 {
+    catchsql {
+        select v1 from t2;
+    }
+} {0 0}
+
+# changes() changed properly by insert within context of before delete trigger
+do_test laststmtchanges-4.3 {
+    catchsql {
+        select v2 from t2;
+    }
+} {0 1}
+
+# ----------------------------------------------------------------------------
+# 5.x - complex tests with temporary tables and nested instead of triggers
+# These tests cannot run if the library does not have view support enabled.
+
+ifcapable view&&tempdb {
+
+do_test laststmtchanges-5.1 {
+    catchsql {
+        drop table t0; drop table t1; drop table t2;
+        create temp table t0(x);
+        create temp table t1 (k integer primary key);
+        create temp table t2 (k integer primary key);
+        create temp view v1 as select * from t1;
+        create temp view v2 as select * from t2;
+        create temp table n1 (k integer primary key, n);
+        create temp table n2 (k integer primary key, n);
+        insert into t0 values (1);
+        insert into t0 values (2);
+        insert into t0 values (1);
+        insert into t0 values (1);
+        insert into t0 values (1);
+        insert into t0 values (2);
+        insert into t0 values (2);
+        insert into t0 values (1);
+        create temp trigger r1 instead of insert on v1 for each row begin
+            insert into n1 values (NULL, changes());
+            update t0 set x=x*10 where x=1;
+            insert into n1 values (NULL, changes());
+            insert into t1 values (NEW.k);
+            insert into n1 values (NULL, changes());
+            update t0 set x=x*10 where x=0;
+            insert into v2 values (100+NEW.k);
+            insert into n1 values (NULL, changes());
+        end;
+        create temp trigger r2 instead of insert on v2 for each row begin
+            insert into n2 values (NULL, changes());
+            insert into t2 values (1000+NEW.k);
+            insert into n2 values (NULL, changes());
+            update t0 set x=x*100 where x=0;
+            insert into n2 values (NULL, changes());
+            delete from t0 where x=2;
+            insert into n2 values (NULL, changes());
+        end;
+        insert into t1 values (77);
+        select changes();
+    }
+} {0 1}
+
+do_test laststmtchanges-5.2 {
+    catchsql {
+        delete from t1 where k=88;
+        select changes();
+    }
+} {0 0}
+
+do_test laststmtchanges-5.3 {
+    catchsql {
+        insert into v1 values (5);
+        select changes();
+    }
+} {0 0}
+
+do_test laststmtchanges-5.4 {
+    catchsql {
+        select n from n1;
+    }
+} {0 {0 5 1 0}}
+
+do_test laststmtchanges-5.5 {
+    catchsql {
+        select n from n2;
+    }
+} {0 {0 1 0 3}}
+
+} ;# ifcapable view
+
+
+# ----------------------------------------------------------------------------
+# 6.x - Test "DELETE FROM <table>" in the absence of triggers
+#
+do_test laststmtchanges-6.1 {
+  execsql {
+    CREATE TABLE t3(a, b, c);
+    INSERT INTO t3 VALUES(1, 2, 3);
+    INSERT INTO t3 VALUES(4, 5, 6);
+  }
+} {}
+do_test laststmtchanges-6.2 {
+  execsql {
+    BEGIN;
+    DELETE FROM t3;
+    SELECT changes();
+  }
+} {2}
+do_test laststmtchanges-6.3 {
+  execsql {
+    ROLLBACK;
+    BEGIN;
+    DELETE FROM t3 WHERE a IS NOT NULL;
+    SELECT changes();
+  }
+} {2}
+do_test laststmtchanges-6.4 {
+  execsql {
+    ROLLBACK;
+    CREATE INDEX t3_i1 ON t3(a);
+    BEGIN;
+    DELETE FROM t3;
+    SELECT changes();
+  }
+} {2}
+do_test laststmtchanges-6.5 {
+  execsql { ROLLBACK }
+  set nTotalChange [execsql {SELECT total_changes()}]
+  expr 0
+} {0}
+do_test laststmtchanges-6.6 {
+  execsql {
+    SELECT total_changes();
+    DELETE FROM t3;
+    SELECT total_changes();
+  }
+} [list $nTotalChange [expr $nTotalChange+2]]
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/lock2.test

@@ -0,0 +1,111 @@
+# 2001 September 15
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is database locks between competing processes.
+#
+# $Id: lock2.test,v 1.11 2009/05/01 10:55:34 danielk1977 Exp $
+
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+
+
+# Simple locking test case:
+#
+# lock2-1.1: Connect a second process to the database.
+# lock2-1.2: Establish a RESERVED lock with this process.
+# lock2-1.3: Get a SHARED lock with the second process.
+# lock2-1.4: Try for a RESERVED lock with process 2. This fails.
+# lock2-1.5: Try to upgrade the first process to EXCLUSIVE, this fails so
+#            it gets PENDING.
+# lock2-1.6: Release the SHARED lock held by the second process. 
+# lock2-1.7: Attempt to reaquire a SHARED lock with the second process.
+#            this fails due to the PENDING lock.
+# lock2-1.8: Ensure the first process can now upgrade to EXCLUSIVE.
+#
+do_test lock2-1.1 {
+  set ::tf1 [launch_testfixture]
+  testfixture $::tf1 {
+    sqlite3 db test.db -key xyzzy
+    db eval {select * from sqlite_master}
+  }
+} {}
+do_test lock2-1.1.1 {
+  execsql {pragma lock_status}
+} {main unlocked temp closed}
+sqlite3_soft_heap_limit 0
+do_test lock2-1.2 {
+  execsql {
+    BEGIN;
+    CREATE TABLE abc(a, b, c);
+  }
+} {}
+do_test lock2-1.3 {
+  testfixture $::tf1 {
+    db eval {
+      BEGIN;
+      SELECT * FROM sqlite_master;
+    }
+  }
+} {}
+do_test lock2-1.4 {
+  testfixture $::tf1 {
+    catch { db eval { CREATE TABLE def(d, e, f) } } msg
+    set msg
+  }
+} {database is locked}
+do_test lock2-1.5 {
+  catchsql {
+    COMMIT;
+  }
+} {1 {database is locked}}
+do_test lock2-1.6 {
+  testfixture $::tf1 {
+    db eval {
+      SELECT * FROM sqlite_master;
+      COMMIT;
+    }
+  }
+} {}
+do_test lock2-1.7 {
+  testfixture $::tf1 {
+    catch { db eval {
+      BEGIN;
+      SELECT * FROM sqlite_master;
+    } } msg 
+    set msg
+  }
+} {database is locked}
+do_test lock2-1.8 {
+  catchsql {
+    COMMIT;
+  }
+} {0 {}}
+do_test lock2-1.9 {
+  execsql {
+    SELECT * FROM sqlite_master;
+  }
+} "table abc abc [expr $AUTOVACUUM?3:2] {CREATE TABLE abc(a, b, c)}"
+catch flush_async_queue
+do_test lock2-1.10 {
+  testfixture $::tf1 {
+    db eval {
+      SELECT * FROM sqlite_master;
+    }
+  }
+} "table abc abc [expr $AUTOVACUUM?3:2] {CREATE TABLE abc(a, b, c)}"
+
+catch {testfixture $::tf1 {db close}}
+catch {close $::tf1}
+sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit)
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/malloc3.test

@@ -0,0 +1,703 @@
+# 2005 November 30
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file contains tests to ensure that the library handles malloc() failures
+# correctly. The emphasis of these tests are the _prepare(), _step() and
+# _finalize() calls.
+#
+# $Id: malloc3.test,v 1.24 2008/10/14 15:54:08 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+
+# Only run these tests if memory debugging is turned on.
+#
+if {!$MEMDEBUG} {
+   puts "Skipping malloc3 tests: not compiled with -DSQLITE_MEMDEBUG..."
+   finish_test
+   return
+}
+
+# Do not run these tests if F2FS batch writes are supported. In this case,
+# it is possible for a single DML statement in an implicit transaction
+# to fail with SQLITE_NOMEM, but for the transaction to still end up
+# committed to disk. Which confuses the tests in this module.
+#
+if {[atomic_batch_write test.db]} {
+   puts "Skipping malloc3 tests: atomic-batch support"
+   finish_test
+   return
+}
+
+
+# Do not run these tests with an in-memory journal.
+#
+# In the pager layer, if an IO or OOM error occurs during a ROLLBACK, or
+# when flushing a page to disk due to cache-stress, the pager enters an
+# "error state". The only way out of the error state is to unlock the
+# database file and end the transaction, leaving whatever journal and
+# database files happen to be on disk in place. The next time the current
+# (or any other) connection opens a read transaction, hot-journal rollback
+# is performed if necessary.
+#
+# Of course, this doesn't work with an in-memory journal.
+#
+if {[permutation]=="inmemory_journal"} {
+  finish_test
+  return
+}
+
+#--------------------------------------------------------------------------
+# NOTES ON RECOVERING FROM A MALLOC FAILURE
+# 
+# The tests in this file test the behaviours described in the following
+# paragraphs. These tests test the behaviour of the system when malloc() fails
+# inside of a call to _prepare(), _step(), _finalize() or _reset(). The
+# handling of malloc() failures within ancillary procedures is tested
+# elsewhere.
+#
+# Overview:
+#
+# Executing a statement is done in three stages (prepare, step and finalize). A
+# malloc() failure may occur within any stage. If a memory allocation fails
+# during statement preparation, no statement handle is returned. From the users
+# point of view the system state is as if _prepare() had never been called.
+#
+# If the memory allocation fails during the _step() or _finalize() calls, then
+# the database may be left in one of two states (after finalize() has been
+# called):
+#
+#     * As if the neither _step() nor _finalize() had ever been called on
+#       the statement handle (i.e. any changes made by the statement are
+#       rolled back).
+#     * The current transaction may be rolled back. In this case a hot-journal
+#       may or may not actually be present in the filesystem.
+#
+# The caller can tell the difference between these two scenarios by invoking
+# _get_autocommit().
+#
+#
+# Handling of sqlite3_reset():
+#
+# If a malloc() fails while executing an sqlite3_reset() call, this is handled
+# in the same way as a failure within _finalize(). The statement handle
+# is not deleted and must be passed to _finalize() for resource deallocation.
+# Attempting to _step() or _reset() the statement after a failed _reset() will
+# always return SQLITE_NOMEM.
+#
+#
+# Other active SQL statements:
+#
+# The effect of a malloc failure on concurrently executing SQL statements,
+# particularly when the statement is executing with READ_UNCOMMITTED set and
+# the malloc() failure mandates statement rollback only. Currently, if
+# transaction rollback is required, all other vdbe's are aborted.
+#
+#     Non-transient mallocs in btree.c:
+#         * The Btree structure itself
+#         * Each BtCursor structure
+#
+#     Mallocs in pager.c:
+#         readMasterJournal()  - Space to read the master journal name
+#         pager_delmaster()    - Space for the entire master journal file
+#
+#         sqlite3pager_open()  - The pager structure itself
+#         sqlite3_pagerget()   - Space for a new page
+#         pager_open_journal() - Pager.aInJournal[] bitmap
+#         sqlite3pager_write() - For in-memory databases only: history page and
+#                                statement history page.
+#         pager_stmt_begin()   - Pager.aInStmt[] bitmap
+#
+# None of the above are a huge problem. The most troublesome failures are the
+# transient malloc() calls in btree.c, which can occur during the tree-balance
+# operation. This means the tree being balanced will be internally inconsistent
+# after the malloc() fails. To avoid the corrupt tree being read by a
+# READ_UNCOMMITTED query, we have to make sure the transaction or statement
+# rollback occurs before sqlite3_step() returns, not during a subsequent
+# sqlite3_finalize().
+#--------------------------------------------------------------------------
+
+#--------------------------------------------------------------------------
+# NOTES ON TEST IMPLEMENTATION
+#
+# The tests in this file are implemented differently from those in other
+# files. Instead, tests are specified using three primitives: SQL, PREP and
+# TEST. Each primitive has a single argument. Primitives are processed in
+# the order they are specified in the file.
+#
+# A TEST primitive specifies a TCL script as its argument. When a TEST
+# directive is encountered the Tcl script is evaluated. Usually, this Tcl
+# script contains one or more calls to [do_test].
+#
+# A PREP primitive specifies an SQL script as its argument. When a PREP
+# directive is encountered the SQL is evaluated using database connection
+# [db].
+#
+# The SQL primitives are where the action happens. An SQL primitive must
+# contain a single, valid SQL statement as its argument. When an SQL
+# primitive is encountered, it is evaluated one or more times to test the
+# behaviour of the system when malloc() fails during preparation or
+# execution of said statement. The Nth time the statement is executed,
+# the Nth malloc is said to fail. The statement is executed until it
+# succeeds, i.e. (M+1) times, where M is the number of mallocs() required
+# to prepare and execute the statement.
+#
+# Each time an SQL statement fails, the driver program (see proc [run_test]
+# below) figures out if a transaction has been automatically rolled back.
+# If not, it executes any TEST block immediately proceeding the SQL
+# statement, then reexecutes the SQL statement with the next value of N.
+#
+# If a transaction has been automatically rolled back, then the driver
+# program executes all the SQL specified as part of SQL or PREP primitives
+# between the current SQL statement and the most recent "BEGIN". Any 
+# TEST block immediately proceeding the SQL statement is evaluated, and
+# then the SQL statement reexecuted with the incremented N value.
+#
+# That make any sense? If not, read the code in [run_test] and it might.
+#
+# Extra restriction imposed by the implementation:
+#
+# * If a PREP block starts a transaction, it must finish it.
+# * A PREP block may not close a transaction it did not start.
+#
+#--------------------------------------------------------------------------
+
+
+# These procs are used to build up a "program" in global variable
+# ::run_test_script. At the end of this file, the proc [run_test] is used
+# to execute the program (and all test cases contained therein).
+#
+set ::run_test_sql_id 0
+set ::run_test_script [list]
+proc TEST {id t} {lappend ::run_test_script -test [list $id $t]}
+proc PREP {p} {lappend ::run_test_script -prep [string trim $p]}
+proc DEBUG {s} {lappend ::run_test_script -debug $s}
+
+# SQL --
+#
+#     SQL ?-norollback? <sql-text>
+#
+# Add an 'SQL' primitive to the program (see notes above). If the -norollback
+# switch is present, then the statement is not allowed to automatically roll
+# back any active transaction if malloc() fails. It must rollback the statement
+# transaction only.
+#
+proc SQL  {a1 {a2 ""}} {
+  # An SQL primitive parameter is a list of three elements, an id, a boolean
+  # value indicating if the statement may cause transaction rollback when
+  # malloc() fails, and the sql statement itself.
+  set id [incr ::run_test_sql_id]
+  if {$a2 == ""} {
+    lappend ::run_test_script -sql [list $id true [string trim $a1]]
+  } else {
+    lappend ::run_test_script -sql [list $id false [string trim $a2]]
+  }
+}
+
+# TEST_AUTOCOMMIT --
+# 
+#     A shorthand test to see if a transaction is active or not. The first
+#     argument - $id - is the integer number of the test case. The second
+#     argument is either 1 or 0, the expected value of the auto-commit flag.
+#
+proc TEST_AUTOCOMMIT {id a} {
+    TEST $id "do_test \$testid { sqlite3_get_autocommit \$::DB } {$a}"
+}
+
+#--------------------------------------------------------------------------
+# Start of test program declaration
+#
+
+
+# Warm body test. A malloc() fails in the middle of a CREATE TABLE statement
+# in a single-statement transaction on an empty database. Not too much can go
+# wrong here.
+#
+TEST 1 {
+  do_test $testid {
+    execsql {SELECT tbl_name FROM sqlite_master;}
+  } {}
+}
+SQL { 
+  CREATE TABLE IF NOT EXISTS abc(a, b, c); 
+}
+TEST 2 {
+  do_test $testid.1 {
+    execsql {SELECT tbl_name FROM sqlite_master;}
+  } {abc}
+}
+
+# Insert a couple of rows into the table. each insert is in its own
+# transaction. test that the table is unpopulated before running the inserts
+# (and hence after each failure of the first insert), and that it has been
+# populated correctly after the final insert succeeds.
+#
+TEST 3 {
+  do_test $testid.2 {
+    execsql {SELECT * FROM abc}
+  } {}
+}
+SQL {INSERT INTO abc VALUES(1, 2, 3);}
+SQL {INSERT INTO abc VALUES(4, 5, 6);}
+SQL {INSERT INTO abc VALUES(7, 8, 9);}
+TEST 4 {
+  do_test $testid {
+    execsql {SELECT * FROM abc}
+  } {1 2 3 4 5 6 7 8 9}
+}
+
+# Test a CREATE INDEX statement. Because the table 'abc' is so small, the index
+# will all fit on a single page, so this doesn't test too much that the CREATE
+# TABLE statement didn't test. A few of the transient malloc()s in btree.c
+# perhaps.
+#
+SQL {CREATE INDEX abc_i ON abc(a, b, c);}
+TEST 4 {
+  do_test $testid {
+    execsql {
+      SELECT * FROM abc ORDER BY a DESC;
+    }
+  } {7 8 9 4 5 6 1 2 3}
+}
+
+# Test a DELETE statement. Also create a trigger and a view, just to make sure
+# these statements don't have any obvious malloc() related bugs in them. Note
+# that the test above will be executed each time the DELETE fails, so we're
+# also testing rollback of a DELETE from a table with an index on it.
+#
+SQL {DELETE FROM abc WHERE a > 2;}
+SQL {CREATE TRIGGER abc_t AFTER INSERT ON abc BEGIN SELECT 'trigger!'; END;}
+SQL {CREATE VIEW abc_v AS SELECT * FROM abc;}
+TEST 5 {
+  do_test $testid {
+    execsql {
+      SELECT name, tbl_name FROM sqlite_master ORDER BY name;
+      SELECT * FROM abc;
+    }
+  } {abc abc abc_i abc abc_t abc abc_v abc_v 1 2 3}
+}
+
+set sql {
+  BEGIN;DELETE FROM abc;
+}
+for {set i 1} {$i < 100} {incr i} {
+  set a $i
+  set b "String value $i"
+  set c [string repeat X $i]
+  append sql "INSERT INTO abc VALUES ($a, '$b', '$c');"
+}
+append sql {COMMIT;}
+PREP $sql
+
+SQL {
+  DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
+}
+TEST 6 {
+  do_test $testid.1 {
+    execsql {SELECT count(*) FROM abc}
+  } {94}
+  do_test $testid.2 {
+    execsql {
+      SELECT min(
+          (oid == a) AND 'String value ' || a == b AND a == length(c) 
+      ) FROM abc;
+    }
+  } {1}
+}
+SQL {
+  DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
+}
+TEST 7 {
+  do_test $testid {
+    execsql {SELECT count(*) FROM abc}
+  } {89}
+  do_test $testid {
+    execsql {
+      SELECT min(
+          (oid == a) AND 'String value ' || a == b AND a == length(c) 
+      ) FROM abc;
+    }
+  } {1}
+}
+SQL {
+  DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
+}
+TEST 9 {
+  do_test $testid {
+    execsql {SELECT count(*) FROM abc}
+  } {84}
+  do_test $testid {
+    execsql {
+      SELECT min(
+          (oid == a) AND 'String value ' || a == b AND a == length(c) 
+      ) FROM abc;
+    }
+  } {1}
+}
+
+set padding [string repeat X 500]
+PREP [subst {
+  DROP TABLE abc;
+  CREATE TABLE abc(a PRIMARY KEY, padding, b, c);
+  INSERT INTO abc VALUES(0, '$padding', 2, 2);
+  INSERT INTO abc VALUES(3, '$padding', 5, 5);
+  INSERT INTO abc VALUES(6, '$padding', 8, 8);
+}]
+
+TEST 10 {
+  do_test $testid {
+    execsql {SELECT a, b, c FROM abc}
+  } {0 2 2 3 5 5 6 8 8}
+}
+
+SQL {BEGIN;}
+SQL {INSERT INTO abc VALUES(9, 'XXXXX', 11, 12);}
+TEST_AUTOCOMMIT 11 0
+SQL -norollback {UPDATE abc SET a = a + 1, c = c + 1;}
+TEST_AUTOCOMMIT 12 0
+SQL {DELETE FROM abc WHERE a = 10;}
+TEST_AUTOCOMMIT 13 0
+SQL {COMMIT;}
+
+TEST 14 {
+  do_test $testid.1 {
+    sqlite3_get_autocommit $::DB
+  } {1}
+  do_test $testid.2 {
+    execsql {SELECT a, b, c FROM abc}
+  } {1 2 3 4 5 6 7 8 9}
+}
+
+PREP [subst {
+  DROP TABLE abc;
+  CREATE TABLE abc(a, padding, b, c);
+  INSERT INTO abc VALUES(1, '$padding', 2, 3);
+  INSERT INTO abc VALUES(4, '$padding', 5, 6);
+  INSERT INTO abc VALUES(7, '$padding', 8, 9);
+  CREATE INDEX abc_i ON abc(a, padding, b, c);
+}]
+
+TEST 15 {
+  db eval {PRAGMA cache_size = 10}
+}
+
+SQL {BEGIN;}
+SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
+TEST 16 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 2 4 2 7 2}
+}
+SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
+TEST 17 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 4 4 4 7 4}
+}
+SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
+TEST 18 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 8 4 8 7 8}
+}
+SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
+TEST 19 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 16 4 16 7 16}
+}
+SQL {COMMIT;}
+TEST 21 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 16 4 16 7 16}
+}
+
+SQL {BEGIN;}
+SQL {DELETE FROM abc WHERE oid %2}
+TEST 22 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 8 4 8 7 8}
+}
+SQL {DELETE FROM abc}
+TEST 23 {
+  do_test $testid {
+    execsql {SELECT * FROM abc}
+  } {}
+}
+SQL {ROLLBACK;}
+TEST 24 {
+  do_test $testid {
+    execsql {SELECT a, count(*) FROM abc GROUP BY a;}
+  } {1 16 4 16 7 16}
+}
+
+# Test some schema modifications inside of a transaction. These should all
+# cause transaction rollback if they fail. Also query a view, to cover a bit
+# more code.
+#
+PREP {DROP VIEW abc_v;}
+TEST 25 {
+  do_test $testid {
+    execsql {
+      SELECT name, tbl_name FROM sqlite_master;
+    }
+  } {abc abc abc_i abc}
+}
+SQL {BEGIN;}
+SQL {CREATE TABLE def(d, e, f);}
+SQL {CREATE TABLE ghi(g, h, i);}
+TEST 26 {
+  do_test $testid {
+    execsql {
+      SELECT name, tbl_name FROM sqlite_master;
+    }
+  } {abc abc abc_i abc def def ghi ghi}
+}
+SQL {CREATE VIEW v1 AS SELECT * FROM def, ghi}
+SQL {CREATE UNIQUE INDEX ghi_i1 ON ghi(g);}
+TEST 27 {
+  do_test $testid {
+    execsql {
+      SELECT name, tbl_name FROM sqlite_master;
+    }
+  } {abc abc abc_i abc def def ghi ghi v1 v1 ghi_i1 ghi}
+}
+SQL {INSERT INTO def VALUES('a', 'b', 'c')}
+SQL {INSERT INTO def VALUES(1, 2, 3)}
+SQL -norollback {INSERT INTO ghi SELECT * FROM def}
+TEST 28 {
+  do_test $testid {
+    execsql {
+      SELECT * FROM def, ghi WHERE d = g;
+    }
+  } {a b c a b c 1 2 3 1 2 3}
+}
+SQL {COMMIT}
+TEST 29 {
+  do_test $testid {
+    execsql {
+      SELECT * FROM v1 WHERE d = g;
+    }
+  } {a b c a b c 1 2 3 1 2 3}
+}
+
+# Test a simple multi-file transaction 
+#
+forcedelete test2.db
+ifcapable attach {
+  SQL {ATTACH 'test2.db' AS aux;}
+  SQL {BEGIN}
+  SQL {CREATE TABLE aux.tbl2(x, y, z)}
+  SQL {INSERT INTO tbl2 VALUES(1, 2, 3)}
+  SQL {INSERT INTO def VALUES(4, 5, 6)}
+  TEST 30 {
+    do_test $testid {
+      execsql {
+        SELECT * FROM tbl2, def WHERE d = x;
+      }
+    } {1 2 3 1 2 3}
+  }
+  SQL {COMMIT}
+  TEST 31 {
+    do_test $testid {
+      execsql {
+        SELECT * FROM tbl2, def WHERE d = x;
+      }
+    } {1 2 3 1 2 3}
+  }
+}
+
+# Test what happens when a malloc() fails while there are other active
+# statements. This changes the way sqlite3VdbeHalt() works.
+TEST 32 {
+  if {![info exists ::STMT32]} {
+    set sql "SELECT name FROM sqlite_master"
+    set ::STMT32 [sqlite3_prepare $::DB $sql -1 DUMMY]
+    do_test $testid {
+      sqlite3_step $::STMT32
+    } {SQLITE_ROW}
+  }
+}
+SQL BEGIN
+TEST 33 { 
+  do_test $testid {
+    execsql {SELECT * FROM ghi}
+  } {a b c 1 2 3}
+}
+SQL -norollback { 
+  -- There is a unique index on ghi(g), so this statement may not cause
+  -- an automatic ROLLBACK. Hence the "-norollback" switch.
+  INSERT INTO ghi SELECT '2'||g, h, i FROM ghi;
+}
+TEST 34 {
+  if {[info exists ::STMT32]} {
+    do_test $testid {
+      sqlite3_finalize $::STMT32
+    } {SQLITE_OK}
+    unset ::STMT32
+  }
+}
+SQL COMMIT
+
+#
+# End of test program declaration
+#--------------------------------------------------------------------------
+
+proc run_test {arglist iRepeat {pcstart 0} {iFailStart 1}} {
+  if {[llength $arglist] %2} {
+    error "Uneven number of arguments to TEST"
+  }
+
+  for {set i 0} {$i < $pcstart} {incr i} {
+    set k2 [lindex $arglist [expr {2 * $i}]]
+    set v2 [lindex $arglist [expr {2 * $i + 1}]]
+    set ac [sqlite3_get_autocommit $::DB]        ;# Auto-Commit
+    switch -- $k2 {
+      -sql  {db eval [lindex $v2 2]}
+      -prep {db eval $v2}
+      -debug {eval $v2}
+    }
+    set nac [sqlite3_get_autocommit $::DB]       ;# New Auto-Commit 
+    if {$ac && !$nac} {set begin_pc $i}
+  }
+
+  db rollback_hook [list incr ::rollback_hook_count]
+
+  set iFail $iFailStart
+  set pc $pcstart
+  while {$pc*2 < [llength $arglist]} {
+    # Fetch the current instruction type and payload.
+    set k [lindex $arglist [expr {2 * $pc}]]
+    set v [lindex $arglist [expr {2 * $pc + 1}]]
+
+    # Id of this iteration:
+    set iterid "pc=$pc.iFail=$iFail$k"
+
+    switch -- $k {
+
+      -test { 
+        foreach {id script} $v {}
+        set testid "malloc3-(test $id).$iterid"
+        eval $script
+        incr pc
+      }
+
+      -sql {
+        set ::rollback_hook_count 0
+
+        set id [lindex $v 0]
+        set testid "malloc3-(integrity $id).$iterid"
+
+        set ac [sqlite3_get_autocommit $::DB]        ;# Auto-Commit
+        sqlite3_memdebug_fail $iFail -repeat 0
+        set rc [catch {db eval [lindex $v 2]} msg]   ;# True error occurs
+        set nac [sqlite3_get_autocommit $::DB]       ;# New Auto-Commit 
+
+        if {$rc != 0 && $nac && !$ac} {
+          # Before [db eval] the auto-commit flag was clear. Now it
+          # is set. Since an error occurred we assume this was not a
+          # commit - therefore a rollback occurred. Check that the
+          # rollback-hook was invoked.
+          do_test malloc3-rollback_hook_count.$iterid {
+            set ::rollback_hook_count
+          } {1}
+        }
+
+        set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
+        if {$rc == 0} {
+            # Successful execution of sql. The number of failed malloc()
+            # calls should be equal to the number of benign failures.
+            # Otherwise a malloc() failed and the error was not reported.
+            # 
+            set expr {$nFail!=$nBenign}
+            if {[expr $expr]} {
+              error "Unreported malloc() failure, test \"$testid\", $expr"
+            }
+
+            if {$ac && !$nac} {
+              # Before the [db eval] the auto-commit flag was set, now it
+              # is clear. We can deduce that a "BEGIN" statement has just
+              # been successfully executed.
+              set begin_pc $pc
+            } 
+
+            incr pc
+            set iFail 1
+            integrity_check $testid
+        } elseif {[regexp {.*out of memory} $msg] || [db errorcode] == 3082} {
+            # Out of memory error, as expected.
+            #
+            integrity_check $testid
+            incr iFail
+            if {$nac && !$ac} {
+              if {![lindex $v 1] && [db errorcode] != 3082} {
+                # error "Statement \"[lindex $v 2]\" caused a rollback"
+              }
+
+              for {set i $begin_pc} {$i < $pc} {incr i} {
+                set k2 [lindex $arglist [expr {2 * $i}]]
+                set v2 [lindex $arglist [expr {2 * $i + 1}]]
+                set catchupsql ""
+                switch -- $k2 {
+                  -sql  {set catchupsql [lindex $v2 2]}
+                  -prep {set catchupsql $v2}
+                }
+                db eval $catchupsql
+              }
+            }
+        } else {
+            error $msg
+        }
+
+        # back up to the previous "-test" block.
+        while {[lindex $arglist [expr {2 * ($pc - 1)}]] == "-test"} {
+          incr pc -1
+        }
+      }
+
+      -prep {
+        db eval $v
+        incr pc
+      }
+
+      -debug {
+        eval $v
+        incr pc
+      }
+
+      default { error "Unknown switch: $k" }
+    }
+  }
+}
+
+# Turn off the Tcl interface's prepared statement caching facility. Then
+# run the tests with "persistent" malloc failures.
+sqlite3_extended_result_codes db 1
+db cache size 0
+run_test $::run_test_script 1
+
+# Close and reopen the db.
+db close
+forcedelete test.db test.db-journal test2.db test2.db-journal
+sqlite3 db test.db
+sqlite3_extended_result_codes db 1
+set ::DB [sqlite3_connection_pointer db]
+
+# Turn off the Tcl interface's prepared statement caching facility in
+# the new connnection. Then run the tests with "transient" malloc failures.
+db cache size 0
+run_test $::run_test_script 0
+
+sqlite3_memdebug_fail -1
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/mallocG.test

@@ -0,0 +1,73 @@
+# 2007 Aug 29
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This test script checks malloc failures in various obscure operations.
+# 
+# $Id: mallocG.test,v 1.5 2008/08/01 18:47:02 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+
+# Only run these tests if memory debugging is turned on.
+#
+if {!$MEMDEBUG} {
+   puts "Skipping mallocG tests: not compiled with -DSQLITE_MEMDEBUG..."
+   finish_test
+   return
+}
+
+# Malloc failures while opening a database connection.
+#
+do_malloc_test mallocG-1 -tclbody {
+  db close
+  sqlite3 db test.db
+}
+
+do_malloc_test mallocG-2 -sqlprep {
+  CREATE TABLE t1(x, y);
+  CREATE TABLE t2(x INTEGER PRIMARY KEY);
+} -sqlbody {
+  SELECT y FROM t1 WHERE x IN t2;
+}
+
+do_malloc_test mallocG-3 -sqlprep {
+  CREATE TABLE t1(x UNIQUE);
+  INSERT INTO t1 VALUES ('hello');
+  INSERT INTO t1 VALUES ('out there');
+} -sqlbody {
+  SELECT * FROM t1
+   WHERE x BETWEEN 'a' AND 'z'
+     AND x BETWEEN 'c' AND 'w'
+     AND x BETWEEN 'e' AND 'u'
+     AND x BETWEEN 'g' AND 'r'
+     AND x BETWEEN 'i' AND 'q'
+     AND x BETWEEN 'i' AND 'm'
+}
+
+ifcapable !utf16 {
+  finish_test
+  return
+}
+
+proc utf16 {utf8} {
+  set utf16 [encoding convertto unicode $utf8]
+  append utf16 "\x00\x00"
+  return $utf16
+}
+
+do_malloc_test mallocG-4 -tclbody {
+  set rc [sqlite3_complete16 [utf16 "SELECT * FROM t1;"]]
+  if {$rc==1} {set rc 0} {error "out of memory"}
+  set rc
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/notify3.test

@@ -0,0 +1,152 @@
+# 2010 June 30
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the sqlite3_unlock_notify() API.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# This script only runs if shared-cache and unlock-notify are available.
+#
+ifcapable !unlock_notify||!shared_cache { 
+  finish_test 
+  return 
+}
+
+set esc [sqlite3_enable_shared_cache 1]
+
+sqlite3 db  test.db
+forcedelete test.db2 test.db2-journal test.db2-wal
+sqlite3 db2 test.db2
+
+do_test notify3-1.1 {
+  execsql { 
+    CREATE TABLE t1(a, b); 
+    INSERT INTO t1 VALUES('t1 A', 't1 B');
+  }
+} {}
+do_test notify3-1.2 {
+  execsql { 
+    CREATE TABLE t2(a, b);
+    INSERT INTO t2 VALUES('t2 A', 't2 B');
+  } db2
+} {}
+
+do_test notify3-1.3 {
+  execsql { 
+    BEGIN EXCLUSIVE;
+    INSERT INTO t2 VALUES('t2 C', 't2 D');
+  } db2
+} {}
+do_test notify3-1.4 {
+  catchsql { ATTACH 'test.db2' AS aux }
+} {0 {}}
+
+do_test notify3-1.5 {
+  catchsql { SELECT * FROM t2 }
+} {1 {database schema is locked: aux}}
+
+do_test notify3-1.6 {
+  list [sqlite3_errcode db] [sqlite3_extended_errcode db]
+} {SQLITE_LOCKED SQLITE_LOCKED_SHAREDCACHE}
+
+do_test notify3-1.7 {
+  sqlite3_extended_result_codes db 1
+  catch { set ::stmt [sqlite3_prepare_v2 db "SELECT * FROM t2" -1 tail] } msg
+  set msg
+} {(262) database schema is locked: aux}
+
+do_test notify3-1.8 {
+  set ::when 1
+  db unlock_notify { set ::res $::when }
+  set ::when 2
+  execsql { COMMIT } db2
+  set ::res
+} {2}
+do_test notify3-1.9 {
+  catchsql { SELECT * FROM t2 }
+} {0 {{t2 A} {t2 B} {t2 C} {t2 D}}}
+db close
+
+
+set err   {{1 {unable to open database: test.db2}}}
+set noerr {{0 {}}}
+
+# When a new database is attached, the connection doing the attaching 
+# tries to load any unloaded schemas for both the new database and any
+# already attached databases (including the main database). If it is
+# unable to load any such schemas, then the ATTACH statement fails.
+#
+# This block tests that if the loading of schemas as a result of an
+# ATTACH fails due to locks on the schema table held by other shared-cache
+# connections the extended error code is SQLITE_LOCKED_SHAREDCACHE and
+# it is possible to use the unlock-notify mechanism to determine when
+# the ATTACH might succeed.
+#
+# This test does not work for test-permutations that specify SQL to
+# be executed as part of the [sqlite3] command that opens the database.
+# Executing such SQL causes SQLite to load the database schema into memory 
+# earlier than expected, causing test cases to fail.
+#
+if {[presql] == ""} {
+  foreach {
+    tn
+    db1_loaded
+    db2_loaded
+    enable_extended_errors
+    result
+    error1 error2
+  } "
+    0   0 0 0   $err     SQLITE_LOCKED               SQLITE_LOCKED_SHAREDCACHE
+    1   0 0 1   $err     SQLITE_LOCKED_SHAREDCACHE   SQLITE_LOCKED_SHAREDCACHE
+    2   0 1 0   $noerr   SQLITE_OK                   SQLITE_OK
+    3   0 1 1   $noerr   SQLITE_OK                   SQLITE_OK
+    4   1 0 0   $err     SQLITE_LOCKED               SQLITE_LOCKED_SHAREDCACHE
+    5   1 0 1   $err     SQLITE_LOCKED_SHAREDCACHE   SQLITE_LOCKED_SHAREDCACHE
+    6   1 1 0   $noerr   SQLITE_OK                   SQLITE_OK
+    7   1 1 1   $noerr   SQLITE_OK                   SQLITE_OK
+  " {
+  
+    do_test notify3-2.$tn.1 {
+      catch { db1 close }
+      catch { db2 close }
+      sqlite3 db1 test.db
+      sqlite3 db2 test.db2
+  
+      sqlite3_extended_result_codes db1 $enable_extended_errors
+      sqlite3_extended_result_codes db2 $enable_extended_errors
+  
+      if { $db1_loaded } { db1 eval "SELECT * FROM sqlite_master" }
+      if { $db2_loaded } { db2 eval "SELECT * FROM sqlite_master" }
+  
+      db2 eval "BEGIN EXCLUSIVE"
+      catchsql "ATTACH 'test.db2' AS two" db1
+    } $result
+  
+    do_test notify3-2.$tn.2 {
+      list [sqlite3_errcode db1] [sqlite3_extended_errcode db1]
+    } [list $error1 $error2]
+  
+    do_test notify3-2.$tn.3 {
+      db1 unlock_notify {set invoked 1}
+      set invoked 0
+      db2 eval commit
+      set invoked
+    } [lindex $result 0]
+  }
+}
+catch { db1 close }
+catch { db2 close }
+
+
+sqlite3_enable_shared_cache $esc
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/offset1.test

@@ -0,0 +1,202 @@
+# 2015-10-06
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# 
+# This file implements test cases for the [b65cb2c8d91f6685841d7d1e13b6]
+# bug:  Correct handling of LIMIT and OFFSET on a UNION ALL query where
+# the right-hand SELECT contains an ORDER BY in a subquery.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !compound {
+  finish_test
+  return
+}
+
+do_execsql_test offset1-1.1 {
+  CREATE TABLE t1(a,b);
+  INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e');
+  CREATE TABLE t2(x,y);
+  INSERT INTO t2 VALUES(8,'y'),(9,'z'),(6,'w'),(7,'x');
+  SELECT count(*) FROM t1, t2;
+} {20}
+
+do_execsql_test offset1-1.2.0 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 0;
+} {1 a 2 b 3 c}
+do_execsql_test offset1-1.2.1 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 1;
+} {2 b 3 c 4 d}
+do_execsql_test offset1-1.2.2 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 2;
+} {3 c 4 d 5 e}
+do_execsql_test offset1-1.2.3 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 3;
+} {4 d 5 e 6 w}
+do_execsql_test offset1-1.2.4 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 4;
+} {5 e 6 w 7 x}
+do_execsql_test offset1-1.2.5 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 5;
+} {6 w 7 x 8 y}
+do_execsql_test offset1-1.2.6 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 6;
+} {7 x 8 y 9 z}
+do_execsql_test offset1-1.2.7 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 7;
+} {8 y 9 z}
+do_execsql_test offset1-1.2.8 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 8;
+} {9 z}
+do_execsql_test offset1-1.2.9 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 9;
+} {}
+
+do_execsql_test offset1-1.3.0 {
+  SELECT * FROM t1 LIMIT 0;
+} {}
+
+do_execsql_test offset1-1.4.0 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 0 OFFSET 1;
+} {}
+do_execsql_test offset1-1.4.1 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 1 OFFSET 1;
+} {2 b}
+do_execsql_test offset1-1.4.2 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 2 OFFSET 1;
+} {2 b 3 c}
+do_execsql_test offset1-1.4.3 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 3 OFFSET 1;
+} {2 b 3 c 4 d}
+do_execsql_test offset1-1.4.4 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 4 OFFSET 1;
+} {2 b 3 c 4 d 5 e}
+do_execsql_test offset1-1.4.5 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 5 OFFSET 1;
+} {2 b 3 c 4 d 5 e 6 w}
+do_execsql_test offset1-1.4.6 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 6 OFFSET 1;
+} {2 b 3 c 4 d 5 e 6 w 7 x}
+do_execsql_test offset1-1.4.7 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 7 OFFSET 1;
+} {2 b 3 c 4 d 5 e 6 w 7 x 8 y}
+do_execsql_test offset1-1.4.8 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 8 OFFSET 1;
+} {2 b 3 c 4 d 5 e 6 w 7 x 8 y 9 z}
+do_execsql_test offset1-1.4.9 {
+  SELECT a, b FROM t1
+  UNION ALL
+  SELECT * FROM (SELECT x, y FROM t2 ORDER BY y)
+  LIMIT 9 OFFSET 1;
+} {2 b 3 c 4 d 5 e 6 w 7 x 8 y 9 z}
+
+# 2022-08-04
+# https://sqlite.org/forum/forumpost/6b5e9188f0657616
+#
+do_execsql_test offset1-2.0 {
+  CREATE TABLE employees (
+    id integer primary key,
+    name text,
+    city text,
+    department text,
+    salary integer
+  );
+  INSERT INTO employees VALUES
+    (11,'Diane','London','hr',70),
+    (12,'Bob','London','hr',78),
+    (21,'Emma','London','it',84),
+    (22,'Grace','Berlin','it',90),
+    (23,'Henry','London','it',104),
+    (24,'Irene','Berlin','it',104),
+    (25,'Frank','Berlin','it',120),
+    (31,'Cindy','Berlin','sales',96),
+    (32,'Dave','London','sales',96),
+    (33,'Alice','Berlin','sales',100);
+  CREATE VIEW v AS
+    SELECT * FROM (
+      SELECT * FROM employees 
+       WHERE salary < 100
+       ORDER BY salary desc)
+     UNION ALL 
+     SELECT * FROM (
+       SELECT * FROM employees
+       WHERE salary >= 100
+       ORDER BY salary asc);
+} {}
+do_execsql_test offset1-2.1 {
+  SELECT * FROM v LIMIT 5 OFFSET 2;
+} {
+  22  Grace  Berlin  it      90
+  21  Emma   London  it      84
+  12  Bob    London  hr      78
+  11  Diane  London  hr      70
+  33  Alice  Berlin  sales   100
+}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/pcache.test

@@ -0,0 +1,182 @@
+# 2008 August 29
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file is focused on testing the pcache module.
+#
+# $Id: pcache.test,v 1.5 2009/05/08 06:52:48 danielk1977 Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Do not use a codec for tests in this file, as the database file is
+# manipulated directly using tcl scripts (using the [hexio_write] command).
+#
+do_not_use_codec
+
+# Only works with a mode-2 pcache where all pcaches share a single set
+# of pages.
+#
+ifcapable {!memorymanage && threadsafe} {
+  finish_test
+  return
+}
+
+# The pcache module limits the number of pages available to purgeable
+# caches to the sum of the 'cache_size' values for the set of open
+# caches. This block of tests, pcache-1.*, test that the library behaves
+# corrctly when it is forced to exceed this limit.
+#
+do_test pcache-1.1 {
+  db close
+  pcache_stats
+} {current 0 max 0 min 0 recyclable 0}
+
+do_test pcache-1.2 {
+  sqlite3 db test.db
+  execsql {
+    PRAGMA cache_size=12;
+    PRAGMA auto_vacuum=0;
+    PRAGMA mmap_size=0;
+  }
+  pcache_stats
+} {current 1 max 12 min 10 recyclable 1}
+
+do_test pcache-1.3 {
+  execsql {
+    BEGIN;
+    CREATE TABLE t1(a, b, c);
+    CREATE TABLE t2(a, b, c);
+    CREATE TABLE t3(a, b, c);
+    CREATE TABLE t4(a, b, c);
+    CREATE TABLE t5(a, b, c);
+  }
+  pcache_stats
+} {current 6 max 12 min 10 recyclable 0}
+
+do_test pcache-1.4 {
+  execsql {
+    CREATE TABLE t6(a, b, c);
+    CREATE TABLE t7(a, b, c);
+    CREATE TABLE t8(a, b, c);
+    CREATE TABLE t9(a, b, c);
+  }
+  pcache_stats
+} {current 10 max 12 min 10 recyclable 0}
+
+do_test pcache-1.5 {
+  sqlite3 db2 test.db
+  execsql "PRAGMA cache_size; PRAGMA cache_size=10" db2
+  pcache_stats
+} {current 11 max 22 min 20 recyclable 1}
+
+do_test pcache-1.6.1 {
+  execsql {
+    BEGIN;
+    SELECT * FROM sqlite_master;
+  } db2
+  pcache_stats
+} {current 11 max 22 min 20 recyclable 0}
+
+# At this point connection db2 has a read lock on the database file and a 
+# single pinned page in its cache. Connection [db] is holding 10 dirty 
+# pages. It cannot recycle them because of the read lock held by db2.
+#
+do_test pcache-1.6.2 {
+  execsql {
+    CREATE INDEX i1 ON t1(a, b);
+    CREATE INDEX i2 ON t2(a, b);
+    CREATE INDEX i3 ON t3(a, b);
+    CREATE INDEX i4 ON t4(a, b);
+    CREATE INDEX i5 ON t5(a, b);
+    CREATE INDEX i6 ON t6(a, b);
+    CREATE INDEX i7 ON t7(a, b);
+    CREATE INDEX i8 ON t8(a, b);
+    CREATE INDEX i9 ON t9(a, b);
+    CREATE INDEX i10 ON t9(a, b);
+    CREATE INDEX i11 ON t9(a, b);
+  } 
+  pcache_stats
+} {current 23 max 22 min 20 recyclable 0}
+
+do_test pcache-1.7 {
+  execsql {
+    CREATE TABLE t10(a, b, c);
+  } 
+  pcache_stats
+} {current 24 max 22 min 20 recyclable 0}
+
+# Rolling back the transaction held by db2 at this point releases a pinned
+# page. Because the number of allocated pages is greater than the 
+# configured maximum, this page should be freed immediately instead of
+# recycled.
+#
+do_test pcache-1.8 {
+  execsql {ROLLBACK} db2
+  pcache_stats
+} {current 23 max 22 min 20 recyclable 0}
+
+do_test pcache-1.9 {
+  execsql COMMIT
+  pcache_stats
+} {current 22 max 22 min 20 recyclable 22}
+
+do_test pcache-1.10 {
+  db2 close
+  pcache_stats
+} {current 12 max 12 min 10 recyclable 12}
+
+do_test pcache-1.11 {
+  execsql { PRAGMA cache_size = 20 }
+  pcache_stats
+} {current 12 max 20 min 10 recyclable 12}
+
+do_test pcache-1.12 {
+  execsql { 
+    SELECT * FROM t1 ORDER BY a; SELECT * FROM t1;
+    SELECT * FROM t2 ORDER BY a; SELECT * FROM t2;
+    SELECT * FROM t3 ORDER BY a; SELECT * FROM t3;
+    SELECT * FROM t4 ORDER BY a; SELECT * FROM t4;
+    SELECT * FROM t5 ORDER BY a; SELECT * FROM t5;
+    SELECT * FROM t6 ORDER BY a; SELECT * FROM t6;
+    SELECT * FROM t7 ORDER BY a; SELECT * FROM t7;
+    SELECT * FROM t8 ORDER BY a; SELECT * FROM t8;
+    SELECT * FROM t9 ORDER BY a; SELECT * FROM t9;
+  }
+  pcache_stats
+} {current 19 max 20 min 10 recyclable 19}
+
+do_test pcache-1.13 {
+  execsql { PRAGMA cache_size = 15 }
+  pcache_stats
+} {current 15 max 15 min 10 recyclable 15}
+
+do_test pcache-1.14 {
+  hexio_write test.db 24 [hexio_render_int32 1000]
+  execsql { SELECT * FROM sqlite_master }
+  pcache_stats
+} {current 2 max 15 min 10 recyclable 2}
+
+do_test pcache-1.15 {
+  execsql { 
+    SELECT * FROM t1 ORDER BY a; SELECT * FROM t1;
+    SELECT * FROM t2 ORDER BY a; SELECT * FROM t2;
+    SELECT * FROM t3 ORDER BY a; SELECT * FROM t3;
+    SELECT * FROM t4 ORDER BY a; SELECT * FROM t4;
+    SELECT * FROM t5 ORDER BY a; SELECT * FROM t5;
+    SELECT * FROM t6 ORDER BY a; SELECT * FROM t6;
+    SELECT * FROM t7 ORDER BY a; SELECT * FROM t7;
+    SELECT * FROM t8 ORDER BY a; SELECT * FROM t8;
+    SELECT * FROM t9 ORDER BY a; SELECT * FROM t9;
+  }
+  pcache_stats
+} {current 14 max 15 min 10 recyclable 14}
+
+finish_test

local-test-sqlite3-delta-03/afc-sqlite3/test/pragma5.test

@@ -0,0 +1,70 @@
+# 2017 August 25
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for the PRAGMA command. Specifically,
+# those pragmas that are not disabled at build time by setting:
+#
+#   -DSQLITE_OMIT_INTROSPECTION_PRAGMAS
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix pragma5
+
+if { [catch {db one "SELECT count(*) FROM pragma_function_list"}] } {
+  finish_test
+  return
+}
+
+db function external external
+
+do_execsql_test 1.0 {
+  PRAGMA table_info(pragma_function_list)
+} {
+  0 name {} 0 {} 0 
+  1 builtin {} 0 {} 0
+  2 type {} 0 {} 0
+  3 enc {} 0 {} 0
+  4 narg {} 0 {} 0
+  5 flags {} 0 {} 0
+}
+do_execsql_test 1.1 {
+  SELECT DISTINCT name, builtin
+    FROM pragma_function_list WHERE name='upper' AND builtin
+} {upper 1}
+do_execsql_test 1.2 {
+  SELECT DISTINCT name, builtin
+    FROM pragma_function_list WHERE name LIKE 'exter%';
+} {external 0}
+
+ifcapable fts5 {
+  do_execsql_test 2.0 {
+    PRAGMA table_info(pragma_module_list)
+  } {
+    0 name {} 0 {} 0 
+  }
+  do_execsql_test 2.1 {
+    SELECT * FROM pragma_module_list WHERE name='fts5'
+  } {fts5}
+}
+
+do_execsql_test 3.0 {
+  PRAGMA table_info(pragma_pragma_list)
+} {
+  0 name {} 0 {} 0 
+}
+do_execsql_test 3.1 {
+  SELECT * FROM pragma_pragma_list WHERE name='pragma_list'
+} {pragma_list}
+
+
+finish_test