Lines Matching defs:pOld
25099 static void memsys3FreeUnsafe(void *pOld){
25100 Mem3Block *p = (Mem3Block*)pOld;
25643 static void memsys5FreeUnsafe(void *pOld){
25647 /* Set iBlock to the index of the block pointed to by pOld in
25650 iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
25652 /* Check that the pointer pOld points to a valid, non-free block. */
25654 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
28056 SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){
28059 assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
28060 assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
28061 if( pOld==0 ){
28065 sqlite3_free(pOld); /* IMP: R-26507-47431 */
28072 nOld = sqlite3MallocSize(pOld);
28078 pNew = pOld;
28092 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
28096 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
28105 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
28115 SQLITE_API void *sqlite3_realloc(void *pOld, int n){
28120 return sqlite3Realloc(pOld, n);
28122 SQLITE_API void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){
28126 return sqlite3Realloc(pOld, n);
72703 MemPage *pOld = apOld[i];
72704 int limit = pOld->nCell;
72705 u8 *aData = pOld->aData;
72706 u16 maskPage = pOld->maskPage;
72707 u8 *piCell = aData + pOld->cellOffset;
72714 if( pOld->aData[0]!=apOld[0]->aData[0] ){
72719 /* Load b.apCell[] with pointers to all cells in pOld. If pOld
72736 memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
72737 if( pOld->nOverflow>0 ){
72738 if( NEVER(limit<pOld->aiOvfl[0]) ){
72742 limit = pOld->aiOvfl[0];
72748 for(k=0; k<pOld->nOverflow; k++){
72749 assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */
72750 b.apCell[b.nCell] = pOld->apOvfl[k];
72754 piEnd = aData + pOld->cellOffset + 2*pOld->nCell;
72761 assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) );
72777 if( !pOld->leaf ){
72779 assert( pOld->hdrOffset==0 );
72780 /* The right pointer of the child page pOld becomes the left
72782 memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
73035 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
73036 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
73056 MemPage *pOld;
73057 MemPage *pNew = pOld = apNew[0];
73068 pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
73069 cntOldNext += pOld->nCell + pOld->nOverflow + !leafData;
73084 || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
73090 ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
83982 SQLITE_API void sqlite3_value_free(sqlite3_value *pOld){
83983 sqlite3ValueFree(pOld);
107320 ** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew
107325 Token *pOld, /* Name of column being changed */
107359 zOld = sqlite3NameFromToken(db, pOld);
109132 static void statAccumDestructor(void *pOld){
109133 StatAccum *p = (StatAccum*)pOld;
109268 ** pNew and pOld are both candidate non-periodic samples selected for
109269 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
109271 ** function returns true if sample pNew is to be preferred over pOld.
109273 ** column for pNew and pOld are equal, is pNew to be preferred over pOld.
109281 StatSample *pOld
109285 assert( pNew->iCol==pOld->iCol );
109287 if( pNew->anEq[i]>pOld->anEq[i] ) return 1;
109288 if( pNew->anEq[i]<pOld->anEq[i] ) return 0;
109290 if( pNew->iHash>pOld->iHash ) return 1;
109297 ** Return true if pNew is to be preferred over pOld.
109305 StatSample *pOld
109308 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
109310 assert( pOld->isPSample==0 && pNew->isPSample==0 );
109311 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
109315 if( pNew->iCol<pOld->iCol ) return 1;
109316 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
109348 StatSample *pOld = &p->a[i];
109349 if( pOld->anEq[pNew->iCol]==0 ){
109350 if( pOld->isPSample ) return;
109351 assert( pOld->iCol>pNew->iCol );
109352 assert( sampleIsBetter(p, pNew, pOld) );
109353 if( pUpgrade==0 || sampleIsBetter(p, pOld, pUpgrade) ){
109354 pUpgrade = pOld;
112295 TESTONLY ( Index *pOld = ) sqlite3HashInsert(
112299 assert( pOld==pIndex || pOld==0 );
114230 Table *pOld;
114233 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
114234 if( pOld ){
114235 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
130919 Vdbe *pOld, /* VM being reprepared */
130939 rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
142480 Table *pOld;
142484 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
142485 if( pOld ){
142487 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
146469 WhereTerm *pOld = pWC->a;
146476 pWC->a = pOld;
146479 memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
146480 if( pOld!=pWC->aStatic ){
146481 sqlite3DbFree(db, pOld);
160978 SrcItem *pOld = yymsp[-4].minor.yy291->a;
160979 pNew->zName = pOld->zName;
160980 pNew->zDatabase = pOld->zDatabase;
160981 pNew->pSelect = pOld->pSelect;
160982 if( pOld->fg.isTabFunc ){
160983 pNew->u1.pFuncArg = pOld->u1.pFuncArg;
160984 pOld->u1.pFuncArg = 0;
160985 pOld->fg.isTabFunc = 0;
160988 pOld->zName = pOld->zDatabase = 0;
160989 pOld->pSelect = 0;
166166 void *pOld;
166175 pOld = db->pTraceArg;
166180 return pOld;
166221 void *pOld;
166230 pOld = db->pProfileArg;
166236 return pOld;
166251 void *pOld;
166260 pOld = db->pCommitArg;
166264 return pOld;
179089 void *pOld;
179096 pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
179097 if( pOld==pPtr ){
207280 sqlite3_session *pOld; /* Session object already attached to db */
207300 pOld = (sqlite3_session*)sqlite3_preupdate_hook(db, xPreUpdate, (void*)pNew);
207301 pNew->pNext = pOld;
209821 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
209823 if( p->abPK[i] || (bPatchset==0 && pOld) ){
209824 rc = sessionBindValue(pUp, i*2+2, pOld);
223445 ** (pNew/<length-unknown>) shares with buffer (pOld/nOld).
223448 ** than buffer (pOld/nOld).
223450 static int fts5PrefixCompress(int nOld, const u8 *pOld, const u8 *pNew){
223453 if( pOld[i]!=pNew[i] ) break;