Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Merge in all the latest changes from trunk. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | sessions |
Files: | files | file ages | folders |
SHA1: |
b11d941e92897663da46160185e6e305 |
User & Date: | drh 2011-03-30 02:03:12.567 |
Context
2011-03-30
| ||
17:07 | Add documentation to the sqlite3_preupdate_hook() interface and its relatives. (check-in: 8180f2881f user: drh tags: sessions) | |
02:03 | Merge in all the latest changes from trunk. (check-in: b11d941e92 user: drh tags: sessions) | |
2011-03-29
| ||
18:28 | Add tests to syscall.test and sysfault.test. (check-in: 3d2de01181 user: dan tags: trunk) | |
2011-03-25
| ||
19:06 | Improve coverage of session module a bit more. (check-in: 4255a9f609 user: dan tags: sessions) | |
Changes
install-sh became executable.
︙ | ︙ |
Changes to main.mk.
︙ | ︙ | |||
250 251 252 253 254 255 256 257 258 259 260 261 262 263 | $(TOP)/src/test_pcache.c \ $(TOP)/src/test_quota.c \ $(TOP)/src/test_rtree.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_stat.c \ $(TOP)/src/test_superlock.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c \ $(TOP)/src/test_vfs.c \ $(TOP)/src/test_wsd.c #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c #TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c | > | 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | $(TOP)/src/test_pcache.c \ $(TOP)/src/test_quota.c \ $(TOP)/src/test_rtree.c \ $(TOP)/src/test_schema.c \ $(TOP)/src/test_server.c \ $(TOP)/src/test_stat.c \ $(TOP)/src/test_superlock.c \ $(TOP)/src/test_syscall.c \ $(TOP)/src/test_tclvar.c \ $(TOP)/src/test_thread.c \ $(TOP)/src/test_vfs.c \ $(TOP)/src/test_wsd.c #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c #TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c |
︙ | ︙ |
Changes to src/backup.c.
︙ | ︙ | |||
484 485 486 487 488 489 490 | } }else{ rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0); } /* Finish committing the transaction to the destination database. */ if( SQLITE_OK==rc | | | | 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 | } }else{ rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0); } /* Finish committing the transaction to the destination database. */ if( SQLITE_OK==rc && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0)) ){ rc = SQLITE_DONE; } } /* If bCloseTrans is true, then this function opened a read transaction ** on the source database. Close the read transaction here. There is ** no need to check the return values of the btree methods here, as ** "committing" a read-only transaction cannot fail. */ if( bCloseTrans ){ TESTONLY( int rc2 ); TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0); assert( rc2==SQLITE_OK ); } if( rc==SQLITE_IOERR_NOMEM ){ rc = SQLITE_NOMEM; } p->rc = rc; |
︙ | ︙ |
Changes to src/btree.c.
︙ | ︙ | |||
3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 | ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() ** routine did all the work of writing information out to disk and flushing the ** contents so that they are written onto the disk platter. All this ** routine has to do is delete or truncate or zero the header in the ** the rollback journal (which causes the transaction to commit) and ** drop locks. ** ** This will release the write lock on the database file. If there ** are no active cursors, it also releases the read lock. */ | > > > > > > > > > > > | | | | 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 | ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() ** routine did all the work of writing information out to disk and flushing the ** contents so that they are written onto the disk platter. All this ** routine has to do is delete or truncate or zero the header in the ** the rollback journal (which causes the transaction to commit) and ** drop locks. ** ** Normally, if an error occurs while the pager layer is attempting to ** finalize the underlying journal file, this function returns an error and ** the upper layer will attempt a rollback. However, if the second argument ** is non-zero then this b-tree transaction is part of a multi-file ** transaction. In this case, the transaction has already been committed ** (by deleting a master journal file) and the caller will ignore this ** functions return code. So, even if an error occurs in the pager layer, ** reset the b-tree objects internal state to indicate that the write ** transaction has been closed. This is quite safe, as the pager will have ** transitioned to the error state. ** ** This will release the write lock on the database file. If there ** are no active cursors, it also releases the read lock. */ int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ if( p->inTrans==TRANS_NONE ) return SQLITE_OK; sqlite3BtreeEnter(p); btreeIntegrity(p); /* If the handle has a write-transaction open, commit the shared-btrees ** transaction and set the shared state to TRANS_READ. */ if( p->inTrans==TRANS_WRITE ){ int rc; BtShared *pBt = p->pBt; assert( pBt->inTransaction==TRANS_WRITE ); assert( pBt->nTransaction>0 ); rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); if( rc!=SQLITE_OK && bCleanup==0 ){ sqlite3BtreeLeave(p); return rc; } pBt->inTransaction = TRANS_READ; } btreeEndTransaction(p); sqlite3BtreeLeave(p); return SQLITE_OK; } /* ** Do both phases of a commit. */ int sqlite3BtreeCommit(Btree *p){ int rc; sqlite3BtreeEnter(p); rc = sqlite3BtreeCommitPhaseOne(p, 0); if( rc==SQLITE_OK ){ rc = sqlite3BtreeCommitPhaseTwo(p, 0); } sqlite3BtreeLeave(p); return rc; } #ifndef NDEBUG /* |
︙ | ︙ |
Changes to src/btree.h.
︙ | ︙ | |||
83 84 85 86 87 88 89 | u32 sqlite3BtreeLastPage(Btree*); int sqlite3BtreeSecureDelete(Btree*,int); int sqlite3BtreeGetReserve(Btree*); int sqlite3BtreeSetAutoVacuum(Btree *, int); int sqlite3BtreeGetAutoVacuum(Btree *); int sqlite3BtreeBeginTrans(Btree*,int); int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); | | | 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | u32 sqlite3BtreeLastPage(Btree*); int sqlite3BtreeSecureDelete(Btree*,int); int sqlite3BtreeGetReserve(Btree*); int sqlite3BtreeSetAutoVacuum(Btree *, int); int sqlite3BtreeGetAutoVacuum(Btree *); int sqlite3BtreeBeginTrans(Btree*,int); int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); int sqlite3BtreeCommitPhaseTwo(Btree*, int); int sqlite3BtreeCommit(Btree*); int sqlite3BtreeRollback(Btree*); int sqlite3BtreeBeginStmt(Btree*,int); int sqlite3BtreeCreateTable(Btree*, int*, int flags); int sqlite3BtreeIsInTrans(Btree*); int sqlite3BtreeIsInReadTrans(Btree*); int sqlite3BtreeIsInBackup(Btree*); |
︙ | ︙ |
Changes to src/build.c.
︙ | ︙ | |||
364 365 366 367 368 369 370 | void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ Index *pIndex; int len; Hash *pHash = &db->aDb[iDb].pSchema->idxHash; len = sqlite3Strlen30(zIdxName); pIndex = sqlite3HashInsert(pHash, zIdxName, len, 0); | | | 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 | void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ Index *pIndex; int len; Hash *pHash = &db->aDb[iDb].pSchema->idxHash; len = sqlite3Strlen30(zIdxName); pIndex = sqlite3HashInsert(pHash, zIdxName, len, 0); if( ALWAYS(pIndex) ){ if( pIndex->pTable->pIndex==pIndex ){ pIndex->pTable->pIndex = pIndex->pNext; }else{ Index *p; /* Justification of ALWAYS(); The index must be on the list of ** indices. */ p = pIndex->pTable->pIndex; |
︙ | ︙ |
Changes to src/os_unix.c.
︙ | ︙ | |||
367 368 369 370 371 372 373 | #define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent) #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 }, #else { "fallocate", (sqlite3_syscall_ptr)0, 0 }, #endif | | | 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 | #define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent) #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 }, #else { "fallocate", (sqlite3_syscall_ptr)0, 0 }, #endif #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent) }; /* End of the overrideable system calls */ /* ** This is the xSetSystemCall() method of sqlite3_vfs for all of the ** "unix" VFSes. Return SQLITE_OK opon successfully updating the ** system call pointer, or SQLITE_NOTFOUND if there is no configurable |
︙ | ︙ | |||
440 441 442 443 444 445 446 | /* ** Return the name of the first system call after zName. If zName==NULL ** then return the name of the first system call. Return NULL if zName ** is the last system call or if zName is not the name of a valid ** system call. */ static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){ | | | < < | | | | | 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 | /* ** Return the name of the first system call after zName. If zName==NULL ** then return the name of the first system call. Return NULL if zName ** is the last system call or if zName is not the name of a valid ** system call. */ static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){ int i = -1; UNUSED_PARAMETER(p); if( zName ){ for(i=0; i<ArraySize(aSyscall)-1; i++){ if( strcmp(zName, aSyscall[i].zName)==0 ) break; } } for(i++; i<ArraySize(aSyscall); i++){ if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName; } return 0; } /* ** Retry open() calls that fail due to EINTR */ |
︙ | ︙ | |||
3376 3377 3378 3379 3380 3381 3382 | if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT; nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk; if( nSize>(i64)buf.st_size ){ #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE int rc; do{ | | | | 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 | if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT; nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk; if( nSize>(i64)buf.st_size ){ #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE int rc; do{ rc = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size); }while( rc<0 && errno==EINTR ); if( rc ) return SQLITE_IOERR_WRITE; #else /* If the OS does not have posix_fallocate(), fake it. First use ** ftruncate() to set the file size, then write a single byte to ** the last byte in each block within the extended region. This ** is the same technique used by glibc to implement posix_fallocate() ** on systems that do not have a real fallocate() system call. |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
2971 2972 2973 2974 2975 2976 2977 | ** interface returns a pointer to a zero-terminated UTF-8 string ** and sqlite3_column_name16() returns a pointer to a zero-terminated ** UTF-16 string. ^The first parameter is the [prepared statement] ** that implements the [SELECT] statement. ^The second parameter is the ** column number. ^The leftmost column is number 0. ** ** ^The returned string pointer is valid until either the [prepared statement] | | > > | 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 | ** interface returns a pointer to a zero-terminated UTF-8 string ** and sqlite3_column_name16() returns a pointer to a zero-terminated ** UTF-16 string. ^The first parameter is the [prepared statement] ** that implements the [SELECT] statement. ^The second parameter is the ** column number. ^The leftmost column is number 0. ** ** ^The returned string pointer is valid until either the [prepared statement] ** is destroyed by [sqlite3_finalize()] or until the statement is automatically ** reprepared by the first call to [sqlite3_step()] for a particular run ** or until the next call to ** sqlite3_column_name() or sqlite3_column_name16() on the same column. ** ** ^If sqlite3_malloc() fails during the processing of either routine ** (for example during a conversion from UTF-8 to UTF-16) then a ** NULL pointer is returned. ** ** ^The name of a result column is the value of the "AS" clause for |
︙ | ︙ | |||
2997 2998 2999 3000 3001 3002 3003 | ** table column that is the origin of a particular result column in ** [SELECT] statement. ** ^The name of the database or table or column can be returned as ** either a UTF-8 or UTF-16 string. ^The _database_ routines return ** the database name, the _table_ routines return the table name, and ** the origin_ routines return the column name. ** ^The returned string is valid until the [prepared statement] is destroyed | | > > | 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 | ** table column that is the origin of a particular result column in ** [SELECT] statement. ** ^The name of the database or table or column can be returned as ** either a UTF-8 or UTF-16 string. ^The _database_ routines return ** the database name, the _table_ routines return the table name, and ** the origin_ routines return the column name. ** ^The returned string is valid until the [prepared statement] is destroyed ** using [sqlite3_finalize()] or until the statement is automatically ** reprepared by the first call to [sqlite3_step()] for a particular run ** or until the same information is requested ** again in a different encoding. ** ** ^The names returned are the original un-aliased names of the ** database, table, and column. ** ** ^The first argument to these interfaces is a [prepared statement]. ** ^These functions return information about the Nth result column returned by |
︙ | ︙ |
Changes to src/tclsqlite.c.
︙ | ︙ | |||
3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 | extern int Sqlitetestintarray_Init(Tcl_Interp*); extern int Sqlitetestvfs_Init(Tcl_Interp *); extern int SqlitetestStat_Init(Tcl_Interp*); extern int Sqlitetestrtree_Init(Tcl_Interp*); extern int Sqlitequota_Init(Tcl_Interp*); extern int Sqlitemultiplex_Init(Tcl_Interp*); extern int SqliteSuperlock_Init(Tcl_Interp*); #ifdef SQLITE_ENABLE_SESSION extern int TestSession_Init(Tcl_Interp*); #endif | > < | 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 | extern int Sqlitetestintarray_Init(Tcl_Interp*); extern int Sqlitetestvfs_Init(Tcl_Interp *); extern int SqlitetestStat_Init(Tcl_Interp*); extern int Sqlitetestrtree_Init(Tcl_Interp*); extern int Sqlitequota_Init(Tcl_Interp*); extern int Sqlitemultiplex_Init(Tcl_Interp*); extern int SqliteSuperlock_Init(Tcl_Interp*); extern int SqlitetestSyscall_Init(Tcl_Interp*); #ifdef SQLITE_ENABLE_SESSION extern int TestSession_Init(Tcl_Interp*); #endif #ifdef SQLITE_ENABLE_ZIPVFS extern int Zipvfs_Init(Tcl_Interp*); Zipvfs_Init(interp); #endif Sqliteconfig_Init(interp); Sqlitetest1_Init(interp); |
︙ | ︙ | |||
3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 | Sqlitetestintarray_Init(interp); Sqlitetestvfs_Init(interp); SqlitetestStat_Init(interp); Sqlitetestrtree_Init(interp); Sqlitequota_Init(interp); Sqlitemultiplex_Init(interp); SqliteSuperlock_Init(interp); #ifdef SQLITE_ENABLE_SESSION TestSession_Init(interp); #endif Tcl_CreateObjCommand(interp,"load_testfixture_extensions",init_all_cmd,0,0); #ifdef SQLITE_SSE | > | 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 | Sqlitetestintarray_Init(interp); Sqlitetestvfs_Init(interp); SqlitetestStat_Init(interp); Sqlitetestrtree_Init(interp); Sqlitequota_Init(interp); Sqlitemultiplex_Init(interp); SqliteSuperlock_Init(interp); SqlitetestSyscall_Init(interp); #ifdef SQLITE_ENABLE_SESSION TestSession_Init(interp); #endif Tcl_CreateObjCommand(interp,"load_testfixture_extensions",init_all_cmd,0,0); #ifdef SQLITE_SSE |
︙ | ︙ |
Added src/test_syscall.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 | /* ** 2011 March 28 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** ** The code in this file implements a Tcl interface used to test error ** handling in the os_unix.c module. Wrapper functions that support fault ** injection are registered as the low-level OS functions using the ** xSetSystemCall() method of the VFS. The Tcl interface is as follows: ** ** ** test_syscall install LIST ** Install wrapper functions for all system calls in argument LIST. ** LIST must be a list consisting of zero or more of the following ** literal values: ** ** open close access getcwd stat fstat ** ftruncate fcntl read pread pread64 write ** pwrite pwrite64 fchmod fallocate ** ** test_syscall uninstall ** Uninstall all wrapper functions. ** ** test_syscall fault ?COUNT PERSIST? ** If [test_syscall fault] is invoked without the two arguments, fault ** injection is disabled. Otherwise, fault injection is configured to ** cause a failure on the COUNT'th next call to a system call with a ** wrapper function installed. A COUNT value of 1 means fail the next ** system call. ** ** Argument PERSIST is interpreted as a boolean. If true, the all ** system calls following the initial failure also fail. Otherwise, only ** the single transient failure is injected. ** ** test_syscall errno CALL ERRNO ** Set the value that the global "errno" is set to following a fault ** in call CALL. Argument CALL must be one of the system call names ** listed above (under [test_syscall install]). ERRNO is a symbolic ** name (i.e. "EACCES"). Not all errno codes are supported. Add extra ** to the aErrno table in function test_syscall_errno() below as ** required. ** ** test_syscall reset ?SYSTEM-CALL? ** With no argument, this is an alias for the [uninstall] command. However, ** this command uses a VFS call of the form: ** ** xSetSystemCall(pVfs, 0, 0); ** ** To restore the default system calls. The [uninstall] command restores ** each system call individually by calling (i.e.): ** ** xSetSystemCall(pVfs, "open", 0); ** ** With an argument, this command attempts to reset the system call named ** by the parameter using the same method as [uninstall]. ** ** test_syscall exists SYSTEM-CALL ** Return true if the named system call exists. Or false otherwise. ** ** test_syscall list ** Return a list of all system calls. The list is constructed using ** the xNextSystemCall() VFS method. */ #include "sqlite3.h" #include "tcl.h" #include <stdlib.h> #include <string.h> #include <assert.h> #ifdef SQLITE_OS_UNIX /* From test1.c */ extern const char *sqlite3TestErrorName(int); #include <sys/types.h> #include <errno.h> static struct TestSyscallGlobal { int bPersist; /* 1 for persistent errors, 0 for transient */ int nCount; /* Fail after this many more calls */ int nFail; /* Number of failures that have occurred */ } gSyscall = { 0, 0 }; static int ts_open(const char *, int, int); static int ts_close(int fd); static int ts_access(const char *zPath, int mode); static char *ts_getcwd(char *zPath, size_t nPath); static int ts_stat(const char *zPath, struct stat *p); static int ts_fstat(int fd, struct stat *p); static int ts_ftruncate(int fd, off_t n); static int ts_fcntl(int fd, int cmd, ... ); static int ts_read(int fd, void *aBuf, size_t nBuf); static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off); static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off); static int ts_write(int fd, const void *aBuf, size_t nBuf); static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off); static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off); static int ts_fchmod(int fd, mode_t mode); static int ts_fallocate(int fd, off_t off, off_t len); struct TestSyscallArray { const char *zName; sqlite3_syscall_ptr xTest; sqlite3_syscall_ptr xOrig; int default_errno; /* Default value for errno following errors */ int custom_errno; /* Current value for errno if error */ } aSyscall[] = { /* 0 */ { "open", (sqlite3_syscall_ptr)ts_open, 0, EACCES, 0 }, /* 1 */ { "close", (sqlite3_syscall_ptr)ts_close, 0, 0, 0 }, /* 2 */ { "access", (sqlite3_syscall_ptr)ts_access, 0, 0, 0 }, /* 3 */ { "getcwd", (sqlite3_syscall_ptr)ts_getcwd, 0, 0, 0 }, /* 4 */ { "stat", (sqlite3_syscall_ptr)ts_stat, 0, 0, 0 }, /* 5 */ { "fstat", (sqlite3_syscall_ptr)ts_fstat, 0, 0, 0 }, /* 6 */ { "ftruncate", (sqlite3_syscall_ptr)ts_ftruncate, 0, EIO, 0 }, /* 7 */ { "fcntl", (sqlite3_syscall_ptr)ts_fcntl, 0, 0, 0 }, /* 8 */ { "read", (sqlite3_syscall_ptr)ts_read, 0, 0, 0 }, /* 9 */ { "pread", (sqlite3_syscall_ptr)ts_pread, 0, 0, 0 }, /* 10 */ { "pread64", (sqlite3_syscall_ptr)ts_pread64, 0, 0, 0 }, /* 11 */ { "write", (sqlite3_syscall_ptr)ts_write, 0, 0, 0 }, /* 12 */ { "pwrite", (sqlite3_syscall_ptr)ts_pwrite, 0, 0, 0 }, /* 13 */ { "pwrite64", (sqlite3_syscall_ptr)ts_pwrite64, 0, 0, 0 }, /* 14 */ { "fchmod", (sqlite3_syscall_ptr)ts_fchmod, 0, 0, 0 }, /* 15 */ { "fallocate", (sqlite3_syscall_ptr)ts_fallocate, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }; #define orig_open ((int(*)(const char *, int, int))aSyscall[0].xOrig) #define orig_close ((int(*)(int))aSyscall[1].xOrig) #define orig_access ((int(*)(const char*,int))aSyscall[2].xOrig) #define orig_getcwd ((char*(*)(char*,size_t))aSyscall[3].xOrig) #define orig_stat ((int(*)(const char*,struct stat*))aSyscall[4].xOrig) #define orig_fstat ((int(*)(int,struct stat*))aSyscall[5].xOrig) #define orig_ftruncate ((int(*)(int,off_t))aSyscall[6].xOrig) #define orig_fcntl ((int(*)(int,int,...))aSyscall[7].xOrig) #define orig_read ((ssize_t(*)(int,void*,size_t))aSyscall[8].xOrig) #define orig_pread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].xOrig) #define orig_pread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].xOrig) #define orig_write ((ssize_t(*)(int,const void*,size_t))aSyscall[11].xOrig) #define orig_pwrite ((ssize_t(*)(int,const void*,size_t,off_t))\ aSyscall[12].xOrig) #define orig_pwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\ aSyscall[13].xOrig) #define orig_fchmod ((int(*)(int,mode_t))aSyscall[14].xOrig) #define orig_fallocate ((int(*)(int,off_t,off_t))aSyscall[15].xOrig) /* ** This function is called exactly once from within each invocation of a ** system call wrapper in this file. It returns 1 if the function should ** fail, or 0 if it should succeed. */ static int tsIsFail(void){ gSyscall.nCount--; if( gSyscall.nCount==0 || (gSyscall.nFail && gSyscall.bPersist) ){ gSyscall.nFail++; return 1; } return 0; } /* ** Return the current error-number value for function zFunc. zFunc must be ** the name of a system call in the aSyscall[] table. ** ** Usually, the current error-number is the value that errno should be set ** to if the named system call fails. The exception is "fallocate". See ** comments above the implementation of ts_fallocate() for details. */ static int tsErrno(const char *zFunc){ int i; int nFunc = strlen(zFunc); for(i=0; aSyscall[i].zName; i++){ if( strlen(aSyscall[i].zName)!=nFunc ) continue; if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue; return aSyscall[i].custom_errno; } assert(0); return 0; } /* ** A wrapper around tsIsFail(). If tsIsFail() returns non-zero, set the ** value of errno before returning. */ static int tsIsFailErrno(const char *zFunc){ if( tsIsFail() ){ errno = tsErrno(zFunc); return 1; } return 0; } /* ** A wrapper around open(). */ static int ts_open(const char *zFile, int flags, int mode){ if( tsIsFailErrno("open") ){ return -1; } return orig_open(zFile, flags, mode); } /* ** A wrapper around close(). */ static int ts_close(int fd){ if( tsIsFail() ){ return -1; } return orig_close(fd); } /* ** A wrapper around access(). */ static int ts_access(const char *zPath, int mode){ if( tsIsFail() ){ return -1; } return orig_access(zPath, mode); } /* ** A wrapper around getcwd(). */ static char *ts_getcwd(char *zPath, size_t nPath){ if( tsIsFail() ){ return NULL; } return orig_getcwd(zPath, nPath); } /* ** A wrapper around stat(). */ static int ts_stat(const char *zPath, struct stat *p){ if( tsIsFail() ){ return -1; } return orig_stat(zPath, p); } /* ** A wrapper around fstat(). */ static int ts_fstat(int fd, struct stat *p){ if( tsIsFailErrno("fstat") ){ return -1; } return orig_fstat(fd, p); } /* ** A wrapper around ftruncate(). */ static int ts_ftruncate(int fd, off_t n){ if( tsIsFailErrno("ftruncate") ){ return -1; } return orig_ftruncate(fd, n); } /* ** A wrapper around fcntl(). */ static int ts_fcntl(int fd, int cmd, ... ){ va_list ap; void *pArg; if( tsIsFail() ){ return -1; } va_start(ap, cmd); pArg = va_arg(ap, void *); return orig_fcntl(fd, cmd, pArg); } /* ** A wrapper around read(). */ static int ts_read(int fd, void *aBuf, size_t nBuf){ if( tsIsFail() ){ return -1; } return orig_read(fd, aBuf, nBuf); } /* ** A wrapper around pread(). */ static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off){ if( tsIsFail() ){ return -1; } return orig_pread(fd, aBuf, nBuf, off); } /* ** A wrapper around pread64(). */ static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off){ if( tsIsFail() ){ return -1; } return orig_pread64(fd, aBuf, nBuf, off); } /* ** A wrapper around write(). */ static int ts_write(int fd, const void *aBuf, size_t nBuf){ if( tsIsFail() ){ return -1; } return orig_write(fd, aBuf, nBuf); } /* ** A wrapper around pwrite(). */ static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){ if( tsIsFail() ){ return -1; } return orig_pwrite(fd, aBuf, nBuf, off); } /* ** A wrapper around pwrite64(). */ static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off){ if( tsIsFail() ){ return -1; } return orig_pwrite64(fd, aBuf, nBuf, off); } /* ** A wrapper around fchmod(). */ static int ts_fchmod(int fd, mode_t mode){ if( tsIsFail() ){ return -1; } return orig_fchmod(fd, mode); } /* ** A wrapper around fallocate(). ** ** SQLite assumes that the fallocate() function is compatible with ** posix_fallocate(). According to the Linux man page (2009-09-30): ** ** posix_fallocate() returns zero on success, or an error number on ** failure. Note that errno is not set. */ static int ts_fallocate(int fd, off_t off, off_t len){ if( tsIsFail() ){ return tsErrno("fallocate"); } return orig_fallocate(fd, off, len); } static int test_syscall_install( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_vfs *pVfs; int nElem; int i; Tcl_Obj **apElem; if( objc!=3 ){ Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL-LIST"); return TCL_ERROR; } if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){ return TCL_ERROR; } pVfs = sqlite3_vfs_find(0); for(i=0; i<nElem; i++){ int iCall; int rc = Tcl_GetIndexFromObjStruct(interp, apElem[i], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall ); if( rc ) return rc; if( aSyscall[iCall].xOrig==0 ){ aSyscall[iCall].xOrig = pVfs->xGetSystemCall(pVfs, aSyscall[iCall].zName); pVfs->xSetSystemCall(pVfs, aSyscall[iCall].zName, aSyscall[iCall].xTest); } aSyscall[iCall].custom_errno = aSyscall[iCall].default_errno; } return TCL_OK; } static int test_syscall_uninstall( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_vfs *pVfs; int i; if( objc!=2 ){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } pVfs = sqlite3_vfs_find(0); for(i=0; aSyscall[i].zName; i++){ if( aSyscall[i].xOrig ){ pVfs->xSetSystemCall(pVfs, aSyscall[i].zName, 0); aSyscall[i].xOrig = 0; } } return TCL_OK; } static int test_syscall_reset( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_vfs *pVfs; int i; int rc; if( objc!=2 && objc!=3 ){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } pVfs = sqlite3_vfs_find(0); if( objc==2 ){ rc = pVfs->xSetSystemCall(pVfs, 0, 0); for(i=0; aSyscall[i].zName; i++) aSyscall[i].xOrig = 0; }else{ int nFunc; char *zFunc = Tcl_GetStringFromObj(objv[2], &nFunc); rc = pVfs->xSetSystemCall(pVfs, Tcl_GetString(objv[2]), 0); for(i=0; rc==SQLITE_OK && aSyscall[i].zName; i++){ if( strlen(aSyscall[i].zName)!=nFunc ) continue; if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue; aSyscall[i].xOrig = 0; } } if( rc!=SQLITE_OK ){ Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3TestErrorName(rc), -1)); return TCL_ERROR; } Tcl_ResetResult(interp); return TCL_OK; } static int test_syscall_exists( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_vfs *pVfs; sqlite3_syscall_ptr x; if( objc!=3 ){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } pVfs = sqlite3_vfs_find(0); x = pVfs->xGetSystemCall(pVfs, Tcl_GetString(objv[2])); Tcl_SetObjResult(interp, Tcl_NewBooleanObj(x!=0)); return TCL_OK; } static int test_syscall_fault( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ int nCount = 0; int bPersist = 0; if( objc!=2 && objc!=4 ){ Tcl_WrongNumArgs(interp, 2, objv, "?COUNT PERSIST?"); return TCL_ERROR; } if( objc==4 ){ if( Tcl_GetIntFromObj(interp, objv[2], &nCount) || Tcl_GetBooleanFromObj(interp, objv[3], &bPersist) ){ return TCL_ERROR; } } Tcl_SetObjResult(interp, Tcl_NewIntObj(gSyscall.nFail)); gSyscall.nCount = nCount; gSyscall.bPersist = bPersist; gSyscall.nFail = 0; return TCL_OK; } static int test_syscall_errno( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ int iCall; int iErrno; int rc; struct Errno { const char *z; int i; } aErrno[] = { { "EACCES", EACCES }, { "EINTR", EINTR }, { "EIO", EIO }, { "EOVERFLOW", EOVERFLOW }, { "ENOMEM", ENOMEM }, { 0, 0 } }; if( objc!=4 ){ Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL ERRNO"); return TCL_ERROR; } rc = Tcl_GetIndexFromObjStruct(interp, objv[2], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall ); if( rc!=TCL_OK ) return rc; rc = Tcl_GetIndexFromObjStruct(interp, objv[3], aErrno, sizeof(aErrno[0]), "errno", 0, &iErrno ); if( rc!=TCL_OK ) return rc; aSyscall[iCall].custom_errno = aErrno[iErrno].i; return TCL_OK; } static int test_syscall_list( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ const char *zSys; sqlite3_vfs *pVfs; Tcl_Obj *pList; if( objc!=2 ){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } pVfs = sqlite3_vfs_find(0); pList = Tcl_NewObj(); Tcl_IncrRefCount(pList); for(zSys = pVfs->xNextSystemCall(pVfs, 0); zSys!=0; zSys = pVfs->xNextSystemCall(pVfs, zSys) ){ Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(zSys, -1)); } Tcl_SetObjResult(interp, pList); Tcl_DecrRefCount(pList); return TCL_OK; } static int test_syscall( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ struct SyscallCmd { const char *zName; Tcl_ObjCmdProc *xCmd; } aCmd[] = { { "fault", test_syscall_fault }, { "install", test_syscall_install }, { "uninstall", test_syscall_uninstall }, { "reset", test_syscall_reset }, { "errno", test_syscall_errno }, { "exists", test_syscall_exists }, { "list", test_syscall_list }, { 0, 0 } }; int iCmd; int rc; if( objc<2 ){ Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ..."); return TCL_ERROR; } rc = Tcl_GetIndexFromObjStruct(interp, objv[1], aCmd, sizeof(aCmd[0]), "sub-command", 0, &iCmd ); if( rc!=TCL_OK ) return rc; return aCmd[iCmd].xCmd(clientData, interp, objc, objv); } int SqlitetestSyscall_Init(Tcl_Interp *interp){ struct SyscallCmd { const char *zName; Tcl_ObjCmdProc *xCmd; } aCmd[] = { { "test_syscall", test_syscall}, }; int i; for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xCmd, 0, 0); } return TCL_OK; } #else int SqlitetestSyscall_Init(Tcl_Interp *interp){ return TCL_OK; } #endif |
Changes to src/test_vfstrace.c.
︙ | ︙ | |||
73 74 75 76 77 78 79 | static void (*vfstraceDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); static void vfstraceDlClose(sqlite3_vfs*, void*); static int vfstraceRandomness(sqlite3_vfs*, int nByte, char *zOut); static int vfstraceSleep(sqlite3_vfs*, int microseconds); static int vfstraceCurrentTime(sqlite3_vfs*, double*); static int vfstraceGetLastError(sqlite3_vfs*, int, char*); static int vfstraceCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); | | | | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | static void (*vfstraceDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); static void vfstraceDlClose(sqlite3_vfs*, void*); static int vfstraceRandomness(sqlite3_vfs*, int nByte, char *zOut); static int vfstraceSleep(sqlite3_vfs*, int microseconds); static int vfstraceCurrentTime(sqlite3_vfs*, double*); static int vfstraceGetLastError(sqlite3_vfs*, int, char*); static int vfstraceCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); static int vfstraceSetSystemCall(sqlite3_vfs*,const char*, sqlite3_syscall_ptr); static sqlite3_syscall_ptr vfstraceGetSystemCall(sqlite3_vfs*, const char *); static const char *vfstraceNextSystemCall(sqlite3_vfs*, const char *zName); /* ** Return a pointer to the tail of the pathname. Examples: ** ** /home/drh/xyzzy.txt -> xyzzy.txt ** xyzzy.txt -> xyzzy.txt |
︙ | ︙ | |||
678 679 680 681 682 683 684 | /* ** Override system calls. */ static int vfstraceSetSystemCall( sqlite3_vfs *pVfs, const char *zName, | | > | > > | 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 | /* ** Override system calls. */ static int vfstraceSetSystemCall( sqlite3_vfs *pVfs, const char *zName, sqlite3_syscall_ptr pFunc ){ vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; sqlite3_vfs *pRoot = pInfo->pRootVfs; return pRoot->xSetSystemCall(pRoot, zName, pFunc); } static sqlite3_syscall_ptr vfstraceGetSystemCall( sqlite3_vfs *pVfs, const char *zName ){ vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; sqlite3_vfs *pRoot = pInfo->pRootVfs; return pRoot->xGetSystemCall(pRoot, zName); } static const char *vfstraceNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ vfstrace_info *pInfo = (vfstrace_info*)pVfs->pAppData; sqlite3_vfs *pRoot = pInfo->pRootVfs; |
︙ | ︙ |
Changes to src/utf.c.
︙ | ︙ | |||
163 164 165 166 167 168 169 | || (c&0xFFFFF800)==0xD800 \ || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ } int sqlite3Utf8Read( const unsigned char *zIn, /* First byte of UTF-8 character */ const unsigned char **pzNext /* Write first byte past UTF-8 char here */ ){ | | | 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | || (c&0xFFFFF800)==0xD800 \ || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ } int sqlite3Utf8Read( const unsigned char *zIn, /* First byte of UTF-8 character */ const unsigned char **pzNext /* Write first byte past UTF-8 char here */ ){ unsigned int c; /* Same as READ_UTF8() above but without the zTerm parameter. ** For this routine, we assume the UTF8 string is always zero-terminated. */ c = *(zIn++); if( c>=0xc0 ){ c = sqlite3Utf8Trans1[c-0xc0]; |
︙ | ︙ | |||
406 407 408 409 410 411 412 | #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) /* ** Translate UTF-8 to UTF-8. ** ** This has the effect of making sure that the string is well-formed ** UTF-8. Miscoded characters are removed. ** | | | | | 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 | #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) /* ** Translate UTF-8 to UTF-8. ** ** This has the effect of making sure that the string is well-formed ** UTF-8. Miscoded characters are removed. ** ** The translation is done in-place and aborted if the output ** overruns the input. */ int sqlite3Utf8To8(unsigned char *zIn){ unsigned char *zOut = zIn; unsigned char *zStart = zIn; u32 c; while( zIn[0] && zOut<=zIn ){ c = sqlite3Utf8Read(zIn, (const u8**)&zIn); if( c!=0xfffd ){ WRITE_UTF8(zOut, c); } } *zOut = 0; return (int)(zOut - zStart); |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
4642 4643 4644 4645 4646 4647 4648 | flags = BTREE_BLOBKEY; } rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags); pOut->u.i = pgno; break; } | | | < < < < < < < < < < < | | | 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 | flags = BTREE_BLOBKEY; } rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags); pOut->u.i = pgno; break; } /* Opcode: ParseSchema P1 * * P4 * ** ** Read and parse all entries from the SQLITE_MASTER table of database P1 ** that match the WHERE clause P4. ** ** This opcode invokes the parser to create a new virtual machine, ** then runs the new virtual machine. It is thus a re-entrant opcode. */ case OP_ParseSchema: { int iDb; const char *zMaster; char *zSql; InitData initData; iDb = pOp->p1; assert( iDb>=0 && iDb<db->nDb ); /* Although the mutex on the BtShared object that corresponds to ** database iDb (the database containing the sqlite_master table ** read by this instruction) is currently held, it is necessary to ** obtain the mutexes on all attached databases before checking if ** the schema of iDb is loaded. This is because, at the start of ** the sqlite3_exec() call below, SQLite will invoke ** sqlite3BtreeEnterAll(). If all mutexes are not already held, the ** iDb mutex may be temporarily released to avoid deadlock. If ** this happens, then some other thread may delete the in-memory ** schema of database iDb before the SQL statement runs. The schema ** will not be reloaded becuase the db->init.busy flag is set. This ** can result in a "no such table: sqlite_master" or "malformed ** database schema" error being returned to the user. */ assert( sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); sqlite3BtreeEnterAll(db); if( ALWAYS(DbHasProperty(db, iDb, DB_SchemaLoaded)) ){ zMaster = SCHEMA_TABLE(iDb); initData.db = db; initData.iDb = pOp->p1; initData.pzErrMsg = &p->zErrMsg; zSql = sqlite3MPrintf(db, "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid", db->aDb[iDb].zName, zMaster, pOp->p4.z); |
︙ | ︙ |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
1700 1701 1702 1703 1704 1705 1706 | ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an ** IO error while deleting or truncating a journal file. It is unlikely, ** but could happen. In this case abandon processing and return the error. */ for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ Btree *pBt = db->aDb[i].pBt; if( pBt ){ | | | 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 | ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an ** IO error while deleting or truncating a journal file. It is unlikely, ** but could happen. In this case abandon processing and return the error. */ for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ Btree *pBt = db->aDb[i].pBt; if( pBt ){ rc = sqlite3BtreeCommitPhaseTwo(pBt, 0); } } if( rc==SQLITE_OK ){ sqlite3VtabCommit(db); } } |
︙ | ︙ | |||
1832 1833 1834 1835 1836 1837 1838 | ** may be lying around. Returning an error code won't help matters. */ disable_simulated_io_errors(); sqlite3BeginBenignMalloc(); for(i=0; i<db->nDb; i++){ Btree *pBt = db->aDb[i].pBt; if( pBt ){ | | | 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 | ** may be lying around. Returning an error code won't help matters. */ disable_simulated_io_errors(); sqlite3BeginBenignMalloc(); for(i=0; i<db->nDb; i++){ Btree *pBt = db->aDb[i].pBt; if( pBt ){ sqlite3BtreeCommitPhaseTwo(pBt, 1); } } sqlite3EndBenignMalloc(); enable_simulated_io_errors(); sqlite3VtabCommit(db); } |
︙ | ︙ |
Changes to src/vtab.c.
︙ | ︙ | |||
368 369 370 371 372 373 374 | ); sqlite3DbFree(db, zStmt); v = sqlite3GetVdbe(pParse); sqlite3ChangeCookie(pParse, iDb); sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName); | | | 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 | ); sqlite3DbFree(db, zStmt); v = sqlite3GetVdbe(pParse); sqlite3ChangeCookie(pParse, iDb); sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName); sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC); sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0, pTab->zName, sqlite3Strlen30(pTab->zName) + 1); } /* If we are rereading the sqlite_master table create the in-memory ** record of the table. The xConnect() method is not called until ** the first time the virtual table is used in an SQL statement. This |
︙ | ︙ |
Added test/badutf2.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | # 2011 March 15 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. # # This file checks to make sure SQLite is able to gracEFully # handle malformed UTF-8. # set testdir [file dirname $argv0] source $testdir/tester.tcl proc utf8_to_ustr2 {s} { set r "" foreach i [split $s ""] { scan $i %c c append r [format \\u%04.4X $c] } set r } proc utf8_to_hstr {in} { regsub -all -- {(..)} $in {%[format "%s" \1]} out subst $out } proc utf8_to_xstr {in} { regsub -all -- {(..)} $in {\\\\x[format "%s" \1]} out subst $out } proc utf8_to_ustr {in} { regsub -all -- {(..)} $in {\\\\u[format "%04.4X" 0x\1]} out subst $out } do_test badutf2-1.0 { db close forcedelete test.db sqlite3 db test.db db eval "PRAGMA encoding = 'UTF-8'" } {} do_test badutf2-4.0 { set S [sqlite3_prepare_v2 db "SELECT ?" -1 dummy] sqlite3_expired $S } {0} foreach { i len uval xstr ustr u2u } { 1 1 00 \x00 {} {} 2 1 01 \x01 "\\u0001" 01 3 1 3F \x3F "\\u003F" 3F 4 1 7F \x7F "\\u007F" 7F 5 1 80 \x80 "\\u0080" C280 6 1 C3BF \xFF "\\u00FF" C3BF 7 3 EFBFBD \xEF\xBF\xBD "\\uFFFD" {} } { set hstr [ utf8_to_hstr $uval ] ifcapable bloblit { if {$hstr != "%00"} { do_test badutf2-2.1.$i { set sql "SELECT '$hstr'=CAST(x'$uval' AS text) AS x;" set res [ sqlite3_exec db $sql ] lindex [ lindex $res 1] 1 } {1} do_test badutf2-2.2.$i { set sql "SELECT CAST('$hstr' AS blob)=x'$uval' AS x;" set res [ sqlite3_exec db $sql ] lindex [ lindex $res 1] 1 } {1} } do_test badutf2-2.3.$i { set sql "SELECT hex(CAST(x'$uval' AS text)) AS x;" set res [ sqlite3_exec db $sql ] lindex [ lindex $res 1] 1 } $uval do_test badutf2-2.4.$i { set sql "SELECT hex(CAST(x'$uval' AS text)) AS x;" set res [ sqlite3_exec db $sql ] lindex [ lindex $res 1] 1 } $uval } if {$hstr != "%00"} { do_test badutf2-3.1.$i { set sql "SELECT hex('$hstr') AS x;" set res [ sqlite3_exec db $sql ] lindex [ lindex $res 1] 1 } $uval } do_test badutf2-4.1.$i { sqlite3_reset $S sqlite3_bind_text $S 1 $xstr $len sqlite3_step $S utf8_to_ustr2 [ sqlite3_column_text $S 0 ] } $ustr do_test badutf2-5.1.$i { utf8_to_utf8 $uval } $u2u } do_test badutf2-4.2 { sqlite3_finalize $S } {SQLITE_OK} finish_test |
Changes to test/fts3fault2.test.
︙ | ︙ | |||
9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set ::testprefix fts3fault2 do_test 1.0 { execsql { CREATE VIRTUAL TABLE t1 USING fts4(x); INSERT INTO t1 VALUES('a b c'); INSERT INTO t1 VALUES('c d e'); CREATE VIRTUAL TABLE terms USING fts4aux(t1); | > > > | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set ::testprefix fts3fault2 # If SQLITE_ENABLE_FTS3 is not defined, omit this file. ifcapable !fts3 { finish_test ; return } do_test 1.0 { execsql { CREATE VIRTUAL TABLE t1 USING fts4(x); INSERT INTO t1 VALUES('a b c'); INSERT INTO t1 VALUES('c d e'); CREATE VIRTUAL TABLE terms USING fts4aux(t1); |
︙ | ︙ |
Changes to test/malloc_common.tcl.
︙ | ︙ | |||
113 114 115 116 117 118 119 | proc do_faultsim_test {name args} { global FAULTSIM set DEFAULT(-faults) [array names FAULTSIM] set DEFAULT(-prep) "" set DEFAULT(-body) "" set DEFAULT(-test) "" | | | | 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | proc do_faultsim_test {name args} { global FAULTSIM set DEFAULT(-faults) [array names FAULTSIM] set DEFAULT(-prep) "" set DEFAULT(-body) "" set DEFAULT(-test) "" set DEFAULT(-install) "" set DEFAULT(-uninstall) "" fix_testname name array set O [array get DEFAULT] array set O $args foreach o [array names O] { if {[info exists DEFAULT($o)]==0} { error "unknown option: $o" } |
︙ | ︙ |
test/progress.test became a regular file.
︙ | ︙ |
Added test/syscall.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 | # 2011 March 29 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl if {[llength [info commands test_syscall]]==0} { finish_test return } set testprefix syscall #------------------------------------------------------------------------- # Tests for the xSetSystemCall method. # do_test 1.1.1 { list [catch { test_syscall reset open } msg] $msg } {0 {}} do_test 1.1.2 { list [catch { test_syscall reset nosuchcall } msg] $msg } {1 SQLITE_NOTFOUND} do_test 1.1.3 { list [catch { test_syscall reset open } msg] $msg } {0 {}} do_test 1.1.4 { list [catch { test_syscall reset ""} msg] $msg } {1 SQLITE_NOTFOUND} do_test 1.2 { test_syscall reset } {} do_test 1.3.1 { test_syscall install {open getcwd access} } {} do_test 1.3.2 { test_syscall reset } {} #------------------------------------------------------------------------- # Tests for the xGetSystemCall method. # do_test 2.1.1 { test_syscall exists open } 1 do_test 2.1.2 { test_syscall exists nosuchcall } 0 #------------------------------------------------------------------------- # Tests for the xNextSystemCall method. # set syscall_list [list \ open close access getcwd stat fstat ftruncate \ fcntl read pread write pwrite fchmod \ ] if {[test_syscall exists fallocate]} {lappend syscall_list fallocate} do_test 3.1 { test_syscall list } $syscall_list #------------------------------------------------------------------------- # This test verifies that if a call to open() fails and errno is set to # EINTR, the call is retried. If it succeeds, execution continues as if # nothing happened. # test_syscall reset forcedelete test.db2 do_execsql_test 4.1 { CREATE TABLE t1(x, y); INSERT INTO t1 VALUES(1, 2); ATTACH 'test.db2' AS aux; CREATE TABLE aux.t2(x, y); INSERT INTO t2 VALUES(3, 4); } db_save_and_close test_syscall install open foreach jrnl [list wal delete] { for {set i 1} {$i < 20} {incr i} { db_restore_and_reopen test_syscall fault $i 0 test_syscall errno open EINTR do_test 4.2.$jrnl.$i { sqlite3 db test.db execsql { ATTACH 'test.db2' AS aux } execsql "PRAGMA main.journal_mode = $jrnl" execsql "PRAGMA aux.journal_mode = $jrnl" execsql { BEGIN; INSERT INTO t1 VALUES(5, 6); INSERT INTO t2 VALUES(7, 8); COMMIT; } db close sqlite3 db test.db execsql { ATTACH 'test.db2' AS aux } execsql { SELECT * FROM t1; SELECT * FROM t2; } } {1 2 5 6 3 4 7 8} } } #------------------------------------------------------------------------- # This test verifies that closing database handles does not drop locks # held by other database handles in the same process on the same file. # # The os_unix.c module has to take precautions to prevent this as the # close() system call drops locks held by other file-descriptors on the # same file. From the Linux man page: # # close() closes a file descriptor, so that it no longer refers to any file # and may be reused. Any record locks (see fcntl(2)) held on the file it # was associated with, and owned by the process, are removed (regardless # of the file descriptor that was used to obtain the lock). # catch { db close } forcedelete test.db test.db2 do_multiclient_test tn { code1 { sqlite3 dbX1 test.db sqlite3 dbX2 test.db } do_test syscall-5.$tn.1 { sql1 { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); BEGIN; INSERT INTO t1 VALUES(3, 4); } } {} do_test syscall-5.$tn.2 { sql2 { SELECT * FROM t1 } } {1 2} do_test syscall-5.$tn.3 { csql2 { INSERT INTO t1 VALUES(5, 6) } } {1 {database is locked}} do_test syscall-5.$tn.4 { code1 { dbX1 close dbX2 close } } {} do_test syscall-5.$tn.5 { csql2 { INSERT INTO t1 VALUES(5, 6) } } {1 {database is locked}} do_test syscall-5.$tn.6 { sql1 { COMMIT } } {} do_test syscall-5.$tn.7 { csql2 { INSERT INTO t1 VALUES(5, 6) } } {0 {}} } catch {db close} do_test 6.1 { sqlite3 db1 test.db1 sqlite3 db2 test.db2 sqlite3 db3 test.db3 sqlite3 dbM "" db2 close db3 close dbM close db1 close } {} do_test 6.2 { sqlite3 db test.db execsql { PRAGMA temp_store = file; PRAGMA main.cache_size = 10; PRAGMA temp.cache_size = 10; CREATE TABLE temp.tt(a, b); INSERT INTO tt VALUES(randomblob(500), randomblob(600)); INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; INSERT INTO tt SELECT randomblob(500), randomblob(600) FROM tt; } db close } {} finish_test |
Added test/sysfault.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | # 2011 March 28 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl if {[llength [info commands test_syscall]]==0} { finish_test return } set testprefix sysfault set FAULTSIM(vfsfault-transient) [list \ -injectinstall vfsfault_install \ -injectstart vfsfault_injectstart_t \ -injectstop vfsfault_injectstop \ -injecterrlist {} \ -injectuninstall {test_syscall uninstall} \ ] set FAULTSIM(vfsfault-persistent) [list \ -injectinstall vfsfault_install \ -injectstart vfsfault_injectstart_p \ -injectstop vfsfault_injectstop \ -injecterrlist {} \ -injectuninstall {test_syscall uninstall} \ ] proc vfsfault_injectstart_t {iFail} { test_syscall fault $iFail 0 } proc vfsfault_injectstart_p {iFail} { test_syscall fault $iFail 1 } proc vfsfault_injectstop {} { test_syscall fault } faultsim_save_and_close set open_and_write_body { sqlite3 db test.db db eval { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); PRAGMA journal_mode = WAL; INSERT INTO t1 VALUES(3, 4); SELECT * FROM t1; CREATE TEMP TABLE t2(x); INSERT INTO t2 VALUES('y'); } } proc vfsfault_install {} { test_syscall install {open getcwd} } do_faultsim_test 1 -faults vfsfault-* -prep { faultsim_restore } -body $open_and_write_body -test { faultsim_test_result {0 {wal 1 2 3 4}} \ {1 {unable to open database file}} \ {1 {attempt to write a readonly database}} } # Errors in the fstat() function when opening and writing a file. # foreach {tn errno errlist} { 1 ENOMEM {{disk I/O error}} 2 EOVERFLOW {{disk I/O error} {large file support is disabled}} } { proc vfsfault_install {} { test_syscall install fstat } set errs [list] foreach e $errlist { lappend errs [list 1 $e] } do_faultsim_test 1.2.$tn -faults vfsfault-* -prep { faultsim_restore } -body " test_syscall errno fstat $errno $open_and_write_body " -test " faultsim_test_result {0 {wal 1 2 3 4}} $errs " } #------------------------------------------------------------------------- # Check that a single EINTR error does not affect processing. # proc vfsfault_install {} { test_syscall reset test_syscall install {open ftruncate close} } forcedelete test.db test.db2 sqlite3 db test.db do_test 2.setup { execsql { CREATE TABLE t1(a, b, c, PRIMARY KEY(a)); INSERT INTO t1 VALUES('abc', 'def', 'ghi'); ATTACH 'test.db2' AS 'aux'; CREATE TABLE aux.t2(x); INSERT INTO t2 VALUES(1); } faultsim_save_and_close } {} do_faultsim_test 2.1 -faults vfsfault-transient -prep { catch { db close } faultsim_restore } -body { test_syscall errno open EINTR test_syscall errno ftruncate EINTR test_syscall errno close EINTR sqlite3 db test.db set res [db eval { ATTACH 'test.db2' AS 'aux'; SELECT * FROM t1; PRAGMA journal_mode = truncate; BEGIN; INSERT INTO t1 VALUES('jkl', 'mno', 'pqr'); UPDATE t2 SET x = 2; COMMIT; SELECT * FROM t1; SELECT * FROM t2; }] db close set res } -test { faultsim_test_result {0 {abc def ghi truncate abc def ghi jkl mno pqr 2}} } do_faultsim_test 2.2 -faults vfsfault-* -prep { catch { db close } faultsim_restore } -body { sqlite3 db test.db set res [db eval { ATTACH 'test.db2' AS 'aux'; SELECT * FROM t1; PRAGMA journal_mode = truncate; BEGIN; INSERT INTO t1 VALUES('jkl', 'mno', 'pqr'); UPDATE t2 SET x = 2; COMMIT; SELECT * FROM t1; SELECT * FROM t2; }] db close set res } -test { faultsim_test_result {0 {abc def ghi truncate abc def ghi jkl mno pqr 2}} \ {1 {unable to open database file}} \ {1 {unable to open database: test.db2}} \ {1 {attempt to write a readonly database}} \ {1 {disk I/O error}} } #------------------------------------------------------------------------- # finish_test |
Changes to test/tableapi.test.
︙ | ︙ | |||
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 | } {0 2 100 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 x33 x34 x35 x36 x37 x38 x39 x40 x41 x42 x43 x44 x45 x46 x47 x48 x49 x50 x51 x52 x53 x54 x55 x56 x57 x58 x59 x60 x61 x62 x63 x64 x65 x66 x67 x68 x69 x70 x71 x72 x73 x74 x75 x76 x77 x78 x79 x80 x81 x82 x83 x84 x85 x86 x87 x88 x89 x90 x91 x92 x93 x94 x95 x96 x97 x98 x99 x100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100} ifcapable schema_pragmas { do_test tableapi-6.1 { sqlite3_get_table_printf $::dbx {PRAGMA user_version} {} } {0 1 1 user_version 0} } ifcapable memdebug { do_malloc_test tableapi-7 -sqlprep { DROP TABLE IF EXISTS t1; CREATE TABLE t1(a,b); INSERT INTO t1 VALUES(1,2); INSERT INTO t1 VALUES(3,4); INSERT INTO t1 SELECT a+4, b+4 FROM t1; INSERT INTO t1 SELECT a+8, b+8 FROM t1; } -tclbody { set r [sqlite3_get_table_printf db {SELECT rowid, a, b FROM t1} {}] if {[llength $r]<26} {error "out of memory"} } } | > > > > > > > > < < < < | 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 | } {0 2 100 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 x33 x34 x35 x36 x37 x38 x39 x40 x41 x42 x43 x44 x45 x46 x47 x48 x49 x50 x51 x52 x53 x54 x55 x56 x57 x58 x59 x60 x61 x62 x63 x64 x65 x66 x67 x68 x69 x70 x71 x72 x73 x74 x75 x76 x77 x78 x79 x80 x81 x82 x83 x84 x85 x86 x87 x88 x89 x90 x91 x92 x93 x94 x95 x96 x97 x98 x99 x100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100} ifcapable schema_pragmas { do_test tableapi-6.1 { sqlite3_get_table_printf $::dbx {PRAGMA user_version} {} } {0 1 1 user_version 0} } # do_malloc_test closes and deletes the usual db connections and files on # each iteration. $::dbx is a seperate connection, and on Windows, will # cause the file deletion of test.db to fail, so we move the close of $::dbx # up to here before the do_malloc_test. do_test tableapi-99.0 { sqlite3_close $::dbx } {SQLITE_OK} ifcapable memdebug { do_malloc_test tableapi-7 -sqlprep { DROP TABLE IF EXISTS t1; CREATE TABLE t1(a,b); INSERT INTO t1 VALUES(1,2); INSERT INTO t1 VALUES(3,4); INSERT INTO t1 SELECT a+4, b+4 FROM t1; INSERT INTO t1 SELECT a+8, b+8 FROM t1; } -tclbody { set r [sqlite3_get_table_printf db {SELECT rowid, a, b FROM t1} {}] if {[llength $r]<26} {error "out of memory"} } } finish_test |