text: /*
  ** 2002 January 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 a simple standalone program used to test whether
  ** or not the SQLite library is threadsafe.
  **
  ** Testing the thread safety of SQLite is difficult because there are very
  ** few places in the code that are even potentially unsafe, and those
  ** places execute for very short periods of time.  So even if the library
  ** is compiled with its mutexes disabled, it is likely to work correctly
  ** in a multi-threaded program most of the time.
  **
  ** This file is NOT part of the standard SQLite library.  It is used for
  ** testing only.
  */
  #include "sqlite3.h"
  #include <pthread.h>
  #include <sched.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #if !defined(_WIN32) && !defined(_WIN64)
  #include <unistd.h>
  #else
  #include <io.h>
  #include <windows.h>
  #endif
  
  /*
  ** Enable for tracing
  */
  static int verbose = 0;
  
  /*
  ** Come here to die.
  */
  static void Exit(int rc){
    exit(rc);
  }
  
  extern char *sqlite3_mprintf(const char *zFormat, ...);
  extern char *sqlite3_vmprintf(const char *zFormat, va_list);
  
  /*
  ** When a lock occurs, yield.
  */
  static int db_is_locked(void *NotUsed, int iCount){
    /* sched_yield(); */
    if( verbose ) printf("BUSY %s #%d\n", (char*)NotUsed, iCount);
  #ifdef _WIN32
    Sleep(1); // 1ms = 1000 usec
  #else
    usleep(100);
  #endif
    return iCount<25;
  }
  
  /*
  ** Used to accumulate query results by db_query()
  */
  struct QueryResult {
    const char *zFile;  /* Filename - used for error reporting */
    int nElem;          /* Number of used entries in azElem[] */
    int nAlloc;         /* Number of slots allocated for azElem[] */
    char **azElem;      /* The result of the query */
  };
  
  /*
  ** The callback function for db_query
  */
  static int db_query_callback(
    void *pUser,     /* Pointer to the QueryResult structure */
    int nArg,        /* Number of columns in this result row */
    char **azArg,    /* Text of data in all columns */
    char **NotUsed   /* Names of the columns */
  ){
    struct QueryResult *pResult = (struct QueryResult*)pUser;
    int i;
    if( pResult->nElem + nArg >= pResult->nAlloc ){
      if( pResult->nAlloc==0 ){
        pResult->nAlloc = nArg+1;
      }else{
        pResult->nAlloc = pResult->nAlloc*2 + nArg + 1;
      }
      pResult->azElem = realloc( pResult->azElem, pResult->nAlloc*sizeof(char*));
      if( pResult->azElem==0 ){
        fprintf(stdout,"%s: malloc failed\n", pResult->zFile);
        return 1;
      }
    }
    if( azArg==0 ) return 0;
    for(i=0; i<nArg; i++){
      pResult->azElem[pResult->nElem++] =
          sqlite3_mprintf("%s",azArg[i] ? azArg[i] : "");
    }
    return 0;
  }
  
  /*
  ** Execute a query against the database.  NULL values are returned
  ** as an empty string.  The list is terminated by a single NULL pointer.
  */
  char **db_query(sqlite3 *db, const char *zFile, const char *zFormat, ...){
    char *zSql;
    int rc;
    char *zErrMsg = 0;
    va_list ap;
    struct QueryResult sResult;
    va_start(ap, zFormat);
    zSql = sqlite3_vmprintf(zFormat, ap);
    va_end(ap);
    memset(&sResult, 0, sizeof(sResult));
    sResult.zFile = zFile;
    if( verbose ) printf("QUERY %s: %s\n", zFile, zSql);
    rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);
    if( rc==SQLITE_SCHEMA ){
      if( zErrMsg ) free(zErrMsg);
      rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);
    }
    if( verbose ) printf("DONE %s %s\n", zFile, zSql);
    if( zErrMsg ){
      fprintf(stdout,"%s: query failed: %s - %s\n", zFile, zSql, zErrMsg);
      free(zErrMsg);
      free(zSql);
      Exit(1);
    }
    sqlite3_free(zSql);
    if( sResult.azElem==0 ){
      db_query_callback(&sResult, 0, 0, 0);
    }
    sResult.azElem[sResult.nElem] = 0;
    return sResult.azElem;
  }
  
  /*
  ** Execute an SQL statement.
  */
  void db_execute(sqlite3 *db, const char *zFile, const char *zFormat, ...){
    char *zSql;
    int rc;
    char *zErrMsg = 0;
    va_list ap;
    va_start(ap, zFormat);
    zSql = sqlite3_vmprintf(zFormat, ap);
    va_end(ap);
    if( verbose ) printf("EXEC %s: %s\n", zFile, zSql);
    do{
      rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg);
    }while( rc==SQLITE_BUSY );
    if( verbose ) printf("DONE %s: %s\n", zFile, zSql);
    if( zErrMsg ){
      fprintf(stdout,"%s: command failed: %s - %s\n", zFile, zSql, zErrMsg);
      free(zErrMsg);
      sqlite3_free(zSql);
      Exit(1);
    }
    sqlite3_free(zSql);
  }
  
  /*
  ** Free the results of a db_query() call.
  */
  void db_query_free(char **az){
    int i;
    for(i=0; az[i]; i++){
      sqlite3_free(az[i]);
    }
    free(az);
  }
  
  /*
  ** Check results
  */
  void db_check(const char *zFile, const char *zMsg, char **az, ...){
    va_list ap;
    int i;
    char *z;
    va_start(ap, az);
    for(i=0; (z = va_arg(ap, char*))!=0; i++){
      if( az[i]==0 || strcmp(az[i],z)!=0 ){
        fprintf(stdout,"%s: %s: bad result in column %d: %s\n",
          zFile, zMsg, i+1, az[i]);
        db_query_free(az);
        Exit(1);
      }
    }
    va_end(ap);
    db_query_free(az);
  }
  
  pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
  pthread_cond_t sig = PTHREAD_COND_INITIALIZER;
  int thread_cnt = 0;
  
  static void *worker_bee(void *pArg){
    const char *zFilename = (char*)pArg;
    char *azErr;
    int i, cnt;
    int t = atoi(zFilename);
    char **az;
    sqlite3 *db;
  
    pthread_mutex_lock(&lock);
    thread_cnt++;
    pthread_mutex_unlock(&lock);
    printf("%s: START\n", zFilename);
    fflush(stdout);
    for(cnt=0; cnt<10; cnt++){
      sqlite3_open(&zFilename[2], &db);
      if( db==0 ){
        fprintf(stdout,"%s: can't open\n", zFilename);
        Exit(1);
      }
      sqlite3_busy_handler(db, db_is_locked, (void*)zFilename);
      db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);
      for(i=1; i<=100; i++){
        db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",
           t, i, i*2, i*i);
      }
      az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);
      db_check(zFilename, "tX size", az, "100", 0);
      az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
      db_check(zFilename, "tX avg", az, "101", 0);
      db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);
      az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
      db_check(zFilename, "tX avg2", az, "51", 0);
      for(i=1; i<=50; i++){
        char z1[30], z2[30];
        az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);
        sprintf(z1, "%d", i*2);
        sprintf(z2, "%d", i*i);
        db_check(zFilename, "readback", az, z1, z2, 0);
      }
      db_execute(db, zFilename, "DROP TABLE t%d;", t);
      sqlite3_close(db);
    }
    printf("%s: END\n", zFilename);
    /* unlink(zFilename); */
    fflush(stdout);
    pthread_mutex_lock(&lock);
    thread_cnt--;
    if( thread_cnt<=0 ){
      pthread_cond_signal(&sig);
    }
    pthread_mutex_unlock(&lock);
    return 0;
  }
  
  
  #if defined(BUILD_MONOLITHIC)
  #define main(cnt, arr)      sqlite_threadtest1_main(cnt, arr)
  #endif
  
  int main(int argc, const char** argv){
    char *zFile;
    int i, n;
    pthread_t id;
    if( argc>2 && strcmp(argv[1], "-v")==0 ){
      verbose = 1;
      argc--;
      argv++;
    }
    if( argc<2 || (n=atoi(argv[1]))<1 ) n = 10;
    for(i=0; i<n; i++){
      char zBuf[200];
      sprintf(zBuf, "testdb-%d", (i+1)/2);
      unlink(zBuf);
    }
    for(i=0; i<n; i++){
      zFile = sqlite3_mprintf("%d.testdb-%d", i%2+1, (i+2)/2);
      if( (i%2)==0 ){
        /* Remove both the database file and any old journal for the file
        ** being used by this thread and the next one. */
        char *zDb = &zFile[2];
        char *zJournal = sqlite3_mprintf("%s-journal", zDb);
        unlink(zDb);
        unlink(zJournal);
        free(zJournal);
      }
  
      pthread_create(&id, 0, worker_bee, (void*)zFile);
      pthread_detach(id);
    }
    pthread_mutex_lock(&lock);
    while( thread_cnt>0 ){
      pthread_cond_wait(&sig, &lock);
    }
    pthread_mutex_unlock(&lock);
    for(i=0; i<n; i++){
      char zBuf[200];
      sprintf(zBuf, "testdb-%d", (i+1)/2);
      unlink(zBuf);
    }
    return 0;
  }
  