1 /* 2 ** 2010 July 12 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ****************************************************************************** 12 ** 13 ** This file contains an implementation of the "dbstat" virtual table. 14 ** 15 ** The dbstat virtual table is used to extract low-level storage 16 ** information from an SQLite database in order to implement the 17 ** "sqlite3_analyzer" utility. See the ../tool/spaceanal.tcl script 18 ** for an example implementation. 19 ** 20 ** Additional information is available on the "dbstat.html" page of the 21 ** official SQLite documentation. 22 */ 23 24 #include "sqliteInt.h" /* Requires access to internal data structures */ 25 #if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \ 26 && !defined(SQLITE_OMIT_VIRTUALTABLE) 27 28 /* 29 ** Page paths: 30 ** 31 ** The value of the 'path' column describes the path taken from the 32 ** root-node of the b-tree structure to each page. The value of the 33 ** root-node path is '/'. 34 ** 35 ** The value of the path for the left-most child page of the root of 36 ** a b-tree is '/000/'. (Btrees store content ordered from left to right 37 ** so the pages to the left have smaller keys than the pages to the right.) 38 ** The next to left-most child of the root page is 39 ** '/001', and so on, each sibling page identified by a 3-digit hex 40 ** value. The children of the 451st left-most sibling have paths such 41 ** as '/1c2/000/, '/1c2/001/' etc. 42 ** 43 ** Overflow pages are specified by appending a '+' character and a 44 ** six-digit hexadecimal value to the path to the cell they are linked 45 ** from. For example, the three overflow pages in a chain linked from 46 ** the left-most cell of the 450th child of the root page are identified 47 ** by the paths: 48 ** 49 ** '/1c2/000+000000' // First page in overflow chain 50 ** '/1c2/000+000001' // Second page in overflow chain 51 ** '/1c2/000+000002' // Third page in overflow chain 52 ** 53 ** If the paths are sorted using the BINARY collation sequence, then 54 ** the overflow pages associated with a cell will appear earlier in the 55 ** sort-order than its child page: 56 ** 57 ** '/1c2/000/' // Left-most child of 451st child of root 58 */ 59 static const char zDbstatSchema[] = 60 "CREATE TABLE x(" 61 " name TEXT," /* 0 Name of table or index */ 62 " path TEXT," /* 1 Path to page from root (NULL for agg) */ 63 " pageno INTEGER," /* 2 Page number (page count for aggregates) */ 64 " pagetype TEXT," /* 3 'internal', 'leaf', 'overflow', or NULL */ 65 " ncell INTEGER," /* 4 Cells on page (0 for overflow) */ 66 " payload INTEGER," /* 5 Bytes of payload on this page */ 67 " unused INTEGER," /* 6 Bytes of unused space on this page */ 68 " mx_payload INTEGER," /* 7 Largest payload size of all cells */ 69 " pgoffset INTEGER," /* 8 Offset of page in file (NULL for agg) */ 70 " pgsize INTEGER," /* 9 Size of the page (sum for aggregate) */ 71 " schema TEXT HIDDEN," /* 10 Database schema being analyzed */ 72 " aggregate BOOLEAN HIDDEN" /* 11 aggregate info for each table */ 73 ")" 74 ; 75 76 /* Forward reference to data structured used in this module */ 77 typedef struct StatTable StatTable; 78 typedef struct StatCursor StatCursor; 79 typedef struct StatPage StatPage; 80 typedef struct StatCell StatCell; 81 82 /* Size information for a single cell within a btree page */ 83 struct StatCell { 84 int nLocal; /* Bytes of local payload */ 85 u32 iChildPg; /* Child node (or 0 if this is a leaf) */ 86 int nOvfl; /* Entries in aOvfl[] */ 87 u32 *aOvfl; /* Array of overflow page numbers */ 88 int nLastOvfl; /* Bytes of payload on final overflow page */ 89 int iOvfl; /* Iterates through aOvfl[] */ 90 }; 91 92 /* Size information for a single btree page */ 93 struct StatPage { 94 u32 iPgno; /* Page number */ 95 DbPage *pPg; /* Page content */ 96 int iCell; /* Current cell */ 97 98 char *zPath; /* Path to this page */ 99 100 /* Variables populated by statDecodePage(): */ 101 u8 flags; /* Copy of flags byte */ 102 int nCell; /* Number of cells on page */ 103 int nUnused; /* Number of unused bytes on page */ 104 StatCell *aCell; /* Array of parsed cells */ 105 u32 iRightChildPg; /* Right-child page number (or 0) */ 106 int nMxPayload; /* Largest payload of any cell on the page */ 107 }; 108 109 /* The cursor for scanning the dbstat virtual table */ 110 struct StatCursor { 111 sqlite3_vtab_cursor base; /* base class. MUST BE FIRST! */ 112 sqlite3_stmt *pStmt; /* Iterates through set of root pages */ 113 u8 isEof; /* After pStmt has returned SQLITE_DONE */ 114 u8 isAgg; /* Aggregate results for each table */ 115 int iDb; /* Schema used for this query */ 116 117 StatPage aPage[32]; /* Pages in path to current page */ 118 int iPage; /* Current entry in aPage[] */ 119 120 /* Values to return. */ 121 u32 iPageno; /* Value of 'pageno' column */ 122 char *zName; /* Value of 'name' column */ 123 char *zPath; /* Value of 'path' column */ 124 char *zPagetype; /* Value of 'pagetype' column */ 125 int nPage; /* Number of pages in current btree */ 126 int nCell; /* Value of 'ncell' column */ 127 int nMxPayload; /* Value of 'mx_payload' column */ 128 i64 nUnused; /* Value of 'unused' column */ 129 i64 nPayload; /* Value of 'payload' column */ 130 i64 iOffset; /* Value of 'pgOffset' column */ 131 i64 szPage; /* Value of 'pgSize' column */ 132 }; 133 134 /* An instance of the DBSTAT virtual table */ 135 struct StatTable { 136 sqlite3_vtab base; /* base class. MUST BE FIRST! */ 137 sqlite3 *db; /* Database connection that owns this vtab */ 138 int iDb; /* Index of database to analyze */ 139 }; 140 141 #ifndef get2byte 142 # define get2byte(x) ((x)[0]<<8 | (x)[1]) 143 #endif 144 145 /* 146 ** Connect to or create a new DBSTAT virtual table. 147 */ 148 static int statConnect( 149 sqlite3 *db, 150 void *pAux, 151 int argc, const char *const*argv, 152 sqlite3_vtab **ppVtab, 153 char **pzErr 154 ){ 155 StatTable *pTab = 0; 156 int rc = SQLITE_OK; 157 int iDb; 158 159 if( argc>=4 ){ 160 Token nm; 161 sqlite3TokenInit(&nm, (char*)argv[3]); 162 iDb = sqlite3FindDb(db, &nm); 163 if( iDb<0 ){ 164 *pzErr = sqlite3_mprintf("no such database: %s", argv[3]); 165 return SQLITE_ERROR; 166 } 167 }else{ 168 iDb = 0; 169 } 170 sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY); 171 rc = sqlite3_declare_vtab(db, zDbstatSchema); 172 if( rc==SQLITE_OK ){ 173 pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable)); 174 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT; 175 } 176 177 assert( rc==SQLITE_OK || pTab==0 ); 178 if( rc==SQLITE_OK ){ 179 memset(pTab, 0, sizeof(StatTable)); 180 pTab->db = db; 181 pTab->iDb = iDb; 182 } 183 184 *ppVtab = (sqlite3_vtab*)pTab; 185 return rc; 186 } 187 188 /* 189 ** Disconnect from or destroy the DBSTAT virtual table. 190 */ 191 static int statDisconnect(sqlite3_vtab *pVtab){ 192 sqlite3_free(pVtab); 193 return SQLITE_OK; 194 } 195 196 /* 197 ** Compute the best query strategy and return the result in idxNum. 198 ** 199 ** idxNum-Bit Meaning 200 ** ---------- ---------------------------------------------- 201 ** 0x01 There is a schema=? term in the WHERE clause 202 ** 0x02 There is a name=? term in the WHERE clause 203 ** 0x04 There is an aggregate=? term in the WHERE clause 204 ** 0x08 Output should be ordered by name and path 205 */ 206 static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ 207 int i; 208 int iSchema = -1; 209 int iName = -1; 210 int iAgg = -1; 211 212 /* Look for a valid schema=? constraint. If found, change the idxNum to 213 ** 1 and request the value of that constraint be sent to xFilter. And 214 ** lower the cost estimate to encourage the constrained version to be 215 ** used. 216 */ 217 for(i=0; i<pIdxInfo->nConstraint; i++){ 218 if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; 219 if( pIdxInfo->aConstraint[i].usable==0 ){ 220 /* Force DBSTAT table should always be the right-most table in a join */ 221 return SQLITE_CONSTRAINT; 222 } 223 switch( pIdxInfo->aConstraint[i].iColumn ){ 224 case 0: { /* name */ 225 iName = i; 226 break; 227 } 228 case 10: { /* schema */ 229 iSchema = i; 230 break; 231 } 232 case 11: { /* aggregate */ 233 iAgg = i; 234 break; 235 } 236 } 237 } 238 i = 0; 239 if( iSchema>=0 ){ 240 pIdxInfo->aConstraintUsage[iSchema].argvIndex = ++i; 241 pIdxInfo->aConstraintUsage[iSchema].omit = 1; 242 pIdxInfo->idxNum |= 0x01; 243 } 244 if( iName>=0 ){ 245 pIdxInfo->aConstraintUsage[iName].argvIndex = ++i; 246 pIdxInfo->idxNum |= 0x02; 247 } 248 if( iAgg>=0 ){ 249 pIdxInfo->aConstraintUsage[iAgg].argvIndex = ++i; 250 pIdxInfo->idxNum |= 0x04; 251 } 252 pIdxInfo->estimatedCost = 1.0; 253 254 /* Records are always returned in ascending order of (name, path). 255 ** If this will satisfy the client, set the orderByConsumed flag so that 256 ** SQLite does not do an external sort. 257 */ 258 if( ( pIdxInfo->nOrderBy==1 259 && pIdxInfo->aOrderBy[0].iColumn==0 260 && pIdxInfo->aOrderBy[0].desc==0 261 ) || 262 ( pIdxInfo->nOrderBy==2 263 && pIdxInfo->aOrderBy[0].iColumn==0 264 && pIdxInfo->aOrderBy[0].desc==0 265 && pIdxInfo->aOrderBy[1].iColumn==1 266 && pIdxInfo->aOrderBy[1].desc==0 267 ) 268 ){ 269 pIdxInfo->orderByConsumed = 1; 270 pIdxInfo->idxNum |= 0x08; 271 } 272 273 return SQLITE_OK; 274 } 275 276 /* 277 ** Open a new DBSTAT cursor. 278 */ 279 static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 280 StatTable *pTab = (StatTable *)pVTab; 281 StatCursor *pCsr; 282 283 pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor)); 284 if( pCsr==0 ){ 285 return SQLITE_NOMEM_BKPT; 286 }else{ 287 memset(pCsr, 0, sizeof(StatCursor)); 288 pCsr->base.pVtab = pVTab; 289 pCsr->iDb = pTab->iDb; 290 } 291 292 *ppCursor = (sqlite3_vtab_cursor *)pCsr; 293 return SQLITE_OK; 294 } 295 296 static void statClearCells(StatPage *p){ 297 int i; 298 if( p->aCell ){ 299 for(i=0; i<p->nCell; i++){ 300 sqlite3_free(p->aCell[i].aOvfl); 301 } 302 sqlite3_free(p->aCell); 303 } 304 p->nCell = 0; 305 p->aCell = 0; 306 } 307 308 static void statClearPage(StatPage *p){ 309 statClearCells(p); 310 sqlite3PagerUnref(p->pPg); 311 sqlite3_free(p->zPath); 312 memset(p, 0, sizeof(StatPage)); 313 } 314 315 static void statResetCsr(StatCursor *pCsr){ 316 int i; 317 sqlite3_reset(pCsr->pStmt); 318 for(i=0; i<ArraySize(pCsr->aPage); i++){ 319 statClearPage(&pCsr->aPage[i]); 320 } 321 pCsr->iPage = 0; 322 sqlite3_free(pCsr->zPath); 323 pCsr->zPath = 0; 324 pCsr->isEof = 0; 325 } 326 327 /* Resize the space-used counters inside of the cursor */ 328 static void statResetCounts(StatCursor *pCsr){ 329 pCsr->nCell = 0; 330 pCsr->nMxPayload = 0; 331 pCsr->nUnused = 0; 332 pCsr->nPayload = 0; 333 pCsr->szPage = 0; 334 pCsr->nPage = 0; 335 } 336 337 /* 338 ** Close a DBSTAT cursor. 339 */ 340 static int statClose(sqlite3_vtab_cursor *pCursor){ 341 StatCursor *pCsr = (StatCursor *)pCursor; 342 statResetCsr(pCsr); 343 sqlite3_finalize(pCsr->pStmt); 344 sqlite3_free(pCsr); 345 return SQLITE_OK; 346 } 347 348 /* 349 ** For a single cell on a btree page, compute the number of bytes of 350 ** content (payload) stored on that page. That is to say, compute the 351 ** number of bytes of content not found on overflow pages. 352 */ 353 static int getLocalPayload( 354 int nUsable, /* Usable bytes per page */ 355 u8 flags, /* Page flags */ 356 int nTotal /* Total record (payload) size */ 357 ){ 358 int nLocal; 359 int nMinLocal; 360 int nMaxLocal; 361 362 if( flags==0x0D ){ /* Table leaf node */ 363 nMinLocal = (nUsable - 12) * 32 / 255 - 23; 364 nMaxLocal = nUsable - 35; 365 }else{ /* Index interior and leaf nodes */ 366 nMinLocal = (nUsable - 12) * 32 / 255 - 23; 367 nMaxLocal = (nUsable - 12) * 64 / 255 - 23; 368 } 369 370 nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4); 371 if( nLocal>nMaxLocal ) nLocal = nMinLocal; 372 return nLocal; 373 } 374 375 /* Populate the StatPage object with information about the all 376 ** cells found on the page currently under analysis. 377 */ 378 static int statDecodePage(Btree *pBt, StatPage *p){ 379 int nUnused; 380 int iOff; 381 int nHdr; 382 int isLeaf; 383 int szPage; 384 385 u8 *aData = sqlite3PagerGetData(p->pPg); 386 u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0]; 387 388 p->flags = aHdr[0]; 389 if( p->flags==0x0A || p->flags==0x0D ){ 390 isLeaf = 1; 391 nHdr = 8; 392 }else if( p->flags==0x05 || p->flags==0x02 ){ 393 isLeaf = 0; 394 nHdr = 12; 395 }else{ 396 goto statPageIsCorrupt; 397 } 398 if( p->iPgno==1 ) nHdr += 100; 399 p->nCell = get2byte(&aHdr[3]); 400 p->nMxPayload = 0; 401 szPage = sqlite3BtreeGetPageSize(pBt); 402 403 nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell; 404 nUnused += (int)aHdr[7]; 405 iOff = get2byte(&aHdr[1]); 406 while( iOff ){ 407 int iNext; 408 if( iOff>=szPage ) goto statPageIsCorrupt; 409 nUnused += get2byte(&aData[iOff+2]); 410 iNext = get2byte(&aData[iOff]); 411 if( iNext<iOff+4 && iNext>0 ) goto statPageIsCorrupt; 412 iOff = iNext; 413 } 414 p->nUnused = nUnused; 415 p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]); 416 417 if( p->nCell ){ 418 int i; /* Used to iterate through cells */ 419 int nUsable; /* Usable bytes per page */ 420 421 sqlite3BtreeEnter(pBt); 422 nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt); 423 sqlite3BtreeLeave(pBt); 424 p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell)); 425 if( p->aCell==0 ) return SQLITE_NOMEM_BKPT; 426 memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell)); 427 428 for(i=0; i<p->nCell; i++){ 429 StatCell *pCell = &p->aCell[i]; 430 431 iOff = get2byte(&aData[nHdr+i*2]); 432 if( iOff<nHdr || iOff>=szPage ) goto statPageIsCorrupt; 433 if( !isLeaf ){ 434 pCell->iChildPg = sqlite3Get4byte(&aData[iOff]); 435 iOff += 4; 436 } 437 if( p->flags==0x05 ){ 438 /* A table interior node. nPayload==0. */ 439 }else{ 440 u32 nPayload; /* Bytes of payload total (local+overflow) */ 441 int nLocal; /* Bytes of payload stored locally */ 442 iOff += getVarint32(&aData[iOff], nPayload); 443 if( p->flags==0x0D ){ 444 u64 dummy; 445 iOff += sqlite3GetVarint(&aData[iOff], &dummy); 446 } 447 if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload; 448 nLocal = getLocalPayload(nUsable, p->flags, nPayload); 449 if( nLocal<0 ) goto statPageIsCorrupt; 450 pCell->nLocal = nLocal; 451 assert( nPayload>=(u32)nLocal ); 452 assert( nLocal<=(nUsable-35) ); 453 if( nPayload>(u32)nLocal ){ 454 int j; 455 int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4); 456 if( iOff+nLocal>nUsable || nPayload>0x7fffffff ){ 457 goto statPageIsCorrupt; 458 } 459 pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4); 460 pCell->nOvfl = nOvfl; 461 pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl); 462 if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT; 463 pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]); 464 for(j=1; j<nOvfl; j++){ 465 int rc; 466 u32 iPrev = pCell->aOvfl[j-1]; 467 DbPage *pPg = 0; 468 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0); 469 if( rc!=SQLITE_OK ){ 470 assert( pPg==0 ); 471 return rc; 472 } 473 pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg)); 474 sqlite3PagerUnref(pPg); 475 } 476 } 477 } 478 } 479 } 480 481 return SQLITE_OK; 482 483 statPageIsCorrupt: 484 p->flags = 0; 485 statClearCells(p); 486 return SQLITE_OK; 487 } 488 489 /* 490 ** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on 491 ** the current value of pCsr->iPageno. 492 */ 493 static void statSizeAndOffset(StatCursor *pCsr){ 494 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab; 495 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt; 496 Pager *pPager = sqlite3BtreePager(pBt); 497 sqlite3_file *fd; 498 sqlite3_int64 x[2]; 499 500 /* If connected to a ZIPVFS backend, find the page size and 501 ** offset from ZIPVFS. 502 */ 503 fd = sqlite3PagerFile(pPager); 504 x[0] = pCsr->iPageno; 505 if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){ 506 pCsr->iOffset = x[0]; 507 pCsr->szPage += x[1]; 508 }else{ 509 /* Not ZIPVFS: The default page size and offset */ 510 pCsr->szPage += sqlite3BtreeGetPageSize(pBt); 511 pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1); 512 } 513 } 514 515 /* 516 ** Move a DBSTAT cursor to the next entry. Normally, the next 517 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0), 518 ** the next entry is the next btree. 519 */ 520 static int statNext(sqlite3_vtab_cursor *pCursor){ 521 int rc; 522 int nPayload; 523 char *z; 524 StatCursor *pCsr = (StatCursor *)pCursor; 525 StatTable *pTab = (StatTable *)pCursor->pVtab; 526 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt; 527 Pager *pPager = sqlite3BtreePager(pBt); 528 529 sqlite3_free(pCsr->zPath); 530 pCsr->zPath = 0; 531 532 statNextRestart: 533 if( pCsr->aPage[0].pPg==0 ){ 534 /* Start measuring space on the next btree */ 535 statResetCounts(pCsr); 536 rc = sqlite3_step(pCsr->pStmt); 537 if( rc==SQLITE_ROW ){ 538 int nPage; 539 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1); 540 sqlite3PagerPagecount(pPager, &nPage); 541 if( nPage==0 ){ 542 pCsr->isEof = 1; 543 return sqlite3_reset(pCsr->pStmt); 544 } 545 rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0); 546 pCsr->aPage[0].iPgno = iRoot; 547 pCsr->aPage[0].iCell = 0; 548 if( !pCsr->isAgg ){ 549 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/"); 550 if( z==0 ) rc = SQLITE_NOMEM_BKPT; 551 } 552 pCsr->iPage = 0; 553 pCsr->nPage = 1; 554 }else{ 555 pCsr->isEof = 1; 556 return sqlite3_reset(pCsr->pStmt); 557 } 558 }else{ 559 /* Continue analyzing the btree previously started */ 560 StatPage *p = &pCsr->aPage[pCsr->iPage]; 561 if( !pCsr->isAgg ) statResetCounts(pCsr); 562 while( p->iCell<p->nCell ){ 563 StatCell *pCell = &p->aCell[p->iCell]; 564 while( pCell->iOvfl<pCell->nOvfl ){ 565 int nUsable, iOvfl; 566 sqlite3BtreeEnter(pBt); 567 nUsable = sqlite3BtreeGetPageSize(pBt) - 568 sqlite3BtreeGetReserveNoMutex(pBt); 569 sqlite3BtreeLeave(pBt); 570 pCsr->nPage++; 571 statSizeAndOffset(pCsr); 572 if( pCell->iOvfl<pCell->nOvfl-1 ){ 573 pCsr->nPayload += nUsable - 4; 574 }else{ 575 pCsr->nPayload += pCell->nLastOvfl; 576 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl; 577 } 578 iOvfl = pCell->iOvfl; 579 pCell->iOvfl++; 580 if( !pCsr->isAgg ){ 581 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0); 582 pCsr->iPageno = pCell->aOvfl[iOvfl]; 583 pCsr->zPagetype = "overflow"; 584 pCsr->zPath = z = sqlite3_mprintf( 585 "%s%.3x+%.6x", p->zPath, p->iCell, iOvfl 586 ); 587 return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK; 588 } 589 } 590 if( p->iRightChildPg ) break; 591 p->iCell++; 592 } 593 594 if( !p->iRightChildPg || p->iCell>p->nCell ){ 595 statClearPage(p); 596 if( pCsr->iPage>0 ){ 597 pCsr->iPage--; 598 }else if( pCsr->isAgg ){ 599 /* label-statNext-done: When computing aggregate space usage over 600 ** an entire btree, this is the exit point from this function */ 601 return SQLITE_OK; 602 } 603 goto statNextRestart; /* Tail recursion */ 604 } 605 pCsr->iPage++; 606 if( pCsr->iPage>=ArraySize(pCsr->aPage) ){ 607 statResetCsr(pCsr); 608 return SQLITE_CORRUPT_BKPT; 609 } 610 assert( p==&pCsr->aPage[pCsr->iPage-1] ); 611 612 if( p->iCell==p->nCell ){ 613 p[1].iPgno = p->iRightChildPg; 614 }else{ 615 p[1].iPgno = p->aCell[p->iCell].iChildPg; 616 } 617 rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0); 618 pCsr->nPage++; 619 p[1].iCell = 0; 620 if( !pCsr->isAgg ){ 621 p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell); 622 if( z==0 ) rc = SQLITE_NOMEM_BKPT; 623 } 624 p->iCell++; 625 } 626 627 628 /* Populate the StatCursor fields with the values to be returned 629 ** by the xColumn() and xRowid() methods. 630 */ 631 if( rc==SQLITE_OK ){ 632 int i; 633 StatPage *p = &pCsr->aPage[pCsr->iPage]; 634 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0); 635 pCsr->iPageno = p->iPgno; 636 637 rc = statDecodePage(pBt, p); 638 if( rc==SQLITE_OK ){ 639 statSizeAndOffset(pCsr); 640 641 switch( p->flags ){ 642 case 0x05: /* table internal */ 643 case 0x02: /* index internal */ 644 pCsr->zPagetype = "internal"; 645 break; 646 case 0x0D: /* table leaf */ 647 case 0x0A: /* index leaf */ 648 pCsr->zPagetype = "leaf"; 649 break; 650 default: 651 pCsr->zPagetype = "corrupted"; 652 break; 653 } 654 pCsr->nCell += p->nCell; 655 pCsr->nUnused += p->nUnused; 656 if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload; 657 if( !pCsr->isAgg ){ 658 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath); 659 if( z==0 ) rc = SQLITE_NOMEM_BKPT; 660 } 661 nPayload = 0; 662 for(i=0; i<p->nCell; i++){ 663 nPayload += p->aCell[i].nLocal; 664 } 665 pCsr->nPayload += nPayload; 666 667 /* If computing aggregate space usage by btree, continue with the 668 ** next page. The loop will exit via the return at label-statNext-done 669 */ 670 if( pCsr->isAgg ) goto statNextRestart; 671 } 672 } 673 674 return rc; 675 } 676 677 static int statEof(sqlite3_vtab_cursor *pCursor){ 678 StatCursor *pCsr = (StatCursor *)pCursor; 679 return pCsr->isEof; 680 } 681 682 /* Initialize a cursor according to the query plan idxNum using the 683 ** arguments in argv[0]. See statBestIndex() for a description of the 684 ** meaning of the bits in idxNum. 685 */ 686 static int statFilter( 687 sqlite3_vtab_cursor *pCursor, 688 int idxNum, const char *idxStr, 689 int argc, sqlite3_value **argv 690 ){ 691 StatCursor *pCsr = (StatCursor *)pCursor; 692 StatTable *pTab = (StatTable*)(pCursor->pVtab); 693 sqlite3_str *pSql; /* Query of btrees to analyze */ 694 char *zSql; /* String value of pSql */ 695 int iArg = 0; /* Count of argv[] parameters used so far */ 696 int rc = SQLITE_OK; /* Result of this operation */ 697 const char *zName = 0; /* Only provide analysis of this table */ 698 699 statResetCsr(pCsr); 700 sqlite3_finalize(pCsr->pStmt); 701 pCsr->pStmt = 0; 702 if( idxNum & 0x01 ){ 703 /* schema=? constraint is present. Get its value */ 704 const char *zDbase = (const char*)sqlite3_value_text(argv[iArg++]); 705 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase); 706 if( pCsr->iDb<0 ){ 707 pCsr->iDb = 0; 708 pCsr->isEof = 1; 709 return SQLITE_OK; 710 } 711 }else{ 712 pCsr->iDb = pTab->iDb; 713 } 714 if( idxNum & 0x02 ){ 715 /* name=? constraint is present */ 716 zName = (const char*)sqlite3_value_text(argv[iArg++]); 717 } 718 if( idxNum & 0x04 ){ 719 /* aggregate=? constraint is present */ 720 pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0; 721 }else{ 722 pCsr->isAgg = 0; 723 } 724 pSql = sqlite3_str_new(pTab->db); 725 sqlite3_str_appendf(pSql, 726 "SELECT * FROM (" 727 "SELECT 'sqlite_schema' AS name,1 AS rootpage,'table' AS type" 728 " UNION ALL " 729 "SELECT name,rootpage,type" 730 " FROM \"%w\".sqlite_schema WHERE rootpage!=0)", 731 pTab->db->aDb[pCsr->iDb].zDbSName); 732 if( zName ){ 733 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName); 734 } 735 if( idxNum & 0x08 ){ 736 sqlite3_str_appendf(pSql, " ORDER BY name"); 737 } 738 zSql = sqlite3_str_finish(pSql); 739 if( zSql==0 ){ 740 return SQLITE_NOMEM_BKPT; 741 }else{ 742 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0); 743 sqlite3_free(zSql); 744 } 745 746 if( rc==SQLITE_OK ){ 747 rc = statNext(pCursor); 748 } 749 return rc; 750 } 751 752 static int statColumn( 753 sqlite3_vtab_cursor *pCursor, 754 sqlite3_context *ctx, 755 int i 756 ){ 757 StatCursor *pCsr = (StatCursor *)pCursor; 758 switch( i ){ 759 case 0: /* name */ 760 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT); 761 break; 762 case 1: /* path */ 763 if( !pCsr->isAgg ){ 764 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT); 765 } 766 break; 767 case 2: /* pageno */ 768 if( pCsr->isAgg ){ 769 sqlite3_result_int64(ctx, pCsr->nPage); 770 }else{ 771 sqlite3_result_int64(ctx, pCsr->iPageno); 772 } 773 break; 774 case 3: /* pagetype */ 775 if( !pCsr->isAgg ){ 776 sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC); 777 } 778 break; 779 case 4: /* ncell */ 780 sqlite3_result_int(ctx, pCsr->nCell); 781 break; 782 case 5: /* payload */ 783 sqlite3_result_int(ctx, pCsr->nPayload); 784 break; 785 case 6: /* unused */ 786 sqlite3_result_int(ctx, pCsr->nUnused); 787 break; 788 case 7: /* mx_payload */ 789 sqlite3_result_int(ctx, pCsr->nMxPayload); 790 break; 791 case 8: /* pgoffset */ 792 if( !pCsr->isAgg ){ 793 sqlite3_result_int64(ctx, pCsr->iOffset); 794 } 795 break; 796 case 9: /* pgsize */ 797 sqlite3_result_int(ctx, pCsr->szPage); 798 break; 799 case 10: { /* schema */ 800 sqlite3 *db = sqlite3_context_db_handle(ctx); 801 int iDb = pCsr->iDb; 802 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC); 803 break; 804 } 805 default: { /* aggregate */ 806 sqlite3_result_int(ctx, pCsr->isAgg); 807 break; 808 } 809 } 810 return SQLITE_OK; 811 } 812 813 static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ 814 StatCursor *pCsr = (StatCursor *)pCursor; 815 *pRowid = pCsr->iPageno; 816 return SQLITE_OK; 817 } 818 819 /* 820 ** Invoke this routine to register the "dbstat" virtual table module 821 */ 822 int sqlite3DbstatRegister(sqlite3 *db){ 823 static sqlite3_module dbstat_module = { 824 0, /* iVersion */ 825 statConnect, /* xCreate */ 826 statConnect, /* xConnect */ 827 statBestIndex, /* xBestIndex */ 828 statDisconnect, /* xDisconnect */ 829 statDisconnect, /* xDestroy */ 830 statOpen, /* xOpen - open a cursor */ 831 statClose, /* xClose - close a cursor */ 832 statFilter, /* xFilter - configure scan constraints */ 833 statNext, /* xNext - advance a cursor */ 834 statEof, /* xEof - check for end of scan */ 835 statColumn, /* xColumn - read data */ 836 statRowid, /* xRowid - read data */ 837 0, /* xUpdate */ 838 0, /* xBegin */ 839 0, /* xSync */ 840 0, /* xCommit */ 841 0, /* xRollback */ 842 0, /* xFindMethod */ 843 0, /* xRename */ 844 0, /* xSavepoint */ 845 0, /* xRelease */ 846 0, /* xRollbackTo */ 847 0 /* xShadowName */ 848 }; 849 return sqlite3_create_module(db, "dbstat", &dbstat_module, 0); 850 } 851 #elif defined(SQLITE_ENABLE_DBSTAT_VTAB) 852 int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; } 853 #endif /* SQLITE_ENABLE_DBSTAT_VTAB */ 854