| 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 |
} |