Annotation of embedaddon/sqlite3/src/test_stat.c, revision 1.1
1.1 ! misho 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 formatting
! 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:
! 21: #ifndef SQLITE_AMALGAMATION
! 22: # include "sqliteInt.h"
! 23: #endif
! 24:
! 25: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 26:
! 27: /*
! 28: ** Page paths:
! 29: **
! 30: ** The value of the 'path' column describes the path taken from the
! 31: ** root-node of the b-tree structure to each page. The value of the
! 32: ** root-node path is '/'.
! 33: **
! 34: ** The value of the path for the left-most child page of the root of
! 35: ** a b-tree is '/000/'. (Btrees store content ordered from left to right
! 36: ** so the pages to the left have smaller keys than the pages to the right.)
! 37: ** The next to left-most child of the root page is
! 38: ** '/001', and so on, each sibling page identified by a 3-digit hex
! 39: ** value. The children of the 451st left-most sibling have paths such
! 40: ** as '/1c2/000/, '/1c2/001/' etc.
! 41: **
! 42: ** Overflow pages are specified by appending a '+' character and a
! 43: ** six-digit hexadecimal value to the path to the cell they are linked
! 44: ** from. For example, the three overflow pages in a chain linked from
! 45: ** the left-most cell of the 450th child of the root page are identified
! 46: ** by the paths:
! 47: **
! 48: ** '/1c2/000+000000' // First page in overflow chain
! 49: ** '/1c2/000+000001' // Second page in overflow chain
! 50: ** '/1c2/000+000002' // Third page in overflow chain
! 51: **
! 52: ** If the paths are sorted using the BINARY collation sequence, then
! 53: ** the overflow pages associated with a cell will appear earlier in the
! 54: ** sort-order than its child page:
! 55: **
! 56: ** '/1c2/000/' // Left-most child of 451st child of root
! 57: */
! 58: #define VTAB_SCHEMA \
! 59: "CREATE TABLE xx( " \
! 60: " name STRING, /* Name of table or index */" \
! 61: " path INTEGER, /* Path to page from root */" \
! 62: " pageno INTEGER, /* Page number */" \
! 63: " pagetype STRING, /* 'internal', 'leaf' or 'overflow' */" \
! 64: " ncell INTEGER, /* Cells on page (0 for overflow) */" \
! 65: " payload INTEGER, /* Bytes of payload on this page */" \
! 66: " unused INTEGER, /* Bytes of unused space on this page */" \
! 67: " mx_payload INTEGER, /* Largest payload size of all cells */" \
! 68: " pgoffset INTEGER, /* Offset of page in file */" \
! 69: " pgsize INTEGER /* Size of the page */" \
! 70: ");"
! 71:
! 72:
! 73: typedef struct StatTable StatTable;
! 74: typedef struct StatCursor StatCursor;
! 75: typedef struct StatPage StatPage;
! 76: typedef struct StatCell StatCell;
! 77:
! 78: struct StatCell {
! 79: int nLocal; /* Bytes of local payload */
! 80: u32 iChildPg; /* Child node (or 0 if this is a leaf) */
! 81: int nOvfl; /* Entries in aOvfl[] */
! 82: u32 *aOvfl; /* Array of overflow page numbers */
! 83: int nLastOvfl; /* Bytes of payload on final overflow page */
! 84: int iOvfl; /* Iterates through aOvfl[] */
! 85: };
! 86:
! 87: struct StatPage {
! 88: u32 iPgno;
! 89: DbPage *pPg;
! 90: int iCell;
! 91:
! 92: char *zPath; /* Path to this page */
! 93:
! 94: /* Variables populated by statDecodePage(): */
! 95: u8 flags; /* Copy of flags byte */
! 96: int nCell; /* Number of cells on page */
! 97: int nUnused; /* Number of unused bytes on page */
! 98: StatCell *aCell; /* Array of parsed cells */
! 99: u32 iRightChildPg; /* Right-child page number (or 0) */
! 100: int nMxPayload; /* Largest payload of any cell on this page */
! 101: };
! 102:
! 103: struct StatCursor {
! 104: sqlite3_vtab_cursor base;
! 105: sqlite3_stmt *pStmt; /* Iterates through set of root pages */
! 106: int isEof; /* After pStmt has returned SQLITE_DONE */
! 107:
! 108: StatPage aPage[32];
! 109: int iPage; /* Current entry in aPage[] */
! 110:
! 111: /* Values to return. */
! 112: char *zName; /* Value of 'name' column */
! 113: char *zPath; /* Value of 'path' column */
! 114: u32 iPageno; /* Value of 'pageno' column */
! 115: char *zPagetype; /* Value of 'pagetype' column */
! 116: int nCell; /* Value of 'ncell' column */
! 117: int nPayload; /* Value of 'payload' column */
! 118: int nUnused; /* Value of 'unused' column */
! 119: int nMxPayload; /* Value of 'mx_payload' column */
! 120: i64 iOffset; /* Value of 'pgOffset' column */
! 121: int szPage; /* Value of 'pgSize' column */
! 122: };
! 123:
! 124: struct StatTable {
! 125: sqlite3_vtab base;
! 126: sqlite3 *db;
! 127: };
! 128:
! 129: #ifndef get2byte
! 130: # define get2byte(x) ((x)[0]<<8 | (x)[1])
! 131: #endif
! 132:
! 133: /*
! 134: ** Connect to or create a statvfs virtual table.
! 135: */
! 136: static int statConnect(
! 137: sqlite3 *db,
! 138: void *pAux,
! 139: int argc, const char *const*argv,
! 140: sqlite3_vtab **ppVtab,
! 141: char **pzErr
! 142: ){
! 143: StatTable *pTab;
! 144:
! 145: pTab = (StatTable *)sqlite3_malloc(sizeof(StatTable));
! 146: memset(pTab, 0, sizeof(StatTable));
! 147: pTab->db = db;
! 148:
! 149: sqlite3_declare_vtab(db, VTAB_SCHEMA);
! 150: *ppVtab = &pTab->base;
! 151: return SQLITE_OK;
! 152: }
! 153:
! 154: /*
! 155: ** Disconnect from or destroy a statvfs virtual table.
! 156: */
! 157: static int statDisconnect(sqlite3_vtab *pVtab){
! 158: sqlite3_free(pVtab);
! 159: return SQLITE_OK;
! 160: }
! 161:
! 162: /*
! 163: ** There is no "best-index". This virtual table always does a linear
! 164: ** scan of the binary VFS log file.
! 165: */
! 166: static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
! 167:
! 168: /* Records are always returned in ascending order of (name, path).
! 169: ** If this will satisfy the client, set the orderByConsumed flag so that
! 170: ** SQLite does not do an external sort.
! 171: */
! 172: if( ( pIdxInfo->nOrderBy==1
! 173: && pIdxInfo->aOrderBy[0].iColumn==0
! 174: && pIdxInfo->aOrderBy[0].desc==0
! 175: ) ||
! 176: ( pIdxInfo->nOrderBy==2
! 177: && pIdxInfo->aOrderBy[0].iColumn==0
! 178: && pIdxInfo->aOrderBy[0].desc==0
! 179: && pIdxInfo->aOrderBy[1].iColumn==1
! 180: && pIdxInfo->aOrderBy[1].desc==0
! 181: )
! 182: ){
! 183: pIdxInfo->orderByConsumed = 1;
! 184: }
! 185:
! 186: pIdxInfo->estimatedCost = 10.0;
! 187: return SQLITE_OK;
! 188: }
! 189:
! 190: /*
! 191: ** Open a new statvfs cursor.
! 192: */
! 193: static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
! 194: StatTable *pTab = (StatTable *)pVTab;
! 195: StatCursor *pCsr;
! 196: int rc;
! 197:
! 198: pCsr = (StatCursor *)sqlite3_malloc(sizeof(StatCursor));
! 199: memset(pCsr, 0, sizeof(StatCursor));
! 200: pCsr->base.pVtab = pVTab;
! 201:
! 202: rc = sqlite3_prepare_v2(pTab->db,
! 203: "SELECT 'sqlite_master' AS name, 1 AS rootpage, 'table' AS type"
! 204: " UNION ALL "
! 205: "SELECT name, rootpage, type FROM sqlite_master WHERE rootpage!=0"
! 206: " ORDER BY name", -1,
! 207: &pCsr->pStmt, 0
! 208: );
! 209: if( rc!=SQLITE_OK ){
! 210: sqlite3_free(pCsr);
! 211: return rc;
! 212: }
! 213:
! 214: *ppCursor = (sqlite3_vtab_cursor *)pCsr;
! 215: return SQLITE_OK;
! 216: }
! 217:
! 218: static void statClearPage(StatPage *p){
! 219: int i;
! 220: for(i=0; i<p->nCell; i++){
! 221: sqlite3_free(p->aCell[i].aOvfl);
! 222: }
! 223: sqlite3PagerUnref(p->pPg);
! 224: sqlite3_free(p->aCell);
! 225: sqlite3_free(p->zPath);
! 226: memset(p, 0, sizeof(StatPage));
! 227: }
! 228:
! 229: static void statResetCsr(StatCursor *pCsr){
! 230: int i;
! 231: sqlite3_reset(pCsr->pStmt);
! 232: for(i=0; i<ArraySize(pCsr->aPage); i++){
! 233: statClearPage(&pCsr->aPage[i]);
! 234: }
! 235: pCsr->iPage = 0;
! 236: sqlite3_free(pCsr->zPath);
! 237: pCsr->zPath = 0;
! 238: }
! 239:
! 240: /*
! 241: ** Close a statvfs cursor.
! 242: */
! 243: static int statClose(sqlite3_vtab_cursor *pCursor){
! 244: StatCursor *pCsr = (StatCursor *)pCursor;
! 245: statResetCsr(pCsr);
! 246: sqlite3_finalize(pCsr->pStmt);
! 247: sqlite3_free(pCsr);
! 248: return SQLITE_OK;
! 249: }
! 250:
! 251: static void getLocalPayload(
! 252: int nUsable, /* Usable bytes per page */
! 253: u8 flags, /* Page flags */
! 254: int nTotal, /* Total record (payload) size */
! 255: int *pnLocal /* OUT: Bytes stored locally */
! 256: ){
! 257: int nLocal;
! 258: int nMinLocal;
! 259: int nMaxLocal;
! 260:
! 261: if( flags==0x0D ){ /* Table leaf node */
! 262: nMinLocal = (nUsable - 12) * 32 / 255 - 23;
! 263: nMaxLocal = nUsable - 35;
! 264: }else{ /* Index interior and leaf nodes */
! 265: nMinLocal = (nUsable - 12) * 32 / 255 - 23;
! 266: nMaxLocal = (nUsable - 12) * 64 / 255 - 23;
! 267: }
! 268:
! 269: nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4);
! 270: if( nLocal>nMaxLocal ) nLocal = nMinLocal;
! 271: *pnLocal = nLocal;
! 272: }
! 273:
! 274: static int statDecodePage(Btree *pBt, StatPage *p){
! 275: int nUnused;
! 276: int iOff;
! 277: int nHdr;
! 278: int isLeaf;
! 279: int szPage;
! 280:
! 281: u8 *aData = sqlite3PagerGetData(p->pPg);
! 282: u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
! 283:
! 284: p->flags = aHdr[0];
! 285: p->nCell = get2byte(&aHdr[3]);
! 286: p->nMxPayload = 0;
! 287:
! 288: isLeaf = (p->flags==0x0A || p->flags==0x0D);
! 289: nHdr = 12 - isLeaf*4 + (p->iPgno==1)*100;
! 290:
! 291: nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
! 292: nUnused += (int)aHdr[7];
! 293: iOff = get2byte(&aHdr[1]);
! 294: while( iOff ){
! 295: nUnused += get2byte(&aData[iOff+2]);
! 296: iOff = get2byte(&aData[iOff]);
! 297: }
! 298: p->nUnused = nUnused;
! 299: p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
! 300: szPage = sqlite3BtreeGetPageSize(pBt);
! 301:
! 302: if( p->nCell ){
! 303: int i; /* Used to iterate through cells */
! 304: int nUsable = szPage - sqlite3BtreeGetReserve(pBt);
! 305:
! 306: p->aCell = sqlite3_malloc((p->nCell+1) * sizeof(StatCell));
! 307: memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
! 308:
! 309: for(i=0; i<p->nCell; i++){
! 310: StatCell *pCell = &p->aCell[i];
! 311:
! 312: iOff = get2byte(&aData[nHdr+i*2]);
! 313: if( !isLeaf ){
! 314: pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
! 315: iOff += 4;
! 316: }
! 317: if( p->flags==0x05 ){
! 318: /* A table interior node. nPayload==0. */
! 319: }else{
! 320: u32 nPayload; /* Bytes of payload total (local+overflow) */
! 321: int nLocal; /* Bytes of payload stored locally */
! 322: iOff += getVarint32(&aData[iOff], nPayload);
! 323: if( p->flags==0x0D ){
! 324: u64 dummy;
! 325: iOff += sqlite3GetVarint(&aData[iOff], &dummy);
! 326: }
! 327: if( nPayload>p->nMxPayload ) p->nMxPayload = nPayload;
! 328: getLocalPayload(nUsable, p->flags, nPayload, &nLocal);
! 329: pCell->nLocal = nLocal;
! 330: assert( nPayload>=nLocal );
! 331: assert( nLocal<=(nUsable-35) );
! 332: if( nPayload>nLocal ){
! 333: int j;
! 334: int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
! 335: pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
! 336: pCell->nOvfl = nOvfl;
! 337: pCell->aOvfl = sqlite3_malloc(sizeof(u32)*nOvfl);
! 338: pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
! 339: for(j=1; j<nOvfl; j++){
! 340: int rc;
! 341: u32 iPrev = pCell->aOvfl[j-1];
! 342: DbPage *pPg = 0;
! 343: rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg);
! 344: if( rc!=SQLITE_OK ){
! 345: assert( pPg==0 );
! 346: return rc;
! 347: }
! 348: pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
! 349: sqlite3PagerUnref(pPg);
! 350: }
! 351: }
! 352: }
! 353: }
! 354: }
! 355:
! 356: return SQLITE_OK;
! 357: }
! 358:
! 359: /*
! 360: ** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
! 361: ** the current value of pCsr->iPageno.
! 362: */
! 363: static void statSizeAndOffset(StatCursor *pCsr){
! 364: StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
! 365: Btree *pBt = pTab->db->aDb[0].pBt;
! 366: Pager *pPager = sqlite3BtreePager(pBt);
! 367: sqlite3_file *fd;
! 368: sqlite3_int64 x[2];
! 369:
! 370: /* The default page size and offset */
! 371: pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
! 372: pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
! 373:
! 374: /* If connected to a ZIPVFS backend, override the page size and
! 375: ** offset with actual values obtained from ZIPVFS.
! 376: */
! 377: fd = sqlite3PagerFile(pPager);
! 378: x[0] = pCsr->iPageno;
! 379: if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
! 380: pCsr->iOffset = x[0];
! 381: pCsr->szPage = x[1];
! 382: }
! 383: }
! 384:
! 385: /*
! 386: ** Move a statvfs cursor to the next entry in the file.
! 387: */
! 388: static int statNext(sqlite3_vtab_cursor *pCursor){
! 389: int rc;
! 390: int nPayload;
! 391: StatCursor *pCsr = (StatCursor *)pCursor;
! 392: StatTable *pTab = (StatTable *)pCursor->pVtab;
! 393: Btree *pBt = pTab->db->aDb[0].pBt;
! 394: Pager *pPager = sqlite3BtreePager(pBt);
! 395:
! 396: sqlite3_free(pCsr->zPath);
! 397: pCsr->zPath = 0;
! 398:
! 399: if( pCsr->aPage[0].pPg==0 ){
! 400: rc = sqlite3_step(pCsr->pStmt);
! 401: if( rc==SQLITE_ROW ){
! 402: int nPage;
! 403: u32 iRoot = sqlite3_column_int64(pCsr->pStmt, 1);
! 404: sqlite3PagerPagecount(pPager, &nPage);
! 405: if( nPage==0 ){
! 406: pCsr->isEof = 1;
! 407: return sqlite3_reset(pCsr->pStmt);
! 408: }
! 409: rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg);
! 410: pCsr->aPage[0].iPgno = iRoot;
! 411: pCsr->aPage[0].iCell = 0;
! 412: pCsr->aPage[0].zPath = sqlite3_mprintf("/");
! 413: pCsr->iPage = 0;
! 414: }else{
! 415: pCsr->isEof = 1;
! 416: return sqlite3_reset(pCsr->pStmt);
! 417: }
! 418: }else{
! 419:
! 420: /* Page p itself has already been visited. */
! 421: StatPage *p = &pCsr->aPage[pCsr->iPage];
! 422:
! 423: while( p->iCell<p->nCell ){
! 424: StatCell *pCell = &p->aCell[p->iCell];
! 425: if( pCell->iOvfl<pCell->nOvfl ){
! 426: int nUsable = sqlite3BtreeGetPageSize(pBt)-sqlite3BtreeGetReserve(pBt);
! 427: pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
! 428: pCsr->iPageno = pCell->aOvfl[pCell->iOvfl];
! 429: pCsr->zPagetype = "overflow";
! 430: pCsr->nCell = 0;
! 431: pCsr->nMxPayload = 0;
! 432: pCsr->zPath = sqlite3_mprintf(
! 433: "%s%.3x+%.6x", p->zPath, p->iCell, pCell->iOvfl
! 434: );
! 435: if( pCell->iOvfl<pCell->nOvfl-1 ){
! 436: pCsr->nUnused = 0;
! 437: pCsr->nPayload = nUsable - 4;
! 438: }else{
! 439: pCsr->nPayload = pCell->nLastOvfl;
! 440: pCsr->nUnused = nUsable - 4 - pCsr->nPayload;
! 441: }
! 442: pCell->iOvfl++;
! 443: statSizeAndOffset(pCsr);
! 444: return SQLITE_OK;
! 445: }
! 446: if( p->iRightChildPg ) break;
! 447: p->iCell++;
! 448: }
! 449:
! 450: while( !p->iRightChildPg || p->iCell>p->nCell ){
! 451: statClearPage(p);
! 452: if( pCsr->iPage==0 ) return statNext(pCursor);
! 453: pCsr->iPage--;
! 454: p = &pCsr->aPage[pCsr->iPage];
! 455: }
! 456: pCsr->iPage++;
! 457: assert( p==&pCsr->aPage[pCsr->iPage-1] );
! 458:
! 459: if( p->iCell==p->nCell ){
! 460: p[1].iPgno = p->iRightChildPg;
! 461: }else{
! 462: p[1].iPgno = p->aCell[p->iCell].iChildPg;
! 463: }
! 464: rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg);
! 465: p[1].iCell = 0;
! 466: p[1].zPath = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
! 467: p->iCell++;
! 468: }
! 469:
! 470:
! 471: /* Populate the StatCursor fields with the values to be returned
! 472: ** by the xColumn() and xRowid() methods.
! 473: */
! 474: if( rc==SQLITE_OK ){
! 475: int i;
! 476: StatPage *p = &pCsr->aPage[pCsr->iPage];
! 477: pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
! 478: pCsr->iPageno = p->iPgno;
! 479:
! 480: statDecodePage(pBt, p);
! 481: statSizeAndOffset(pCsr);
! 482:
! 483: switch( p->flags ){
! 484: case 0x05: /* table internal */
! 485: case 0x02: /* index internal */
! 486: pCsr->zPagetype = "internal";
! 487: break;
! 488: case 0x0D: /* table leaf */
! 489: case 0x0A: /* index leaf */
! 490: pCsr->zPagetype = "leaf";
! 491: break;
! 492: default:
! 493: pCsr->zPagetype = "corrupted";
! 494: break;
! 495: }
! 496: pCsr->nCell = p->nCell;
! 497: pCsr->nUnused = p->nUnused;
! 498: pCsr->nMxPayload = p->nMxPayload;
! 499: pCsr->zPath = sqlite3_mprintf("%s", p->zPath);
! 500: nPayload = 0;
! 501: for(i=0; i<p->nCell; i++){
! 502: nPayload += p->aCell[i].nLocal;
! 503: }
! 504: pCsr->nPayload = nPayload;
! 505: }
! 506:
! 507: return rc;
! 508: }
! 509:
! 510: static int statEof(sqlite3_vtab_cursor *pCursor){
! 511: StatCursor *pCsr = (StatCursor *)pCursor;
! 512: return pCsr->isEof;
! 513: }
! 514:
! 515: static int statFilter(
! 516: sqlite3_vtab_cursor *pCursor,
! 517: int idxNum, const char *idxStr,
! 518: int argc, sqlite3_value **argv
! 519: ){
! 520: StatCursor *pCsr = (StatCursor *)pCursor;
! 521:
! 522: statResetCsr(pCsr);
! 523: return statNext(pCursor);
! 524: }
! 525:
! 526: static int statColumn(
! 527: sqlite3_vtab_cursor *pCursor,
! 528: sqlite3_context *ctx,
! 529: int i
! 530: ){
! 531: StatCursor *pCsr = (StatCursor *)pCursor;
! 532: switch( i ){
! 533: case 0: /* name */
! 534: sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_STATIC);
! 535: break;
! 536: case 1: /* path */
! 537: sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
! 538: break;
! 539: case 2: /* pageno */
! 540: sqlite3_result_int64(ctx, pCsr->iPageno);
! 541: break;
! 542: case 3: /* pagetype */
! 543: sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
! 544: break;
! 545: case 4: /* ncell */
! 546: sqlite3_result_int(ctx, pCsr->nCell);
! 547: break;
! 548: case 5: /* payload */
! 549: sqlite3_result_int(ctx, pCsr->nPayload);
! 550: break;
! 551: case 6: /* unused */
! 552: sqlite3_result_int(ctx, pCsr->nUnused);
! 553: break;
! 554: case 7: /* mx_payload */
! 555: sqlite3_result_int(ctx, pCsr->nMxPayload);
! 556: break;
! 557: case 8: /* pgoffset */
! 558: sqlite3_result_int64(ctx, pCsr->iOffset);
! 559: break;
! 560: case 9: /* pgsize */
! 561: sqlite3_result_int(ctx, pCsr->szPage);
! 562: break;
! 563: }
! 564: return SQLITE_OK;
! 565: }
! 566:
! 567: static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
! 568: StatCursor *pCsr = (StatCursor *)pCursor;
! 569: *pRowid = pCsr->iPageno;
! 570: return SQLITE_OK;
! 571: }
! 572:
! 573: int sqlite3_dbstat_register(sqlite3 *db){
! 574: static sqlite3_module dbstat_module = {
! 575: 0, /* iVersion */
! 576: statConnect, /* xCreate */
! 577: statConnect, /* xConnect */
! 578: statBestIndex, /* xBestIndex */
! 579: statDisconnect, /* xDisconnect */
! 580: statDisconnect, /* xDestroy */
! 581: statOpen, /* xOpen - open a cursor */
! 582: statClose, /* xClose - close a cursor */
! 583: statFilter, /* xFilter - configure scan constraints */
! 584: statNext, /* xNext - advance a cursor */
! 585: statEof, /* xEof - check for end of scan */
! 586: statColumn, /* xColumn - read data */
! 587: statRowid, /* xRowid - read data */
! 588: 0, /* xUpdate */
! 589: 0, /* xBegin */
! 590: 0, /* xSync */
! 591: 0, /* xCommit */
! 592: 0, /* xRollback */
! 593: 0, /* xFindMethod */
! 594: 0, /* xRename */
! 595: };
! 596: sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
! 597: return SQLITE_OK;
! 598: }
! 599:
! 600: #endif
! 601:
! 602: #if defined(SQLITE_TEST) || TCLSH==2
! 603: #include <tcl.h>
! 604:
! 605: static int test_dbstat(
! 606: void *clientData,
! 607: Tcl_Interp *interp,
! 608: int objc,
! 609: Tcl_Obj *CONST objv[]
! 610: ){
! 611: #ifdef SQLITE_OMIT_VIRTUALTABLE
! 612: Tcl_AppendResult(interp, "dbstat not available because of "
! 613: "SQLITE_OMIT_VIRTUALTABLE", (void*)0);
! 614: return TCL_ERROR;
! 615: #else
! 616: struct SqliteDb { sqlite3 *db; };
! 617: char *zDb;
! 618: Tcl_CmdInfo cmdInfo;
! 619:
! 620: if( objc!=2 ){
! 621: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 622: return TCL_ERROR;
! 623: }
! 624:
! 625: zDb = Tcl_GetString(objv[1]);
! 626: if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
! 627: sqlite3* db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
! 628: sqlite3_dbstat_register(db);
! 629: }
! 630: return TCL_OK;
! 631: #endif
! 632: }
! 633:
! 634: int SqlitetestStat_Init(Tcl_Interp *interp){
! 635: Tcl_CreateObjCommand(interp, "register_dbstat_vtab", test_dbstat, 0, 0);
! 636: return TCL_OK;
! 637: }
! 638: #endif /* if defined(SQLITE_TEST) || TCLSH==2 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_stat.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src