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);
32284 static void winMemFree(void *pPrior);
32285 static void *winMemRealloc(void *pPrior, int nBytes);
32894 static void winMemFree(void *pPrior){
32902 assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32904 if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
32905 if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
32907 pPrior, osGetLastError(), (void*)hHeap);
32914 static void *winMemRealloc(void *pPrior, int nBytes){
32923 assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32926 if( !pPrior ){
32929 p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
32933 pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
54719 unsigned char *pPrior;
54766 pPrior = &pCell[info.iOverflow];
54805 /* If pToRelease is not zero than pPrior points into the data area
54809 /* If pPrior is part of the data area of pPage, then make sure pPage
54811 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
54814 put4byte(pPrior, pgnoOvfl);
54817 pPrior = pOvfl->aData;
54818 put4byte(pPrior, 0);
73180 ** on the compound select chain, p->pPrior.
73197 p = p->pPrior;
73965 while( pSelect->pPrior ){
73966 pSelect->pPrior->pNext = pSelect;
73967 pSelect = pSelect->pPrior;
74166 isCompound = p->pPrior!=0;
74299 p = p->pPrior;
74402 ** decendents of the SELECT, including compounds off of p->pPrior,
74739 heightOfSelect(p->pPrior, pnHeight);
75374 Select *pNew, *pPrior;
75385 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
75386 if( pPrior ) pPrior->pNext = pNew;
75782 if( p->pPrior ) return 0; /* Not a compound SELECT */
80922 pSelect = pSelect->pPrior;
90660 if( pSelect->pPrior ){
94566 sqlite3SelectDelete(db, p->pPrior);
95924 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
96044 if( p->pPrior ){
96045 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
96072 ** left is p->pPrior. The left query could also be a compound query
96090 ** The arrows in the diagram above represent the Select.pPrior pointer.
96092 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
96103 Select *pPrior; /* Another SELECT immediately to our left */
96116 assert( p && p->pPrior ); /* Calling function guarantees this much */
96118 pPrior = p->pPrior;
96119 assert( pPrior->pRightmost!=pPrior );
96120 assert( pPrior->pRightmost==p->pRightmost );
96122 if( pPrior->pOrderBy ){
96128 if( pPrior->pLimit ){
96150 assert( p->pEList && pPrior->pEList );
96151 if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
96174 assert( !pPrior->pLimit );
96175 pPrior->pLimit = p->pLimit;
96176 pPrior->pOffset = p->pOffset;
96178 rc = sqlite3Select(pParse, pPrior, &dest);
96184 p->pPrior = 0;
96185 p->iLimit = pPrior->iLimit;
96186 p->iOffset = pPrior->iOffset;
96194 pDelete = p->pPrior;
96195 p->pPrior = pPrior;
96196 p->nSelectRow += pPrior->nSelectRow;
96197 if( pPrior->pLimit
96198 && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
96244 assert( !pPrior->pOrderBy );
96247 rc = sqlite3Select(pParse, pPrior, &uniondest);
96260 p->pPrior = 0;
96272 pDelete = p->pPrior;
96273 p->pPrior = pPrior;
96275 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
96291 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96334 rc = sqlite3Select(pParse, pPrior, &intersectdest);
96344 p->pPrior = 0;
96353 pDelete = p->pPrior;
96354 p->pPrior = pPrior;
96355 if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96366 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96425 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
96699 Select *pPrior; /* Another SELECT immediately to our left */
96750 pPrior = p->pPrior;
96751 assert( pPrior->pOrderBy==0 );
96819 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
96847 p->pPrior = 0;
96849 if( pPrior->pPrior==0 ){
96850 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
96889 pPrior->iLimit = regLimitA;
96891 sqlite3Select(pParse, pPrior, &destA);
96942 p->nSelectRow += pPrior->nSelectRow;
96950 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
97024 Select *pFirst = pPrior;
97025 while( pFirst->pPrior ) pFirst = pFirst->pPrior;
97031 if( p->pPrior ){
97032 sqlite3SelectDelete(db, p->pPrior);
97034 p->pPrior = pPrior;
97120 substSelect(db, p->pPrior, iTable, pEList);
97270 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
97350 if( pSub->pPrior ){
97357 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
97362 || (pSub1->pPrior && pSub1->op!=TK_ALL)
97419 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
97423 Select *pPrior = p->pPrior;
97426 p->pPrior = 0;
97435 pNew = pPrior;
97437 pNew->pPrior = pPrior;
97440 p->pPrior = pNew;
97492 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
97782 while( pSel->pPrior ){ pSel = pSel->pPrior; }
98022 while( pSel->pPrior ) pSel = pSel->pPrior;
98363 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
98441 if( p->pPrior ){
98446 for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
99134 while( p->pPrior ) p = p->pPrior;
103064 pS = pS->pPrior;
110213 yymsp[0].minor.yy159->pPrior = yymsp[-2].minor.yy159;
110444 pRight->pPrior = yymsp[-4].minor.yy487.pSelect;
110446 pRight->pPrior->selFlags |= SF_Values;
