[sql] Import SQLite 3.17.0.

third_party/sqlite/src/test/speedtest1.c

 /*
 ** A program for performance testing.
 **
 ** The available command-line options are described below:
 */
 static const char zHelp[] =
   "Usage: %s [--options] DATABASE\n"
   "Options:\n"
   "  --autovacuum        Enable AUTOVACUUM mode\n"
   "  --cachesize N       Set the cache size to N\n" 
   "  --exclusive         Enable locking_mode=EXCLUSIVE\n"
   "  --explain           Like --sqlonly but with added EXPLAIN keywords\n"
   "  --heap SZ MIN       Memory allocator uses SZ bytes & min allocation MIN\n"
   "  --incrvacuum        Enable incremenatal vacuum mode\n"
   "  --journal M         Set the journal_mode to M\n"
   "  --key KEY           Set the encryption key to KEY\n"
   "  --lookaside N SZ    Configure lookaside for N slots of SZ bytes each\n"
+  "  --mmap SZ           MMAP the first SZ bytes of the database file\n"
   "  --multithread       Set multithreaded mode\n"
   "  --nomemstat         Disable memory statistics\n"
   "  --nosync            Set PRAGMA synchronous=OFF\n"
   "  --notnull           Add NOT NULL constraints to table columns\n"
   "  --pagesize N        Set the page size to N\n"
   "  --pcache N SZ       Configure N pages of pagecache each of size SZ bytes\n"
   "  --primarykey        Use PRIMARY KEY instead of UNIQUE where appropriate\n"
+  "  --repeat N          Repeat each SELECT N times (default: 1)\n"
   "  --reprepare         Reprepare each statement upon every invocation\n"
   "  --scratch N SZ      Configure scratch memory for N slots of SZ bytes each\n"
   "  --serialized        Set serialized threading mode\n"
   "  --singlethread      Set single-threaded mode - disables all mutexing\n"
   "  --sqlonly           No-op.  Only show the SQL that would have been run.\n"
   "  --shrink-memory     Invoke sqlite3_db_release_memory() frequently.\n"
   "  --size N            Relative test size.  Default=100\n"
   "  --stats             Show statistics at the end\n"
+  "  --temp N            N from 0 to 9.  0: no temp table. 9: all temp tables\n"
   "  --testset T         Run test-set T\n"
   "  --trace             Turn on SQL tracing\n"
   "  --threads N         Use up to N threads for sorting\n"
   "  --utf16be           Set text encoding to UTF-16BE\n"
   "  --utf16le           Set text encoding to UTF-16LE\n"
   "  --verify            Run additional verification steps.\n"
   "  --without-rowid     Use WITHOUT ROWID where appropriate\n"
 ;
 
 
 #include "sqlite3.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <ctype.h>
+#ifndef _WIN32
+# include <unistd.h>
+#else
+# include <io.h>
+#endif
 #define ISSPACE(X) isspace((unsigned char)(X))
 #define ISDIGIT(X) isdigit((unsigned char)(X))
 
 #if SQLITE_VERSION_NUMBER<3005000
 # define sqlite3_int64 sqlite_int64
 #endif
-#ifdef SQLITE_ENABLE_RBU
-# include "sqlite3rbu.h"
-#endif
 
 /* All global state is held in this structure */
 static struct Global {
   sqlite3 *db;               /* The open database connection */
   sqlite3_stmt *pStmt;       /* Current SQL statement */
   sqlite3_int64 iStart;      /* Start-time for the current test */
   sqlite3_int64 iTotal;      /* Total time */
   int bWithoutRowid;         /* True for --without-rowid */
   int bReprepare;            /* True to reprepare the SQL on each rerun */
   int bSqlOnly;              /* True to print the SQL once only */
   int bExplain;              /* Print SQL with EXPLAIN prefix */
   int bVerify;               /* Try to verify that results are correct */
   int bMemShrink;            /* Call sqlite3_db_release_memory() often */
+  int eTemp;                 /* 0: no TEMP.  9: always TEMP. */
   int szTest;                /* Scale factor for test iterations */
+  int nRepeat;               /* Repeat selects this many times */
   const char *zWR;           /* Might be WITHOUT ROWID */
   const char *zNN;           /* Might be NOT NULL */
   const char *zPK;           /* Might be UNIQUE or PRIMARY KEY */
   unsigned int x, y;         /* Pseudo-random number generator state */
   int nResult;               /* Size of the current result */
   char zResult[3000];        /* Text of the current result */
 } g;
 
+/* Return " TEMP" or "", as appropriate for creating a table.
+*/
+static const char *isTemp(int N){
+  return g.eTemp>=N ? " TEMP" : "";
+}
+
 
 /* Print an error message and exit */
 static void fatal_error(const char *zMsg, ...){
   va_list ap;
   va_start(ap, zMsg);
   vfprintf(stderr, zMsg, ap);
   va_end(ap);
   exit(1);
 }
 
@@ skipping 315 matching lines @@
     sqlite3_finalize(g.pStmt);
     g.pStmt = pNew;
   }else
 #endif
   {
     sqlite3_reset(g.pStmt);
   }
   speedtest1_shrink_memory();
 }
 
