1 /*

     2 ** 2002 January 15

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 ** This file implements a simple standalone program used to test whether

    13 ** or not the SQLite library is threadsafe.

    14 **

    15 ** Testing the thread safety of SQLite is difficult because there are very

    16 ** few places in the code that are even potentially unsafe, and those

    17 ** places execute for very short periods of time.  So even if the library

    18 ** is compiled with its mutexes disabled, it is likely to work correctly

    19 ** in a multi-threaded program most of the time.  

    20 **

    21 ** This file is NOT part of the standard SQLite library.  It is used for

    22 ** testing only.

    23 */

    24 #include "sqlite.h"

    25 #include <pthread.h>

    26 #include <sched.h>

    27 #include <stdio.h>

    28 #include <stdlib.h>

    29 #include <string.h>

    30 #include <unistd.h>

    31 

    32 /*

    33 ** Enable for tracing

    34 */

    35 static int verbose = 0;

    36 

    37 /*

    38 ** Come here to die.

    39 */

    40 static void Exit(int rc){

    41   exit(rc);

    42 }

    43 

    44 extern char *sqlite3_mprintf(const char *zFormat, ...);

    45 extern char *sqlite3_vmprintf(const char *zFormat, va_list);

    46 

    47 /*

    48 ** When a lock occurs, yield.

    49 */

    50 static int db_is_locked(void *NotUsed, int iCount){

    51   /* sched_yield(); */

    52   if( verbose ) printf("BUSY %s #%d\n", (char*)NotUsed, iCount);

    53   usleep(100);

    54   return iCount<25;

    55 }

    56 

    57 /*

    58 ** Used to accumulate query results by db_query()

    59 */

    60 struct QueryResult {

    61   const char *zFile;  /* Filename - used for error reporting */

    62   int nElem;          /* Number of used entries in azElem[] */

    63   int nAlloc;         /* Number of slots allocated for azElem[] */

    64   char **azElem;      /* The result of the query */

    65 };

    66 

    67 /*

    68 ** The callback function for db_query

    69 */

    70 static int db_query_callback(

    71   void *pUser,     /* Pointer to the QueryResult structure */

    72   int nArg,        /* Number of columns in this result row */

    73   char **azArg,    /* Text of data in all columns */

    74   char **NotUsed   /* Names of the columns */

    75 ){

    76   struct QueryResult *pResult = (struct QueryResult*)pUser;

    77   int i;

    78   if( pResult->nElem + nArg >= pResult->nAlloc ){

    79     if( pResult->nAlloc==0 ){

    80       pResult->nAlloc = nArg+1;

    81     }else{

    82       pResult->nAlloc = pResult->nAlloc*2 + nArg + 1;

    83     }

    84     pResult->azElem = realloc( pResult->azElem, pResult->nAlloc*sizeof(char*));

    85     if( pResult->azElem==0 ){

    86       fprintf(stdout,"%s: malloc failed\n", pResult->zFile);

    87       return 1;

    88     }

    89   }

    90   if( azArg==0 ) return 0;

    91   for(i=0; i<nArg; i++){

    92     pResult->azElem[pResult->nElem++] =

    93         sqlite3_mprintf("%s",azArg[i] ? azArg[i] : ""); 

    94   }

    95   return 0;

    96 }

    97 

    98 /*

    99 ** Execute a query against the database.  NULL values are returned

   100 ** as an empty string.  The list is terminated by a single NULL pointer.

   101 */

   102 char **db_query(sqlite *db, const char *zFile, const char *zFormat, ...){

   103   char *zSql;

   104   int rc;

   105   char *zErrMsg = 0;

   106   va_list ap;

   107   struct QueryResult sResult;

   108   va_start(ap, zFormat);

   109   zSql = sqlite3_vmprintf(zFormat, ap);

   110   va_end(ap);

   111   memset(&sResult, 0, sizeof(sResult));

   112   sResult.zFile = zFile;

   113   if( verbose ) printf("QUERY %s: %s\n", zFile, zSql);

   114   rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);

   115   if( rc==SQLITE_SCHEMA ){

   116     if( zErrMsg ) free(zErrMsg);

   117     rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);

   118   }

   119   if( verbose ) printf("DONE %s %s\n", zFile, zSql);

   120   if( zErrMsg ){

   121     fprintf(stdout,"%s: query failed: %s - %s\n", zFile, zSql, zErrMsg);

   122     free(zErrMsg);

   123     free(zSql);

   124     Exit(1);

   125   }

   126   sqlite3_free(zSql);

   127   if( sResult.azElem==0 ){

   128     db_query_callback(&sResult, 0, 0, 0);

   129   }

   130   sResult.azElem[sResult.nElem] = 0;

   131   return sResult.azElem;

   132 }

   133 

   134 /*

   135 ** Execute an SQL statement.

   136 */

   137 void db_execute(sqlite *db, const char *zFile, const char *zFormat, ...){

   138   char *zSql;

   139   int rc;

   140   char *zErrMsg = 0;

   141   va_list ap;

   142   va_start(ap, zFormat);

   143   zSql = sqlite3_vmprintf(zFormat, ap);

   144   va_end(ap);

   145   if( verbose ) printf("EXEC %s: %s\n", zFile, zSql);

   146   do{

   147     rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg);

   148   }while( rc==SQLITE_BUSY );

   149   if( verbose ) printf("DONE %s: %s\n", zFile, zSql);

   150   if( zErrMsg ){

   151     fprintf(stdout,"%s: command failed: %s - %s\n", zFile, zSql, zErrMsg);

   152     free(zErrMsg);

   153     sqlite3_free(zSql);

   154     Exit(1);

   155   }

   156   sqlite3_free(zSql);

   157 }

   158 

   159 /*

   160 ** Free the results of a db_query() call.

   161 */

   162 void db_query_free(char **az){

   163   int i;

   164   for(i=0; az[i]; i++){

   165     sqlite3_free(az[i]);

   166   }

   167   free(az);

   168 }

   169 

   170 /*

   171 ** Check results

   172 */

   173 void db_check(const char *zFile, const char *zMsg, char **az, ...){

   174   va_list ap;

   175   int i;

   176   char *z;

   177   va_start(ap, az);

   178   for(i=0; (z = va_arg(ap, char*))!=0; i++){

   179     if( az[i]==0 || strcmp(az[i],z)!=0 ){

   180       fprintf(stdout,"%s: %s: bad result in column %d: %s\n",

   181         zFile, zMsg, i+1, az[i]);

   182       db_query_free(az);

   183       Exit(1);

   184     }

   185   }

   186   va_end(ap);

   187   db_query_free(az);

   188 }

   189 

   190 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

   191 pthread_cond_t sig = PTHREAD_COND_INITIALIZER;

   192 int thread_cnt = 0;

   193 

   194 static void *worker_bee(void *pArg){

   195   const char *zFilename = (char*)pArg;

   196   char *azErr;

   197   int i, cnt;

   198   int t = atoi(zFilename);

   199   char **az;

   200   sqlite *db;

   201 

   202   pthread_mutex_lock(&lock);

   203   thread_cnt++;

   204   pthread_mutex_unlock(&lock);

   205   printf("%s: START\n", zFilename);

   206   fflush(stdout);

   207   for(cnt=0; cnt<10; cnt++){

   208     sqlite3_open(&zFilename[2], &db);

   209     if( db==0 ){

   210       fprintf(stdout,"%s: can't open\n", zFilename);

   211       Exit(1);

   212     }

   213     sqlite3_busy_handler(db, db_is_locked, zFilename);

   214     db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);

   215     for(i=1; i<=100; i++){

   216       db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",

   217          t, i, i*2, i*i);

   218     }

   219     az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);

   220     db_check(zFilename, "tX size", az, "100", 0);  

   221     az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);

   222     db_check(zFilename, "tX avg", az, "101", 0);  

   223     db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);

   224     az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);

   225     db_check(zFilename, "tX avg2", az, "51", 0);

   226     for(i=1; i<=50; i++){

   227       char z1[30], z2[30];

   228       az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);

   229       sprintf(z1, "%d", i*2);

   230       sprintf(z2, "%d", i*i);

   231       db_check(zFilename, "readback", az, z1, z2, 0);

   232     }

   233     db_execute(db, zFilename, "DROP TABLE t%d;", t);

   234     sqlite3_close(db);

   235   }

   236   printf("%s: END\n", zFilename);

   237   /* unlink(zFilename); */

   238   fflush(stdout);

   239   pthread_mutex_lock(&lock);

   240   thread_cnt--;

   241   if( thread_cnt<=0 ){

   242     pthread_cond_signal(&sig);

   243   }

   244   pthread_mutex_unlock(&lock);

   245   return 0;

   246 }

   247 

   248 int main(int argc, char **argv){

   249   char *zFile;

   250   int i, n;

   251   pthread_t id;

   252   if( argc>2 && strcmp(argv[1], "-v")==0 ){

   253     verbose = 1;

   254     argc--;

   255     argv++;

   256   }

   257   if( argc<2 || (n=atoi(argv[1]))<1 ) n = 10;

   258   for(i=0; i<n; i++){

   259     char zBuf[200];

   260     sprintf(zBuf, "testdb-%d", (i+1)/2);

   261     unlink(zBuf);

   262   }

   263   for(i=0; i<n; i++){

   264     zFile = sqlite3_mprintf("%d.testdb-%d", i%2+1, (i+2)/2);

   265     if( (i%2)==0 ){

   266       /* Remove both the database file and any old journal for the file

   267       ** being used by this thread and the next one. */

   268       char *zDb = &zFile[2];

   269       char *zJournal = sqlite3_mprintf("%s-journal", zDb);

   270       unlink(zDb);

   271       unlink(zJournal);

   272       free(zJournal);

   273     }

   274       

   275     pthread_create(&id, 0, worker_bee, (void*)zFile);

   276     pthread_detach(id);

   277   }

   278   pthread_mutex_lock(&lock);

   279   while( thread_cnt>0 ){

   280     pthread_cond_wait(&sig, &lock);

   281   }

   282   pthread_mutex_unlock(&lock);

   283   for(i=0; i<n; i++){

   284     char zBuf[200];

   285     sprintf(zBuf, "testdb-%d", (i+1)/2);

   286     unlink(zBuf);

   287   }

   288   return 0;

   289 }