SQLite4  Check-in [f93e75f2b1]

    }
  }
  if( !doInsert ) return;
  if( p->nSample==p->mxSample ){
    assert( p->nSample - iMin - 1 >= 0 );
    memmove(&p->a[iMin], &p->a[iMin+1], sizeof(p->a[0])*(p->nSample-iMin-1));
    pSample = &p->a[p->nSample-1];
    memset(pSample, 0, sizeof(struct Stat3Sample));
  }else{
    pSample = &p->a[p->nSample++];
  }

  pKey = sqlite4_value_blob(argv[3], &nKey);
  if( nKey>pSample->nAlloc ){
    sqlite4 *db = sqlite4_context_db_handle(context);

  if( !zSql ){
    return SQLITE4_NOMEM;
  }
  rc = sqlite4_prepare(db, zSql, -1, &pStmt, 0);
  sqlite4DbFree(db, zSql);
  if( rc ) return rc;

  while( sqlite4_step(pStmt)==SQLITE4_ROW ){
    char *zIndex;   /* Index name */
    Index *pIdx;    /* Pointer to the index object */
    int i;          /* Loop counter */
    tRowcnt sumEq;  /* Sum of the nEq values */
    const u8 *aVal;
    int nVal;

      sqlite4_stmt *pStmt = va_arg(ap, sqlite4_stmt*);
      const char **pzRet = va_arg(ap, const char**);
      *pzRet = sqlite4VdbeExplanation((Vdbe*)pStmt);
      break;
    }
#endif

    case SQLITE4_TESTCTRL_PRNG_GET: {
      sqlite4_env *pEnv = va_arg(ap, sqlite4_env *);
      sqlite4_int64 *piOut = va_arg(ap, sqlite4_int64 *);
      if( pEnv==0 ) pEnv = &sqlite4DefaultEnv;
      *piOut = (sqlite4_int64)(((u64)pEnv->prngX << 32) + pEnv->prngY);
      break;
    }
    case SQLITE4_TESTCTRL_PRNG_SET: {
      sqlite4_env *pEnv = va_arg(ap, sqlite4_env *);
      u64 iVal = (u64)va_arg(ap, sqlite4_int64);
      if( pEnv==0 ) pEnv = &sqlite4DefaultEnv;
      pEnv->prngX = (iVal>>32);
      pEnv->prngY = (iVal & 0xFFFFFFFF);
      break;
    }
  }
  va_end(ap);
#endif /* SQLITE4_OMIT_BUILTIN_TEST */
  return rc;
}

/*

#define SQLITE4_TESTCTRL_ASSERT                   3
#define SQLITE4_TESTCTRL_ALWAYS                   4
#define SQLITE4_TESTCTRL_RESERVE                  5
#define SQLITE4_TESTCTRL_OPTIMIZATIONS            6
#define SQLITE4_TESTCTRL_ISKEYWORD                7
#define SQLITE4_TESTCTRL_LOCALTIME_FAULT          8
#define SQLITE4_TESTCTRL_EXPLAIN_STMT             9
#define SQLITE4_TESTCTRL_PRNG_GET                 10  /* pEnv, *pi64 */
#define SQLITE4_TESTCTRL_PRNG_SET                 11  /* pEnv, i64   */
#define SQLITE4_TESTCTRL_LAST                     11

