Lines Matching refs:pPrior
10956 Select *pPrior; /* Prior select in a compound select statement */
15147 static void sqlite3MemFree(void *pPrior){ return; }
15148 static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
15149 static int sqlite3MemSize(void *pPrior){ return 0; }
15314 ** For this low-level routine, we already know that pPrior!=0 since
15315 ** cases where pPrior==0 will have been intecepted and dealt with
15318 static void sqlite3MemFree(void *pPrior){
15320 SQLITE_FREE(pPrior);
15322 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
15323 assert( pPrior!=0 );
15333 static int sqlite3MemSize(void *pPrior){
15335 return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
15338 if( pPrior==0 ) return 0;
15339 p = (sqlite3_int64*)pPrior;
15349 ** For this low-level interface, we know that pPrior!=0. Cases where
15350 ** pPrior==0 while have been intercepted by higher-level routine and
15355 static void *sqlite3MemRealloc(void *pPrior, int nByte){
15357 void *p = SQLITE_REALLOC(pPrior, nByte);
15362 SQLITE_MALLOCSIZE(pPrior), nByte);
15366 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
15367 assert( pPrior!=0 && nByte>0 );
15378 sqlite3MemSize(pPrior), nByte);
15758 static void sqlite3MemFree(void *pPrior){
15764 pHdr = sqlite3MemsysGetHeader(pPrior);
15800 static void *sqlite3MemRealloc(void *pPrior, int nByte){
15805 pOldHdr = sqlite3MemsysGetHeader(pPrior);
15808 memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15812 sqlite3MemFree(pPrior);
16498 static void memsys3Free(void *pPrior){
16499 assert( pPrior );
16501 memsys3FreeUnsafe(pPrior);
16508 static void *memsys3Realloc(void *pPrior, int nBytes){
16511 if( pPrior==0 ){
16515 sqlite3_free(pPrior);
16518 nOld = memsys3Size(pPrior);
16520 return pPrior;
16526 memcpy(p, pPrior, nOld);
16528 memcpy(p, pPrior, nBytes);
16530 memsys3FreeUnsafe(pPrior);
17049 ** being called with pPrior==0.
17051 static void memsys5Free(void *pPrior){
17052 assert( pPrior!=0 );
17054 memsys5FreeUnsafe(pPrior);
17062 ** being called with pPrior==0.
17068 ** routine should return 0 without freeing pPrior.
17070 static void *memsys5Realloc(void *pPrior, int nBytes){
17073 assert( pPrior!=0 );
17079 nOld = memsys5Size(pPrior);
17081 return pPrior;
17086 memcpy(p, pPrior, nOld);
17087 memsys5FreeUnsafe(pPrior);
32256 static void winMemFree(void *pPrior);
32257 static void *winMemRealloc(void *pPrior, int nBytes);
32866 static void winMemFree(void *pPrior){
32874 assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32876 if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
32877 if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
32879 pPrior, osGetLastError(), (void*)hHeap);
32886 static void *winMemRealloc(void *pPrior, int nBytes){
32895 assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32898 if( !pPrior ){
32901 p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
32905 pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
54691 unsigned char *pPrior;
54738 pPrior = &pCell[info.iOverflow];
54777 /* If pToRelease is not zero than pPrior points into the data area
54781 /* If pPrior is part of the data area of pPage, then make sure pPage
54783 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
54786 put4byte(pPrior, pgnoOvfl);
54789 pPrior = pOvfl->aData;
54790 put4byte(pPrior, 0);
73144 ** on the compound select chain, p->pPrior.
73161 p = p->pPrior;
73929 while( pSelect->pPrior ){
73930 pSelect->pPrior->pNext = pSelect;
73931 pSelect = pSelect->pPrior;
74130 isCompound = p->pPrior!=0;
74263 p = p->pPrior;
74366 ** decendents of the SELECT, including compounds off of p->pPrior,
74703 heightOfSelect(p->pPrior, pnHeight);
75338 Select *pNew, *pPrior;
75349 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
75350 if( pPrior ) pPrior->pNext = pNew;
75746 if( p->pPrior ) return 0; /* Not a compound SELECT */
80886 pSelect = pSelect->pPrior;
90624 if( pSelect->pPrior ){
94530 sqlite3SelectDelete(db, p->pPrior);
95888 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
96008 if( p->pPrior ){
96009 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
96036 ** left is p->pPrior. The left query could also be a compound query
96054 ** The arrows in the diagram above represent the Select.pPrior pointer.
96056 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
96067 Select *pPrior; /* Another SELECT immediately to our left */
96080 assert( p && p->pPrior ); /* Calling function guarantees this much */
96082 pPrior = p->pPrior;
96083 assert( pPrior->pRightmost!=pPrior );
96084 assert( pPrior->pRightmost==p->pRightmost );
96086 if( pPrior->pOrderBy ){
96092 if( pPrior->pLimit ){
96114 assert( p->pEList && pPrior->pEList );
96115 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
96138 assert( !pPrior->pLimit );
96139 pPrior->pLimit = p->pLimit;
96140 pPrior->pOffset = p->pOffset;
96142 rc = sqlite3Select(pParse, pPrior, &dest);
96148 p->pPrior = 0;
96149 p->iLimit = pPrior->iLimit;
96150 p->iOffset = pPrior->iOffset;
96158 pDelete = p->pPrior;
96159 p->pPrior = pPrior;
96160 p->nSelectRow += pPrior->nSelectRow;
96161 if( pPrior->pLimit
96162 && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
96208 assert( !pPrior->pOrderBy );
96211 rc = sqlite3Select(pParse, pPrior, &uniondest);
96224 p->pPrior = 0;
96236 pDelete = p->pPrior;
96237 p->pPrior = pPrior;
96239 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
96255 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96298 rc = sqlite3Select(pParse, pPrior, &intersectdest);
96308 p->pPrior = 0;
96317 pDelete = p->pPrior;
96318 p->pPrior = pPrior;
96319 if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96330 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96389 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
96663 Select *pPrior; /* Another SELECT immediately to our left */
96714 pPrior = p->pPrior;
96715 assert( pPrior->pOrderBy==0 );
96783 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
96811 p->pPrior = 0;
96813 if( pPrior->pPrior==0 ){
96814 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
96853 pPrior->iLimit = regLimitA;
96855 sqlite3Select(pParse, pPrior, &destA);
96906 p->nSelectRow += pPrior->nSelectRow;
96914 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96988 Select *pFirst = pPrior;
96989 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96995 if( p->pPrior ){
96996 sqlite3SelectDelete(db, p->pPrior);
96998 p->pPrior = pPrior;
97084 substSelect(db, p->pPrior, iTable, pEList);
97234 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
97314 if( pSub->pPrior ){
97321 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
97326 || (pSub1->pPrior && pSub1->op!=TK_ALL)
97383 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
97387 Select *pPrior = p->pPrior;
97390 p->pPrior = 0;
97399 pNew = pPrior;
97401 pNew->pPrior = pPrior;
97404 p->pPrior = pNew;
97456 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
97746 while( pSel->pPrior ){ pSel = pSel->pPrior; }
97986 while( pSel->pPrior ) pSel = pSel->pPrior;
98327 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
98405 if( p->pPrior ){
98410 for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
99098 while( p->pPrior ) p = p->pPrior;
103028 pS = pS->pPrior;
110177 yymsp[0].minor.yy159->pPrior = yymsp[-2].minor.yy159;
110408 pRight->pPrior = yymsp[-4].minor.yy487.pSelect;
110410 pRight->pPrior->selFlags |= SF_Values;
