diff --git a/manifest b/manifest
index e0333b2cb8..119f1fbebb 100644
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Fix\sfor\sticket\s#145:\sInclude\sthe\sfunc.c\ssource\sfile\sin\sthe\sbuild\sof\stestfixture\nso\sthat\sthe\s"randstr()"\sfunction\swill\sbe\savailable.\s(CVS\s734)
-D 2002-08-31T16:33:25
+C Initial\schecking\sof\stwo\snew\stest\sfiles:\sformat3.test\sand\smemleak.test.\s(CVS\s735)
+D 2002-08-31T16:52:45
 F Makefile.in 420fada882179cb72ffd07313f3fd693f9f06640
 F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
 F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
@@ -64,6 +64,7 @@ F test/conflict.test 0173a12a257f73bac2c9d53ad44cac9b15ea517e
 F test/copy.test 55d60a4d5ed342a0fa08b7cd07d46d43ea0d0d7f
 F test/delete.test 5821a95a66061ae09723a88938f23d10d8a881ad
 F test/expr.test dea1cd62684a8bf116426447c948f5e8fb2c84b6
+F test/format3.test cbb168d446152fcf1dd85be299ad2d6cd507da4e
 F test/func.test bed7ae7a3482df05db0f5eed2debdf25ac2d07fc
 F test/in.test e59461f1702b7387880bf08a0ce6bb777925d282
 F test/index.test 2a5a1b654f50ca0768fb10ae44b72e6a776b1f18
@@ -76,6 +77,7 @@ F test/limit.test dd932f7572fe78e82ef621ef62f0cc480c7e541e
 F test/lock.test 5079615ba0ef0899c4cbade42ffec291620a2819
 F test/main.test c66b564554b770ee7fdbf6a66c0cd90329bc2c85
 F test/malloc.test 7ba32a9ebd3aeed52ae4aaa6d42ca37e444536fd
+F test/memleak.test b4f59aa44488793b00feff2011d77d0f05b22468
 F test/minmax.test 29bc5727c3e4c792d5c4745833dd4b505905819e
 F test/misc1.test 3ee14f86e00c1d5a3f3fc90b8490c398ec623e79
 F test/misuse.test a3aa2b18a97e4c409a1fcaff5151a4dd804a0162
@@ -147,7 +149,7 @@ F www/speed.tcl a20a792738475b68756ea7a19321600f23d1d803
 F www/sqlite.tcl ae3dcfb077e53833b59d4fcc94d8a12c50a44098
 F www/tclsqlite.tcl 1db15abeb446aad0caf0b95b8b9579720e4ea331
 F www/vdbe.tcl 2013852c27a02a091d39a766bc87cff329f21218
-P 78a0229a7e5e33fe642847381f5514e6ec30f29f
-R d1aee1b6d455eca5263b2e9712360fc3
+P c5e0c6a782aedc4a273aaf8bc2ef60918797e5f1
+R 6ed2ff4a07aa3e2b4804dae71efd75e5
 U drh
