Annotation of embedaddon/sqlite3/test/threadtest1.c, revision 1.1
1.1 ! misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to threadtest1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test