/*
** CAPIREF: SQLite Runtime Status
**
** ^This interface is used to retrieve runtime status information
** about the performance of SQLite, and optionally to reset various
** highwater marks.  ^The first argument is an integer code for

  for(i=0; i<pIdx->nSample; i++){
    int res;
    int n = pBuf->n;
    if( n>aSample[i].nVal ) n = aSample[i].nVal;

    res = memcmp(pBuf->p, aSample[i].aVal, n);
    if( res==0 ) res = pBuf->n - aSample[i].nVal;
    if( res<=0 ){
      isEq = (res==0);
      break;
    }
  }

  /* At this point, aSample[i] is the first sample that is greater than
  ** or equal to pVal.  Or if i==pIdx->nSample, then all samples are less

    sqlite4_buffer_init(&buf, db->pEnv->pMM);
    rc = whereSampleKeyinfo(pParse, p, &keyinfo);

    if( rc==SQLITE4_OK && pLower ){
      Expr *pExpr = pLower->pExpr->pRight;
      rc = valueFromExpr(pParse, &keyinfo, pExpr, aff, &buf);
      assert( pLower->eOperator==WO_GT || pLower->eOperator==WO_GE );
      if( rc==SQLITE4_OK && buf.n
       && whereKeyStats(pParse, p, &buf, 0, a)==SQLITE4_OK
      ){
        iLower = a[0];
        if( pLower->eOperator==WO_GT ) iLower += a[1];
      }
      sqlite4_buffer_set(&buf, 0, 0);
    }
    if( rc==SQLITE4_OK && pUpper ){
      Expr *pExpr = pUpper->pExpr->pRight;
      rc = valueFromExpr(pParse, &keyinfo, pExpr, aff, &buf);
      assert( pUpper->eOperator==WO_LT || pUpper->eOperator==WO_LE );
      if( rc==SQLITE4_OK && buf.n
       && whereKeyStats(pParse, p, &buf, 1, a)==SQLITE4_OK
      ){
        iUpper = a[0];
        if( pUpper->eOperator==WO_LE ) iUpper += a[1];
      }
    }
    sqlite4_buffer_clear(&buf);

set testdir [file dirname $argv0]
source $testdir/tester.tcl

ifcapable !stat3 {
  finish_test
  return
}


#----------------------------------------------------------------------
# Test Organization:
#
# analyze3-1.*: Test that the values of bound parameters are considered 
#               in the same way as constants when planning queries that
#               use range constraints.

db function var getvar

proc eqp {sql {db db}} {
  uplevel execsql [list "EXPLAIN QUERY PLAN $sql"] $db
}

proc sf_execsql {sql {db db}} {
  kvwrap reset
  set res [uplevel execsql [list $sql]]
  #puts "sql={$sql} seek=[kvwrap seek] step=[kvwrap step]"
  set count [expr [kvwrap step] + [kvwrap seek]]
  concat $count [$db status step] $res
}

# This proc calls sqlite4_step() on the statement passed as the only
# argument. It ignores the results of this call and immediately resets
# the statement. The return value is 1 if the authorization callback
# was invoked one or more times, or 0 otherwise. This is used to test
# that statements are recompiled as required.
#
proc test_for_recompile {stmt} {
  set ::auth_callbacks 0
  sqlite4_step $stmt
  sqlite4_reset $stmt
  return [expr $::auth_callbacks>0]
}
proc auth_callback {args} {
  incr ::auth_callbacks
  return SQLITE4_OK
}
db auth auth_callback

#-------------------------------------------------------------------------
#
# analyze3-1.1.1: 
#   Create a table with two columns. Populate the first column (affinity 
#   INTEGER) with integer values from 100 to 1100. Create an index on this 
#   column. ANALYZE the table.

#   literal values to constrain the range scan.
#
#   These tests also check that the compiler code considers column 
#   affinities when estimating the number of rows scanned by the "use 
#   index strategy".
#
do_test analyze3-1.1.1 {
  # The precise output of EXPLAIN QUERY PLAN are normally non-deterministic 
  # (as the estimated number of rows may vary slightly based on arbitrary 
  # decisions made while sampling the index for the sqlite_stat3 table).
  # Or, more accurately, the output depends on the built-in PRNG. So set
  # the PRNG to a known state before running ANALYZE in order to make
  # the results deterministic.
  #
  prng_state_set 0
  execsql {
    BEGIN;
    CREATE TABLE t1(x INTEGER, y);
    CREATE INDEX i1 ON t1(x);
  }
  for {set i 0} {$i < 1000} {incr i} {
    execsql { INSERT INTO t1 VALUES($i+100, $i) }
  }
  execsql COMMIT

  execsql ANALYZE

} {}

do_eqp_test analyze3-1.1.2 {
  SELECT sum(y) FROM t1 WHERE x>200 AND x<300
} {0 0 0 {SEARCH TABLE t1 USING INDEX i1 (x>? AND x<?) (~160 rows)}}
do_eqp_test analyze3-1.1.3 {
  SELECT sum(y) FROM t1 WHERE x>0 AND x<1100 
} {0 0 0 {SEARCH TABLE t1 USING INDEX i1 (x>? AND x<?) (~985 rows)}}

do_test analyze3-1.1.4 {
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>200 AND x<300 }
} {199 0 14850}
do_test analyze3-1.1.5 {
  set l [string range "200" 0 end]
  set u [string range "300" 0 end]
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>$l AND x<$u }
} {199 0 14850}
do_test analyze3-1.1.6 {
  set l [expr int(200)]
  set u [expr int(300)]
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>$l AND x<$u }
} {199 0 14850}
do_test analyze3-1.1.7 {
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>0 AND x<1100 }
} {2001 0 499500}
do_test analyze3-1.1.8 {
  set l [string range "0" 0 end]
  set u [string range "1100" 0 end]
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>$l AND x<$u }
} {2001 0 499500}
do_test analyze3-1.1.9 {
  set l [expr int(0)]
  set u [expr int(1100)]
  sf_execsql { SELECT sum(y) FROM t1 WHERE x>$l AND x<$u }
} {2001 0 499500}


# The following tests are similar to the block above. The difference is
# that the indexed column has TEXT affinity in this case. In the tests
# above the affinity is INTEGER.
#
do_test analyze3-1.2.1 {
  prng_state_set 0
  execsql {
    BEGIN;
      CREATE TABLE t2(x TEXT, y);
      INSERT INTO t2 SELECT * FROM t1;
      CREATE INDEX i2 ON t2(x);
    COMMIT;
    ANALYZE;
  }
} {}
do_eqp_test analyze3-1.2.2 {
  SELECT sum(y) FROM t2 WHERE x>1 AND x<2
} {0 0 0 {SEARCH TABLE t2 USING INDEX i2 (x>? AND x<?) (~193 rows)}}
do_eqp_test analyze3-1.2.3 {
  SELECT sum(y) FROM t2 WHERE x>0 AND x<99
} {0 0 0 {SEARCH TABLE t2 USING INDEX i2 (x>? AND x<?) (~972 rows)}}
do_test analyze3-1.2.4 {
  sf_execsql { SELECT sum(y) FROM t2 WHERE x>12 AND x<20 }
} {161 0 4760}
do_test analyze3-1.2.5 {
  set l [string range "12" 0 end]
  set u [string range "20" 0 end]
  sf_execsql {SELECT typeof($l), typeof($u), sum(y) FROM t2 WHERE x>$l AND x<$u}

} {1981 0 integer integer 490555}

# Same tests a third time. This time, column x has INTEGER affinity and
# is not the leftmost column of the table. This triggered a bug causing
# SQLite to use sub-optimal query plans in 3.6.18 and earlier.
#
do_test analyze3-1.3.1 {
  prng_state_set 0
  execsql {
    BEGIN;
      CREATE TABLE t3(y TEXT, x INTEGER);
      INSERT INTO t3 SELECT y, x FROM t1;
      CREATE INDEX i3 ON t3(x);
    COMMIT;
    ANALYZE;
  }
} {}
do_eqp_test analyze3-1.3.2 {
  SELECT sum(y) FROM t3 WHERE x>200 AND x<300
} {0 0 0 {SEARCH TABLE t3 USING INDEX i3 (x>? AND x<?) (~107 rows)}}
do_eqp_test analyze3-1.3.3 {
  SELECT sum(y) FROM t3 WHERE x>0 AND x<1100
} {0 0 0 {SEARCH TABLE t3 USING INDEX i3 (x>? AND x<?) (~972 rows)}}

do_test analyze3-1.3.4 {
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>200 AND x<300 }
} {199 0 14850}
do_test analyze3-1.3.5 {
  set l [string range "200" 0 end]
  set u [string range "300" 0 end]
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>$l AND x<$u }
} {199 0 14850}
do_test analyze3-1.3.6 {
  set l [expr int(200)]
  set u [expr int(300)]
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>$l AND x<$u }
} {199 0 14850}
do_test analyze3-1.3.7 {
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>0 AND x<1100 }
} {2001 0 499500}
do_test analyze3-1.3.8 {
  set l [string range "0" 0 end]
  set u [string range "1100" 0 end]
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>$l AND x<$u }
} {2001 0 499500}
do_test analyze3-1.3.9 {
  set l [expr int(0)]
  set u [expr int(1100)]
  sf_execsql { SELECT sum(y) FROM t3 WHERE x>$l AND x<$u }
} {2001 0 499500}

#-------------------------------------------------------------------------
# Test that the values of bound SQL variables may be used for the LIKE
# optimization.
#
drop_all_tables
do_test analyze3-2.1 {

} {0 0 0 {SEARCH TABLE t1 USING INDEX i1 (b>? AND b<?) (~31250 rows)}}
do_eqp_test analyze3-2.3 {
  SELECT count(a) FROM t1 WHERE b LIKE '%a'
} {0 0 0 {SCAN TABLE t1 (~500000 rows)}}

do_test analyze3-2.4 {
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE 'a%' }
} {201 0 100}
do_test analyze3-2.5 {
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE '%a' }
} {1001 999 100}

do_test analyze3-2.4 {
  set like "a%"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {201 0 100}
do_test analyze3-2.5 {
  set like "%a"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {1001 999 100}
do_test analyze3-2.6 {
  set like "a"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {201 0 0}
do_test analyze3-2.7 {
  set like "ab"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {21 0 0}
do_test analyze3-2.8 {
  set like "abc"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {3 0 1}
do_test analyze3-2.9 {
  set like "a_c"
  sf_execsql { SELECT count(*) FROM t1 WHERE b LIKE $like }
} {201 0 10}


#-------------------------------------------------------------------------
# This block of tests checks that statements are correctly marked as
# expired when the values bound to any parameters that may affect the 
# query plan are modified.
#
drop_all_tables
db auth auth_callback





do_test analyze3-3.1 {
  execsql {
    BEGIN;
    CREATE TABLE t1(a, b, c);
    CREATE INDEX i1 ON t1(b);
  }
  for {set i 0} {$i < 100} {incr i} {
    execsql { INSERT INTO t1 VALUES($i, $i, $i) }
  }
  execsql COMMIT
  execsql ANALYZE
} {}

do_test analyze3-3.2.1 {
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE b>?" -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.2.2 {
  sqlite4_bind_text $S 1 "abc" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.2.4 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.2.5 {
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE b=?" -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.2.6 {
  sqlite4_bind_text $S 1 "abc" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.2.7 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.4.1 {
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE a=? AND b>?" -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.4.2 {
  sqlite4_bind_text $S 1 "abc" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.4.3 {
  sqlite4_bind_text $S 2 "def" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.4.4 {
  sqlite4_bind_text $S 2 "ghi" 3


  test_for_recompile $S

} {1}
do_test analyze3-3.4.6 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.5.1 {
  set S [sqlite4_prepare db {
    SELECT * FROM t1 WHERE a IN (
      ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10,
      ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20,
      ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28, ?29, ?30, ?31
    ) AND b>?32;
  } -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.5.2 {
  sqlite4_bind_text $S 31 "abc" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.5.3 {
  sqlite4_bind_text $S 32 "def" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.5.5 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.6.1 {
  set S [sqlite4_prepare db {
    SELECT * FROM t1 WHERE a IN (
      ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10,
      ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20,
      ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28, ?29, ?30, ?31, ?32
    ) AND b>?33;
  } -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.6.2 {
  sqlite4_bind_text $S 32 "abc" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.6.3 {
  sqlite4_bind_text $S 33 "def" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.6.5 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.7.1 {
  set S [sqlite4_prepare db {
    SELECT * FROM t1 WHERE a IN (
      ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?33,
      ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20,
      ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28, ?29, ?30, ?31, ?32
    ) AND b>?10;
  } -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.7.2 {
  sqlite4_bind_text $S 32 "abc" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.7.3 {
  sqlite4_bind_text $S 33 "def" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.7.4 {
  sqlite4_bind_text $S 10 "def" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.7.6 {
  sqlite4_finalize $S
} {SQLITE4_OK}

do_test analyze3-3.8.1 {
  execsql {
    CREATE TABLE t4(x, y TEXT COLLATE NOCASE);
    CREATE INDEX i4 ON t4(y);
  }
} {}
do_test analyze3-3.8.2 {
  set S [sqlite4_prepare db {
    SELECT * FROM t4 WHERE x != ? AND y LIKE ?
  } -1 dummy]
  test_for_recompile $S
} {0}
do_test analyze3-3.8.3 {
  sqlite4_bind_text $S 1 "abc" 3
  test_for_recompile $S
} {0}
do_test analyze3-3.8.4 {
  sqlite4_bind_text $S 2 "def" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.8.7 {
  sqlite4_bind_text $S 2 "ghi%" 4
  test_for_recompile $S
} {1}
do_test analyze3-3.8.8 {
  test_for_recompile $S
} {0}
do_test analyze3-3.8.9 {
  sqlite4_bind_text $S 2 "ghi%def" 7
  test_for_recompile $S
} {1}
do_test analyze3-3.8.10 {
  test_for_recompile $S
} {0}
do_test analyze3-3.8.11 {
  sqlite4_bind_text $S 2 "%ab" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.8.12 {
  test_for_recompile $S
} {0}
do_test analyze3-3.8.12 {
  sqlite4_bind_text $S 2 "%de" 3
  test_for_recompile $S
} {1}
do_test analyze3-3.8.13 {
  test_for_recompile $S
} {0}
do_test analyze3-3.8.14 {
  sqlite4_finalize $S
} {SQLITE4_OK}

#-------------------------------------------------------------------------
# These tests check that errors encountered while repreparing an SQL
# statement within sqlite4Reprepare() are handled correctly.
#

# Check a schema error.
#
do_test analyze3-4.1.1 {
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE a=? AND b>?" -1 dummy]
  sqlite4_step $S
} {SQLITE4_DONE}
do_test analyze3-4.1.2 {
  sqlite4_reset $S
  sqlite4_bind_text $S 2 "abc" 3
  execsql { DROP TABLE t1 }
  sqlite4_step $S

    CREATE INDEX i1 ON t1(b);
  }
  for {set i 0} {$i < 100} {incr i} {
    execsql { INSERT INTO t1 VALUES($i, $i, $i) }
  }
  execsql COMMIT
  execsql ANALYZE
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE a=? AND b>?" -1 dummy]
  sqlite4_step $S
} {SQLITE4_DONE}
db auth auth
proc auth {args} {
  if {[lindex $args 0] == "SQLITE4_READ"} {return SQLITE4_DENY}
  return SQLITE4_OK
}

# Check the effect of an authorization error that occurs in a re-prepare
# performed by sqlite4_step() is the same as one that occurs within
# sqlite4Reprepare().
#
do_test analyze3-4.3.1 {
  db auth {}
  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE a=? AND b>?" -1 dummy]
  execsql { CREATE TABLE t2(d, e, f) }
  db auth auth
  sqlite4_step $S
} {SQLITE4_AUTH}
do_test analyze3-4.3.2 {
  sqlite4_finalize $S
} {SQLITE4_AUTH}
db auth {}

#-------------------------------------------------------------------------
# Test that modifying bound variables using the clear_bindings() works.




#
do_test analyze3-5.1.1 {
  drop_all_tables
  execsql {
    CREATE TABLE t1(x TEXT COLLATE NOCASE);
    CREATE INDEX i1 ON t1(x);
    INSERT INTO t1 VALUES('aaa');
    INSERT INTO t1 VALUES('abb');
    INSERT INTO t1 VALUES('acc');
    INSERT INTO t1 VALUES('baa');
    INSERT INTO t1 VALUES('bbb');
    INSERT INTO t1 VALUES('bcc');
  }

  set S [sqlite4_prepare db "SELECT * FROM t1 WHERE x LIKE ?" -1 dummy]
  sqlite4_bind_text $S 1 "a%" 2
  set R [list]
  while { "SQLITE4_ROW" == [sqlite4_step $S] } {
    lappend R [sqlite4_column_text $S 0]
  }
  concat [sqlite4_reset $S] $R
} {SQLITE4_OK aaa abb acc}
do_test analyze3-5.1.2 {
  sqlite4_clear_bindings $S
  set R [list]
  while { "SQLITE4_ROW" == [sqlite4_step $S] } {
    lappend R [sqlite4_column_text $S 0]
  }
  concat [sqlite4_reset $S] $R
} {SQLITE4_OK}
do_test analyze3-5.1.3 {
  sqlite4_finalize $S
} {SQLITE4_OK}


























finish_test

#-------------------------------------------------------------------------
# The point of this test is to add a large number of blocks to the 
# free-block list and check that this doesn't seem to cause any
# obvious problems.
#
do_test 3.0 {
  prng_state_set 11003242342353200
  db close
  forcedelete test.db
  sqlite4 db file:test.db?lsm_block_size=65536
  execsql { 
    CREATE TABLE t1(a PRIMARY KEY, b);
    CREATE INDEX i1 ON t1(b);
  }

  lsm1.test lsm2.test lsm3.test lsm4.test lsm5.test
  csr1.test
  ckpt1.test
  mc1.test
  fts5expr1.test fts5query1.test fts5rnd1.test fts5create.test
  fts5snippet.test

  analyze.test analyze3.test
  auth.test auth2.test auth3.test auth4.test
  aggerror.test
  attach.test
  autoindex1.test
  badutf.test
  between.test
  bigrow.test

  ** printExplainQueryPlan() immediately.
  */
  fflush(stdout);
  Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
  return TCL_OK;
}
#endif /* SQLITE4_OMIT_EXPLAIN */

