SQLite

    }
  }

  Tcl_ResetResult(interp);
  return TCL_OK;
}

/*
**     sorter_test_sort4_helper DB SQL1 NSTEP SQL2
**
** Compile SQL statement $SQL1 and step it $NSTEP times. For each row, 
** check that the leftmost and rightmost columns returned are both integers,
** and that both contain the same value.
**
** Then execute statement $SQL2. Check that the statement returns the same
** set of integers in the same order as in the previous step (using $SQL1).
*/
static int sorter_test_sort4_helper(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  const char *zSql1;
  const char *zSql2;
  int nStep; 
  int iStep; 
  int iCksum1 = 0; 
  int iCksum2 = 0; 
  int rc;
  int iB;
  sqlite3 *db;
  sqlite3_stmt *pStmt;
  
  if( objc!=5 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB SQL1 NSTEP SQL2");
    return TCL_ERROR;
  }

  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
  zSql1 = Tcl_GetString(objv[2]);
  if( Tcl_GetIntFromObj(interp, objv[3], &nStep) ) return TCL_ERROR;
  zSql2 = Tcl_GetString(objv[4]);

  rc = sqlite3_prepare_v2(db, zSql1, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ) goto sql_error;

  iB = sqlite3_column_count(pStmt)-1;
  for(iStep=0; iStep<nStep && SQLITE_ROW==sqlite3_step(pStmt); iStep++){
    int a = sqlite3_column_int(pStmt, 0);
    if( a!=sqlite3_column_int(pStmt, iB) ){
      Tcl_AppendResult(interp, "data error: (a!=b)", 0);
      return TCL_ERROR;
    }

    iCksum1 += (iCksum1 << 3) + a;
  }
  rc = sqlite3_finalize(pStmt);
  if( rc!=SQLITE_OK ) goto sql_error;

  rc = sqlite3_prepare_v2(db, zSql2, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ) goto sql_error;
  for(iStep=0; SQLITE_ROW==sqlite3_step(pStmt); iStep++){
    int a = sqlite3_column_int(pStmt, 0);
    iCksum2 += (iCksum2 << 3) + a;
  }
  rc = sqlite3_finalize(pStmt);
  if( rc!=SQLITE_OK ) goto sql_error;

  if( iCksum1!=iCksum2 ){
    Tcl_AppendResult(interp, "checksum mismatch", 0);
    return TCL_ERROR;
  }

  return TCL_OK;
 sql_error:
  Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0);
  return TCL_ERROR;
}


/*
** Register commands with the TCL interpreter.
*/
int Sqlitetest1_Init(Tcl_Interp *interp){
  extern int sqlite3_search_count;
  extern int sqlite3_found_count;

#endif
     { "sqlite3_test_control", test_test_control },
#if SQLITE_OS_UNIX
     { "getrusage", test_getrusage },
#endif
     { "load_static_extension", tclLoadStaticExtensionCmd },
     { "sorter_test_fakeheap", sorter_test_fakeheap },
     { "sorter_test_sort4_helper", sorter_test_sort4_helper },
  };
  static int bitmask_size = sizeof(Bitmask)*8;
  int i;
  extern int sqlite3_sync_count, sqlite3_fullsync_count;
  extern int sqlite3_opentemp_count;
  extern int sqlite3_like_count;
  extern int sqlite3_xferopt_count;

  sqlite3_shutdown
  catch {sqlite3_config multithread}
  sqlite3_initialize
  autoinstall_test_functions
} -files {
  delete.test   delete2.test  insert.test  rollback.test  select1.test
  select2.test  trans.test    update.test  vacuum.test    types.test
  types2.test   types3.test   sort4.test
} -shutdown {
  catch {db close}
  sqlite3_shutdown
  catch {sqlite3_config serialized}
  sqlite3_initialize
  autoinstall_test_functions
}

# sorter.
#

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

# Configure the sorter to use 3 background threads.
catch { db close }
sqlite3_shutdown
sqlite3_config_worker_threads 3
sqlite3_initialize
reset_db

# Minimum number of seconds to run for. If the value is 0, each test
# is run exactly once. Otherwise, tests are repeated until the timeout
# expires.
set SORT4TIMEOUT 0
if {[permutation] == "multithread"} { set SORT4TIMEOUT 300 }

