Lines Matching refs:pNew
6472 ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
26104 void *pNew;
26108 pNew = sqlite3MemMalloc(nByte);
26109 if( pNew ){
26110 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize));
26112 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize);
26116 return pNew;
28043 sqlite3_debug_mutex *pNew = 0;
28047 pNew = sqlite3Malloc(sizeof(*pNew));
28048 if( pNew ){
28049 pNew->id = id;
28050 pNew->cnt = 0;
28061 pNew = &aStatic[id-2];
28062 pNew->id = id;
28066 return (sqlite3_mutex*)pNew;
29548 void *pNew;
29568 pNew = pOld;
29582 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
29584 if( pNew==0 && mem0.alarmThreshold>0 ){
29586 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
29589 if( pNew ){
29590 nNew = sqlite3MallocSize(pNew);
29595 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
29597 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
29598 return pNew;
29759 void *pNew = 0;
29764 pNew = sqlite3DbMallocRawNN(db, n);
29765 if( pNew ){
29766 memcpy(pNew, p, lookasideMallocSize(db, p));
29773 pNew = sqlite3Realloc(p, n);
29774 if( !pNew ){
29777 sqlite3MemdebugSetType(pNew,
29781 return pNew;
29789 void *pNew;
29790 pNew = sqlite3DbRealloc(db, p, n);
29791 if( !pNew ){
29794 return pNew;
35338 ** "pNew" is a pointer to the hash table that is to be initialized.
35340 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
35341 assert( pNew!=0 );
35342 pNew->first = 0;
35343 pNew->count = 0;
35344 pNew->htsize = 0;
35345 pNew->ht = 0;
35386 /* Link pNew element into the hash table pH. If pEntry!=0 then also
35387 ** insert pNew into the pEntry hash bucket.
35391 struct _ht *pEntry, /* The entry into which pNew is inserted */
35392 HashElem *pNew /* The element to be inserted */
35398 pEntry->chain = pNew;
35403 pNew->next = pHead;
35404 pNew->prev = pHead->prev;
35405 if( pHead->prev ){ pHead->prev->next = pNew; }
35406 else { pH->first = pNew; }
35407 pHead->prev = pNew;
35409 pNew->next = pH->first;
35410 if( pH->first ){ pH->first->prev = pNew; }
35411 pNew->prev = 0;
35412 pH->first = pNew;
37785 struct vxworksFileId *pNew; /* search key and new file ID */
37791 pNew = sqlite3_malloc64( sizeof(*pNew) + (n+1) );
37792 if( pNew==0 ) return 0;
37793 pNew->zCanonicalName = (char*)&pNew[1];
37794 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
37795 n = vxworksSimplifyName(pNew->zCanonicalName, n);
37804 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
37806 sqlite3_free(pNew);
37814 pNew->nRef = 1;
37815 pNew->nName = n;
37816 pNew->pNext = vxworksFileList;
37817 vxworksFileList = pNew;
37819 return pNew;
42053 u8 *pNew = 0; /* Location of new mapping */
42082 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
42085 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
42086 if( pNew!=MAP_FAILED ){
42087 if( pNew!=pReq ){
42088 osMunmap(pNew, nNew - nReuse);
42089 pNew = 0;
42091 pNew = pOrig;
42097 if( pNew==MAP_FAILED || pNew==0 ){
42102 /* If pNew is still NULL, try to create an entirely new mapping. */
42103 if( pNew==0 ){
42104 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
42107 if( pNew==MAP_FAILED ){
42108 pNew = 0;
42117 pFd->pMapRegion = (void *)pNew;
42427 unixFile *pNew /* open file object for the database file */
42468 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
42491 unixFile *pNew /* the open file object */
42508 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
42543 unixFile *pNew = (unixFile *)pId;
42546 assert( pNew->pInode==NULL );
42552 pNew->h = h;
42553 pNew->pVfs = pVfs;
42554 pNew->zPath = zFilename;
42555 pNew->ctrlFlags = (u8)ctrlFlags;
42557 pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
42561 pNew->ctrlFlags |= UNIXFILE_PSOW;
42564 pNew->ctrlFlags |= UNIXFILE_EXCL;
42568 pNew->pId = vxworksFindFileId(zFilename);
42569 if( pNew->pId==0 ){
42578 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
42583 pNew->lockingContext = (void*)zFilename;
42593 rc = findInodeInfo(pNew, &pNew->pInode);
42613 robust_close(pNew, h, __LINE__);
42625 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
42636 rc = findInodeInfo(pNew, &pNew->pInode);
42638 sqlite3_free(pNew->lockingContext);
42639 robust_close(pNew, h, __LINE__);
42661 pNew->lockingContext = zLockFile;
42670 rc = findInodeInfo(pNew, &pNew->pInode);
42671 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
42672 char *zSemName = pNew->pInode->aSemName;
42675 pNew->pId->zCanonicalName);
42678 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
42679 if( pNew->pInode->pSem == SEM_FAILED ){
42681 pNew->pInode->aSemName[0] = '\0';
42688 storeLastErrno(pNew, 0);
42691 if( h>=0 ) robust_close(pNew, h, __LINE__);
42694 pNew->ctrlFlags |= UNIXFILE_DELETE;
42698 if( h>=0 ) robust_close(pNew, h, __LINE__);
42702 verifyDbFile(pNew);
43996 unixFile *pNew;
44047 pNew = (unixFile *)sqlite3_malloc64(sizeof(*pNew));
44048 if( pNew==NULL ){
44052 memset(pNew, 0, sizeof(unixFile));
44053 pNew->openFlags = openFlags;
44059 pNew->pPreallocatedUnused = pUnused;
44061 rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
44063 *ppFile = pNew;
44067 robust_close(pNew, fd, __LINE__);
44068 sqlite3_free(pNew);
48998 winShmNode *pNew; /* Newly allocated winShmNode */
49009 pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 );
49010 if( pNew==0 ){
49014 pNew->zFilename = (char*)&pNew[1];
49015 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
49016 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
49026 if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
49029 sqlite3_free(pNew);
49034 pShmNode = pNew;
49035 pNew = 0;
49094 sqlite3_free(pNew);
49515 void *pNew = 0;
49549 pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap);
49551 pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
49553 if( pNew==NULL ){
49564 pFd->pMapRegion = pNew;
51546 unsigned char *pNew;
51555 pNew = sqlite3Realloc(p->aData, newSz);
51556 if( pNew==0 ) return SQLITE_IOERR_NOMEM;
51557 p->aData = pNew;
52958 sqlite3_pcache *pNew;
52959 pNew = sqlite3GlobalConfig.pcache2.xCreate(
52963 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
52964 sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
52968 pCache->pCache = pNew;
55007 struct RowSetChunk *pNew;
55008 pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
55009 if( pNew==0 ){
55012 pNew->pNextChunk = p->pChunk;
55013 p->pChunk = pNew;
55014 p->pFresh = pNew->aEntry;
59285 char *pNew = NULL; /* New temp space */
59294 pNew = (char *)sqlite3PageMalloc(pageSize+8);
59295 if( !pNew ){
59298 memset(pNew+pageSize, 0, 8);
59308 pPager->pTmpSpace = pNew;
59313 sqlite3PageFree(pNew);
67503 WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot;
67504 if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
67505 || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
76264 MemPage *pNew; /* Newly allocated page */
76266 Pgno pgnoNew; /* Page number of pNew */
76280 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
76290 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
76292 zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
76299 rc = rebuildPage(&b, 0, 1, pNew);
76301 releasePage(pNew);
76304 pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
76317 if( szCell>pNew->minLocal ){
76318 ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);
76351 releasePage(pNew);
76917 MemPage *pNew;
76919 pNew = apNew[i] = apOld[i];
76921 rc = sqlite3PagerWrite(pNew->pDbPage);
76923 if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv))
76931 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
76933 zeroPage(pNew, pageFlags);
76934 apNew[i] = pNew;
76940 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
77034 MemPage *pNew = pOld = apNew[0];
77035 int cntOldNext = pNew->nCell + pNew->nOverflow;
77049 pNew = apNew[++iNew];
77053 /* Cell pCell is destined for new sibling page pNew. Originally, it
77056 ** if sibling page iOld had the same page number as pNew, and if
77060 || pNew->pgno!=aPgno[iOld]
77064 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
77066 if( cachedCellSize(&b,i)>pNew->minLocal ){
77067 ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
77080 MemPage *pNew = apNew[i];
77088 if( !pNew->leaf ){
77089 memcpy(&pNew->aData[8], pCell, 4);
77098 pNew->xParseCell(pNew, b.apCell[j], &info);
77129 insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);
78015 MemPage *pNew = 0;
78016 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
78022 pPageOut = pNew;
82699 VdbeOp *pNew;
82726 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
82727 if( pNew ){
82728 p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
82730 v->aOp = pNew;
82732 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
83655 ScanStatus *pNew = &aNew[p->nScan++];
83656 pNew->addrExplain = addrExplain;
83657 pNew->addrLoop = addrLoop;
83658 pNew->addrVisit = addrVisit;
83659 pNew->nEst = nEst;
83660 pNew->zName = sqlite3DbStrDup(p->db, zName);
88200 sqlite3_value *pNew;
88202 pNew = sqlite3_malloc( sizeof(*pNew) );
88203 if( pNew==0 ) return 0;
88204 memset(pNew, 0, sizeof(*pNew));
88205 memcpy(pNew, pOrig, MEMCELLSIZE);
88206 pNew->flags &= ~MEM_Dyn;
88207 pNew->db = 0;
88208 if( pNew->flags&(MEM_Str|MEM_Blob) ){
88209 pNew->flags &= ~(MEM_Static|MEM_Dyn);
88210 pNew->flags |= MEM_Ephem;
88211 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
88212 sqlite3ValueFree(pNew);
88213 pNew = 0;
88215 }else if( pNew->flags & MEM_Null ){
88217 pNew->flags &= ~(MEM_Term|MEM_Subtype);
88219 return pNew;
93984 Savepoint *pNew;
94024 pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
94025 if( pNew ){
94026 pNew->zName = (char *)&pNew[1];
94027 memcpy(pNew->zName, zName, nName+1);
94039 pNew->pNext = db->pSavepoint;
94040 db->pSavepoint = pNew;
94041 pNew->nDeferredCons = db->nDeferredCons;
94042 pNew->nDeferredImmCons = db->nDeferredImmCons;
100956 MergeEngine *pNew; /* Pointer to allocated object to return */
100963 pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
100964 if( pNew ){
100965 pNew->nTree = N;
100966 pNew->pTask = 0;
100967 pNew->aReadr = (PmaReader*)&pNew[1];
100968 pNew->aTree = (int*)&pNew->aReadr[N];
100970 return pNew;
101549 SorterRecord *pNew; /* New list element */
101630 pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
101633 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
101636 pNew = (SorterRecord *)sqlite3Malloc(nReq);
101637 if( pNew==0 ){
101640 pNew->u.pNext = pSorter->list.pList;
101643 memcpy(SRVAL(pNew), pVal->z, pVal->n);
101644 pNew->nVal = pVal->n;
101645 pSorter->list.pList = pNew;
102090 MergeEngine *pNew; /* Merge engine to return */
102095 *ppOut = pNew = vdbeMergeEngineNew(nPMA);
102096 if( pNew==0 ) rc = SQLITE_NOMEM_BKPT;
102100 PmaReader *pReadr = &pNew->aReadr[i];
102106 vdbeMergeEngineFree(pNew);
102165 MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT);
102166 if( pNew==0 ){
102169 rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
102602 bytecodevtab *pNew;
102633 pNew = sqlite3_malloc( sizeof(*pNew) );
102634 *ppVtab = (sqlite3_vtab*)pNew;
102635 if( pNew==0 ) return SQLITE_NOMEM;
102636 memset(pNew, 0, sizeof(*pNew));
102637 pNew->db = db;
102638 pNew->bTablesUsed = isTabUsed*2;
103202 FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
103203 if( !pNew ){
103206 pNew->pNext = 0;
103209 pChunk->pNext = pNew;
103212 p->pFirst = pNew;
103214 pChunk = p->endpoint.pChunk = pNew;
103869 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
103870 if( pNew ){
103871 pNew->iTable = pMatch->iCursor;
103872 pNew->iColumn = iColumn;
103873 pNew->y.pTab = pMatch->pTab;
103875 ExprSetProperty(pNew, EP_CanBeNull);
103876 *ppList = sqlite3ExprListAppend(pParse, *ppList, pNew);
105176 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
105177 if( pNew==0 ) return 1;
105178 pNew->flags |= EP_IntValue;
105179 pNew->u.iValue = iCol;
105181 pItem->pExpr = pNew;
105187 pParent->pLeft = pNew;
105917 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
105918 if( pNew ){
105919 pNew->pLeft = pExpr;
105920 pNew->flags |= EP_Collate|EP_Skip;
105921 pExpr = pNew;
106657 Expr *pNew;
106669 pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
106670 if( pNew ){
106671 memset(pNew, 0, sizeof(Expr));
106672 pNew->op = (u8)op;
106673 pNew->iAgg = -1;
106676 pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
106677 pNew->u.iValue = iValue;
106679 pNew->u.zToken = (char*)&pNew[1];
106681 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
106682 pNew->u.zToken[pToken->n] = 0;
106683 if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
106684 sqlite3DequoteExpr(pNew);
106689 pNew->nHeight = 1;
106692 return pNew;
106886 Expr *pNew;
106889 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
106890 if( pNew==0 ){
106894 assert( !ExprHasProperty(pNew, EP_InnerON|EP_OuterON) );
106895 pNew->w.iOfst = (int)(pToken->z - pParse->zTail);
106902 pNew->x.pList = pList;
106903 ExprSetProperty(pNew, EP_HasFunc);
106904 assert( ExprUseXList(pNew) );
106905 sqlite3ExprSetHeightAndFlags(pParse, pNew);
106906 if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct);
106907 return pNew;
107229 Expr *pNew; /* Value to return */
107247 pNew = (Expr *)zAlloc;
107249 if( pNew ){
107251 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
107275 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
107276 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
107277 pNew->flags |= staticFlag;
107278 ExprClearVVAProperties(pNew);
107280 ExprSetVVAProperty(pNew, EP_Immutable);
107285 char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
107289 if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){
107290 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
107292 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags);
107294 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags);
107298 /* Fill in pNew->pLeft and pNew->pRight. */
107299 if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){
107301 if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){
107302 pNew->pLeft = p->pLeft ?
107304 pNew->pRight = p->pRight ?
107309 pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin);
107310 assert( ExprHasProperty(pNew, EP_WinFunc) );
107318 if( pNew->op==TK_SELECT_COLUMN ){
107319 pNew->pLeft = p->pLeft;
107323 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
107325 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
107329 return pNew;
107415 ExprList *pNew;
107423 pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p));
107424 if( pNew==0 ) return 0;
107425 pNew->nExpr = p->nExpr;
107426 pNew->nAlloc = p->nAlloc;
107427 pItem = pNew->a;
107455 return pNew;
107467 SrcList *pNew;
107473 pNew = sqlite3DbMallocRawNN(db, nByte );
107474 if( pNew==0 ) return 0;
107475 pNew->nSrc = pNew->nAlloc = p->nSrc;
107477 SrcItem *pNewItem = &pNew->a[i];
107512 return pNew;
107515 IdList *pNew;
107520 pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew)+(p->nId-1)*sizeof(p->a[0]) );
107521 if( pNew==0 ) return 0;
107522 pNew->nId = p->nId;
107523 pNew->eU4 = p->eU4;
107525 struct IdList_item *pNewItem = &pNew->a[i];
107530 return pNew;
107540 Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) );
107541 if( pNew==0 ) break;
107542 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
107543 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
107544 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
107545 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
107546 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
107547 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
107548 pNew->op = p->op;
107549 pNew->pNext = pNext;
107550 pNew->pPrior = 0;
107551 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
107552 pNew->iLimit = 0;
107553 pNew->iOffset = 0;
107554 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
107555 pNew->addrOpenEphm[0] = -1;
107556 pNew->addrOpenEphm[1] = -1;
107557 pNew->nSelectRow = p->nSelectRow;
107558 pNew->pWith = sqlite3WithDup(db, p->pWith);
107560 pNew->pWin = 0;
107561 pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
107562 if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
107564 pNew->selId = p->selId;
107569 pNew->pNext = 0;
107570 sqlite3SelectDelete(db, pNew);
107573 *pp = pNew;
107574 pp = &pNew->pPrior;
107575 pNext = pNew;
107629 ExprList *pNew;
107631 pNew = sqlite3DbRealloc(db, pList,
107633 if( pNew==0 ){
107638 pList = pNew;
112640 Table *pNew; /* Copy of pParse->pNewTable */
112656 pNew = pParse->pNewTable;
112657 assert( pNew );
112660 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
112662 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
112663 pCol = &pNew->aCol[pNew->nCol-1];
112664 pDflt = sqlite3ColumnExpr(pNew, pCol);
112684 if( pNew->pIndex ){
112698 assert( IsOrdinaryTable(pNew) );
112699 if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){
112742 assert( IsOrdinaryTable(pNew) );
112748 zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset,
112773 if( pNew->pCheck!=0
112805 Table *pNew;
112847 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
112848 if( !pNew ) goto exit_begin_add_column;
112849 pParse->pNewTable = pNew;
112850 pNew->nTabRef = 1;
112851 pNew->nCol = pTab->nCol;
112852 assert( pNew->nCol>0 );
112853 nAlloc = (((pNew->nCol-1)/8)*8)+8;
112854 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
112855 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
112856 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
112857 if( !pNew->aCol || !pNew->zName ){
112861 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
112862 for(i=0; i<pNew->nCol; i++){
112863 Column *pCol = &pNew->aCol[i];
112867 assert( IsOrdinaryTable(pNew) );
112868 pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
112869 pNew->pSchema = db->aDb[iDb].pSchema;
112870 pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
112871 pNew->nTabRef = 1;
112915 ** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew
112921 Token *pNew /* New column name */
112973 zNew = sqlite3NameFromToken(db, pNew);
112975 assert( pNew->n>0 );
112976 bQuote = sqlite3Isquote(pNew->z[0]);
113100 RenameToken *pNew;
113104 pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
113105 if( pNew ){
113106 pNew->p = pPtr;
113107 pNew->t = *pToken;
113108 pNew->pNext = pParse->pRename;
113109 pParse->pRename = pNew;
113615 Trigger *pNew = pParse->pNewTrigger;
113622 assert( pNew->pTabSchema );
113623 pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
113624 db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName
113626 pParse->eTriggerOp = pNew->op;
113634 if( rc==SQLITE_OK && pNew->pWhen ){
113635 rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen);
113638 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
115106 ** pNew and pOld are both candidate non-periodic samples selected for
115107 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
115109 ** function returns true if sample pNew is to be preferred over pOld.
115111 ** column for pNew and pOld are equal, is pNew to be preferred over pOld.
115118 StatSample *pNew,
115123 assert( pNew->iCol==pOld->iCol );
115124 for(i=pNew->iCol+1; i<nCol; i++){
115125 if( pNew->anEq[i]>pOld->anEq[i] ) return 1;
115126 if( pNew->anEq[i]<pOld->anEq[i] ) return 0;
115128 if( pNew->iHash>pOld->iHash ) return 1;
115135 ** Return true if pNew is to be preferred over pOld.
115142 StatSample *pNew,
115145 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
115148 assert( pOld->isPSample==0 && pNew->isPSample==0 );
115149 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
115153 if( pNew->iCol<pOld->iCol ) return 1;
115154 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
115160 ** Copy the contents of sample *pNew into the p->a[] array. If necessary,
115163 static void sampleInsert(StatAccum *p, StatSample *pNew, int nEqZero){
115176 if( pNew->isPSample==0 ){
115178 assert( pNew->anEq[pNew->iCol]>0 );
115187 if( pOld->anEq[pNew->iCol]==0 ){
115189 assert( pOld->iCol>pNew->iCol );
115190 assert( sampleIsBetter(p, pNew, pOld) );
115197 pUpgrade->iCol = pNew->iCol;
115198 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
115223 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
115227 sampleCopy(p, pSample, pNew);
116634 Db *pNew; /* Db object for the newly attached database */
116656 pNew = &db->aDb[db->init.iDb];
116657 if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
116658 pNew->pBt = 0;
116659 pNew->pSchema = 0;
116660 rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
116696 pNew = &db->aDb[db->nDb];
116697 memset(pNew, 0, sizeof(*pNew));
116713 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
116715 pNew->zDbSName = sqlite3DbStrDup(db, zName);
116723 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
116724 if( !pNew->pSchema ){
116726 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
116731 sqlite3BtreeEnter(pNew->pBt);
116732 pPager = sqlite3BtreePager(pNew->pBt);
116734 sqlite3BtreeSecureDelete(pNew->pBt,
116737 sqlite3BtreeSetPagerFlags(pNew->pBt,
116740 sqlite3BtreeLeave(pNew->pBt);
116742 pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
116743 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
122123 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
122124 if( pNew==0 ){
122128 pArray = pNew;
122149 IdList *pNew;
122150 pNew = sqlite3DbRealloc(db, pList,
122152 if( pNew==0 ){
122156 pList = pNew;
122241 SrcList *pNew;
122251 pNew = sqlite3DbRealloc(db, pSrc,
122253 if( pNew==0 ){
122257 pSrc = pNew;
122334 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
122335 if( pNew==0 ){
122339 pList = pNew;
122506 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
122507 if( pNew==0 ){
122510 p1 = pNew;
123052 Cte *pNew;
123055 pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
123056 assert( pNew!=0 || db->mallocFailed );
123062 pNew->pSelect = pQuery;
123063 pNew->pCols = pArglist;
123064 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
123065 pNew->eM10d = eM10d;
123067 return pNew;
123102 With *pNew;
123123 pNew = sqlite3DbRealloc(db, pWith, nByte);
123125 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
123127 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
123131 pNew = pWith;
123133 pNew->a[pNew->nCte++] = *pCte;
123137 return pNew;
128410 Expr *pNew;
128412 pNew = sqlite3PExpr(pParse, TK_DOT,
128426 pNew = sqlite3ExprDup(db, pDflt, 0);
128428 pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
128431 pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
128433 pList = sqlite3ExprListAppend(pParse, pList, pNew);
138014 sqlite3_stmt *pNew;
138025 rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
138030 assert( pNew==0 );
138033 assert( pNew!=0 );
138035 sqlite3VdbeSwap((Vdbe*)pNew, p);
138036 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
138037 sqlite3VdbeResetStepResult((Vdbe*)pNew);
138038 sqlite3VdbeFinalize((Vdbe*)pNew);
138343 Select *pNew, *pAllocated;
138345 pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
138346 if( pNew==0 ){
138348 pNew = &standin;
138354 pNew->pEList = pEList;
138355 pNew->op = TK_SELECT;
138356 pNew->selFlags = selFlags;
138357 pNew->iLimit = 0;
138358 pNew->iOffset = 0;
138359 pNew->selId = ++pParse->nSelect;
138360 pNew->addrOpenEphm[0] = -1;
138361 pNew->addrOpenEphm[1] = -1;
138362 pNew->nSelectRow = 0;
138364 pNew->pSrc = pSrc;
138365 pNew->pWhere = pWhere;
138366 pNew->pGroupBy = pGroupBy;
138367 pNew->pHaving = pHaving;
138368 pNew->pOrderBy = pOrderBy;
138369 pNew->pPrior = 0;
138370 pNew->pNext = 0;
138371 pNew->pLimit = pLimit;
138372 pNew->pWith = 0;
138374 pNew->pWin = 0;
138375 pNew->pWinDefn = 0;
138378 clearSelect(pParse->db, pNew, pNew!=&standin);
138381 assert( pNew->pSrc!=0 || pParse->nErr>0 );
139266 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
139267 if( pNew ){
139268 pNew->iTable = pExpr->iTable;
139269 assert( ExprUseYTab(pNew) );
139270 pNew->y.pTab = pExpr->y.pTab;
139271 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
139272 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
141718 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
141719 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
141720 pNew->flags |= EP_IntValue;
141721 pNew->u.iValue = i;
141722 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
142047 Expr *pNew;
142067 pNew = sqlite3ExprDup(db, pCopy, 0);
142069 sqlite3ExprDelete(db, pNew);
142073 ExprSetProperty(pNew, EP_CanBeNull);
142076 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
142080 pExpr = pNew;
142702 Select *pNew;
142711 pNew = sqlite3SelectDup(db, p, 0);
142716 if( pNew==0 ){
142719 pNew->selId = ++pParse->nSelect;
142721 renumberCursors(pParse, pNew, iFrom, aCsrMap);
142723 pNew->pPrior = pPrior;
142724 if( pPrior ) pPrior->pNext = pNew;
142725 pNew->pNext = p;
142726 p->pPrior = pNew;
142728 " creates %u as peer\n",pNew->selId));
143298 Expr *pNew;
143359 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
143360 unsetJoinExpr(pNew, -1, 1);
143367 pNew = substExpr(&x, pNew);
143369 if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){
143371 sqlite3ExprDelete(pParse->db, pNew);
143377 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
143379 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
143542 Select *pNew;
143572 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
143573 if( pNew==0 ) return WRC_Abort;
143575 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0);
143577 *pNew = *p;
143582 pNew->pGroupBy = 0;
143583 pNew->pHaving = 0;
143584 pNew->pOrderBy = 0;
143594 assert( pNew->pPrior!=0 );
143595 pNew->pPrior->pNext = pNew;
143596 pNew->pLimit = 0;
144128 ExprList *pNew = 0;
144143 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
144144 if( pNew ){
144145 pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
144146 pNew->a[pNew->nExpr-1].fg.eEName = a[k].fg.eEName;
144195 pNew = sqlite3ExprListAppend(pParse, pNew, pRight);
144196 if( pNew ){
144197 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
144267 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
144268 if( pNew==0 ){
144271 pX = &pNew->a[pNew->nExpr-1];
144309 p->pEList = pNew;
144680 Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
144681 if( pNew ){
144683 SWAP(Expr, *pNew, *pExpr);
144684 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
144685 pS->pWhere = pNew;
147278 ExprList *pNew = 0;
147291 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
147293 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
147300 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
147302 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
147308 return pNew;
147324 ExprList *pNew;
147347 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
147352 pReturning->nRetCol = pNew->nExpr;
147360 if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK
147364 int nCol = pNew->nExpr;
147369 Expr *pCol = pNew->a[i].pExpr;
147381 sqlite3ExprListDelete(db, pNew);
148074 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
148077 pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
148080 pList = sqlite3ExprListAppend(pParse, pList, pNew);
149254 Upsert *pNew;
149255 pNew = sqlite3DbMallocZero(db, sizeof(Upsert));
149256 if( pNew==0 ){
149264 pNew->pUpsertTarget = pTarget;
149265 pNew->pUpsertTargetWhere = pTargetWhere;
149266 pNew->pUpsertSet = pSet;
149267 pNew->pUpsertWhere = pWhere;
149268 pNew->isDoUpdate = pSet!=0;
149269 pNew->pNextUpsert = pNext;
149271 return pNew;
150782 Table *pNew = sParse.pNewTable;
150784 pTab->aCol = pNew->aCol;
150785 sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
150786 pTab->nNVCol = pTab->nCol = pNew->nCol;
150787 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
150788 pNew->nCol = 0;
150789 pNew->aCol = 0;
150791 assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
150792 if( !HasRowid(pNew)
150794 && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
150800 pIdx = pNew->pIndex;
150804 pNew->pIndex = 0;
151072 FuncDef *pNew;
151111 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
151113 if( pNew==0 ){
151116 *pNew = *pDef;
151117 pNew->zName = (const char*)&pNew[1];
151118 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
151119 pNew->xSFunc = xSFunc;
151120 pNew->pUserData = pArg;
151121 pNew->funcFlags |= SQLITE_FUNC_EPHEM;
151122 return pNew;
151721 WhereLoop *pNew; /* Template WhereLoop */
152403 Expr *pNew;
152404 pNew = sqlite3ExprDup(db, pX, 0);
152413 assert( ExprUseXSelect(pNew) );
152414 pOrigRhs = pNew->x.pSelect->pEList;
152415 assert( pNew->pLeft!=0 );
152416 assert( ExprUseXList(pNew->pLeft) );
152417 pOrigLhs = pNew->pLeft->x.pList;
152433 pNew->pLeft->x.pList = pLhs;
152434 pNew->x.pSelect->pEList = pRhs;
152441 sqlite3ExprDelete(db, pNew->pLeft);
152442 pNew->pLeft = p;
152444 pSelect = pNew->x.pSelect;
152463 sqlite3TreeViewExpr(0, pNew, 0);
152466 return pNew;
155217 Expr *pNew; /* New virtual expression */
155240 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
155241 if( pNew==0 ) return;
155243 pNew->op = op;
155244 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
155562 Expr *pNew; /* The complete IN operator */
155576 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0);
155577 if( pNew ){
155579 transferJoinMarkings(pNew, pExpr);
155580 assert( ExprUseXList(pNew) );
155581 pNew->x.pList = pList;
155582 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
155860 WhereTerm *pNew;
155862 u16 eExtraOp = 0; /* Extra bits for pNew->eOperator */
155873 pNew = &pWC->a[idxNew];
155875 if( op==TK_IS ) pNew->wtFlags |= TERM_IS;
155885 pNew = pTerm;
155887 pNew->wtFlags |= exprCommute(pParse, pDup);
155888 pNew->leftCursor = aiCurCol[0];
155890 pNew->u.x.leftColumn = aiCurCol[1];
155892 pNew->prereqRight = prereqLeft | extraRight;
155893 pNew->prereqAll = prereqAll;
155894 pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
156105 Expr *pNew;
156109 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
156110 transferJoinMarkings(pNew, pExpr);
156111 idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_SLICE);
156257 Expr *pNew;
156265 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
156270 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
156272 if( pNew ){
156275 idx = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_VIRTUAL);
156820 void *pNew = sqlite3WhereMalloc(pWInfo, nByte);
156821 if( pNew && pOld ){
156825 memcpy(pNew, pOld, pOldBlk->sz);
156827 return pNew;
158326 ** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index
158538 Index *p = pBuilder->pNew->u.btree.pIndex;
158539 int nEq = pBuilder->pNew->u.btree.nEq;
158602 Index *p = pBuilder->pNew->u.btree.pIndex;
159323 ** We have so far matched pBuilder->pNew->u.btree.nEq terms of the
159326 ** When this function is called, pBuilder->pNew->nOut contains the
159343 WhereLoop *pNew; /* Template WhereLoop under construction */
159347 Bitmask saved_prereq; /* Original value of pNew->prereq */
159348 u16 saved_nLTerm; /* Original value of pNew->nLTerm */
159349 u16 saved_nEq; /* Original value of pNew->u.btree.nEq */
159350 u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */
159351 u16 saved_nTop; /* Original value of pNew->u.btree.nTop */
159352 u16 saved_nSkip; /* Original value of pNew->nSkip */
159353 u32 saved_wsFlags; /* Original value of pNew->wsFlags */
159354 LogEst saved_nOut; /* Original value of pNew->nOut */
159360 pNew = pBuilder->pNew;
159364 pNew->u.btree.nEq, pNew->nSkip, pNew->rRun));
159366 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
159367 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
159368 if( pNew->wsFlags & WHERE_BTM_LIMIT ){
159371 assert( pNew->u.btree.nBtm==0 );
159376 assert( pNew->u.btree.nEq<pProbe->nColumn );
159377 assert( pNew->u.btree.nEq<pProbe->nKeyCol
159380 saved_nEq = pNew->u.btree.nEq;
159381 saved_nBtm = pNew->u.btree.nBtm;
159382 saved_nTop = pNew->u.btree.nTop;
159383 saved_nSkip = pNew->nSkip;
159384 saved_nLTerm = pNew->nLTerm;
159385 saved_wsFlags = pNew->wsFlags;
159386 saved_prereq = pNew->prereq;
159387 saved_nOut = pNew->nOut;
159390 pNew->rSetup = 0;
159406 if( pTerm->prereqRight & pNew->maskSelf ) continue;
159422 pNew->wsFlags = saved_wsFlags;
159423 pNew->u.btree.nEq = saved_nEq;
159424 pNew->u.btree.nBtm = saved_nBtm;
159425 pNew->u.btree.nTop = saved_nTop;
159426 pNew->nLTerm = saved_nLTerm;
159427 if( pNew->nLTerm>=pNew->nLSlot
159428 && whereLoopResize(db, pNew, pNew->nLTerm+1)
159430 break; /* OOM while trying to enlarge the pNew->aLTerm array */
159432 pNew->aLTerm[pNew->nLTerm++] = pTerm;
159433 pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
159436 || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0
159437 || (pNew->wsFlags & WHERE_COLUMN_IN)!=0
159438 || (pNew->wsFlags & WHERE_SKIPSCAN)!=0
159453 for(i=0; i<pNew->nLTerm-1; i++){
159454 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
159496 pNew->wsFlags |= WHERE_IN_SEEKSCAN;
159505 pNew->wsFlags |= WHERE_COLUMN_IN;
159508 pNew->wsFlags |= WHERE_COLUMN_EQ;
159509 assert( saved_nEq==pNew->u.btree.nEq );
159516 pNew->wsFlags |= WHERE_ONEROW;
159518 pNew->wsFlags |= WHERE_UNQ_WANTED;
159521 if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS;
159523 pNew->wsFlags |= WHERE_COLUMN_NULL;
159531 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
159532 pNew->u.btree.nBtm = nVecLen;
159542 if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
159543 pNew->aLTerm[pNew->nLTerm++] = pTop;
159544 pNew->wsFlags |= WHERE_TOP_LIMIT;
159545 pNew->u.btree.nTop = 1;
159551 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT;
159552 pNew->u.btree.nTop = nVecLen;
159554 pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ?
159555 pNew->aLTerm[pNew->nLTerm-2] : 0;
159559 /* At this point pNew->nOut is set to the number of rows expected to
159563 ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */
159564 assert( pNew->nOut==saved_nOut );
159565 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
159568 whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew);
159570 int nEq = ++pNew->u.btree.nEq;
159573 assert( pNew->nOut==saved_nOut );
159577 pNew->nOut += pTerm->truthProb;
159578 pNew->nOut -= nIn;
159584 && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
159600 pNew->nOut = sqlite3LogEst(nOut);
159605 && pNew->nOut+10 > pProbe->aiRowLogEst[0]
159622 if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut;
159623 pNew->nOut -= nIn;
159629 pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]);
159634 pNew->nOut += 10;
159641 ** it to pNew->rRun, which is currently set to the cost of the index
159645 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
159646 pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx);
159647 if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){
159648 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
159650 ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult);
159652 nOutUnadjusted = pNew->nOut;
159653 pNew->rRun += nInMul + nIn;
159654 pNew->nOut += nInMul + nIn;
159655 whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize);
159656 rc = whereLoopInsert(pBuilder, pNew);
159658 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
159659 pNew->nOut = saved_nOut;
159661 pNew->nOut = nOutUnadjusted;
159664 if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
159665 && pNew->u.btree.nEq<pProbe->nColumn
159666 && (pNew->u.btree.nEq<pProbe->nKeyCol ||
159671 pNew->nOut = saved_nOut;
159676 pNew->prereq = saved_prereq;
159677 pNew->u.btree.nEq = saved_nEq;
159678 pNew->u.btree.nBtm = saved_nBtm;
159679 pNew->u.btree.nTop = saved_nTop;
159680 pNew->nSkip = saved_nSkip;
159681 pNew->wsFlags = saved_wsFlags;
159682 pNew->nOut = saved_nOut;
159683 pNew->nLTerm = saved_nLTerm;
159698 && saved_nEq==pNew->nLTerm
159703 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
159706 pNew->u.btree.nEq++;
159707 pNew->nSkip++;
159708 pNew->aLTerm[pNew->nLTerm++] = 0;
159709 pNew->wsFlags |= WHERE_SKIPSCAN;
159711 pNew->nOut -= nIter;
159716 pNew->nOut = saved_nOut;
159717 pNew->u.btree.nEq = saved_nEq;
159718 pNew->nSkip = saved_nSkip;
159719 pNew->wsFlags = saved_wsFlags;
159890 ** is identified by pBuilder->pNew->iTab. That table is guaranteed to be
159935 WhereLoop *pNew; /* Template WhereLoop object */
159943 pNew = pBuilder->pNew;
159946 pSrc = pTabList->a + pNew->iTab;
160002 if( pTerm->prereqRight & pNew->maskSelf ) continue;
160004 pNew->u.btree.nEq = 1;
160005 pNew->nSkip = 0;
160006 pNew->u.btree.pIndex = 0;
160007 pNew->nLTerm = 1;
160008 pNew->aLTerm[0] = pTerm;
160017 pNew->rSetup = rLogSize + rSize;
160019 pNew->rSetup += 28;
160021 pNew->rSetup -= 10;
160023 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
160024 if( pNew->rSetup<0 ) pNew->rSetup = 0;
160029 pNew->nOut = 43; assert( 43==sqlite3LogEst(20) );
160030 pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut);
160031 pNew->wsFlags = WHERE_AUTO_INDEX;
160032 pNew->prereq = mPrereq | pTerm->prereqRight;
160033 rc = whereLoopInsert(pBuilder, pNew);
160048 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
160053 pNew->u.btree.nEq = 0;
160054 pNew->u.btree.nBtm = 0;
160055 pNew->u.btree.nTop = 0;
160056 pNew->nSkip = 0;
160057 pNew->nLTerm = 0;
160058 pNew->iSortIdx = 0;
160059 pNew->rSetup = 0;
160060 pNew->prereq = mPrereq;
160061 pNew->nOut = rSize;
160062 pNew->u.btree.pIndex = pProbe;
160069 pNew->wsFlags = WHERE_IPK;
160072 pNew->iSortIdx = b ? iSortIdx : 0;
160086 pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0);
160088 pNew->rRun = rSize + 16;
160091 pNew->wsFlags |= WHERE_VIEWSCAN;
160093 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
160094 whereLoopOutputAdjust(pWC, pNew, rSize);
160095 rc = whereLoopInsert(pBuilder, pNew);
160096 pNew->nOut = rSize;
160101 pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
160108 pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;
160124 pNew->iSortIdx = b ? iSortIdx : 0;
160129 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
160155 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup);
160157 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
160158 whereLoopOutputAdjust(pWC, pNew, rSize);
160165 rc = whereLoopInsert(pBuilder, pNew);
160167 pNew->nOut = rSize;
160203 ** be used by the virtual table identified by pBuilder->pNew->iTab. This
160238 WhereLoop *pNew = pBuilder->pNew;
160240 SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
160245 pNew->prereq = mPrereq;
160288 assert( pNew->nLSlot>=nConstraint );
160289 memset(pNew->aLTerm, 0, sizeof(pNew->aLTerm[0])*nConstraint );
160290 memset(&pNew->u.vtab, 0, sizeof(pNew->u.vtab));
160300 || pNew->aLTerm[iTerm]!=0
160311 pNew->prereq |= pTerm->prereqRight;
160312 assert( iTerm<pNew->nLSlot );
160313 pNew->aLTerm[iTerm] = pTerm;
160320 pNew->u.vtab.omitMask |= 1<<iTerm;
160325 pNew->u.vtab.bOmitOffset = 1;
160329 pNew->u.vtab.mHandleIn |= MASKBIT32(iTerm);
160359 pNew->nLTerm = mxTerm+1;
160361 if( pNew->aLTerm[i]==0 ){
160369 assert( pNew->nLTerm<=pNew->nLSlot );
160370 pNew->u.vtab.idxNum = pIdxInfo->idxNum;
160371 pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
160373 pNew->u.vtab.idxStr = pIdxInfo->idxStr;
160374 pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
160376 pNew->rSetup = 0;
160377 pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
160378 pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
160383 pNew->wsFlags |= WHERE_ONEROW;
160385 pNew->wsFlags &= ~WHERE_ONEROW;
160387 rc = whereLoopInsert(pBuilder, pNew);
160388 if( pNew->u.vtab.needFree ){
160389 sqlite3_free(pNew->u.vtab.idxStr);
160390 pNew->u.vtab.needFree = 0;
160394 (sqlite3_uint64)(pNew->prereq & ~mPrereq)));
160522 ** pBuilder->pNew->iTab. That table is guaranteed to be a virtual table.
160558 WhereLoop *pNew;
160567 pNew = pBuilder->pNew;
160568 pSrc = &pWInfo->pTabList->a[pNew->iTab];
160572 pNew->rSetup = 0;
160573 pNew->wsFlags = WHERE_VIRTUALTABLE;
160574 pNew->nLTerm = 0;
160575 pNew->u.vtab.needFree = 0;
160577 if( whereLoopResize(pParse->db, pNew, nConstraint) ){
160600 if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
160613 mBestNoIn = pNew->prereq & ~mPrereq;
160639 if( pNew->prereq==mPrereq ){
160683 WhereLoop *pNew;
160694 pNew = pBuilder->pNew;
160696 pItem = pWInfo->pTabList->a + pNew->iTab;
160704 && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
160772 pNew->nLTerm = 1;
160773 pNew->aLTerm[0] = pTerm;
160774 pNew->wsFlags = WHERE_MULTI_OR;
160775 pNew->rSetup = 0;
160776 pNew->iSortIdx = 0;
160777 memset(&pNew->u, 0, sizeof(pNew->u));
160791 pNew->rRun = sSum.a[i].rRun + 1;
160792 pNew->nOut = sSum.a[i].nOut;
160793 pNew->prereq = sSum.a[i].prereq;
160794 rc = whereLoopInsert(pBuilder, pNew);
160817 WhereLoop *pNew;
160821 pNew = pBuilder->pNew;
160823 /* Verify that pNew has already been initialized */
160824 assert( pNew->nLTerm==0 );
160825 assert( pNew->wsFlags==0 );
160826 assert( pNew->nLSlot>=ArraySize(pNew->aLTermSpace) );
160827 assert( pNew->aLTerm!=0 );
160832 pNew->iTab = iTab;
160834 pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
160871 mPrior |= pNew->maskSelf;
160883 whereLoopClear(db, pNew);
161753 pLoop = pBuilder->pNew;
162268 sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo);
162269 assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) );
162270 whereLoopInit(sWLB.pNew);
162272 sWLB.pNew->cId = '*';
165502 Window *pNew = 0;
165504 pNew = sqlite3DbMallocZero(db, sizeof(Window));
165505 if( pNew ){
165506 pNew->zName = sqlite3DbStrDup(db, p->zName);
165507 pNew->zBase = sqlite3DbStrDup(db, p->zBase);
165508 pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
165509 pNew->pWFunc = p->pWFunc;
165510 pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
165511 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
165512 pNew->eFrmType = p->eFrmType;
165513 pNew->eEnd = p->eEnd;
165514 pNew->eStart = p->eStart;
165515 pNew->eExclude = p->eExclude;
165516 pNew->regResult = p->regResult;
165517 pNew->regAccum = p->regAccum;
165518 pNew->iArgCol = p->iArgCol;
165519 pNew->iEphCsr = p->iEphCsr;
165520 pNew->bExprArgs = p->bExprArgs;
165521 pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
165522 pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
165523 pNew->pOwner = pOwner;
165524 pNew->bImplicitFrame = p->bImplicitFrame;
165527 return pNew;
168470 yyStackEntry *pNew;
168475 pNew = malloc(newSize*sizeof(pNew[0]));
168476 if( pNew ) pNew[0] = p->yystk0;
168478 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
168480 if( pNew ){
168481 p->yystack = pNew;
168491 return pNew==0;
170287 SrcItem *pNew = &yymsp[-5].minor.yy131->a[yymsp[-5].minor.yy131->nSrc-1];
170289 pNew->zName = pOld->zName;
170290 pNew->zDatabase = pOld->zDatabase;
170291 pNew->pSelect = pOld->pSelect;
170292 if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
170293 pNew->fg.isNestedFrom = 1;
170296 pNew->u1.pFuncArg = pOld->u1.pFuncArg;
170299 pNew->fg.isTabFunc = 1;
178628 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
178629 if( pNew ){
178630 memcpy(pNew, aArg, nArg*sizeof(void *));
178632 aDyn = aArg = pNew;
179280 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
182580 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
182584 Fts3SegReader *pNew
182591 sqlite3Fts3SegReaderFree(pNew);
182596 pCsr->apSegment[pCsr->nSegment++] = pNew;
186895 ** inserted into the tree. This function adds pNew, which is always a binary
186897 ** of pNew and the existing nodes of the tree. This may result in the head
186903 Fts3Expr *pNew /* New binary node to insert into expression tree */
186906 while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
186912 pSplit->pParent->pRight = pNew;
186913 pNew->pParent = pSplit->pParent;
186915 *ppHead = pNew;
186917 pNew->pLeft = pSplit;
186918 pSplit->pParent = pNew;
187667 ** "pNew" is a pointer to the hash table that is to be initialized.
187674 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
187675 assert( pNew!=0 );
187677 pNew->keyClass = keyClass;
187678 pNew->copyKey = copyKey;
187679 pNew->first = 0;
187680 pNew->count = 0;
187681 pNew->htsize = 0;
187682 pNew->ht = 0;
187783 struct _fts3ht *pEntry, /* The entry into which pNew is inserted */
187784 Fts3HashElem *pNew /* The element to be inserted */
187789 pNew->next = pHead;
187790 pNew->prev = pHead->prev;
187791 if( pHead->prev ){ pHead->prev->next = pNew; }
187792 else { pH->first = pNew; }
187793 pHead->prev = pNew;
187795 pNew->next = pH->first;
187796 if( pH->first ){ pH->first->prev = pNew; }
187797 pNew->prev = 0;
187798 pH->first = pNew;
187801 pEntry->chain = pNew;
188623 char *pNew;
188625 pNew = sqlite3_realloc64(c->zToken, c->nAllocated);
188626 if( !pNew ) return SQLITE_NOMEM;
188627 c->zToken = pNew;
189375 char *pNew;
189377 pNew = sqlite3_realloc64(c->pToken, c->nTokenAllocated);
189378 if( !pNew ) return SQLITE_NOMEM;
189379 c->pToken = pNew;
191919 SegmentNode *pNew;
191994 pNew = (SegmentNode *)sqlite3_malloc64(sizeof(SegmentNode) + p->nNodeSize);
191995 if( !pNew ){
191998 memset(pNew, 0, sizeof(SegmentNode));
191999 pNew->nData = 1 + FTS3_VARINT_MAX;
192000 pNew->aData = (char *)&pNew[1];
192008 pTree->pRight = pNew;
192009 pNew->pLeftmost = pTree->pLeftmost;
192010 pNew->pParent = pParent;
192011 pNew->zMalloc = pTree->zMalloc;
192012 pNew->nMalloc = pTree->nMalloc;
192015 pNew->pLeftmost = pNew;
192016 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
192019 *ppTree = pNew;
192558 char *pNew;
192560 pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, pMsr->nBuffer);
192561 if( !pNew ) return SQLITE_NOMEM;
192562 pMsr->aBuffer = pNew;
194490 ** This function creates a new node image in blob object *pNew by copying
194497 Blob *pNew, /* OUT: Write new node image here */
194511 blobGrowBuffer(pNew, nNode, &rc);
194513 pNew->n = 0;
194520 if( pNew->n==0 ){
194523 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
194527 pNew, &prev, reader.term.a, reader.term.n,
194532 if( pNew->n==0 ){
194533 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
194536 assert( pNew->n<=pNew->nAlloc );
197681 unicode_tokenizer *pNew; /* New tokenizer object */
197685 pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer));
197686 if( pNew==NULL ) return SQLITE_NOMEM;
197687 memset(pNew, 0, sizeof(unicode_tokenizer));
197688 pNew->eRemoveDiacritic = 1;
197695 pNew->eRemoveDiacritic = 1;
197698 pNew->eRemoveDiacritic = 0;
197701 pNew->eRemoveDiacritic = 2;
197704 rc = unicodeAddExceptions(pNew, 1, &z[11], n-11);
197707 rc = unicodeAddExceptions(pNew, 0, &z[11], n-11);
197716 unicodeDestroy((sqlite3_tokenizer *)pNew);
197717 pNew = 0;
197719 *pp = (sqlite3_tokenizer *)pNew;
198953 JsonNode *pNew;
198957 pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew);
198958 if( pNew==0 ){
198963 pParse->aNode = pNew;
199899 JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]);
199900 if( pNew==0 ) return 0;
199902 if( pNew!=&pTarget[j+1] ){
199909 pTarget[j+1].u.pPatch = pNew;
200388 sqlite3_vtab *pNew;
200414 pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
200415 if( pNew==0 ) return SQLITE_NOMEM;
200416 memset(pNew, 0, sizeof(*pNew));
202410 RtreeSearchPoint *pNew;
202413 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
202414 if( pNew==0 ) return 0;
202415 pCur->aPoint = pNew;
202419 pNew = pCur->aPoint + i;
202420 pNew->rScore = rScore;
202421 pNew->iLevel = iLevel;
202427 if( rtreeSearchPointCompare(pNew, pParent)>=0 ) break;
202430 pNew = pParent;
202432 return pNew;
202444 RtreeSearchPoint *pNew, *pFirst;
202453 pNew = rtreeEnqueue(pCur, rScore, iLevel);
202454 if( pNew==0 ) return 0;
202455 ii = (int)(pNew - pCur->aPoint) + 1;
202464 *pNew = pCur->sPoint;
202875 RtreeSearchPoint *pNew;
202877 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
202878 if( NEVER(pNew==0) ){ /* Because pCsr->bPoint was FALSE */
202881 pNew->id = 1;
202882 pNew->iCell = 0;
202883 pNew->eWithin = PARTLY_WITHIN;
206787 RtreeSearchPoint *pNew;
206788 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
206789 if( pNew==0 ){
206793 pNew->id = 1;
206794 pNew->iCell = 0;
206795 pNew->eWithin = PARTLY_WITHIN;
213781 char *pNew = (char*)sqlite3_malloc64(szRegion);
213782 if( pNew==0 ){
213785 memset(pNew, 0, szRegion);
213786 p->apShm[iRegion] = pNew;
214121 rbu_vfs *pNew = 0; /* Newly allocated VFS */
214128 pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
214129 if( pNew==0 ){
214133 memset(pNew, 0, nByte);
214139 memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
214140 pNew->base.mxPathname = pParent->mxPathname;
214141 pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
214142 pNew->pRealVfs = pParent;
214143 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
214147 pNew->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
214148 if( pNew->mutex==0 ){
214151 rc = sqlite3_vfs_register(&pNew->base, 0);
214156 sqlite3_mutex_free(pNew->mutex);
214157 sqlite3_free(pNew);
217352 sqlite3_session *pNew; /* Newly allocated session object */
217360 pNew = (sqlite3_session *)sqlite3_malloc64(sizeof(sqlite3_session) + nDb + 1);
217361 if( !pNew ) return SQLITE_NOMEM;
217362 memset(pNew, 0, sizeof(sqlite3_session));
217363 pNew->db = db;
217364 pNew->zDb = (char *)&pNew[1];
217365 pNew->bEnable = 1;
217366 memcpy(pNew->zDb, zDb, nDb+1);
217367 sessionPreupdateHooks(pNew);
217373 pOld = (sqlite3_session*)sqlite3_preupdate_hook(db, xPreUpdate, (void*)pNew);
217374 pNew->pNext = pOld;
217377 *ppSession = pNew;
219978 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
219982 if( rc==SQLITE_OK && pNew ){
219983 rc = sessionBindValue(pUp, i*2+1, pNew);
220491 SessionChange *pNew = 0;
220495 pNew = (SessionChange *)sqlite3_malloc64(sizeof(SessionChange) + nRec);
220496 if( !pNew ){
220499 memset(pNew, 0, sizeof(SessionChange));
220500 pNew->op = op2;
220501 pNew->bIndirect = bIndirect;
220502 pNew->aRecord = (u8*)&pNew[1];
220504 pNew->nRecord = nRec;
220505 memcpy(pNew->aRecord, aRec, nRec);
220509 u8 *pOut = pNew->aRecord;
220522 pNew->nRecord = pOut - pNew->aRecord;
220529 pNew = (SessionChange*)sqlite3_malloc64(nByte);
220530 if( pNew==0 ){
220538 memset(pNew, 0, nByte);
220539 pNew->bIndirect = bIndirect || pExist->bIndirect;
220540 pNew->op = op2;
220541 pOut = pNew->aRecord = (u8*)&pNew[1];
220558 pNew->nRecord = pOut - pNew->aRecord;
220583 pNew = pExist;
220586 assert( pNew==0 );
220596 pNew = (SessionChange *)sqlite3_malloc64(nByte);
220597 if( !pNew ){
220601 memset(pNew, 0, sizeof(SessionChange));
220602 pNew->bIndirect = (bIndirect && pExist->bIndirect);
220603 aCsr = pNew->aRecord = (u8 *)&pNew[1];
220608 pNew->op = SQLITE_INSERT;
220613 pNew->op = SQLITE_UPDATE;
220619 sqlite3_free(pNew);
220620 pNew = 0;
220631 pNew->op = SQLITE_UPDATE;
220633 sqlite3_free(pNew);
220634 pNew = 0;
220638 pNew->op = SQLITE_DELETE;
220647 if( pNew ){
220648 pNew->nRecord = (int)(aCsr - pNew->aRecord);
220654 *ppNew = pNew;
221239 sqlite3_rebaser *pNew;
221241 pNew = sqlite3_malloc(sizeof(sqlite3_rebaser));
221242 if( pNew==0 ){
221245 memset(pNew, 0, sizeof(sqlite3_rebaser));
221247 *ppNew = pNew;
223270 fts5yyStackEntry *pNew;
223275 pNew = malloc(newSize*sizeof(pNew[0]));
223276 if( pNew ) pNew[0] = p->fts5yystk0;
223278 pNew = realloc(p->fts5yystack, newSize*sizeof(pNew[0]));
223280 if( pNew ){
223281 p->fts5yystack = pNew;
223291 return pNew==0;
225018 u8 *pNew;
225022 pNew = sqlite3_realloc64(pBuf->p, nNew);
225023 if( pNew==0 ){
225028 pBuf->p = pNew;
226604 Fts5Expr *pNew;
226634 *ppNew = pNew = sqlite3_malloc(sizeof(Fts5Expr));
226635 if( pNew==0 ){
226641 pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&sParse.rc, nByte);
226642 if( pNew->pRoot ){
226643 pNew->pRoot->bEof = 1;
226646 pNew->pRoot = sParse.pExpr;
226648 pNew->pIndex = 0;
226649 pNew->pConfig = pConfig;
226650 pNew->apExprPhrase = sParse.apPhrase;
226651 pNew->nPhrase = sParse.nPhrase;
226652 pNew->bDesc = 0;
228067 Fts5ExprPhrase *pNew;
228070 pNew = (Fts5ExprPhrase*)sqlite3_realloc64(pPhrase,
228073 if( pNew==0 ){
228076 if( pPhrase==0 ) memset(pNew, 0, sizeof(Fts5ExprPhrase));
228077 pCtx->pPhrase = pPhrase = pNew;
228078 pNew->nTerm = nNew - SZALLOC;
228200 Fts5Expr *pNew = 0; /* Expression to return via *ppNew */
228204 pNew = (Fts5Expr*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Expr));
228206 pNew->apExprPhrase = (Fts5ExprPhrase**)sqlite3Fts5MallocZero(&rc,
228210 pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&rc,
228214 pNew->pRoot->pNear = (Fts5ExprNearset*)sqlite3Fts5MallocZero(&rc,
228227 pNew->pRoot->pNear->pColset = pColset;
228255 pNew->pIndex = pExpr->pIndex;
228256 pNew->pConfig = pExpr->pConfig;
228257 pNew->nPhrase = 1;
228258 pNew->apExprPhrase[0] = sCtx.pPhrase;
228259 pNew->pRoot->pNear->apPhrase[0] = sCtx.pPhrase;
228260 pNew->pRoot->pNear->nPhrase = 1;
228261 sCtx.pPhrase->pNode = pNew->pRoot;
228267 pNew->pRoot->eType = FTS5_TERM;
228268 pNew->pRoot->xNext = fts5ExprNodeNext_TERM;
228270 pNew->pRoot->eType = FTS5_STRING;
228271 pNew->pRoot->xNext = fts5ExprNodeNext_STRING;
228274 sqlite3Fts5ExprFree(pNew);
228276 pNew = 0;
228279 *ppNew = pNew;
228338 Fts5Colset *pNew; /* New colset object to return */
228343 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
228344 if( pNew==0 ){
228347 int *aiCol = pNew->aiCol;
228350 if( aiCol[i]==iCol ) return pNew;
228357 pNew->nCol = nCol+1;
228361 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
228365 return pNew;
229531 Fts5Hash *pNew;
229533 *ppNew = pNew = (Fts5Hash*)sqlite3_malloc(sizeof(Fts5Hash));
229534 if( pNew==0 ){
229538 memset(pNew, 0, sizeof(Fts5Hash));
229539 pNew->pnByte = pnByte;
229540 pNew->eDetail = pConfig->eDetail;
229542 pNew->nSlot = 1024;
229543 nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
229544 pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte);
229545 if( pNew->aSlot==0 ){
229546 sqlite3_free(pNew);
229550 memset(pNew->aSlot, 0, (size_t)nByte);
229767 Fts5HashEntry *pNew;
229769 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
229770 if( pNew==0 ) return SQLITE_NOMEM;
229771 pNew->nAlloc = (int)nNew;
229773 *pp = pNew;
229774 p = pNew;
230859 Fts5Structure *pNew;
230860 pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte);
230861 if( pNew ){
230863 memcpy(pNew, p, nByte);
230864 for(i=0; i<p->nLevel; i++) pNew->aLevel[i].aSeg = 0;
230866 Fts5StructureLevel *pLvl = &pNew->aLevel[i];
230867 nByte = sizeof(Fts5StructureSegment) * pNew->aLevel[i].nSeg;
230871 sqlite3_free(pNew->aLevel[i].aSeg);
230873 sqlite3_free(pNew);
230879 pNew->nRef = 1;
230881 *pp = pNew;
231542 Fts5DlidxIter *pNew;
231544 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
231545 if( pNew==0 ){
231549 Fts5DlidxLvl *pLvl = &pNew->aLvl[i];
231550 pIter = pNew;
231868 Fts5Data *pNew;
231870 pNew = fts5DataRead(p, FTS5_SEGMENT_ROWID(
231873 if( pNew ){
231879 if( pIter->iTermLeafOffset<pNew->szLeaf ){
231880 pIter->pLeaf = pNew;
231885 iRowidOff = fts5LeafFirstRowidOff(pNew);
231887 if( iRowidOff>=pNew->szLeaf ){
231890 pIter->pLeaf = pNew;
231901 fts5DataRelease(pNew);
232199 Fts5Data *pNew = fts5LeafRead(p, iAbs);
232200 if( pNew ){
232202 iRowid = fts5LeafFirstRowidOff(pNew);
232203 bTermless = fts5LeafIsTermless(pNew);
232205 SWAPVAL(Fts5Data*, pNew, pLast);
232208 fts5DataRelease(pNew);
232868 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
232870 if( pNew->iRowid==pIter->iSwitchRowid
232871 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
232879 assert( pNew->pLeaf );
232883 if( pNew->iRowid==pOther->iRowid ){
232885 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
232887 pNew = pOther;
232892 pRes->iFirst = (u16)(pNew - pIter->aSeg);
232899 *ppFirst = pNew;
232993 Fts5Iter *pNew;
232997 pNew = fts5IdxMalloc(p,
232998 sizeof(Fts5Iter) + /* pNew */
232999 sizeof(Fts5SegIter) * (nSlot-1) + /* pNew->aSeg[] */
233000 sizeof(Fts5CResult) * nSlot /* pNew->aFirst[] */
233002 if( pNew ){
233003 pNew->nSeg = nSlot;
233004 pNew->aFirst = (Fts5CResult*)&pNew->aSeg[nSlot];
233005 pNew->pIndex = p;
233006 pNew->xSetOutputs = fts5IterSetOutputs_Noop;
233008 return pNew;
233465 Fts5Iter *pNew;
233479 *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
233480 if( pNew==0 ){
233484 pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
233485 pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
233486 pNew->pColset = pColset;
233488 fts5IterSetOutputCb(&p->rc, pNew);
233497 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
233503 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
233514 fts5SegIterInit(p, &pLvl->aSeg[iSeg], &pNew->aSeg[iIter++]);
233525 for(iIter=pNew->nSeg-1; iIter>0; iIter--){
233527 if( (iEq = fts5MultiIterDoCompare(pNew, iIter)) ){
233528 Fts5SegIter *pSeg = &pNew->aSeg[iEq];
233530 fts5MultiIterAdvanced(p, pNew, iEq, iIter);
233533 fts5MultiIterSetEof(pNew);
233534 fts5AssertMultiIterSetup(p, pNew);
233536 if( pNew->bSkipEmpty && fts5MultiIterIsEmpty(p, pNew) ){
233537 fts5MultiIterNext(p, pNew, 0, 0);
233538 }else if( pNew->base.bEof==0 ){
233539 Fts5SegIter *pSeg = &pNew->aSeg[pNew->aFirst[1].iFirst];
233540 pNew->xSetOutputs(pNew, pSeg);
233544 fts5MultiIterFree(pNew);
233563 Fts5Iter *pNew;
233564 pNew = fts5MultiIterAlloc(p, 2);
233565 if( pNew ){
233566 Fts5SegIter *pIter = &pNew->aSeg[1];
233573 pNew->aFirst[1].iFirst = 1;
233575 pNew->bRev = 1;
233583 pNew->base.bEof = 1;
233587 *ppOut = pNew;
233719 ** (pNew/<length-unknown>) shares with buffer (pOld/nOld).
233721 ** Buffer (pNew/<length-unknown>) is guaranteed to be greater
233724 static int fts5PrefixCompress(int nOld, const u8 *pOld, const u8 *pNew){
233727 if( pOld[i]!=pNew[i] ) break;
234745 Fts5Structure *pNew = 0;
234771 pNew = (Fts5Structure*)sqlite3Fts5MallocZero(&p->rc, nByte);
234773 if( pNew ){
234776 pNew->nLevel = pStruct->nLevel+1;
234777 pNew->nRef = 1;
234778 pNew->nWriteCounter = pStruct->nWriteCounter;
234779 pLvl = &pNew->aLevel[pStruct->nLevel];
234793 pNew->nSegment = pLvl->nSeg = nSeg;
234795 sqlite3_free(pNew);
234796 pNew = 0;
234800 return pNew;
234805 Fts5Structure *pNew = 0;
234813 pNew = fts5IndexOptimizeStruct(p, pStruct);
234817 assert( pNew==0 || pNew->nSegment>0 );
234818 if( pNew ){
234820 for(iLvl=0; pNew->aLevel[iLvl].nSeg==0; iLvl++){}
234821 while( p->rc==SQLITE_OK && pNew->aLevel[iLvl].nSeg>0 ){
234823 fts5IndexMergeLevel(p, &pNew, iLvl, &nRem);
234826 fts5StructureWrite(p, pNew);
234827 fts5StructureRelease(pNew);
234843 Fts5Structure *pNew = fts5IndexOptimizeStruct(p, pStruct);
234845 pStruct = pNew;
239137 Fts5Cursor *pNew = 0;
239139 rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
239141 pNew->ePlan = FTS5_PLAN_MATCH;
239142 pNew->iFirstRowid = SMALLEST_INT64;
239143 pNew->iLastRowid = LARGEST_INT64;
239144 pNew->base.pVtab = (sqlite3_vtab*)pTab;
239145 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
239149 for(rc = fts5CursorFirst(pTab, pNew, 0);
239150 rc==SQLITE_OK && CsrFlagTest(pNew, FTS5CSR_EOF)==0;
239151 rc = fts5NextMethod((sqlite3_vtab_cursor*)pNew)
239153 rc = xCallback(&sFts5Api, (Fts5Context*)pNew, pUserData);
239161 fts5CloseMethod((sqlite3_vtab_cursor*)pNew);
239475 Fts5TokenizerModule *pNew;
239482 pNew = (Fts5TokenizerModule*)sqlite3_malloc64(nByte);
239483 if( pNew ){
239484 memset(pNew, 0, (size_t)nByte);
239485 pNew->zName = (char*)&pNew[1];
239486 memcpy(pNew->zName, zName, nName);
239487 pNew->pUserData = pUserData;
239488 pNew->x = *pTokenizer;
239489 pNew->xDestroy = xDestroy;
239490 pNew->pNext = pGlobal->pTok;
239491 pGlobal->pTok = pNew;
239492 if( pNew->pNext==0 ){
239493 pGlobal->pDfltTok = pNew;
242210 TrigramTokenizer *pNew = (TrigramTokenizer*)sqlite3_malloc(sizeof(*pNew));
242212 if( pNew==0 ){
242216 pNew->bFold = 1;
242223 pNew->bFold = (zArg[0]=='0');
242230 fts5TriDelete((Fts5Tokenizer*)pNew);
242231 pNew = 0;
242234 *ppOut = (Fts5Tokenizer*)pNew;
244345 stmt_vtab *pNew;
244366 pNew = sqlite3_malloc64( sizeof(*pNew) );
244367 *ppVtab = (sqlite3_vtab*)pNew;
244368 if( pNew==0 ) return SQLITE_NOMEM;
244369 memset(pNew, 0, sizeof(*pNew));
244370 pNew->db = db;
244486 StmtRow *pNew = (StmtRow*)sqlite3_malloc64(sizeof(StmtRow) + nSql);
244488 if( pNew==0 ) return SQLITE_NOMEM;
244489 memset(pNew, 0, sizeof(StmtRow));
244491 pNew->zSql = (char*)&pNew[1];
244492 memcpy(pNew->zSql, zSql, nSql);
244494 pNew->aCol[STMT_COLUMN_NCOL] = sqlite3_column_count(p);
244495 pNew->aCol[STMT_COLUMN_RO] = sqlite3_stmt_readonly(p);
244496 pNew->aCol[STMT_COLUMN_BUSY] = sqlite3_stmt_busy(p);
244497 pNew->aCol[STMT_COLUMN_NSCAN] = sqlite3_stmt_status(
244500 pNew->aCol[STMT_COLUMN_NSORT] = sqlite3_stmt_status(
244503 pNew->aCol[STMT_COLUMN_NAIDX] = sqlite3_stmt_status(
244506 pNew->aCol[STMT_COLUMN_NSTEP] = sqlite3_stmt_status(
244509 pNew->aCol[STMT_COLUMN_REPREP] = sqlite3_stmt_status(
244512 pNew->aCol[STMT_COLUMN_RUN] = sqlite3_stmt_status(
244515 pNew->aCol[STMT_COLUMN_MEM] = sqlite3_stmt_status(
244518 pNew->iRowid = iRowid++;
244519 *ppRow = pNew;
244520 ppRow = &pNew->pNext;