Annotation of embedaddon/sqlite3/test/threadtest3.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: ** The code in this file runs a few multi-threaded test cases using the
! 4: ** SQLite library. It can be compiled to an executable on unix using the
! 5: ** following command:
! 6: **
! 7: ** gcc -O2 threadtest3.c sqlite3.c -ldl -lpthread -lm
! 8: **
! 9: ** Then run the compiled program. The exit status is non-zero if any tests
! 10: ** failed (hopefully there is also some output to stdout to clarify what went
! 11: ** wrong).
! 12: **
! 13: ** There are three parts to the code in this file, in the following order:
! 14: **
! 15: ** 1. Code for the SQL aggregate function md5sum() copied from
! 16: ** tclsqlite.c in the SQLite distribution. The names of all the
! 17: ** types and functions in this section begin with "MD5" or "md5".
! 18: **
! 19: ** 2. A set of utility functions that may be used to implement
! 20: ** multi-threaded test cases. These are all called by test code
! 21: ** via macros that help with error reporting. The macros are defined
! 22: ** immediately below this comment.
! 23: **
! 24: ** 3. The test code itself. And a main() routine to drive the test
! 25: ** code.
! 26: */
! 27:
! 28: /*************************************************************************
! 29: ** Start of test code/infrastructure interface macros.
! 30: **
! 31: ** The following macros constitute the interface between the test
! 32: ** programs and the test infrastructure. Test infrastructure code
! 33: ** does not itself use any of these macros. Test code should not
! 34: ** call any of the macroname_x() functions directly.
! 35: **
! 36: ** See the header comments above the corresponding macroname_x()
! 37: ** function for a description of each interface.
! 38: */
! 39:
! 40: /* Database functions */
! 41: #define opendb(w,x,y,z) (SEL(w), opendb_x(w,x,y,z))
! 42: #define closedb(y,z) (SEL(y), closedb_x(y,z))
! 43:
! 44: /* Functions to execute SQL */
! 45: #define sql_script(x,y,z) (SEL(x), sql_script_x(x,y,z))
! 46: #define integrity_check(x,y) (SEL(x), integrity_check_x(x,y))
! 47: #define execsql_i64(x,y,...) (SEL(x), execsql_i64_x(x,y,__VA_ARGS__))
! 48: #define execsql_text(x,y,z,...) (SEL(x), execsql_text_x(x,y,z,__VA_ARGS__))
! 49: #define execsql(x,y,...) (SEL(x), (void)execsql_i64_x(x,y,__VA_ARGS__))
! 50:
! 51: /* Thread functions */
! 52: #define launch_thread(w,x,y,z) (SEL(w), launch_thread_x(w,x,y,z))
! 53: #define join_all_threads(y,z) (SEL(y), join_all_threads_x(y,z))
! 54:
! 55: /* Timer functions */
! 56: #define setstoptime(y,z) (SEL(y), setstoptime_x(y,z))
! 57: #define timetostop(z) (SEL(z), timetostop_x(z))
! 58:
! 59: /* Report/clear errors. */
! 60: #define test_error(z, ...) test_error_x(z, sqlite3_mprintf(__VA_ARGS__))
! 61: #define clear_error(y,z) clear_error_x(y, z)
! 62:
! 63: /* File-system operations */
! 64: #define filesize(y,z) (SEL(y), filesize_x(y,z))
! 65: #define filecopy(x,y,z) (SEL(x), filecopy_x(x,y,z))
! 66:
! 67: /*
! 68: ** End of test code/infrastructure interface macros.
! 69: *************************************************************************/
! 70:
! 71:
! 72:
! 73:
! 74: #include <sqlite3.h>
! 75: #include <unistd.h>
! 76: #include <stdio.h>
! 77: #include <pthread.h>
! 78: #include <assert.h>
! 79: #include <sys/types.h>
! 80: #include <sys/stat.h>
! 81: #include <string.h>
! 82: #include <fcntl.h>
! 83: #include <errno.h>
! 84:
! 85: /*
! 86: * This code implements the MD5 message-digest algorithm.
! 87: * The algorithm is due to Ron Rivest. This code was
! 88: * written by Colin Plumb in 1993, no copyright is claimed.
! 89: * This code is in the public domain; do with it what you wish.
! 90: *
! 91: * Equivalent code is available from RSA Data Security, Inc.
! 92: * This code has been tested against that, and is equivalent,
! 93: * except that you don't need to include two pages of legalese
! 94: * with every copy.
! 95: *
! 96: * To compute the message digest of a chunk of bytes, declare an
! 97: * MD5Context structure, pass it to MD5Init, call MD5Update as
! 98: * needed on buffers full of bytes, and then call MD5Final, which
! 99: * will fill a supplied 16-byte array with the digest.
! 100: */
! 101:
! 102: /*
! 103: * If compiled on a machine that doesn't have a 32-bit integer,
! 104: * you just set "uint32" to the appropriate datatype for an
! 105: * unsigned 32-bit integer. For example:
! 106: *
! 107: * cc -Duint32='unsigned long' md5.c
! 108: *
! 109: */
! 110: #ifndef uint32
! 111: # define uint32 unsigned int
! 112: #endif
! 113:
! 114: struct MD5Context {
! 115: int isInit;
! 116: uint32 buf[4];
! 117: uint32 bits[2];
! 118: unsigned char in[64];
! 119: };
! 120: typedef struct MD5Context MD5Context;
! 121:
! 122: /*
! 123: * Note: this code is harmless on little-endian machines.
! 124: */
! 125: static void byteReverse (unsigned char *buf, unsigned longs){
! 126: uint32 t;
! 127: do {
! 128: t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
! 129: ((unsigned)buf[1]<<8 | buf[0]);
! 130: *(uint32 *)buf = t;
! 131: buf += 4;
! 132: } while (--longs);
! 133: }
! 134: /* The four core functions - F1 is optimized somewhat */
! 135:
! 136: /* #define F1(x, y, z) (x & y | ~x & z) */
! 137: #define F1(x, y, z) (z ^ (x & (y ^ z)))
! 138: #define F2(x, y, z) F1(z, x, y)
! 139: #define F3(x, y, z) (x ^ y ^ z)
! 140: #define F4(x, y, z) (y ^ (x | ~z))
! 141:
! 142: /* This is the central step in the MD5 algorithm. */
! 143: #define MD5STEP(f, w, x, y, z, data, s) \
! 144: ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
! 145:
! 146: /*
! 147: * The core of the MD5 algorithm, this alters an existing MD5 hash to
! 148: * reflect the addition of 16 longwords of new data. MD5Update blocks
! 149: * the data and converts bytes into longwords for this routine.
! 150: */
! 151: static void MD5Transform(uint32 buf[4], const uint32 in[16]){
! 152: register uint32 a, b, c, d;
! 153:
! 154: a = buf[0];
! 155: b = buf[1];
! 156: c = buf[2];
! 157: d = buf[3];
! 158:
! 159: MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
! 160: MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
! 161: MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
! 162: MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
! 163: MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
! 164: MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
! 165: MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
! 166: MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
! 167: MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
! 168: MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
! 169: MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
! 170: MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
! 171: MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
! 172: MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
! 173: MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
! 174: MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
! 175:
! 176: MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
! 177: MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
! 178: MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
! 179: MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
! 180: MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
! 181: MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
! 182: MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
! 183: MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
! 184: MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
! 185: MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
! 186: MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
! 187: MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
! 188: MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
! 189: MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
! 190: MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
! 191: MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
! 192:
! 193: MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
! 194: MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
! 195: MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
! 196: MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
! 197: MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
! 198: MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
! 199: MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
! 200: MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
! 201: MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
! 202: MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
! 203: MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
! 204: MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
! 205: MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
! 206: MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
! 207: MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
! 208: MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
! 209:
! 210: MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
! 211: MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
! 212: MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
! 213: MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
! 214: MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
! 215: MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
! 216: MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
! 217: MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
! 218: MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
! 219: MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
! 220: MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
! 221: MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
! 222: MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
! 223: MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
! 224: MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
! 225: MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
! 226:
! 227: buf[0] += a;
! 228: buf[1] += b;
! 229: buf[2] += c;
! 230: buf[3] += d;
! 231: }
! 232:
! 233: /*
! 234: * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
! 235: * initialization constants.
! 236: */
! 237: static void MD5Init(MD5Context *ctx){
! 238: ctx->isInit = 1;
! 239: ctx->buf[0] = 0x67452301;
! 240: ctx->buf[1] = 0xefcdab89;
! 241: ctx->buf[2] = 0x98badcfe;
! 242: ctx->buf[3] = 0x10325476;
! 243: ctx->bits[0] = 0;
! 244: ctx->bits[1] = 0;
! 245: }
! 246:
! 247: /*
! 248: * Update context to reflect the concatenation of another buffer full
! 249: * of bytes.
! 250: */
! 251: static
! 252: void MD5Update(MD5Context *ctx, const unsigned char *buf, unsigned int len){
! 253: uint32 t;
! 254:
! 255: /* Update bitcount */
! 256:
! 257: t = ctx->bits[0];
! 258: if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
! 259: ctx->bits[1]++; /* Carry from low to high */
! 260: ctx->bits[1] += len >> 29;
! 261:
! 262: t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
! 263:
! 264: /* Handle any leading odd-sized chunks */
! 265:
! 266: if ( t ) {
! 267: unsigned char *p = (unsigned char *)ctx->in + t;
! 268:
! 269: t = 64-t;
! 270: if (len < t) {
! 271: memcpy(p, buf, len);
! 272: return;
! 273: }
! 274: memcpy(p, buf, t);
! 275: byteReverse(ctx->in, 16);
! 276: MD5Transform(ctx->buf, (uint32 *)ctx->in);
! 277: buf += t;
! 278: len -= t;
! 279: }
! 280:
! 281: /* Process data in 64-byte chunks */
! 282:
! 283: while (len >= 64) {
! 284: memcpy(ctx->in, buf, 64);
! 285: byteReverse(ctx->in, 16);
! 286: MD5Transform(ctx->buf, (uint32 *)ctx->in);
! 287: buf += 64;
! 288: len -= 64;
! 289: }
! 290:
! 291: /* Handle any remaining bytes of data. */
! 292:
! 293: memcpy(ctx->in, buf, len);
! 294: }
! 295:
! 296: /*
! 297: * Final wrapup - pad to 64-byte boundary with the bit pattern
! 298: * 1 0* (64-bit count of bits processed, MSB-first)
! 299: */
! 300: static void MD5Final(unsigned char digest[16], MD5Context *ctx){
! 301: unsigned count;
! 302: unsigned char *p;
! 303:
! 304: /* Compute number of bytes mod 64 */
! 305: count = (ctx->bits[0] >> 3) & 0x3F;
! 306:
! 307: /* Set the first char of padding to 0x80. This is safe since there is
! 308: always at least one byte free */
! 309: p = ctx->in + count;
! 310: *p++ = 0x80;
! 311:
! 312: /* Bytes of padding needed to make 64 bytes */
! 313: count = 64 - 1 - count;
! 314:
! 315: /* Pad out to 56 mod 64 */
! 316: if (count < 8) {
! 317: /* Two lots of padding: Pad the first block to 64 bytes */
! 318: memset(p, 0, count);
! 319: byteReverse(ctx->in, 16);
! 320: MD5Transform(ctx->buf, (uint32 *)ctx->in);
! 321:
! 322: /* Now fill the next block with 56 bytes */
! 323: memset(ctx->in, 0, 56);
! 324: } else {
! 325: /* Pad block to 56 bytes */
! 326: memset(p, 0, count-8);
! 327: }
! 328: byteReverse(ctx->in, 14);
! 329:
! 330: /* Append length in bits and transform */
! 331: ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
! 332: ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
! 333:
! 334: MD5Transform(ctx->buf, (uint32 *)ctx->in);
! 335: byteReverse((unsigned char *)ctx->buf, 4);
! 336: memcpy(digest, ctx->buf, 16);
! 337: memset(ctx, 0, sizeof(ctx)); /* In case it is sensitive */
! 338: }
! 339:
! 340: /*
! 341: ** Convert a 128-bit MD5 digest into a 32-digit base-16 number.
! 342: */
! 343: static void MD5DigestToBase16(unsigned char *digest, char *zBuf){
! 344: static char const zEncode[] = "0123456789abcdef";
! 345: int i, j;
! 346:
! 347: for(j=i=0; i<16; i++){
! 348: int a = digest[i];
! 349: zBuf[j++] = zEncode[(a>>4)&0xf];
! 350: zBuf[j++] = zEncode[a & 0xf];
! 351: }
! 352: zBuf[j] = 0;
! 353: }
! 354:
! 355: /*
! 356: ** During testing, the special md5sum() aggregate function is available.
! 357: ** inside SQLite. The following routines implement that function.
! 358: */
! 359: static void md5step(sqlite3_context *context, int argc, sqlite3_value **argv){
! 360: MD5Context *p;
! 361: int i;
! 362: if( argc<1 ) return;
! 363: p = sqlite3_aggregate_context(context, sizeof(*p));
! 364: if( p==0 ) return;
! 365: if( !p->isInit ){
! 366: MD5Init(p);
! 367: }
! 368: for(i=0; i<argc; i++){
! 369: const char *zData = (char*)sqlite3_value_text(argv[i]);
! 370: if( zData ){
! 371: MD5Update(p, (unsigned char*)zData, strlen(zData));
! 372: }
! 373: }
! 374: }
! 375: static void md5finalize(sqlite3_context *context){
! 376: MD5Context *p;
! 377: unsigned char digest[16];
! 378: char zBuf[33];
! 379: p = sqlite3_aggregate_context(context, sizeof(*p));
! 380: MD5Final(digest,p);
! 381: MD5DigestToBase16(digest, zBuf);
! 382: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
! 383: }
! 384:
! 385: /*************************************************************************
! 386: ** End of copied md5sum() code.
! 387: */
! 388:
! 389: typedef sqlite3_int64 i64;
! 390:
! 391: typedef struct Error Error;
! 392: typedef struct Sqlite Sqlite;
! 393: typedef struct Statement Statement;
! 394:
! 395: typedef struct Threadset Threadset;
! 396: typedef struct Thread Thread;
! 397:
! 398: /* Total number of errors in this process so far. */
! 399: static int nGlobalErr = 0;
! 400:
! 401: /* Set to true to run in "process" instead of "thread" mode. */
! 402: static int bProcessMode = 0;
! 403:
! 404: struct Error {
! 405: int rc;
! 406: int iLine;
! 407: char *zErr;
! 408: };
! 409:
! 410: struct Sqlite {
! 411: sqlite3 *db; /* Database handle */
! 412: Statement *pCache; /* Linked list of cached statements */
! 413: int nText; /* Size of array at aText[] */
! 414: char **aText; /* Stored text results */
! 415: };
! 416:
! 417: struct Statement {
! 418: sqlite3_stmt *pStmt; /* Pre-compiled statement handle */
! 419: Statement *pNext; /* Next statement in linked-list */
! 420: };
! 421:
! 422: struct Thread {
! 423: int iTid; /* Thread number within test */
! 424: int iArg; /* Integer argument passed by caller */
! 425:
! 426: pthread_t tid; /* Thread id */
! 427: char *(*xProc)(int, int); /* Thread main proc */
! 428: Thread *pNext; /* Next in this list of threads */
! 429: };
! 430:
! 431: struct Threadset {
! 432: int iMaxTid; /* Largest iTid value allocated so far */
! 433: Thread *pThread; /* Linked list of threads */
! 434: };
! 435:
! 436: static void free_err(Error *p){
! 437: sqlite3_free(p->zErr);
! 438: p->zErr = 0;
! 439: p->rc = 0;
! 440: }
! 441:
! 442: static void print_err(Error *p){
! 443: if( p->rc!=SQLITE_OK ){
! 444: printf("Error: (%d) \"%s\" at line %d\n", p->rc, p->zErr, p->iLine);
! 445: nGlobalErr++;
! 446: }
! 447: }
! 448:
! 449: static void print_and_free_err(Error *p){
! 450: print_err(p);
! 451: free_err(p);
! 452: }
! 453:
! 454: static void system_error(Error *pErr, int iSys){
! 455: pErr->rc = iSys;
! 456: pErr->zErr = (char *)sqlite3_malloc(512);
! 457: strerror_r(iSys, pErr->zErr, 512);
! 458: pErr->zErr[511] = '\0';
! 459: }
! 460:
! 461: static void sqlite_error(
! 462: Error *pErr,
! 463: Sqlite *pDb,
! 464: const char *zFunc
! 465: ){
! 466: pErr->rc = sqlite3_errcode(pDb->db);
! 467: pErr->zErr = sqlite3_mprintf(
! 468: "sqlite3_%s() - %s (%d)", zFunc, sqlite3_errmsg(pDb->db),
! 469: sqlite3_extended_errcode(pDb->db)
! 470: );
! 471: }
! 472:
! 473: static void test_error_x(
! 474: Error *pErr,
! 475: char *zErr
! 476: ){
! 477: if( pErr->rc==SQLITE_OK ){
! 478: pErr->rc = 1;
! 479: pErr->zErr = zErr;
! 480: }else{
! 481: sqlite3_free(zErr);
! 482: }
! 483: }
! 484:
! 485: static void clear_error_x(
! 486: Error *pErr,
! 487: int rc
! 488: ){
! 489: if( pErr->rc==rc ){
! 490: pErr->rc = SQLITE_OK;
! 491: sqlite3_free(pErr->zErr);
! 492: pErr->zErr = 0;
! 493: }
! 494: }
! 495:
! 496: static int busyhandler(void *pArg, int n){
! 497: usleep(10*1000);
! 498: return 1;
! 499: }
! 500:
! 501: static void opendb_x(
! 502: Error *pErr, /* IN/OUT: Error code */
! 503: Sqlite *pDb, /* OUT: Database handle */
! 504: const char *zFile, /* Database file name */
! 505: int bDelete /* True to delete db file before opening */
! 506: ){
! 507: if( pErr->rc==SQLITE_OK ){
! 508: int rc;
! 509: if( bDelete ) unlink(zFile);
! 510: rc = sqlite3_open(zFile, &pDb->db);
! 511: if( rc ){
! 512: sqlite_error(pErr, pDb, "open");
! 513: sqlite3_close(pDb->db);
! 514: pDb->db = 0;
! 515: }else{
! 516: sqlite3_create_function(
! 517: pDb->db, "md5sum", -1, SQLITE_UTF8, 0, 0, md5step, md5finalize
! 518: );
! 519: sqlite3_busy_handler(pDb->db, busyhandler, 0);
! 520: sqlite3_exec(pDb->db, "PRAGMA synchronous=OFF", 0, 0, 0);
! 521: }
! 522: }
! 523: }
! 524:
! 525: static void closedb_x(
! 526: Error *pErr, /* IN/OUT: Error code */
! 527: Sqlite *pDb /* OUT: Database handle */
! 528: ){
! 529: int rc;
! 530: int i;
! 531: Statement *pIter;
! 532: Statement *pNext;
! 533: for(pIter=pDb->pCache; pIter; pIter=pNext){
! 534: pNext = pIter->pNext;
! 535: sqlite3_finalize(pIter->pStmt);
! 536: sqlite3_free(pIter);
! 537: }
! 538: for(i=0; i<pDb->nText; i++){
! 539: sqlite3_free(pDb->aText[i]);
! 540: }
! 541: sqlite3_free(pDb->aText);
! 542: rc = sqlite3_close(pDb->db);
! 543: if( rc && pErr->rc==SQLITE_OK ){
! 544: pErr->zErr = sqlite3_mprintf("%s", sqlite3_errmsg(pDb->db));
! 545: }
! 546: memset(pDb, 0, sizeof(Sqlite));
! 547: }
! 548:
! 549: static void sql_script_x(
! 550: Error *pErr, /* IN/OUT: Error code */
! 551: Sqlite *pDb, /* Database handle */
! 552: const char *zSql /* SQL script to execute */
! 553: ){
! 554: if( pErr->rc==SQLITE_OK ){
! 555: pErr->rc = sqlite3_exec(pDb->db, zSql, 0, 0, &pErr->zErr);
! 556: }
! 557: }
! 558:
! 559: static Statement *getSqlStatement(
! 560: Error *pErr, /* IN/OUT: Error code */
! 561: Sqlite *pDb, /* Database handle */
! 562: const char *zSql /* SQL statement */
! 563: ){
! 564: Statement *pRet;
! 565: int rc;
! 566:
! 567: for(pRet=pDb->pCache; pRet; pRet=pRet->pNext){
! 568: if( 0==strcmp(sqlite3_sql(pRet->pStmt), zSql) ){
! 569: return pRet;
! 570: }
! 571: }
! 572:
! 573: pRet = sqlite3_malloc(sizeof(Statement));
! 574: rc = sqlite3_prepare_v2(pDb->db, zSql, -1, &pRet->pStmt, 0);
! 575: if( rc!=SQLITE_OK ){
! 576: sqlite_error(pErr, pDb, "prepare_v2");
! 577: return 0;
! 578: }
! 579: assert( 0==strcmp(sqlite3_sql(pRet->pStmt), zSql) );
! 580:
! 581: pRet->pNext = pDb->pCache;
! 582: pDb->pCache = pRet;
! 583: return pRet;
! 584: }
! 585:
! 586: static sqlite3_stmt *getAndBindSqlStatement(
! 587: Error *pErr, /* IN/OUT: Error code */
! 588: Sqlite *pDb, /* Database handle */
! 589: va_list ap /* SQL followed by parameters */
! 590: ){
! 591: Statement *pStatement; /* The SQLite statement wrapper */
! 592: sqlite3_stmt *pStmt; /* The SQLite statement to return */
! 593: int i; /* Used to iterate through parameters */
! 594:
! 595: pStatement = getSqlStatement(pErr, pDb, va_arg(ap, const char *));
! 596: if( !pStatement ) return 0;
! 597: pStmt = pStatement->pStmt;
! 598: for(i=1; i<=sqlite3_bind_parameter_count(pStmt); i++){
! 599: const char *zName = sqlite3_bind_parameter_name(pStmt, i);
! 600: void * pArg = va_arg(ap, void*);
! 601:
! 602: switch( zName[1] ){
! 603: case 'i':
! 604: sqlite3_bind_int64(pStmt, i, *(i64 *)pArg);
! 605: break;
! 606:
! 607: default:
! 608: pErr->rc = 1;
! 609: pErr->zErr = sqlite3_mprintf("Cannot discern type: \"%s\"", zName);
! 610: pStmt = 0;
! 611: break;
! 612: }
! 613: }
! 614:
! 615: return pStmt;
! 616: }
! 617:
! 618: static i64 execsql_i64_x(
! 619: Error *pErr, /* IN/OUT: Error code */
! 620: Sqlite *pDb, /* Database handle */
! 621: ... /* SQL and pointers to parameter values */
! 622: ){
! 623: i64 iRet = 0;
! 624: if( pErr->rc==SQLITE_OK ){
! 625: sqlite3_stmt *pStmt; /* SQL statement to execute */
! 626: va_list ap; /* ... arguments */
! 627: int i; /* Used to iterate through parameters */
! 628: va_start(ap, pDb);
! 629: pStmt = getAndBindSqlStatement(pErr, pDb, ap);
! 630: if( pStmt ){
! 631: int rc;
! 632: int first = 1;
! 633: while( SQLITE_ROW==sqlite3_step(pStmt) ){
! 634: if( first && sqlite3_column_count(pStmt)>0 ){
! 635: iRet = sqlite3_column_int64(pStmt, 0);
! 636: }
! 637: first = 0;
! 638: }
! 639: if( SQLITE_OK!=sqlite3_reset(pStmt) ){
! 640: sqlite_error(pErr, pDb, "reset");
! 641: }
! 642: }
! 643: va_end(ap);
! 644: }
! 645: return iRet;
! 646: }
! 647:
! 648: static char * execsql_text_x(
! 649: Error *pErr, /* IN/OUT: Error code */
! 650: Sqlite *pDb, /* Database handle */
! 651: int iSlot, /* Db handle slot to store text in */
! 652: ... /* SQL and pointers to parameter values */
! 653: ){
! 654: char *zRet = 0;
! 655:
! 656: if( iSlot>=pDb->nText ){
! 657: int nByte = sizeof(char *)*(iSlot+1);
! 658: pDb->aText = (char **)sqlite3_realloc(pDb->aText, nByte);
! 659: memset(&pDb->aText[pDb->nText], 0, sizeof(char*)*(iSlot+1-pDb->nText));
! 660: pDb->nText = iSlot+1;
! 661: }
! 662:
! 663: if( pErr->rc==SQLITE_OK ){
! 664: sqlite3_stmt *pStmt; /* SQL statement to execute */
! 665: va_list ap; /* ... arguments */
! 666: int i; /* Used to iterate through parameters */
! 667: va_start(ap, iSlot);
! 668: pStmt = getAndBindSqlStatement(pErr, pDb, ap);
! 669: if( pStmt ){
! 670: int rc;
! 671: int first = 1;
! 672: while( SQLITE_ROW==sqlite3_step(pStmt) ){
! 673: if( first && sqlite3_column_count(pStmt)>0 ){
! 674: zRet = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
! 675: sqlite3_free(pDb->aText[iSlot]);
! 676: pDb->aText[iSlot] = zRet;
! 677: }
! 678: first = 0;
! 679: }
! 680: if( SQLITE_OK!=sqlite3_reset(pStmt) ){
! 681: sqlite_error(pErr, pDb, "reset");
! 682: }
! 683: }
! 684: va_end(ap);
! 685: }
! 686:
! 687: return zRet;
! 688: }
! 689:
! 690: static void integrity_check_x(
! 691: Error *pErr, /* IN/OUT: Error code */
! 692: Sqlite *pDb /* Database handle */
! 693: ){
! 694: if( pErr->rc==SQLITE_OK ){
! 695: Statement *pStatement; /* Statement to execute */
! 696: int rc; /* Return code */
! 697: char *zErr = 0; /* Integrity check error */
! 698:
! 699: pStatement = getSqlStatement(pErr, pDb, "PRAGMA integrity_check");
! 700: if( pStatement ){
! 701: sqlite3_stmt *pStmt = pStatement->pStmt;
! 702: while( SQLITE_ROW==sqlite3_step(pStmt) ){
! 703: const char *z = sqlite3_column_text(pStmt, 0);
! 704: if( strcmp(z, "ok") ){
! 705: if( zErr==0 ){
! 706: zErr = sqlite3_mprintf("%s", z);
! 707: }else{
! 708: zErr = sqlite3_mprintf("%z\n%s", zErr, z);
! 709: }
! 710: }
! 711: }
! 712: sqlite3_reset(pStmt);
! 713:
! 714: if( zErr ){
! 715: pErr->zErr = zErr;
! 716: pErr->rc = 1;
! 717: }
! 718: }
! 719: }
! 720: }
! 721:
! 722: static void *launch_thread_main(void *pArg){
! 723: Thread *p = (Thread *)pArg;
! 724: return (void *)p->xProc(p->iTid, p->iArg);
! 725: }
! 726:
! 727: static void launch_thread_x(
! 728: Error *pErr, /* IN/OUT: Error code */
! 729: Threadset *pThreads, /* Thread set */
! 730: char *(*xProc)(int, int), /* Proc to run */
! 731: int iArg /* Argument passed to thread proc */
! 732: ){
! 733: if( pErr->rc==SQLITE_OK ){
! 734: int iTid = ++pThreads->iMaxTid;
! 735: Thread *p;
! 736: int rc;
! 737:
! 738: p = (Thread *)sqlite3_malloc(sizeof(Thread));
! 739: memset(p, 0, sizeof(Thread));
! 740: p->iTid = iTid;
! 741: p->iArg = iArg;
! 742: p->xProc = xProc;
! 743:
! 744: rc = pthread_create(&p->tid, NULL, launch_thread_main, (void *)p);
! 745: if( rc!=0 ){
! 746: system_error(pErr, rc);
! 747: sqlite3_free(p);
! 748: }else{
! 749: p->pNext = pThreads->pThread;
! 750: pThreads->pThread = p;
! 751: }
! 752: }
! 753: }
! 754:
! 755: static void join_all_threads_x(
! 756: Error *pErr, /* IN/OUT: Error code */
! 757: Threadset *pThreads /* Thread set */
! 758: ){
! 759: Thread *p;
! 760: Thread *pNext;
! 761: for(p=pThreads->pThread; p; p=pNext){
! 762: void *ret;
! 763: pNext = p->pNext;
! 764: int rc;
! 765: rc = pthread_join(p->tid, &ret);
! 766: if( rc!=0 ){
! 767: if( pErr->rc==SQLITE_OK ) system_error(pErr, rc);
! 768: }else{
! 769: printf("Thread %d says: %s\n", p->iTid, (ret==0 ? "..." : (char *)ret));
! 770: }
! 771: sqlite3_free(p);
! 772: }
! 773: pThreads->pThread = 0;
! 774: }
! 775:
! 776: static i64 filesize_x(
! 777: Error *pErr,
! 778: const char *zFile
! 779: ){
! 780: i64 iRet = 0;
! 781: if( pErr->rc==SQLITE_OK ){
! 782: struct stat sStat;
! 783: if( stat(zFile, &sStat) ){
! 784: iRet = -1;
! 785: }else{
! 786: iRet = sStat.st_size;
! 787: }
! 788: }
! 789: return iRet;
! 790: }
! 791:
! 792: static void filecopy_x(
! 793: Error *pErr,
! 794: const char *zFrom,
! 795: const char *zTo
! 796: ){
! 797: if( pErr->rc==SQLITE_OK ){
! 798: i64 nByte = filesize_x(pErr, zFrom);
! 799: if( nByte<0 ){
! 800: test_error_x(pErr, sqlite3_mprintf("no such file: %s", zFrom));
! 801: }else{
! 802: i64 iOff;
! 803: char aBuf[1024];
! 804: int fd1;
! 805: int fd2;
! 806: unlink(zTo);
! 807:
! 808: fd1 = open(zFrom, O_RDONLY);
! 809: if( fd1<0 ){
! 810: system_error(pErr, errno);
! 811: return;
! 812: }
! 813: fd2 = open(zTo, O_RDWR|O_CREAT|O_EXCL, 0644);
! 814: if( fd2<0 ){
! 815: system_error(pErr, errno);
! 816: close(fd1);
! 817: return;
! 818: }
! 819:
! 820: iOff = 0;
! 821: while( iOff<nByte ){
! 822: int nCopy = sizeof(aBuf);
! 823: if( nCopy+iOff>nByte ){
! 824: nCopy = nByte - iOff;
! 825: }
! 826: if( nCopy!=read(fd1, aBuf, nCopy) ){
! 827: system_error(pErr, errno);
! 828: break;
! 829: }
! 830: if( nCopy!=write(fd2, aBuf, nCopy) ){
! 831: system_error(pErr, errno);
! 832: break;
! 833: }
! 834: iOff += nCopy;
! 835: }
! 836:
! 837: close(fd1);
! 838: close(fd2);
! 839: }
! 840: }
! 841: }
! 842:
! 843: /*
! 844: ** Used by setstoptime() and timetostop().
! 845: */
! 846: static double timelimit = 0.0;
! 847: static sqlite3_vfs *pTimelimitVfs = 0;
! 848:
! 849: static void setstoptime_x(
! 850: Error *pErr, /* IN/OUT: Error code */
! 851: int nMs /* Milliseconds until "stop time" */
! 852: ){
! 853: if( pErr->rc==SQLITE_OK ){
! 854: double t;
! 855: int rc;
! 856: pTimelimitVfs = sqlite3_vfs_find(0);
! 857: rc = pTimelimitVfs->xCurrentTime(pTimelimitVfs, &t);
! 858: if( rc!=SQLITE_OK ){
! 859: pErr->rc = rc;
! 860: }else{
! 861: timelimit = t + ((double)nMs)/(1000.0*60.0*60.0*24.0);
! 862: }
! 863: }
! 864: }
! 865:
! 866: static int timetostop_x(
! 867: Error *pErr /* IN/OUT: Error code */
! 868: ){
! 869: int ret = 1;
! 870: if( pErr->rc==SQLITE_OK ){
! 871: double t;
! 872: int rc;
! 873: rc = pTimelimitVfs->xCurrentTime(pTimelimitVfs, &t);
! 874: if( rc!=SQLITE_OK ){
! 875: pErr->rc = rc;
! 876: }else{
! 877: ret = (t >= timelimit);
! 878: }
! 879: }
! 880: return ret;
! 881: }
! 882:
! 883: /*
! 884: ** The "Set Error Line" macro.
! 885: */
! 886: #define SEL(e) ((e)->iLine = ((e)->rc ? (e)->iLine : __LINE__))
! 887:
! 888:
! 889: /*************************************************************************
! 890: **************************************************************************
! 891: **************************************************************************
! 892: ** End infrastructure. Begin tests.
! 893: */
! 894:
! 895: #define WALTHREAD1_NTHREAD 10
! 896: #define WALTHREAD3_NTHREAD 6
! 897:
! 898: static char *walthread1_thread(int iTid, int iArg){
! 899: Error err = {0}; /* Error code and message */
! 900: Sqlite db = {0}; /* SQLite database connection */
! 901: int nIter = 0; /* Iterations so far */
! 902:
! 903: opendb(&err, &db, "test.db", 0);
! 904: while( !timetostop(&err) ){
! 905: const char *azSql[] = {
! 906: "SELECT md5sum(x) FROM t1 WHERE rowid != (SELECT max(rowid) FROM t1)",
! 907: "SELECT x FROM t1 WHERE rowid = (SELECT max(rowid) FROM t1)",
! 908: };
! 909: char *z1, *z2, *z3;
! 910:
! 911: execsql(&err, &db, "BEGIN");
! 912: integrity_check(&err, &db);
! 913: z1 = execsql_text(&err, &db, 1, azSql[0]);
! 914: z2 = execsql_text(&err, &db, 2, azSql[1]);
! 915: z3 = execsql_text(&err, &db, 3, azSql[0]);
! 916: execsql(&err, &db, "COMMIT");
! 917:
! 918: if( strcmp(z1, z2) || strcmp(z1, z3) ){
! 919: test_error(&err, "Failed read: %s %s %s", z1, z2, z3);
! 920: }
! 921:
! 922: sql_script(&err, &db,
! 923: "BEGIN;"
! 924: "INSERT INTO t1 VALUES(randomblob(100));"
! 925: "INSERT INTO t1 VALUES(randomblob(100));"
! 926: "INSERT INTO t1 SELECT md5sum(x) FROM t1;"
! 927: "COMMIT;"
! 928: );
! 929: nIter++;
! 930: }
! 931: closedb(&err, &db);
! 932:
! 933: print_and_free_err(&err);
! 934: return sqlite3_mprintf("%d iterations", nIter);
! 935: }
! 936:
! 937: static char *walthread1_ckpt_thread(int iTid, int iArg){
! 938: Error err = {0}; /* Error code and message */
! 939: Sqlite db = {0}; /* SQLite database connection */
! 940: int nCkpt = 0; /* Checkpoints so far */
! 941:
! 942: opendb(&err, &db, "test.db", 0);
! 943: while( !timetostop(&err) ){
! 944: usleep(500*1000);
! 945: execsql(&err, &db, "PRAGMA wal_checkpoint");
! 946: if( err.rc==SQLITE_OK ) nCkpt++;
! 947: clear_error(&err, SQLITE_BUSY);
! 948: }
! 949: closedb(&err, &db);
! 950:
! 951: print_and_free_err(&err);
! 952: return sqlite3_mprintf("%d checkpoints", nCkpt);
! 953: }
! 954:
! 955: static void walthread1(int nMs){
! 956: Error err = {0}; /* Error code and message */
! 957: Sqlite db = {0}; /* SQLite database connection */
! 958: Threadset threads = {0}; /* Test threads */
! 959: int i; /* Iterator variable */
! 960:
! 961: opendb(&err, &db, "test.db", 1);
! 962: sql_script(&err, &db,
! 963: "PRAGMA journal_mode = WAL;"
! 964: "CREATE TABLE t1(x PRIMARY KEY);"
! 965: "INSERT INTO t1 VALUES(randomblob(100));"
! 966: "INSERT INTO t1 VALUES(randomblob(100));"
! 967: "INSERT INTO t1 SELECT md5sum(x) FROM t1;"
! 968: );
! 969:
! 970: setstoptime(&err, nMs);
! 971: for(i=0; i<WALTHREAD1_NTHREAD; i++){
! 972: launch_thread(&err, &threads, walthread1_thread, 0);
! 973: }
! 974: launch_thread(&err, &threads, walthread1_ckpt_thread, 0);
! 975: join_all_threads(&err, &threads);
! 976:
! 977: print_and_free_err(&err);
! 978: }
! 979:
! 980: static char *walthread2_thread(int iTid, int iArg){
! 981: Error err = {0}; /* Error code and message */
! 982: Sqlite db = {0}; /* SQLite database connection */
! 983: int anTrans[2] = {0, 0}; /* Number of WAL and Rollback transactions */
! 984:
! 985: const char *zJournal = "PRAGMA journal_mode = WAL";
! 986: if( iArg ){ zJournal = "PRAGMA journal_mode = DELETE"; }
! 987:
! 988: while( !timetostop(&err) ){
! 989: int journal_exists = 0;
! 990: int wal_exists = 0;
! 991:
! 992: opendb(&err, &db, "test.db", 0);
! 993:
! 994: sql_script(&err, &db, zJournal);
! 995: clear_error(&err, SQLITE_BUSY);
! 996: sql_script(&err, &db, "BEGIN");
! 997: sql_script(&err, &db, "INSERT INTO t1 VALUES(NULL, randomblob(100))");
! 998:
! 999: journal_exists = (filesize(&err, "test.db-journal") >= 0);
! 1000: wal_exists = (filesize(&err, "test.db-wal") >= 0);
! 1001: if( (journal_exists+wal_exists)!=1 ){
! 1002: test_error(&err, "File system looks incorrect (%d, %d)",
! 1003: journal_exists, wal_exists
! 1004: );
! 1005: }
! 1006: anTrans[journal_exists]++;
! 1007:
! 1008: sql_script(&err, &db, "COMMIT");
! 1009: integrity_check(&err, &db);
! 1010: closedb(&err, &db);
! 1011: }
! 1012:
! 1013: print_and_free_err(&err);
! 1014: return sqlite3_mprintf("W %d R %d", anTrans[0], anTrans[1]);
! 1015: }
! 1016:
! 1017: static void walthread2(int nMs){
! 1018: Error err = {0};
! 1019: Sqlite db = {0};
! 1020: Threadset threads = {0};
! 1021:
! 1022: opendb(&err, &db, "test.db", 1);
! 1023: sql_script(&err, &db, "CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE)");
! 1024: closedb(&err, &db);
! 1025:
! 1026: setstoptime(&err, nMs);
! 1027: launch_thread(&err, &threads, walthread2_thread, 0);
! 1028: launch_thread(&err, &threads, walthread2_thread, 0);
! 1029: launch_thread(&err, &threads, walthread2_thread, 1);
! 1030: launch_thread(&err, &threads, walthread2_thread, 1);
! 1031: join_all_threads(&err, &threads);
! 1032:
! 1033: print_and_free_err(&err);
! 1034: }
! 1035:
! 1036: static char *walthread3_thread(int iTid, int iArg){
! 1037: Error err = {0}; /* Error code and message */
! 1038: Sqlite db = {0}; /* SQLite database connection */
! 1039: i64 iNextWrite; /* Next value this thread will write */
! 1040:
! 1041: opendb(&err, &db, "test.db", 0);
! 1042: sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 10");
! 1043:
! 1044: iNextWrite = iArg+1;
! 1045: while( 1 ){
! 1046: i64 sum1;
! 1047: i64 sum2;
! 1048: int stop = 0; /* True to stop executing (test timed out) */
! 1049:
! 1050: while( 0==(stop = timetostop(&err)) ){
! 1051: i64 iMax = execsql_i64(&err, &db, "SELECT max(cnt) FROM t1");
! 1052: if( iMax+1==iNextWrite ) break;
! 1053: }
! 1054: if( stop ) break;
! 1055:
! 1056: sum1 = execsql_i64(&err, &db, "SELECT sum(cnt) FROM t1");
! 1057: sum2 = execsql_i64(&err, &db, "SELECT sum(sum1) FROM t1");
! 1058: execsql_i64(&err, &db,
! 1059: "INSERT INTO t1 VALUES(:iNextWrite, :iSum1, :iSum2)",
! 1060: &iNextWrite, &sum1, &sum2
! 1061: );
! 1062: integrity_check(&err, &db);
! 1063:
! 1064: iNextWrite += WALTHREAD3_NTHREAD;
! 1065: }
! 1066:
! 1067: closedb(&err, &db);
! 1068: print_and_free_err(&err);
! 1069: return 0;
! 1070: }
! 1071:
! 1072: static void walthread3(int nMs){
! 1073: Error err = {0};
! 1074: Sqlite db = {0};
! 1075: Threadset threads = {0};
! 1076: int i;
! 1077:
! 1078: opendb(&err, &db, "test.db", 1);
! 1079: sql_script(&err, &db,
! 1080: "PRAGMA journal_mode = WAL;"
! 1081: "CREATE TABLE t1(cnt PRIMARY KEY, sum1, sum2);"
! 1082: "CREATE INDEX i1 ON t1(sum1);"
! 1083: "CREATE INDEX i2 ON t1(sum2);"
! 1084: "INSERT INTO t1 VALUES(0, 0, 0);"
! 1085: );
! 1086: closedb(&err, &db);
! 1087:
! 1088: setstoptime(&err, nMs);
! 1089: for(i=0; i<WALTHREAD3_NTHREAD; i++){
! 1090: launch_thread(&err, &threads, walthread3_thread, i);
! 1091: }
! 1092: join_all_threads(&err, &threads);
! 1093:
! 1094: print_and_free_err(&err);
! 1095: }
! 1096:
! 1097: static char *walthread4_reader_thread(int iTid, int iArg){
! 1098: Error err = {0}; /* Error code and message */
! 1099: Sqlite db = {0}; /* SQLite database connection */
! 1100:
! 1101: opendb(&err, &db, "test.db", 0);
! 1102: while( !timetostop(&err) ){
! 1103: integrity_check(&err, &db);
! 1104: }
! 1105: closedb(&err, &db);
! 1106:
! 1107: print_and_free_err(&err);
! 1108: return 0;
! 1109: }
! 1110:
! 1111: static char *walthread4_writer_thread(int iTid, int iArg){
! 1112: Error err = {0}; /* Error code and message */
! 1113: Sqlite db = {0}; /* SQLite database connection */
! 1114: i64 iRow = 1;
! 1115:
! 1116: opendb(&err, &db, "test.db", 0);
! 1117: sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 15;");
! 1118: while( !timetostop(&err) ){
! 1119: execsql_i64(
! 1120: &err, &db, "REPLACE INTO t1 VALUES(:iRow, randomblob(300))", &iRow
! 1121: );
! 1122: iRow++;
! 1123: if( iRow==10 ) iRow = 0;
! 1124: }
! 1125: closedb(&err, &db);
! 1126:
! 1127: print_and_free_err(&err);
! 1128: return 0;
! 1129: }
! 1130:
! 1131: static void walthread4(int nMs){
! 1132: Error err = {0};
! 1133: Sqlite db = {0};
! 1134: Threadset threads = {0};
! 1135:
! 1136: opendb(&err, &db, "test.db", 1);
! 1137: sql_script(&err, &db,
! 1138: "PRAGMA journal_mode = WAL;"
! 1139: "CREATE TABLE t1(a INTEGER PRIMARY KEY, b UNIQUE);"
! 1140: );
! 1141: closedb(&err, &db);
! 1142:
! 1143: setstoptime(&err, nMs);
! 1144: launch_thread(&err, &threads, walthread4_reader_thread, 0);
! 1145: launch_thread(&err, &threads, walthread4_writer_thread, 0);
! 1146: join_all_threads(&err, &threads);
! 1147:
! 1148: print_and_free_err(&err);
! 1149: }
! 1150:
! 1151: static char *walthread5_thread(int iTid, int iArg){
! 1152: Error err = {0}; /* Error code and message */
! 1153: Sqlite db = {0}; /* SQLite database connection */
! 1154: i64 nRow;
! 1155:
! 1156: opendb(&err, &db, "test.db", 0);
! 1157: nRow = execsql_i64(&err, &db, "SELECT count(*) FROM t1");
! 1158: closedb(&err, &db);
! 1159:
! 1160: if( nRow!=65536 ) test_error(&err, "Bad row count: %d", (int)nRow);
! 1161: print_and_free_err(&err);
! 1162: return 0;
! 1163: }
! 1164: static void walthread5(int nMs){
! 1165: Error err = {0};
! 1166: Sqlite db = {0};
! 1167: Threadset threads = {0};
! 1168:
! 1169: opendb(&err, &db, "test.db", 1);
! 1170: sql_script(&err, &db,
! 1171: "PRAGMA wal_autocheckpoint = 0;"
! 1172: "PRAGMA page_size = 1024;"
! 1173: "PRAGMA journal_mode = WAL;"
! 1174: "CREATE TABLE t1(x);"
! 1175: "BEGIN;"
! 1176: "INSERT INTO t1 VALUES(randomblob(900));"
! 1177: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 2 */"
! 1178: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 4 */"
! 1179: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 8 */"
! 1180: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 16 */"
! 1181: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 32 */"
! 1182: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 64 */"
! 1183: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 128 */"
! 1184: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 256 */"
! 1185: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 512 */"
! 1186: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 1024 */"
! 1187: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 2048 */"
! 1188: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 4096 */"
! 1189: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 8192 */"
! 1190: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 16384 */"
! 1191: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 32768 */"
! 1192: "INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 65536 */"
! 1193: "COMMIT;"
! 1194: );
! 1195: filecopy(&err, "test.db", "test_sv.db");
! 1196: filecopy(&err, "test.db-wal", "test_sv.db-wal");
! 1197: closedb(&err, &db);
! 1198:
! 1199: filecopy(&err, "test_sv.db", "test.db");
! 1200: filecopy(&err, "test_sv.db-wal", "test.db-wal");
! 1201:
! 1202: if( err.rc==SQLITE_OK ){
! 1203: printf(" WAL file is %d bytes,", (int)filesize(&err,"test.db-wal"));
! 1204: printf(" DB file is %d.\n", (int)filesize(&err,"test.db"));
! 1205: }
! 1206:
! 1207: setstoptime(&err, nMs);
! 1208: launch_thread(&err, &threads, walthread5_thread, 0);
! 1209: launch_thread(&err, &threads, walthread5_thread, 0);
! 1210: launch_thread(&err, &threads, walthread5_thread, 0);
! 1211: launch_thread(&err, &threads, walthread5_thread, 0);
! 1212: launch_thread(&err, &threads, walthread5_thread, 0);
! 1213: join_all_threads(&err, &threads);
! 1214:
! 1215: if( err.rc==SQLITE_OK ){
! 1216: printf(" WAL file is %d bytes,", (int)filesize(&err,"test.db-wal"));
! 1217: printf(" DB file is %d.\n", (int)filesize(&err,"test.db"));
! 1218: }
! 1219:
! 1220: print_and_free_err(&err);
! 1221: }
! 1222:
! 1223: /*------------------------------------------------------------------------
! 1224: ** Test case "cgt_pager_1"
! 1225: */
! 1226: #define CALLGRINDTEST1_NROW 10000
! 1227: static void cgt_pager_1_populate(Error *pErr, Sqlite *pDb){
! 1228: const char *zInsert = "INSERT INTO t1 VALUES(:iRow, zeroblob(:iBlob))";
! 1229: i64 iRow;
! 1230: sql_script(pErr, pDb, "BEGIN");
! 1231: for(iRow=1; iRow<=CALLGRINDTEST1_NROW; iRow++){
! 1232: i64 iBlob = 600 + (iRow%300);
! 1233: execsql(pErr, pDb, zInsert, &iRow, &iBlob);
! 1234: }
! 1235: sql_script(pErr, pDb, "COMMIT");
! 1236: }
! 1237: static void cgt_pager_1_update(Error *pErr, Sqlite *pDb){
! 1238: const char *zUpdate = "UPDATE t1 SET b = zeroblob(:iBlob) WHERE a = :iRow";
! 1239: i64 iRow;
! 1240: sql_script(pErr, pDb, "BEGIN");
! 1241: for(iRow=1; iRow<=CALLGRINDTEST1_NROW; iRow++){
! 1242: i64 iBlob = 600 + ((iRow+100)%300);
! 1243: execsql(pErr, pDb, zUpdate, &iBlob, &iRow);
! 1244: }
! 1245: sql_script(pErr, pDb, "COMMIT");
! 1246: }
! 1247: static void cgt_pager_1_read(Error *pErr, Sqlite *pDb){
! 1248: i64 iRow;
! 1249: sql_script(pErr, pDb, "BEGIN");
! 1250: for(iRow=1; iRow<=CALLGRINDTEST1_NROW; iRow++){
! 1251: execsql(pErr, pDb, "SELECT * FROM t1 WHERE a = :iRow", &iRow);
! 1252: }
! 1253: sql_script(pErr, pDb, "COMMIT");
! 1254: }
! 1255: static void cgt_pager_1(int nMs){
! 1256: void (*xSub)(Error *, Sqlite *);
! 1257: Error err = {0};
! 1258: Sqlite db = {0};
! 1259:
! 1260: opendb(&err, &db, "test.db", 1);
! 1261: sql_script(&err, &db,
! 1262: "PRAGMA cache_size = 2000;"
! 1263: "PRAGMA page_size = 1024;"
! 1264: "CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB);"
! 1265: );
! 1266:
! 1267: xSub = cgt_pager_1_populate; xSub(&err, &db);
! 1268: xSub = cgt_pager_1_update; xSub(&err, &db);
! 1269: xSub = cgt_pager_1_read; xSub(&err, &db);
! 1270:
! 1271: closedb(&err, &db);
! 1272: print_and_free_err(&err);
! 1273: }
! 1274:
! 1275: /*------------------------------------------------------------------------
! 1276: ** Test case "dynamic_triggers"
! 1277: **
! 1278: ** Two threads executing statements that cause deeply nested triggers
! 1279: ** to fire. And one thread busily creating and deleting triggers. This
! 1280: ** is an attempt to find a bug reported to us.
! 1281: */
! 1282:
! 1283: static char *dynamic_triggers_1(int iTid, int iArg){
! 1284: Error err = {0}; /* Error code and message */
! 1285: Sqlite db = {0}; /* SQLite database connection */
! 1286: int nDrop = 0;
! 1287: int nCreate = 0;
! 1288:
! 1289: opendb(&err, &db, "test.db", 0);
! 1290: while( !timetostop(&err) ){
! 1291: int i;
! 1292:
! 1293: for(i=1; i<9; i++){
! 1294: char *zSql = sqlite3_mprintf(
! 1295: "CREATE TRIGGER itr%d BEFORE INSERT ON t%d BEGIN "
! 1296: "INSERT INTO t%d VALUES(new.x, new.y);"
! 1297: "END;", i, i, i+1
! 1298: );
! 1299: execsql(&err, &db, zSql);
! 1300: sqlite3_free(zSql);
! 1301: nCreate++;
! 1302: }
! 1303:
! 1304: for(i=1; i<9; i++){
! 1305: char *zSql = sqlite3_mprintf(
! 1306: "CREATE TRIGGER dtr%d BEFORE DELETE ON t%d BEGIN "
! 1307: "DELETE FROM t%d WHERE x = old.x; "
! 1308: "END;", i, i, i+1
! 1309: );
! 1310: execsql(&err, &db, zSql);
! 1311: sqlite3_free(zSql);
! 1312: nCreate++;
! 1313: }
! 1314:
! 1315: for(i=1; i<9; i++){
! 1316: char *zSql = sqlite3_mprintf("DROP TRIGGER itr%d", i);
! 1317: execsql(&err, &db, zSql);
! 1318: sqlite3_free(zSql);
! 1319: nDrop++;
! 1320: }
! 1321:
! 1322: for(i=1; i<9; i++){
! 1323: char *zSql = sqlite3_mprintf("DROP TRIGGER dtr%d", i);
! 1324: execsql(&err, &db, zSql);
! 1325: sqlite3_free(zSql);
! 1326: nDrop++;
! 1327: }
! 1328: }
! 1329:
! 1330: print_and_free_err(&err);
! 1331: return sqlite3_mprintf("%d created, %d dropped", nCreate, nDrop);
! 1332: }
! 1333:
! 1334: static char *dynamic_triggers_2(int iTid, int iArg){
! 1335: Error err = {0}; /* Error code and message */
! 1336: Sqlite db = {0}; /* SQLite database connection */
! 1337: i64 iVal = 0;
! 1338: int nInsert = 0;
! 1339: int nDelete = 0;
! 1340:
! 1341: opendb(&err, &db, "test.db", 0);
! 1342: while( !timetostop(&err) ){
! 1343: do {
! 1344: iVal = (iVal+1)%100;
! 1345: execsql(&err, &db, "INSERT INTO t1 VALUES(:iX, :iY+1)", &iVal, &iVal);
! 1346: nInsert++;
! 1347: } while( iVal );
! 1348:
! 1349: do {
! 1350: iVal = (iVal+1)%100;
! 1351: execsql(&err, &db, "DELETE FROM t1 WHERE x = :iX", &iVal);
! 1352: nDelete++;
! 1353: } while( iVal );
! 1354: }
! 1355:
! 1356: print_and_free_err(&err);
! 1357: return sqlite3_mprintf("%d inserts, %d deletes", nInsert, nDelete);
! 1358: }
! 1359:
! 1360: static void dynamic_triggers(int nMs){
! 1361: Error err = {0};
! 1362: Sqlite db = {0};
! 1363: Threadset threads = {0};
! 1364:
! 1365: opendb(&err, &db, "test.db", 1);
! 1366: sql_script(&err, &db,
! 1367: "PRAGMA page_size = 1024;"
! 1368: "PRAGMA journal_mode = WAL;"
! 1369: "CREATE TABLE t1(x, y);"
! 1370: "CREATE TABLE t2(x, y);"
! 1371: "CREATE TABLE t3(x, y);"
! 1372: "CREATE TABLE t4(x, y);"
! 1373: "CREATE TABLE t5(x, y);"
! 1374: "CREATE TABLE t6(x, y);"
! 1375: "CREATE TABLE t7(x, y);"
! 1376: "CREATE TABLE t8(x, y);"
! 1377: "CREATE TABLE t9(x, y);"
! 1378: );
! 1379:
! 1380: setstoptime(&err, nMs);
! 1381:
! 1382: sqlite3_enable_shared_cache(1);
! 1383: launch_thread(&err, &threads, dynamic_triggers_2, 0);
! 1384: launch_thread(&err, &threads, dynamic_triggers_2, 0);
! 1385: sqlite3_enable_shared_cache(0);
! 1386:
! 1387: sleep(2);
! 1388:
! 1389: launch_thread(&err, &threads, dynamic_triggers_2, 0);
! 1390: launch_thread(&err, &threads, dynamic_triggers_1, 0);
! 1391:
! 1392: join_all_threads(&err, &threads);
! 1393:
! 1394: print_and_free_err(&err);
! 1395: }
! 1396:
! 1397: #include "tt3_checkpoint.c"
! 1398:
! 1399: int main(int argc, char **argv){
! 1400: struct ThreadTest {
! 1401: void (*xTest)(int);
! 1402: const char *zTest;
! 1403: int nMs;
! 1404: } aTest[] = {
! 1405: { walthread1, "walthread1", 20000 },
! 1406: { walthread2, "walthread2", 20000 },
! 1407: { walthread3, "walthread3", 20000 },
! 1408: { walthread4, "walthread4", 20000 },
! 1409: { walthread5, "walthread5", 1000 },
! 1410: { walthread5, "walthread5", 1000 },
! 1411:
! 1412: { cgt_pager_1, "cgt_pager_1", 0 },
! 1413: { dynamic_triggers, "dynamic_triggers", 20000 },
! 1414:
! 1415: { checkpoint_starvation_1, "checkpoint_starvation_1", 10000 },
! 1416: { checkpoint_starvation_2, "checkpoint_starvation_2", 10000 },
! 1417: };
! 1418:
! 1419: int i;
! 1420: char *zTest = 0;
! 1421: int nTest = 0;
! 1422: int bTestfound = 0;
! 1423: int bPrefix = 0;
! 1424:
! 1425: if( argc>2 ) goto usage;
! 1426: if( argc==2 ){
! 1427: zTest = argv[1];
! 1428: nTest = strlen(zTest);
! 1429: if( zTest[nTest-1]=='*' ){
! 1430: nTest--;
! 1431: bPrefix = 1;
! 1432: }
! 1433: }
! 1434:
! 1435: sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
! 1436:
! 1437: for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
! 1438: char const *z = aTest[i].zTest;
! 1439: int n = strlen(z);
! 1440: if( !zTest || ((bPrefix || n==nTest) && 0==strncmp(zTest, z, nTest)) ){
! 1441: printf("Running %s for %d seconds...\n", z, aTest[i].nMs/1000);
! 1442: aTest[i].xTest(aTest[i].nMs);
! 1443: bTestfound++;
! 1444: }
! 1445: }
! 1446: if( bTestfound==0 ) goto usage;
! 1447:
! 1448: printf("Total of %d errors across all tests\n", nGlobalErr);
! 1449: return (nGlobalErr>0 ? 255 : 0);
! 1450:
! 1451: usage:
! 1452: printf("Usage: %s [testname|testprefix*]\n", argv[0]);
! 1453: printf("Available tests are:\n");
! 1454: for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
! 1455: printf(" %s\n", aTest[i].zTest);
! 1456: }
! 1457:
! 1458: return 254;
! 1459: }
! 1460:
! 1461:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to threadtest3.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