Lines Matching full:nnew
5067 ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
21840 int nOld, nNew, nDiff;
21859 nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
21860 if( nOld==nNew ){
21865 nDiff = nNew - nOld;
21870 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
21873 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
21876 nNew = sqlite3MallocSize(pNew);
21877 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
21881 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
31383 ** descriptor pFd to nNew bytes. Any existing mapping is discarded.
31398 i64 nNew /* Required mapping size */
31408 assert( nNew>pFd->mmapSize );
31409 assert( nNew<=pFd->mmapSizeMax );
31410 assert( nNew>0 );
31431 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
31434 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
31437 osMunmap(pNew, nNew - nReuse);
31453 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
31458 nNew = 0;
31467 pFd->mmapSize = pFd->mmapSizeActual = nNew;
41655 unsigned int nNew;
41660 nNew = p->nHash*2;
41661 if( nNew<256 ){
41662 nNew = 256;
41667 apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
41675 unsigned int h = pPage->iKey % nNew;
41683 p->nHash = nNew;
49279 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
49281 rc = pager_truncate(pPager, nNew);
49620 int nNew; /* Number of remaining savepoints after this op. */
49623 ** operation. Store this value in nNew. Then free resources associated
49626 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
49627 for(ii=nNew; ii<pPager->nSavepoint; ii++){
49630 pPager->nSavepoint = nNew;
49635 if( nNew==0 && isOpen(pPager->sjfd) ){
49650 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
61094 ** with apCell[iOld]. After balancing, this page should hold nNew cells
61107 int nNew, /* Final number of cells on page */
61112 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
61118 int iNewEnd = iNew + nNew;
61140 int nAdd = MIN(nNew,iOld-iNew);
61141 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
61154 if( iCell>=0 && iCell<nNew ){
61169 iNew+nCell, nNew-nCell, pCArray
61172 pPg->nCell = nNew;
61179 for(i=0; i<nNew && !CORRUPT_DB; i++){
61193 populateCellCache(pCArray, iNew, nNew);
61194 return rebuildPage(pPg, nNew, &pCArray->apCell[iNew], &pCArray->szCell[iNew]);
61472 int nNew = 0; /* Number of pages in apNew[] */
61872 nNew++;
61880 nNew++;
61905 for(i=0; i<nNew; i++){
61922 for(i=0; i<nNew; i++){
61924 for(j=1; j<nNew; j++){
61941 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
61942 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
61943 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
61944 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
61945 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
61946 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
61947 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
61948 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
61952 put4byte(pRight, apNew[nNew-1]->pgno);
61957 if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
61958 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
61959 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
61989 MemPage *pOld = (++iOld)<nNew ? apNew[iOld] : apOld[iOld];
62004 if( iOld>=nNew
62021 for(i=0; i<nNew-1; i++){
62087 ** The iPg value in the following loop starts at nNew-1 goes down
62088 ** to 0, then back up to nNew-1 again, thus making two passes over
62095 for(i=1-nNew; i<nNew; i++){
62097 assert( iPg>=0 && iPg<nNew );
62133 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
62136 assert( nNew>0 );
62154 assert( nNew==1 || CORRUPT_DB );
62167 for(i=0; i<nNew; i++){
62175 nOld, nNew, b.nCell));
62179 for(i=nNew; i<nOld; i++){
62189 ptrmapCheckPages(apNew, nNew);
62202 for(i=0; i<nNew; i++){
66817 int nNew = (p->nOpAlloc>=512 ? p->nOpAlloc*2 : p->nOpAlloc+nOp);
66819 int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
66824 assert( nNew>=(p->nOpAlloc+nOp) );
66825 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
80636 int nNew = MAX(128, p->nAlloc*2);
80637 while( nByte>nNew ) nNew = nNew*2;
80638 aNew = sqlite3Realloc(p->aAlloc, nNew);
80640 p->nAlloc = nNew;
81916 int nNew = pSorter->nMemory * 2;
81917 while( nNew < nMin ) nNew = nNew*2;
81918 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
81919 if( nNew < nMin ) nNew = nMin;
81921 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
81927 pSorter->nMemory = nNew;
122554 ** that the scan will visit nNew rows. This function returns the number
122562 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
122563 LogEst nRet = nNew;
122746 LogEst nNew;
122841 nNew = sqlite3LogEst(iUpper - iLower);
122846 if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) );
122848 nNew = 10; assert( 10==sqlite3LogEst(2) );
122850 if( nNew<nOut ){
122851 nOut = nNew;
122868 nNew = whereRangeAdjust(pLower, nOut);
122869 nNew = whereRangeAdjust(pUpper, nNew);
122878 nNew -= 20;
122882 if( nNew<10 ) nNew = 10;
122883 if( nNew<nOut ) nOut = nNew;
138552 int nNew;
138556 pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
138567 nOut = nNew;
138634 int nNew;
138637 pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
138649 nMerge = nNew;
140914 int nNew;
140926 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
140927 assert( pPhrase->doclist.pList[nNew]=='\0' );
140928 assert( nNew<=pPhrase->doclist.nList && nNew>0 );
140929 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
140930 pPhrase->doclist.nList = nNew;
142618 static void *fts3ReallocOrFree(void *pOrig, int nNew){
142619 void *pRet = sqlite3_realloc(pOrig, nNew);
144908 int nNew = sizeof(char *)*(iArg+1);
144909 char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);
146573 int nNew = p->nSpace * 2;
146574 p = sqlite3_realloc(p, sizeof(*p) + nNew);
146580 p->nSpace = nNew;
147299 int nNew = (nPrefix+nSuffix)*2;
147300 char *zNew = sqlite3_realloc(pReader->zTerm, nNew);
147305 pReader->nTermAlloc = nNew;
153461 int nNew; /* Number of valid entries in array aNew[] */
153465 nNew = p->nException;
153474 for(i=0; i<nNew && aNew[i]<iCode; i++);
153475 for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
153477 nNew++;
153481 p->nException = nNew;
155243 int nNew = pCur->nPointAlloc*2 + 8;
155244 pNew = sqlite3_realloc(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
155247 pCur->nPointAlloc = nNew;
161149 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
161151 aNew = (RbuFrame*)sqlite3_realloc(pRbu->aFrame, nNew * sizeof(RbuFrame));
161154 pRbu->nFrameAlloc = nNew;
164221 u32 nNew;
164225 nNew = pParse->nAlloc*2 + 10;
164226 pNew = sqlite3_realloc(pParse->aNode, sizeof(JsonNode)*nNew);
164231 pParse->nAlloc = nNew;
168644 int nNew = pBuf->nSpace ? pBuf->nSpace*2 : 64;
168649 while( nNew<(pBuf->n + nByte) ){
168650 nNew = nNew * 2;
168652 pNew = sqlite3_realloc(pBuf->p, nNew);
168657 pBuf->nSpace = nNew;
171175 int nNew = pNear->nPhrase + SZALLOC;
171176 int nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
171240 int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
171243 sizeof(Fts5ExprPhrase) + sizeof(Fts5ExprTerm) * nNew
171250 pNew->nTerm = nNew - SZALLOC;
172190 int nNew = pHash->nSlot*2;
172195 apNew = (Fts5HashEntry**)sqlite3_malloc(nNew*sizeof(Fts5HashEntry*));
172197 memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
172204 iHash = fts5HashKey(nNew, (u8*)p->zKey, strlen(p->zKey));
172211 pHash->nSlot = nNew;
172300 int nNew = p->nAlloc * 2;
172303 pNew = (Fts5HashEntry*)sqlite3_realloc(p, nNew);
172305 pNew->nAlloc = nNew;
172616 ** varint: number of bytes of new term data (nNew)
172617 ** blob: nNew bytes of new term data
174031 int nNew; /* Bytes of new data */
174033 iOff += fts5GetVarint32(&a[iOff], nNew);
174035 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
174036 iOff += nNew;
174130 int nNew = pIter->nRowidOffset + 8;
174131 int *aNew = (int*)sqlite3_realloc(pIter->aRowidOffset, nNew*sizeof(int));
174137 pIter->nRowidOffset = nNew;
174479 int nNew = 0;
174493 fts5FastGetVarint32(a, iOff, nNew);
174502 nCmp = MIN(nNew, nTerm-nMatch);
174509 if( i==nNew ){
174514 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
174548 iOff += fts5GetVarint32(&a[iOff], nNew);
174557 pIter->iLeafOffset = iOff + nNew;
174562 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
175392 ** Return the size of the prefix, in bytes, that buffer (nNew/pNew) shares
175397 int nNew, const u8 *pNew
175400 assert( fts5BlobCompare(pOld, nOld, pNew, nNew)<0 );
182100 int nNew = p->nException;
182115 for(i=0; i<nNew; i++){
182118 memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
182120 nNew++;
182125 p->nException = nNew;
