Lines Matching refs:nNew
6472 ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
29547 int nOld, nNew, nDiff;
29566 nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
29567 if( nOld==nNew ){
29573 nDiff = nNew - nOld;
29582 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
29586 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
29590 nNew = sqlite3MallocSize(pNew);
29591 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
29595 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
42032 ** descriptor pFd to nNew bytes. Any existing mapping is discarded.
42047 i64 nNew /* Required mapping size */
42057 assert( nNew>pFd->mmapSize );
42058 assert( nNew<=pFd->mmapSizeMax );
42059 assert( nNew>0 );
42082 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
42085 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
42088 osMunmap(pNew, nNew - nReuse);
42104 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
42109 nNew = 0;
42118 pFd->mmapSize = pFd->mmapSizeActual = nNew;
54073 unsigned int nNew;
54078 nNew = p->nHash*2;
54079 if( nNew<256 ){
54080 nNew = 256;
54085 apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
54093 unsigned int h = pPage->iKey % nNew;
54101 p->nHash = nNew;
62165 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
62167 rc = pager_truncate(pPager, nNew);
62519 int nNew; /* Number of remaining savepoints after this op. */
62522 ** operation. Store this value in nNew. Then free resources associated
62525 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
62526 for(ii=nNew; ii<pPager->nSavepoint; ii++){
62529 pPager->nSavepoint = nNew;
62534 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
62551 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
76124 ** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells
76137 int nNew, /* Final number of cells on page */
76142 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
76148 int iNewEnd = iNew + nNew;
76175 int nAdd = MIN(nNew,iOld-iNew);
76176 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
76190 if( iCell>=0 && iCell<nNew ){
76209 iNew+nCell, nNew-nCell, pCArray
76212 pPg->nCell = nNew;
76219 for(i=0; i<nNew && !CORRUPT_DB; i++){
76233 populateCellCache(pCArray, iNew, nNew);
76234 return rebuildPage(pCArray, iNew, nNew, pPg);
76508 int nNew = 0; /* Number of pages in apNew[] */
76922 nNew++;
76935 nNew++;
76960 for(i=0; i<nNew; i++){
76965 for(i=0; i<nNew-1; i++){
76967 for(j=i+1; j<nNew; j++){
76993 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
76994 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
76995 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
76996 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
76997 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
76998 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
76999 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
77000 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
77004 assert( nNew>=1 && nNew<=ArraySize(apNew) );
77005 assert( apNew[nNew-1]!=0 );
77006 put4byte(pRight, apNew[nNew-1]->pgno);
77011 if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){
77012 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
77013 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
77043 assert( iOld<nNew || iOld<nOld );
77045 pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
77059 if( iOld>=nNew
77075 for(i=0; i<nNew-1; i++){
77148 ** The iPg value in the following loop starts at nNew-1 goes down
77149 ** to 0, then back up to nNew-1 again, thus making two passes over
77156 for(i=1-nNew; i<nNew; i++){
77158 assert( iPg>=0 && iPg<nNew );
77194 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
77197 assert( nNew>0 );
77215 assert( nNew==1 || CORRUPT_DB );
77229 for(i=0; i<nNew; i++){
77237 nOld, nNew, b.nCell));
77241 for(i=nNew; i<nOld; i++){
77251 ptrmapCheckPages(apNew, nNew);
77264 for(i=0; i<nNew; i++){
82710 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
82713 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
82719 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
82725 assert( nNew>=(v->nOpAlloc+nOp) );
82726 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
100316 sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
100317 while( nByte>nNew ) nNew = nNew*2;
100318 aNew = sqlite3Realloc(p->aAlloc, nNew);
100320 p->nAlloc = nNew;
101613 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
101618 while( nNew < nMin ) nNew = nNew*2;
101619 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
101620 if( nNew < nMin ) nNew = nMin;
101621 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
101627 pSorter->nMemory = nNew;
113513 i64 nNew = sqlite3Strlen30(zNew);
113536 assert( nQuot>=nNew );
113561 nReplace = nNew;
158167 ** that the scan will visit nNew rows. This function returns the number
158175 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
158176 LogEst nRet = nNew;
158360 LogEst nNew;
158461 nNew = sqlite3LogEst(iUpper - iLower);
158466 if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) );
158468 nNew = 10; assert( 10==sqlite3LogEst(2) );
158470 if( nNew<nOut ){
158471 nOut = nNew;
158488 nNew = whereRangeAdjust(pLower, nOut);
158489 nNew = whereRangeAdjust(pUpper, nNew);
158498 nNew -= 20;
158502 if( nNew<10 ) nNew = 10;
158503 if( nNew<nOut ) nOut = nNew;
182470 int nNew;
182474 pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
182485 nOut = nNew;
182553 int nNew;
182556 pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
182568 nMerge = nNew;
184859 int nNew;
184871 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
184872 assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 );
184873 if( nNew>=0 && nNew<=pPhrase->doclist.nList ){
184874 assert( pPhrase->doclist.pList[nNew]=='\0' );
184875 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
184876 pPhrase->doclist.nList = nNew;
186574 static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){
186575 void *pRet = sqlite3_realloc64(pOrig, nNew);
188865 sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
188866 char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
190548 i64 nNew = p->nSpace * 2;
190549 p = sqlite3_realloc64(p, sizeof(*p) + nNew);
190555 p->nSpace = (int)nNew;
191292 i64 nNew = ((i64)nPrefix+nSuffix)*2;
191293 char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
191298 pReader->nTermAlloc = nNew;
197614 int nNew; /* Number of valid entries in array aNew[] */
197618 nNew = p->nException;
197627 for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
197628 for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
197630 nNew++;
197634 p->nException = nNew;
198952 u32 nNew;
198956 nNew = pParse->nAlloc*2 + 10;
198957 pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew);
198962 pParse->nAlloc = nNew;
202412 int nNew = pCur->nPointAlloc*2 + 8;
202413 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
202416 pCur->nPointAlloc = nNew;
211908 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
211910 aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
211913 pRbu->nFrameAlloc = nNew;
213309 static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
213311 i64 nDiff = nNew - pFd->sz;
213313 pFd->sz = nNew;
216311 int nNew;
216315 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
216316 if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
216336 int nNew;
216340 aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
216342 && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
216346 memcpy(aOut, aNew, nNew);
216347 aOut += nNew;
216449 sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
216452 pSession, sizeof(SessionChange*) * nNew
216460 memset(apNew, 0, sizeof(SessionChange *) * nNew);
216467 int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
216475 pTab->nChange = nNew;
216715 i64 nNew = 2;
216722 sessionSerializeValue(0, p, &nNew);
216726 nNew += pC->nRecord;
216728 nNew += pC->nRecord;
216784 nNew = pC->nRecord + 2;
216789 nNew += 1 + nOld;
216790 sessionSerializeValue(0, p, &nNew);
216792 nNew += 2 + nOld;
216794 nNew += 2;
216799 if( nNew>pC->nMaxSize ){
216800 int nIncr = nNew - pC->nMaxSize;
216801 pC->nMaxSize = nNew;
217517 i64 nNew = p->nAlloc ? p->nAlloc : 128;
217520 nNew = nNew*2;
217521 }while( nNew<nReq );
217528 if( nNew>SESSION_MAX_BUFFER_SZ ){
217529 nNew = SESSION_MAX_BUFFER_SZ;
217530 if( nNew<nReq ){
217536 aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
217541 p->nAlloc = nNew;
218430 int nNew = sessions_strm_chunk_size;
218433 if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
218434 rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
218435 if( nNew==0 ){
218438 pIn->buf.nBuf += nNew;
220692 int nNew = (int)strlen(zNew);
220697 if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
220702 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
220712 memcpy(pTab->zName, zNew, nNew+1);
224550 int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
224553 aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
224556 p->nFirstAlloc = nNew;
225017 u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
225019 while( nNew<nByte ){
225020 nNew = nNew * 2;
225022 pNew = sqlite3_realloc64(pBuf->p, nNew);
225027 pBuf->nSpace = (int)nNew;
227982 int nNew = pNear->nPhrase + SZALLOC;
227985 nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
228068 int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
228071 sizeof(Fts5ExprPhrase) + sizeof(Fts5ExprTerm) * nNew
228078 pNew->nTerm = nNew - SZALLOC;
229607 int nNew = pHash->nSlot*2;
229612 apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
229614 memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
229621 iHash = fts5HashKey(nNew, (u8*)fts5EntryKey(p),
229629 pHash->nSlot = nNew;
229766 sqlite3_int64 nNew = p->nAlloc * 2;
229769 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
229771 pNew->nAlloc = (int)nNew;
230118 ** varint: number of bytes of new term data (nNew)
230119 ** blob: nNew bytes of new term data
231711 int nNew; /* Bytes of new data */
231713 iOff += fts5GetVarint32(&a[iOff], nNew);
231714 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
231719 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
231721 iOff += nNew;
231841 int nNew = pIter->nRowidOffset + 8;
231842 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
231848 pIter->nRowidOffset = nNew;
232299 u32 nNew = 0;
232317 fts5FastGetVarint32(a, iOff, nNew);
232326 nCmp = (u32)MIN(nNew, nTerm-nMatch);
232333 if( i==nNew ){
232338 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
232381 iOff += fts5GetVarint32(&a[iOff], nNew);
232389 if( (i64)iOff+nNew>n || nNew<1 ){
232393 pIter->iLeafOffset = iOff + nNew;
232398 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
241186 int nNew = p->nException;
241201 for(i=0; i<nNew; i++){
241204 memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
241206 nNew++;
241211 p->nException = nNew;