Lines Matching refs:pNew
27278 void *pNew; in sqlite3MemRealloc() local
27282 pNew = sqlite3MemMalloc(nByte); in sqlite3MemRealloc()
27283 if( pNew ){ in sqlite3MemRealloc()
27284 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize)); in sqlite3MemRealloc()
27286 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); in sqlite3MemRealloc()
27290 return pNew; in sqlite3MemRealloc()
29217 sqlite3_debug_mutex *pNew = 0; in debugMutexAlloc() local
29221 pNew = sqlite3Malloc(sizeof(*pNew)); in debugMutexAlloc()
29222 if( pNew ){ in debugMutexAlloc()
29223 pNew->id = id; in debugMutexAlloc()
29224 pNew->cnt = 0; in debugMutexAlloc()
29235 pNew = &aStatic[id-2]; in debugMutexAlloc()
29236 pNew->id = id; in debugMutexAlloc()
29240 return (sqlite3_mutex*)pNew; in debugMutexAlloc()
30741 void *pNew; in sqlite3Realloc() local
30761 pNew = pOld; in sqlite3Realloc()
30776 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
30778 if( pNew==0 && mem0.alarmThreshold>0 ){ in sqlite3Realloc()
30780 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
30783 if( pNew ){ in sqlite3Realloc()
30784 nNew = sqlite3MallocSize(pNew); in sqlite3Realloc()
30789 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); in sqlite3Realloc()
30791 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ in sqlite3Realloc()
30792 return pNew; in sqlite3Realloc()
30953 void *pNew = 0; in dbReallocFinish() local
30958 pNew = sqlite3DbMallocRawNN(db, n); in dbReallocFinish()
30959 if( pNew ){ in dbReallocFinish()
30960 memcpy(pNew, p, lookasideMallocSize(db, p)); in dbReallocFinish()
30967 pNew = sqlite3Realloc(p, n); in dbReallocFinish()
30968 if( !pNew ){ in dbReallocFinish()
30971 sqlite3MemdebugSetType(pNew, in dbReallocFinish()
30975 return pNew; in dbReallocFinish()
30983 void *pNew; in sqlite3DbReallocOrFree() local
30984 pNew = sqlite3DbRealloc(db, p, n); in sqlite3DbReallocOrFree()
30985 if( !pNew ){ in sqlite3DbReallocOrFree()
30988 return pNew; in sqlite3DbReallocOrFree()
32570 RCStr *pNew; in sqlite3RCStrResize() local
32574 pNew = sqlite3_realloc64(p, N+sizeof(RCStr)+1); in sqlite3RCStrResize()
32575 if( pNew==0 ){ in sqlite3RCStrResize()
32579 return (char*)&pNew[1]; in sqlite3RCStrResize()
36917 SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
36918 assert( pNew!=0 );
36919 pNew->first = 0;
36920 pNew->count = 0;
36921 pNew->htsize = 0;
36922 pNew->ht = 0;
36969 HashElem *pNew /* The element to be inserted */
36975 pEntry->chain = pNew;
36980 pNew->next = pHead;
36981 pNew->prev = pHead->prev;
36982 if( pHead->prev ){ pHead->prev->next = pNew; }
36983 else { pH->first = pNew; }
36984 pHead->prev = pNew;
36986 pNew->next = pH->first;
36987 if( pH->first ){ pH->first->prev = pNew; }
36988 pNew->prev = 0;
36989 pH->first = pNew;
39372 struct vxworksFileId *pNew; /* search key and new file ID */
39378 pNew = sqlite3_malloc64( sizeof(*pNew) + (n+1) );
39379 if( pNew==0 ) return 0;
39380 pNew->zCanonicalName = (char*)&pNew[1];
39381 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
39382 n = vxworksSimplifyName(pNew->zCanonicalName, n);
39391 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
39393 sqlite3_free(pNew);
39401 pNew->nRef = 1;
39402 pNew->nName = n;
39403 pNew->pNext = vxworksFileList;
39404 vxworksFileList = pNew;
39406 return pNew;
43677 u8 *pNew = 0; /* Location of new mapping */
43706 pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
43709 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
43710 if( pNew!=MAP_FAILED ){
43711 if( pNew!=pReq ){
43712 osMunmap(pNew, nNew - nReuse);
43713 pNew = 0;
43715 pNew = pOrig;
43721 if( pNew==MAP_FAILED || pNew==0 ){
43727 if( pNew==0 ){
43728 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
43731 if( pNew==MAP_FAILED ){
43732 pNew = 0;
43741 pFd->pMapRegion = (void *)pNew;
44056 unixFile *pNew /* open file object for the database file */
44097 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44120 unixFile *pNew /* the open file object */
44137 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44172 unixFile *pNew = (unixFile *)pId;
44175 assert( pNew->pInode==NULL );
44181 pNew->h = h;
44182 pNew->pVfs = pVfs;
44183 pNew->zPath = zFilename;
44184 pNew->ctrlFlags = (u8)ctrlFlags;
44186 pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
44190 pNew->ctrlFlags |= UNIXFILE_PSOW;
44193 pNew->ctrlFlags |= UNIXFILE_EXCL;
44197 pNew->pId = vxworksFindFileId(zFilename);
44198 if( pNew->pId==0 ){
44207 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
44212 pNew->lockingContext = (void*)zFilename;
44222 rc = findInodeInfo(pNew, &pNew->pInode);
44242 robust_close(pNew, h, __LINE__);
44254 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
44265 rc = findInodeInfo(pNew, &pNew->pInode);
44267 sqlite3_free(pNew->lockingContext);
44268 robust_close(pNew, h, __LINE__);
44290 pNew->lockingContext = zLockFile;
44299 rc = findInodeInfo(pNew, &pNew->pInode);
44300 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
44301 char *zSemName = pNew->pInode->aSemName;
44304 pNew->pId->zCanonicalName);
44307 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
44308 if( pNew->pInode->pSem == SEM_FAILED ){
44310 pNew->pInode->aSemName[0] = '\0';
44317 storeLastErrno(pNew, 0);
44320 if( h>=0 ) robust_close(pNew, h, __LINE__);
44323 pNew->ctrlFlags |= UNIXFILE_DELETE;
44327 if( h>=0 ) robust_close(pNew, h, __LINE__);
44331 verifyDbFile(pNew);
45584 unixFile *pNew;
45634 pNew = (unixFile *)sqlite3_malloc64(sizeof(*pNew));
45635 if( pNew==NULL ){
45639 memset(pNew, 0, sizeof(unixFile));
45640 pNew->openFlags = openFlags;
45646 pNew->pPreallocatedUnused = pUnused;
45648 rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
45650 *ppFile = pNew;
45654 robust_close(pNew, fd, __LINE__);
45655 sqlite3_free(pNew);
50576 winShmNode *pNew; /* Newly allocated winShmNode */
50587 pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 );
50588 if( pNew==0 ){
50592 pNew->zFilename = (char*)&pNew[1];
50593 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
50594 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
50604 if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
50607 sqlite3_free(pNew);
50612 pShmNode = pNew;
50613 pNew = 0;
50672 sqlite3_free(pNew);
51093 void *pNew = 0;
51127 pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap);
51129 pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
51131 if( pNew==NULL ){
51142 pFd->pMapRegion = pNew;
53140 unsigned char *pNew;
53149 pNew = sqlite3Realloc(p->aData, newSz);
53150 if( pNew==0 ) return SQLITE_IOERR_NOMEM;
53151 p->aData = pNew;
54580 sqlite3_pcache *pNew;
54581 pNew = sqlite3GlobalConfig.pcache2.xCreate(
54585 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
54586 sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
54590 pCache->pCache = pNew;
56629 struct RowSetChunk *pNew;
56630 pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
56631 if( pNew==0 ){
56634 pNew->pNextChunk = p->pChunk;
56635 p->pChunk = pNew;
56636 p->pFresh = pNew->aEntry;
60870 char *pNew = NULL; /* New temp space */
60879 pNew = (char *)sqlite3PageMalloc(pageSize+8);
60880 if( !pNew ){
60883 memset(pNew+pageSize, 0, 8);
60893 pPager->pTmpSpace = pNew;
60898 sqlite3PageFree(pNew);
69447 WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot;
69448 if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
69449 || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
78446 MemPage *pNew; /* Newly allocated page */
78462 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
78472 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
78474 zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
78481 rc = rebuildPage(&b, 0, 1, pNew);
78483 releasePage(pNew);
78486 pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
78499 if( szCell>pNew->minLocal ){
78500 ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);
78533 releasePage(pNew);
79101 MemPage *pNew;
79103 pNew = apNew[i] = apOld[i];
79105 rc = sqlite3PagerWrite(pNew->pDbPage);
79107 if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv))
79115 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
79117 zeroPage(pNew, pageFlags);
79118 apNew[i] = pNew;
79124 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
79218 MemPage *pNew = pOld = apNew[0];
79219 int cntOldNext = pNew->nCell + pNew->nOverflow;
79233 pNew = apNew[++iNew];
79244 || pNew->pgno!=aPgno[iOld]
79248 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
79250 if( cachedCellSize(&b,i)>pNew->minLocal ){
79251 ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
79264 MemPage *pNew = apNew[i];
79272 if( !pNew->leaf ){
79273 memcpy(&pNew->aData[8], pCell, 4);
79282 pNew->xParseCell(pNew, b.apCell[j], &info);
79313 rc = insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno);
80229 MemPage *pNew = 0;
80230 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
80236 pPageOut = pNew;
85002 VdbeOp *pNew;
85029 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
85030 if( pNew ){
85031 p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
85033 v->aOp = pNew;
85035 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
86038 ScanStatus *pNew = &aNew[p->nScan++];
86039 memset(pNew, 0, sizeof(ScanStatus));
86040 pNew->addrExplain = addrExplain;
86041 pNew->addrLoop = addrLoop;
86042 pNew->addrVisit = addrVisit;
86043 pNew->nEst = nEst;
86044 pNew->zName = sqlite3DbStrDup(p->db, zName);
90723 sqlite3_value *pNew;
90725 pNew = sqlite3_malloc( sizeof(*pNew) );
90726 if( pNew==0 ) return 0;
90727 memset(pNew, 0, sizeof(*pNew));
90728 memcpy(pNew, pOrig, MEMCELLSIZE);
90729 pNew->flags &= ~MEM_Dyn;
90730 pNew->db = 0;
90731 if( pNew->flags&(MEM_Str|MEM_Blob) ){
90732 pNew->flags &= ~(MEM_Static|MEM_Dyn);
90733 pNew->flags |= MEM_Ephem;
90734 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
90735 sqlite3ValueFree(pNew);
90736 pNew = 0;
90738 }else if( pNew->flags & MEM_Null ){
90740 pNew->flags &= ~(MEM_Term|MEM_Subtype);
90742 return pNew;
96852 Savepoint *pNew;
96892 pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
96893 if( pNew ){
96894 pNew->zName = (char *)&pNew[1];
96895 memcpy(pNew->zName, zName, nName+1);
96907 pNew->pNext = db->pSavepoint;
96908 db->pSavepoint = pNew;
96909 pNew->nDeferredCons = db->nDeferredCons;
96910 pNew->nDeferredImmCons = db->nDeferredImmCons;
103981 MergeEngine *pNew; /* Pointer to allocated object to return */
103988 pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
103989 if( pNew ){
103990 pNew->nTree = N;
103991 pNew->pTask = 0;
103992 pNew->aReadr = (PmaReader*)&pNew[1];
103993 pNew->aTree = (int*)&pNew->aReadr[N];
103995 return pNew;
104574 SorterRecord *pNew; /* New list element */
104655 pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
104658 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
104661 pNew = (SorterRecord *)sqlite3Malloc(nReq);
104662 if( pNew==0 ){
104665 pNew->u.pNext = pSorter->list.pList;
104668 memcpy(SRVAL(pNew), pVal->z, pVal->n);
104669 pNew->nVal = pVal->n;
104670 pSorter->list.pList = pNew;
105115 MergeEngine *pNew; /* Merge engine to return */
105120 *ppOut = pNew = vdbeMergeEngineNew(nPMA);
105121 if( pNew==0 ) rc = SQLITE_NOMEM_BKPT;
105125 PmaReader *pReadr = &pNew->aReadr[i];
105131 vdbeMergeEngineFree(pNew);
105190 MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT);
105191 if( pNew==0 ){
105194 rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
105627 bytecodevtab *pNew;
105663 pNew = sqlite3_malloc( sizeof(*pNew) );
105664 *ppVtab = (sqlite3_vtab*)pNew;
105665 if( pNew==0 ) return SQLITE_NOMEM;
105666 memset(pNew, 0, sizeof(*pNew));
105667 pNew->db = db;
105668 pNew->bTablesUsed = isTabUsed*2;
106249 FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
106250 if( !pNew ){
106253 pNew->pNext = 0;
106256 pChunk->pNext = pNew;
106259 p->pFirst = pNew;
106261 pChunk = p->endpoint.pChunk = pNew;
106938 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
106939 if( pNew ){
106940 pNew->iTable = pMatch->iCursor;
106941 pNew->iColumn = iColumn;
106942 pNew->y.pTab = pMatch->pTab;
106944 ExprSetProperty(pNew, EP_CanBeNull);
106945 *ppList = sqlite3ExprListAppend(pParse, *ppList, pNew);
108365 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
108366 if( pNew==0 ) return 1;
108367 pNew->flags |= EP_IntValue;
108368 pNew->u.iValue = iCol;
108370 pItem->pExpr = pNew;
108376 pParent->pLeft = pNew;
109189 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
109190 if( pNew ){
109191 pNew->pLeft = pExpr;
109192 pNew->flags |= EP_Collate|EP_Skip;
109193 pExpr = pNew;
109942 Expr *pNew;
109954 pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
109955 if( pNew ){
109956 memset(pNew, 0, sizeof(Expr));
109957 pNew->op = (u8)op;
109958 pNew->iAgg = -1;
109961 pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
109962 pNew->u.iValue = iValue;
109964 pNew->u.zToken = (char*)&pNew[1];
109966 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
109967 pNew->u.zToken[pToken->n] = 0;
109968 if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
109969 sqlite3DequoteExpr(pNew);
109974 pNew->nHeight = 1;
109977 return pNew;
110174 Expr *pNew;
110177 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
110178 if( pNew==0 ){
110182 assert( !ExprHasProperty(pNew, EP_InnerON|EP_OuterON) );
110183 pNew->w.iOfst = (int)(pToken->z - pParse->zTail);
110190 pNew->x.pList = pList;
110191 ExprSetProperty(pNew, EP_HasFunc);
110192 assert( ExprUseXList(pNew) );
110193 sqlite3ExprSetHeightAndFlags(pParse, pNew);
110194 if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct);
110195 return pNew;
110604 Expr *pNew; /* Value to return */
110642 pNew = (Expr *)sEdupBuf.zAlloc;
110643 assert( EIGHT_BYTE_ALIGNMENT(pNew) );
110645 if( pNew ){
110676 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
110677 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
110678 pNew->flags |= staticFlag;
110679 ExprClearVVAProperties(pNew);
110681 ExprSetVVAProperty(pNew, EP_Immutable);
110687 char *zToken = pNew->u.zToken = (char*)&sEdupBuf.zAlloc[nNewSize];
110693 if( ((p->flags|pNew->flags)&(EP_TokenOnly|EP_Leaf))==0 ){
110697 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags);
110699 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList,
110705 pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin);
110706 assert( ExprHasProperty(pNew, EP_WinFunc) );
110713 pNew->pLeft = p->pLeft;
110718 pNew->pLeft = p->pLeft ?
110721 pNew->pRight = p->pRight ?
110725 pNew->pLeft = p->pLeft;
110730 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
110732 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
110738 return pNew;
110824 ExprList *pNew;
110832 pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p));
110833 if( pNew==0 ) return 0;
110834 pNew->nExpr = p->nExpr;
110835 pNew->nAlloc = p->nAlloc;
110836 pItem = pNew->a;
110864 return pNew;
110876 SrcList *pNew;
110882 pNew = sqlite3DbMallocRawNN(db, nByte );
110883 if( pNew==0 ) return 0;
110884 pNew->nSrc = pNew->nAlloc = p->nSrc;
110886 SrcItem *pNewItem = &pNew->a[i];
110923 return pNew;
110926 IdList *pNew;
110931 pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew)+(p->nId-1)*sizeof(p->a[0]) );
110932 if( pNew==0 ) return 0;
110933 pNew->nId = p->nId;
110934 pNew->eU4 = p->eU4;
110936 struct IdList_item *pNewItem = &pNew->a[i];
110941 return pNew;
110951 Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) );
110952 if( pNew==0 ) break;
110953 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
110954 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
110955 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
110956 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
110957 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
110958 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
110959 pNew->op = p->op;
110960 pNew->pNext = pNext;
110961 pNew->pPrior = 0;
110962 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
110963 pNew->iLimit = 0;
110964 pNew->iOffset = 0;
110965 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
110966 pNew->addrOpenEphm[0] = -1;
110967 pNew->addrOpenEphm[1] = -1;
110968 pNew->nSelectRow = p->nSelectRow;
110969 pNew->pWith = sqlite3WithDup(db, p->pWith);
110971 pNew->pWin = 0;
110972 pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
110973 if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
110975 pNew->selId = p->selId;
110980 pNew->pNext = 0;
110981 sqlite3SelectDelete(db, pNew);
110984 *pp = pNew;
110985 pp = &pNew->pPrior;
110986 pNext = pNew;
111036 ExprList *pNew;
111038 pNew = sqlite3DbRealloc(db, pList,
111040 if( pNew==0 ){
111045 pList = pNew;
116456 Table *pNew; /* Copy of pParse->pNewTable */
116472 pNew = pParse->pNewTable;
116473 assert( pNew );
116476 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
116478 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
116479 pCol = &pNew->aCol[pNew->nCol-1];
116480 pDflt = sqlite3ColumnExpr(pNew, pCol);
116500 if( pNew->pIndex ){
116514 assert( IsOrdinaryTable(pNew) );
116515 if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){
116558 assert( IsOrdinaryTable(pNew) );
116564 zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset,
116589 if( pNew->pCheck!=0
116626 Table *pNew;
116668 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
116669 if( !pNew ) goto exit_begin_add_column;
116670 pParse->pNewTable = pNew;
116671 pNew->nTabRef = 1;
116672 pNew->nCol = pTab->nCol;
116673 assert( pNew->nCol>0 );
116674 nAlloc = (((pNew->nCol-1)/8)*8)+8;
116675 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
116676 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
116677 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
116678 if( !pNew->aCol || !pNew->zName ){
116682 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
116683 for(i=0; i<pNew->nCol; i++){
116684 Column *pCol = &pNew->aCol[i];
116688 assert( IsOrdinaryTable(pNew) );
116689 pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
116690 pNew->pSchema = db->aDb[iDb].pSchema;
116691 pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
116692 assert( pNew->nTabRef==1 );
116742 Token *pNew /* New column name */
116794 zNew = sqlite3NameFromToken(db, pNew);
116796 assert( pNew->n>0 );
116797 bQuote = sqlite3Isquote(pNew->z[0]);
116922 RenameToken *pNew;
116926 pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
116927 if( pNew ){
116928 pNew->p = pPtr;
116929 pNew->t = *pToken;
116930 pNew->pNext = pParse->pRename;
116931 pParse->pRename = pNew;
117450 Trigger *pNew = pParse->pNewTrigger;
117457 assert( pNew->pTabSchema );
117458 pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
117459 db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName
117461 pParse->eTriggerOp = pNew->op;
117469 if( rc==SQLITE_OK && pNew->pWhen ){
117470 rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen);
117473 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
118968 StatSample *pNew,
118973 assert( pNew->iCol==pOld->iCol );
118974 for(i=pNew->iCol+1; i<nCol; i++){
118975 if( pNew->anEq[i]>pOld->anEq[i] ) return 1;
118976 if( pNew->anEq[i]<pOld->anEq[i] ) return 0;
118978 if( pNew->iHash>pOld->iHash ) return 1;
118992 StatSample *pNew,
118995 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
118998 assert( pOld->isPSample==0 && pNew->isPSample==0 );
118999 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
119003 if( pNew->iCol<pOld->iCol ) return 1;
119004 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
119013 static void sampleInsert(StatAccum *p, StatSample *pNew, int nEqZero){
119026 if( pNew->isPSample==0 ){
119028 assert( pNew->anEq[pNew->iCol]>0 );
119037 if( pOld->anEq[pNew->iCol]==0 ){
119039 assert( pOld->iCol>pNew->iCol );
119040 assert( sampleIsBetter(p, pNew, pOld) );
119047 pUpgrade->iCol = pNew->iCol;
119048 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
119073 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
119077 sampleCopy(p, pSample, pNew);
120564 Db *pNew = 0; /* Db object for the newly attached database */
120594 pNew = &db->aDb[db->init.iDb];
120595 if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt);
120596 pNew->pBt = pNewBt;
120597 pNew->pSchema = pNewSchema;
120639 pNew = &db->aDb[db->nDb];
120640 memset(pNew, 0, sizeof(*pNew));
120656 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
120658 pNew->zDbSName = sqlite3DbStrDup(db, zName);
120666 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
120667 if( !pNew->pSchema ){
120669 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
120674 sqlite3BtreeEnter(pNew->pBt);
120675 pPager = sqlite3BtreePager(pNew->pBt);
120677 sqlite3BtreeSecureDelete(pNew->pBt,
120680 sqlite3BtreeSetPagerFlags(pNew->pBt,
120683 sqlite3BtreeLeave(pNew->pBt);
120685 pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
120686 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
126038 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
126039 if( pNew==0 ){
126043 pArray = pNew;
126064 IdList *pNew;
126065 pNew = sqlite3DbRealloc(db, pList,
126067 if( pNew==0 ){
126071 pList = pNew;
126156 SrcList *pNew;
126166 pNew = sqlite3DbRealloc(db, pSrc,
126168 if( pNew==0 ){
126172 pSrc = pNew;
126249 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
126250 if( pNew==0 ){
126254 pList = pNew;
126421 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
126422 if( pNew==0 ){
126425 p1 = pNew;
126968 Cte *pNew;
126971 pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
126972 assert( pNew!=0 || db->mallocFailed );
126978 pNew->pSelect = pQuery;
126979 pNew->pCols = pArglist;
126980 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
126981 pNew->eM10d = eM10d;
126983 return pNew;
127018 With *pNew;
127039 pNew = sqlite3DbRealloc(db, pWith, nByte);
127041 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
127043 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
127047 pNew = pWith;
127049 pNew->a[pNew->nCte++] = *pCte;
127053 return pNew;
132702 Expr *pNew;
132704 pNew = sqlite3PExpr(pParse, TK_DOT,
132718 pNew = sqlite3ExprDup(db, pDflt, 0);
132720 pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
132723 pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
132725 pList = sqlite3ExprListAppend(pParse, pList, pNew);
142695 sqlite3_stmt *pNew;
142706 rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
142711 assert( pNew==0 );
142714 assert( pNew!=0 );
142716 sqlite3VdbeSwap((Vdbe*)pNew, p);
142717 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
142718 sqlite3VdbeResetStepResult((Vdbe*)pNew);
142719 sqlite3VdbeFinalize((Vdbe*)pNew);
143028 Select *pNew, *pAllocated;
143030 pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
143031 if( pNew==0 ){
143033 pNew = &standin;
143039 pNew->pEList = pEList;
143040 pNew->op = TK_SELECT;
143041 pNew->selFlags = selFlags;
143042 pNew->iLimit = 0;
143043 pNew->iOffset = 0;
143044 pNew->selId = ++pParse->nSelect;
143045 pNew->addrOpenEphm[0] = -1;
143046 pNew->addrOpenEphm[1] = -1;
143047 pNew->nSelectRow = 0;
143049 pNew->pSrc = pSrc;
143050 pNew->pWhere = pWhere;
143051 pNew->pGroupBy = pGroupBy;
143052 pNew->pHaving = pHaving;
143053 pNew->pOrderBy = pOrderBy;
143054 pNew->pPrior = 0;
143055 pNew->pNext = 0;
143056 pNew->pLimit = pLimit;
143057 pNew->pWith = 0;
143059 pNew->pWin = 0;
143060 pNew->pWinDefn = 0;
143063 clearSelect(pParse->db, pNew, pNew!=&standin);
143066 assert( pNew->pSrc!=0 || pParse->nErr>0 );
143962 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
143963 if( pNew ){
143964 pNew->iTable = pExpr->iTable;
143965 assert( ExprUseYTab(pNew) );
143966 pNew->y.pTab = pExpr->y.pTab;
143967 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
143968 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
146427 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
146428 if( pNew==0 ) return SQLITE_NOMEM_BKPT;
146429 pNew->flags |= EP_IntValue;
146430 pNew->u.iValue = i;
146431 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
146755 Expr *pNew;
146780 pNew = sqlite3ExprDup(db, pCopy, 0);
146782 sqlite3ExprDelete(db, pNew);
146786 ExprSetProperty(pNew, EP_CanBeNull);
146789 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
146793 pExpr = pNew;
147432 Select *pNew;
147441 pNew = sqlite3SelectDup(db, p, 0);
147446 if( pNew==0 ){
147449 pNew->selId = ++pParse->nSelect;
147451 renumberCursors(pParse, pNew, iFrom, aCsrMap);
147453 pNew->pPrior = pPrior;
147454 if( pPrior ) pPrior->pNext = pNew;
147455 pNew->pNext = p;
147456 p->pPrior = pNew;
147458 " creates %u as peer\n",pNew->selId));
148058 Expr *pNew;
148175 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
148176 unsetJoinExpr(pNew, -1, 1);
148183 pNew = substExpr(&x, pNew);
148185 if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){
148187 sqlite3ExprDelete(pParse->db, pNew);
148193 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
148195 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
148430 Select *pNew;
148460 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
148461 if( pNew==0 ) return WRC_Abort;
148463 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0);
148465 *pNew = *p;
148470 pNew->pGroupBy = 0;
148471 pNew->pHaving = 0;
148472 pNew->pOrderBy = 0;
148482 assert( pNew->pPrior!=0 );
148483 pNew->pPrior->pNext = pNew;
148484 pNew->pLimit = 0;
149014 ExprList *pNew = 0;
149029 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
149030 if( pNew ){
149031 pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
149032 pNew->a[pNew->nExpr-1].fg.eEName = a[k].fg.eEName;
149091 pNew = sqlite3ExprListAppend(pParse, pNew, pRight);
149092 if( pNew ){
149093 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
149180 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
149181 if( pNew==0 ){
149184 pX = &pNew->a[pNew->nExpr-1];
149223 p->pEList = pNew;
149904 Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
149905 if( pNew ){
149907 SWAP(Expr, *pNew, *pExpr);
149908 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
149909 pS->pWhere = pNew;
152633 ExprList *pNew = 0;
152646 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
152648 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
152655 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
152657 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
152663 return pNew;
152745 ExprList *pNew;
152776 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
152781 pReturning->nRetCol = pNew->nExpr;
152789 if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK
152793 int nCol = pNew->nExpr;
152795 sqlite3ProcessReturningSubqueries(pNew, pTab);
152799 Expr *pCol = pNew->a[i].pExpr;
152811 sqlite3ExprListDelete(db, pNew);
153507 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
153510 pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
153513 pList = sqlite3ExprListAppend(pParse, pList, pNew);
154707 Upsert *pNew;
154708 pNew = sqlite3DbMallocZero(db, sizeof(Upsert));
154709 if( pNew==0 ){
154717 pNew->pUpsertTarget = pTarget;
154718 pNew->pUpsertTargetWhere = pTargetWhere;
154719 pNew->pUpsertSet = pSet;
154720 pNew->pUpsertWhere = pWhere;
154721 pNew->isDoUpdate = pSet!=0;
154722 pNew->pNextUpsert = pNext;
154724 return pNew;
156259 Table *pNew = sParse.pNewTable;
156261 pTab->aCol = pNew->aCol;
156262 sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
156263 pTab->nNVCol = pTab->nCol = pNew->nCol;
156264 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
156265 pNew->nCol = 0;
156266 pNew->aCol = 0;
156268 assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
156269 if( !HasRowid(pNew)
156271 && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
156277 pIdx = pNew->pIndex;
156281 pNew->pIndex = 0;
156552 FuncDef *pNew;
156591 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
156593 if( pNew==0 ){
156596 *pNew = *pDef;
156597 pNew->zName = (const char*)&pNew[1];
156598 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
156599 pNew->xSFunc = xSFunc;
156600 pNew->pUserData = pArg;
156601 pNew->funcFlags |= SQLITE_FUNC_EPHEM;
156602 return pNew;
157205 WhereLoop *pNew; /* Template WhereLoop */
157912 Expr *pNew;
157913 pNew = sqlite3ExprDup(db, pX, 0);
157915 for(pSelect=pNew->x.pSelect; pSelect; pSelect=pSelect->pPrior){
157922 assert( ExprUseXSelect(pNew) );
157924 assert( pNew->pLeft!=0 );
157925 assert( ExprUseXList(pNew->pLeft) );
157926 if( pSelect==pNew->x.pSelect ){
157927 pOrigLhs = pNew->pLeft->x.pList;
157947 pNew->pLeft->x.pList = pLhs;
157956 sqlite3ExprDelete(db, pNew->pLeft);
157957 pNew->pLeft = p;
157977 sqlite3TreeViewExpr(0, pNew, 0);
157981 return pNew;
160761 Expr *pNew; /* New virtual expression */
160784 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
160785 if( pNew==0 ) return;
160787 pNew->op = op;
160788 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
161106 Expr *pNew; /* The complete IN operator */
161120 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0);
161121 if( pNew ){
161123 transferJoinMarkings(pNew, pExpr);
161124 assert( ExprUseXList(pNew) );
161125 pNew->x.pList = pList;
161126 idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
161414 WhereTerm *pNew;
161427 pNew = &pWC->a[idxNew];
161429 if( op==TK_IS ) pNew->wtFlags |= TERM_IS;
161439 pNew = pTerm;
161441 pNew->wtFlags |= exprCommute(pParse, pDup);
161442 pNew->leftCursor = aiCurCol[0];
161444 pNew->u.x.leftColumn = aiCurCol[1];
161446 pNew->prereqRight = prereqLeft | extraRight;
161447 pNew->prereqAll = prereqAll;
161448 pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
161659 Expr *pNew;
161663 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
161664 transferJoinMarkings(pNew, pExpr);
161665 idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_SLICE);
161811 Expr *pNew;
161819 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
161824 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
161826 if( pNew ){
161829 idx = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_VIRTUAL);
162387 void *pNew = sqlite3WhereMalloc(pWInfo, nByte);
162388 if( pNew && pOld ){
162392 memcpy(pNew, pOld, pOldBlk->sz);
162394 return pNew;
164265 Index *p = pBuilder->pNew->u.btree.pIndex;
164266 int nEq = pBuilder->pNew->u.btree.nEq;
164329 Index *p = pBuilder->pNew->u.btree.pIndex;
165111 WhereLoop *pNew; /* Template WhereLoop under construction */
165128 pNew = pBuilder->pNew;
165135 pNew->u.btree.nEq, pNew->nSkip, pNew->rRun));
165137 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
165138 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
165139 if( pNew->wsFlags & WHERE_BTM_LIMIT ){
165142 assert( pNew->u.btree.nBtm==0 );
165152 assert( pNew->u.btree.nEq<pProbe->nColumn );
165153 assert( pNew->u.btree.nEq<pProbe->nKeyCol
165156 saved_nEq = pNew->u.btree.nEq;
165157 saved_nBtm = pNew->u.btree.nBtm;
165158 saved_nTop = pNew->u.btree.nTop;
165159 saved_nSkip = pNew->nSkip;
165160 saved_nLTerm = pNew->nLTerm;
165161 saved_wsFlags = pNew->wsFlags;
165162 saved_prereq = pNew->prereq;
165163 saved_nOut = pNew->nOut;
165166 pNew->rSetup = 0;
165182 if( pTerm->prereqRight & pNew->maskSelf ) continue;
165198 pNew->wsFlags = saved_wsFlags;
165199 pNew->u.btree.nEq = saved_nEq;
165200 pNew->u.btree.nBtm = saved_nBtm;
165201 pNew->u.btree.nTop = saved_nTop;
165202 pNew->nLTerm = saved_nLTerm;
165203 if( pNew->nLTerm>=pNew->nLSlot
165204 && whereLoopResize(db, pNew, pNew->nLTerm+1)
165208 pNew->aLTerm[pNew->nLTerm++] = pTerm;
165209 pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
165212 || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0
165213 || (pNew->wsFlags & WHERE_COLUMN_IN)!=0
165214 || (pNew->wsFlags & WHERE_SKIPSCAN)!=0
165229 for(i=0; i<pNew->nLTerm-1; i++){
165230 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
165272 pNew->wsFlags |= WHERE_IN_SEEKSCAN;
165281 pNew->wsFlags |= WHERE_COLUMN_IN;
165284 pNew->wsFlags |= WHERE_COLUMN_EQ;
165285 assert( saved_nEq==pNew->u.btree.nEq );
165292 pNew->wsFlags |= WHERE_ONEROW;
165294 pNew->wsFlags |= WHERE_UNQ_WANTED;
165297 if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS;
165299 pNew->wsFlags |= WHERE_COLUMN_NULL;
165307 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
165308 pNew->u.btree.nBtm = nVecLen;
165318 if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
165319 pNew->aLTerm[pNew->nLTerm++] = pTop;
165320 pNew->wsFlags |= WHERE_TOP_LIMIT;
165321 pNew->u.btree.nTop = 1;
165327 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT;
165328 pNew->u.btree.nTop = nVecLen;
165330 pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ?
165331 pNew->aLTerm[pNew->nLTerm-2] : 0;
165340 assert( pNew->nOut==saved_nOut );
165341 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
165344 whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew);
165346 int nEq = ++pNew->u.btree.nEq;
165349 assert( pNew->nOut==saved_nOut );
165353 pNew->nOut += pTerm->truthProb;
165354 pNew->nOut -= nIn;
165360 && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
165376 pNew->nOut = sqlite3LogEst(nOut);
165381 && pNew->nOut+10 > pProbe->aiRowLogEst[0]
165398 if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut;
165399 pNew->nOut -= nIn;
165405 pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]);
165410 pNew->nOut += 10;
165429 rCostIdx = pNew->nOut + 16;
165431 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
165441 pNew->rRun = rCostIdx;
165442 if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){
165443 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
165445 ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult);
165447 nOutUnadjusted = pNew->nOut;
165448 pNew->rRun += nInMul + nIn;
165449 pNew->nOut += nInMul + nIn;
165450 whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize);
165451 rc = whereLoopInsert(pBuilder, pNew);
165453 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
165454 pNew->nOut = saved_nOut;
165456 pNew->nOut = nOutUnadjusted;
165459 if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
165460 && pNew->u.btree.nEq<pProbe->nColumn
165461 && (pNew->u.btree.nEq<pProbe->nKeyCol ||
165464 if( pNew->u.btree.nEq>3 ){
165469 pNew->nOut = saved_nOut;
165474 pNew->prereq = saved_prereq;
165475 pNew->u.btree.nEq = saved_nEq;
165476 pNew->u.btree.nBtm = saved_nBtm;
165477 pNew->u.btree.nTop = saved_nTop;
165478 pNew->nSkip = saved_nSkip;
165479 pNew->wsFlags = saved_wsFlags;
165480 pNew->nOut = saved_nOut;
165481 pNew->nLTerm = saved_nLTerm;
165496 && saved_nEq==pNew->nLTerm
165501 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
165504 pNew->u.btree.nEq++;
165505 pNew->nSkip++;
165506 pNew->aLTerm[pNew->nLTerm++] = 0;
165507 pNew->wsFlags |= WHERE_SKIPSCAN;
165509 pNew->nOut -= nIter;
165514 pNew->nOut = saved_nOut;
165515 pNew->u.btree.nEq = saved_nEq;
165516 pNew->nSkip = saved_nSkip;
165517 pNew->wsFlags = saved_wsFlags;
165884 WhereLoop *pNew; /* Template WhereLoop object */
165892 pNew = pBuilder->pNew;
165895 pSrc = pTabList->a + pNew->iTab;
165951 if( pTerm->prereqRight & pNew->maskSelf ) continue;
165953 pNew->u.btree.nEq = 1;
165954 pNew->nSkip = 0;
165955 pNew->u.btree.pIndex = 0;
165956 pNew->nLTerm = 1;
165957 pNew->aLTerm[0] = pTerm;
165966 pNew->rSetup = rLogSize + rSize;
165968 pNew->rSetup += 28;
165970 pNew->rSetup -= 25; /* Greatly reduced setup cost for auto indexes
165973 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
165974 if( pNew->rSetup<0 ) pNew->rSetup = 0;
165979 pNew->nOut = 43; assert( 43==sqlite3LogEst(20) );
165980 pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut);
165981 pNew->wsFlags = WHERE_AUTO_INDEX;
165982 pNew->prereq = mPrereq | pTerm->prereqRight;
165983 rc = whereLoopInsert(pBuilder, pNew);
165998 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
166003 pNew->u.btree.nEq = 0;
166004 pNew->u.btree.nBtm = 0;
166005 pNew->u.btree.nTop = 0;
166006 pNew->nSkip = 0;
166007 pNew->nLTerm = 0;
166008 pNew->iSortIdx = 0;
166009 pNew->rSetup = 0;
166010 pNew->prereq = mPrereq;
166011 pNew->nOut = rSize;
166012 pNew->u.btree.pIndex = pProbe;
166019 pNew->wsFlags = WHERE_IPK;
166022 pNew->iSortIdx = b ? iSortIdx : 0;
166036 pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0);
166038 pNew->rRun = rSize + 16;
166040 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166041 whereLoopOutputAdjust(pWC, pNew, rSize);
166042 rc = whereLoopInsert(pBuilder, pNew);
166043 pNew->nOut = rSize;
166049 pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
166057 pNew->wsFlags = WHERE_INDEXED;
166067 pNew->wsFlags |= isCov;
166085 pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
166102 pNew->iSortIdx = b ? iSortIdx : 0;
166107 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
166133 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup);
166135 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166136 whereLoopOutputAdjust(pWC, pNew, rSize);
166143 rc = whereLoopInsert(pBuilder, pNew);
166145 pNew->nOut = rSize;
166231 WhereLoop *pNew = pBuilder->pNew;
166233 SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
166238 pNew->prereq = mPrereq;
166281 assert( pNew->nLSlot>=nConstraint );
166282 memset(pNew->aLTerm, 0, sizeof(pNew->aLTerm[0])*nConstraint );
166283 memset(&pNew->u.vtab, 0, sizeof(pNew->u.vtab));
166293 || pNew->aLTerm[iTerm]!=0
166304 pNew->prereq |= pTerm->prereqRight;
166305 assert( iTerm<pNew->nLSlot );
166306 pNew->aLTerm[iTerm] = pTerm;
166313 pNew->u.vtab.omitMask |= 1<<iTerm;
166318 pNew->u.vtab.bOmitOffset = 1;
166322 pNew->u.vtab.mHandleIn |= MASKBIT32(iTerm);
166359 pNew->nLTerm = mxTerm+1;
166361 if( pNew->aLTerm[i]==0 ){
166369 assert( pNew->nLTerm<=pNew->nLSlot );
166370 pNew->u.vtab.idxNum = pIdxInfo->idxNum;
166371 pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
166373 pNew->u.vtab.idxStr = pIdxInfo->idxStr;
166374 pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
166376 pNew->rSetup = 0;
166377 pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
166378 pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
166383 pNew->wsFlags |= WHERE_ONEROW;
166385 pNew->wsFlags &= ~WHERE_ONEROW;
166387 rc = whereLoopInsert(pBuilder, pNew);
166388 if( pNew->u.vtab.needFree ){
166389 sqlite3_free(pNew->u.vtab.idxStr);
166390 pNew->u.vtab.needFree = 0;
166394 (sqlite3_uint64)(pNew->prereq & ~mPrereq)));
166553 WhereLoop *pNew;
166562 pNew = pBuilder->pNew;
166563 pSrc = &pWInfo->pTabList->a[pNew->iTab];
166567 pNew->rSetup = 0;
166568 pNew->wsFlags = WHERE_VIRTUALTABLE;
166569 pNew->nLTerm = 0;
166570 pNew->u.vtab.needFree = 0;
166572 if( whereLoopResize(pParse->db, pNew, nConstraint) ){
166595 if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
166608 mBestNoIn = pNew->prereq & ~mPrereq;
166634 if( pNew->prereq==mPrereq ){
166678 WhereLoop *pNew;
166689 pNew = pBuilder->pNew;
166691 pItem = pWInfo->pTabList->a + pNew->iTab;
166699 && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
166765 pNew->nLTerm = 1;
166766 pNew->aLTerm[0] = pTerm;
166767 pNew->wsFlags = WHERE_MULTI_OR;
166768 pNew->rSetup = 0;
166769 pNew->iSortIdx = 0;
166770 memset(&pNew->u, 0, sizeof(pNew->u));
166784 pNew->rRun = sSum.a[i].rRun + 1;
166785 pNew->nOut = sSum.a[i].nOut;
166786 pNew->prereq = sSum.a[i].prereq;
166787 rc = whereLoopInsert(pBuilder, pNew);
166810 WhereLoop *pNew;
166814 pNew = pBuilder->pNew;
166817 assert( pNew->nLTerm==0 );
166818 assert( pNew->wsFlags==0 );
166819 assert( pNew->nLSlot>=ArraySize(pNew->aLTermSpace) );
166820 assert( pNew->aLTerm!=0 );
166825 pNew->iTab = iTab;
166827 pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
166864 mPrior |= pNew->maskSelf;
166876 whereLoopClear(db, pNew);
167838 pLoop = pBuilder->pNew;
168448 sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo);
168449 assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) );
168450 whereLoopInit(sWLB.pNew);
168452 sWLB.pNew->cId = '*';
171726 Window *pNew = 0;
171728 pNew = sqlite3DbMallocZero(db, sizeof(Window));
171729 if( pNew ){
171730 pNew->zName = sqlite3DbStrDup(db, p->zName);
171731 pNew->zBase = sqlite3DbStrDup(db, p->zBase);
171732 pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
171733 pNew->pWFunc = p->pWFunc;
171734 pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
171735 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
171736 pNew->eFrmType = p->eFrmType;
171737 pNew->eEnd = p->eEnd;
171738 pNew->eStart = p->eStart;
171739 pNew->eExclude = p->eExclude;
171740 pNew->regResult = p->regResult;
171741 pNew->regAccum = p->regAccum;
171742 pNew->iArgCol = p->iArgCol;
171743 pNew->iEphCsr = p->iEphCsr;
171744 pNew->bExprArgs = p->bExprArgs;
171745 pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
171746 pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
171747 pNew->pOwner = pOwner;
171748 pNew->bImplicitFrame = p->bImplicitFrame;
171751 return pNew;
174742 yyStackEntry *pNew;
174747 pNew = YYREALLOC(0, newSize*sizeof(pNew[0]));
174748 if( pNew==0 ) return 1;
174749 memcpy(pNew, p->yystack, oldSize*sizeof(pNew[0]));
174751 pNew = YYREALLOC(p->yystack, newSize*sizeof(pNew[0]));
174752 if( pNew==0 ) return 1;
174754 p->yystack = pNew;
176575 SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
176577 pNew->zName = pOld->zName;
176578 pNew->zDatabase = pOld->zDatabase;
176579 pNew->pSelect = pOld->pSelect;
176580 if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){
176581 pNew->fg.isNestedFrom = 1;
176584 pNew->u1.pFuncArg = pOld->u1.pFuncArg;
176587 pNew->fg.isTabFunc = 1;
185132 void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
185133 if( pNew ){
185134 memcpy(pNew, aArg, nArg*sizeof(void *));
185136 aDyn = aArg = pNew;
185784 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
189094 Fts3SegReader *pNew
189101 sqlite3Fts3SegReaderFree(pNew);
189106 pCsr->apSegment[pCsr->nSegment++] = pNew;
193486 Fts3Expr *pNew /* New binary node to insert into expression tree */
193489 while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
193495 pSplit->pParent->pRight = pNew;
193496 pNew->pParent = pSplit->pParent;
193498 *ppHead = pNew;
193500 pNew->pLeft = pSplit;
193501 pSplit->pParent = pNew;
194257 SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
194258 assert( pNew!=0 );
194260 pNew->keyClass = keyClass;
194261 pNew->copyKey = copyKey;
194262 pNew->first = 0;
194263 pNew->count = 0;
194264 pNew->htsize = 0;
194265 pNew->ht = 0;
194367 Fts3HashElem *pNew /* The element to be inserted */
194372 pNew->next = pHead;
194373 pNew->prev = pHead->prev;
194374 if( pHead->prev ){ pHead->prev->next = pNew; }
194375 else { pH->first = pNew; }
194376 pHead->prev = pNew;
194378 pNew->next = pH->first;
194379 if( pH->first ){ pH->first->prev = pNew; }
194380 pNew->prev = 0;
194381 pH->first = pNew;
194384 pEntry->chain = pNew;
195206 char *pNew;
195208 pNew = sqlite3_realloc64(c->zToken, c->nAllocated);
195209 if( !pNew ) return SQLITE_NOMEM;
195210 c->zToken = pNew;
195958 char *pNew;
195960 pNew = sqlite3_realloc64(c->pToken, c->nTokenAllocated);
195961 if( !pNew ) return SQLITE_NOMEM;
195962 c->pToken = pNew;
198503 SegmentNode *pNew;
198578 pNew = (SegmentNode *)sqlite3_malloc64(sizeof(SegmentNode) + p->nNodeSize);
198579 if( !pNew ){
198582 memset(pNew, 0, sizeof(SegmentNode));
198583 pNew->nData = 1 + FTS3_VARINT_MAX;
198584 pNew->aData = (char *)&pNew[1];
198592 pTree->pRight = pNew;
198593 pNew->pLeftmost = pTree->pLeftmost;
198594 pNew->pParent = pParent;
198595 pNew->zMalloc = pTree->zMalloc;
198596 pNew->nMalloc = pTree->nMalloc;
198599 pNew->pLeftmost = pNew;
198600 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
198603 *ppTree = pNew;
199142 char *pNew;
199144 pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, nNew);
199145 if( !pNew ) return SQLITE_NOMEM;
199146 pMsr->aBuffer = pNew;
201093 Blob *pNew, /* OUT: Write new node image here */
201107 blobGrowBuffer(pNew, nNode, &rc);
201109 pNew->n = 0;
201116 if( pNew->n==0 ){
201119 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
201123 pNew, &prev, reader.term.a, reader.term.n,
201128 if( pNew->n==0 ){
201129 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
201132 assert( pNew->n<=pNew->nAlloc );
204289 unicode_tokenizer *pNew; /* New tokenizer object */
204293 pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer));
204294 if( pNew==NULL ) return SQLITE_NOMEM;
204295 memset(pNew, 0, sizeof(unicode_tokenizer));
204296 pNew->eRemoveDiacritic = 1;
204303 pNew->eRemoveDiacritic = 1;
204306 pNew->eRemoveDiacritic = 0;
204309 pNew->eRemoveDiacritic = 2;
204312 rc = unicodeAddExceptions(pNew, 1, &z[11], n-11);
204315 rc = unicodeAddExceptions(pNew, 0, &z[11], n-11);
204324 unicodeDestroy((sqlite3_tokenizer *)pNew);
204325 pNew = 0;
204327 *pp = (sqlite3_tokenizer *)pNew;
209660 JsonEachConnection *pNew;
209686 pNew = (JsonEachConnection*)sqlite3DbMallocZero(db, sizeof(*pNew));
209687 *ppVtab = (sqlite3_vtab*)pNew;
209688 if( pNew==0 ) return SQLITE_NOMEM;
209690 pNew->db = db;
209819 JsonParent *pNew;
209822 pNew = sqlite3DbRealloc(p->db, p->aParent, sizeof(JsonParent)*nNew);
209823 if( pNew==0 ) return SQLITE_NOMEM;
209825 p->aParent = pNew;
211787 RtreeSearchPoint *pNew;
211790 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
211791 if( pNew==0 ) return 0;
211792 pCur->aPoint = pNew;
211796 pNew = pCur->aPoint + i;
211797 pNew->rScore = rScore;
211798 pNew->iLevel = iLevel;
211804 if( rtreeSearchPointCompare(pNew, pParent)>=0 ) break;
211807 pNew = pParent;
211809 return pNew;
211821 RtreeSearchPoint *pNew, *pFirst;
211830 pNew = rtreeEnqueue(pCur, rScore, iLevel);
211831 if( pNew==0 ) return 0;
211832 ii = (int)(pNew - pCur->aPoint) + 1;
211841 *pNew = pCur->sPoint;
212273 RtreeSearchPoint *pNew;
212275 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
212276 if( NEVER(pNew==0) ){ /* Because pCsr->bPoint was FALSE */
212279 pNew->id = 1;
212280 pNew->iCell = 0;
212281 pNew->eWithin = PARTLY_WITHIN;
216060 RtreeSearchPoint *pNew;
216061 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
216062 if( pNew==0 ){
216066 pNew->id = 1;
216067 pNew->iCell = 0;
216068 pNew->eWithin = PARTLY_WITHIN;
223112 char *pNew = (char*)sqlite3_malloc64(szRegion);
223113 if( pNew==0 ){
223116 memset(pNew, 0, szRegion);
223117 p->apShm[iRegion] = pNew;
223476 rbu_vfs *pNew = 0; /* Newly allocated VFS */
223483 pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
223484 if( pNew==0 ){
223488 memset(pNew, 0, nByte);
223494 memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
223495 pNew->base.mxPathname = pParent->mxPathname;
223496 pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
223497 pNew->pRealVfs = pParent;
223498 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
223502 pNew->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
223503 if( pNew->mutex==0 ){
223506 rc = sqlite3_vfs_register(&pNew->base, 0);
223511 sqlite3_mutex_free(pNew->mutex);
223512 sqlite3_free(pNew);
226175 SessionChange *pNew = 0;
226197 pNew = sessionMalloc64(pSession, nByte);
226198 if( pNew==0 ){
226202 memcpy(pNew, pOld, sizeof(SessionChange));
226203 pNew->aRecord = (u8*)&pNew[1];
226204 memcpy(pNew->aRecord, pOld->aRecord, pOld->nRecord);
226205 pNew->aRecord[pNew->nRecord++] = (u8)eType;
226209 sessionPutI64(&pNew->aRecord[pNew->nRecord], iVal);
226210 pNew->nRecord += 8;
226218 sessionPutI64(&pNew->aRecord[pNew->nRecord], iVal);
226219 pNew->nRecord += 8;
226226 pNew->nRecord += sessionVarintPut(&pNew->aRecord[pNew->nRecord], n);
226227 memcpy(&pNew->aRecord[pNew->nRecord], z, n);
226228 pNew->nRecord += n;
226235 pNew->nRecord += sessionVarintPut(&pNew->aRecord[pNew->nRecord], n);
226236 memcpy(&pNew->aRecord[pNew->nRecord], z, n);
226237 pNew->nRecord += n;
226247 *pp = pOld = pNew;
226248 pNew->nRecordField++;
226249 pNew->nMaxSize += nIncr;
227155 sqlite3_session *pNew; /* Newly allocated session object */
227163 pNew = (sqlite3_session *)sqlite3_malloc64(sizeof(sqlite3_session) + nDb + 1);
227164 if( !pNew ) return SQLITE_NOMEM;
227165 memset(pNew, 0, sizeof(sqlite3_session));
227166 pNew->db = db;
227167 pNew->zDb = (char *)&pNew[1];
227168 pNew->bEnable = 1;
227169 memcpy(pNew->zDb, zDb, nDb+1);
227170 sessionPreupdateHooks(pNew);
227176 pOld = (sqlite3_session*)sqlite3_preupdate_hook(db, xPreUpdate, (void*)pNew);
227177 pNew->pNext = pOld;
227180 *ppSession = pNew;
229805 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
229809 if( rc==SQLITE_OK && pNew ){
229810 rc = sessionBindValue(pUp, i*2+1, pNew);
230337 SessionChange *pNew = 0;
230342 pNew = (SessionChange *)sqlite3_malloc64(sizeof(SessionChange) + nRec);
230343 if( !pNew ){
230346 memset(pNew, 0, sizeof(SessionChange));
230347 pNew->op = op2;
230348 pNew->bIndirect = bIndirect;
230349 pNew->aRecord = (u8*)&pNew[1];
230351 pNew->nRecord = nRec;
230352 memcpy(pNew->aRecord, aRec, nRec);
230356 u8 *pOut = pNew->aRecord;
230369 pNew->nRecord = pOut - pNew->aRecord;
230376 pNew = (SessionChange*)sqlite3_malloc64(nByte);
230377 if( pNew==0 ){
230385 memset(pNew, 0, nByte);
230386 pNew->bIndirect = bIndirect || pExist->bIndirect;
230387 pNew->op = op2;
230388 pOut = pNew->aRecord = (u8*)&pNew[1];
230405 pNew->nRecord = pOut - pNew->aRecord;
230430 pNew = pExist;
230433 assert( pNew==0 );
230443 pNew = (SessionChange *)sqlite3_malloc64(nByte);
230444 if( !pNew ){
230448 memset(pNew, 0, sizeof(SessionChange));
230449 pNew->bIndirect = (bIndirect && pExist->bIndirect);
230450 aCsr = pNew->aRecord = (u8 *)&pNew[1];
230455 pNew->op = SQLITE_INSERT;
230460 pNew->op = SQLITE_UPDATE;
230466 sqlite3_free(pNew);
230467 pNew = 0;
230478 pNew->op = SQLITE_UPDATE;
230480 sqlite3_free(pNew);
230481 pNew = 0;
230485 pNew->op = SQLITE_DELETE;
230494 if( pNew ){
230495 pNew->nRecord = (int)(aCsr - pNew->aRecord);
230501 *ppNew = pNew;
231305 sqlite3_rebaser *pNew;
231307 pNew = sqlite3_malloc(sizeof(sqlite3_rebaser));
231308 if( pNew==0 ){
231311 memset(pNew, 0, sizeof(sqlite3_rebaser));
231313 *ppNew = pNew;
233450 fts5yyStackEntry *pNew;
233455 pNew = fts5YYREALLOC(0, newSize*sizeof(pNew[0]));
233456 if( pNew==0 ) return 1;
233457 memcpy(pNew, p->fts5yystack, oldSize*sizeof(pNew[0]));
233459 pNew = fts5YYREALLOC(p->fts5yystack, newSize*sizeof(pNew[0]));
233460 if( pNew==0 ) return 1;
233462 p->fts5yystack = pNew;
235238 u8 *pNew;
235242 pNew = sqlite3_realloc64(pBuf->p, nNew);
235243 if( pNew==0 ){
235248 pBuf->p = pNew;
236939 Fts5Expr *pNew;
236971 *ppNew = pNew = sqlite3_malloc(sizeof(Fts5Expr));
236972 if( pNew==0 ){
236978 pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&sParse.rc, nByte);
236979 if( pNew->pRoot ){
236980 pNew->pRoot->bEof = 1;
236983 pNew->pRoot = sParse.pExpr;
236985 pNew->pIndex = 0;
236986 pNew->pConfig = pConfig;
236987 pNew->apExprPhrase = sParse.apPhrase;
236988 pNew->nPhrase = sParse.nPhrase;
236989 pNew->bDesc = 0;
238427 Fts5ExprPhrase *pNew;
238430 pNew = (Fts5ExprPhrase*)sqlite3_realloc64(pPhrase,
238433 if( pNew==0 ){
238436 if( pPhrase==0 ) memset(pNew, 0, sizeof(Fts5ExprPhrase));
238437 pCtx->pPhrase = pPhrase = pNew;
238438 pNew->nTerm = nNew - SZALLOC;
238565 Fts5Expr *pNew = 0; /* Expression to return via *ppNew */
238571 pNew = (Fts5Expr*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Expr));
238574 pNew->apExprPhrase = (Fts5ExprPhrase**)sqlite3Fts5MallocZero(&rc,
238578 pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&rc,
238582 pNew->pRoot->pNear = (Fts5ExprNearset*)sqlite3Fts5MallocZero(&rc,
238595 pNew->pRoot->pNear->pColset = pColset;
238624 pNew->pIndex = pExpr->pIndex;
238625 pNew->pConfig = pExpr->pConfig;
238626 pNew->nPhrase = 1;
238627 pNew->apExprPhrase[0] = sCtx.pPhrase;
238628 pNew->pRoot->pNear->apPhrase[0] = sCtx.pPhrase;
238629 pNew->pRoot->pNear->nPhrase = 1;
238630 sCtx.pPhrase->pNode = pNew->pRoot;
238636 pNew->pRoot->eType = FTS5_TERM;
238637 pNew->pRoot->xNext = fts5ExprNodeNext_TERM;
238639 pNew->pRoot->eType = FTS5_STRING;
238640 pNew->pRoot->xNext = fts5ExprNodeNext_STRING;
238643 sqlite3Fts5ExprFree(pNew);
238645 pNew = 0;
238648 *ppNew = pNew;
238707 Fts5Colset *pNew; /* New colset object to return */
238712 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
238713 if( pNew==0 ){
238716 int *aiCol = pNew->aiCol;
238719 if( aiCol[i]==iCol ) return pNew;
238726 pNew->nCol = nCol+1;
238730 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
238734 return pNew;
240025 Fts5Hash *pNew;
240027 *ppNew = pNew = (Fts5Hash*)sqlite3_malloc(sizeof(Fts5Hash));
240028 if( pNew==0 ){
240032 memset(pNew, 0, sizeof(Fts5Hash));
240033 pNew->pnByte = pnByte;
240034 pNew->eDetail = pConfig->eDetail;
240036 pNew->nSlot = 1024;
240037 nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
240038 pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte);
240039 if( pNew->aSlot==0 ){
240040 sqlite3_free(pNew);
240044 memset(pNew->aSlot, 0, (size_t)nByte);
240260 Fts5HashEntry *pNew;
240262 pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
240263 if( pNew==0 ) return SQLITE_NOMEM;
240264 pNew->nAlloc = (int)nNew;
240266 *pp = pNew;
240267 p = pNew;
241546 Fts5Structure *pNew;
241547 pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte);
241548 if( pNew ){
241550 memcpy(pNew, p, nByte);
241551 for(i=0; i<p->nLevel; i++) pNew->aLevel[i].aSeg = 0;
241553 Fts5StructureLevel *pLvl = &pNew->aLevel[i];
241554 nByte = sizeof(Fts5StructureSegment) * pNew->aLevel[i].nSeg;
241558 sqlite3_free(pNew->aLevel[i].aSeg);
241560 sqlite3_free(pNew);
241566 pNew->nRef = 1;
241568 *pp = pNew;
242245 Fts5DlidxIter *pNew;
242247 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
242248 if( pNew==0 ){
242252 Fts5DlidxLvl *pLvl = &pNew->aLvl[i];
242253 pIter = pNew;
242463 Fts5TombstoneArray *pNew;
242464 pNew = (Fts5TombstoneArray*)sqlite3Fts5MallocZero(&p->rc, nByte);
242465 if( pNew ){
242466 pNew->nTombstone = nTomb;
242467 pNew->nRef = 1;
242468 pIter->pTombArray = pNew;
242593 Fts5Data *pNew;
242595 pNew = fts5DataRead(p, FTS5_SEGMENT_ROWID(
242598 if( pNew ){
242604 if( pIter->iTermLeafOffset<pNew->szLeaf ){
242605 pIter->pLeaf = pNew;
242610 iRowidOff = fts5LeafFirstRowidOff(pNew);
242612 if( iRowidOff>=pNew->szLeaf ){
242615 pIter->pLeaf = pNew;
242626 fts5DataRelease(pNew);
242925 Fts5Data *pNew = fts5LeafRead(p, iAbs);
242926 if( pNew ){
242928 iRowid = fts5LeafFirstRowidOff(pNew);
242929 bTermless = fts5LeafIsTermless(pNew);
242931 SWAPVAL(Fts5Data*, pNew, pLast);
242934 fts5DataRelease(pNew);
243710 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
243712 if( pNew->iRowid==pIter->iSwitchRowid
243713 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
243721 assert( pNew->pLeaf );
243725 if( pNew->iRowid==pOther->iRowid ){
243727 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
243729 pNew = pOther;
243734 pRes->iFirst = (u16)(pNew - pIter->aSeg);
243741 *ppFirst = pNew;
243918 Fts5Iter *pNew;
243922 pNew = fts5IdxMalloc(p,
243927 if( pNew ){
243928 pNew->nSeg = nSlot;
243929 pNew->aFirst = (Fts5CResult*)&pNew->aSeg[nSlot];
243930 pNew->pIndex = p;
243931 pNew->xSetOutputs = fts5IterSetOutputs_Noop;
243933 return pNew;
244416 Fts5Iter *pNew;
244430 *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
244431 if( pNew==0 ){
244435 pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
244436 pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
244437 pNew->pColset = pColset;
244439 fts5IterSetOutputCb(&p->rc, pNew);
244448 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
244454 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
244465 fts5SegIterInit(p, &pLvl->aSeg[iSeg], &pNew->aSeg[iIter++]);
244476 fts5MultiIterFinishSetup(p, pNew);
244478 fts5MultiIterFree(pNew);
244497 Fts5Iter *pNew;
244498 pNew = fts5MultiIterAlloc(p, 2);
244499 if( pNew ){
244500 Fts5SegIter *pIter = &pNew->aSeg[1];
244506 pNew->aFirst[1].iFirst = 1;
244508 pNew->bRev = 1;
244516 pNew->base.bEof = 1;
244520 *ppOut = pNew;
244660 static int fts5PrefixCompress(int nOld, const u8 *pOld, const u8 *pNew){
244663 if( pOld[i]!=pNew[i] ) break;
246252 Fts5Structure *pNew = 0;
246283 pNew = (Fts5Structure*)sqlite3Fts5MallocZero(&p->rc, nByte);
246285 if( pNew ){
246288 pNew->nLevel = MIN(pStruct->nLevel+1, FTS5_MAX_LEVEL);
246289 pNew->nRef = 1;
246290 pNew->nWriteCounter = pStruct->nWriteCounter;
246291 pNew->nOriginCntr = pStruct->nOriginCntr;
246292 pLvl = &pNew->aLevel[pNew->nLevel-1];
246306 pNew->nSegment = pLvl->nSeg = nSeg;
246308 sqlite3_free(pNew);
246309 pNew = 0;
246313 return pNew;
246318 Fts5Structure *pNew = 0;
246328 pNew = fts5IndexOptimizeStruct(p, pStruct);
246332 assert( pNew==0 || pNew->nSegment>0 );
246333 if( pNew ){
246335 for(iLvl=0; pNew->aLevel[iLvl].nSeg==0; iLvl++){}
246336 while( p->rc==SQLITE_OK && pNew->aLevel[iLvl].nSeg>0 ){
246338 fts5IndexMergeLevel(p, &pNew, iLvl, &nRem);
246341 fts5StructureWrite(p, pNew);
246342 fts5StructureRelease(pNew);
246361 Fts5Structure *pNew = fts5IndexOptimizeStruct(p, pStruct);
246363 pStruct = pNew;
247160 Fts5TokenDataIter *pNew = (Fts5TokenDataIter*)sqlite3_realloc(pIn, nByte);
247162 if( pNew==0 ){
247165 if( pIn==0 ) memset(pNew, 0, nByte);
247166 pRet = pNew;
247167 pNew->nIterAlloc = nAlloc;
247419 Fts5Iter *pNew = 0;
247425 pNew = fts5MultiIterAlloc(p, pStruct->nSegment);
247433 sqlite3Fts5IterClose((Fts5IndexIter*)pNew);
247437 pNewIter = &pNew->aSeg[0];
247475 pNew->bSkipEmpty = 1;
247476 pNew->pColset = pColset;
247477 fts5IterSetOutputCb(&p->rc, pNew);
247484 for(ii=0; ii<pNew->nSeg; ii++){
247485 Fts5SegIter *pII = &pNew->aSeg[ii];
247498 sqlite3Fts5IterClose((Fts5IndexIter*)pNew);
247503 pSet = fts5AppendTokendataIter(p, pSet, pNew);
248103 Fts5Data *pNew = (Fts5Data*)sqlite3Fts5MallocZero(&p->rc,
248106 if( pNew ){
248107 pNew->nn = szPage;
248108 pNew->p = (u8*)&pNew[1];
248109 apOut[ii] = pNew;
249320 Fts5StructVtab *pNew = 0;
249329 pNew = sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
249332 *ppVtab = (sqlite3_vtab*)pNew;
249377 Fts5StructVcsr *pNew = 0;
249379 pNew = sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
249380 *ppCsr = (sqlite3_vtab_cursor*)pNew;
252026 Fts5Cursor *pNew = 0;
252028 rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
252030 pNew->ePlan = FTS5_PLAN_MATCH;
252031 pNew->iFirstRowid = SMALLEST_INT64;
252032 pNew->iLastRowid = LARGEST_INT64;
252033 pNew->base.pVtab = (sqlite3_vtab*)pTab;
252034 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
252038 for(rc = fts5CursorFirst(pTab, pNew, 0);
252039 rc==SQLITE_OK && CsrFlagTest(pNew, FTS5CSR_EOF)==0;
252040 rc = fts5NextMethod((sqlite3_vtab_cursor*)pNew)
252042 rc = xCallback(&sFts5Api, (Fts5Context*)pNew, pUserData);
252050 fts5CloseMethod((sqlite3_vtab_cursor*)pNew);
252389 Fts5TokenizerModule *pNew;
252396 pNew = (Fts5TokenizerModule*)sqlite3_malloc64(nByte);
252397 if( pNew ){
252398 memset(pNew, 0, (size_t)nByte);
252399 pNew->zName = (char*)&pNew[1];
252400 memcpy(pNew->zName, zName, nName);
252401 pNew->pUserData = pUserData;
252402 pNew->x = *pTokenizer;
252403 pNew->xDestroy = xDestroy;
252404 pNew->pNext = pGlobal->pTok;
252405 pGlobal->pTok = pNew;
252406 if( pNew->pNext==0 ){
252407 pGlobal->pDfltTok = pNew;
255237 TrigramTokenizer *pNew = (TrigramTokenizer*)sqlite3_malloc(sizeof(*pNew));
255239 if( pNew==0 ){
255243 pNew->bFold = 1;
255244 pNew->iFoldParam = 0;
255251 pNew->bFold = (zArg[0]=='0');
255257 pNew->iFoldParam = (zArg[0]!='0') ? 2 : 0;
255265 if( pNew->iFoldParam!=0 && pNew->bFold==0 ){
255270 fts5TriDelete((Fts5Tokenizer*)pNew);
255271 pNew = 0;
255274 *ppOut = (Fts5Tokenizer*)pNew;
257410 stmt_vtab *pNew;
257435 pNew = sqlite3_malloc64( sizeof(*pNew) );
257436 *ppVtab = (sqlite3_vtab*)pNew;
257437 if( pNew==0 ) return SQLITE_NOMEM;
257438 memset(pNew, 0, sizeof(*pNew));
257439 pNew->db = db;
257559 StmtRow *pNew = (StmtRow*)sqlite3_malloc64(sizeof(StmtRow) + nSql);
257561 if( pNew==0 ) return SQLITE_NOMEM;
257562 memset(pNew, 0, sizeof(StmtRow));
257564 pNew->zSql = (char*)&pNew[1];
257565 memcpy(pNew->zSql, zSql, nSql);
257567 pNew->aCol[STMT_COLUMN_NCOL] = sqlite3_column_count(p);
257568 pNew->aCol[STMT_COLUMN_RO] = sqlite3_stmt_readonly(p);
257569 pNew->aCol[STMT_COLUMN_BUSY] = sqlite3_stmt_busy(p);
257570 pNew->aCol[STMT_COLUMN_NSCAN] = sqlite3_stmt_status(
257573 pNew->aCol[STMT_COLUMN_NSORT] = sqlite3_stmt_status(
257576 pNew->aCol[STMT_COLUMN_NAIDX] = sqlite3_stmt_status(
257579 pNew->aCol[STMT_COLUMN_NSTEP] = sqlite3_stmt_status(
257582 pNew->aCol[STMT_COLUMN_REPREP] = sqlite3_stmt_status(
257585 pNew->aCol[STMT_COLUMN_RUN] = sqlite3_stmt_status(
257588 pNew->aCol[STMT_COLUMN_MEM] = sqlite3_stmt_status(
257591 pNew->iRowid = iRowid++;
257592 *ppRow = pNew;
257593 ppRow = &pNew->pNext;