static int test_prng_state_get(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  sqlite4_int64 iVal;
  if( objc!=0 ){
    Tcl_WrongNumArgs(interp, 1, objv, "");
    return TCL_ERROR;
  }
  sqlite4_test_control(SQLITE4_TESTCTRL_PRNG_SET, (sqlite4_env *)0, &iVal);
  Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal));
  return TCL_OK;
}

static int test_prng_state_set(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  sqlite4_int64 iVal;
  if( objc!=2 ){
    Tcl_WrongNumArgs(interp, 1, objv, "VALUE");
    return TCL_ERROR;
  }
  if( Tcl_GetWideIntFromObj(interp, objv[1], &iVal) ){
    return TCL_ERROR;
  }
  sqlite4_test_control(SQLITE4_TESTCTRL_PRNG_SET, (sqlite4_env *)0, iVal);
  return TCL_OK;
}

/*
** sqlite4_test_control VERB ARGS...
*/
static int test_test_control(
  void * clientData,
  Tcl_Interp *interp,

     { "tcl_variable_type",       tcl_variable_type, 0       },
     { "sqlite4_libversion_number", test_libversion_number, 0  },
     { "test_sqlite4_log",         test_sqlite4_log, 0  },
#ifndef SQLITE4_OMIT_EXPLAIN
     { "print_explain_query_plan", test_print_eqp, 0  },
#endif
     { "sqlite4_test_control", test_test_control },

     { "prng_state_get", test_prng_state_get },
     { "prng_state_set", test_prng_state_set },
  };
  static int bitmask_size = sizeof(Bitmask)*8;
  int i;
  extern int sqlite4_opentemp_count;
  extern int sqlite4_like_count;
  extern int sqlite4_xferopt_count;
  extern int sqlite4_pager_readdb_count;