Import SQLite 3.8.7.4.

third_party/sqlite/src/src/test_stat.c

 /*
 ** 2010 July 12
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 ******************************************************************************
 **
 ** This file contains an implementation of the "dbstat" virtual table.
 **
 ** The dbstat virtual table is used to extract low-level formatting
 ** information from an SQLite database in order to implement the
 ** "sqlite3_analyzer" utility.  See the ../tool/spaceanal.tcl script
 ** for an example implementation.
 */
 
-#include "sqliteInt.h"
+#ifndef SQLITE_AMALGAMATION
+# include "sqliteInt.h"
+#endif
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 
 /*
 ** Page paths:
 ** 
 **   The value of the 'path' column describes the path taken from the 
 **   root-node of the b-tree structure to each page. The value of the 
 **   root-node path is '/'.
 **
@@ skipping 23 matching lines @@
 */
 #define VTAB_SCHEMA                                                         \
   "CREATE TABLE xx( "                                                       \
   "  name       STRING,           /* Name of table or index */"             \
   "  path       INTEGER,          /* Path to page from root */"             \
   "  pageno     INTEGER,          /* Page number */"                        \
   "  pagetype   STRING,           /* 'internal', 'leaf' or 'overflow' */"   \
   "  ncell      INTEGER,          /* Cells on page (0 for overflow) */"     \
   "  payload    INTEGER,          /* Bytes of payload on this page */"      \
   "  unused     INTEGER,          /* Bytes of unused space on this page */" \
-  "  mx_payload INTEGER           /* Largest payload size of all cells */"  \
+  "  mx_payload INTEGER,          /* Largest payload size of all cells */"  \
+  "  pgoffset   INTEGER,          /* Offset of page in file */"             \
+  "  pgsize     INTEGER           /* Size of the page */"                   \
   ");"
 
-#if 0
-#define VTAB_SCHEMA2                                                        \
-  "CREATE TABLE yy( "                                                       \
-  "  pageno   INTEGER,            /* B-tree page number */"                 \
-  "  cellno   INTEGER,            /* Cell number within page */"            \
-  "  local    INTEGER,            /* Bytes of content stored locally */"    \
-  "  payload  INTEGER,            /* Total cell payload size */"            \
-  "  novfl    INTEGER             /* Number of overflow pages */"           \
-  ");"
-#endif
-
 
 typedef struct StatTable StatTable;
 typedef struct StatCursor StatCursor;
 typedef struct StatPage StatPage;
 typedef struct StatCell StatCell;
 
 struct StatCell {
   int nLocal;                     /* Bytes of local payload */
   u32 iChildPg;                   /* Child node (or 0 if this is a leaf) */
   int nOvfl;                      /* Entries in aOvfl[] */
@@ skipping 28 matching lines @@
 
   /* Values to return. */
   char *zName;                    /* Value of 'name' column */
   char *zPath;                    /* Value of 'path' column */
   u32 iPageno;                    /* Value of 'pageno' column */
   char *zPagetype;                /* Value of 'pagetype' column */
   int nCell;                      /* Value of 'ncell' column */
   int nPayload;                   /* Value of 'payload' column */
   int nUnused;                    /* Value of 'unused' column */
   int nMxPayload;                 /* Value of 'mx_payload' column */
+  i64 iOffset;                    /* Value of 'pgOffset' column */
+  int szPage;                     /* Value of 'pgSize' column */
 };
 
 struct StatTable {
   sqlite3_vtab base;
   sqlite3 *db;
 };
 
 #ifndef get2byte
 # define get2byte(x)   ((x)[0]<<8 | (x)[1])
 #endif
