Lines Matching refs:nNew
31979 int nOld, nNew, nDiff;
31997 nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
31998 if( nOld==nNew ){
32004 nDiff = nNew - nOld;
32014 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
32018 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
32022 nNew = sqlite3MallocSize(pNew);
32023 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
32027 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
45736 ** descriptor pFd to nNew bytes. Any existing mapping is discarded.
45751 i64 nNew /* Required mapping size */
45761 assert( nNew>pFd->mmapSize );
45762 assert( nNew<=pFd->mmapSizeMax );
45763 assert( nNew>0 );
45786 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
45789 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
45792 osMunmap(pNew, nNew - nReuse);
45808 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
45813 nNew = 0;
45822 pFd->mmapSize = pFd->mmapSizeActual = nNew;
58171 u64 nNew;
58176 nNew = 2*(u64)p->nHash;
58177 if( nNew<256 ){
58178 nNew = 256;
58183 nNew);
58191 unsigned int h = pPage->iKey % nNew;
58199 p->nHash = nNew;
66249 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
66251 rc = pager_truncate(pPager, nNew);
66603 int nNew; /* Number of remaining savepoints after this op. */
66606 ** operation. Store this value in nNew. Then free resources associated
66609 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
66610 for(ii=nNew; ii<pPager->nSavepoint; ii++){
66613 pPager->nSavepoint = nNew;
66618 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
66635 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
80968 ** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells
80981 int nNew, /* Final number of cells on page */
80986 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
80992 int iNewEnd = iNew + nNew;
81019 int nAdd = MIN(nNew,iOld-iNew);
81020 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
81034 if( iCell>=0 && iCell<nNew ){
81053 iNew+nCell, nNew-nCell, pCArray
81059 assert( nNew < 10922 );
81060 pPg->nCell = (u16)nNew;
81067 for(i=0; i<nNew && !CORRUPT_DB; i++){
81081 if( nNew<1 ) return SQLITE_CORRUPT_BKPT;
81082 populateCellCache(pCArray, iNew, nNew);
81083 return rebuildPage(pCArray, iNew, nNew, pPg);
81358 int nNew = 0; /* Number of pages in apNew[] */
81776 nNew++;
81789 nNew++;
81814 for(i=0; i<nNew; i++){
81819 for(i=0; i<nNew-1; i++){
81821 for(j=i+1; j<nNew; j++){
81847 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
81848 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
81849 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
81850 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
81851 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
81852 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
81853 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
81854 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
81858 assert( nNew>=1 && nNew<=ArraySize(apNew) );
81859 assert( apNew[nNew-1]!=0 );
81860 put4byte(pRight, apNew[nNew-1]->pgno);
81865 if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
81867 if( nNew>nOld ){
81872 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
81902 assert( iOld<nNew || iOld<nOld );
81904 pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
81918 if( iOld>=nNew
81934 for(i=0; i<nNew-1; i++){
82008 ** The iPg value in the following loop starts at nNew-1 goes down
82009 ** to 0, then back up to nNew-1 again, thus making two passes over
82016 for(i=1-nNew; i<nNew; i++){
82018 assert( iPg>=0 && iPg<nNew );
82056 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
82059 assert( nNew>0 );
82077 assert( nNew==1 || CORRUPT_DB );
82091 for(i=0; i<nNew; i++){
82099 nOld, nNew, b.nCell));
82103 for(i=nNew; i<nOld; i++){
82113 ptrmapCheckPages(apNew, nNew);
82126 for(i=0; i<nNew; i++){
87896 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
87899 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
87905 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
87911 assert( nNew>=(v->nOpAlloc+nOp) );
87912 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
106913 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
106914 while( nByte>nNew ) nNew = nNew*2;
106915 aNew = sqlite3Realloc(p->aAlloc, nNew);
106917 p->nAlloc = nNew;
108235 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
108240 while( nNew < nMin ) nNew = nNew*2;
108241 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
108242 if( nNew < nMin ) nNew = nMin;
108243 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
108249 pSorter->nMemory = nNew;
121574 i64 nNew = sqlite3Strlen30(zNew);
121597 assert( nQuot>=nNew && nSql>=0 && nNew>=0 );
121624 nReplace = nNew;
161443 int nNew = (int)sqlite3_uri_int64(zFilename, "reserve", nRes);
161444 if( nNew>=0 && nNew<=255 ) nRes = nNew;
170478 ** that the scan will visit nNew rows. This function returns the number
170486 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
170487 LogEst nRet = nNew;
170671 LogEst nNew;
170772 nNew = sqlite3LogEst(iUpper - iLower);
170777 if( iLwrIdx==iUprIdx ){ nNew -= 20; }
170780 nNew = 10; assert( 10==sqlite3LogEst(2) );
170782 if( nNew<nOut ){
170783 nOut = nNew;
170800 nNew = whereRangeAdjust(pLower, nOut);
170801 nNew = whereRangeAdjust(pUpper, nNew);
170810 nNew -= 20;
170814 if( nNew<10 ) nNew = 10;
170815 if( nNew<nOut ) nOut = nNew;
196453 int nNew;
196457 pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
196468 nOut = nNew;
196536 int nNew;
196539 pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
196551 nMerge = nNew;
198897 int nNew;
198909 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
198910 assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 );
198911 if( nNew>=0 && nNew<=pPhrase->doclist.nList ){
198912 assert( pPhrase->doclist.pList[nNew]=='\0' );
198913 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
198914 pPhrase->doclist.nList = nNew;
200672 static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){
200673 void *pRet = sqlite3_realloc64(pOrig, nNew);
202961 sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
202962 char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
204659 i64 nNew = p->nSpace * 2;
204660 p = sqlite3_realloc64(p, sizeof(*p) + nNew);
204666 p->nSpace = (int)nNew;
205407 i64 nNew = ((i64)nPrefix+nSuffix)*2;
205408 char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
205413 pReader->nTermAlloc = nNew;
206674 int nNew = nList*2 + FTS3_NODE_PADDING;
206675 pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, nNew);
206678 pMsr->nBuffer = nNew;
211776 int nNew; /* Number of valid entries in array aNew[] */
211780 nNew = p->nException;
211789 for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
211790 for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
211792 nNew++;
211796 p->nException = nNew;
217625 u64 nNew;
217626 nNew = p->nParentAlloc*2 + 3;
217627 pNew = sqlite3DbRealloc(p->db, p->aParent, sizeof(JsonParent)*nNew);
217629 p->nParentAlloc = (u32)nNew;
219595 int nNew = pCur->nPointAlloc*2 + 8;
219596 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
219599 pCur->nPointAlloc = nNew;
229039 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
229041 aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
229044 pRbu->nFrameAlloc = nNew;
230459 static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
230461 i64 nDiff = nNew - pFd->sz;
230463 pFd->sz = nNew;
234193 int nNew;
234197 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
234198 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
234218 int nNew;
234222 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
234224 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
234228 memcpy(aOut, aNew, nNew);
234229 aOut += nNew;
234339 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
234342 pSession, sizeof(SessionChange*) * nNew
234350 memset(apNew, 0, sizeof(SessionChange *) * nNew);
234357 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
234365 pTab->nChange = nNew;
234773 i64 nNew = p->nAlloc ? p->nAlloc : 128;
234776 nNew = nNew*2;
234777 }while( nNew<nReq );
234784 if( nNew>SESSION_MAX_BUFFER_SZ ){
234785 nNew = SESSION_MAX_BUFFER_SZ;
234786 if( nNew<nReq ){
234792 aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
234797 p->nAlloc = nNew;
234960 i64 nNew = 2;
234962 if( pTab->bRowid ) nNew += 9;
234968 sessionSerializeValue(0, p, &nNew);
234972 nNew += pC->nRecord;
234974 nNew += pC->nRecord;
234980 nNew += 9 + 1;
235035 nNew = pC->nRecord + 2;
235040 nNew += 1 + nOld;
235041 sessionSerializeValue(0, p, &nNew);
235043 nNew += 2 + nOld;
235045 nNew += 2;
235050 if( nNew>pC->nMaxSize ){
235051 int nIncr = nNew - pC->nMaxSize;
235052 pC->nMaxSize = nNew;
236800 int nNew = sessions_strm_chunk_size;
236803 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
236804 rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
236805 if( nNew==0 ){
236808 pIn->buf.nBuf += nNew;
244151 int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
244154 aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
244157 p->nFirstAlloc = nNew;
244682 u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
244684 while( nNew<nByte ){
244685 nNew = nNew * 2;
244687 pNew = sqlite3_realloc64(pBuf->p, nNew);
244692 pBuf->nSpace = (int)nNew;
247881 int nNew = pNear->nPhrase + SZALLOC;
247884 nByte = SZ_FTS5EXPRNEARSET(nNew+1);
247972 int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
247975 SZ_FTS5EXPRPHRASE(nNew+1)
247982 pNew->nTerm = nNew - SZALLOC;
249655 int nNew = pHash->nSlot*2;
249660 apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
249662 memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
249669 iHash = fts5HashKey(nNew, (u8*)fts5EntryKey(p), p->nKey);
249676 pHash->nSlot = nNew;
249813 sqlite3_int64 nNew = p->nAlloc * 2;
249816 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
249818 pNew->nAlloc = (int)nNew;
250217 ** varint: number of bytes of new term data (nNew)
250218 ** blob: nNew bytes of new term data
252021 int nNew; /* Bytes of new data */
252023 iOff += fts5GetVarint32(&a[iOff], nNew);
252024 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
252029 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
252031 iOff += nNew;
252174 i64 nNew = pIter->nRowidOffset + 8;
252175 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
252181 pIter->nRowidOffset = nNew;
252635 u32 nNew = 0;
252653 fts5FastGetVarint32(a, iOff, nNew);
252662 nCmp = (u32)MIN(nNew, nTerm-nMatch);
252669 if( i==nNew ){
252674 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
252717 iOff += fts5GetVarint32(&a[iOff], nNew);
252725 if( (i64)iOff+nNew>n || nNew<1 ){
252729 pIter->iLeafOffset = iOff + nNew;
252734 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
256428 int nNew = 0;
256435 nNew = pSeg->term.n;
256437 if( nNew<nToken || memcmp(pToken, pNew, nToken) ) break;
256440 xVisit(p, pCtx, p1, pNew, nNew);
256564 i64 nNew = pT->nMapAlloc ? pT->nMapAlloc*2 : 64;
256565 i64 nAlloc = nNew * sizeof(Fts5TokenDataMap);
256575 pT->nMapAlloc = nNew;
256671 int nNew
256678 pSetup->nTermByte = nNew-1;
256680 fts5BufferAppendBlob(&p->rc, &pSetup->pT->terms, nNew-1, pNew+1);
256716 int nNew
256752 prefixIterSetupTokendataCb(p, (void*)pSetup->pTokendata, p1, pNew, nNew);
257228 i64 nNew = (pT->nMapAlloc + nByte) * 2;
257230 pT->aMap, nNew*sizeof(Fts5TokenDataMap)
257237 pT->nMapAlloc = nNew;
265324 int nNew = p->nException;
265339 for(i=0; i<nNew; i++){
265342 memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
265344 nNew++;
265349 p->nException = nNew;
Indexes created Thu Jun 11 00:25:07 UTC 2026