Lines Matching defs:nNew
30740 int nOld, nNew, nDiff;
30759 nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
30760 if( nOld==nNew ){
30766 nDiff = nNew - nOld;
30776 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
30780 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
30784 nNew = sqlite3MallocSize(pNew);
30785 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
30789 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
43656 ** descriptor pFd to nNew bytes. Any existing mapping is discarded.
43671 i64 nNew /* Required mapping size */
43681 assert( nNew>pFd->mmapSize );
43682 assert( nNew<=pFd->mmapSizeMax );
43683 assert( nNew>0 );
43706 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
43709 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
43712 osMunmap(pNew, nNew - nReuse);
43728 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
43733 nNew = 0;
43742 pFd->mmapSize = pFd->mmapSizeActual = nNew;
55695 unsigned int nNew;
55700 nNew = p->nHash*2;
55701 if( nNew<256 ){
55702 nNew = 256;
55707 apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
55715 unsigned int h = pPage->iKey % nNew;
55723 p->nHash = nNew;
63745 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
63747 rc = pager_truncate(pPager, nNew);
64099 int nNew; /* Number of remaining savepoints after this op. */
64102 ** operation. Store this value in nNew. Then free resources associated
64105 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
64106 for(ii=nNew; ii<pPager->nSavepoint; ii++){
64109 pPager->nSavepoint = nNew;
64114 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
64131 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
78305 ** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells
78318 int nNew, /* Final number of cells on page */
78323 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
78329 int iNewEnd = iNew + nNew;
78356 int nAdd = MIN(nNew,iOld-iNew);
78357 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
78371 if( iCell>=0 && iCell<nNew ){
78390 iNew+nCell, nNew-nCell, pCArray
78393 pPg->nCell = nNew;
78400 for(i=0; i<nNew && !CORRUPT_DB; i++){
78414 if( nNew<1 ) return SQLITE_CORRUPT_BKPT;
78415 populateCellCache(pCArray, iNew, nNew);
78416 return rebuildPage(pCArray, iNew, nNew, pPg);
78690 int nNew = 0; /* Number of pages in apNew[] */
79106 nNew++;
79119 nNew++;
79144 for(i=0; i<nNew; i++){
79149 for(i=0; i<nNew-1; i++){
79151 for(j=i+1; j<nNew; j++){
79177 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
79178 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
79179 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
79180 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
79181 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
79182 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
79183 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
79184 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
79188 assert( nNew>=1 && nNew<=ArraySize(apNew) );
79189 assert( apNew[nNew-1]!=0 );
79190 put4byte(pRight, apNew[nNew-1]->pgno);
79195 if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
79196 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
79197 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
79227 assert( iOld<nNew || iOld<nOld );
79229 pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
79243 if( iOld>=nNew
79259 for(i=0; i<nNew-1; i++){
79332 ** The iPg value in the following loop starts at nNew-1 goes down
79333 ** to 0, then back up to nNew-1 again, thus making two passes over
79340 for(i=1-nNew; i<nNew; i++){
79342 assert( iPg>=0 && iPg<nNew );
79380 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
79383 assert( nNew>0 );
79401 assert( nNew==1 || CORRUPT_DB );
79415 for(i=0; i<nNew; i++){
79423 nOld, nNew, b.nCell));
79427 for(i=nNew; i<nOld; i++){
79437 ptrmapCheckPages(apNew, nNew);
79450 for(i=0; i<nNew; i++){
85013 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
85016 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
85022 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
85028 assert( nNew>=(v->nOpAlloc+nOp) );
85029 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
103341 sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
103342 while( nByte>nNew ) nNew = nNew*2;
103343 aNew = sqlite3Realloc(p->aAlloc, nNew);
103345 p->nAlloc = nNew;
104638 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
104643 while( nNew < nMin ) nNew = nNew*2;
104644 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
104645 if( nNew < nMin ) nNew = nMin;
104646 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
104652 pSorter->nMemory = nNew;
117335 i64 nNew = sqlite3Strlen30(zNew);
117358 assert( nQuot>=nNew );
117383 nReplace = nNew;
163893 ** that the scan will visit nNew rows. This function returns the number
163901 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
163902 LogEst nRet = nNew;
164086 LogEst nNew;
164187 nNew = sqlite3LogEst(iUpper - iLower);
164192 if( iLwrIdx==iUprIdx ){ nNew -= 20; }
164195 nNew = 10; assert( 10==sqlite3LogEst(2) );
164197 if( nNew<nOut ){
164198 nOut = nNew;
164215 nNew = whereRangeAdjust(pLower, nOut);
164216 nNew = whereRangeAdjust(pUpper, nNew);
164225 nNew -= 20;
164229 if( nNew<10 ) nNew = 10;
164230 if( nNew<nOut ) nOut = nNew;
188980 int nNew;
188984 pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
188995 nOut = nNew;
189063 int nNew;
189066 pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
189078 nMerge = nNew;
191425 int nNew;
191437 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
191438 assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 );
191439 if( nNew>=0 && nNew<=pPhrase->doclist.nList ){
191440 assert( pPhrase->doclist.pList[nNew]=='\0' );
191441 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
191442 pPhrase->doclist.nList = nNew;
193157 static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){
193158 void *pRet = sqlite3_realloc64(pOrig, nNew);
195448 sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
195449 char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
197132 i64 nNew = p->nSpace * 2;
197133 p = sqlite3_realloc64(p, sizeof(*p) + nNew);
197139 p->nSpace = (int)nNew;
197876 i64 nNew = ((i64)nPrefix+nSuffix)*2;
197877 char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
197882 pReader->nTermAlloc = nNew;
199143 int nNew = nList*2 + FTS3_NODE_PADDING;
199144 pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, nNew);
199147 pMsr->nBuffer = nNew;
204222 int nNew; /* Number of valid entries in array aNew[] */
204226 nNew = p->nException;
204235 for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
204236 for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
204238 nNew++;
204242 p->nException = nNew;
209820 u64 nNew;
209821 nNew = p->nParentAlloc*2 + 3;
209822 pNew = sqlite3DbRealloc(p->db, p->aParent, sizeof(JsonParent)*nNew);
209824 p->nParentAlloc = (u32)nNew;
211789 int nNew = pCur->nPointAlloc*2 + 8;
211790 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
211793 pCur->nPointAlloc = nNew;
221219 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
221221 aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
221224 pRbu->nFrameAlloc = nNew;
222637 static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
222639 i64 nDiff = nNew - pFd->sz;
222641 pFd->sz = nNew;
225708 int nNew;
225712 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
225713 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
225733 int nNew;
225737 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
225739 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
225743 memcpy(aOut, aNew, nNew);
225744 aOut += nNew;
225853 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
225856 pSession, sizeof(SessionChange*) * nNew
225864 memset(apNew, 0, sizeof(SessionChange *) * nNew);
225871 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
225879 pTab->nChange = nNew;
226269 i64 nNew = p->nAlloc ? p->nAlloc : 128;
226272 nNew = nNew*2;
226273 }while( nNew<nReq );
226280 if( nNew>SESSION_MAX_BUFFER_SZ ){
226281 nNew = SESSION_MAX_BUFFER_SZ;
226282 if( nNew<nReq ){
226288 aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
226293 p->nAlloc = nNew;
226456 i64 nNew = 2;
226458 if( pTab->bRowid ) nNew += 9;
226464 sessionSerializeValue(0, p, &nNew);
226468 nNew += pC->nRecord;
226470 nNew += pC->nRecord;
226476 nNew += 9 + 1;
226530 nNew = pC->nRecord + 2;
226535 nNew += 1 + nOld;
226536 sessionSerializeValue(0, p, &nNew);
226538 nNew += 2 + nOld;
226540 nNew += 2;
226545 if( nNew>pC->nMaxSize ){
226546 int nIncr = nNew - pC->nMaxSize;
226547 pC->nMaxSize = nNew;
228235 int nNew = sessions_strm_chunk_size;
228238 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
228239 rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
228240 if( nNew==0 ){
228243 pIn->buf.nBuf += nNew;
234766 int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
234769 aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
234772 p->nFirstAlloc = nNew;
235237 u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
235239 while( nNew<nByte ){
235240 nNew = nNew * 2;
235242 pNew = sqlite3_realloc64(pBuf->p, nNew);
235247 pBuf->nSpace = (int)nNew;
238337 int nNew = pNear->nPhrase + SZALLOC;
238340 nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
238428 int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
238431 sizeof(Fts5ExprPhrase) + sizeof(Fts5ExprTerm) * nNew
238438 pNew->nTerm = nNew - SZALLOC;
240101 int nNew = pHash->nSlot*2;
240106 apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
240108 memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
240115 iHash = fts5HashKey(nNew, (u8*)fts5EntryKey(p), p->nKey);
240122 pHash->nSlot = nNew;
240259 sqlite3_int64 nNew = p->nAlloc * 2;
240262 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
240264 pNew->nAlloc = (int)nNew;
240663 ** varint: number of bytes of new term data (nNew)
240664 ** blob: nNew bytes of new term data
242414 int nNew; /* Bytes of new data */
242416 iOff += fts5GetVarint32(&a[iOff], nNew);
242417 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
242422 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
242424 iOff += nNew;
242566 int nNew = pIter->nRowidOffset + 8;
242567 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
242573 pIter->nRowidOffset = nNew;
243025 u32 nNew = 0;
243043 fts5FastGetVarint32(a, iOff, nNew);
243052 nCmp = (u32)MIN(nNew, nTerm-nMatch);
243059 if( i==nNew ){
243064 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
243107 iOff += fts5GetVarint32(&a[iOff], nNew);
243115 if( (i64)iOff+nNew>n || nNew<1 ){
243119 pIter->iLeafOffset = iOff + nNew;
243124 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
247208 int nNew = pT->nMapAlloc ? pT->nMapAlloc*2 : 64;
247209 int nByte = nNew * sizeof(Fts5TokenDataMap);
247219 pT->nMapAlloc = nNew;
247305 int nNew = (pT->nMapAlloc + nByte) * 2;
247307 pT->aMap, nNew*sizeof(Fts5TokenDataMap)
247314 pT->nMapAlloc = nNew;
254212 int nNew = p->nException;
254227 for(i=0; i<nNew; i++){
254230 memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
254232 nNew++;
254237 p->nException = nNew;