Lines Matching defs:pPrior
19513 Select *pPrior; /* Prior select in a compound select statement */
26609 static void sqlite3MemFree(void *pPrior){ return; }
26610 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
26611 static int sqlite3MemSize(void *pPrior){ return 0; }
26797 ** For this low-level routine, we already know that pPrior!=0 since
26798 ** cases where pPrior==0 will have been intercepted and dealt with
26801 static void sqlite3MemFree(void *pPrior){
26803 SQLITE_FREE(pPrior);
26805 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
26806 assert( pPrior!=0 );
26816 static int sqlite3MemSize(void *pPrior){
26818 assert( pPrior!=0 );
26819 return (int)SQLITE_MALLOCSIZE(pPrior);
26822 assert( pPrior!=0 );
26823 p = (sqlite3_int64*)pPrior;
26833 ** For this low-level interface, we know that pPrior!=0. Cases where
26834 ** pPrior==0 while have been intercepted by higher-level routine and
26839 static void *sqlite3MemRealloc(void *pPrior, int nByte){
26841 void *p = SQLITE_REALLOC(pPrior, nByte);
26846 SQLITE_MALLOCSIZE(pPrior), nByte);
26850 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
26851 assert( pPrior!=0 && nByte>0 );
26862 sqlite3MemSize(pPrior), nByte);
27234 static void sqlite3MemFree(void *pPrior){
27240 pHdr = sqlite3MemsysGetHeader(pPrior);
27276 static void *sqlite3MemRealloc(void *pPrior, int nByte){
27281 pOldHdr = sqlite3MemsysGetHeader(pPrior);
27284 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize));
27288 sqlite3MemFree(pPrior);
27975 static void memsys3Free(void *pPrior){
27976 assert( pPrior );
27978 memsys3FreeUnsafe(pPrior);
27985 static void *memsys3Realloc(void *pPrior, int nBytes){
27988 if( pPrior==0 ){
27992 sqlite3_free(pPrior);
27995 nOld = memsys3Size(pPrior);
27997 return pPrior;
28003 memcpy(p, pPrior, nOld);
28005 memcpy(p, pPrior, nBytes);
28007 memsys3FreeUnsafe(pPrior);
28524 ** being called with pPrior==0.
28526 static void memsys5Free(void *pPrior){
28527 assert( pPrior!=0 );
28529 memsys5FreeUnsafe(pPrior);
28537 ** being called with pPrior==0.
28543 ** routine should return 0 without freeing pPrior.
28545 static void *memsys5Realloc(void *pPrior, int nBytes){
28548 assert( pPrior!=0 );
28554 nOld = memsys5Size(pPrior);
28556 return pPrior;
28560 memcpy(p, pPrior, nOld);
28561 memsys5Free(pPrior);
32869 if( p->pPrior ){
32941 if( p->pPrior ){
32950 p = p->pPrior;
47110 static void winMemFree(void *pPrior);
47111 static void *winMemRealloc(void *pPrior, int nBytes);
48144 static void winMemFree(void *pPrior){
48152 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
48154 if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
48155 if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
48157 pPrior, osGetLastError(), (void*)hHeap);
48164 static void *winMemRealloc(void *pPrior, int nBytes){
48173 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
48176 if( !pPrior ){
48179 p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
48183 pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
77529 unsigned char *pPrior;
77588 pPrior = &pCell[nHeader+n];
77600 ** pPrior Where to write the pgno of the first overflow page
77681 /* If pToRelease is not zero than pPrior points into the data area
77685 /* If pPrior is part of the data area of pPage, then make sure pPage
77687 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
77690 put4byte(pPrior, pgnoOvfl);
77693 pPrior = pOvfl->aData;
77694 put4byte(pPrior, 0);
106652 ** on the compound select chain, p->pPrior.
106681 p = p->pPrior;
108316 while( pSelect->pPrior ){
108317 pSelect->pPrior->pNext = pSelect;
108318 pSelect = pSelect->pPrior;
108582 isCompound = p->pPrior!=0;
108609 assert( pSub->pPrior && pSub->pOrderBy==0 );
108780 p = p->pPrior;
108931 ** descendants of the SELECT, including compounds off of p->pPrior,
109835 for(p=pSelect; p; p=p->pPrior){
110123 pSel->pPrior = pRet;
110129 if( pRet && pRet->pPrior ){
110950 for(p=pDup; p; p=p->pPrior){
110961 pNew->pPrior = 0;
110985 pp = &pNew->pPrior;
111972 if( p->pPrior ) return 0; /* Not a compound SELECT */
128526 Index *pPrior = 0; /* Prior index */
128539 &iPartIdxLabel, pPrior, r1);
128544 pPrior = pIdx;
128568 ** The pPrior and regPrior parameters are used to implement a cache to
128569 ** avoid unnecessary register loads. If pPrior is not NULL, then it is
128572 ** its key into the same sequence of registers and if pPrior and pIdx share
128586 Index *pPrior, /* Previously generated index key */
128601 pPrior = 0; /* Ticket a9efb42811fa41ee 2019-11-02;
128609 if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
128611 if( pPrior
128612 && pPrior->aiColumn[j]==pIdx->aiColumn[j]
128613 && pPrior->aiColumn[j]!=XN_EXPR
133581 }else if( pLeft->pPrior ){
133589 pSelect->pPrior = pLeft;
133611 pRet->pPrior = pLeft->pPrior;
133613 if( pRet->pPrior ) pRet->selFlags |= SF_Values;
133614 pLeft->pPrior = 0;
133828 if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
134003 && pSelect->pPrior==0
135945 if( pSelect->pPrior ){
140536 Index *pPrior = 0; /* Previous index */
140775 pPrior, r1);
140776 pPrior = pIdx;
142976 Select *pPrior = p->pPrior;
142995 p = pPrior;
143054 pNew->pPrior = 0;
145013 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145222 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145307 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145424 if( p->pPrior ){
145425 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
145484 ** p->pPrior p
145606 for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){
145612 if( (pFirstRec->pPrior->selFlags & SF_Recursive)==0 ) break;
145616 pSetup = pFirstRec->pPrior;
145649 pFirstRec->pPrior = 0;
145652 assert( pFirstRec->pPrior==0 );
145653 pFirstRec->pPrior = pSetup;
145701 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
145706 if( p->pPrior==0 ) break;
145707 assert( p->pPrior->pNext==p );
145708 p = p->pPrior;
145728 while( p && (p->selFlags & SF_Recursive)!=0 ){ p = p->pPrior; }
145738 ** left is p->pPrior. The left query could also be a compound query
145756 ** The arrows in the diagram above represent the Select.pPrior pointer.
145758 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
145769 Select *pPrior; /* Another SELECT immediately to our left */
145778 assert( p && p->pPrior ); /* Calling function guarantees this much */
145782 pPrior = p->pPrior;
145784 assert( pPrior->pOrderBy==0 );
145785 assert( pPrior->pLimit==0 );
145809 assert( p->pEList && pPrior->pEList );
145810 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
145825 if( pPrior->pPrior==0 ){
145837 assert( !pPrior->pLimit );
145838 pPrior->iLimit = p->iLimit;
145839 pPrior->iOffset = p->iOffset;
145840 pPrior->pLimit = p->pLimit;
145842 rc = sqlite3Select(pParse, pPrior, &dest);
145843 pPrior->pLimit = 0;
145847 p->pPrior = 0;
145848 p->iLimit = pPrior->iLimit;
145849 p->iOffset = pPrior->iOffset;
145862 pDelete = p->pPrior;
145863 p->pPrior = pPrior;
145864 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
145910 assert( !pPrior->pOrderBy );
145913 rc = sqlite3Select(pParse, pPrior, &uniondest);
145926 p->pPrior = 0;
145936 pDelete = p->pPrior;
145937 p->pPrior = pPrior;
145940 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
145994 rc = sqlite3Select(pParse, pPrior, &intersectdest);
146004 p->pPrior = 0;
146013 pDelete = p->pPrior;
146014 p->pPrior = pPrior;
146015 if( p->nSelectRow>pPrior->nSelectRow ){
146016 p->nSelectRow = pPrior->nSelectRow;
146085 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
146361 Select *pPrior; /* Another SELECT immediately to our left */
146409 assert( p->pPrior->pOrderBy==0 );
146487 for(pSplit=p; pSplit->pPrior!=0 && pSplit->op==op; pSplit=pSplit->pPrior){
146489 assert( pSplit->pPrior->pNext==pSplit );
146496 for(i=2; i<nSelect; i+=2){ pSplit = pSplit->pPrior; }
146498 pPrior = pSplit->pPrior;
146499 assert( pPrior!=0 );
146500 pSplit->pPrior = 0;
146501 pPrior->pNext = 0;
146504 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
146506 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
146537 pPrior->iLimit = regLimitA;
146539 sqlite3Select(pParse, pPrior, &destA);
146589 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
146597 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
146657 if( pSplit->pPrior ){
146658 sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, pSplit->pPrior);
146660 pSplit->pPrior = pPrior;
146661 pPrior->pNext = pSplit;
146662 sqlite3ExprListDelete(db, pPrior->pOrderBy);
146663 pPrior->pOrderBy = 0;
146851 int doPrior /* Do substitutes on p->pPrior too */
146871 }while( doPrior && (p = p->pPrior)!=0 );
146937 for(p=pItem->pSelect; p; p=p->pPrior){
147010 while( pSel->pPrior ){
147011 pSel = pSel->pPrior;
147025 assert( p->pPrior!=0 );
147032 for(pSub1=p->pPrior; pSub1; pSub1=pSub1->pPrior){
147243 assert( p->pPrior==0 );
147324 if( pSub->pPrior ){
147332 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
147339 || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */
147431 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
147435 Select *pPrior = p->pPrior;
147439 p->pPrior = 0;
147447 p->pPrior = pPrior;
147453 pNew->pPrior = pPrior;
147454 if( pPrior ) pPrior->pNext = pNew;
147456 p->pPrior = pNew;
147501 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
147937 assert( pSubq->pPrior==0 );
148070 if( pSubq->pPrior ){
148073 for(pSel=pSubq; pSel; pSel=pSel->pPrior){
148088 for(pSel=pSubq; pSel; pSel=pSel->pPrior){
148113 for(pX=pSubq; pX; pX=pX->pPrior){
148197 pSubq = pSubq->pPrior;
148229 for(pX=pSub; pX; pX=pX->pPrior){
148235 if( pX->pPrior && pX->op!=TK_ALL ){
148263 for(pX=pSub; pX; pX=pX->pPrior) {
148438 if( p->pPrior==0 ) return WRC_Continue;
148440 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
148473 p->pPrior = 0;
148482 assert( pNew->pPrior!=0 );
148483 pNew->pPrior->pNext = pNew;
148673 assert( pRecTerm->pPrior!=0 );
148695 pRecTerm = pRecTerm->pPrior;
148723 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
148764 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
148794 while( pSel->pPrior ){ pSel = pSel->pPrior; }
150020 Select *pSub, *pPrior;
150040 if( pSub->pPrior==0 ) return 0; /* Must be a compound */
150043 if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */
150048 pSub = pSub->pPrior; /* Repeat over compound */
150062 pPrior = pSub->pPrior;
150063 pSub->pPrior = 0;
150069 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
150078 pSub = pPrior;
150320 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
150490 if( p->pPrior ){
150536 SrcItem *pPrior;
150653 }else if( (pPrior = isSelfJoinView(pTabList, pItem, 0, i))!=0 ){
150656 if( pPrior->addrFillSub ){
150657 sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
150659 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
150660 pSub->nSelectRow = pPrior->pSelect->nSelectRow;
155419 VtabCtx *pPrior; /* Parent context (if any) */
155969 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
156001 sCtx.pPrior = db->pVtabCtx;
156009 db->pVtabCtx = sCtx.pPrior;
157915 for(pSelect=pNew->x.pSelect; pSelect; pSelect=pSelect->pPrior){
161198 pS = pS->pPrior;
161686 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
170308 && p->pPrior==0
172561 ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
172567 if( p->pPrior ){
172574 pLoop = pLoop->pPrior;
172668 ExprList *pPrior,
172673 ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
176429 if( pRhs && pRhs->pPrior ){
176439 pRhs->pPrior = pLhs;