@@ skipping 137 matching lines @@
   nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4);
   if( nLocal>nMaxLocal ) nLocal = nMinLocal;
   *pnLocal = nLocal;
 }
 
 static int statDecodePage(Btree *pBt, StatPage *p){
   int nUnused;
   int iOff;
   int nHdr;
   int isLeaf;
+  int szPage;
 
   u8 *aData = sqlite3PagerGetData(p->pPg);
   u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
 
   p->flags = aHdr[0];
   p->nCell = get2byte(&aHdr[3]);
   p->nMxPayload = 0;
 
   isLeaf = (p->flags==0x0A || p->flags==0x0D);
   nHdr = 12 - isLeaf*4 + (p->iPgno==1)*100;
 
   nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
   nUnused += (int)aHdr[7];
   iOff = get2byte(&aHdr[1]);
   while( iOff ){
     nUnused += get2byte(&aData[iOff+2]);
     iOff = get2byte(&aData[iOff]);
   }
   p->nUnused = nUnused;
   p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
+  szPage = sqlite3BtreeGetPageSize(pBt);
 
   if( p->nCell ){
     int i;                        /* Used to iterate through cells */
-    int nUsable = sqlite3BtreeGetPageSize(pBt) - sqlite3BtreeGetReserve(pBt);
+    int nUsable = szPage - sqlite3BtreeGetReserve(pBt);
 
     p->aCell = sqlite3_malloc((p->nCell+1) * sizeof(StatCell));
     memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
 
     for(i=0; i<p->nCell; i++){
       StatCell *pCell = &p->aCell[i];
 
       iOff = get2byte(&aData[nHdr+i*2]);
       if( !isLeaf ){
         pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
         iOff += 4;
       }
       if( p->flags==0x05 ){
         /* A table interior node. nPayload==0. */
       }else{
         u32 nPayload;             /* Bytes of payload total (local+overflow) */
         int nLocal;               /* Bytes of payload stored locally */
         iOff += getVarint32(&aData[iOff], nPayload);
         if( p->flags==0x0D ){
           u64 dummy;
           iOff += sqlite3GetVarint(&aData[iOff], &dummy);
         }
-        if( nPayload>p->nMxPayload ) p->nMxPayload = nPayload;
+        if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
         getLocalPayload(nUsable, p->flags, nPayload, &nLocal);
         pCell->nLocal = nLocal;
-        assert( nPayload>=nLocal );
+        assert( nLocal>=0 );
+        assert( nPayload>=(u32)nLocal );
         assert( nLocal<=(nUsable-35) );
-        if( nPayload>nLocal ){
+        if( nPayload>(u32)nLocal ){
           int j;
           int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
           pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
           pCell->nOvfl = nOvfl;
           pCell->aOvfl = sqlite3_malloc(sizeof(u32)*nOvfl);
           pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
           for(j=1; j<nOvfl; j++){
             int rc;
             u32 iPrev = pCell->aOvfl[j-1];
             DbPage *pPg = 0;
             rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg);
             if( rc!=SQLITE_OK ){
               assert( pPg==0 );
               return rc;
             } 
             pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
             sqlite3PagerUnref(pPg);
           }
         }
       }
     }
   }
 
   return SQLITE_OK;
 }
 
 /*
+** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
+** the current value of pCsr->iPageno.
+*/
+static void statSizeAndOffset(StatCursor *pCsr){
+  StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
+  Btree *pBt = pTab->db->aDb[0].pBt;
+  Pager *pPager = sqlite3BtreePager(pBt);
+  sqlite3_file *fd;
+  sqlite3_int64 x[2];
+
+  /* The default page size and offset */
+  pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
+  pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
+
+  /* If connected to a ZIPVFS backend, override the page size and
+  ** offset with actual values obtained from ZIPVFS.
+  */
+  fd = sqlite3PagerFile(pPager);
+  x[0] = pCsr->iPageno;
+  if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
+    pCsr->iOffset = x[0];
+    pCsr->szPage = (int)x[1];
+  }
+}
+
+/*
 ** Move a statvfs cursor to the next entry in the file.
 */
 static int statNext(sqlite3_vtab_cursor *pCursor){
   int rc;
   int nPayload;
   StatCursor *pCsr = (StatCursor *)pCursor;
   StatTable *pTab = (StatTable *)pCursor->pVtab;
   Btree *pBt = pTab->db->aDb[0].pBt;
   Pager *pPager = sqlite3BtreePager(pBt);
 
   sqlite3_free(pCsr->zPath);
   pCsr->zPath = 0;
 
+statNextRestart:
   if( pCsr->aPage[0].pPg==0 ){
     rc = sqlite3_step(pCsr->pStmt);
     if( rc==SQLITE_ROW ){
       int nPage;
-      u32 iRoot = sqlite3_column_int64(pCsr->pStmt, 1);
+      u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
       sqlite3PagerPagecount(pPager, &nPage);
       if( nPage==0 ){
         pCsr->isEof = 1;
         return sqlite3_reset(pCsr->pStmt);
       }
       rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg);
       pCsr->aPage[0].iPgno = iRoot;
       pCsr->aPage[0].iCell = 0;
       pCsr->aPage[0].zPath = sqlite3_mprintf("/");
       pCsr->iPage = 0;
@@ skipping 19 matching lines @@
             "%s%.3x+%.6x", p->zPath, p->iCell, pCell->iOvfl
         );
         if( pCell->iOvfl<pCell->nOvfl-1 ){
           pCsr->nUnused = 0;
           pCsr->nPayload = nUsable - 4;
         }else{
           pCsr->nPayload = pCell->nLastOvfl;
           pCsr->nUnused = nUsable - 4 - pCsr->nPayload;
         }
         pCell->iOvfl++;
+        statSizeAndOffset(pCsr);
         return SQLITE_OK;
       }
       if( p->iRightChildPg ) break;
       p->iCell++;
     }
 
