contrib/sqlite3/sqlite3.c

24008   u32 nFree = countLookasideSlots(db->lookaside.pFree);
24011   nFree += countLookasideSlots(db->lookaside.pSmallFree);
24014   return db->lookaside.nSlot - (nInit+nFree);
56393   int nFree = 0;
56399     while( (nReq<0 || nFree<nReq)
56403       nFree += pcache1MemSize(p->page.pBuf);
56410   return nFree;
69800   int nFree;           /* Number of free bytes on the page. -1 for unknown */
72258   assert( pPage->nFree>=0 );
72259   if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
72369   assert( pPage->nFree>=nByte );
72422     assert( pPage->nFree>=0 );
72423     rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
72549   pPage->nFree += iOrigSize;
72626 ** in the pPage->nFree field.
72633   int nFree;         /* Number of unused bytes on the page */
72645   assert( pPage->nFree<0 );
72662   nFree = data[hdr+7] + top;  /* Init nFree to non-freeblock free space */
72678       nFree = nFree + size;
72692   /* At this point, nFree contains the sum of the offset to the start
72699   if( nFree>usableSize || nFree<iCellFirst ){
72702   pPage->nFree = (u16)(nFree - iCellFirst);
72792   pPage->nFree = -1;  /* Indicate that this value is yet uncomputed */
72823   pPage->nFree = (u16)(pBt->usableSize - first);
74633 ** nOrig pages in size containing nFree free pages. Return the expected
74636 static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){
74642   nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
74643   nFin = nOrig - nFree - nPtrmap;
74672     Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
74673     Pgno nFin = finalDbSize(pBt, nOrig, nFree);
74675     if( nOrig<nFin || nFree>=nOrig ){
74677     }else if( nFree>0 ){
74716     Pgno nFree;        /* Number of pages on the freelist initially */
74730     nFree = get4byte(&pBt->pPage1->aData[36]);
74741         nFree,
74744       if( nVac>nFree ){
74745         nVac = nFree;
74751       nVac = nFree;
74759       rc = incrVacuumStep(pBt, nFin, iFree, nVac==nFree);
74761     if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
74763       if( nVac==nFree ){
77286   u32 nFree;                          /* Initial number of pages on free-list */
77305   nFree = get4byte(&pPage1->aData[36]);
77306   put4byte(&pPage1->aData[36], nFree+1);
77335   if( nFree!=0 ){
77724   assert( pPage->nFree>=0 );
77746     pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset
77751     pPage->nFree += 2;
77795   assert( pPage->nFree>=0 );
77797   if( pPage->nOverflow || sz+2>pPage->nFree ){
77833     pPage->nFree -= (u16)(2 + sz);
77890   assert( pPage->nFree>=0 );
77892   if( sz+2>pPage->nFree ){
77923     pPage->nFree -= (u16)(2 + sz);
78085 ** The MemPage.nFree field is invalidated by this function. It is the
78144   /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
78256   int nFree = 0;
78272       for(j=0; j<nFree; j++){
78281       if( j>=nFree ){
78282         if( nFree>=(int)(sizeof(aOfst)/sizeof(aOfst[0])) ){
78283           for(j=0; j<nFree; j++){
78286           nFree = 0;
78288         aOfst[nFree] = iOfst;
78289         aAfter[nFree] = iAfter;
78291         nFree++;
78296   for(j=0; j<nFree; j++){
78311 ** The pPg->nFree field is invalid when this function returns. It is the
78455   assert( pPage->nFree>=0 );
78456   assert( pParent->nFree>=0 );
78486     pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
78611     assert( pFrom->nFree>=iToHdr );
78732   assert( pParent->nFree>=0 );
78774     if( apOld[i]->nFree<0 ){
78987     assert( p->nFree>=0 );
78988     szNew[i] = usableSpace - p->nFree;
79373       apNew[iPg]->nFree = usableSpace-szNew[iPg];
79385   if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
79404     assert( apNew[0]->nFree ==
79570     if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break;
79571     if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
79608       if( rc==SQLITE_OK && pParent->nFree<0 ){
79995   if( pPage->nFree<0 ){
80305   if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){
80331      || (pPage->nFree+pPage->xCellSize(pPage,pCell)+2) >
80390     if( pLeaf->nFree<0 ){
80429   assert( pCur->pPage->nFree>=0 );
80430   if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
87366   sqlite3_int64 nFree;   /* Bytes of available memory */
87392     if( nByte <= p->nFree ){
87393       p->nFree -= nByte;
87394       pBuf = &p->pSpace[p->nFree];
87502   x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n);  /* Bytes of unused memory */
87503   assert( x.nFree>=0 );
87504   assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
87532     x.nFree = x.nNeeded;