#--------------------------------------------------------------------
# Set up a table "t1" containing $nRow rows. Each row contains also
# contains blob fields that collectively contain at least $nPayload 
# bytes of content. The table schema is as follows:
#
#   CREATE TABLE t1(a INTEGER, <extra-columns>, b INTEGER);
#
# For each row, the values of columns "a" and "b" are set to the same
# pseudo-randomly selected integer. The "extra-columns", of which there
# are at most eight, are named c0, c1, c2 etc. Column c0 contains a 4
# byte string. Column c1 an 8 byte string. Field c2 16 bytes, and so on.
#
# This table is intended to be used for testing queries of the form: 
#
#   SELECT a, <cols>, b FROM t1 ORDER BY a;
#
# The test code checks that rows are returned in order, and that the 
# values of "a" and "b" are the same for each row (the idea being that
# if field "b" at the end of the sorter record has not been corrupted, 
# the rest of the record is probably Ok as well).
#
proc populate_table {nRow nPayload} {
  set nCol 0

  set n 0
  for {set nCol 0} {$n < $nPayload} {incr nCol} {
    incr n [expr (4 << $nCol)]

      execsql $insert
    }
  }
}

# Helper for [do_sorter_test]
#
proc sorter_test {nRow nRead nPayload} {

  set res [list]

  set nLoad [expr ($nRow > $nRead) ? $nRead : $nRow]

  set nPayload [expr (($nPayload+3)/4) * 4]
  set cols [list]
  foreach {mask col} { 
    0x04  c0 0x08  c1 0x10  c2 0x20  c3 
    0x40  c4 0x80  c5 0x100 c6 0x200 c7 
  } {
    if {$nPayload & $mask} { lappend cols $col }
  }

  # Create two SELECT statements. Statement $sql1 uses the sorter to sort
  # $nRow records of a bit over $nPayload bytes each read from the "t1"
  # table created by [populate_table] proc above. Rows are sorted in order
  # of the integer field in each "t1" record.



  #
  # The second SQL statement sorts the same set of rows as the first, but
  # uses a LIMIT clause, causing SQLite to use a temp table instead of the
  # sorter for sorting.
  #
  set sql1 "SELECT a, [join $cols ,], b FROM t1 WHERE rowid<=$nRow ORDER BY a"


  set sql2 "SELECT a FROM t1 WHERE rowid<=$nRow ORDER BY a LIMIT $nRead"


  # Pass the two SQL statements to a helper command written in C. This
  # command steps statement $sql1 $nRead times and compares the integer
  # values in the rows returned with the results of executing $sql2. If
  # the comparison fails (indicating some bug in the sorter), a Tcl
  # exception is thrown.
  #
  sorter_test_sort4_helper db $sql1 $nRead $sql2
  set {} {} 
}

# Usage:
#
#   do_sorter_test <testname> <args>...
#

      unset a(-cachesize)
      set optlist "[join [array names a] ,] or -cachesize"
      error "Unknown option $s, expected $optlist"
    }
    set a($s) $val
  }

  db eval "PRAGMA cache_size = $a(-cachesize)"

  do_test $tn [subst -nocommands {
    for {set i 0} {[set i] < $a(-repeats)} {incr i} {
      sorter_test $a(-rows) $a(-read) $a(-payload)
    }
  }] {}
}

proc clock_seconds {} {
  db one {SELECT strftime('%s')}
}

#-------------------------------------------------------------------------
# Begin tests here.

# Create a test database.
do_test 1 {
  execsql "PRAGMA page_size = 4096"
  populate_table 100000 500
} {}

set iTimeLimit [expr [clock_seconds] + $SORT4TIMEOUT]

for {set tn 2} {1} {incr tn} {
  do_sorter_test $tn.2 -repeats 10 -rows 1000   -read 100
  do_sorter_test $tn.3 -repeats 10 -rows 100000 -read 1000
  do_sorter_test $tn.4 -repeats 10 -rows 100000 -read 1000 -payload 500
  do_sorter_test $tn.5 -repeats 10 -rows 100000 -read 100000 -payload 8
  do_sorter_test $tn.6 -repeats 10 -rows 100000 -read 10 -payload 8

  set iNow [clock_seconds]
  if {$iNow>=$iTimeLimit} break
  do_test "$testprefix-([expr $iTimeLimit-$iNow] seconds remain)" {} {}
}

catch { db close }
sqlite3_shutdown
sqlite3_config_worker_threads 0
sqlite3_initialize
finish_test