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 */
8270 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
8478 FuncDef *pNext; /* Next function with same name */
8543 Savepoint *pNext; /* Parent savepoint (if any) */
8712 VTable *pNext; /* Next in linked list (see above) */
8957 Index *pNext; /* The next index associated with the same table */
9458 ** Each subquery gets a new NameContext. The pNext field points to the
9474 NameContext *pNext; /* Next outer name context. NULL for outermost */
9508 Select *pNext; /* Next select to the left in a compound */
9570 AutoincInfo *pNext; /* Next info block in a list of them all */
9606 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
9743 * pNext member of struct Trigger. A pointer to the first element of the
9761 Trigger *pNext; /* Next trigger associated with the table */
9779 * using the "pNext" member) referenced by the "step_list" member of the
9821 TriggerStep *pNext; /* Next in the link-list */
12277 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
12293 vfsList = pVfs->pNext;
12296 while( p->pNext && p->pNext!=pVfs ){
12297 p = p->pNext;
12299 if( p->pNext==pVfs ){
12300 p->pNext = pVfs->pNext;
12320 pVfs->pNext = vfsList;
12323 pVfs->pNext = vfsList->pNext;
12324 vfsList->pNext = pVfs;
12703 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
12905 pHdr->pNext = 0;
12908 mem.pLast->pNext = pHdr;
12955 assert( pHdr->pPrev->pNext==pHdr );
12956 pHdr->pPrev->pNext = pHdr->pNext;
12959 mem.pFirst = pHdr->pNext;
12961 if( pHdr->pNext ){
12962 assert( pHdr->pNext->pPrev==pHdr );
12963 pHdr->pNext->pPrev = pHdr->pPrev;
13051 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
13073 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
16063 pBuf->pNext = db->lookaside.pFree;
16179 db->lookaside.pFree = pBuf->pNext;
17792 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
21259 0, /* pNext */
21465 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
21972 pNext; /* Next in a list of them all */
22050 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
22064 pNew->pNext = vxworksFileList;
22080 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
22082 *pp = pId->pNext;
22254 struct unixLockInfo *pNext; /* List of all unixLockInfo objects */
22279 struct unixOpenCnt *pNext, *pPrev; /* List of all unixOpenCnt objects */
22395 assert( pLock->pPrev->pNext==pLock );
22396 pLock->pPrev->pNext = pLock->pNext;
22399 lockList = pLock->pNext;
22401 if( pLock->pNext ){
22402 assert( pLock->pNext->pPrev==pLock );
22403 pLock->pNext->pPrev = pLock->pPrev;
22422 assert( pOpen->pPrev->pNext==pOpen );
22423 pOpen->pPrev->pNext = pOpen->pNext;
22426 openList = pOpen->pNext;
22428 if( pOpen->pNext ){
22429 assert( pOpen->pNext->pPrev==pOpen );
22430 pOpen->pNext->pPrev = pOpen->pPrev;
22527 pLock = pLock->pNext;
22539 pLock->pNext = lockList;
22551 pOpen = pOpen->pNext;
22563 pOpen->pNext = openList;
22997 UnixUnusedFd *pNext;
22998 for(p=pOpen->pUnused; p; p=pNext){
22999 pNext = p->pNext;
23003 p->pNext = pError;
23020 p->pNext = pOpen->pUnused;
25317 pOpen = pOpen->pNext;
25321 for(pp=&pOpen->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
25324 *pp = pUnused->pNext;
27024 0, /* pNext */ \
27044 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
29211 0, /* pNext */
30055 PgHdr *pNext;
30056 for(p=pCache->pDirty; p; p=pNext){
30057 pNext = p->pDirtyNext;
30286 PgHdr1 *pNext; /* Next in hash table chain */
30297 PgFreeslot *pNext; /* Next free slot */
30364 p->pNext = pcache1.pFree;
30384 pcache1.pFree = pcache1.pFree->pNext;
30416 pSlot->pNext = pcache1.pFree;
30511 PgHdr1 *pNext = p->apHash[i];
30512 while( (pPage = pNext)!=0 ){
30514 pNext = pPage->pNext;
30515 pPage->pNext = apNew[h];
30568 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
30569 *pp = (*pp)->pNext;
30608 *pp = pPage->pNext;
30612 pp = &pPage->pNext;
30759 for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
30806 pPage->pNext = pCache->apHash[h];
30886 pp = &(*pp)->pNext;
30888 *pp = pPage->pNext;
30892 pPage->pNext = pCache->apHash[h];
37109 BtLock *pNext; /* Next in BtShared.pLock list */
37145 Btree *pNext; /* List of other sharable Btrees from the same db */
37174 ** mutex, except for nRef and pNext which are accessed under the
37223 BtShared *pNext; /* Next on a list of sharable BtShared structs */
37277 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
37478 ** by all database connections. The p->pNext is a list of other
37481 ** p, then first unlock all of the others on p->pNext, then wait
37489 ** connected by pNext and pPrev should be in sorted order by
37492 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
37494 assert( p->pNext==0 || p->pNext->db==p->db );
37496 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
37528 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
37530 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
37537 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
37618 while( p->locked && ALWAYS(p->pNext) ) p = p->pNext;
37619 for(pLater = p->pNext; pLater; pLater=pLater->pNext){
37626 p = p->pNext;
37938 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
37973 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
38020 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
38084 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
38101 pLock->pNext = pBt->pLock;
38140 *ppIter = pLock->pNext;
38146 ppIter = &pLock->pNext;
38179 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
38219 for(p=pBt->pCursor; p; p=p->pNext){
38245 for(p=pBt->pCursor; p; p=p->pNext){
38394 for(p=pBt->pCursor; p; p=p->pNext){
39065 int pnext, psize, x;
39068 pnext = get2byte(&data[pbegin]);
39070 if( pbegin + psize + 3 >= pnext && pnext>0 ){
39071 int frag = pnext - (pbegin+psize);
39076 x = get2byte(&data[pnext]);
39078 x = pnext + get2byte(&data[pnext+2]) - pbegin;
39519 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
39632 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
39651 p->pNext = pSib;
39655 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
39656 pSib = pSib->pNext;
39658 p->pNext = pSib->pNext;
39660 if( p->pNext ){
39661 p->pNext->pPrev = p;
39663 pSib->pNext = p;
39706 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
39709 while( ALWAYS(pList) && pList->pNext!=pBt ){
39710 pList=pList->pNext;
39713 pList->pNext = pBt->pNext;
39759 pCur = pCur->pNext;
39796 if( p->pPrev ) p->pPrev->pNext = p->pNext;
39797 if( p->pNext ) p->pNext->pPrev = p->pPrev;
40231 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
40285 p->lock.pNext = pBt->pLock;
40873 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
40900 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
41107 pCur->pNext = pBt->pCursor;
41108 if( pCur->pNext ){
41109 pCur->pNext->pPrev = pCur;
41168 for(p=pCur->pBt->pCursor; p; p=p->pNext){
41196 pCur->pPrev->pNext = pCur->pNext;
41198 pBt->pCursor = pCur->pNext;
41200 if( pCur->pNext ){
41201 pCur->pNext->pPrev = pCur->pPrev;
45727 sqlite3_backup *pNext; /* Next backup associated with source pager */
45961 p->pNext = *pp;
46176 pp = &(*pp)->pNext;
46178 *pp = p->pNext;
46230 for(p=pBackup; p; p=p->pNext){
46259 for(p=pBackup; p; p=p->pNext){
47455 p->pNext = db->pVdbe;
47493 pTmp = pA->pNext;
47494 pA->pNext = pB->pNext;
47495 pB->pNext = pTmp;
49272 p = p->pNext;
49736 p->pPrev->pNext = p->pNext;
49739 db->pVdbe = p->pNext;
49741 if( p->pNext ){
49742 p->pNext->pPrev = p->pPrev;
50475 for(p = db->pVdbe; p; p=p->pNext){
51761 sqlite3_stmt *pNext;
51764 pNext = (sqlite3_stmt*)pDb->pVdbe;
51766 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
51769 return pNext;
52514 for(p=db->pSavepoint; p; p=p->pNext) n++;
54997 u.aq.pNew->pNext = db->pSavepoint;
55010 u.aq.pSavepoint = u.aq.pSavepoint->pNext
55035 int isTransaction = u.aq.pSavepoint->pNext==0 && db->isTransactionSavepoint;
55067 db->pSavepoint = u.aq.pTmp->pNext;
55078 db->pSavepoint = u.aq.pSavepoint->pNext;
56912 for(u.br.pVdbe=db->pVdbe; u.br.pVdbe; u.br.pVdbe = u.br.pVdbe->pNext){
58446 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
58950 FileChunk *pNext; /* Next chunk in the journal */
58997 pChunk=pChunk->pNext
59013 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
59050 pNew->pNext = 0;
59053 pChunk->pNext = pNew;
59081 pChunk = pChunk->pNext;
59625 pNC = pNC->pNext;
59695 pTopNC = pTopNC->pNext;
60053 pSelect->pNext = 0;
60055 pSelect->pPrior->pNext = pSelect;
60099 pSelect = pSelect->pNext;
60278 sNC.pNext = pOuterNC;
60339 sNC.pNext = 0;
61983 for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
64544 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
64577 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
65188 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
66046 0, /* pNext */
66067 0, /* pNext */
66215 pStep = pStep->pNext;
66862 pIndex->pTable->pIndex = pIndex->pNext;
66868 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
66869 if( ALWAYS(p && p->pNext==pIndex) ){
66870 p->pNext = pIndex->pNext;
66976 Index *pIndex, *pNext;
66992 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
66993 pNext = pIndex->pNext;
67698 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
68386 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68416 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
68545 pTrigger = pTrigger->pNext;
68978 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
69144 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
69278 pIndex->pNext = pTab->pIndex;
69282 while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
69283 pOther = pOther->pNext;
69285 pIndex->pNext = pOther->pNext;
69286 pOther->pNext = pIndex;
70039 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
70470 assert( pOther!=pDef && pOther->pNext!=pDef );
70471 pDef->pNext = pOther->pNext;
70472 pOther->pNext = pDef;
70474 pDef->pNext = 0;
70528 p = p->pNext;
70548 p = p->pNext;
70921 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
70977 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71038 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
71216 for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
73017 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
73952 FKey *pNext; /* Copy of pFKey->pNextFrom */
73954 for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
73979 pNext = pFKey->pNextFrom;
74138 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
74187 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
74191 pInfo->pNext = pToplevel->pAinc;
74222 for(p = pParse->pAinc; p; p = p->pNext){
74268 for(p = pParse->pAinc; p; p = p->pNext){
75000 for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
75283 for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
75414 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
75469 for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
75691 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
75695 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
75765 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
75766 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
77856 pIdx = pIdx->pNext;
78031 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
78069 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
78096 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
79038 pParse->pTriggerPrg = pT->pNext;
80158 pNC = pNC->pNext;
80197 sNC.pNext = pNC;
80232 sNC.pNext = pNC;
82248 pIdx=pIdx->pNext
82904 pLoop->pNext = pRight;
83301 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83735 pTriggerStep = pTriggerStep->pNext;
83748 ** the table. The list is connected by Trigger.pNext pointers.
83775 pTrig->pNext = (pList ? pList : pTab->pTrigger);
83985 pStepList = pStepList->pNext;
84028 pLink->pNext = pTab->pTrigger;
84298 for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
84299 *pp = (*pp)->pNext;
84341 for(p=pList; p; p=p->pNext){
84399 for(pStep=pStepList; pStep; pStep=pStep->pNext){
84520 pPrg->pNext = pTop->pTriggerPrg;
84624 pPrg=pPrg->pNext
84729 for(p=pTrigger; p; p=p->pNext){
84788 for(p=pTrigger; p; p=p->pNext){
84984 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85044 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
85049 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
85154 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85161 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85335 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
85908 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
85956 VTable *pNext = pVTable->pNext;
85961 pRet->pNext = 0;
85963 pVTable->pNext = db2->pDisconnect;
85966 pVTable = pNext;
86004 VTable *pNext = p->pNext;
86006 p = pNext;
86291 pVTable->pNext = pTab->pVTable;
86515 assert( pTab->pVTable==p && p->pNext==0 );
89000 sPk.pNext = pFirst;
89022 for(; pProbe; pIdx=pProbe=pProbe->pNext){
93835 yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473;
95056 pParse->pAinc = p->pNext;
95893 p->pNext = db->lookaside.pFree;
96028 db->pSavepoint = pTmp->pNext;
96104 FuncDef *pNext, *pHash, *p;
96108 pNext = p->pNext;
96110 p = pNext;
104556 char *pNext; /* Cursor variable */
104561 pNext = pReader->aNode;
104563 pNext = &pReader->aDoclist[pReader->nDoclist];
104566 if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
104594 pNext = pReader->aNode;
104597 pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
104598 pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
104609 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
104611 pNext += nSuffix;
104612 pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
104613 assert( pNext<&pReader->aNode[pReader->nNode] );
104614 pReader->aDoclist = pNext;
107607 ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
107716 RtreeNode *pNext; /* Next node in this hash chain */
107834 for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
107844 assert( pNode->pNext==0 );
107846 pNode->pNext = pRtree->aHash[iHash];
107858 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
107859 *pp = pNode->pNext;
107860 pNode->pNext = 0;
107921 pNode->pNext = 0;
109372 RtreeCell *pNext;
109373 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
109375 cellGrowth(pRtree, pBboxLeft, pNext) -
109376 cellGrowth(pRtree, pBboxRight, pNext)
109381 nodeInsertCell(pRtree, pRight, pNext);
109382 cellUnion(pRtree, pBboxRight, pNext);
109384 nodeInsertCell(pRtree, pLeft, pNext);
109385 cellUnion(pRtree, pBboxLeft, pNext);
109594 pNode->pNext = pRtree->pDeleted;
109929 pRtree->pDeleted = pLeaf->pNext;
