Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Merge recent enhancements from trunk. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | bind-pointer |
Files: | files | file ages | folders |
SHA3-256: |
73d0fc027ddcc24e55cdc8c54443a960 |
User & Date: | drh 2017-07-07 14:26:43.473 |
Context
2017-07-13
| ||
17:34 | Merge the latest changes from trunk. (check-in: a54be6e041 user: drh tags: bind-pointer) | |
2017-07-07
| ||
14:26 | Merge recent enhancements from trunk. (check-in: 73d0fc027d user: drh tags: bind-pointer) | |
13:59 | Exploit the fact that Expr.pRight and Expr.x are never used at the same time for a small performance gain. (check-in: aacbb9a461 user: drh tags: trunk) | |
2017-06-30
| ||
23:46 | Update the carray() and remember() extension functions so that they user the new sqlite3_value_pointer() interface. (check-in: a99fa94db7 user: drh tags: bind-pointer) | |
Changes
Changes to ext/fts3/fts3.c.
︙ | ︙ | |||
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 | sqlite3_reset(pCsr->pStmt); pCsr->pStmt = 0; } pCsr->bSeekStmt = 0; } sqlite3_finalize(pCsr->pStmt); } /* ** Close the cursor. For additional information see the documentation ** on the xClose method of the virtual table interface. */ static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){ Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); | > > > > > > > > > > > > > | < < < < | 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 | sqlite3_reset(pCsr->pStmt); pCsr->pStmt = 0; } pCsr->bSeekStmt = 0; } sqlite3_finalize(pCsr->pStmt); } /* ** Free all resources currently held by the cursor passed as the only ** argument. */ static void fts3ClearCursor(Fts3Cursor *pCsr){ fts3CursorFinalizeStmt(pCsr); sqlite3Fts3FreeDeferredTokens(pCsr); sqlite3_free(pCsr->aDoclist); sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); sqlite3Fts3ExprFree(pCsr->pExpr); memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor)); } /* ** Close the cursor. For additional information see the documentation ** on the xClose method of the virtual table interface. */ static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){ Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); fts3ClearCursor(pCsr); assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); sqlite3_free(pCsr); return SQLITE_OK; } /* ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then |
︙ | ︙ | |||
3215 3216 3217 3218 3219 3220 3221 | if( eSearch!=FTS3_FULLSCAN_SEARCH ) pCons = apVal[iIdx++]; if( idxNum & FTS3_HAVE_LANGID ) pLangid = apVal[iIdx++]; if( idxNum & FTS3_HAVE_DOCID_GE ) pDocidGe = apVal[iIdx++]; if( idxNum & FTS3_HAVE_DOCID_LE ) pDocidLe = apVal[iIdx++]; assert( iIdx==nVal ); /* In case the cursor has been used before, clear it now. */ | | < < < < | 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 | if( eSearch!=FTS3_FULLSCAN_SEARCH ) pCons = apVal[iIdx++]; if( idxNum & FTS3_HAVE_LANGID ) pLangid = apVal[iIdx++]; if( idxNum & FTS3_HAVE_DOCID_GE ) pDocidGe = apVal[iIdx++]; if( idxNum & FTS3_HAVE_DOCID_LE ) pDocidLe = apVal[iIdx++]; assert( iIdx==nVal ); /* In case the cursor has been used before, clear it now. */ fts3ClearCursor(pCsr); /* Set the lower and upper bounds on docids to return */ pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64); pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64); if( idxStr ){ pCsr->bDesc = (idxStr[0]=='D'); |
︙ | ︙ | |||
3298 3299 3300 3301 3302 3303 3304 | } /* ** This is the xEof method of the virtual table. SQLite calls this ** routine to find out if it has reached the end of a result set. */ static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){ | | > > > > > | 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 | } /* ** This is the xEof method of the virtual table. SQLite calls this ** routine to find out if it has reached the end of a result set. */ static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){ Fts3Cursor *pCsr = (Fts3Cursor*)pCursor; if( pCsr->isEof ){ fts3ClearCursor(pCsr); pCsr->isEof = 1; } return pCsr->isEof; } /* ** This is the xRowid method. The SQLite core calls this routine to ** retrieve the rowid for the current row of the result set. fts3 ** exposes %_content.docid as the rowid for the virtual table. The ** rowid should be written to *pRowid. |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest.h.
︙ | ︙ | |||
228 229 230 231 232 233 234 235 236 237 238 239 240 241 | char *testDatasourceName(const DatasourceDefn *); Datasource *testDatasourceNew(const DatasourceDefn *); void testDatasourceFree(Datasource *); void testDatasourceEntry(Datasource *, int, void **, int *, void **, int *); /* End of test_datasource.c interface. *************************************************************************/ void testWriteDatasource(TestDb *, Datasource *, int, int *); void testWriteDatasourceRange(TestDb *, Datasource *, int, int, int *); void testDeleteDatasource(TestDb *, Datasource *, int, int *); void testDeleteDatasourceRange(TestDb *, Datasource *, int, int, int *); | > > > > > > | 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 | char *testDatasourceName(const DatasourceDefn *); Datasource *testDatasourceNew(const DatasourceDefn *); void testDatasourceFree(Datasource *); void testDatasourceEntry(Datasource *, int, void **, int *, void **, int *); /* End of test_datasource.c interface. *************************************************************************/ void testDatasourceFetch( TestDb *pDb, /* Database handle */ Datasource *pData, int iKey, int *pRc /* IN/OUT: Error code */ ); void testWriteDatasource(TestDb *, Datasource *, int, int *); void testWriteDatasourceRange(TestDb *, Datasource *, int, int, int *); void testDeleteDatasource(TestDb *, Datasource *, int, int *); void testDeleteDatasourceRange(TestDb *, Datasource *, int, int, int *); |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest1.c.
︙ | ︙ | |||
77 78 79 80 81 82 83 | int nIter; /* Total number of iterations to run */ }; /* ** Generate a unique name for the test case pTest with database system ** zSystem. */ | | | | | 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | int nIter; /* Total number of iterations to run */ }; /* ** Generate a unique name for the test case pTest with database system ** zSystem. */ static char *getName(const char *zSystem, int bRecover, Datatest1 *pTest){ char *zRet; char *zData; zData = testDatasourceName(&pTest->defn); zRet = testMallocPrintf("data.%s.%s.rec=%d.%d.%d", zSystem, zData, bRecover, pTest->nRow, pTest->nVerify ); testFree(zData); return zRet; } int testControlDb(TestDb **ppDb){ #ifdef HAVE_KYOTOCABINET |
︙ | ︙ | |||
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 | static void printScanCb( void *pCtx, void *pKey, int nKey, void *pVal, int nVal ){ printf("%s\n", (char *)pKey); fflush(stdout); } #endif static void doDataTest1( const char *zSystem, /* Database system to test */ Datatest1 *p, /* Structure containing test parameters */ int *pRc /* OUT: Error code */ ){ int i; int iDot; int rc = LSM_OK; Datasource *pData; | > > > > > > > > > > > > > | 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 | static void printScanCb( void *pCtx, void *pKey, int nKey, void *pVal, int nVal ){ printf("%s\n", (char *)pKey); fflush(stdout); } #endif void testReopenRecover(TestDb **ppDb, int *pRc){ if( *pRc==0 ){ const char *zLib = tdb_library_name(*ppDb); const char *zDflt = tdb_default_db(zLib); testCopyLsmdb(zDflt, "bak.db"); testClose(ppDb); testCopyLsmdb("bak.db", zDflt); *pRc = tdb_open(zLib, 0, 0, ppDb); } } static void doDataTest1( const char *zSystem, /* Database system to test */ int bRecover, Datatest1 *p, /* Structure containing test parameters */ int *pRc /* OUT: Error code */ ){ int i; int iDot; int rc = LSM_OK; Datasource *pData; |
︙ | ︙ | |||
273 274 275 276 277 278 279 | /* Insert some data */ testWriteDatasourceRange(pDb, pData, i, p->nVerify, &rc); i += p->nVerify; /* Check that the db content is correct. */ testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc); | > | > | > > > > | > | 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 | /* Insert some data */ testWriteDatasourceRange(pDb, pData, i, p->nVerify, &rc); i += p->nVerify; /* Check that the db content is correct. */ testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc); if( bRecover ){ testReopenRecover(&pDb, &rc); }else{ testReopen(&pDb, &rc); } /* Check that the db content is still correct. */ testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc); /* Update the progress dots... */ testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot); } i = 0; iDot = 0; while( rc==LSM_OK && i<p->nRow ){ /* Delete some entries */ testDeleteDatasourceRange(pDb, pData, i, p->nVerify, &rc); i += p->nVerify; /* Check that the db content is correct. */ testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc); /* Close and reopen the database. */ if( bRecover ){ testReopenRecover(&pDb, &rc); }else{ testReopen(&pDb, &rc); } /* Check that the db content is still correct. */ testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc); /* Update the progress dots... */ testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot); } |
︙ | ︙ | |||
335 336 337 338 339 340 341 342 | { {DATA_SEQUENTIAL, 5,10, 1000,2000}, 1000, 250, 1000, 1}, { {DATA_SEQUENTIAL, 5,100, 10000,20000}, 100, 25, 100, 1}, { {DATA_RANDOM, 10,10, 100,100}, 100000, 1000, 100, 0}, { {DATA_SEQUENTIAL, 10,10, 100,100}, 100000, 1000, 100, 0}, }; int i; | > > > | | | | | | > | 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 | { {DATA_SEQUENTIAL, 5,10, 1000,2000}, 1000, 250, 1000, 1}, { {DATA_SEQUENTIAL, 5,100, 10000,20000}, 100, 25, 100, 1}, { {DATA_RANDOM, 10,10, 100,100}, 100000, 1000, 100, 0}, { {DATA_SEQUENTIAL, 10,10, 100,100}, 100000, 1000, 100, 0}, }; int i; int bRecover; for(bRecover=0; bRecover<2; bRecover++){ if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break; for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){ char *zName = getName(zSystem, bRecover, &aTest[i]); if( testCaseBegin(pRc, zPattern, "%s", zName) ){ doDataTest1(zSystem, bRecover, &aTest[i], pRc); } testFree(zName); } } } void testCompareDb( Datasource *pData, int nData, int iSeed, |
︙ | ︙ | |||
392 393 394 395 396 397 398 399 400 401 402 403 404 405 | testDatasourceEntry(pData, i, &pKey, &nKey, 0, 0); testFetchCompare(pControl, pDb, pKey, nKey, pRc); } } static void doDataTest2( const char *zSystem, /* Database system to test */ Datatest2 *p, /* Structure containing test parameters */ int *pRc /* OUT: Error code */ ){ TestDb *pDb; TestDb *pControl; Datasource *pData; int i; | > | 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 | testDatasourceEntry(pData, i, &pKey, &nKey, 0, 0); testFetchCompare(pControl, pDb, pKey, nKey, pRc); } } static void doDataTest2( const char *zSystem, /* Database system to test */ int bRecover, Datatest2 *p, /* Structure containing test parameters */ int *pRc /* OUT: Error code */ ){ TestDb *pDb; TestDb *pControl; Datasource *pData; int i; |
︙ | ︙ | |||
433 434 435 436 437 438 439 | testDatasourceEntry(pData, i+2000000, &pKey2, &nKey2, 0, 0); testDeleteRange(pDb, pKey1, nKey1, pKey2, nKey2, &rc); testDeleteRange(pControl, pKey1, nKey1, pKey2, nKey2, &rc); testFree(pKey1); testCompareDb(pData, nRange, i, pControl, pDb, &rc); | > > > | > | | | > > > | | | | | | > | 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 | testDatasourceEntry(pData, i+2000000, &pKey2, &nKey2, 0, 0); testDeleteRange(pDb, pKey1, nKey1, pKey2, nKey2, &rc); testDeleteRange(pControl, pKey1, nKey1, pKey2, nKey2, &rc); testFree(pKey1); testCompareDb(pData, nRange, i, pControl, pDb, &rc); if( bRecover ){ testReopenRecover(&pDb, &rc); }else{ testReopen(&pDb, &rc); } testCompareDb(pData, nRange, i, pControl, pDb, &rc); /* Update the progress dots... */ testCaseProgress(i, p->nIter, testCaseNDot(), &iDot); } testClose(&pDb); testClose(&pControl); testDatasourceFree(pData); testCaseFinish(rc); *pRc = rc; } static char *getName2(const char *zSystem, int bRecover, Datatest2 *pTest){ char *zRet; char *zData; zData = testDatasourceName(&pTest->defn); zRet = testMallocPrintf("data2.%s.%s.rec=%d.%d.%d.%d", zSystem, zData, bRecover, pTest->nRange, pTest->nWrite, pTest->nIter ); testFree(zData); return zRet; } void test_data_2( const char *zSystem, /* Database system name */ const char *zPattern, /* Run test cases that match this pattern */ int *pRc /* IN/OUT: Error code */ ){ Datatest2 aTest[] = { /* defn, nRange, nWrite, nIter */ { {DATA_RANDOM, 20,25, 100,200}, 10000, 10, 50 }, { {DATA_RANDOM, 20,25, 100,200}, 10000, 200, 50 }, { {DATA_RANDOM, 20,25, 100,200}, 100, 10, 1000 }, { {DATA_RANDOM, 20,25, 100,200}, 100, 200, 50 }, }; int i; int bRecover; for(bRecover=0; bRecover<2; bRecover++){ if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break; for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){ char *zName = getName2(zSystem, bRecover, &aTest[i]); if( testCaseBegin(pRc, zPattern, "%s", zName) ){ doDataTest2(zSystem, bRecover, &aTest[i], pRc); } testFree(zName); } } } /************************************************************************* ** Test case data3.* */ |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest2.c.
︙ | ︙ | |||
238 239 240 241 242 243 244 245 246 247 248 249 250 251 | *pRc = 1; test_failed(); } } } } static void testCompareCksumBtdb( const char *zFile, /* Path to LSM database */ const char *zExpect1, /* Expected checksum 1 */ const char *zExpect2, /* Expected checksum 2 (or NULL) */ int *pRc /* IN/OUT: Test case error code */ ){ if( *pRc==0 ){ | > | 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 | *pRc = 1; test_failed(); } } } } #if 0 /* not used */ static void testCompareCksumBtdb( const char *zFile, /* Path to LSM database */ const char *zExpect1, /* Expected checksum 1 */ const char *zExpect2, /* Expected checksum 2 (or NULL) */ int *pRc /* IN/OUT: Test case error code */ ){ if( *pRc==0 ){ |
︙ | ︙ | |||
274 275 276 277 278 279 280 281 282 283 284 285 286 287 | } *pRc = 1; test_failed(); } } } } /* Above this point are reusable test routines. Not clear that they ** should really be in this file. *************************************************************************/ /* ** This test verifies that if a system crash occurs while doing merge work | > | 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 | } *pRc = 1; test_failed(); } } } } #endif /* not used */ /* Above this point are reusable test routines. Not clear that they ** should really be in this file. *************************************************************************/ /* ** This test verifies that if a system crash occurs while doing merge work |
︙ | ︙ | |||
480 481 482 483 484 485 486 | struct Test *p = &aTest[i]; if( testCaseBegin(pRc, zPattern, "%s", p->zTest) ){ p->x(p->bCompress, pRc); testCaseFinish(*pRc); } } } | < | 482 483 484 485 486 487 488 | struct Test *p = &aTest[i]; if( testCaseBegin(pRc, zPattern, "%s", p->zTest) ){ p->x(p->bCompress, pRc); testCaseFinish(*pRc); } } } |
Changes to ext/lsm1/lsm-test/lsmtest9.c.
︙ | ︙ | |||
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | lsm_db *db = 0; TestDb *pDb; TestDb *pControl; Datasource *pData; int i; int rc = 0; int iDot = 0; int nRecOn3 = (p->nRec / 3); int iData = 0; /* Start the test case, open a database and allocate the datasource. */ rc = testControlDb(&pControl); pDb = testOpen(zSystem, 1, &rc); pData = testDatasourceNew(&p->defn); | > | > > > > | 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 | lsm_db *db = 0; TestDb *pDb; TestDb *pControl; Datasource *pData; int i; int rc = 0; int iDot = 0; int bMultiThreaded = 0; /* True for MT LSM database */ int nRecOn3 = (p->nRec / 3); int iData = 0; /* Start the test case, open a database and allocate the datasource. */ rc = testControlDb(&pControl); pDb = testOpen(zSystem, 1, &rc); pData = testDatasourceNew(&p->defn); if( rc==0 ){ db = tdb_lsm(pDb); bMultiThreaded = tdb_lsm_multithread(pDb); } testWriteDatasourceRange(pControl, pData, iData, nRecOn3*3, &rc); testWriteDatasourceRange(pDb, pData, iData, nRecOn3*3, &rc); for(i=0; rc==0 && i<p->nRepeat; i++){ testDeleteDatasourceRange(pControl, pData, iData, nRecOn3*2, &rc); testDeleteDatasourceRange(pDb, pData, iData, nRecOn3*2, &rc); if( db ){ int nDone; #if 0 fprintf(stderr, "lsm_work() start...\n"); fflush(stderr); #endif do { nDone = 0; rc = lsm_work(db, 1, (1<<30), &nDone); }while( rc==0 && nDone>0 ); if( bMultiThreaded && rc==LSM_BUSY ) rc = LSM_OK; #if 0 fprintf(stderr, "lsm_work() done...\n"); fflush(stderr); #endif } if( i+1<p->nRepeat ){ iData += (nRecOn3*2); |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest_main.c.
︙ | ︙ | |||
22 23 24 25 26 27 28 | return; } #define testSetError(rc) testSetErrorFunc(rc, pRc, __FILE__, __LINE__) static void testSetErrorFunc(int rc, int *pRc, const char *zFile, int iLine){ if( rc ){ *pRc = rc; | | | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | return; } #define testSetError(rc) testSetErrorFunc(rc, pRc, __FILE__, __LINE__) static void testSetErrorFunc(int rc, int *pRc, const char *zFile, int iLine){ if( rc ){ *pRc = rc; fprintf(stderr, "FAILED (%s:%d) rc=%d ", zFile, iLine, rc); test_failed(); } } static int lsm_memcmp(u8 *a, u8 *b, int c){ int i; for(i=0; i<c; i++){ |
︙ | ︙ | |||
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 | void testCommit(TestDb *pDb, int iTrans, int *pRc){ if( *pRc==0 ){ int rc; rc = tdb_commit(pDb, iTrans); testSetError(rc); } } static void testRollback(TestDb *pDb, int iTrans, int *pRc){ if( *pRc==0 ){ int rc; rc = tdb_rollback(pDb, iTrans); testSetError(rc); } } void testWriteStr( TestDb *pDb, /* Database handle */ const char *zKey, /* Key to query database for */ const char *zVal, /* Value to write */ int *pRc /* IN/OUT: Error code */ ){ int nVal = (zVal ? strlen(zVal) : 0); testWrite(pDb, (void *)zKey, strlen(zKey), (void *)zVal, nVal, pRc); } static void testDeleteStr(TestDb *pDb, const char *zKey, int *pRc){ testDelete(pDb, (void *)zKey, strlen(zKey), pRc); } | > > > | | 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 | void testCommit(TestDb *pDb, int iTrans, int *pRc){ if( *pRc==0 ){ int rc; rc = tdb_commit(pDb, iTrans); testSetError(rc); } } #if 0 /* unused */ static void testRollback(TestDb *pDb, int iTrans, int *pRc){ if( *pRc==0 ){ int rc; rc = tdb_rollback(pDb, iTrans); testSetError(rc); } } #endif void testWriteStr( TestDb *pDb, /* Database handle */ const char *zKey, /* Key to query database for */ const char *zVal, /* Value to write */ int *pRc /* IN/OUT: Error code */ ){ int nVal = (zVal ? strlen(zVal) : 0); testWrite(pDb, (void *)zKey, strlen(zKey), (void *)zVal, nVal, pRc); } #if 0 /* unused */ static void testDeleteStr(TestDb *pDb, const char *zKey, int *pRc){ testDelete(pDb, (void *)zKey, strlen(zKey), pRc); } #endif void testFetchStr( TestDb *pDb, /* Database handle */ const char *zKey, /* Key to query database for */ const char *zVal, /* Value to write */ int *pRc /* IN/OUT: Error code */ ){ int nVal = (zVal ? strlen(zVal) : 0); |
︙ | ︙ | |||
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 | zLib = tdb_library_name(*ppDb); testClose(ppDb); *pRc = tdb_open(zLib, 0, 0, ppDb); } } static void testSystemSelect(const char *zSys, int *piSel, int *pRc){ if( *pRc==0 ){ struct SysName { const char *zName; } *aName; int nSys; int i; for(nSys=0; tdb_system_name(nSys); nSys++); aName = malloc(sizeof(struct SysName) * (nSys+1)); for(i=0; i<=nSys; i++){ aName[i].zName = tdb_system_name(i); } *pRc = testArgSelect(aName, "db", zSys, piSel); free(aName); } } char *testMallocVPrintf(const char *zFormat, va_list ap){ int nByte; va_list copy; char *zRet; __va_copy(copy, ap); | > > | 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 | zLib = tdb_library_name(*ppDb); testClose(ppDb); *pRc = tdb_open(zLib, 0, 0, ppDb); } } #if 0 /* unused */ static void testSystemSelect(const char *zSys, int *piSel, int *pRc){ if( *pRc==0 ){ struct SysName { const char *zName; } *aName; int nSys; int i; for(nSys=0; tdb_system_name(nSys); nSys++); aName = malloc(sizeof(struct SysName) * (nSys+1)); for(i=0; i<=nSys; i++){ aName[i].zName = tdb_system_name(i); } *pRc = testArgSelect(aName, "db", zSys, piSel); free(aName); } } #endif char *testMallocVPrintf(const char *zFormat, va_list ap){ int nByte; va_list copy; char *zRet; __va_copy(copy, ap); |
︙ | ︙ | |||
537 538 539 540 541 542 543 544 545 546 547 548 549 550 | static void flushPrev(FILE *pOut){ if( prev.nData ){ fprintf(pOut, "w %s %lld %d %d\n", "d", prev.iOff, prev.nData, prev.nUs); prev.nData = 0; } } static void do_speed_write_hook2( void *pCtx, int bLog, i64 iOff, int nData, int nUs ){ | > | 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 | static void flushPrev(FILE *pOut){ if( prev.nData ){ fprintf(pOut, "w %s %lld %d %d\n", "d", prev.iOff, prev.nData, prev.nUs); prev.nData = 0; } } #if 0 /* unused */ static void do_speed_write_hook2( void *pCtx, int bLog, i64 iOff, int nData, int nUs ){ |
︙ | ︙ | |||
561 562 563 564 565 566 567 568 569 570 571 572 573 574 | }else{ prev.iOff = iOff; prev.nData = nData; prev.nUs = nUs; } } } #define ST_REPEAT 0 #define ST_WRITE 1 #define ST_PAUSE 2 #define ST_FETCH 3 #define ST_SCAN 4 #define ST_NSCAN 5 | > | 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 | }else{ prev.iOff = iOff; prev.nData = nData; prev.nUs = nUs; } } } #endif #define ST_REPEAT 0 #define ST_WRITE 1 #define ST_PAUSE 2 #define ST_FETCH 3 #define ST_SCAN 4 #define ST_NSCAN 5 |
︙ | ︙ | |||
658 659 660 661 662 663 664 | if( i+1==nArg ){ testPrintError("option %s requires an argument\n", aOpt[iSel].zOpt); return 1; } if( aOpt[iSel].eVal>=0 ){ aParam[aOpt[iSel].eVal] = atoi(azArg[i+1]); }else{ | < | 665 666 667 668 669 670 671 672 673 674 675 676 677 678 | if( i+1==nArg ){ testPrintError("option %s requires an argument\n", aOpt[iSel].zOpt); return 1; } if( aOpt[iSel].eVal>=0 ){ aParam[aOpt[iSel].eVal] = atoi(azArg[i+1]); }else{ zSystem = azArg[i+1]; bLsm = 0; #if 0 for(j=0; zSystem[j]; j++){ if( zSystem[j]=='=' ) bLsm = 1; } #endif |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest_mem.c.
︙ | ︙ | |||
322 323 324 325 326 327 328 | LsmMutex *p = (LsmMutex *)pTm->pMutex; pTm->xFree(p); } static void *tmLsmMalloc(int n){ return malloc(n); } static void tmLsmFree(void *ptr){ free(ptr); } static void *tmLsmRealloc(void *ptr, int n){ return realloc(ptr, n); } | | | | 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 | LsmMutex *p = (LsmMutex *)pTm->pMutex; pTm->xFree(p); } static void *tmLsmMalloc(int n){ return malloc(n); } static void tmLsmFree(void *ptr){ free(ptr); } static void *tmLsmRealloc(void *ptr, int n){ return realloc(ptr, n); } static void *tmLsmEnvMalloc(lsm_env *p, size_t n){ return tmMalloc((TmGlobal *)(p->pMemCtx), n); } static void tmLsmEnvFree(lsm_env *p, void *ptr){ tmFree((TmGlobal *)(p->pMemCtx), ptr); } static void *tmLsmEnvRealloc(lsm_env *p, void *ptr, size_t n){ return tmRealloc((TmGlobal *)(p->pMemCtx), ptr, n); } void testMallocInstall(lsm_env *pEnv){ TmGlobal *pGlobal; LsmMutex *pMutex; assert( pEnv->pMemCtx==0 ); |
︙ | ︙ | |||
366 367 368 369 370 371 372 | pEnv->xFree = tmLsmEnvFree; } void testMallocUninstall(lsm_env *pEnv){ TmGlobal *p = (TmGlobal *)pEnv->pMemCtx; pEnv->pMemCtx = 0; if( p ){ | | | | | 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 | pEnv->xFree = tmLsmEnvFree; } void testMallocUninstall(lsm_env *pEnv){ TmGlobal *p = (TmGlobal *)pEnv->pMemCtx; pEnv->pMemCtx = 0; if( p ){ pEnv->xMalloc = p->xSaveMalloc; pEnv->xRealloc = p->xSaveRealloc; pEnv->xFree = p->xSaveFree; p->xDelMutex(p); tmLsmFree(p); } } void testMallocCheck( lsm_env *pEnv, |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest_tdb.c.
︙ | ︙ | |||
740 741 742 743 744 745 746 747 748 749 750 751 752 753 | #endif }; const char *tdb_system_name(int i){ if( i<0 || i>=ArraySize(aLib) ) return 0; return aLib[i].zName; } int tdb_open(const char *zLib, const char *zDb, int bClear, TestDb **ppDb){ int i; int rc = 1; const char *zSpec = 0; int nLib = 0; | > > > > > > > > | 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 | #endif }; const char *tdb_system_name(int i){ if( i<0 || i>=ArraySize(aLib) ) return 0; return aLib[i].zName; } const char *tdb_default_db(const char *zSys){ int i; for(i=0; i<ArraySize(aLib); i++){ if( strcmp(aLib[i].zName, zSys)==0 ) return aLib[i].zDefaultDb; } return 0; } int tdb_open(const char *zLib, const char *zDb, int bClear, TestDb **ppDb){ int i; int rc = 1; const char *zSpec = 0; int nLib = 0; |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest_tdb.h.
︙ | ︙ | |||
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | int bReverse, /* True to scan in reverse order */ void *pKey1, int nKey1, /* Start of search */ void *pKey2, int nKey2, /* End of search */ void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal) ); const char *tdb_system_name(int i); int tdb_lsm_open(const char *zCfg, const char *zDb, int bClear, TestDb **ppDb); /* ** If the TestDb handle passed as an argument is a wrapper around an LSM ** database, return the LSM handle. Otherwise, if the argument is some other ** database system, return NULL. */ lsm_db *tdb_lsm(TestDb *pDb); /* ** Return a pointer to the lsm_env object used by all lsm database ** connections initialized as a copy of the object returned by ** lsm_default_env(). It may be modified (e.g. to override functions) ** if the caller can guarantee that it is not already in use. */ lsm_env *tdb_lsm_env(void); | > > > > > > > | 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 | int bReverse, /* True to scan in reverse order */ void *pKey1, int nKey1, /* Start of search */ void *pKey2, int nKey2, /* End of search */ void (*xCallback)(void *pCtx, void *pKey, int nKey, void *pVal, int nVal) ); const char *tdb_system_name(int i); const char *tdb_default_db(const char *zSys); int tdb_lsm_open(const char *zCfg, const char *zDb, int bClear, TestDb **ppDb); /* ** If the TestDb handle passed as an argument is a wrapper around an LSM ** database, return the LSM handle. Otherwise, if the argument is some other ** database system, return NULL. */ lsm_db *tdb_lsm(TestDb *pDb); /* ** Return true if the db passed as an argument is a multi-threaded LSM ** connection. */ int tdb_lsm_multithread(TestDb *pDb); /* ** Return a pointer to the lsm_env object used by all lsm database ** connections initialized as a copy of the object returned by ** lsm_default_env(). It may be modified (e.g. to override functions) ** if the caller can guarantee that it is not already in use. */ lsm_env *tdb_lsm_env(void); |
︙ | ︙ |
Changes to ext/lsm1/lsm-test/lsmtest_tdb3.c.
︙ | ︙ | |||
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 | lsm_db *tdb_lsm(TestDb *pDb){ if( pDb->pMethods->xClose==test_lsm_close ){ return ((LsmDb *)pDb)->db; } return 0; } void tdb_lsm_enable_log(TestDb *pDb, int bEnable){ lsm_db *db = tdb_lsm(pDb); if( db ){ lsm_config_log(db, (bEnable ? xLog : 0), (void *)"client"); } } | > > > > > > > > | 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 | lsm_db *tdb_lsm(TestDb *pDb){ if( pDb->pMethods->xClose==test_lsm_close ){ return ((LsmDb *)pDb)->db; } return 0; } int tdb_lsm_multithread(TestDb *pDb){ int ret = 0; if( tdb_lsm(pDb) ){ ret = ((LsmDb*)pDb)->eMode!=LSMTEST_MODE_SINGLETHREAD; } return ret; } void tdb_lsm_enable_log(TestDb *pDb, int bEnable){ lsm_db *db = tdb_lsm(pDb); if( db ){ lsm_config_log(db, (bEnable ? xLog : 0), (void *)"client"); } } |
︙ | ︙ |
Changes to ext/lsm1/lsmInt.h.
︙ | ︙ | |||
860 861 862 863 864 865 866 | void lsmLogMessage(lsm_db *, int, const char *, ...); int lsmInfoFreelist(lsm_db *pDb, char **pzOut); /* ** Functions from file "lsm_log.c". */ int lsmLogBegin(lsm_db *pDb); | | > > > > | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 | void lsmLogMessage(lsm_db *, int, const char *, ...); int lsmInfoFreelist(lsm_db *pDb, char **pzOut); /* ** Functions from file "lsm_log.c". */ int lsmLogBegin(lsm_db *pDb); int lsmLogWrite(lsm_db *, int, void *, int, void *, int); int lsmLogCommit(lsm_db *); void lsmLogEnd(lsm_db *pDb, int bCommit); void lsmLogTell(lsm_db *, LogMark *); void lsmLogSeek(lsm_db *, LogMark *); void lsmLogClose(lsm_db *); int lsmLogRecover(lsm_db *); int lsmInfoLogStructure(lsm_db *pDb, char **pzVal); /* Valid values for the second argument to lsmLogWrite(). */ #define LSM_WRITE 0x06 #define LSM_DELETE 0x08 #define LSM_DRANGE 0x0A /************************************************************************** ** Functions from file "lsm_shared.c". */ int lsmDbDatabaseConnect(lsm_db*, const char *); void lsmDbDatabaseRelease(lsm_db *); |
︙ | ︙ |
Changes to ext/lsm1/lsm_ckpt.c.
︙ | ︙ | |||
1089 1090 1091 1092 1093 1094 1095 | assert( n<=LSM_META_RW_PAGE_SIZE ); memcpy(pShm->aSnap2, p, n); lsmShmBarrier(pDb); memcpy(pShm->aSnap1, p, n); lsmFree(pDb->pEnv, p); | | | 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 | assert( n<=LSM_META_RW_PAGE_SIZE ); memcpy(pShm->aSnap2, p, n); lsmShmBarrier(pDb); memcpy(pShm->aSnap1, p, n); lsmFree(pDb->pEnv, p); /* assert( lsmFsIntegrityCheck(pDb) ); */ return LSM_OK; } /* ** This function is used to determine the snapshot-id of the most recently ** checkpointed snapshot. Variable ShmHeader.iMetaPage indicates which of ** the two meta-pages said snapshot resides on (if any). |
︙ | ︙ |
Changes to ext/lsm1/lsm_log.c.
︙ | ︙ | |||
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | #define LSM_LOG_PAD1 0x01 #define LSM_LOG_PAD2 0x02 #define LSM_LOG_COMMIT 0x03 #define LSM_LOG_JUMP 0x04 #define LSM_LOG_WRITE 0x06 #define LSM_LOG_WRITE_CKSUM 0x07 #define LSM_LOG_DELETE 0x08 #define LSM_LOG_DELETE_CKSUM 0x09 /* Require a checksum every 32KB. */ #define LSM_CKSUM_MAXDATA (32*1024) /* Do not wrap a log file smaller than this in bytes. */ #define LSM_MIN_LOGWRAP (128*1024) | > > > > | 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | #define LSM_LOG_PAD1 0x01 #define LSM_LOG_PAD2 0x02 #define LSM_LOG_COMMIT 0x03 #define LSM_LOG_JUMP 0x04 #define LSM_LOG_WRITE 0x06 #define LSM_LOG_WRITE_CKSUM 0x07 #define LSM_LOG_DELETE 0x08 #define LSM_LOG_DELETE_CKSUM 0x09 #define LSM_LOG_DRANGE 0x0A #define LSM_LOG_DRANGE_CKSUM 0x0B /* Require a checksum every 32KB. */ #define LSM_CKSUM_MAXDATA (32*1024) /* Do not wrap a log file smaller than this in bytes. */ #define LSM_MIN_LOGWRAP (128*1024) |
︙ | ︙ | |||
369 370 371 372 373 374 375 376 377 378 379 380 381 382 | rc = lsmFsOpenLog(pDb, 0); if( pDb->pLogWriter==0 ){ pNew = lsmMallocZeroRc(pDb->pEnv, sizeof(LogWriter), &rc); if( pNew ){ lsmStringInit(&pNew->buf, pDb->pEnv); rc = lsmStringExtend(&pNew->buf, 2); } }else{ pNew = pDb->pLogWriter; assert( (u8 *)(&pNew[1])==(u8 *)(&((&pNew->buf)[1])) ); memset(pNew, 0, ((u8 *)&pNew->buf) - (u8 *)pNew); pNew->buf.n = 0; } | > | 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 | rc = lsmFsOpenLog(pDb, 0); if( pDb->pLogWriter==0 ){ pNew = lsmMallocZeroRc(pDb->pEnv, sizeof(LogWriter), &rc); if( pNew ){ lsmStringInit(&pNew->buf, pDb->pEnv); rc = lsmStringExtend(&pNew->buf, 2); } pDb->pLogWriter = pNew; }else{ pNew = pDb->pLogWriter; assert( (u8 *)(&pNew[1])==(u8 *)(&((&pNew->buf)[1])) ); memset(pNew, 0, ((u8 *)&pNew->buf) - (u8 *)pNew); pNew->buf.n = 0; } |
︙ | ︙ | |||
460 461 462 463 464 465 466 | assert( pNew->jump.iStart>pNew->iOff ); iRound = firstByteOnSector(pNew, pNew->jump.iStart); if( iRound>pNew->iOff ) pNew->jump.iStart = iRound; pNew->jump.iEnd = lastByteOnSector(pNew, pNew->jump.iEnd); } | | | 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 | assert( pNew->jump.iStart>pNew->iOff ); iRound = firstByteOnSector(pNew, pNew->jump.iStart); if( iRound>pNew->iOff ) pNew->jump.iStart = iRound; pNew->jump.iEnd = lastByteOnSector(pNew, pNew->jump.iEnd); } assert( pDb->pLogWriter==pNew ); return rc; } /* ** This function is called when a write-transaction is being closed. ** Parameter bCommit is true if the transaction is being committed, ** or false otherwise. The caller must hold the client-mutex to call |
︙ | ︙ | |||
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 | /* ** Append an LSM_LOG_WRITE (if nVal>=0) or LSM_LOG_DELETE (if nVal<0) ** record to the database log. */ int lsmLogWrite( lsm_db *pDb, /* Database handle */ void *pKey, int nKey, /* Database key to write to log */ void *pVal, int nVal /* Database value (or nVal<0) to write */ ){ int rc = LSM_OK; LogWriter *pLog; /* Log object to write to */ int nReq; /* Bytes of space required in log */ int bCksum = 0; /* True to embed a checksum in this record */ if( pDb->bUseLog==0 ) return LSM_OK; pLog = pDb->pLogWriter; /* Determine how many bytes of space are required, assuming that a checksum ** will be embedded in this record (even though it may not be). */ nReq = 1 + lsmVarintLen32(nKey) + 8 + nKey; | > > > > > > > | > | | | | 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 | /* ** Append an LSM_LOG_WRITE (if nVal>=0) or LSM_LOG_DELETE (if nVal<0) ** record to the database log. */ int lsmLogWrite( lsm_db *pDb, /* Database handle */ int eType, void *pKey, int nKey, /* Database key to write to log */ void *pVal, int nVal /* Database value (or nVal<0) to write */ ){ int rc = LSM_OK; LogWriter *pLog; /* Log object to write to */ int nReq; /* Bytes of space required in log */ int bCksum = 0; /* True to embed a checksum in this record */ assert( eType==LSM_WRITE || eType==LSM_DELETE || eType==LSM_DRANGE ); assert( LSM_LOG_WRITE==LSM_WRITE ); assert( LSM_LOG_DELETE==LSM_DELETE ); assert( LSM_LOG_DRANGE==LSM_DRANGE ); assert( (eType==LSM_LOG_DELETE)==(nVal<0) ); if( pDb->bUseLog==0 ) return LSM_OK; pLog = pDb->pLogWriter; /* Determine how many bytes of space are required, assuming that a checksum ** will be embedded in this record (even though it may not be). */ nReq = 1 + lsmVarintLen32(nKey) + 8 + nKey; if( eType!=LSM_LOG_DELETE ) nReq += lsmVarintLen32(nVal) + nVal; /* Jump over the jump region if required. Set bCksum to true to tell the ** code below to include a checksum in the record if either (a) writing ** this record would mean that more than LSM_CKSUM_MAXDATA bytes of data ** have been written to the log since the last checksum, or (b) the jump ** is taken. */ rc = jumpIfRequired(pDb, pLog, nReq, &bCksum); if( (pLog->buf.n+nReq) > LSM_CKSUM_MAXDATA ) bCksum = 1; if( rc==LSM_OK ){ rc = lsmStringExtend(&pLog->buf, nReq); } if( rc==LSM_OK ){ u8 *a = (u8 *)&pLog->buf.z[pLog->buf.n]; /* Write the record header - the type byte followed by either 1 (for ** DELETE) or 2 (for WRITE) varints. */ assert( LSM_LOG_WRITE_CKSUM == (LSM_LOG_WRITE | 0x0001) ); assert( LSM_LOG_DELETE_CKSUM == (LSM_LOG_DELETE | 0x0001) ); assert( LSM_LOG_DRANGE_CKSUM == (LSM_LOG_DRANGE | 0x0001) ); *(a++) = (u8)eType | (u8)bCksum; a += lsmVarintPut32(a, nKey); if( eType!=LSM_LOG_DELETE ) a += lsmVarintPut32(a, nVal); if( bCksum ){ pLog->buf.n = (a - (u8 *)pLog->buf.z); rc = logCksumAndFlush(pDb); a = (u8 *)&pLog->buf.z[pLog->buf.n]; } memcpy(a, pKey, nKey); a += nKey; if( eType!=LSM_LOG_DELETE ){ memcpy(a, pVal, nVal); a += nVal; } pLog->buf.n = a - (u8 *)pLog->buf.z; assert( pLog->buf.n<=pLog->buf.nAlloc ); } |
︙ | ︙ | |||
864 865 866 867 868 869 870 | if( ppBlob && nReq==nBlob && nBlob<=nAvail ){ *ppBlob = (u8 *)&p->buf.z[p->iBuf]; p->iBuf += nBlob; nReq = 0; }else{ int nCopy = LSM_MIN(nAvail, nReq); if( nBlob==nReq ){ | < > > > | 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 | if( ppBlob && nReq==nBlob && nBlob<=nAvail ){ *ppBlob = (u8 *)&p->buf.z[p->iBuf]; p->iBuf += nBlob; nReq = 0; }else{ int nCopy = LSM_MIN(nAvail, nReq); if( nBlob==nReq ){ pBuf->n = 0; } rc = lsmStringBinAppend(pBuf, (u8 *)&p->buf.z[p->iBuf], nCopy); nReq -= nCopy; p->iBuf += nCopy; if( nReq==0 && ppBlob ){ *ppBlob = (u8*)pBuf->z; } } } *pRc = rc; } static void logReaderVarint( |
︙ | ︙ | |||
911 912 913 914 915 916 917 918 919 920 921 922 923 924 | int nCksum = p->iBuf - p->iCksumBuf; /* Update in-memory (expected) checksums */ assert( nCksum>=0 ); logCksumUnaligned(&p->buf.z[p->iCksumBuf], nCksum, &p->cksum0, &p->cksum1); p->iCksumBuf = p->iBuf + 8; logReaderBlob(p, pBuf, 8, &pPtr, pRc); /* Read the checksums from the log file. Set *pbEof if they do not match. */ if( pPtr ){ cksum0 = lsmGetU32(pPtr); cksum1 = lsmGetU32(&pPtr[4]); *pbEof = (cksum0!=p->cksum0 || cksum1!=p->cksum1); p->iCksumBuf = p->iBuf; | > | 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 | int nCksum = p->iBuf - p->iCksumBuf; /* Update in-memory (expected) checksums */ assert( nCksum>=0 ); logCksumUnaligned(&p->buf.z[p->iCksumBuf], nCksum, &p->cksum0, &p->cksum1); p->iCksumBuf = p->iBuf + 8; logReaderBlob(p, pBuf, 8, &pPtr, pRc); assert( pPtr || *pRc ); /* Read the checksums from the log file. Set *pbEof if they do not match. */ if( pPtr ){ cksum0 = lsmGetU32(pPtr); cksum1 = lsmGetU32(&pPtr[4]); *pbEof = (cksum0!=p->cksum0 || cksum1!=p->cksum1); p->iCksumBuf = p->iBuf; |
︙ | ︙ | |||
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 | case LSM_LOG_PAD2: { int nPad; logReaderVarint(&reader, &buf1, &nPad, &rc); logReaderBlob(&reader, &buf1, nPad, 0, &rc); break; } case LSM_LOG_WRITE: case LSM_LOG_WRITE_CKSUM: { int nKey; int nVal; u8 *aVal; logReaderVarint(&reader, &buf1, &nKey, &rc); logReaderVarint(&reader, &buf2, &nVal, &rc); | > > | > | > > > | 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 | case LSM_LOG_PAD2: { int nPad; logReaderVarint(&reader, &buf1, &nPad, &rc); logReaderBlob(&reader, &buf1, nPad, 0, &rc); break; } case LSM_LOG_DRANGE: case LSM_LOG_DRANGE_CKSUM: case LSM_LOG_WRITE: case LSM_LOG_WRITE_CKSUM: { int nKey; int nVal; u8 *aVal; logReaderVarint(&reader, &buf1, &nKey, &rc); logReaderVarint(&reader, &buf2, &nVal, &rc); if( eType==LSM_LOG_WRITE_CKSUM || eType==LSM_LOG_DRANGE_CKSUM ){ logReaderCksum(&reader, &buf1, &bEof, &rc); }else{ bEof = logRequireCksum(&reader, nKey+nVal); } if( bEof ) break; logReaderBlob(&reader, &buf1, nKey, 0, &rc); logReaderBlob(&reader, &buf2, nVal, &aVal, &rc); if( iPass==1 && rc==LSM_OK ){ if( eType==LSM_LOG_WRITE || eType==LSM_LOG_WRITE_CKSUM ){ rc = lsmTreeInsert(pDb, (u8 *)buf1.z, nKey, aVal, nVal); }else{ rc = lsmTreeDelete(pDb, (u8 *)buf1.z, nKey, aVal, nVal); } } break; } case LSM_LOG_DELETE: case LSM_LOG_DELETE_CKSUM: { int nKey; u8 *aKey; |
︙ | ︙ |
Changes to ext/lsm1/lsm_main.c.
︙ | ︙ | |||
222 223 224 225 226 227 228 | pDb->pClient = 0; assertRwclientLockValue(pDb); lsmDbDatabaseRelease(pDb); lsmLogClose(pDb); lsmFsClose(pDb->pFS); | | | 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 | pDb->pClient = 0; assertRwclientLockValue(pDb); lsmDbDatabaseRelease(pDb); lsmLogClose(pDb); lsmFsClose(pDb->pFS); /* assert( pDb->mLock==0 ); */ /* Invoke any destructors registered for the compression or ** compression factory callbacks. */ if( pDb->factory.xFree ) pDb->factory.xFree(pDb->factory.pCtx); if( pDb->compress.xFree ) pDb->compress.xFree(pDb->compress.pCtx); lsmFree(pDb->pEnv, pDb->rollback.aArray); |
︙ | ︙ | |||
665 666 667 668 669 670 671 | if( pDb->nTransOpen==0 ){ bCommit = 1; rc = lsm_begin(pDb, 1); } if( rc==LSM_OK ){ | | | < < < | 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 | if( pDb->nTransOpen==0 ){ bCommit = 1; rc = lsm_begin(pDb, 1); } if( rc==LSM_OK ){ int eType = (bDeleteRange ? LSM_DRANGE : (nVal>=0?LSM_WRITE:LSM_DELETE)); rc = lsmLogWrite(pDb, eType, (void *)pKey, nKey, (void *)pVal, nVal); } lsmSortedSaveTreeCursors(pDb); if( rc==LSM_OK ){ int pgsz = lsmFsPageSize(pDb->pFS); int nQuant = LSM_AUTOWORK_QUANT * pgsz; |
︙ | ︙ | |||
919 920 921 922 923 924 925 926 927 928 929 930 | assert_db_state( pDb ); /* A value less than zero means close the innermost nested transaction. */ if( iLevel<0 ) iLevel = LSM_MAX(0, pDb->nTransOpen - 1); if( iLevel<pDb->nTransOpen ){ if( iLevel==0 ){ /* Commit the transaction to disk. */ if( rc==LSM_OK ) rc = lsmLogCommit(pDb); if( rc==LSM_OK && pDb->eSafety==LSM_SAFETY_FULL ){ rc = lsmFsSyncLog(pDb->pFS); } | > | > | 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 | assert_db_state( pDb ); /* A value less than zero means close the innermost nested transaction. */ if( iLevel<0 ) iLevel = LSM_MAX(0, pDb->nTransOpen - 1); if( iLevel<pDb->nTransOpen ){ if( iLevel==0 ){ int rc2; /* Commit the transaction to disk. */ if( rc==LSM_OK ) rc = lsmLogCommit(pDb); if( rc==LSM_OK && pDb->eSafety==LSM_SAFETY_FULL ){ rc = lsmFsSyncLog(pDb->pFS); } rc2 = lsmFinishWriteTrans(pDb, (rc==LSM_OK)); if( rc==LSM_OK ) rc = rc2; } pDb->nTransOpen = iLevel; } dbReleaseClientSnapshot(pDb); return rc; } |
︙ | ︙ |
Changes to ext/lsm1/lsm_sorted.c.
︙ | ︙ | |||
1948 1949 1950 1951 1952 1953 1954 | /* If the segment-pointer has settled on a key that is smaller than ** the splitkey, invalidate the segment-pointer. */ if( pPtr->pPg ){ res = sortedKeyCompare(pCsr->pDb->xCmp, rtTopic(pPtr->eType), pPtr->pKey, pPtr->nKey, pLvl->iSplitTopic, pLvl->pSplitKey, pLvl->nSplitKey ); | > > > > > > > > | > > | 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 | /* If the segment-pointer has settled on a key that is smaller than ** the splitkey, invalidate the segment-pointer. */ if( pPtr->pPg ){ res = sortedKeyCompare(pCsr->pDb->xCmp, rtTopic(pPtr->eType), pPtr->pKey, pPtr->nKey, pLvl->iSplitTopic, pLvl->pSplitKey, pLvl->nSplitKey ); if( res<0 ){ if( pPtr->eType & LSM_START_DELETE ){ pPtr->eType &= ~LSM_INSERT; pPtr->pKey = pLvl->pSplitKey; pPtr->nKey = pLvl->nSplitKey; pPtr->pVal = 0; pPtr->nVal = 0; }else{ segmentPtrReset(pPtr, LSM_SEGMENTPTR_FREE_THRESHOLD); } } } if( aPtr[i].pKey ) bHit = 1; } if( rc==LSM_OK && eSeek==LSM_SEEK_LE && bHit==0 ){ rc = segmentPtrEnd(pCsr, &aPtr[0], 1); |
︙ | ︙ | |||
3860 3861 3862 3863 3864 3865 3866 | int iFPtr, /* Footer ptr for new pages */ u8 *aWrite, /* Write data from this buffer */ int nWrite /* Size of aWrite[] in bytes */ ){ int rc = LSM_OK; /* Return code */ int nRem = nWrite; /* Number of bytes still to write */ | | | 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 | int iFPtr, /* Footer ptr for new pages */ u8 *aWrite, /* Write data from this buffer */ int nWrite /* Size of aWrite[] in bytes */ ){ int rc = LSM_OK; /* Return code */ int nRem = nWrite; /* Number of bytes still to write */ while( rc==LSM_OK && nRem>0 ){ Merge *pMerge = pMW->pLevel->pMerge; int nCopy; /* Number of bytes to copy */ u8 *aData; /* Pointer to buffer of current output page */ int nData; /* Size of aData[] in bytes */ int nRec; /* Number of records on current output page */ int iOff; /* Offset in aData[] to write to */ |
︙ | ︙ | |||
5392 5393 5394 5395 5396 5397 5398 | rc = doLsmWork(pDb, pDb->nMerge, nRemaining, 0); if( rc==LSM_BUSY ) rc = LSM_OK; if( bRestore && pDb->pCsr ){ lsmMCursorFreeCache(pDb); lsmFreeSnapshot(pDb->pEnv, pDb->pClient); pDb->pClient = 0; | > | > | 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 | rc = doLsmWork(pDb, pDb->nMerge, nRemaining, 0); if( rc==LSM_BUSY ) rc = LSM_OK; if( bRestore && pDb->pCsr ){ lsmMCursorFreeCache(pDb); lsmFreeSnapshot(pDb->pEnv, pDb->pClient); pDb->pClient = 0; if( rc==LSM_OK ){ rc = lsmCheckpointLoad(pDb, 0); } if( rc==LSM_OK ){ rc = lsmCheckpointDeserialize(pDb, 0, pDb->aSnapshot, &pDb->pClient); } if( rc==LSM_OK ){ rc = lsmRestoreCursors(pDb); } } |
︙ | ︙ |
Changes to ext/lsm1/lsm_str.c.
︙ | ︙ | |||
35 36 37 38 39 40 41 | if( pStr->n + nNew >= pStr->nAlloc ){ int nAlloc = pStr->n + nNew + 100; char *zNew = lsmRealloc(pStr->pEnv, pStr->z, nAlloc); if( zNew==0 ){ lsmFree(pStr->pEnv, pStr->z); nAlloc = 0; pStr->n = -1; | < < > | | < | 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | if( pStr->n + nNew >= pStr->nAlloc ){ int nAlloc = pStr->n + nNew + 100; char *zNew = lsmRealloc(pStr->pEnv, pStr->z, nAlloc); if( zNew==0 ){ lsmFree(pStr->pEnv, pStr->z); nAlloc = 0; pStr->n = -1; } pStr->nAlloc = nAlloc; pStr->z = zNew; } return (pStr->z ? LSM_OK : LSM_NOMEM_BKPT); } /* ** Clear an LsmString object, releasing any allocated memory that it holds. ** This also clears the error indication (if any). |
︙ | ︙ |
Changes to ext/lsm1/lsm_tree.c.
︙ | ︙ | |||
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 | TreeKey *pRes; /* Key at end of seek operation */ treeCursorInit(pDb, 0, &csr); /* Seek to the leaf (or internal node) that the new key belongs on */ rc = lsmTreeCursorSeek(&csr, pKey, nKey, &res); pRes = csrGetKey(&csr, &csr.blob, &rc); if( rc!=LSM_OK ) return rc; if( flags==LSM_START_DELETE ){ /* When inserting a start-delete-range entry, if the key that ** occurs immediately before the new entry is already a START_DELETE, ** then the new entry is not required. */ if( (res<=0 && (pRes->flags & LSM_START_DELETE)) || (res>0 && treePrevIsStartDelete(pDb, &csr)) | > | 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 | TreeKey *pRes; /* Key at end of seek operation */ treeCursorInit(pDb, 0, &csr); /* Seek to the leaf (or internal node) that the new key belongs on */ rc = lsmTreeCursorSeek(&csr, pKey, nKey, &res); pRes = csrGetKey(&csr, &csr.blob, &rc); if( rc!=LSM_OK ) return rc; assert( pRes ); if( flags==LSM_START_DELETE ){ /* When inserting a start-delete-range entry, if the key that ** occurs immediately before the new entry is already a START_DELETE, ** then the new entry is not required. */ if( (res<=0 && (pRes->flags & LSM_START_DELETE)) || (res>0 && treePrevIsStartDelete(pDb, &csr)) |
︙ | ︙ | |||
1940 1941 1942 1943 1944 1945 1946 | if( pCsr ){ pCsr->iNode = -1; pCsr->pSave = 0; } } #ifndef NDEBUG | | < | | 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 | if( pCsr ){ pCsr->iNode = -1; pCsr->pSave = 0; } } #ifndef NDEBUG static int treeCsrCompare(TreeCursor *pCsr, void *pKey, int nKey, int *pRc){ TreeKey *p; int cmp = 0; assert( pCsr->iNode>=0 ); p = csrGetKey(pCsr, &pCsr->blob, pRc); if( p ){ cmp = treeKeycmp(TKV_KEY(p), p->nKey, pKey, nKey); } return cmp; } #endif |
︙ | ︙ | |||
2047 2048 2049 2050 2051 2052 2053 | pCsr->iNode = iNode; tblobFree(pDb, &b); } /* assert() that *pRes has been set properly */ #ifndef NDEBUG if( rc==LSM_OK && lsmTreeCursorValid(pCsr) ){ | | | | 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 | pCsr->iNode = iNode; tblobFree(pDb, &b); } /* assert() that *pRes has been set properly */ #ifndef NDEBUG if( rc==LSM_OK && lsmTreeCursorValid(pCsr) ){ int cmp = treeCsrCompare(pCsr, pKey, nKey, &rc); assert( rc!=LSM_OK || *pRes==cmp || (*pRes ^ cmp)>0 ); } #endif return rc; } int lsmTreeCursorNext(TreeCursor *pCsr){ |
︙ | ︙ |
Changes to ext/lsm1/lsm_vtab.c.
︙ | ︙ | |||
455 456 457 458 459 460 461 | int j; for(j=1; j<nVal; j++){ x = (x<<8) | aVal[j]; } if( aVal[0]==SQLITE_INTEGER ){ sqlite3_result_int64(ctx, *(sqlite3_int64*)&x); }else{ | > > > | | 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 | int j; for(j=1; j<nVal; j++){ x = (x<<8) | aVal[j]; } if( aVal[0]==SQLITE_INTEGER ){ sqlite3_result_int64(ctx, *(sqlite3_int64*)&x); }else{ double r; assert( sizeof(r)==sizeof(x) ); memcpy(&r, &x, sizeof(r)); sqlite3_result_double(ctx, r); } break; } case SQLITE_TEXT: { sqlite3_result_text(ctx, (char*)&aVal[1], nVal-1, SQLITE_TRANSIENT); break; } |
︙ | ︙ | |||
662 663 664 665 666 667 668 | case SQLITE_FLOAT: { sqlite3_uint64 x; unsigned char aVal[9]; int i; if( eType==SQLITE_INTEGER ){ *(sqlite3_int64*)&x = sqlite3_value_int64(pValue); }else{ | | > > | 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 | case SQLITE_FLOAT: { sqlite3_uint64 x; unsigned char aVal[9]; int i; if( eType==SQLITE_INTEGER ){ *(sqlite3_int64*)&x = sqlite3_value_int64(pValue); }else{ double r = sqlite3_value_double(pValue); assert( sizeof(r)==sizeof(x) ); memcpy(&x, &r, sizeof(r)); } for(i=8; x>0 && i>=1; i--){ aVal[i] = x & 0xff; x >>= 8; } aVal[i] = eType; rc = lsm_insert(p->pDb, pKey, nKey, &aVal[i], 9-i); |
︙ | ︙ |
Changes to ext/rtree/rtree.c.
︙ | ︙ | |||
3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 | zSql = sqlite3_mprintf( "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1", pRtree->zDb, pRtree->zName ); rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize); if( rc!=SQLITE_OK ){ *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); } } sqlite3_free(zSql); return rc; } | > > > > | 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 | zSql = sqlite3_mprintf( "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1", pRtree->zDb, pRtree->zName ); rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize); if( rc!=SQLITE_OK ){ *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); }else if( pRtree->iNodeSize<(512-64) ){ rc = SQLITE_CORRUPT; *pzErr = sqlite3_mprintf("undersize RTree blobs in \"%q_node\"", pRtree->zName); } } sqlite3_free(zSql); return rc; } |
︙ | ︙ |
Changes to ext/rtree/rtreeA.test.
︙ | ︙ | |||
211 212 213 214 215 216 217 218 219 220 | do_execsql_test rtreeA-6.1.0 { UPDATE t1_parent set parentnode = parentnode+1 } {} do_corruption_tests rtreeA-6.1 { 1 "DELETE FROM t1 WHERE rowid = 5" 2 "UPDATE t1 SET x1=x1+1, x2=x2+1" } finish_test | > > > > > > > > > > > > > | 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 | do_execsql_test rtreeA-6.1.0 { UPDATE t1_parent set parentnode = parentnode+1 } {} do_corruption_tests rtreeA-6.1 { 1 "DELETE FROM t1 WHERE rowid = 5" 2 "UPDATE t1 SET x1=x1+1, x2=x2+1" } #------------------------------------------------------------------------- # Truncated blobs in the _node table. # create_t1 populate_t1 sqlite3 db test.db do_execsql_test rtreeA-7.100 { UPDATE t1_node SET data=x'' WHERE rowid=1; } {} do_catchsql_test rtreeA-7.110 { SELECT * FROM t1 WHERE x1>0 AND x1<100 AND x2>0 AND x2<100; } {1 {undersize RTree blobs in "t1_node"}} finish_test |
Changes to main.mk.
︙ | ︙ | |||
470 471 472 473 474 475 476 | # Standard options to testfixture # TESTOPTS = --verbose=file --output=test-out.txt # Extra compiler options for various shell tools # | | | 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 | # Standard options to testfixture # TESTOPTS = --verbose=file --output=test-out.txt # Extra compiler options for various shell tools # SHELL_OPT += -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5 SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS SHELL_OPT += -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION SHELL_OPT += -DSQLITE_ENABLE_STMTVTAB FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1 FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000 DBFUZZ_OPT = |
︙ | ︙ |
Changes to src/build.c.
︙ | ︙ | |||
3768 3769 3770 3771 3772 3773 3774 | return 0; } pItem = &pList->a[pList->nSrc-1]; if( pDatabase && pDatabase->z==0 ){ pDatabase = 0; } if( pDatabase ){ | | | < | | | > | 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 | return 0; } pItem = &pList->a[pList->nSrc-1]; if( pDatabase && pDatabase->z==0 ){ pDatabase = 0; } if( pDatabase ){ pItem->zName = sqlite3NameFromToken(db, pDatabase); pItem->zDatabase = sqlite3NameFromToken(db, pTable); }else{ pItem->zName = sqlite3NameFromToken(db, pTable); pItem->zDatabase = 0; } return pList; } /* ** Assign VdbeCursor index numbers to all tables in a SrcList */ void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ |
︙ | ︙ | |||
3962 3963 3964 3965 3966 3967 3968 | sqlite3VdbeUsesBtree(v, i); } } sqlite3VdbeAddOp0(v, OP_AutoCommit); } /* | | > > | > < < < < < < < < | < < < < < | < < | > | | 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 | sqlite3VdbeUsesBtree(v, i); } } sqlite3VdbeAddOp0(v, OP_AutoCommit); } /* ** Generate VDBE code for a COMMIT or ROLLBACK statement. ** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise ** code is generated for a COMMIT. */ void sqlite3EndTransaction(Parse *pParse, int eType){ Vdbe *v; int isRollback; assert( pParse!=0 ); assert( pParse->db!=0 ); assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK ); isRollback = eType==TK_ROLLBACK; if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){ return; } v = sqlite3GetVdbe(pParse); if( v ){ sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback); } } /* ** This function is called by the parser when it parses a command to create, ** release or rollback an SQL savepoint. */ |
︙ | ︙ |
Changes to src/callback.c.
︙ | ︙ | |||
117 118 119 120 121 122 123 | ** ** If required, this routine calls the 'collation needed' callback to ** request a definition of the collating sequence. If this doesn't work, ** an equivalent collating sequence that uses a text encoding different ** from the main database is substituted, if one is available. */ int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ | | | 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | ** ** If required, this routine calls the 'collation needed' callback to ** request a definition of the collating sequence. If this doesn't work, ** an equivalent collating sequence that uses a text encoding different ** from the main database is substituted, if one is available. */ int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ if( pColl && pColl->xCmp==0 ){ const char *zName = pColl->zName; sqlite3 *db = pParse->db; CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName); if( !p ){ return SQLITE_ERROR; } assert( p==pColl ); |
︙ | ︙ | |||
153 154 155 156 157 158 159 | const char *zName, /* Name of the collating sequence */ int create /* Create a new entry if true */ ){ CollSeq *pColl; pColl = sqlite3HashFind(&db->aCollSeq, zName); if( 0==pColl && create ){ | | | < | 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 | const char *zName, /* Name of the collating sequence */ int create /* Create a new entry if true */ ){ CollSeq *pColl; pColl = sqlite3HashFind(&db->aCollSeq, zName); if( 0==pColl && create ){ int nName = sqlite3Strlen30(zName) + 1; pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName); if( pColl ){ CollSeq *pDel = 0; pColl[0].zName = (char*)&pColl[3]; pColl[0].enc = SQLITE_UTF8; pColl[1].zName = (char*)&pColl[3]; pColl[1].enc = SQLITE_UTF16LE; pColl[2].zName = (char*)&pColl[3]; pColl[2].enc = SQLITE_UTF16BE; memcpy(pColl[0].zName, zName, nName); pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl); /* If a malloc() failure occurred in sqlite3HashInsert(), it will ** return the pColl pointer to be deleted (because it wasn't added ** to the hash table). */ assert( pDel==0 || pDel==pColl ); |
︙ | ︙ | |||
304 305 306 307 308 309 310 | int nDef /* Length of the apDef[] list */ ){ int i; for(i=0; i<nDef; i++){ FuncDef *pOther; const char *zName = aDef[i].zName; int nName = sqlite3Strlen30(zName); | | > | 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 | int nDef /* Length of the apDef[] list */ ){ int i; for(i=0; i<nDef; i++){ FuncDef *pOther; const char *zName = aDef[i].zName; int nName = sqlite3Strlen30(zName); int h = (zName[0] + nName) % SQLITE_FUNC_HASH_SZ; assert( zName[0]>='a' && zName[0]<='z' ); pOther = functionSearch(h, zName); if( pOther ){ assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] ); aDef[i].pNext = pOther->pNext; pOther->pNext = &aDef[i]; }else{ aDef[i].pNext = 0; |
︙ | ︙ |
Changes to src/expr.c.
︙ | ︙ | |||
740 741 742 743 744 745 746 | pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); if( pNew ){ memset(pNew, 0, sizeof(Expr)); pNew->op = (u8)op; pNew->iAgg = -1; if( pToken ){ if( nExtra==0 ){ | | | 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 | pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); if( pNew ){ memset(pNew, 0, sizeof(Expr)); pNew->op = (u8)op; pNew->iAgg = -1; if( pToken ){ if( nExtra==0 ){ pNew->flags |= EP_IntValue|EP_Leaf; pNew->u.iValue = iValue; }else{ pNew->u.zToken = (char*)&pNew[1]; assert( pToken->z!=0 || pToken->n==0 ); if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); pNew->u.zToken[pToken->n] = 0; if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ |
︙ | ︙ | |||
1021 1022 1023 1024 1025 1026 1027 | assert( p->x.pSelect==0 ); } #endif if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ /* The Expr.x union is never used at the same time as Expr.pRight */ assert( p->x.pList==0 || p->pRight==0 ); if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); | > | | | 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 | assert( p->x.pSelect==0 ); } #endif if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ /* The Expr.x union is never used at the same time as Expr.pRight */ assert( p->x.pList==0 || p->pRight==0 ); if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); if( p->pRight ){ sqlite3ExprDeleteNN(db, p->pRight); }else if( ExprHasProperty(p, EP_xIsSelect) ){ sqlite3SelectDelete(db, p->x.pSelect); }else{ sqlite3ExprListDelete(db, p->x.pList); } } if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken); if( !ExprHasProperty(p, EP_Static) ){ |
︙ | ︙ |
Changes to src/func.c.
︙ | ︙ | |||
72 73 74 75 76 77 78 | ** Return the type of the argument. */ static void typeofFunc( sqlite3_context *context, int NotUsed, sqlite3_value **argv ){ | | > < > | > | | | < < | | 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 | ** Return the type of the argument. */ static void typeofFunc( sqlite3_context *context, int NotUsed, sqlite3_value **argv ){ static const char *azType[] = { "integer", "real", "text", "blob", "null" }; int i = sqlite3_value_type(argv[0]) - 1; UNUSED_PARAMETER(NotUsed); assert( i>=0 && i<ArraySize(azType) ); assert( SQLITE_INTEGER==1 ); assert( SQLITE_FLOAT==2 ); assert( SQLITE_TEXT==3 ); assert( SQLITE_BLOB==4 ); assert( SQLITE_NULL==5 ); sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC); } /* ** Implementation of the length() function */ static void lengthFunc( |
︙ | ︙ |
Changes to src/hash.c.
︙ | ︙ | |||
136 137 138 139 140 141 142 | next_elem = elem->next; insertElement(pH, &new_ht[h], elem); } return 1; } /* This function (for internal use only) locates an element in an | | | > > | | | 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 | next_elem = elem->next; insertElement(pH, &new_ht[h], elem); } return 1; } /* This function (for internal use only) locates an element in an ** hash table that matches the given key. If no element is found, ** a pointer to a static null element with HashElem.data==0 is returned. ** If pH is not NULL, then the hash for this key is written to *pH. */ static HashElem *findElementWithHash( const Hash *pH, /* The pH to be searched */ const char *pKey, /* The key we are searching for */ unsigned int *pHash /* Write the hash value here */ ){ HashElem *elem; /* Used to loop thru the element list */ int count; /* Number of elements left to test */ unsigned int h; /* The computed hash */ static HashElem nullElement = { 0, 0, 0, 0 }; if( pH->ht ){ /*OPTIMIZATION-IF-TRUE*/ struct _ht *pEntry; h = strHash(pKey) % pH->htsize; pEntry = &pH->ht[h]; elem = pEntry->chain; count = pEntry->count; }else{ h = 0; elem = pH->first; count = pH->count; } if( pHash ) *pHash = h; while( count-- ){ assert( elem!=0 ); if( sqlite3StrICmp(elem->pKey,pKey)==0 ){ return elem; } elem = elem->next; } return &nullElement; } /* Remove a single entry from the hash table given a pointer to that ** element and a hash on the element's key. */ static void removeElementGivenHash( Hash *pH, /* The pH containing "elem" */ |
︙ | ︙ | |||
209 210 211 212 213 214 215 | } /* Attempt to locate an element of the hash table pH with a key ** that matches pKey. Return the data for this element if it is ** found, or NULL if there is no match. */ void *sqlite3HashFind(const Hash *pH, const char *pKey){ | < < < | < | 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 | } /* Attempt to locate an element of the hash table pH with a key ** that matches pKey. Return the data for this element if it is ** found, or NULL if there is no match. */ void *sqlite3HashFind(const Hash *pH, const char *pKey){ assert( pH!=0 ); assert( pKey!=0 ); return findElementWithHash(pH, pKey, 0)->data; } /* Insert an element into the hash table pH. The key is pKey ** and the data is "data". ** ** If no element exists with a matching key, then a new ** element is created and NULL is returned. |
︙ | ︙ | |||
240 241 242 243 244 245 246 | unsigned int h; /* the hash of the key modulo hash table size */ HashElem *elem; /* Used to loop thru the element list */ HashElem *new_elem; /* New element added to the pH */ assert( pH!=0 ); assert( pKey!=0 ); elem = findElementWithHash(pH,pKey,&h); | | | 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 | unsigned int h; /* the hash of the key modulo hash table size */ HashElem *elem; /* Used to loop thru the element list */ HashElem *new_elem; /* New element added to the pH */ assert( pH!=0 ); assert( pKey!=0 ); elem = findElementWithHash(pH,pKey,&h); if( elem->data ){ void *old_data = elem->data; if( data==0 ){ removeElementGivenHash(pH,elem,h); }else{ elem->data = data; elem->pKey = pKey; } |
︙ | ︙ |
Changes to src/parse.y.
︙ | ︙ | |||
136 137 138 139 140 141 142 | trans_opt ::= TRANSACTION. trans_opt ::= TRANSACTION nm. %type transtype {int} transtype(A) ::= . {A = TK_DEFERRED;} transtype(A) ::= DEFERRED(X). {A = @X; /*A-overwrites-X*/} transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/} transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/} | | | < | 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | trans_opt ::= TRANSACTION. trans_opt ::= TRANSACTION nm. %type transtype {int} transtype(A) ::= . {A = TK_DEFERRED;} transtype(A) ::= DEFERRED(X). {A = @X; /*A-overwrites-X*/} transtype(A) ::= IMMEDIATE(X). {A = @X; /*A-overwrites-X*/} transtype(A) ::= EXCLUSIVE(X). {A = @X; /*A-overwrites-X*/} cmd ::= COMMIT|END(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} cmd ::= ROLLBACK(X) trans_opt. {sqlite3EndTransaction(pParse,@X);} savepoint_opt ::= SAVEPOINT. savepoint_opt ::= . cmd ::= SAVEPOINT nm(X). { sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &X); } cmd ::= RELEASE savepoint_opt nm(X). { |
︙ | ︙ |
Changes to src/resolve.c.
︙ | ︙ | |||
474 475 476 477 478 479 480 481 482 483 484 485 486 487 | /* Clean up and return */ sqlite3ExprDelete(db, pExpr->pLeft); pExpr->pLeft = 0; sqlite3ExprDelete(db, pExpr->pRight); pExpr->pRight = 0; pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN); lookupname_end: if( cnt==1 ){ assert( pNC!=0 ); if( !ExprHasProperty(pExpr, EP_Alias) ){ sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); } /* Increment the nRef value on all name contexts from TopNC up to | > | 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 | /* Clean up and return */ sqlite3ExprDelete(db, pExpr->pLeft); pExpr->pLeft = 0; sqlite3ExprDelete(db, pExpr->pRight); pExpr->pRight = 0; pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN); ExprSetProperty(pExpr, EP_Leaf); lookupname_end: if( cnt==1 ){ assert( pNC!=0 ); if( !ExprHasProperty(pExpr, EP_Alias) ){ sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); } /* Increment the nRef value on all name contexts from TopNC up to |
︙ | ︙ |
Changes to src/select.c.
︙ | ︙ | |||
5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 | continue; } return pItem; } return 0; } /* ** Generate code for the SELECT statement given in the p argument. ** ** The results are returned according to the SelectDest structure. ** See comments in sqliteInt.h for further information. ** ** This routine returns the number of errors. If any errors are | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 | continue; } return pItem; } return 0; } #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION /* ** Attempt to transform a query of the form ** ** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2) ** ** Into this: ** ** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2) ** ** The transformation only works if all of the following are true: ** ** * The subquery is a UNION ALL of two or more terms ** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries ** * The outer query is a simple count(*) ** ** Return TRUE if the optimization is undertaken. */ static int countOfViewOptimization(Parse *pParse, Select *p){ Select *pSub, *pPrior; Expr *pExpr; Expr *pCount; sqlite3 *db; if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate query */ if( p->pEList->nExpr!=1 ) return 0; /* Single result column */ pExpr = p->pEList->a[0].pExpr; if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */ if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Must be count() */ if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */ if( p->pSrc->nSrc!=1 ) return 0; /* One table in the FROM clause */ pSub = p->pSrc->a[0].pSelect; if( pSub==0 ) return 0; /* The FROM is a subquery */ if( pSub->pPrior==0 ) return 0; /* Must be a compound subquery */ do{ if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */ if( pSub->pWhere ) return 0; /* No WHERE clause */ if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */ pSub = pSub->pPrior; /* Repeat over compound terms */ }while( pSub ); /* If we reach this point, that means it is OK to perform the transformation */ db = pParse->db; pCount = pExpr; pExpr = 0; pSub = p->pSrc->a[0].pSelect; p->pSrc->a[0].pSelect = 0; sqlite3SrcListDelete(db, p->pSrc); p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc)); while( pSub ){ Expr *pTerm; pPrior = pSub->pPrior; pSub->pPrior = 0; pSub->pNext = 0; pSub->selFlags |= SF_Aggregate; pSub->selFlags &= ~SF_Compound; pSub->nSelectRow = 0; sqlite3ExprListDelete(db, pSub->pEList); pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount; pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm); pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0); sqlite3PExprAddSelect(pParse, pTerm, pSub); if( pExpr==0 ){ pExpr = pTerm; }else{ pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr); } pSub = pPrior; } p->pEList->a[0].pExpr = pExpr; p->selFlags &= ~SF_Aggregate; #if SELECTTRACE_ENABLED if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif return 1; } #endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */ /* ** Generate code for the SELECT statement given in the p argument. ** ** The results are returned according to the SelectDest structure. ** See comments in sqliteInt.h for further information. ** ** This routine returns the number of errors. If any errors are |
︙ | ︙ | |||
5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 | #if SELECTTRACE_ENABLED if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and ** if the select-list is the same as the ORDER BY list, then this query ** can be rewritten as a GROUP BY. In other words, this: ** ** SELECT DISTINCT xyz FROM ... ORDER BY xyz ** | > > > > > > > > > > | 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 | #if SELECTTRACE_ENABLED if( sqlite3SelectTrace & 0x400 ){ SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView) && countOfViewOptimization(pParse, p) ){ if( db->mallocFailed ) goto select_end; pEList = p->pEList; pTabList = p->pSrc; } #endif /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and ** if the select-list is the same as the ORDER BY list, then this query ** can be rewritten as a GROUP BY. In other words, this: ** ** SELECT DISTINCT xyz FROM ... ORDER BY xyz ** |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 | #endif #define SQLITE3_TEXT 3 /* ** CAPI3REF: Result Values From A Query ** KEYWORDS: {column access functions} ** METHOD: sqlite3_stmt ** ** ^These routines return information about a single column of the current ** result row of a query. ^In every case the first argument is a pointer ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] ** that was returned from [sqlite3_prepare_v3()] or one of its variants) ** and the second argument is the index of the column for which information ** should be returned. ^The leftmost column of the result set has the index 0. | > > > > > > > > > > > > > > > > > > > > > > | 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 | #endif #define SQLITE3_TEXT 3 /* ** CAPI3REF: Result Values From A Query ** KEYWORDS: {column access functions} ** METHOD: sqlite3_stmt ** ** <b>Summary:</b> ** <blockquote><table border=0 cellpadding=0 cellspacing=0> ** <tr><td><b>sqlite3_column_blob</b><td>→<td>BLOB result ** <tr><td><b>sqlite3_column_double</b><td>→<td>REAL result ** <tr><td><b>sqlite3_column_int</b><td>→<td>32-bit INTEGER result ** <tr><td><b>sqlite3_column_int64</b><td>→<td>64-bit INTEGER result ** <tr><td><b>sqlite3_column_text</b><td>→<td>UTF-8 TEXT result ** <tr><td><b>sqlite3_column_text16</b><td>→<td>UTF-16 TEXT result ** <tr><td><b>sqlite3_column_value</b><td>→<td>The result as an ** [sqlite3_value|unprotected sqlite3_value] object. ** <tr><td> <td> <td> ** <tr><td><b>sqlite3_column_bytes</b><td>→<td>Size of a BLOB ** or a UTF-8 TEXT result in bytes ** <tr><td><b>sqlite3_column_bytes16 </b> ** <td>→ <td>Size of UTF-16 ** TEXT in bytes ** <tr><td><b>sqlite3_column_type</b><td>→<td>Default ** datatype of the result ** </table></blockquote> ** ** <b>Details:</b> ** ** ^These routines return information about a single column of the current ** result row of a query. ^In every case the first argument is a pointer ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] ** that was returned from [sqlite3_prepare_v3()] or one of its variants) ** and the second argument is the index of the column for which information ** should be returned. ^The leftmost column of the result set has the index 0. |
︙ | ︙ | |||
4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 | ** If any of these routines are called after [sqlite3_reset()] or ** [sqlite3_finalize()] or after [sqlite3_step()] has returned ** something other than [SQLITE_ROW], the results are undefined. ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] ** are called from a different thread while any of these routines ** are pending, then the results are undefined. ** ** ^The sqlite3_column_type() routine returns the ** [SQLITE_INTEGER | datatype code] for the initial data type ** of the result column. ^The returned value is one of [SQLITE_INTEGER], | > > > > > > | > > | | | > > > > > | 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 | ** If any of these routines are called after [sqlite3_reset()] or ** [sqlite3_finalize()] or after [sqlite3_step()] has returned ** something other than [SQLITE_ROW], the results are undefined. ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] ** are called from a different thread while any of these routines ** are pending, then the results are undefined. ** ** The first six interfaces (_blob, _double, _int, _int64, _text, and _text16) ** each return the value of a result column in a specific data format. If ** the result column is not initially in the requested format (for example, ** if the query returns an integer but the sqlite3_column_text() interface ** is used to extract the value) then an automatic type conversion is performed. ** ** ^The sqlite3_column_type() routine returns the ** [SQLITE_INTEGER | datatype code] for the initial data type ** of the result column. ^The returned value is one of [SQLITE_INTEGER], ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. ** The return value of sqlite3_column_type() can be used to decide which ** of the first six interface should be used to extract the column value. ** The value returned by sqlite3_column_type() is only meaningful if no ** automatic type conversions have occurred for the value in question. ** After a type conversion, the result of calling sqlite3_column_type() ** is undefined, though harmless. Future ** versions of SQLite may change the behavior of sqlite3_column_type() ** following a type conversion. ** ** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes() ** or sqlite3_column_bytes16() interfaces can be used to determine the size ** of that BLOB or string. ** ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() ** routine returns the number of bytes in that BLOB or string. ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts ** the string to UTF-8 and then returns the number of bytes. ** ^If the result is a numeric value then sqlite3_column_bytes() uses ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns |
︙ | ︙ | |||
4341 4342 4343 4344 4345 4346 4347 4348 | ** [unprotected sqlite3_value] object. In a multithreaded environment, ** an unprotected sqlite3_value object may only be used safely with ** [sqlite3_bind_value()] and [sqlite3_result_value()]. ** If the [unprotected sqlite3_value] object returned by ** [sqlite3_column_value()] is used in any other way, including calls ** to routines like [sqlite3_value_int()], [sqlite3_value_text()], ** or [sqlite3_value_bytes()], the behavior is not threadsafe. ** | > > > > | | | 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 | ** [unprotected sqlite3_value] object. In a multithreaded environment, ** an unprotected sqlite3_value object may only be used safely with ** [sqlite3_bind_value()] and [sqlite3_result_value()]. ** If the [unprotected sqlite3_value] object returned by ** [sqlite3_column_value()] is used in any other way, including calls ** to routines like [sqlite3_value_int()], [sqlite3_value_text()], ** or [sqlite3_value_bytes()], the behavior is not threadsafe. ** Hence, the sqlite3_column_value() interface ** is normally only useful within the implementation of ** [application-defined SQL functions] or [virtual tables], not within ** top-level application code. ** ** The these routines may attempt to convert the datatype of the result. ** ^For example, if the internal representation is FLOAT and a text result ** is requested, [sqlite3_snprintf()] is used internally to perform the ** conversion automatically. ^(The following table details the conversions ** that are applied: ** ** <blockquote> ** <table border="1"> ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion |
︙ | ︙ | |||
4415 4416 4417 4418 4419 4420 4421 | ** to sqlite3_column_text() or sqlite3_column_blob() with calls to ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() ** with calls to sqlite3_column_bytes(). ** ** ^The pointers returned are valid until a type conversion occurs as ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or ** [sqlite3_finalize()] is called. ^The memory space used to hold strings | | < < < > > > | 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 | ** to sqlite3_column_text() or sqlite3_column_blob() with calls to ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() ** with calls to sqlite3_column_bytes(). ** ** ^The pointers returned are valid until a type conversion occurs as ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or ** [sqlite3_finalize()] is called. ^The memory space used to hold strings ** and BLOBs is freed automatically. Do not pass the pointers returned ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into ** [sqlite3_free()]. ** ** ^(If a memory allocation error occurs during the evaluation of any ** of these routines, a default value is returned. The default value ** is either the integer 0, the floating point number 0.0, or a NULL ** pointer. Subsequent calls to [sqlite3_errcode()] will return ** [SQLITE_NOMEM].)^ */ const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); double sqlite3_column_double(sqlite3_stmt*, int iCol); int sqlite3_column_int(sqlite3_stmt*, int iCol); sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); int sqlite3_column_bytes(sqlite3_stmt*, int iCol); int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); /* ** CAPI3REF: Destroy A Prepared Statement Object ** DESTRUCTOR: sqlite3_stmt ** ** ^The sqlite3_finalize() function is called to delete a [prepared statement]. ** ^If the most recent evaluation of the statement encountered no errors |
︙ | ︙ | |||
4668 4669 4670 4671 4672 4673 4674 | void*,sqlite3_int64); #endif /* ** CAPI3REF: Obtaining SQL Values ** METHOD: sqlite3_value ** | | | > > > > > > | > > > > > > > > > > > > > < < < < > > > | > | < | | 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 | void*,sqlite3_int64); #endif /* ** CAPI3REF: Obtaining SQL Values ** METHOD: sqlite3_value ** ** <b>Summary:</b> ** <blockquote><table border=0 cellpadding=0 cellspacing=0> ** <tr><td><b>sqlite3_value_blob</b><td>→<td>BLOB value ** <tr><td><b>sqlite3_value_double</b><td>→<td>REAL value ** <tr><td><b>sqlite3_value_int</b><td>→<td>32-bit INTEGER value ** <tr><td><b>sqlite3_value_int64</b><td>→<td>64-bit INTEGER value ** <tr><td><b>sqlite3_value_text</b><td>→<td>UTF-8 TEXT value ** <tr><td><b>sqlite3_value_text16</b><td>→<td>UTF-16 TEXT value in ** the native byteorder ** <tr><td><b>sqlite3_value_text16be</b><td>→<td>UTF-16be TEXT value ** <tr><td><b>sqlite3_value_text16le</b><td>→<td>UTF-16le TEXT value ** <tr><td> <td> <td> ** <tr><td><b>sqlite3_value_bytes</b><td>→<td>Size of a BLOB ** or a UTF-8 TEXT in bytes ** <tr><td><b>sqlite3_value_bytes16 </b> ** <td>→ <td>Size of UTF-16 ** TEXT in bytes ** <tr><td><b>sqlite3_value_type</b><td>→<td>Default ** datatype of the value ** <tr><td><b>sqlite3_value_numeric_type </b> ** <td>→ <td>Best numeric datatype of the value ** </table></blockquote> ** ** <b>Details:</b> ** ** This routine extract type, size, and content information from ** [protected sqlite3_value] objects. Protected sqlite3_value objects ** are used to pass parameter information into implementation of ** [application-defined SQL functions] and [virtual tables]. ** ** These routines work only with [protected sqlite3_value] objects. ** Any attempt to use these routines on an [unprotected sqlite3_value] ** is not threadsafe. ** ** ^These routines work just like the corresponding [column access functions] ** except that these routines take a single [protected sqlite3_value] object ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. ** ** ^The sqlite3_value_text16() interface extracts a UTF-16 string ** in the native byte-order of the host machine. ^The |
︙ | ︙ | |||
4727 4728 4729 4730 4731 4732 4733 | ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], ** or [sqlite3_value_text16()]. ** ** These routines must be called from the same thread as ** the SQL function that supplied the [sqlite3_value*] parameters. */ const void *sqlite3_value_blob(sqlite3_value*); | < < > > | 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 | ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], ** or [sqlite3_value_text16()]. ** ** These routines must be called from the same thread as ** the SQL function that supplied the [sqlite3_value*] parameters. */ const void *sqlite3_value_blob(sqlite3_value*); double sqlite3_value_double(sqlite3_value*); int sqlite3_value_int(sqlite3_value*); sqlite3_int64 sqlite3_value_int64(sqlite3_value*); const unsigned char *sqlite3_value_text(sqlite3_value*); const void *sqlite3_value_text16(sqlite3_value*); const void *sqlite3_value_text16le(sqlite3_value*); const void *sqlite3_value_text16be(sqlite3_value*); void *sqlite3_value_pointer(sqlite3_value*); int sqlite3_value_bytes(sqlite3_value*); int sqlite3_value_bytes16(sqlite3_value*); int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); /* ** CAPI3REF: Finding The Subtype Of SQL Values ** METHOD: sqlite3_value ** |
︙ | ︙ |
Changes to src/sqliteInt.h.
︙ | ︙ | |||
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 | #define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */ #define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */ #define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */ #define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */ #define SQLITE_Transitive 0x0200 /* Transitive constraints */ #define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */ #define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */ #define SQLITE_CursorHints 0x2000 /* Add OP_CursorHint opcodes */ #define SQLITE_AllOpts 0xffff /* All optimizations */ /* ** Macros for testing whether or not optimizations are enabled or disabled. */ #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) | > | 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 | #define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */ #define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */ #define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */ #define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */ #define SQLITE_Transitive 0x0200 /* Transitive constraints */ #define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */ #define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */ #define SQLITE_CountOfView 0x1000 /* The count-of-view optimization */ #define SQLITE_CursorHints 0x2000 /* Add OP_CursorHint opcodes */ #define SQLITE_AllOpts 0xffff /* All optimizations */ /* ** Macros for testing whether or not optimizations are enabled or disabled. */ #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) |
︙ | ︙ | |||
3799 3800 3801 3802 3803 3804 3805 | void sqlite3PrngSaveState(void); void sqlite3PrngRestoreState(void); #endif void sqlite3RollbackAll(sqlite3*,int); void sqlite3CodeVerifySchema(Parse*, int); void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); void sqlite3BeginTransaction(Parse*, int); | | < | 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 | void sqlite3PrngSaveState(void); void sqlite3PrngRestoreState(void); #endif void sqlite3RollbackAll(sqlite3*,int); void sqlite3CodeVerifySchema(Parse*, int); void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); void sqlite3BeginTransaction(Parse*, int); void sqlite3EndTransaction(Parse*,int); void sqlite3Savepoint(Parse*, int, Token*); void sqlite3CloseSavepoints(sqlite3 *); void sqlite3LeaveMutexAndCloseZombie(sqlite3*); int sqlite3ExprIsConstant(Expr*); int sqlite3ExprIsConstantNotJoin(Expr*); int sqlite3ExprIsConstantOrFunction(Expr*, u8); int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*); |
︙ | ︙ |
Changes to src/walker.c.
︙ | ︙ | |||
37 38 39 40 41 42 43 | ** and WRC_Continue to continue. */ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ int rc; testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); testcase( ExprHasProperty(pExpr, EP_Reduced) ); rc = pWalker->xExprCallback(pWalker, pExpr); | > | < < | > > | | | | | > | 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 | ** and WRC_Continue to continue. */ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ int rc; testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); testcase( ExprHasProperty(pExpr, EP_Reduced) ); rc = pWalker->xExprCallback(pWalker, pExpr); if( rc ) return rc & WRC_Abort; if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort; assert( pExpr->x.pList==0 || pExpr->pRight==0 ); if( pExpr->pRight ){ if( walkExpr(pWalker, pExpr->pRight) ) return WRC_Abort; }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; }else if( pExpr->x.pList ){ if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort; } } return WRC_Continue; } int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue; } |
︙ | ︙ | |||
100 101 102 103 104 105 106 | SrcList *pSrc; int i; struct SrcList_item *pItem; pSrc = p->pSrc; if( ALWAYS(pSrc) ){ for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ | | | 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | SrcList *pSrc; int i; struct SrcList_item *pItem; pSrc = p->pSrc; if( ALWAYS(pSrc) ){ for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){ return WRC_Abort; } if( pItem->fg.isTabFunc && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg) ){ return WRC_Abort; } |
︙ | ︙ | |||
132 133 134 135 136 137 138 | ** there is an abort request. ** ** If the Walker does not have an xSelectCallback() then this routine ** is a no-op returning WRC_Continue. */ int sqlite3WalkSelect(Walker *pWalker, Select *p){ int rc; | > | | 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | ** there is an abort request. ** ** If the Walker does not have an xSelectCallback() then this routine ** is a no-op returning WRC_Continue. */ int sqlite3WalkSelect(Walker *pWalker, Select *p){ int rc; if( p==0 ) return WRC_Continue; if( pWalker->xSelectCallback==0 ) return WRC_Continue; do{ rc = pWalker->xSelectCallback(pWalker, p); if( rc ) return rc & WRC_Abort; if( sqlite3WalkSelectExpr(pWalker, p) || sqlite3WalkSelectFrom(pWalker, p) ){ return WRC_Abort; |
︙ | ︙ |
Changes to src/where.c.
︙ | ︙ | |||
4545 4546 4547 4548 4549 4550 4551 | ** WHERE_OR_SUBCLAUSE flag is set. */ for(ii=0; ii<pTabList->nSrc; ii++){ createMask(pMaskSet, pTabList->a[ii].iCursor); sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); } #ifdef SQLITE_DEBUG | > > | | | > > | 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 | ** WHERE_OR_SUBCLAUSE flag is set. */ for(ii=0; ii<pTabList->nSrc; ii++){ createMask(pMaskSet, pTabList->a[ii].iCursor); sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); } #ifdef SQLITE_DEBUG { Bitmask mx = 0; for(ii=0; ii<pTabList->nSrc; ii++){ Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor); assert( m>=mx ); mx = m; } } #endif /* Analyze all of the subexpressions. */ sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC); if( db->mallocFailed ) goto whereBeginError; |
︙ | ︙ |
Changes to tool/lempar.c.
︙ | ︙ | |||
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 | #endif #ifndef YYNOERRORRECOVERY pParser->yyerrcnt = -1; #endif pParser->yytos = pParser->yystack; pParser->yystack[0].stateno = 0; pParser->yystack[0].major = 0; pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; } #ifndef Parse_ENGINEALWAYSONSTACK /* ** This function allocates a new parser. ** The only argument is a pointer to a function which works like ** malloc. | > > | 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 | #endif #ifndef YYNOERRORRECOVERY pParser->yyerrcnt = -1; #endif pParser->yytos = pParser->yystack; pParser->yystack[0].stateno = 0; pParser->yystack[0].major = 0; #if YYSTACKDEPTH>0 pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; #endif } #ifndef Parse_ENGINEALWAYSONSTACK /* ** This function allocates a new parser. ** The only argument is a pointer to a function which works like ** malloc. |
︙ | ︙ |
Changes to tool/mkkeywordhash.c.
︙ | ︙ | |||
332 333 334 335 336 337 338 | */ int main(int argc, char **argv){ int i, j, k, h; int bestSize, bestCount; int count; int nChar; int totalLen = 0; | | | | 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 | */ int main(int argc, char **argv){ int i, j, k, h; int bestSize, bestCount; int count; int nChar; int totalLen = 0; int aKWHash[1000]; /* 1000 is much bigger than nKeyword */ char zKWText[2000]; /* Remove entries from the list of keywords that have mask==0 */ for(i=j=0; i<nKeyword; i++){ if( aKeywordTable[i].mask==0 ) continue; if( j<i ){ aKeywordTable[j] = aKeywordTable[i]; } |
︙ | ︙ | |||
437 438 439 440 441 442 443 | qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare3); /* Figure out how big to make the hash table in order to minimize the ** number of collisions */ bestSize = nKeyword; bestCount = nKeyword*nKeyword; for(i=nKeyword/2; i<=2*nKeyword; i++){ | | | | | | | | < | | | | | | | | | > | | | | > > > | | | > | | | > > | | | > | | | | > > > | | | | | 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 | qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare3); /* Figure out how big to make the hash table in order to minimize the ** number of collisions */ bestSize = nKeyword; bestCount = nKeyword*nKeyword; for(i=nKeyword/2; i<=2*nKeyword; i++){ for(j=0; j<i; j++) aKWHash[j] = 0; for(j=0; j<nKeyword; j++){ h = aKeywordTable[j].hash % i; aKWHash[h] *= 2; aKWHash[h]++; } for(j=count=0; j<i; j++) count += aKWHash[j]; if( count<bestCount ){ bestCount = count; bestSize = i; } } /* Compute the hash */ for(i=0; i<bestSize; i++) aKWHash[i] = 0; for(i=0; i<nKeyword; i++){ h = aKeywordTable[i].hash % bestSize; aKeywordTable[i].iNext = aKWHash[h]; aKWHash[h] = i+1; } /* Begin generating code */ printf("%s", zHdr); printf("/* Hash score: %d */\n", bestCount); printf("/* zKWText[] encodes %d bytes of keyword text in %d bytes */\n", totalLen + nKeyword, nChar+1 ); for(i=j=k=0; i<nKeyword; i++){ Keyword *p = &aKeywordTable[i]; if( p->substrId ) continue; memcpy(&zKWText[k], p->zName, p->len); k += p->len; if( j+p->len>70 ){ printf("%*s */\n", 74-j, ""); j = 0; } if( j==0 ){ printf("/* "); j = 8; } printf("%s", p->zName); j += p->len; } if( j>0 ){ printf("%*s */\n", 74-j, ""); } printf("static const char zKWText[%d] = {\n", nChar); zKWText[nChar] = 0; for(i=j=0; i<k; i++){ if( j==0 ){ printf(" "); } if( zKWText[i]==0 ){ printf("0"); }else{ printf("'%c',", zKWText[i]); } j += 4; if( j>68 ){ printf("\n"); j = 0; } } if( j>0 ) printf("\n"); printf("};\n"); printf("/* aKWHash[i] is the hash value for the i-th keyword */\n"); printf("static const unsigned char aKWHash[%d] = {\n", bestSize); for(i=j=0; i<bestSize; i++){ if( j==0 ) printf(" "); printf(" %3d,", aKWHash[i]); j++; if( j>12 ){ printf("\n"); j = 0; } } printf("%s};\n", j==0 ? "" : "\n"); printf("/* aKWNext[] forms the hash collision chain. If aKWHash[i]==0\n"); printf("** then the i-th keyword has no more hash collisions. Otherwise,\n"); printf("** the next keyword with the same hash is aKWHash[i]-1. */\n"); printf("static const unsigned char aKWNext[%d] = {\n", nKeyword); for(i=j=0; i<nKeyword; i++){ if( j==0 ) printf(" "); printf(" %3d,", aKeywordTable[i].iNext); j++; if( j>12 ){ printf("\n"); j = 0; } } printf("%s};\n", j==0 ? "" : "\n"); printf("/* aKWLen[i] is the length (in bytes) of the i-th keyword */\n"); printf("static const unsigned char aKWLen[%d] = {\n", nKeyword); for(i=j=0; i<nKeyword; i++){ if( j==0 ) printf(" "); printf(" %3d,", aKeywordTable[i].len+aKeywordTable[i].prefix); j++; if( j>12 ){ printf("\n"); j = 0; } } printf("%s};\n", j==0 ? "" : "\n"); printf("/* aKWOffset[i] is the index into zKWText[] of the start of\n"); printf("** the text for the i-th keyword. */\n"); printf("static const unsigned short int aKWOffset[%d] = {\n", nKeyword); for(i=j=0; i<nKeyword; i++){ if( j==0 ) printf(" "); printf(" %3d,", aKeywordTable[i].offset); j++; if( j>12 ){ printf("\n"); j = 0; } } printf("%s};\n", j==0 ? "" : "\n"); printf("/* aKWCode[i] is the parser symbol code for the i-th keyword */\n"); printf("static const unsigned char aKWCode[%d] = {\n", nKeyword); for(i=j=0; i<nKeyword; i++){ char *zToken = aKeywordTable[i].zTokenType; if( j==0 ) printf(" "); printf("%s,%*s", zToken, (int)(14-strlen(zToken)), ""); j++; if( j>=5 ){ printf("\n"); j = 0; } } printf("%s};\n", j==0 ? "" : "\n"); printf("/* Check to see if z[0..n-1] is a keyword. If it is, write the\n"); printf("** parser symbol code for that keyword into *pType. Always\n"); printf("** return the integer n (the length of the token). */\n"); printf("static int keywordCode(const char *z, int n, int *pType){\n"); printf(" int i, j;\n"); printf(" const char *zKW;\n"); printf(" if( n>=2 ){\n"); printf(" i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) %% %d;\n", bestSize); printf(" for(i=((int)aKWHash[i])-1; i>=0; i=((int)aKWNext[i])-1){\n"); printf(" if( aKWLen[i]!=n ) continue;\n"); printf(" j = 0;\n"); printf(" zKW = &zKWText[aKWOffset[i]];\n"); printf("#ifdef SQLITE_ASCII\n"); printf(" while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }\n"); printf("#endif\n"); printf("#ifdef SQLITE_EBCDIC\n"); printf(" while( j<n && toupper(z[j])==zKW[j] ){ j++; }\n"); printf("#endif\n"); printf(" if( j<n ) continue;\n"); for(i=0; i<nKeyword; i++){ printf(" testcase( i==%d ); /* %s */\n", i, aKeywordTable[i].zOrigName); } printf(" *pType = aKWCode[i];\n"); printf(" break;\n"); printf(" }\n"); printf(" }\n"); printf(" return n;\n"); printf("}\n"); printf("int sqlite3KeywordCode(const unsigned char *z, int n){\n"); printf(" int id = TK_ID;\n"); |
︙ | ︙ |