-    while( !p->iRightChildPg || p->iCell>p->nCell ){
+    if( !p->iRightChildPg || p->iCell>p->nCell ){
       statClearPage(p);
       if( pCsr->iPage==0 ) return statNext(pCursor);
       pCsr->iPage--;
-      p = &pCsr->aPage[pCsr->iPage];
+      goto statNextRestart; /* Tail recursion */
     }
     pCsr->iPage++;
     assert( p==&pCsr->aPage[pCsr->iPage-1] );
 
     if( p->iCell==p->nCell ){
       p[1].iPgno = p->iRightChildPg;
     }else{
       p[1].iPgno = p->aCell[p->iCell].iChildPg;
     }
     rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg);
     p[1].iCell = 0;
     p[1].zPath = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
     p->iCell++;
   }
 
 
   /* Populate the StatCursor fields with the values to be returned
   ** by the xColumn() and xRowid() methods.
   */
   if( rc==SQLITE_OK ){
     int i;
     StatPage *p = &pCsr->aPage[pCsr->iPage];
     pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
     pCsr->iPageno = p->iPgno;
 
     statDecodePage(pBt, p);
+    statSizeAndOffset(pCsr);
 
     switch( p->flags ){
       case 0x05:             /* table internal */
       case 0x02:             /* index internal */
         pCsr->zPagetype = "internal";
         break;
       case 0x0D:             /* table leaf */
       case 0x0A:             /* index leaf */
         pCsr->zPagetype = "leaf";
         break;
@@ skipping 55 matching lines @@
       break;
     case 5:            /* payload */
       sqlite3_result_int(ctx, pCsr->nPayload);
       break;
     case 6:            /* unused */
       sqlite3_result_int(ctx, pCsr->nUnused);
       break;
     case 7:            /* mx_payload */
       sqlite3_result_int(ctx, pCsr->nMxPayload);
       break;
+    case 8:            /* pgoffset */
+      sqlite3_result_int64(ctx, pCsr->iOffset);
+      break;
+    case 9:            /* pgsize */
+      sqlite3_result_int(ctx, pCsr->szPage);
+      break;
   }
   return SQLITE_OK;
 }
 
 static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
   StatCursor *pCsr = (StatCursor *)pCursor;
   *pRowid = pCsr->iPageno;
   return SQLITE_OK;
 }
 
@@ skipping 19 matching lines @@
     0,                            /* xRollback */
     0,                            /* xFindMethod */
     0,                            /* xRename */
   };
   sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
   return SQLITE_OK;
 }
 
 #endif
 
-#ifdef SQLITE_TEST
+#if defined(SQLITE_TEST) || TCLSH==2
 #include <tcl.h>
 
 static int test_dbstat(
   void *clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
 #ifdef SQLITE_OMIT_VIRTUALTABLE
   Tcl_AppendResult(interp, "dbstat not available because of "
@@ skipping 15 matching lines @@
     sqlite3_dbstat_register(db);
   }
   return TCL_OK;
 #endif
 }
 
 int SqlitetestStat_Init(Tcl_Interp *interp){
   Tcl_CreateObjCommand(interp, "register_dbstat_vtab", test_dbstat, 0, 0);
   return TCL_OK;
 }
-#endif
+#endif /* if defined(SQLITE_TEST) || TCLSH==2 */