| OLD | NEW |
|---|
| (Empty) |
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3108030:
Move bundled copy of sqlite one level deeper to better separate it... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/