Lines Matching refs:pPrior
11701 Select *pPrior; /* Prior select in a compound select statement */
16246 static void sqlite3MemFree(void *pPrior){ return; }
16247 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
16248 static int sqlite3MemSize(void *pPrior){ return 0; }
16429 ** For this low-level routine, we already know that pPrior!=0 since
16430 ** cases where pPrior==0 will have been intecepted and dealt with
16433 static void sqlite3MemFree(void *pPrior){
16435 SQLITE_FREE(pPrior);
16437 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
16438 assert( pPrior!=0 );
16448 static int sqlite3MemSize(void *pPrior){
16450 return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
16453 if( pPrior==0 ) return 0;
16454 p = (sqlite3_int64*)pPrior;
16464 ** For this low-level interface, we know that pPrior!=0. Cases where
16465 ** pPrior==0 while have been intercepted by higher-level routine and
16470 static void *sqlite3MemRealloc(void *pPrior, int nByte){
16472 void *p = SQLITE_REALLOC(pPrior, nByte);
16477 SQLITE_MALLOCSIZE(pPrior), nByte);
16481 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
16482 assert( pPrior!=0 && nByte>0 );
16493 sqlite3MemSize(pPrior), nByte);
16873 static void sqlite3MemFree(void *pPrior){
16879 pHdr = sqlite3MemsysGetHeader(pPrior);
16915 static void *sqlite3MemRealloc(void *pPrior, int nByte){
16920 pOldHdr = sqlite3MemsysGetHeader(pPrior);
16923 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize));
16927 sqlite3MemFree(pPrior);
17613 static void memsys3Free(void *pPrior){
17614 assert( pPrior );
17616 memsys3FreeUnsafe(pPrior);
17623 static void *memsys3Realloc(void *pPrior, int nBytes){
17626 if( pPrior==0 ){
17630 sqlite3_free(pPrior);
17633 nOld = memsys3Size(pPrior);
17635 return pPrior;
17641 memcpy(p, pPrior, nOld);
17643 memcpy(p, pPrior, nBytes);
17645 memsys3FreeUnsafe(pPrior);
18159 ** being called with pPrior==0.
18161 static void memsys5Free(void *pPrior){
18162 assert( pPrior!=0 );
18164 memsys5FreeUnsafe(pPrior);
18172 ** being called with pPrior==0.
18178 ** routine should return 0 without freeing pPrior.
18180 static void *memsys5Realloc(void *pPrior, int nBytes){
18183 assert( pPrior!=0 );
18189 nOld = memsys5Size(pPrior);
18191 return pPrior;
18196 memcpy(p, pPrior, nOld);
18197 memsys5FreeUnsafe(pPrior);
32393 static void winMemFree(void *pPrior);
32394 static void *winMemRealloc(void *pPrior, int nBytes);
33375 static void winMemFree(void *pPrior){
33383 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
33385 if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
33386 if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
33388 pPrior, osGetLastError(), (void*)hHeap);
33395 static void *winMemRealloc(void *pPrior, int nBytes){
33404 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
33407 if( !pPrior ){
33410 p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
33414 pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
57088 unsigned char *pPrior;
57135 pPrior = &pCell[info.iOverflow];
57174 /* If pToRelease is not zero than pPrior points into the data area
57178 /* If pPrior is part of the data area of pPage, then make sure pPage
57180 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
57183 put4byte(pPrior, pgnoOvfl);
57186 pPrior = pOvfl->aData;
57187 put4byte(pPrior, 0);
76747 ** on the compound select chain, p->pPrior.
76781 p = p->pPrior;
77729 while( pSelect->pPrior ){
77730 pSelect->pPrior->pNext = pSelect;
77731 pSelect = pSelect->pPrior;
77944 isCompound = p->pPrior!=0;
78074 p = p->pPrior;
78178 ** decendents of the SELECT, including compounds off of p->pPrior,
78594 heightOfSelect(p->pPrior, pnHeight);
79295 Select *pNew, *pPrior;
79306 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
79307 if( pPrior ) pPrior->pNext = pNew;
79693 if( p->pPrior ) return 0; /* Not a compound SELECT */
85793 pSelect = pSelect->pPrior;
91579 Index *pPrior = 0; /* Prior index */
91591 &iPartIdxLabel, pPrior, r1);
91595 pPrior = pIdx;
91619 ** The pPrior and regPrior parameters are used to implement a cache to
91620 ** avoid unnecessary register loads. If pPrior is not NULL, then it is
91623 ** its key into the same sequence of registers and if pPrior and pIdx share
91637 Index *pPrior, /* Previously generated index key */
91659 if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
91661 if( pPrior && pPrior->aiColumn[j]==pIdx->aiColumn[j] ) continue;
95298 if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
96628 if( pSelect->pPrior ){
100110 Index *pPrior = 0;
100156 pPrior, r1);
100157 pPrior = pIdx;
101526 sqlite3SelectDelete(db, p->pPrior);
103145 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
103272 if( p->pPrior ){
103273 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
103329 ** p->pPrior p
103367 Select *pSetup = p->pPrior; /* The setup query */
103468 p->pPrior = 0;
103470 assert( p->pPrior==0 );
103471 p->pPrior = pSetup;
103500 ** left is p->pPrior. The left query could also be a compound query
103518 ** The arrows in the diagram above represent the Select.pPrior pointer.
103520 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
103531 Select *pPrior; /* Another SELECT immediately to our left */
103544 assert( p && p->pPrior ); /* Calling function guarantees this much */
103547 pPrior = p->pPrior;
103549 if( pPrior->pOrderBy ){
103555 if( pPrior->pLimit ){
103577 assert( p->pEList && pPrior->pEList );
103578 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
103607 assert( !pPrior->pLimit );
103608 pPrior->iLimit = p->iLimit;
103609 pPrior->iOffset = p->iOffset;
103610 pPrior->pLimit = p->pLimit;
103611 pPrior->pOffset = p->pOffset;
103613 rc = sqlite3Select(pParse, pPrior, &dest);
103619 p->pPrior = 0;
103620 p->iLimit = pPrior->iLimit;
103621 p->iOffset = pPrior->iOffset;
103629 pDelete = p->pPrior;
103630 p->pPrior = pPrior;
103631 p->nSelectRow += pPrior->nSelectRow;
103632 if( pPrior->pLimit
103633 && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
103677 assert( !pPrior->pOrderBy );
103680 rc = sqlite3Select(pParse, pPrior, &uniondest);
103693 p->pPrior = 0;
103705 pDelete = p->pPrior;
103706 p->pPrior = pPrior;
103708 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
103724 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
103767 rc = sqlite3Select(pParse, pPrior, &intersectdest);
103777 p->pPrior = 0;
103786 pDelete = p->pPrior;
103787 p->pPrior = pPrior;
103788 if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
103799 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
103853 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
104127 Select *pPrior; /* Another SELECT immediately to our left */
104177 pPrior = p->pPrior;
104178 assert( pPrior->pOrderBy==0 );
104228 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
104254 p->pPrior = 0;
104255 pPrior->pNext = 0;
104257 if( pPrior->pPrior==0 ){
104258 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
104290 pPrior->iLimit = regLimitA;
104292 sqlite3Select(pParse, pPrior, &destA);
104342 p->nSelectRow += pPrior->nSelectRow;
104350 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
104411 Select *pFirst = pPrior;
104412 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
104418 if( p->pPrior ){
104419 sqlite3SelectDelete(db, p->pPrior);
104421 p->pPrior = pPrior;
104422 pPrior->pNext = p;
104505 substSelect(db, p->pPrior, iTable, pEList);
104669 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
104708 if( (p->selFlags & SF_Recursive) && pSub->pPrior ) return 0; /* (23) */
104751 if( pSub->pPrior ){
104758 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
104763 || (pSub1->pPrior && pSub1->op!=TK_ALL)
104822 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
104827 Select *pPrior = p->pPrior;
104830 p->pPrior = 0;
104840 p->pPrior = pPrior;
104842 pNew->pPrior = pPrior;
104843 if( pPrior ) pPrior->pNext = pNew;
104845 p->pPrior = pNew;
104898 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
105157 if( p->pPrior==0 ) return WRC_Continue;
105159 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
105184 p->pPrior = 0;
105187 assert( pNew->pPrior!=0 );
105188 pNew->pPrior->pNext = pNew;
105333 sqlite3WalkSelect(pWalker, bMayRecursive ? pSel->pPrior : pSel);
105335 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
105468 while( pSel->pPrior ){ pSel = pSel->pPrior; }
105755 while( pSel->pPrior ) pSel = pSel->pPrior;
106070 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
106179 if( p->pPrior ){
111263 pS = pS->pPrior;
119853 if( p->pPrior ){
119855 for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
119877 if( pRhs && pRhs->pPrior ){
119886 pRhs->pPrior = yymsp[-2].minor.yy3;
119912 pRight->pPrior = yymsp[-4].minor.yy3;