+#ifndef SQLITE_OMIT_DEPRECATED
 /* The sqlite3_trace() callback function */
 static void traceCallback(void *NotUsed, const char *zSql){
   int n = (int)strlen(zSql);
   while( n>0 && (zSql[n-1]==';' || ISSPACE(zSql[n-1])) ) n--;
   fprintf(stderr,"%.*s;\n", n, zSql);
 }
+#endif /* SQLITE_OMIT_DEPRECATED */
 
 /* Substitute random() function that gives the same random
 ** sequence on each run, for repeatability. */
 static void randomFunc(
   sqlite3_context *context,
   int NotUsed,
   sqlite3_value **NotUsed2
 ){
   sqlite3_result_int64(context, (sqlite3_int64)speedtest1_random());
 }
 
 /* Estimate the square root of an integer */
 static int est_square_root(int x){
   int y0 = x/2;
   int y1;
   int n;
   for(n=0; y0>0 && n<10; n++){
     y1 = (y0 + x/y0)/2;
     if( y1==y0 ) break;
     y0 = y1;
   }
   return y0;
 }
 
+
+#if SQLITE_VERSION_NUMBER<3005004
+/*
+** An implementation of group_concat().  Used only when testing older
+** versions of SQLite that lack the built-in group_concat().
+*/
+struct groupConcat {
+  char *z;
+  int nAlloc;
+  int nUsed;
+};
+static void groupAppend(struct groupConcat *p, const char *z, int n){
+  if( p->nUsed+n >= p->nAlloc ){
+    int n2 = (p->nAlloc+n+1)*2;
+    char *z2 = sqlite3_realloc(p->z, n2);
+    if( z2==0 ) return;
+    p->z = z2;
+    p->nAlloc = n2;
+  }
+  memcpy(p->z+p->nUsed, z, n);
+  p->nUsed += n;
+}
+static void groupStep(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const char *zVal;
+  struct groupConcat *p;
+  const char *zSep;
+  int nVal, nSep;
+  assert( argc==1 || argc==2 );
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  p= (struct groupConcat*)sqlite3_aggregate_context(context, sizeof(*p));
+
+  if( p ){
+    int firstTerm = p->nUsed==0;
+    if( !firstTerm ){
+      if( argc==2 ){
+        zSep = (char*)sqlite3_value_text(argv[1]);
+        nSep = sqlite3_value_bytes(argv[1]);
+      }else{
+        zSep = ",";
+        nSep = 1;
+      }
+      if( nSep ) groupAppend(p, zSep, nSep);
+    }
+    zVal = (char*)sqlite3_value_text(argv[0]);
+    nVal = sqlite3_value_bytes(argv[0]);
+    if( zVal ) groupAppend(p, zVal, nVal);
+  }
+}
+static void groupFinal(sqlite3_context *context){
+  struct groupConcat *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->z ){
+    p->z[p->nUsed] = 0;
+    sqlite3_result_text(context, p->z, p->nUsed, sqlite3_free);
+  }
+}
+#endif
+
 /*
 ** The main and default testset
 */
 void testset_main(void){
   int i;                        /* Loop counter */
   int n;                        /* iteration count */
   int sz;                       /* Size of the tables */
   int maxb;                     /* Maximum swizzled value */
-  unsigned x1, x2;              /* Parameters */
-  int len;                      /* Length of the zNum[] string */
+  unsigned x1 = 0, x2 = 0;      /* Parameters */
+  int len = 0;                  /* Length of the zNum[] string */
   char zNum[2000];              /* A number name */
 
   sz = n = g.szTest*500;
+  zNum[0] = 0;
   maxb = roundup_allones(sz);
   speedtest1_begin_test(100, "%d INSERTs into table with no index", n);
   speedtest1_exec("BEGIN");
-  speedtest1_exec("CREATE TABLE t1(a INTEGER %s, b INTEGER %s, c TEXT %s);",
-                  g.zNN, g.zNN, g.zNN);
+  speedtest1_exec("CREATE%s TABLE t1(a INTEGER %s, b INTEGER %s, c TEXT %s);",
+                  isTemp(9), g.zNN, g.zNN, g.zNN);
   speedtest1_prepare("INSERT INTO t1 VALUES(?1,?2,?3); --  %d times", n);
   for(i=1; i<=n; i++){
     x1 = swizzle(i,maxb);
     speedtest1_numbername(x1, zNum, sizeof(zNum));
     sqlite3_bind_int64(g.pStmt, 1, (sqlite3_int64)x1);
     sqlite3_bind_int(g.pStmt, 2, i);
     sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = sz;
   speedtest1_begin_test(110, "%d ordered INSERTS with one index/PK", n);
   speedtest1_exec("BEGIN");
-  speedtest1_exec("CREATE TABLE t2(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
-                   g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
+  speedtest1_exec(
+     "CREATE%s TABLE t2(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
+     isTemp(5), g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
   speedtest1_prepare("INSERT INTO t2 VALUES(?1,?2,?3); -- %d times", n);
   for(i=1; i<=n; i++){
     x1 = swizzle(i,maxb);
     speedtest1_numbername(x1, zNum, sizeof(zNum));
     sqlite3_bind_int(g.pStmt, 1, i);
     sqlite3_bind_int64(g.pStmt, 2, (sqlite3_int64)x1);
     sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = sz;
   speedtest1_begin_test(120, "%d unordered INSERTS with one index/PK", n);
   speedtest1_exec("BEGIN");
-  speedtest1_exec("CREATE TABLE t3(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
-                   g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
+  speedtest1_exec(
+      "CREATE%s TABLE t3(a INTEGER %s %s, b INTEGER %s, c TEXT %s) %s",
+      isTemp(3), g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
   speedtest1_prepare("INSERT INTO t3 VALUES(?1,?2,?3); -- %d times", n);
   for(i=1; i<=n; i++){
     x1 = swizzle(i,maxb);
     speedtest1_numbername(x1, zNum, sizeof(zNum));
     sqlite3_bind_int(g.pStmt, 2, i);
     sqlite3_bind_int64(g.pStmt, 1, (sqlite3_int64)x1);
     sqlite3_bind_text(g.pStmt, 3, zNum, -1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
+#if SQLITE_VERSION_NUMBER<3005004
+  sqlite3_create_function(g.db, "group_concat", 1, SQLITE_UTF8, 0,
+                          0, groupStep, groupFinal);
+#endif
 
   n = 25;
   speedtest1_begin_test(130, "%d SELECTS, numeric BETWEEN, unindexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
-    "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
+    "SELECT count(*), avg(b), sum(length(c)), group_concat(c) FROM t1\n"
     " WHERE b BETWEEN ?1 AND ?2; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    x2 = speedtest1_random()%10 + sz/5000 + x1;
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      x2 = speedtest1_random()%10 + sz/5000 + x1;
+    }
     sqlite3_bind_int(g.pStmt, 1, x1);
     sqlite3_bind_int(g.pStmt, 2, x2);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = 10;
   speedtest1_begin_test(140, "%d SELECTS, LIKE, unindexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
-    "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
+    "SELECT count(*), avg(b), sum(length(c)), group_concat(c) FROM t1\n"
     " WHERE c LIKE ?1; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    zNum[0] = '%';
-    len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
-    zNum[len] = '%';
-    zNum[len+1] = 0;
-    sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      zNum[0] = '%';
+      len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
+      zNum[len] = '%';
+      zNum[len+1] = 0;
+    }
+    sqlite3_bind_text(g.pStmt, 1, zNum, len+1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = 10;
   speedtest1_begin_test(142, "%d SELECTS w/ORDER BY, unindexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
     "SELECT a, b, c FROM t1 WHERE c LIKE ?1\n"
     " ORDER BY a; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    zNum[0] = '%';
-    len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
-    zNum[len] = '%';
-    zNum[len+1] = 0;
-    sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      zNum[0] = '%';
+      len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
+      zNum[len] = '%';
+      zNum[len+1] = 0;
+    }
+    sqlite3_bind_text(g.pStmt, 1, zNum, len+1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
   n = 10; /* g.szTest/5; */
   speedtest1_begin_test(145, "%d SELECTS w/ORDER BY and LIMIT, unindexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
     "SELECT a, b, c FROM t1 WHERE c LIKE ?1\n"
     " ORDER BY a LIMIT 10; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    zNum[0] = '%';
-    len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
-    zNum[len] = '%';
-    zNum[len+1] = 0;
-    sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      zNum[0] = '%';
+      len = speedtest1_numbername(i, zNum+1, sizeof(zNum)-2);
+      zNum[len] = '%';
+      zNum[len+1] = 0;
+    }
+    sqlite3_bind_text(g.pStmt, 1, zNum, len+1, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   speedtest1_begin_test(150, "CREATE INDEX five times");
   speedtest1_exec("BEGIN;");
   speedtest1_exec("CREATE UNIQUE INDEX t1b ON t1(b);");
   speedtest1_exec("CREATE INDEX t1c ON t1(c);");
   speedtest1_exec("CREATE UNIQUE INDEX t2b ON t2(b);");
   speedtest1_exec("CREATE INDEX t2c ON t2(c DESC);");
   speedtest1_exec("CREATE INDEX t3bc ON t3(b,c);");
   speedtest1_exec("COMMIT;");
   speedtest1_end_test();
 
 
   n = sz/5;
   speedtest1_begin_test(160, "%d SELECTS, numeric BETWEEN, indexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
-    "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
+    "SELECT count(*), avg(b), sum(length(c)), group_concat(a) FROM t1\n"
     " WHERE b BETWEEN ?1 AND ?2; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    x2 = speedtest1_random()%10 + sz/5000 + x1;
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      x2 = speedtest1_random()%10 + sz/5000 + x1;
+    }
     sqlite3_bind_int(g.pStmt, 1, x1);
     sqlite3_bind_int(g.pStmt, 2, x2);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = sz/5;
   speedtest1_begin_test(161, "%d SELECTS, numeric BETWEEN, PK", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
-    "SELECT count(*), avg(b), sum(length(c)) FROM t2\n"
+    "SELECT count(*), avg(b), sum(length(c)), group_concat(a) FROM t2\n"
     " WHERE a BETWEEN ?1 AND ?2; -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = speedtest1_random()%maxb;
-    x2 = speedtest1_random()%10 + sz/5000 + x1;
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = speedtest1_random()%maxb;
+      x2 = speedtest1_random()%10 + sz/5000 + x1;
+    }
     sqlite3_bind_int(g.pStmt, 1, x1);
     sqlite3_bind_int(g.pStmt, 2, x2);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
 
   n = sz/5;
   speedtest1_begin_test(170, "%d SELECTS, text BETWEEN, indexed", n);
   speedtest1_exec("BEGIN");
   speedtest1_prepare(
-    "SELECT count(*), avg(b), sum(length(c)) FROM t1\n"
+    "SELECT count(*), avg(b), sum(length(c)), group_concat(a) FROM t1\n"
     " WHERE c BETWEEN ?1 AND (?1||'~'); -- %d times", n
   );
   for(i=1; i<=n; i++){
-    x1 = swizzle(i, maxb);
-    len = speedtest1_numbername(x1, zNum, sizeof(zNum)-1);
+    if( (i-1)%g.nRepeat==0 ){
+      x1 = swizzle(i, maxb);
+      len = speedtest1_numbername(x1, zNum, sizeof(zNum)-1);
+    }
     sqlite3_bind_text(g.pStmt, 1, zNum, len, SQLITE_STATIC);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
   n = sz;
   speedtest1_begin_test(180, "%d INSERTS with three indexes", n);
   speedtest1_exec("BEGIN");
   speedtest1_exec(
-    "CREATE TABLE t4(\n"
+    "CREATE%s TABLE t4(\n"
     "  a INTEGER %s %s,\n"
     "  b INTEGER %s,\n"
     "  c TEXT %s\n"
     ") %s",
-    g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
+    isTemp(1), g.zNN, g.zPK, g.zNN, g.zNN, g.zWR);
   speedtest1_exec("CREATE INDEX t4b ON t4(b)");
   speedtest1_exec("CREATE INDEX t4c ON t4(c)");
   speedtest1_exec("INSERT INTO t4 SELECT * FROM t1");
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
   n = sz;
   speedtest1_begin_test(190, "DELETE and REFILL one table", n);
   speedtest1_exec("DELETE FROM t2;");
   speedtest1_exec("INSERT INTO t2 SELECT * FROM t1;");
@@ skipping 122 matching lines @@
   speedtest1_begin_test(320, "subquery in result set", n);
   speedtest1_prepare(
     "SELECT sum(a), max(c),\n"
     "       avg((SELECT a FROM t2 WHERE 5+t2.b=t1.b) AND rowid<?1), max(c)\n"
     " FROM t1 WHERE rowid<?1;"
   );
   sqlite3_bind_int(g.pStmt, 1, est_square_root(g.szTest)*50);
   speedtest1_run();
   speedtest1_end_test();
 
+  sz = n = g.szTest*700;
+  zNum[0] = 0;
+  maxb = roundup_allones(sz/3);
+  speedtest1_begin_test(400, "%d REPLACE ops on an IPK", n);
+  speedtest1_exec("BEGIN");
+  speedtest1_exec("CREATE%s TABLE t5(a INTEGER PRIMARY KEY, b %s);",
+                  isTemp(9), g.zNN);
+  speedtest1_prepare("REPLACE INTO t5 VALUES(?1,?2); --  %d times",n);
+  for(i=1; i<=n; i++){
+    x1 = swizzle(i,maxb);
+    speedtest1_numbername(i, zNum, sizeof(zNum));
+    sqlite3_bind_int(g.pStmt, 1, (sqlite3_int64)x1);
+    sqlite3_bind_text(g.pStmt, 2, zNum, -1, SQLITE_STATIC);
+    speedtest1_run();
+  }
+  speedtest1_exec("COMMIT");
+  speedtest1_end_test();
+  speedtest1_begin_test(410, "%d SELECTS on an IPK", n);
+  speedtest1_prepare("SELECT b FROM t5 WHERE a=?1; --  %d times",n);
+  for(i=1; i<=n; i++){
+    x1 = swizzle(i,maxb);
+    sqlite3_bind_int(g.pStmt, 1, (sqlite3_int64)x1);
+    speedtest1_run();
+  }
+  speedtest1_end_test();
+
+  sz = n = g.szTest*700;
+  zNum[0] = 0;
+  maxb = roundup_allones(sz/3);
+  speedtest1_begin_test(500, "%d REPLACE on TEXT PK", n);
+  speedtest1_exec("BEGIN");
+  speedtest1_exec("CREATE%s TABLE t6(a TEXT PRIMARY KEY, b %s)%s;",
+                  isTemp(9), g.zNN,
+                  sqlite3_libversion_number()>=3008002 ? "WITHOUT ROWID" : "");
+  speedtest1_prepare("REPLACE INTO t6 VALUES(?1,?2); --  %d times",n);
+  for(i=1; i<=n; i++){
+    x1 = swizzle(i,maxb);
+    speedtest1_numbername(x1, zNum, sizeof(zNum));
+    sqlite3_bind_int(g.pStmt, 2, i);
+    sqlite3_bind_text(g.pStmt, 1, zNum, -1, SQLITE_STATIC);
+    speedtest1_run();
+  }
+  speedtest1_exec("COMMIT");
+  speedtest1_end_test();
+  speedtest1_begin_test(510, "%d SELECTS on a TEXT PK", n);
+  speedtest1_prepare("SELECT b FROM t6 WHERE a=?1; --  %d times",n);
+  for(i=1; i<=n; i++){
+    x1 = swizzle(i,maxb);
+    speedtest1_numbername(x1, zNum, sizeof(zNum));
+    sqlite3_bind_text(g.pStmt, 1, zNum, -1, SQLITE_STATIC);
+    speedtest1_run();
+  }
+  speedtest1_end_test();
+  speedtest1_begin_test(520, "%d SELECT DISTINCT", n);
+  speedtest1_exec("SELECT DISTINCT b FROM t5;");
+  speedtest1_exec("SELECT DISTINCT b FROM t6;");
+  speedtest1_end_test();
+
+
   speedtest1_begin_test(980, "PRAGMA integrity_check");
   speedtest1_exec("PRAGMA integrity_check");
   speedtest1_end_test();
 
 
   speedtest1_begin_test(990, "ANALYZE");
   speedtest1_exec("ANALYZE");
   speedtest1_end_test();
 }
 
@@ skipping 199 matching lines @@
 
 #ifdef SQLITE_ENABLE_RTREE
 /*
 ** A testset for the R-Tree virtual table
 */
 void testset_rtree(int p1, int p2){
   unsigned i, n;
   unsigned mxCoord;
   unsigned x0, x1, y0, y1, z0, z1;
   unsigned iStep;
-  int *aCheck = sqlite3_malloc( sizeof(int)*g.szTest*100 );
+  int *aCheck = sqlite3_malloc( sizeof(int)*g.szTest*500 );
 
   mxCoord = 15000;
-  n = g.szTest*100;
+  n = g.szTest*500;
   speedtest1_begin_test(100, "%d INSERTs into an r-tree", n);
   speedtest1_exec("BEGIN");
   speedtest1_exec("CREATE VIRTUAL TABLE rt1 USING rtree(id,x0,x1,y0,y1,z0,z1)");
   speedtest1_prepare("INSERT INTO rt1(id,x0,x1,y0,y1,z0,z1)"
                      "VALUES(?1,?2,?3,?4,?5,?6,?7)");
   for(i=1; i<=n; i++){
     twoCoords(p1, p2, mxCoord, &x0, &x1);
     twoCoords(p1, p2, mxCoord, &y0, &y1);
     twoCoords(p1, p2, mxCoord, &z0, &z1);
     sqlite3_bind_int(g.pStmt, 1, i);
     sqlite3_bind_int(g.pStmt, 2, x0);
     sqlite3_bind_int(g.pStmt, 3, x1);
     sqlite3_bind_int(g.pStmt, 4, y0);
     sqlite3_bind_int(g.pStmt, 5, y1);
     sqlite3_bind_int(g.pStmt, 6, z0);
     sqlite3_bind_int(g.pStmt, 7, z1);
     speedtest1_run();
   }
   speedtest1_exec("COMMIT");
   speedtest1_end_test();
 
   speedtest1_begin_test(101, "Copy from rtree to a regular table");
   speedtest1_exec("CREATE TABLE t1(id INTEGER PRIMARY KEY,x0,x1,y0,y1,z0,z1)");
   speedtest1_exec("INSERT INTO t1 SELECT * FROM rt1");
   speedtest1_end_test();
 
-  n = g.szTest*20;
+  n = g.szTest*100;
   speedtest1_begin_test(110, "%d one-dimensional intersect slice queries", n);
   speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x0>=?1 AND x1<=?2");
   iStep = mxCoord/n;
   for(i=0; i<n; i++){
     sqlite3_bind_int(g.pStmt, 1, i*iStep);
     sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
     speedtest1_run();
     aCheck[i] = atoi(g.zResult);
   }
   speedtest1_end_test();
 
   if( g.bVerify ){
-    n = g.szTest*20;
+    n = g.szTest*100;
     speedtest1_begin_test(111, "Verify result from 1-D intersect slice queries");
     speedtest1_prepare("SELECT count(*) FROM t1 WHERE x0>=?1 AND x1<=?2");
     iStep = mxCoord/n;
     for(i=0; i<n; i++){
       sqlite3_bind_int(g.pStmt, 1, i*iStep);
       sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
       speedtest1_run();
       if( aCheck[i]!=atoi(g.zResult) ){
         fatal_error("Count disagree step %d: %d..%d.  %d vs %d",
                     i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
       }
     }
     speedtest1_end_test();
   }
   
-  n = g.szTest*20;
+  n = g.szTest*100;
   speedtest1_begin_test(120, "%d one-dimensional overlap slice queries", n);
   speedtest1_prepare("SELECT count(*) FROM rt1 WHERE y1>=?1 AND y0<=?2");
   iStep = mxCoord/n;
   for(i=0; i<n; i++){
     sqlite3_bind_int(g.pStmt, 1, i*iStep);
     sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
     speedtest1_run();
     aCheck[i] = atoi(g.zResult);
   }
   speedtest1_end_test();
 
   if( g.bVerify ){
-    n = g.szTest*20;
+    n = g.szTest*100;
     speedtest1_begin_test(121, "Verify result from 1-D overlap slice queries");
     speedtest1_prepare("SELECT count(*) FROM t1 WHERE y1>=?1 AND y0<=?2");
     iStep = mxCoord/n;
     for(i=0; i<n; i++){
       sqlite3_bind_int(g.pStmt, 1, i*iStep);
       sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
       speedtest1_run();
       if( aCheck[i]!=atoi(g.zResult) ){
         fatal_error("Count disagree step %d: %d..%d.  %d vs %d",
                     i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
       }
     }
     speedtest1_end_test();
   }
   
 
-  n = g.szTest*20;
+  n = g.szTest*100;
   speedtest1_begin_test(125, "%d custom geometry callback queries", n);
   sqlite3_rtree_geometry_callback(g.db, "xslice", xsliceGeometryCallback, 0);
   speedtest1_prepare("SELECT count(*) FROM rt1 WHERE id MATCH xslice(?1,?2)");
   iStep = mxCoord/n;
   for(i=0; i<n; i++){
     sqlite3_bind_int(g.pStmt, 1, i*iStep);
     sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
     speedtest1_run();
     if( aCheck[i]!=atoi(g.zResult) ){
       fatal_error("Count disagree step %d: %d..%d.  %d vs %d",
                   i, i*iStep, (i+1)*iStep, aCheck[i], atoi(g.zResult));
     }
   }
   speedtest1_end_test();
 
-  n = g.szTest*80;
+  n = g.szTest*400;
   speedtest1_begin_test(130, "%d three-dimensional intersect box queries", n);
   speedtest1_prepare("SELECT count(*) FROM rt1 WHERE x1>=?1 AND x0<=?2"
                      " AND y1>=?1 AND y0<=?2 AND z1>=?1 AND z0<=?2");
   iStep = mxCoord/n;
   for(i=0; i<n; i++){
     sqlite3_bind_int(g.pStmt, 1, i*iStep);
     sqlite3_bind_int(g.pStmt, 2, (i+1)*iStep);
     speedtest1_run();
     aCheck[i] = atoi(g.zResult);
   }
   speedtest1_end_test();
 
-  n = g.szTest*100;
+  n = g.szTest*500;
   speedtest1_begin_test(140, "%d rowid queries", n);
   speedtest1_prepare("SELECT * FROM rt1 WHERE id=?1");
   for(i=1; i<=n; i++){
     sqlite3_bind_int(g.pStmt, 1, i);
     speedtest1_run();
   }
   speedtest1_end_test();
 }
 #endif /* SQLITE_ENABLE_RTREE */
 
 /*
 ** A testset used for debugging speedtest1 itself.
 */
 void testset_debug1(void){
   unsigned i, n;
   unsigned x1, x2;
   char zNum[2000];              /* A number name */
 
   n = g.szTest;
   for(i=1; i<=n; i++){
     x1 = swizzle(i, n);
     x2 = swizzle(x1, n);
     speedtest1_numbername(x1, zNum, sizeof(zNum));
     printf("%5d %5d %5d %s\n", i, x1, x2, zNum);
   }
 }
 
+#ifdef __linux__
+#include <sys/types.h>
+#include <unistd.h>
+
+/*
+** Attempt to display I/O stats on Linux using /proc/PID/io
+*/
+static void displayLinuxIoStats(FILE *out){
+  FILE *in;
+  char z[200];
+  sqlite3_snprintf(sizeof(z), z, "/proc/%d/io", getpid());
+  in = fopen(z, "rb");
+  if( in==0 ) return;
+  while( fgets(z, sizeof(z), in)!=0 ){
+    static const struct {
+      const char *zPattern;
+      const char *zDesc;
+    } aTrans[] = {
+      { "rchar: ",                  "Bytes received by read():" },
+      { "wchar: ",                  "Bytes sent to write():"    },
+      { "syscr: ",                  "Read() system calls:"      },
+      { "syscw: ",                  "Write() system calls:"     },
+      { "read_bytes: ",             "Bytes rcvd from storage:"  },
+      { "write_bytes: ",            "Bytes sent to storage:"    },
+      { "cancelled_write_bytes: ",  "Cancelled write bytes:"    },
+    };
+    int i;
+    for(i=0; i<sizeof(aTrans)/sizeof(aTrans[0]); i++){
+      int n = (int)strlen(aTrans[i].zPattern);
+      if( strncmp(aTrans[i].zPattern, z, n)==0 ){
+        fprintf(out, "-- %-28s %s", aTrans[i].zDesc, &z[n]);
+        break;
+      }
+    }
+  }
+  fclose(in);
+}   
+#endif
+
+#if SQLITE_VERSION_NUMBER<3006018
+#  define sqlite3_sourceid(X) "(before 3.6.18)"
+#endif
+
 int main(int argc, char **argv){
   int doAutovac = 0;            /* True for --autovacuum */
   int cacheSize = 0;            /* Desired cache size.  0 means default */
   int doExclusive = 0;          /* True for --exclusive */
   int nHeap = 0, mnHeap = 0;    /* Heap size from --heap */
   int doIncrvac = 0;            /* True for --incrvacuum */
   const char *zJMode = 0;       /* Journal mode */
   const char *zKey = 0;         /* Encryption key */
-  int nLook = 0, szLook = 0;    /* --lookaside configuration */
+  int nLook = -1, szLook = 0;   /* --lookaside configuration */
   int noSync = 0;               /* True for --nosync */
   int pageSize = 0;             /* Desired page size.  0 means default */
   int nPCache = 0, szPCache = 0;/* --pcache configuration */
   int doPCache = 0;             /* True if --pcache is seen */
   int nScratch = 0, szScratch=0;/* --scratch configuration */
   int showStats = 0;            /* True for --stats */
   int nThread = 0;              /* --threads value */
+  int mmapSize = 0;             /* How big of a memory map to use */
   const char *zTSet = "main";   /* Which --testset torun */
   int doTrace = 0;              /* True for --trace */
   const char *zEncoding = 0;    /* --utf16be or --utf16le */
   const char *zDbName = 0;      /* Name of the test database */
 
   void *pHeap = 0;              /* Allocated heap space */
   void *pLook = 0;              /* Allocated lookaside space */
   void *pPCache = 0;            /* Allocated storage for pcache */
   void *pScratch = 0;           /* Allocated storage for scratch */
   int iCur, iHi;                /* Stats values, current and "highwater" */
   int i;                        /* Loop counter */
   int rc;                       /* API return code */
 
+  /* Display the version of SQLite being tested */
+  printf("-- Speedtest1 for SQLite %s %.50s\n",
+         sqlite3_libversion(), sqlite3_sourceid());
+
   /* Process command-line arguments */
   g.zWR = "";
   g.zNN = "";
   g.zPK = "UNIQUE";
   g.szTest = 100;
+  g.nRepeat = 1;
   for(i=1; i<argc; i++){
     const char *z = argv[i];
     if( z[0]=='-' ){
       do{ z++; }while( z[0]=='-' );
       if( strcmp(z,"autovacuum")==0 ){
         doAutovac = 1;
       }else if( strcmp(z,"cachesize")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         i++;
         cacheSize = integerValue(argv[i]);
@@ skipping 13 matching lines @@
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         zJMode = argv[++i];
       }else if( strcmp(z,"key")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         zKey = argv[++i];
       }else if( strcmp(z,"lookaside")==0 ){
         if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
         nLook = integerValue(argv[i+1]);
         szLook = integerValue(argv[i+2]);
         i += 2;
+#if SQLITE_VERSION_NUMBER>=3006000
       }else if( strcmp(z,"multithread")==0 ){
         sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
       }else if( strcmp(z,"nomemstat")==0 ){
         sqlite3_config(SQLITE_CONFIG_MEMSTATUS, 0);
+#endif
+#if SQLITE_VERSION_NUMBER>=3007017
+      }else if( strcmp(z, "mmap")==0 ){
+        if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
+        mmapSize = integerValue(argv[++i]);
+ #endif
       }else if( strcmp(z,"nosync")==0 ){
         noSync = 1;
       }else if( strcmp(z,"notnull")==0 ){
         g.zNN = "NOT NULL";
-#ifdef SQLITE_ENABLE_RBU
-      }else if( strcmp(z,"rbu")==0 ){
-        sqlite3ota_create_vfs("rbu", 0);
-        sqlite3_vfs_register(sqlite3_vfs_find("rbu"), 1);
-#endif
       }else if( strcmp(z,"pagesize")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         pageSize = integerValue(argv[++i]);
       }else if( strcmp(z,"pcache")==0 ){
         if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
         nPCache = integerValue(argv[i+1]);
         szPCache = integerValue(argv[i+2]);
         doPCache = 1;
         i += 2;
       }else if( strcmp(z,"primarykey")==0 ){
         g.zPK = "PRIMARY KEY";
+      }else if( strcmp(z,"repeat")==0 ){
+        if( i>=argc-1 ) fatal_error("missing arguments on %s\n", argv[i]);
+        g.nRepeat = integerValue(argv[i+1]);
+        i += 1;
       }else if( strcmp(z,"reprepare")==0 ){
         g.bReprepare = 1;
       }else if( strcmp(z,"scratch")==0 ){
         if( i>=argc-2 ) fatal_error("missing arguments on %s\n", argv[i]);
         nScratch = integerValue(argv[i+1]);
         szScratch = integerValue(argv[i+2]);
         i += 2;
+#if SQLITE_VERSION_NUMBER>=3006000
       }else if( strcmp(z,"serialized")==0 ){
         sqlite3_config(SQLITE_CONFIG_SERIALIZED);
       }else if( strcmp(z,"singlethread")==0 ){
         sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
+#endif
       }else if( strcmp(z,"sqlonly")==0 ){
         g.bSqlOnly = 1;
       }else if( strcmp(z,"shrink-memory")==0 ){
         g.bMemShrink = 1;
       }else if( strcmp(z,"size")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         g.szTest = integerValue(argv[++i]);
       }else if( strcmp(z,"stats")==0 ){
         showStats = 1;
+      }else if( strcmp(z,"temp")==0 ){
+        if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
+        i++;
+        if( argv[i][0]<'0' || argv[i][0]>'9' || argv[i][1]!=0 ){
+          fatal_error("argument to --temp should be integer between 0 and 9");
+        }
+        g.eTemp = argv[i][0] - '0';
       }else if( strcmp(z,"testset")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         zTSet = argv[++i];
       }else if( strcmp(z,"trace")==0 ){
         doTrace = 1;
       }else if( strcmp(z,"threads")==0 ){
         if( i>=argc-1 ) fatal_error("missing argument on %s\n", argv[i]);
         nThread = integerValue(argv[++i]);
       }else if( strcmp(z,"utf16le")==0 ){
         zEncoding = "utf16le";
@@ skipping 11 matching lines @@
         fatal_error("unknown option: %s\nUse \"%s -?\" for help\n",
                     argv[i], argv[0]);
       }
     }else if( zDbName==0 ){
       zDbName = argv[i];
     }else{
       fatal_error("surplus argument: %s\nUse \"%s -?\" for help\n",
                   argv[i], argv[0]);
     }
   }
-#if 0
-  if( zDbName==0 ){
-    fatal_error(zHelp, argv[0]);
-  }
-#endif
+  if( zDbName!=0 ) unlink(zDbName);
 #if SQLITE_VERSION_NUMBER>=3006001
   if( nHeap>0 ){
     pHeap = malloc( nHeap );
     if( pHeap==0 ) fatal_error("cannot allocate %d-byte heap\n", nHeap);
     rc = sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nHeap, mnHeap);
     if( rc ) fatal_error("heap configuration failed: %d\n", rc);
   }
   if( doPCache ){
     if( nPCache>0 && szPCache>0 ){
       pPCache = malloc( nPCache*(sqlite3_int64)szPCache );
       if( pPCache==0 ) fatal_error("cannot allocate %lld-byte pcache\n",
                                    nPCache*(sqlite3_int64)szPCache);
     }
     rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, pPCache, szPCache, nPCache);
     if( rc ) fatal_error("pcache configuration failed: %d\n", rc);
   }
   if( nScratch>0 && szScratch>0 ){
     pScratch = malloc( nScratch*(sqlite3_int64)szScratch );
     if( pScratch==0 ) fatal_error("cannot allocate %lld-byte scratch\n",
                                  nScratch*(sqlite3_int64)szScratch);
     rc = sqlite3_config(SQLITE_CONFIG_SCRATCH, pScratch, szScratch, nScratch);
     if( rc ) fatal_error("scratch configuration failed: %d\n", rc);
   }
-  if( nLook>0 ){
+  if( nLook>=0 ){
     sqlite3_config(SQLITE_CONFIG_LOOKASIDE, 0, 0);
   }
 #endif
  
   /* Open the database and the input file */
   if( sqlite3_open(zDbName, &g.db) ){
     fatal_error("Cannot open database file: %s\n", zDbName);
   }
 #if SQLITE_VERSION_NUMBER>=3006001
   if( nLook>0 && szLook>0 ){
     pLook = malloc( nLook*szLook );
     rc = sqlite3_db_config(g.db, SQLITE_DBCONFIG_LOOKASIDE, pLook, szLook,nLook);
     if( rc ) fatal_error("lookaside configuration failed: %d\n", rc);
   }
 #endif
 
   /* Set database connection options */
   sqlite3_create_function(g.db, "random", 0, SQLITE_UTF8, 0, randomFunc, 0, 0);
+#ifndef SQLITE_OMIT_DEPRECATED
   if( doTrace ) sqlite3_trace(g.db, traceCallback, 0);
+#endif
+  if( mmapSize>0 ){
+    speedtest1_exec("PRAGMA mmap_size=%d", mmapSize);
+  }
   speedtest1_exec("PRAGMA threads=%d", nThread);
   if( zKey ){
     speedtest1_exec("PRAGMA key('%s')", zKey);
   }
   if( zEncoding ){
     speedtest1_exec("PRAGMA encoding=%s", zEncoding);
   }
   if( doAutovac ){
     speedtest1_exec("PRAGMA auto_vacuum=FULL");
   }else if( doIncrvac ){
@@ skipping 80 matching lines @@
     printf("-- Scratch Overflow Bytes:      %d (max %d)\n", iCur,iHi);
     sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHi, 0);
     printf("-- Largest Allocation:          %d bytes\n",iHi);
     sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHi, 0);
     printf("-- Largest Pcache Allocation:   %d bytes\n",iHi);
     sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHi, 0);
     printf("-- Largest Scratch Allocation:  %d bytes\n", iHi);
   }
 #endif
 
+#ifdef __linux__
+  if( showStats ){
+    displayLinuxIoStats(stdout);
+  }
+#endif
+
   /* Release memory */
   free( pLook );
   free( pPCache );
   free( pScratch );
   free( pHeap );
   return 0;
 }