Lines Matching full:pnext
1211 ** the pNext pointer. The [sqlite3_vfs_register()]
1215 ** implementation should use the pNext pointer.
1217 ** The pNext field is the only field in the sqlite3_vfs
1326 sqlite3_vfs *pNext; /* Next registered VFS */
8275 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
8483 FuncDef *pNext; /* Next function with same name */
8548 Savepoint *pNext; /* Parent savepoint (if any) */
8717 VTable *pNext; /* Next in linked list (see above) */
8962 Index *pNext; /* The next index associated with the same table */
9463 ** Each subquery gets a new NameContext. The pNext field points to the
9479 NameContext *pNext; /* Next outer name context. NULL for outermost */
9513 Select *pNext; /* Next select to the left in a compound */
9575 AutoincInfo *pNext; /* Next info block in a list of them all */
9611 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
9748 * pNext member of struct Trigger. A pointer to the first element of the
9766 Trigger *pNext; /* Next trigger associated with the table */
9784 * using the "pNext" member) referenced by the "step_list" member of the
9826 TriggerStep *pNext; /* Next in the link-list */
12282 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
12298 vfsList = pVfs->pNext;
12301 while( p->pNext && p->pNext!=pVfs ){
12302 p = p->pNext;
12304 if( p->pNext==pVfs ){
12305 p->pNext = pVfs->pNext;
12325 pVfs->pNext = vfsList;
12328 pVfs->pNext = vfsList->pNext;
12329 vfsList->pNext = pVfs;
12708 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
12910 pHdr->pNext = 0;
12913 mem.pLast->pNext = pHdr;
12960 assert( pHdr->pPrev->pNext==pHdr );
12961 pHdr->pPrev->pNext = pHdr->pNext;
12964 mem.pFirst = pHdr->pNext;
12966 if( pHdr->pNext ){
12967 assert( pHdr->pNext->pPrev==pHdr );
12968 pHdr->pNext->pPrev = pHdr->pPrev;
13056 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
13078 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
16068 pBuf->pNext = db->lookaside.pFree;
16184 db->lookaside.pFree = pBuf->pNext;
17797 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
21264 0, /* pNext */
21470 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
21977 struct vxworksFileId *pNext; /* Next in a list of them all */
22055 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
22069 pNew->pNext = vxworksFileList;
22085 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
22087 *pp = pId->pNext;
22259 struct unixLockInfo *pNext; /* List of all unixLockInfo objects */
22284 struct unixOpenCnt *pNext, *pPrev; /* List of all unixOpenCnt objects */
22400 assert( pLock->pPrev->pNext==pLock );
22401 pLock->pPrev->pNext = pLock->pNext;
22404 lockList = pLock->pNext;
22406 if( pLock->pNext ){
22407 assert( pLock->pNext->pPrev==pLock );
22408 pLock->pNext->pPrev = pLock->pPrev;
22427 assert( pOpen->pPrev->pNext==pOpen );
22428 pOpen->pPrev->pNext = pOpen->pNext;
22431 openList = pOpen->pNext;
22433 if( pOpen->pNext ){
22434 assert( pOpen->pNext->pPrev==pOpen );
22435 pOpen->pNext->pPrev = pOpen->pPrev;
22532 pLock = pLock->pNext;
22544 pLock->pNext = lockList;
22556 pOpen = pOpen->pNext;
22568 pOpen->pNext = openList;
23002 UnixUnusedFd *pNext;
23003 for(p=pOpen->pUnused; p; p=pNext){
23004 pNext = p->pNext;
23008 p->pNext = pError;
23025 p->pNext = pOpen->pUnused;
25322 pOpen = pOpen->pNext;
25326 for(pp=&pOpen->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
25329 *pp = pUnused->pNext;
27029 0, /* pNext */ \
27049 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
29216 0, /* pNext */
30060 PgHdr *pNext;
30061 for(p=pCache->pDirty; p; p=pNext){
30062 pNext = p->pDirtyNext;
30291 PgHdr1 *pNext; /* Next in hash table chain */
30302 PgFreeslot *pNext; /* Next free slot */
30369 p->pNext = pcache1.pFree;
30389 pcache1.pFree = pcache1.pFree->pNext;
30421 pSlot->pNext = pcache1.pFree;
30516 PgHdr1 *pNext = p->apHash[i];
30517 while( (pPage = pNext)!=0 ){
30519 pNext = pPage->pNext;
30520 pPage->pNext = apNew[h];
30573 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
30574 *pp = (*pp)->pNext;
30613 *pp = pPage->pNext;
30617 pp = &pPage->pNext;
30764 for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
30811 pPage->pNext = pCache->apHash[h];
30891 pp = &(*pp)->pNext;
30893 *pp = pPage->pNext;
30897 pPage->pNext = pCache->apHash[h];
37114 BtLock *pNext; /* Next in BtShared.pLock list */
37150 Btree *pNext; /* List of other sharable Btrees from the same db */
37179 ** mutex, except for nRef and pNext which are accessed under the
37228 BtShared *pNext; /* Next on a list of sharable BtShared structs */
37282 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
37483 ** by all database connections. The p->pNext is a list of other
37486 ** p, then first unlock all of the others on p->pNext, then wait
37494 ** connected by pNext and pPrev should be in sorted order by
37497 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
37499 assert( p->pNext==0 || p->pNext->db==p->db );
37501 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
37533 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
37535 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
37542 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
37623 while( p->locked && ALWAYS(p->pNext) ) p = p->pNext;
37624 for(pLater = p->pNext; pLater; pLater=pLater->pNext){
37631 p = p->pNext;
37943 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
37978 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
38025 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
38089 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
38106 pLock->pNext = pBt->pLock;
38145 *ppIter = pLock->pNext;
38151 ppIter = &pLock->pNext;
38184 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
38224 for(p=pBt->pCursor; p; p=p->pNext){
38250 for(p=pBt->pCursor; p; p=p->pNext){
38399 for(p=pBt->pCursor; p; p=p->pNext){
39070 int pnext, psize, x;
39073 pnext = get2byte(&data[pbegin]);
39075 if( pbegin + psize + 3 >= pnext && pnext>0 ){
39076 int frag = pnext - (pbegin+psize);
39081 x = get2byte(&data[pnext]);
39083 x = pnext + get2byte(&data[pnext+2]) - pbegin;
39524 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
39637 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
39656 p->pNext = pSib;
39660 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
39661 pSib = pSib->pNext;
39663 p->pNext = pSib->pNext;
39665 if( p->pNext ){
39666 p->pNext->pPrev = p;
39668 pSib->pNext = p;
39711 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
39714 while( ALWAYS(pList) && pList->pNext!=pBt ){
39715 pList=pList->pNext;
39718 pList->pNext = pBt->pNext;
39764 pCur = pCur->pNext;
39801 if( p->pPrev ) p->pPrev->pNext = p->pNext;
39802 if( p->pNext ) p->pNext->pPrev = p->pPrev;
40242 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
40296 p->lock.pNext = pBt->pLock;
40884 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
40911 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
41118 pCur->pNext = pBt->pCursor;
41119 if( pCur->pNext ){
41120 pCur->pNext->pPrev = pCur;
41179 for(p=pCur->pBt->pCursor; p; p=p->pNext){
41207 pCur->pPrev->pNext = pCur->pNext;
41209 pBt->pCursor = pCur->pNext;
41211 if( pCur->pNext ){
41212 pCur->pNext->pPrev = pCur->pPrev;
45738 sqlite3_backup *pNext; /* Next backup associated with source pager */
45972 p->pNext = *pp;
46187 pp = &(*pp)->pNext;
46189 *pp = p->pNext;
46241 for(p=pBackup; p; p=p->pNext){
46270 for(p=pBackup; p; p=p->pNext){
47466 p->pNext = db->pVdbe;
47504 pTmp = pA->pNext;
47505 pA->pNext = pB->pNext;
47506 pB->pNext = pTmp;
49283 p = p->pNext;
49747 p->pPrev->pNext = p->pNext;
49750 db->pVdbe = p->pNext;
49752 if( p->pNext ){
49753 p->pNext->pPrev = p->pPrev;
50486 for(p = db->pVdbe; p; p=p->pNext){
51772 sqlite3_stmt *pNext;
51775 pNext = (sqlite3_stmt*)pDb->pVdbe;
51777 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
51780 return pNext;
52525 for(p=db->pSavepoint; p; p=p->pNext) n++;
55008 u.aq.pNew->pNext = db->pSavepoint;
55021 u.aq.pSavepoint = u.aq.pSavepoint->pNext
55046 int isTransaction = u.aq.pSavepoint->pNext==0 && db->isTransactionSavepoint;
55078 db->pSavepoint = u.aq.pTmp->pNext;
55089 db->pSavepoint = u.aq.pSavepoint->pNext;
56923 for(u.br.pVdbe=db->pVdbe; u.br.pVdbe; u.br.pVdbe = u.br.pVdbe->pNext){
58457 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
58961 FileChunk *pNext; /* Next chunk in the journal */
59008 pChunk=pChunk->pNext
59024 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
59061 pNew->pNext = 0;
59064 pChunk->pNext = pNew;
59092 pChunk = pChunk->pNext;
59636 pNC = pNC->pNext;
59706 pTopNC = pTopNC->pNext;
60064 pSelect->pNext = 0;
60066 pSelect->pPrior->pNext = pSelect;
60110 pSelect = pSelect->pNext;
60289 sNC.pNext = pOuterNC;
60350 sNC.pNext = 0;
61994 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
64555 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
64588 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
65199 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
66057 0, /* pNext */
66078 0, /* pNext */
66226 pStep = pStep->pNext;
66873 pIndex->pTable->pIndex = pIndex->pNext;
66879 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
66880 if( ALWAYS(p && p->pNext==pIndex) ){
66881 p->pNext = pIndex->pNext;
66987 Index *pIndex, *pNext;
67003 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
67004 pNext = pIndex->pNext;
67709 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
68397 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68427 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68556 pTrigger = pTrigger->pNext;
68989 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
69155 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
69289 pIndex->pNext = pTab->pIndex;
69293 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
69294 pOther = pOther->pNext;
69296 pIndex->pNext = pOther->pNext;
69297 pOther->pNext = pIndex;
70050 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
70481 assert( pOther!=pDef && pOther->pNext!=pDef );
70482 pDef->pNext = pOther->pNext;
70483 pOther->pNext = pDef;
70485 pDef->pNext = 0;
70539 p = p->pNext;
70559 p = p->pNext;
70932 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
70988 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71049 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
71227 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
73028 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
73963 FKey *pNext; /* Copy of pFKey->pNextFrom */
73965 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
73990 pNext = pFKey->pNextFrom;
74149 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
74198 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
74202 pInfo->pNext = pToplevel->pAinc;
74233 for(p = pParse->pAinc; p; p = p->pNext){
74279 for(p = pParse->pAinc; p; p = p->pNext){
75011 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
75294 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
75425 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
75480 for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
75702 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
75706 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
75776 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
75777 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
77867 pIdx = pIdx->pNext;
78042 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
78080 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
78107 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
79049 pParse->pTriggerPrg = pT->pNext;
80169 pNC = pNC->pNext;
80208 sNC.pNext = pNC;
80243 sNC.pNext = pNC;
82259 pIdx=pIdx->pNext
82915 pLoop->pNext = pRight;
83312 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83746 pTriggerStep = pTriggerStep->pNext;
83759 ** the table. The list is connected by Trigger.pNext pointers.
83786 pTrig->pNext = (pList ? pList : pTab->pTrigger);
83996 pStepList = pStepList->pNext;
84039 pLink->pNext = pTab->pTrigger;
84309 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
84310 *pp = (*pp)->pNext;
84352 for(p=pList; p; p=p->pNext){
84410 for(pStep=pStepList; pStep; pStep=pStep->pNext){
84531 pPrg->pNext = pTop->pTriggerPrg;
84635 pPrg=pPrg->pNext
84740 for(p=pTrigger; p; p=p->pNext){
84799 for(p=pTrigger; p; p=p->pNext){
84995 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85055 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
85060 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
85165 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85172 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85346 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85919 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
85967 VTable *pNext = pVTable->pNext;
85972 pRet->pNext = 0;
85974 pVTable->pNext = db2->pDisconnect;
85977 pVTable = pNext;
86015 VTable *pNext = p->pNext;
86017 p = pNext;
86302 pVTable->pNext = pTab->pVTable;
86526 assert( pTab->pVTable==p && p->pNext==0 );
89011 sPk.pNext = pFirst;
89033 for(; pProbe; pIdx=pProbe=pProbe->pNext){
93846 yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473;
95067 pParse->pAinc = p->pNext;
95906 p->pNext = db->lookaside.pFree;
96041 db->pSavepoint = pTmp->pNext;
96117 FuncDef *pNext, *pHash, *p;
96121 pNext = p->pNext;
96123 p = pNext;
104596 char *pNext; /* Cursor variable */
104601 pNext = pReader->aNode;
104603 pNext = &pReader->aDoclist[pReader->nDoclist];
104606 if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
104634 pNext = pReader->aNode;
104637 pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
104638 pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
104649 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
104651 pNext += nSuffix;
104652 pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
104653 assert( pNext<&pReader->aNode[pReader->nNode] );
104654 pReader->aDoclist = pNext;
107647 ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
107756 RtreeNode *pNext; /* Next node in this hash chain */
107874 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
107884 assert( pNode->pNext==0 );
107886 pNode->pNext = pRtree->aHash[iHash];
107898 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
107899 *pp = pNode->pNext;
107900 pNode->pNext = 0;
107961 pNode->pNext = 0;
109412 RtreeCell *pNext;
109413 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
109415 cellGrowth(pRtree, pBboxLeft, pNext) -
109416 cellGrowth(pRtree, pBboxRight, pNext)
109421 nodeInsertCell(pRtree, pRight, pNext);
109422 cellUnion(pRtree, pBboxRight, pNext);
109424 nodeInsertCell(pRtree, pLeft, pNext);
109425 cellUnion(pRtree, pBboxLeft, pNext);
109634 pNode->pNext = pRtree->pDeleted;
109969 pRtree->pDeleted = pLeaf->pNext;
