Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes to src/btree.c.

  7876   7876   
  7877   7877   #ifndef SQLITE_OMIT_INTEGRITY_CHECK
  7878   7878   /*
  7879   7879   ** Append a message to the error message string.
  7880   7880   */
  7881   7881   static void checkAppendMsg(
  7882   7882     IntegrityCk *pCheck,
  7883         -  char *zMsg1,
  7884   7883     const char *zFormat,
  7885   7884     ...
  7886   7885   ){
  7887   7886     va_list ap;
         7887  +  char zBuf[200];
  7888   7888     if( !pCheck->mxErr ) return;
  7889   7889     pCheck->mxErr--;
  7890   7890     pCheck->nErr++;
  7891   7891     va_start(ap, zFormat);
  7892   7892     if( pCheck->errMsg.nChar ){
  7893   7893       sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
  7894   7894     }
  7895         -  if( zMsg1 ){
  7896         -    sqlite3StrAccumAppendAll(&pCheck->errMsg, zMsg1);
         7895  +  if( pCheck->zPfx ){
         7896  +    sqlite3_snprintf(sizeof(zBuf), zBuf, pCheck->zPfx, pCheck->v1, pCheck->v2);
         7897  +    sqlite3StrAccumAppendAll(&pCheck->errMsg, zBuf);
  7897   7898     }
  7898   7899     sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
  7899   7900     va_end(ap);
  7900   7901     if( pCheck->errMsg.accError==STRACCUM_NOMEM ){
  7901   7902       pCheck->mallocFailed = 1;
  7902   7903     }
  7903   7904   }
................................................................................
  7927   7928   ** Add 1 to the reference count for page iPage.  If this is the second
  7928   7929   ** reference to the page, add an error message to pCheck->zErrMsg.
  7929   7930   ** Return 1 if there are 2 or more references to the page and 0 if
  7930   7931   ** if this is the first reference to the page.
  7931   7932   **
  7932   7933   ** Also check that the page number is in bounds.
  7933   7934   */
  7934         -static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
         7935  +static int checkRef(IntegrityCk *pCheck, Pgno iPage){
  7935   7936     if( iPage==0 ) return 1;
  7936   7937     if( iPage>pCheck->nPage ){
  7937         -    checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
         7938  +    checkAppendMsg(pCheck, "invalid page number %d", iPage);
  7938   7939       return 1;
  7939   7940     }
  7940   7941     if( getPageReferenced(pCheck, iPage) ){
  7941         -    checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
         7942  +    checkAppendMsg(pCheck, "2nd reference to page %d", iPage);
  7942   7943       return 1;
  7943   7944     }
  7944   7945     setPageReferenced(pCheck, iPage);
  7945   7946     return 0;
  7946   7947   }
  7947   7948   
  7948   7949   #ifndef SQLITE_OMIT_AUTOVACUUM
................................................................................
  7951   7952   ** page iParent, pointer type ptrType. If not, append an error message
  7952   7953   ** to pCheck.
  7953   7954   */
  7954   7955   static void checkPtrmap(
  7955   7956     IntegrityCk *pCheck,   /* Integrity check context */
  7956   7957     Pgno iChild,           /* Child page number */
  7957   7958     u8 eType,              /* Expected pointer map type */
  7958         -  Pgno iParent,          /* Expected pointer map parent page number */
  7959         -  char *zContext         /* Context description (used for error msg) */
         7959  +  Pgno iParent           /* Expected pointer map parent page number */
  7960   7960   ){
  7961   7961     int rc;
  7962   7962     u8 ePtrmapType;
  7963   7963     Pgno iPtrmapParent;
  7964   7964   
  7965   7965     rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
  7966   7966     if( rc!=SQLITE_OK ){
  7967   7967       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1;
  7968         -    checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
         7968  +    checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild);
  7969   7969       return;
  7970   7970     }
  7971   7971   
  7972   7972     if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
  7973         -    checkAppendMsg(pCheck, zContext, 
         7973  +    checkAppendMsg(pCheck,
  7974   7974         "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", 
  7975   7975         iChild, eType, iParent, ePtrmapType, iPtrmapParent);
  7976   7976     }
  7977   7977   }
  7978   7978   #endif
  7979   7979   
  7980   7980   /*
................................................................................
  7981   7981   ** Check the integrity of the freelist or of an overflow page list.
  7982   7982   ** Verify that the number of pages on the list is N.
  7983   7983   */
  7984   7984   static void checkList(
  7985   7985     IntegrityCk *pCheck,  /* Integrity checking context */
  7986   7986     int isFreeList,       /* True for a freelist.  False for overflow page list */
  7987   7987     int iPage,            /* Page number for first page in the list */
  7988         -  int N,                /* Expected number of pages in the list */
  7989         -  char *zContext        /* Context for error messages */
         7988  +  int N                 /* Expected number of pages in the list */
  7990   7989   ){
  7991   7990     int i;
  7992   7991     int expected = N;
  7993   7992     int iFirst = iPage;
  7994   7993     while( N-- > 0 && pCheck->mxErr ){
  7995   7994       DbPage *pOvflPage;
  7996   7995       unsigned char *pOvflData;
  7997   7996       if( iPage<1 ){
  7998         -      checkAppendMsg(pCheck, zContext,
         7997  +      checkAppendMsg(pCheck,
  7999   7998            "%d of %d pages missing from overflow list starting at %d",
  8000   7999             N+1, expected, iFirst);
  8001   8000         break;
  8002   8001       }
  8003         -    if( checkRef(pCheck, iPage, zContext) ) break;
         8002  +    if( checkRef(pCheck, iPage) ) break;
  8004   8003       if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
  8005         -      checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
         8004  +      checkAppendMsg(pCheck, "failed to get page %d", iPage);
  8006   8005         break;
  8007   8006       }
  8008   8007       pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
  8009   8008       if( isFreeList ){
  8010   8009         int n = get4byte(&pOvflData[4]);
  8011   8010   #ifndef SQLITE_OMIT_AUTOVACUUM
  8012   8011         if( pCheck->pBt->autoVacuum ){
  8013         -        checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
         8012  +        checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0);
  8014   8013         }
  8015   8014   #endif
  8016   8015         if( n>(int)pCheck->pBt->usableSize/4-2 ){
  8017         -        checkAppendMsg(pCheck, zContext,
         8016  +        checkAppendMsg(pCheck,
  8018   8017              "freelist leaf count too big on page %d", iPage);
  8019   8018           N--;
  8020   8019         }else{
  8021   8020           for(i=0; i<n; i++){
  8022   8021             Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
  8023   8022   #ifndef SQLITE_OMIT_AUTOVACUUM
  8024   8023             if( pCheck->pBt->autoVacuum ){
  8025         -            checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
         8024  +            checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0);
  8026   8025             }
  8027   8026   #endif
  8028         -          checkRef(pCheck, iFreePage, zContext);
         8027  +          checkRef(pCheck, iFreePage);
  8029   8028           }
  8030   8029           N -= n;
  8031   8030         }
  8032   8031       }
  8033   8032   #ifndef SQLITE_OMIT_AUTOVACUUM
  8034   8033       else{
  8035   8034         /* If this database supports auto-vacuum and iPage is not the last
  8036   8035         ** page in this overflow list, check that the pointer-map entry for
  8037   8036         ** the following page matches iPage.
  8038   8037         */
  8039   8038         if( pCheck->pBt->autoVacuum && N>0 ){
  8040   8039           i = get4byte(pOvflData);
  8041         -        checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
         8040  +        checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage);
  8042   8041         }
  8043   8042       }
  8044   8043   #endif
  8045   8044       iPage = get4byte(pOvflData);
  8046   8045       sqlite3PagerUnref(pOvflPage);
  8047   8046     }
  8048   8047   }
