/*** 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 "sqlite.h"#include <pthread.h>#include <sched.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>/*** 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);  usleep(100);  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(sqlite *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(sqlite *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;  sqlite *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, 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;}int main(int argc, 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;}