-Z 2eba446c82c736106cbd3a0923580fc4
+Z e73ed8c27fc079694489e23a188ddf17
diff --git a/manifest.uuid b/manifest.uuid
index 3acf62dbc7..e87e03ccf6 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-c5e0c6a782aedc4a273aaf8bc2ef60918797e5f1
\ No newline at end of file
+6ffedb90a6478af6548db5298368eeca2b708cdc
\ No newline at end of file
diff --git a/test/format3.test b/test/format3.test
new file mode 100644
index 0000000000..92ecd7e4b9
--- /dev/null
+++ b/test/format3.test
@@ -0,0 +1,716 @@
+# 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 file is testing the the library is able to correctly
+# handle file-format 3 (version 2.6.x) databases.
+#
+# $Id: format3.test,v 1.1 2002/08/31 16:52:45 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Create a bunch of data to sort against
+#
+do_test format3-1.0 {
+  set fd [open data.txt w]
+  puts $fd "1\tone\t0\tI\t3.141592653"
+  puts $fd "2\ttwo\t1\tII\t2.15"
+  puts $fd "3\tthree\t1\tIII\t4221.0"
+  puts $fd "4\tfour\t2\tIV\t-0.0013442"
+  puts $fd "5\tfive\t2\tV\t-11"
+  puts $fd "6\tsix\t2\tVI\t0.123"
+  puts $fd "7\tseven\t2\tVII\t123.0"
+  puts $fd "8\teight\t3\tVIII\t-1.6"
+  close $fd
+  execsql {
+    CREATE TABLE t1(
+       n int,
+       v varchar(10),
+       log int,
+       roman varchar(10),
+       flt real
+    );
+    COPY t1 FROM 'data.txt'
+  }
+  file delete data.txt
+  db close
+  set ::bt [btree_open test.db]
+  btree_begin_transaction $::bt
+  set m [btree_get_meta $::bt]
+  set m [lreplace $m 2 2 3]
+  eval btree_update_meta $::bt $m
+  btree_commit $::bt
+  btree_close $::bt
+  sqlite db test.db
+  execsql {SELECT count(*) FROM t1}
+} {8}
+
+do_test format3-1.1 {
+  execsql {SELECT n FROM t1 ORDER BY n}
+} {1 2 3 4 5 6 7 8}
+do_test format3-1.1.1 {
+  execsql {SELECT n FROM t1 ORDER BY n ASC}
+} {1 2 3 4 5 6 7 8}
+do_test format3-1.1.1 {
+  execsql {SELECT ALL n FROM t1 ORDER BY n ASC}
+} {1 2 3 4 5 6 7 8}
+do_test format3-1.2 {
+  execsql {SELECT n FROM t1 ORDER BY n DESC}
+} {8 7 6 5 4 3 2 1}
+do_test format3-1.3a {
+  execsql {SELECT v FROM t1 ORDER BY v}
+} {eight five four one seven six three two}
+do_test format3-1.3b {
+  execsql {SELECT n FROM t1 ORDER BY v}
+} {8 5 4 1 7 6 3 2}
+do_test format3-1.4 {
+  execsql {SELECT n FROM t1 ORDER BY v DESC}
+} {2 3 6 7 1 4 5 8}
+do_test format3-1.5 {
+  execsql {SELECT flt FROM t1 ORDER BY flt}
+} {-11 -1.6 -0.0013442 0.123 2.15 3.141592653 123.0 4221.0}
+do_test format3-1.6 {
+  execsql {SELECT flt FROM t1 ORDER BY flt DESC}
+} {4221.0 123.0 3.141592653 2.15 0.123 -0.0013442 -1.6 -11}
+do_test format3-1.7 {
+  execsql {SELECT roman FROM t1 ORDER BY roman}
+} {I II III IV V VI VII VIII}
+do_test format3-1.8 {
+  execsql {SELECT n FROM t1 ORDER BY log, flt}
+} {1 2 3 5 4 6 7 8}
+do_test format3-1.8.1 {
+  execsql {SELECT n FROM t1 ORDER BY log asc, flt}
+} {1 2 3 5 4 6 7 8}
+do_test format3-1.8.2 {
+  execsql {SELECT n FROM t1 ORDER BY log, flt ASC}
+} {1 2 3 5 4 6 7 8}
+do_test format3-1.8.3 {
+  execsql {SELECT n FROM t1 ORDER BY log ASC, flt asc}
+} {1 2 3 5 4 6 7 8}
+do_test format3-1.9 {
+  execsql {SELECT n FROM t1 ORDER BY log, flt DESC}
+} {1 3 2 7 6 4 5 8}
+do_test format3-1.9.1 {
+  execsql {SELECT n FROM t1 ORDER BY log ASC, flt DESC}
+} {1 3 2 7 6 4 5 8}
+do_test format3-1.10 {
+  execsql {SELECT n FROM t1 ORDER BY log DESC, flt}
+} {8 5 4 6 7 2 3 1}
+do_test format3-1.11 {
+  execsql {SELECT n FROM t1 ORDER BY log DESC, flt DESC}
+} {8 7 6 4 5 3 2 1}
+
+# These tests are designed to reach some hard-to-reach places
+# inside the string comparison routines.
+#
+# (Later) The sorting behavior changed in 2.7.0.  But we will
+# keep these tests.  You can never have too many test cases!
+#
+do_test format3-2.1.1 {
+  execsql {
+    UPDATE t1 SET v='x' || -flt;
+    UPDATE t1 SET v='x-2b' where v=='x-0.123';
+    SELECT v FROM t1 ORDER BY v;
+  }
+} {x-123 x-2.15 x-2b x-3.141592653 x-4221 x0.0013442 x1.6 x11}
+do_test format3-2.1.2 {
+  execsql {
+    SELECT v FROM t1 ORDER BY substr(v,2,999);
+  }
+} {x-4221 x-123 x-3.141592653 x-2.15 x0.0013442 x1.6 x11 x-2b}
+do_test format3-2.1.3 {
+  execsql {
+    SELECT v FROM t1 ORDER BY substr(v,2,999)+0.0;
+  }
+} {x-4221 x-123 x-3.141592653 x-2.15 x-2b x0.0013442 x1.6 x11}
+do_test format3-2.1.4 {
+  execsql {
+    SELECT v FROM t1 ORDER BY substr(v,2,999) DESC;
+  }
+} {x-2b x11 x1.6 x0.0013442 x-2.15 x-3.141592653 x-123 x-4221}
+do_test format3-2.1.5 {
+  execsql {
+    SELECT v FROM t1 ORDER BY substr(v,2,999)+0.0 DESC;
+  }
+} {x11 x1.6 x0.0013442 x-2b x-2.15 x-3.141592653 x-123 x-4221}
+
+# This is a bug fix for 2.2.4.
+# Strings are normally mapped to upper-case for a caseless comparison.
+# But this can cause problems for characters in between 'Z' and 'a'.
+#
+do_test format3-3.1 {
+  execsql {
+    CREATE TABLE t2(a,b);
+    INSERT INTO t2 VALUES('AGLIENTU',1);
+    INSERT INTO t2 VALUES('AGLIE`',2);
+    INSERT INTO t2 VALUES('AGNA',3);
+    SELECT a, b FROM t2 ORDER BY a;
+  }
+} {AGLIENTU 1 AGLIE` 2 AGNA 3}
+do_test format3-3.2 {
+  execsql {
+    SELECT a, b FROM t2 ORDER BY a DESC;
+  }
+} {AGNA 3 AGLIE` 2 AGLIENTU 1}
+do_test format3-3.3 {
+  execsql {
+    DELETE FROM t2;
+    INSERT INTO t2 VALUES('aglientu',1);
+    INSERT INTO t2 VALUES('aglie`',2);
+    INSERT INTO t2 VALUES('agna',3);
+    SELECT a, b FROM t2 ORDER BY a;
+  }
+} {aglie` 2 aglientu 1 agna 3}
+do_test format3-3.4 {
+  execsql {
+    SELECT a, b FROM t2 ORDER BY a DESC;
+  }
+} {agna 3 aglientu 1 aglie` 2}
+
+# Version 2.7.0 testing.
+#
+do_test format3-4.1 {
+  execsql {
+    INSERT INTO t1 VALUES(9,'x2.7',3,'IX',4.0e5);
+    INSERT INTO t1 VALUES(10,'x5.0e10',3,'X',-4.0e5);
+    INSERT INTO t1 VALUES(11,'x-4.0e9',3,'XI',4.1e4);
+    INSERT INTO t1 VALUES(12,'x01234567890123456789',3,'XII',-4.2e3);
+    SELECT n FROM t1 ORDER BY n;
+  }
+} {1 2 3 4 5 6 7 8 9 10 11 12}
+do_test format3-4.2 {
+  execsql {
+    SELECT n||'' FROM t1 ORDER BY 1;
+  }
+} {1 2 3 4 5 6 7 8 9 10 11 12}
+do_test format3-4.3 {
+  execsql {
+    SELECT n+0 FROM t1 ORDER BY 1;
+  }
+} {1 2 3 4 5 6 7 8 9 10 11 12}
+do_test format3-4.4 {
+  execsql {
+    SELECT n||'' FROM t1 ORDER BY 1 DESC;
+  }
+} {12 11 10 9 8 7 6 5 4 3 2 1}
+do_test format3-4.5 {
+  execsql {
+    SELECT n+0 FROM t1 ORDER BY 1 DESC;
+  }
+} {12 11 10 9 8 7 6 5 4 3 2 1}
+do_test format3-4.6 {
+  execsql {
+    SELECT v FROM t1 ORDER BY 1;
+  }
+} {x-123 x-2.15 x-2b x-3.141592653 x-4.0e9 x-4221 x0.0013442 x01234567890123456789 x1.6 x11 x2.7 x5.0e10}
+do_test format3-4.7 {
+  execsql {
+    SELECT v FROM t1 ORDER BY 1 DESC;
+  }
+} {x5.0e10 x2.7 x11 x1.6 x01234567890123456789 x0.0013442 x-4221 x-4.0e9 x-3.141592653 x-2b x-2.15 x-123}
+do_test format3-4.8 {
+  execsql {
+    SELECT substr(v,2,99) FROM t1 ORDER BY 1;
+  }
+} {-4.0e9 -4221 -123 -3.141592653 -2.15 0.0013442 1.6 2.7 11 5.0e10 01234567890123456789 -2b}
+
+# Build some new test data, this time with indices.
+#
+do_test format3-5.0 {
+  execsql {
+    DROP TABLE t1;
+    CREATE TABLE t1(w int, x text, y blob);
+    DROP TABLE t2;
+    CREATE TABLE t2(p varchar(1), q clob, r real, s numeric(8));
+  }
+  for {set i 1} {$i<=100} {incr i} {
+    set w $i
+    set x [expr {int(log($i)/log(2))}]
+    set y [expr {$i*$i + 2*$i + 1}]
+    execsql "INSERT INTO t1 VALUES($w,$x,$y)"
+  }
+  execsql {
+    INSERT INTO t2 SELECT 101-w, x, (SELECT max(y) FROM t1)+1-y, y FROM t1;
+    CREATE INDEX i1w ON t1(w);
+    CREATE INDEX i1xy ON t1(x,y);
+    CREATE INDEX i2p ON t2(p);
+    CREATE INDEX i2r ON t2(r);
+    CREATE INDEX i2qs ON t2(q, s);
+  }
+} {}
+
+# Do an SQL statement.  Append the search count to the end of the result.
+#
+proc count sql {
+  set ::sqlite_search_count 0
+  return [concat [execsql $sql] $::sqlite_search_count]
+}
+
+# Verify that queries use an index.  We are using the special variable
+# "sqlite_search_count" which tallys the number of executions of MoveTo
+# and Next operators in the VDBE.  By verifing that the search count is
+# small we can be assured that indices are being used properly.
+#
+do_test format3-5.1 {
+  db close
+  sqlite db test.db
+  count {SELECT x, y FROM t1 WHERE w=10}
+} {3 121 3}
+do_test format3-5.2 {
+  count {SELECT x, y FROM t1 WHERE w=11}
+} {3 144 3}
+do_test format3-5.3 {
+  count {SELECT x, y FROM t1 WHERE 11=w}
+} {3 144 3}
+do_test format3-5.4 {
+  count {SELECT x, y FROM t1 WHERE 11=w AND x>2}
+} {3 144 3}
+do_test format3-5.5 {
+  count {SELECT x, y FROM t1 WHERE y<200 AND w=11 AND x>2}
+} {3 144 3}
+do_test format3-5.6 {
+  count {SELECT x, y FROM t1 WHERE y<200 AND x>2 AND w=11}
+} {3 144 3}
+do_test format3-5.7 {
+  count {SELECT x, y FROM t1 WHERE w=11 AND y<200 AND x>2}
+} {3 144 3}
+do_test format3-5.8 {
+  count {SELECT x, y FROM t1 WHERE w>10 AND y=144 AND x=3}
+} {3 144 3}
+do_test format3-5.9 {
+  count {SELECT x, y FROM t1 WHERE y=144 AND w>10 AND x=3}
+} {3 144 3}
+do_test format3-5.10 {
+  count {SELECT x, y FROM t1 WHERE x=3 AND w>=10 AND y=121}
+} {3 121 3}
+do_test format3-5.11 {
+  count {SELECT x, y FROM t1 WHERE x=3 AND y=100 AND w<10}
+} {3 100 3}
+
+# New for SQLite version 2.1: Verify that that inequality constraints
+# are used correctly.
+#
+do_test format3-5.12 {
+  count {SELECT w FROM t1 WHERE x=3 AND y<100}
+} {8 3}
+do_test format3-5.13 {
+  count {SELECT w FROM t1 WHERE x=3 AND 100>y}
+} {8 3}
+do_test format3-5.14 {
+  count {SELECT w FROM t1 WHERE 3=x AND y<100}
+} {8 3}
+do_test format3-5.15 {
+  count {SELECT w FROM t1 WHERE 3=x AND 100>y}
+} {8 3}
+do_test format3-5.16 {
+  count {SELECT w FROM t1 WHERE x=3 AND y<=100}
+} {8 9 5}
+do_test format3-5.17 {
+  count {SELECT w FROM t1 WHERE x=3 AND 100>=y}
+} {8 9 5}
+do_test format3-5.18 {
+  count {SELECT w FROM t1 WHERE x=3 AND y>225}
+} {15 3}
+do_test format3-5.19 {
+  count {SELECT w FROM t1 WHERE x=3 AND 225<y}
+} {15 3}
+do_test format3-5.20 {
+  count {SELECT w FROM t1 WHERE x=3 AND y>=225}
+} {14 15 5}
+do_test format3-5.21 {
+  count {SELECT w FROM t1 WHERE x=3 AND 225<=y}
+} {14 15 5}
+do_test format3-5.22 {
+  count {SELECT w FROM t1 WHERE x=3 AND y>121 AND y<196}
+} {11 12 5}
+do_test format3-5.23 {
+  count {SELECT w FROM t1 WHERE x=3 AND y>=121 AND y<=196}
+} {10 11 12 13 9}
+do_test format3-5.24 {
+  count {SELECT w FROM t1 WHERE x=3 AND 121<y AND 196>y}
+} {11 12 5}
+do_test format3-5.25 {
+  count {SELECT w FROM t1 WHERE x=3 AND 121<=y AND 196>=y}
+} {10 11 12 13 9}
+
+# Need to work on optimizing the BETWEEN operator.  
+#
+# do_test format3-5.26 {
+#   count {SELECT w FROM t1 WHERE x=3 AND y BETWEEN 121 AND 196}
+# } {10 11 12 13 9}
+
+do_test format3-5.27 {
+  count {SELECT w FROM t1 WHERE x=3 AND y+1==122}
+} {10 17}
+do_test format3-5.28 {
+  count {SELECT w FROM t1 WHERE x+1=4 AND y+1==122}
+} {10 99}
+do_test format3-5.29 {
+  count {SELECT w FROM t1 WHERE y==121}
+} {10 99}
+
+
+do_test format3-5.30 {
+  count {SELECT w FROM t1 WHERE w>97}
+} {98 99 100 6}
+do_test format3-5.31 {
+  count {SELECT w FROM t1 WHERE w>=97}
+} {97 98 99 100 8}
+do_test format3-5.33 {
+  count {SELECT w FROM t1 WHERE w==97}
+} {97 3}
+do_test format3-5.34 {
+  count {SELECT w FROM t1 WHERE w+1==98}
+} {97 99}
+do_test format3-5.35 {
+  count {SELECT w FROM t1 WHERE w<3}
+} {1 2 4}
+do_test format3-5.36 {
+  count {SELECT w FROM t1 WHERE w<=3}
+} {1 2 3 6}
+do_test format3-5.37 {
+  count {SELECT w FROM t1 WHERE w+1<=4 ORDER BY w}
+} {1 2 3 199}
+
+
+# Do the same kind of thing except use a join as the data source.
+#
+do_test format3-6.1 {
+  db close
+  sqlite db test.db
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE x=q AND y=s AND r=8977
+  }
+} {34 67 6}
+do_test format3-6.2 {
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE x=q AND s=y AND r=8977
+  }
+} {34 67 6}
+do_test format3-6.3 {
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE x=q AND s=y AND r=8977 AND w>10
+  }
+} {34 67 6}
+do_test format3-6.4 {
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE p<80 AND x=q AND s=y AND r=8977 AND w>10
+  }
+} {34 67 6}
+do_test format3-6.5 {
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE p<80 AND x=q AND 8977=r AND s=y AND w>10
+  }
+} {34 67 6}
+do_test format3-6.6 {
+  count {
+    SELECT w, p FROM t2, t1
+    WHERE x=q AND p=77 AND s=y AND w>5
+  }
+} {24 77 6}
+do_test format3-6.7 {
+  count {
+    SELECT w, p FROM t1, t2
+    WHERE x=q AND p>77 AND s=y AND w=5
+  }
+} {5 96 6}
+
+# Lets do a 3-way join.
+#
+do_test format3-7.1 {
+  count {
+    SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
+    WHERE C.w=101-B.p AND B.r=10202-A.y AND A.w=11
+  }
+} {11 90 11 9}
+do_test format3-7.2 {
+  count {
+    SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
+    WHERE C.w=101-B.p AND B.r=10202-A.y AND A.w=12
+  }
+} {12 89 12 9}
+do_test format3-7.3 {
+  count {
+    SELECT A.w, B.p, C.w FROM t1 as A, t2 as B, t1 as C
+    WHERE A.w=15 AND B.p=C.w AND B.r=10202-A.y
+  }
+} {15 86 86 9}
+
+# Test to see that the special case of a constant WHERE clause is
+# handled.
+#
+do_test format3-8.1 {
+  count {
+    SELECT * FROM t1 WHERE 0
+  }
+} {0}
+do_test format3-8.2 {
+  count {
+    SELECT * FROM t1 WHERE 1 LIMIT 1
+  }
+} {1 0 4 1}
+do_test format3-8.3 {
+  execsql {
+    SELECT 99 WHERE 0
+  }
+} {}
+do_test format3-8.4 {
+  execsql {
+    SELECT 99 WHERE 1
+  }
+} {99}
+
+# Verify that IN operators in a WHERE clause are handled correctly.
+#
+do_test format3-9.1 {
+  count {
+    SELECT * FROM t1 WHERE rowid IN (1,2,3,1234) order by 1;
+  }
+} {1 0 4 2 1 9 3 1 16 0}
+do_test format3-9.2 {
+  count {
+    SELECT * FROM t1 WHERE rowid+0 IN (1,2,3,1234) order by 1;
+  }
+} {1 0 4 2 1 9 3 1 16 199}
+do_test format3-9.3 {
+  count {
+    SELECT * FROM t1 WHERE w IN (-1,1,2,3) order by 1;
+  }
+} {1 0 4 2 1 9 3 1 16 10}
+do_test format3-9.4 {
+  count {
+    SELECT * FROM t1 WHERE w+0 IN (-1,1,2,3) order by 1;
+  }
+} {1 0 4 2 1 9 3 1 16 199}
+do_test format3-9.5 {
+  count {
+    SELECT * FROM t1 WHERE rowid IN 
+       (select rowid from t1 where rowid IN (-1,2,4))
+    ORDER BY 1;
+  }
+} {2 1 9 4 2 25 1}
+do_test format3-9.6 {
+  count {
+    SELECT * FROM t1 WHERE rowid+0 IN 
+       (select rowid from t1 where rowid IN (-1,2,4))
+    ORDER BY 1;
+  }
+} {2 1 9 4 2 25 199}
+do_test format3-9.7 {
+  count {
+    SELECT * FROM t1 WHERE w IN 
+       (select rowid from t1 where rowid IN (-1,2,4))
+    ORDER BY 1;
+  }
+} {2 1 9 4 2 25 7}
+do_test format3-9.8 {
+  count {
+    SELECT * FROM t1 WHERE w+0 IN 
+       (select rowid from t1 where rowid IN (-1,2,4))
+    ORDER BY 1;
+  }
+} {2 1 9 4 2 25 199}
+do_test format3-9.9 {
+  count {
+    SELECT * FROM t1 WHERE x IN (1,7) ORDER BY 1;
+  }
+} {2 1 9 3 1 16 6}
+do_test format3-9.10 {
+  count {
+    SELECT * FROM t1 WHERE x+0 IN (1,7) ORDER BY 1;
+  }
+} {2 1 9 3 1 16 199}
+do_test format3-9.11 {
+  count {
+    SELECT * FROM t1 WHERE y IN (6400,8100) ORDER BY 1;
+  }
+} {79 6 6400 89 6 8100 199}
+do_test format3-9.12 {
+  count {
+    SELECT * FROM t1 WHERE x=6 AND y IN (6400,8100) ORDER BY 1;
+  }
+} {79 6 6400 89 6 8100 74}
+do_test format3-9.13 {
+  count {
+    SELECT * FROM t1 WHERE x IN (1,7) AND y NOT IN (6400,8100) ORDER BY 1;
+  }
+} {2 1 9 3 1 16 6}
+do_test format3-9.14 {
+  count {
+    SELECT * FROM t1 WHERE x IN (1,7) AND y IN (9,10) ORDER BY 1;
+  }
+} {2 1 9 6}
+
+# This procedure executes the SQL.  Then it checks the generated program
+# for the SQL and appends a "nosort" to the result if the program contains the
+# SortCallback opcode.  If the program does not contain the SortCallback
+# opcode it appends "sort"
+#
+proc cksort {sql} {
+  set data [execsql $sql]
+  set prog [execsql "EXPLAIN $sql"]
+  if {[regexp SortCallback $prog]} {set x sort} {set x nosort}
+  lappend data $x
+  return $data
+}
+# Check out the logic that attempts to implement the ORDER BY clause
+# using an index rather than by sorting.
+#
+do_test format3-10.1 {
+  execsql {
+    CREATE TABLE t3(a,b,c);
+    CREATE INDEX t3a ON t3(a);
+    CREATE INDEX t3bc ON t3(b,c);
+    CREATE INDEX t3acb ON t3(a,c,b);
+    INSERT INTO t3 SELECT w, 101-w, y FROM t1;
+    SELECT count(*), sum(a), sum(b), sum(c) FROM t3;
+  }
+} {100 5050 5050 348550}
+do_test format3-10.2 {
+  cksort {
+    SELECT * FROM t3 ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test format3-10.3 {
+  cksort {
+    SELECT * FROM t3 ORDER BY a+1 LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test format3-10.4 {
+  cksort {
+    SELECT * FROM t3 WHERE a<10 ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test format3-10.5 {
+  cksort {
+    SELECT * FROM t3 WHERE a>0 AND a<10 ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test format3-10.6 {
+  cksort {
+    SELECT * FROM t3 WHERE a>0 ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 nosort}
+do_test format3-10.7 {
+  cksort {
+    SELECT * FROM t3 WHERE b>0 ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test format3-10.8 {
+  cksort {
+    SELECT * FROM t3 WHERE a IN (3,5,7,1,9,4,2) ORDER BY a LIMIT 3
+  }
+} {1 100 4 2 99 9 3 98 16 sort}
+do_test format3-10.9 {
+  cksort {
+    SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
+  }
+} {1 100 4 nosort}
+do_test format3-10.10 {
+  cksort {
+    SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a LIMIT 3
+  }
+} {1 100 4 nosort}
+do_test format3-10.11 {
+  cksort {
+    SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c LIMIT 3
+  }
+} {1 100 4 nosort}
+do_test format3-10.12 {
+  cksort {
+    SELECT * FROM t3 WHERE a=1 AND c>0 ORDER BY a,c,b LIMIT 3
+  }
+} {1 100 4 nosort}
+do_test format3-10.13 {
+  cksort {
+    SELECT * FROM t3 WHERE a>0 ORDER BY a DESC LIMIT 3
+  }
+} {100 1 10201 99 2 10000 98 3 9801 sort}
+do_test format3-10.14 {
+  cksort {
+    SELECT * FROM t3 ORDER BY b LIMIT 3
+  }
+} {100 1 10201 99 2 10000 98 3 9801 nosort}
+do_test format3-10.15 {
+  cksort {
+    SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t3.a LIMIT 3
+  }
+} {1 0 2 1 3 1 nosort}
+do_test format3-10.16 {
+  cksort {
+    SELECT t3.a, t1.x FROM t3, t1 WHERE t3.a=t1.w ORDER BY t1.x, t3.a LIMIT 3
+  }
+} {1 0 2 1 3 1 sort}
+do_test format3-10.17 {
+  cksort {
+    SELECT y FROM t1 ORDER BY w COLLATE text LIMIT 3;
+  }
+} {4 121 10201 sort}
+do_test format3-10.18 {
+  cksort {
+    SELECT y FROM t1 ORDER BY w COLLATE numeric LIMIT 3;
+  }
+} {4 9 16 sort}
+do_test format3-10.19 {
+  cksort {
+    SELECT y FROM t1 ORDER BY w LIMIT 3;
+  }
+} {4 9 16 nosort}
+
+# Check that all comparisons are numeric.  Similar tests in misc1.test
+# check the same comparisons on a format4+ database and find that some
+# are numeric and some are text.
+#
+do_test format3-11.1 {
+  execsql {SELECT '0'=='0.0'}
+} {1}
+do_test format3-11.2 {
+  execsql {SELECT '0'==0.0}
+} {1}
+do_test format3-11.3 {
+  execsql {SELECT '12345678901234567890'=='12345678901234567891'}
+} {1}
+do_test format3-11.4 {
+  execsql {
+    CREATE TABLE t6(a INT UNIQUE, b TEXT UNIQUE);
+    INSERT INTO t6 VALUES('0','0.0');
+    SELECT * FROM t6;
+  }
+} {0 0.0}
+do_test format3-11.5 {
+  execsql {
+    INSERT OR IGNORE INTO t6 VALUES(0.0,'x');
+    SELECT * FROM t6;
+  }
+} {0 0.0}
+do_test format3-11.6 {
+  execsql {
+    INSERT OR IGNORE INTO t6 VALUES('y',0);
+    SELECT * FROM t6;
+  }
+} {0 0.0}
+do_test format3-11.7 {
+  execsql {
+    CREATE TABLE t7(x INTEGER, y TEXT, z);
+    INSERT INTO t7 VALUES(0,0,1);
+    INSERT INTO t7 VALUES(0.0,0,2);
+    INSERT INTO t7 VALUES(0,0.0,3);
+    INSERT INTO t7 VALUES(0.0,0.0,4);
+    SELECT DISTINCT x, y FROM t7 ORDER BY z;
+  }
+} {0 0}
+
+finish_test
diff --git a/test/memleak.test b/test/memleak.test
new file mode 100644
index 0000000000..d2bcb7c923
--- /dev/null
+++ b/test/memleak.test
@@ -0,0 +1,77 @@
+# 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 runs all tests.
+#
+# $Id: memleak.test,v 1.1 2002/08/31 16:52:45 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+rename finish_test really_finish_test
+proc finish_test {} {
+  catch {db close}
+  memleak_check
+}
+
+if {[file exists ./sqlite_test_count]} {
+  set COUNT [exec cat ./sqlite_test_count]
+} else {
+  set COUNT 3
+}
+
+# LeakList will hold a list of the number of unfreed mallocs after
+# each round of the test.  This number should be constant.  If it
+# grows, it may mean there is a memory leak in the library.
+#
+set LeakList {}
+
+set EXCLUDE {
+  all.test
+  quick.test
+  malloc.test
+  misuse.test
+  memleak.test
+  btree2.test
+  trans.test
+}
+
+foreach testfile [lsort -dictionary [glob $testdir/*.test]] {
+  set tail [file tail $testfile]
+  if {[lsearch -exact $EXCLUDE $tail]>=0} continue
+  set LeakList {}
+  for {set COUNTER 0} {$COUNTER<$COUNT} {incr COUNTER} {
+    source $testfile
+    if {[info exists Leak]} {
+      lappend LeakList $Leak
+    }
+  }
+  if {$LeakList!=""} {
+    puts -nonewline memory-leak-test-$tail...
+    incr ::nTest
+    foreach x $LeakList {
+      if {$x!=[lindex $LeakList 0]} {
+         puts " failed! ($LeakList)"
+         incr ::nErr
+         lappend ::failList memory-leak-test-$tail
+         break
+       }
+    }
+    puts " Ok"
+  }
+}
+really_finish_test
+
+# Run the malloc tests and the misuse test after memory leak detection.
+# Both tests leak memory.
+#
+#catch {source $testdir/misuse.test}
+#catch {source $testdir/malloc.test}
+
+really_finish_test