................................................................................
  8066   8065   **      7.  Verify that the depth of all children is the same.
  8067   8066   **      8.  Make sure this page is at least 33% full or else it is
  8068   8067   **          the root of the tree.
  8069   8068   */
  8070   8069   static int checkTreePage(
  8071   8070     IntegrityCk *pCheck,  /* Context for the sanity check */
  8072   8071     int iPage,            /* Page number of the page to check */
  8073         -  char *zParentContext, /* Parent context */
  8074   8072     i64 *pnParentMinKey, 
  8075   8073     i64 *pnParentMaxKey
  8076   8074   ){
  8077   8075     MemPage *pPage;
  8078   8076     int i, rc, depth, d2, pgno, cnt;
  8079   8077     int hdr, cellStart;
  8080   8078     int nCell;
  8081   8079     u8 *data;
  8082   8080     BtShared *pBt;
  8083   8081     int usableSize;
  8084         -  char zContext[100];
  8085   8082     char *hit = 0;
  8086   8083     i64 nMinKey = 0;
  8087   8084     i64 nMaxKey = 0;
  8088         -
  8089         -  sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
         8085  +  const char *saved_zPfx = pCheck->zPfx;
         8086  +  int saved_v1 = pCheck->v1;
         8087  +  int saved_v2 = pCheck->v2;
  8090   8088   
  8091   8089     /* Check that the page exists
  8092   8090     */
  8093   8091     pBt = pCheck->pBt;
  8094   8092     usableSize = pBt->usableSize;
  8095   8093     if( iPage==0 ) return 0;
  8096         -  if( checkRef(pCheck, iPage, zParentContext) ) return 0;
         8094  +  if( checkRef(pCheck, iPage) ) return 0;
         8095  +  pCheck->zPfx = "Page %d: ";
         8096  +  pCheck->v1 = iPage;
  8097   8097     if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
  8098         -    checkAppendMsg(pCheck, zContext,
         8098  +    checkAppendMsg(pCheck,
  8099   8099          "unable to get the page. error code=%d", rc);
  8100         -    return 0;
         8100  +    depth = -1;
         8101  +    goto end_of_check;
  8101   8102     }
  8102   8103   
  8103   8104     /* Clear MemPage.isInit to make sure the corruption detection code in
  8104   8105     ** btreeInitPage() is executed.  */
  8105   8106     pPage->isInit = 0;
  8106   8107     if( (rc = btreeInitPage(pPage))!=0 ){
  8107   8108       assert( rc==SQLITE_CORRUPT );  /* The only possible error from InitPage */
  8108         -    checkAppendMsg(pCheck, zContext, 
         8109  +    checkAppendMsg(pCheck,
  8109   8110                      "btreeInitPage() returns error code %d", rc);
  8110   8111       releasePage(pPage);
  8111         -    return 0;
         8112  +    depth = -1;
         8113  +    goto end_of_check;
  8112   8114     }
  8113   8115   
  8114   8116     /* Check out all the cells.
  8115   8117     */
  8116   8118     depth = 0;
  8117   8119     for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
  8118   8120       u8 *pCell;
  8119   8121       u32 sz;
  8120   8122       CellInfo info;
  8121   8123   
  8122   8124       /* Check payload overflow pages
  8123   8125       */
  8124         -    sqlite3_snprintf(sizeof(zContext), zContext,
  8125         -             "On tree page %d cell %d: ", iPage, i);
         8126  +    pCheck->zPfx = "On tree page %d cell %d: ";
         8127  +    pCheck->v1 = iPage;
         8128  +    pCheck->v2 = i;
  8126   8129       pCell = findCell(pPage,i);
  8127   8130       btreeParseCellPtr(pPage, pCell, &info);
  8128   8131       sz = info.nPayload;
  8129   8132       /* For intKey pages, check that the keys are in order.
  8130   8133       */
  8131   8134       if( pPage->intKey ){
  8132   8135         if( i==0 ){
  8133   8136           nMinKey = nMaxKey = info.nKey;
  8134   8137         }else if( info.nKey <= nMaxKey ){
  8135         -        checkAppendMsg(pCheck, zContext, 
         8138  +        checkAppendMsg(pCheck,
  8136   8139              "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
  8137   8140         }
  8138   8141         nMaxKey = info.nKey;
  8139   8142       }
  8140   8143       if( (sz>info.nLocal) 
  8141   8144        && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
  8142   8145       ){
  8143   8146         int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
  8144   8147         Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
  8145   8148   #ifndef SQLITE_OMIT_AUTOVACUUM
  8146   8149         if( pBt->autoVacuum ){
  8147         -        checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
         8150  +        checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage);
  8148   8151         }
  8149   8152   #endif
  8150         -      checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
         8153  +      checkList(pCheck, 0, pgnoOvfl, nPage);
  8151   8154       }
  8152   8155   
  8153   8156       /* Check sanity of left child page.
  8154   8157       */
  8155   8158       if( !pPage->leaf ){
  8156   8159         pgno = get4byte(pCell);
  8157   8160   #ifndef SQLITE_OMIT_AUTOVACUUM
  8158   8161         if( pBt->autoVacuum ){
  8159         -        checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
         8162  +        checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
  8160   8163         }
  8161   8164   #endif
  8162         -      d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0?NULL:&nMaxKey);
         8165  +      d2 = checkTreePage(pCheck, pgno, &nMinKey, i==0?NULL:&nMaxKey);
  8163   8166         if( i>0 && d2!=depth ){
  8164         -        checkAppendMsg(pCheck, zContext, "Child page depth differs");
         8167  +        checkAppendMsg(pCheck, "Child page depth differs");
  8165   8168         }
  8166   8169         depth = d2;
  8167   8170       }
  8168   8171     }
  8169   8172   
  8170   8173     if( !pPage->leaf ){
  8171   8174       pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
  8172         -    sqlite3_snprintf(sizeof(zContext), zContext, 
  8173         -                     "On page %d at right child: ", iPage);
         8175  +    pCheck->zPfx = "On page %d at right child: ";
         8176  +    pCheck->v1 = iPage;
  8174   8177   #ifndef SQLITE_OMIT_AUTOVACUUM
  8175   8178       if( pBt->autoVacuum ){
  8176         -      checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
         8179  +      checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
  8177   8180       }
  8178   8181   #endif
  8179         -    checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell?NULL:&nMaxKey);
         8182  +    checkTreePage(pCheck, pgno, NULL, !pPage->nCell?NULL:&nMaxKey);
  8180   8183     }
  8181   8184    
  8182   8185     /* For intKey leaf pages, check that the min/max keys are in order
  8183   8186     ** with any left/parent/right pages.
  8184   8187     */
         8188  +  pCheck->zPfx = "Page %d: ";
         8189  +  pCheck->v1 = iPage;
  8185   8190     if( pPage->leaf && pPage->intKey ){
  8186   8191       /* if we are a left child page */
  8187   8192       if( pnParentMinKey ){
  8188   8193         /* if we are the left most child page */
  8189   8194         if( !pnParentMaxKey ){
  8190   8195           if( nMaxKey > *pnParentMinKey ){
  8191         -          checkAppendMsg(pCheck, zContext, 
         8196  +          checkAppendMsg(pCheck,
  8192   8197                 "Rowid %lld out of order (max larger than parent min of %lld)",
  8193   8198                 nMaxKey, *pnParentMinKey);
  8194   8199           }
  8195   8200         }else{
  8196   8201           if( nMinKey <= *pnParentMinKey ){
  8197         -          checkAppendMsg(pCheck, zContext, 
         8202  +          checkAppendMsg(pCheck,
  8198   8203                 "Rowid %lld out of order (min less than parent min of %lld)",
  8199   8204                 nMinKey, *pnParentMinKey);
  8200   8205           }
  8201   8206           if( nMaxKey > *pnParentMaxKey ){
  8202         -          checkAppendMsg(pCheck, zContext, 
         8207  +          checkAppendMsg(pCheck,
  8203   8208                 "Rowid %lld out of order (max larger than parent max of %lld)",
  8204   8209                 nMaxKey, *pnParentMaxKey);
  8205   8210           }
  8206   8211           *pnParentMinKey = nMaxKey;
  8207   8212         }
  8208   8213       /* else if we're a right child page */
  8209   8214       } else if( pnParentMaxKey ){
  8210   8215         if( nMinKey <= *pnParentMaxKey ){
  8211         -        checkAppendMsg(pCheck, zContext, 
         8216  +        checkAppendMsg(pCheck,
  8212   8217               "Rowid %lld out of order (min less than parent max of %lld)",
  8213   8218               nMinKey, *pnParentMaxKey);
  8214   8219         }
  8215   8220       }
  8216   8221     }
  8217   8222   
  8218   8223     /* Check for complete coverage of the page
  8219   8224     */
  8220   8225     data = pPage->aData;
  8221   8226     hdr = pPage->hdrOffset;
  8222   8227     hit = sqlite3PageMalloc( pBt->pageSize );
         8228  +  pCheck->zPfx = 0;
  8223   8229     if( hit==0 ){
  8224   8230       pCheck->mallocFailed = 1;
  8225   8231     }else{
  8226   8232       int contentOffset = get2byteNotZero(&data[hdr+5]);
  8227   8233       assert( contentOffset<=usableSize );  /* Enforced by btreeInitPage() */
  8228   8234       memset(hit+contentOffset, 0, usableSize-contentOffset);
  8229   8235       memset(hit, 1, contentOffset);
................................................................................
  8233   8239         int pc = get2byte(&data[cellStart+i*2]);
  8234   8240         u32 size = 65536;
  8235   8241         int j;
  8236   8242         if( pc<=usableSize-4 ){
  8237   8243           size = cellSizePtr(pPage, &data[pc]);
  8238   8244         }
  8239   8245         if( (int)(pc+size-1)>=usableSize ){
  8240         -        checkAppendMsg(pCheck, 0, 
         8246  +        pCheck->zPfx = 0;
         8247  +        checkAppendMsg(pCheck,
  8241   8248               "Corruption detected in cell %d on page %d",i,iPage);
  8242   8249         }else{
  8243   8250           for(j=pc+size-1; j>=pc; j--) hit[j]++;
  8244   8251         }
  8245   8252       }
  8246   8253       i = get2byte(&data[hdr+1]);
  8247   8254       while( i>0 ){
................................................................................
  8255   8262         assert( j<=usableSize-4 );   /* Enforced by btreeInitPage() */
  8256   8263         i = j;
  8257   8264       }
  8258   8265       for(i=cnt=0; i<usableSize; i++){
  8259   8266         if( hit[i]==0 ){
  8260   8267           cnt++;
  8261   8268         }else if( hit[i]>1 ){
  8262         -        checkAppendMsg(pCheck, 0,
         8269  +        checkAppendMsg(pCheck,
  8263   8270             "Multiple uses for byte %d of page %d", i, iPage);
  8264   8271           break;
  8265   8272         }
  8266   8273       }
  8267   8274       if( cnt!=data[hdr+7] ){
  8268         -      checkAppendMsg(pCheck, 0, 
         8275  +      checkAppendMsg(pCheck,
  8269   8276             "Fragmentation of %d bytes reported as %d on page %d",
  8270   8277             cnt, data[hdr+7], iPage);
  8271   8278       }
  8272   8279     }
  8273   8280     sqlite3PageFree(hit);
  8274   8281     releasePage(pPage);
         8282  +
         8283  +end_of_check:
         8284  +  pCheck->zPfx = saved_zPfx;
         8285  +  pCheck->v1 = saved_v1;
         8286  +  pCheck->v2 = saved_v2;
  8275   8287     return depth+1;
  8276   8288   }
  8277   8289   #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
  8278   8290   
  8279   8291   #ifndef SQLITE_OMIT_INTEGRITY_CHECK
  8280   8292   /*
  8281   8293   ** This routine does a complete check of the given BTree file.  aRoot[] is
................................................................................
  8308   8320     nRef = sqlite3PagerRefcount(pBt->pPager);
  8309   8321     sCheck.pBt = pBt;
  8310   8322     sCheck.pPager = pBt->pPager;
  8311   8323     sCheck.nPage = btreePagecount(sCheck.pBt);
  8312   8324     sCheck.mxErr = mxErr;
  8313   8325     sCheck.nErr = 0;
  8314   8326     sCheck.mallocFailed = 0;
         8327  +  sCheck.zPfx = 0;
         8328  +  sCheck.v1 = 0;
         8329  +  sCheck.v2 = 0;
  8315   8330     *pnErr = 0;
  8316   8331     if( sCheck.nPage==0 ){
  8317   8332       sqlite3BtreeLeave(p);
  8318   8333       return 0;
  8319   8334     }
  8320   8335   
  8321   8336     sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1);
................................................................................
  8327   8342     i = PENDING_BYTE_PAGE(pBt);
  8328   8343     if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i);
  8329   8344     sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), SQLITE_MAX_LENGTH);
  8330   8345     sCheck.errMsg.useMalloc = 2;
  8331   8346   
  8332   8347     /* Check the integrity of the freelist
  8333   8348     */
         8349  +  sCheck.zPfx = "Main freelist: ";
  8334   8350     checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
  8335         -            get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
         8351  +            get4byte(&pBt->pPage1->aData[36]));
         8352  +  sCheck.zPfx = 0;
  8336   8353   
  8337   8354     /* Check all the tables.
  8338   8355     */
  8339   8356     for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
  8340   8357       if( aRoot[i]==0 ) continue;
  8341   8358   #ifndef SQLITE_OMIT_AUTOVACUUM
  8342   8359       if( pBt->autoVacuum && aRoot[i]>1 ){
  8343         -      checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
         8360  +      checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0);
  8344   8361       }
  8345   8362   #endif
  8346         -    checkTreePage(&sCheck, aRoot[i], "List of tree roots: ", NULL, NULL);
         8363  +    sCheck.zPfx = "List of tree roots: ";
         8364  +    checkTreePage(&sCheck, aRoot[i], NULL, NULL);
         8365  +    sCheck.zPfx = 0;
  8347   8366     }
  8348   8367   
  8349   8368     /* Make sure every page in the file is referenced
  8350   8369     */
  8351   8370     for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
  8352   8371   #ifdef SQLITE_OMIT_AUTOVACUUM
  8353   8372       if( getPageReferenced(&sCheck, i)==0 ){
  8354         -      checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
         8373  +      checkAppendMsg(&sCheck, "Page %d is never used", i);
  8355   8374       }
  8356   8375   #else
  8357   8376       /* If the database supports auto-vacuum, make sure no tables contain
  8358   8377       ** references to pointer-map pages.
  8359   8378       */
  8360   8379       if( getPageReferenced(&sCheck, i)==0 && 
  8361   8380          (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
  8362         -      checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
         8381  +      checkAppendMsg(&sCheck, "Page %d is never used", i);
  8363   8382       }
  8364   8383       if( getPageReferenced(&sCheck, i)!=0 && 
  8365   8384          (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
  8366         -      checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
         8385  +      checkAppendMsg(&sCheck, "Pointer map page %d is referenced", i);
  8367   8386       }
  8368   8387   #endif
  8369   8388     }
  8370   8389   
  8371   8390     /* Make sure this analysis did not leave any unref() pages.
  8372   8391     ** This is an internal consistency check; an integrity check
  8373   8392     ** of the integrity check.
  8374   8393     */
  8375   8394     if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
  8376         -    checkAppendMsg(&sCheck, 0, 
         8395  +    checkAppendMsg(&sCheck,
  8377   8396         "Outstanding page count goes from %d to %d during this analysis",
  8378   8397         nRef, sqlite3PagerRefcount(pBt->pPager)
  8379   8398       );
  8380   8399     }
  8381   8400   
  8382   8401     /* Clean  up and report errors.
  8383   8402     */

Changes to src/btreeInt.h.

   653    653     BtShared *pBt;    /* The tree being checked out */
   654    654     Pager *pPager;    /* The associated pager.  Also accessible by pBt->pPager */
   655    655     u8 *aPgRef;       /* 1 bit per page in the db (see above) */
   656    656     Pgno nPage;       /* Number of pages in the database */
   657    657     int mxErr;        /* Stop accumulating errors when this reaches zero */
   658    658     int nErr;         /* Number of messages written to zErrMsg so far */
   659    659     int mallocFailed; /* A memory allocation error has occurred */
          660  +  const char *zPfx; /* Error message prefix */
          661  +  int v1, v2;       /* Values for up to two %d fields in zPfx */
   660    662     StrAccum errMsg;  /* Accumulate the error message text here */
   661    663   };
   662    664   
   663    665   /*
   664    666   ** Routines to read or write a two- and four-byte big-endian integer values.
   665    667   */
   666    668   #define get2byte(x)   ((x)[0]<<8 | (x)[1])
   667    669   #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
   668    670   #define get4byte sqlite3Get4byte
   669    671   #define put4byte sqlite3Put4byte