Lines Matching refs:pCur
7123 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
58123 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
58124 sqlite3BtreeEnter(pCur->pBtree);
58127 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
58128 sqlite3BtreeLeave(pCur->pBtree);
58608 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
58734 static void btreeReleaseAllCursorPages(BtCursor *pCur){
58736 for(i=0; i<=pCur->iPage; i++){
58737 releasePage(pCur->apPage[i]);
58738 pCur->apPage[i] = 0;
58740 pCur->iPage = -1;
58756 static int saveCursorKey(BtCursor *pCur){
58758 assert( CURSOR_VALID==pCur->eState );
58759 assert( 0==pCur->pKey );
58760 assert( cursorHoldsMutex(pCur) );
58762 if( pCur->curIntKey ){
58764 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
58768 pCur->nKey = sqlite3BtreePayloadSize(pCur);
58769 pKey = sqlite3Malloc( pCur->nKey );
58771 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
58773 pCur->pKey = pKey;
58781 assert( !pCur->curIntKey || !pCur->pKey );
58792 static int saveCursorPosition(BtCursor *pCur){
58795 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
58796 assert( 0==pCur->pKey );
58797 assert( cursorHoldsMutex(pCur) );
58799 if( pCur->eState==CURSOR_SKIPNEXT ){
58800 pCur->eState = CURSOR_VALID;
58802 pCur->skipNext = 0;
58805 rc = saveCursorKey(pCur);
58807 btreeReleaseAllCursorPages(pCur);
58808 pCur->eState = CURSOR_REQUIRESEEK;
58811 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
58881 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
58882 assert( cursorHoldsMutex(pCur) );
58883 sqlite3_free(pCur->pKey);
58884 pCur->pKey = 0;
58885 pCur->eState = CURSOR_INVALID;
58894 BtCursor *pCur, /* Cursor open on the btree to be searched */
58908 pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
58911 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
58913 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
58919 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
58921 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
58933 static int btreeRestoreCursorPosition(BtCursor *pCur){
58936 assert( cursorOwnsBtShared(pCur) );
58937 assert( pCur->eState>=CURSOR_REQUIRESEEK );
58938 if( pCur->eState==CURSOR_FAULT ){
58939 return pCur->skipNext;
58941 pCur->eState = CURSOR_INVALID;
58942 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
58944 sqlite3_free(pCur->pKey);
58945 pCur->pKey = 0;
58946 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
58947 pCur->skipNext |= skipNext;
58948 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
58949 pCur->eState = CURSOR_SKIPNEXT;
58972 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
58973 return pCur->eState!=CURSOR_VALID;
58989 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
58992 assert( pCur!=0 );
58993 assert( pCur->eState!=CURSOR_VALID );
58994 rc = restoreCursorPosition(pCur);
58999 if( pCur->eState!=CURSOR_VALID ){
59002 assert( pCur->skipNext==0 );
59014 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
59022 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
59024 pCur->hints = x;
60123 BtCursor *pCur, /* Cursor to receive the page, or NULL */
60129 assert( pCur==0 || ppPage==&pCur->apPage[pCur->iPage] );
60130 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
60131 assert( pCur==0 || pCur->iPage>0 );
60155 if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
60163 if( pCur ) pCur->iPage--;
60640 BtCursor *pCur;
60645 pCur = pBt->pCursor;
60646 while( pCur ){
60647 BtCursor *pTmp = pCur;
60648 pCur = pCur->pNext;
61145 BtCursor *pCur;
61147 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
61148 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
61149 && pCur->eState!=CURSOR_FAULT ) r++;
62236 BtCursor *pCur /* Space for new cursor */
62271 pCur->pgnoRoot = (Pgno)iTable;
62272 pCur->iPage = -1;
62273 pCur->pKeyInfo = pKeyInfo;
62274 pCur->pBtree = p;
62275 pCur->pBt = pBt;
62276 pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0;
62277 pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY;
62283 pCur->curFlags |= BTCF_Multiple;
62286 pCur->pNext = pBt->pCursor;
62287 pBt->pCursor = pCur;
62288 pCur->eState = CURSOR_INVALID;
62296 BtCursor *pCur /* Write new cursor here */
62303 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
62337 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
62338 Btree *pBtree = pCur->pBtree;
62341 BtShared *pBt = pCur->pBt;
62343 sqlite3BtreeClearCursor(pCur);
62345 if( pBt->pCursor==pCur ){
62346 pBt->pCursor = pCur->pNext;
62350 if( pPrev->pNext==pCur ){
62351 pPrev->pNext = pCur->pNext;
62357 for(i=0; i<=pCur->iPage; i++){
62358 releasePage(pCur->apPage[i]);
62361 sqlite3_free(pCur->aOverflow);
62377 static void assertCellInfo(BtCursor *pCur){
62379 int iPage = pCur->iPage;
62381 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
62382 assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 );
62387 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
62388 if( pCur->info.nSize==0 ){
62389 int iPage = pCur->iPage;
62390 pCur->curFlags |= BTCF_ValidNKey;
62391 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
62393 assertCellInfo(pCur);
62403 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
62404 return pCur && pCur->eState==CURSOR_VALID;
62414 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
62415 assert( cursorHoldsMutex(pCur) );
62416 assert( pCur->eState==CURSOR_VALID );
62417 assert( pCur->curIntKey );
62418 getCellInfo(pCur);
62419 return pCur->info.nKey;
62431 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
62432 assert( cursorHoldsMutex(pCur) );
62433 assert( pCur->eState==CURSOR_VALID );
62434 getCellInfo(pCur);
62435 return pCur->info.nPayload;
62577 BtCursor *pCur, /* Cursor pointing to entry to read from */
62586 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
62587 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
62594 assert( pCur->eState==CURSOR_VALID );
62595 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
62596 assert( cursorHoldsMutex(pCur) );
62599 getCellInfo(pCur);
62600 aPayload = pCur->info.pPayload;
62602 bEnd = offset+amt==pCur->info.nPayload;
62604 assert( offset+amt <= pCur->info.nPayload );
62607 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
62617 if( offset<pCur->info.nLocal ){
62619 if( a+offset>pCur->info.nLocal ){
62620 a = pCur->info.nLocal - offset;
62627 offset -= pCur->info.nLocal;
62635 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
62645 if( eOp!=2 && (pCur->curFlags & BTCF_ValidOvfl)==0 ){
62646 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
62647 if( nOvfl>pCur->nOvflAlloc ){
62649 pCur->aOverflow, nOvfl*2*sizeof(Pgno)
62654 pCur->nOvflAlloc = nOvfl*2;
62655 pCur->aOverflow = aNew;
62659 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
62660 pCur->curFlags |= BTCF_ValidOvfl;
62668 if( (pCur->curFlags & BTCF_ValidOvfl)!=0
62669 && pCur->aOverflow[offset/ovflSize]
62672 nextPage = pCur->aOverflow[iIdx];
62679 if( (pCur->curFlags & BTCF_ValidOvfl)!=0 ){
62680 assert( pCur->aOverflow[iIdx]==0
62681 || pCur->aOverflow[iIdx]==nextPage
62683 pCur->aOverflow[iIdx] = nextPage;
62697 assert( pCur->curFlags & BTCF_ValidOvfl );
62698 assert( pCur->pBtree->db==pBt->db );
62699 if( pCur->aOverflow[iIdx+1] ){
62700 nextPage = pCur->aOverflow[iIdx+1];
62787 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
62788 assert( cursorHoldsMutex(pCur) );
62789 assert( pCur->eState==CURSOR_VALID );
62790 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
62791 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
62792 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
62804 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
62808 if ( pCur->eState==CURSOR_INVALID ){
62813 assert( cursorOwnsBtShared(pCur) );
62814 rc = restoreCursorPosition(pCur);
62816 assert( pCur->eState==CURSOR_VALID );
62817 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
62818 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
62819 rc = accessPayload(pCur, offset, amt, pBuf, 0);
62844 BtCursor *pCur, /* Cursor pointing to entry to read from */
62848 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
62849 assert( pCur->eState==CURSOR_VALID );
62850 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
62851 assert( cursorOwnsBtShared(pCur) );
62852 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
62853 assert( pCur->info.nSize>0 );
62854 assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB );
62855 assert( pCur->info.pPayload<pCur->apPage[pCur->iPage]->aDataEnd ||CORRUPT_DB);
62856 amt = (int)(pCur->apPage[pCur->iPage]->aDataEnd - pCur->info.pPayload);
62857 if( pCur->info.nLocal<amt ) amt = pCur->info.nLocal;
62859 return (void*)pCur->info.pPayload;
62877 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
62878 return fetchPayload(pCur, pAmt);
62891 static int moveToChild(BtCursor *pCur, u32 newPgno){
62892 BtShared *pBt = pCur->pBt;
62894 assert( cursorOwnsBtShared(pCur) );
62895 assert( pCur->eState==CURSOR_VALID );
62896 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
62897 assert( pCur->iPage>=0 );
62898 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
62901 pCur->info.nSize = 0;
62902 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
62903 pCur->iPage++;
62904 pCur->aiIdx[pCur->iPage] = 0;
62905 return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage],
62906 pCur, pCur->curPagerFlags);
62939 static void moveToParent(BtCursor *pCur){
62940 assert( cursorOwnsBtShared(pCur) );
62941 assert( pCur->eState==CURSOR_VALID );
62942 assert( pCur->iPage>0 );
62943 assert( pCur->apPage[pCur->iPage] );
62945 pCur->apPage[pCur->iPage-1],
62946 pCur->aiIdx[pCur->iPage-1],
62947 pCur->apPage[pCur->iPage]->pgno
62949 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
62950 pCur->info.nSize = 0;
62951 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
62952 releasePageNotNull(pCur->apPage[pCur->iPage--]);
62976 static int moveToRoot(BtCursor *pCur){
62980 assert( cursorOwnsBtShared(pCur) );
62984 if( pCur->eState>=CURSOR_REQUIRESEEK ){
62985 if( pCur->eState==CURSOR_FAULT ){
62986 assert( pCur->skipNext!=SQLITE_OK );
62987 return pCur->skipNext;
62989 sqlite3BtreeClearCursor(pCur);
62992 if( pCur->iPage>=0 ){
62993 while( pCur->iPage ){
62994 assert( pCur->apPage[pCur->iPage]!=0 );
62995 releasePageNotNull(pCur->apPage[pCur->iPage--]);
62997 }else if( pCur->pgnoRoot==0 ){
62998 pCur->eState = CURSOR_INVALID;
63001 assert( pCur->iPage==(-1) );
63002 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0],
63003 0, pCur->curPagerFlags);
63005 pCur->eState = CURSOR_INVALID;
63008 pCur->iPage = 0;
63009 pCur->curIntKey = pCur->apPage[0]->intKey;
63011 pRoot = pCur->apPage[0];
63012 assert( pRoot->pgno==pCur->pgnoRoot );
63025 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
63029 pCur->aiIdx[0] = 0;
63030 pCur->info.nSize = 0;
63031 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
63034 pCur->eState = CURSOR_VALID;
63039 pCur->eState = CURSOR_VALID;
63040 rc = moveToChild(pCur, subpage);
63042 pCur->eState = CURSOR_INVALID;
63054 static int moveToLeftmost(BtCursor *pCur){
63059 assert( cursorOwnsBtShared(pCur) );
63060 assert( pCur->eState==CURSOR_VALID );
63061 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
63062 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
63063 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
63064 rc = moveToChild(pCur, pgno);
63079 static int moveToRightmost(BtCursor *pCur){
63084 assert( cursorOwnsBtShared(pCur) );
63085 assert( pCur->eState==CURSOR_VALID );
63086 while( !(pPage = pCur->apPage[pCur->iPage])->leaf ){
63088 pCur->aiIdx[pCur->iPage] = pPage->nCell;
63089 rc = moveToChild(pCur, pgno);
63092 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
63093 assert( pCur->info.nSize==0 );
63094 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
63102 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
63105 assert( cursorOwnsBtShared(pCur) );
63106 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
63107 rc = moveToRoot(pCur);
63109 if( pCur->eState==CURSOR_INVALID ){
63110 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
63113 assert( pCur->apPage[pCur->iPage]->nCell>0 );
63115 rc = moveToLeftmost(pCur);
63125 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
63128 assert( cursorOwnsBtShared(pCur) );
63129 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
63132 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
63137 for(ii=0; ii<pCur->iPage; ii++){
63138 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
63140 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
63141 assert( pCur->apPage[pCur->iPage]->leaf );
63146 rc = moveToRoot(pCur);
63148 if( CURSOR_INVALID==pCur->eState ){
63149 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
63152 assert( pCur->eState==CURSOR_VALID );
63154 rc = moveToRightmost(pCur);
63156 pCur->curFlags |= BTCF_AtLast;
63158 pCur->curFlags &= ~BTCF_AtLast;
63197 BtCursor *pCur, /* The cursor to be moved */
63206 assert( cursorOwnsBtShared(pCur) );
63207 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
63209 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
63210 assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
63215 && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
63217 if( pCur->info.nKey==intKey ){
63221 if( (pCur->curFlags & BTCF_AtLast)!=0 && pCur->info.nKey<intKey ){
63238 rc = moveToRoot(pCur);
63242 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
63243 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
63244 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
63245 if( pCur->eState==CURSOR_INVALID ){
63247 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
63250 assert( pCur->apPage[0]->intKey==pCur->curIntKey );
63251 assert( pCur->curIntKey || pIdxKey );
63255 MemPage *pPage = pCur->apPage[pCur->iPage];
63270 pCur->aiIdx[pCur->iPage] = (u16)idx;
63289 pCur->curFlags |= BTCF_ValidNKey;
63290 pCur->info.nKey = nCellKey;
63291 pCur->aiIdx[pCur->iPage] = (u16)idx;
63343 pPage->xParseCell(pPage, pCellBody, &pCur->info);
63344 nCell = (int)pCur->info.nKey;
63358 pCur->aiIdx[pCur->iPage] = (u16)idx;
63359 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 2);
63369 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
63379 pCur->aiIdx[pCur->iPage] = (u16)idx;
63391 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
63392 pCur->aiIdx[pCur->iPage] = (u16)idx;
63403 pCur->aiIdx[pCur->iPage] = (u16)lwr;
63404 rc = moveToChild(pCur, chldPg);
63408 pCur->info.nSize = 0;
63409 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
63421 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
63426 return (CURSOR_VALID!=pCur->eState);
63450 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){
63455 assert( cursorOwnsBtShared(pCur) );
63456 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
63458 if( pCur->eState!=CURSOR_VALID ){
63459 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
63460 rc = restoreCursorPosition(pCur);
63464 if( CURSOR_INVALID==pCur->eState ){
63468 if( pCur->skipNext ){
63469 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
63470 pCur->eState = CURSOR_VALID;
63471 if( pCur->skipNext>0 ){
63472 pCur->skipNext = 0;
63475 pCur->skipNext = 0;
63479 pPage = pCur->apPage[pCur->iPage];
63480 idx = ++pCur->aiIdx[pCur->iPage];
63492 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
63494 return moveToLeftmost(pCur);
63497 if( pCur->iPage==0 ){
63499 pCur->eState = CURSOR_INVALID;
63502 moveToParent(pCur);
63503 pPage = pCur->apPage[pCur->iPage];
63504 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
63506 return sqlite3BtreeNext(pCur, pRes);
63514 return moveToLeftmost(pCur);
63517 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
63519 assert( cursorOwnsBtShared(pCur) );
63522 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
63523 pCur->info.nSize = 0;
63524 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
63526 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur, pRes);
63527 pPage = pCur->apPage[pCur->iPage];
63528 if( (++pCur->aiIdx[pCur->iPage])>=pPage->nCell ){
63529 pCur->aiIdx[pCur->iPage]--;
63530 return btreeNext(pCur, pRes);
63535 return moveToLeftmost(pCur);
63560 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){
63564 assert( cursorOwnsBtShared(pCur) );
63567 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
63568 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
63569 assert( pCur->info.nSize==0 );
63570 if( pCur->eState!=CURSOR_VALID ){
63571 rc = restoreCursorPosition(pCur);
63575 if( CURSOR_INVALID==pCur->eState ){
63579 if( pCur->skipNext ){
63580 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
63581 pCur->eState = CURSOR_VALID;
63582 if( pCur->skipNext<0 ){
63583 pCur->skipNext = 0;
63586 pCur->skipNext = 0;
63590 pPage = pCur->apPage[pCur->iPage];
63593 int idx = pCur->aiIdx[pCur->iPage];
63594 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
63596 rc = moveToRightmost(pCur);
63598 while( pCur->aiIdx[pCur->iPage]==0 ){
63599 if( pCur->iPage==0 ){
63600 pCur->eState = CURSOR_INVALID;
63604 moveToParent(pCur);
63606 assert( pCur->info.nSize==0 );
63607 assert( (pCur->curFlags & (BTCF_ValidNKey|BTCF_ValidOvfl))==0 );
63609 pCur->aiIdx[pCur->iPage]--;
63610 pPage = pCur->apPage[pCur->iPage];
63612 rc = sqlite3BtreePrevious(pCur, pRes);
63619 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
63620 assert( cursorOwnsBtShared(pCur) );
63623 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
63625 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
63626 pCur->info.nSize = 0;
63627 if( pCur->eState!=CURSOR_VALID
63628 || pCur->aiIdx[pCur->iPage]==0
63629 || pCur->apPage[pCur->iPage]->leaf==0
63631 return btreePrevious(pCur, pRes);
63633 pCur->aiIdx[pCur->iPage]--;
65933 static int balance(BtCursor *pCur){
65935 const int nMin = pCur->pBt->usableSize * 2 / 3;
65943 int iPage = pCur->iPage;
65944 MemPage *pPage = pCur->apPage[iPage];
65955 rc = balance_deeper(pPage, &pCur->apPage[1]);
65957 pCur->iPage = 1;
65958 pCur->aiIdx[0] = 0;
65959 pCur->aiIdx[1] = 0;
65960 assert( pCur->apPage[1]->nOverflow );
65968 MemPage * const pParent = pCur->apPage[iPage-1];
65969 int const iIdx = pCur->aiIdx[iPage-1];
66016 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
66018 pCur->hints&BTREE_BULKLOAD);
66038 pCur->iPage--;
66039 assert( pCur->iPage>=0 );
66079 BtCursor *pCur, /* Insert data into the table of this cursor */
66089 Btree *p = pCur->pBtree;
66094 if( pCur->eState==CURSOR_FAULT ){
66095 assert( pCur->skipNext!=SQLITE_OK );
66096 return pCur->skipNext;
66099 assert( cursorOwnsBtShared(pCur) );
66100 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
66103 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
66110 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
66123 if( pCur->curFlags & BTCF_Multiple ){
66124 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
66128 if( pCur->pKeyInfo==0 ){
66137 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey>0
66138 && pCur->info.nKey==pX->nKey-1 ){
66141 rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, appendBias, &loc);
66145 rc = btreeMoveto(pCur, pX->pKey, pX->nKey, appendBias, &loc);
66148 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
66150 pPage = pCur->apPage[pCur->iPage];
66155 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
66164 idx = pCur->aiIdx[pCur->iPage];
66181 idx = ++pCur->aiIdx[pCur->iPage];
66209 pCur->info.nSize = 0;
66212 pCur->curFlags &= ~(BTCF_ValidNKey);
66213 rc = balance(pCur);
66219 pCur->apPage[pCur->iPage]->nOverflow = 0;
66220 pCur->eState = CURSOR_INVALID;
66222 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
66245 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
66246 Btree *p = pCur->pBtree;
66257 assert( cursorOwnsBtShared(pCur) );
66260 assert( pCur->curFlags & BTCF_WriteFlag );
66261 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
66262 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
66263 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
66264 assert( pCur->eState==CURSOR_VALID );
66267 iCellDepth = pCur->iPage;
66268 iCellIdx = pCur->aiIdx[iCellDepth];
66269 pPage = pCur->apPage[iCellDepth];
66287 rc = saveCursorKey(pCur);
66303 rc = sqlite3BtreePrevious(pCur, ¬Used);
66309 if( pCur->curFlags & BTCF_Multiple ){
66310 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
66316 if( pCur->pKeyInfo==0 ){
66317 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
66335 MemPage *pLeaf = pCur->apPage[pCur->iPage];
66337 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
66369 rc = balance(pCur);
66370 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
66371 while( pCur->iPage>iCellDepth ){
66372 releasePage(pCur->apPage[pCur->iPage--]);
66374 rc = balance(pCur);
66379 assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
66380 assert( pPage==pCur->apPage[pCur->iPage] || CORRUPT_DB );
66382 pCur->eState = CURSOR_SKIPNEXT;
66384 pCur->skipNext = -1;
66385 pCur->aiIdx[iCellDepth] = pPage->nCell-1;
66387 pCur->skipNext = 1;
66390 rc = moveToRoot(pCur);
66392 pCur->eState = CURSOR_REQUIRESEEK;
66656 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
66657 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
66874 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
66878 if( pCur->pgnoRoot==0 ){
66882 rc = moveToRoot(pCur);
66895 pPage = pCur->apPage[pCur->iPage];
66912 if( pCur->iPage==0 ){
66915 return moveToRoot(pCur);
66917 moveToParent(pCur);
66918 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
66920 pCur->aiIdx[pCur->iPage]++;
66921 pPage = pCur->apPage[pCur->iPage];
66927 iIdx = pCur->aiIdx[pCur->iPage];
66929 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
66931 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
67769 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
67770 pCur->curFlags |= BTCF_Incrblob;
67771 pCur->pBtree->hasIncrblobCur = 1;
69603 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
69613 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
69615 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
69629 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
69639 assert( sqlite3BtreeCursorIsValid(pCur) );
69645 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
69653 rc = vdbeMemFromBtreeResize(pCur, offset, amt, key, pMem);
74663 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
74676 assert( sqlite3BtreeCursorIsValid(pCur) );
74677 nCellKey = sqlite3BtreePayloadSize(pCur);
74682 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
74748 BtCursor *pCur;
74752 pCur = pC->uc.pCursor;
74753 assert( sqlite3BtreeCursorIsValid(pCur) );
74754 nCellKey = sqlite3BtreePayloadSize(pCur);
74762 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
80478 VdbeCursor *pCur;
80483 pCur = p->apCsr[pOp->p1];
80484 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
80485 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
80547 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
80548 if( pCur==0 ) goto no_mem;
80549 pCur->nullRow = 1;
80550 pCur->isOrdered = 1;
80551 pCur->pgnoRoot = p2;
80553 pCur->wrFlag = wrFlag;
80555 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
80556 pCur->pKeyInfo = pKeyInfo;
80561 pCur->isTable = pOp->p4type!=P4_KEYINFO;
80570 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
83568 VdbeCursor *pCur;
83574 pCur = 0;
83590 pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
83591 if( pCur ){
83592 pCur->uc.pVCur = pVCur;
83631 VdbeCursor *pCur;
83638 pCur = p->apCsr[pOp->p1];
83641 assert( pCur->eCurType==CURTYPE_VTAB );
83642 pVCur = pCur->uc.pVCur;
83661 pCur->nullRow = 0;
83682 VdbeCursor *pCur = p->apCsr[pOp->p1];
83683 assert( pCur->eCurType==CURTYPE_VTAB );
83687 if( pCur->nullRow ){
83691 pVtab = pCur->uc.pVCur->pVtab;
83697 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
83725 VdbeCursor *pCur;
83728 pCur = p->apCsr[pOp->p1];
83729 assert( pCur->eCurType==CURTYPE_VTAB );
83730 if( pCur->nullRow ){
83733 pVtab = pCur->uc.pVCur->pVtab;
83743 rc = pModule->xNext(pCur->uc.pVCur);
83746 res = pModule->xEof(pCur->uc.pVCur);
161131 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
161132 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
161138 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
161140 int ii = 1 - pCur->bPoint;
161142 assert( pCur->bPoint || pCur->nPoint );
161143 if( pCur->aNode[ii]==0 ){
161145 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
161146 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
161148 return pCur->aNode[ii];
161155 RtreeCursor *pCur, /* The cursor */
161161 if( pCur->nPoint>=pCur->nPointAlloc ){
161162 int nNew = pCur->nPointAlloc*2 + 8;
161163 pNew = sqlite3_realloc(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
161165 pCur->aPoint = pNew;
161166 pCur->nPointAlloc = nNew;
161168 i = pCur->nPoint++;
161169 pNew = pCur->aPoint + i;
161176 pParent = pCur->aPoint + j;
161178 rtreeSearchPointSwap(pCur, j, i);
161190 RtreeCursor *pCur, /* The cursor */
161195 pFirst = rtreeSearchPointFirst(pCur);
161196 pCur->anQueue[iLevel]++;
161201 if( pCur->bPoint ){
161203 pNew = rtreeEnqueue(pCur, rScore, iLevel);
161205 ii = (int)(pNew - pCur->aPoint) + 1;
161207 assert( pCur->aNode[ii]==0 );
161208 pCur->aNode[ii] = pCur->aNode[0];
161210 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
161212 pCur->aNode[0] = 0;
161213 *pNew = pCur->sPoint;
161215 pCur->sPoint.rScore = rScore;
161216 pCur->sPoint.iLevel = iLevel;
161217 pCur->bPoint = 1;
161218 return &pCur->sPoint;
161220 return rtreeEnqueue(pCur, rScore, iLevel);
161226 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
161233 printf(" %p\n", pCur->aNode[idx]);
161238 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
161241 if( pCur->bPoint ){
161242 tracePoint(&pCur->sPoint, -1, pCur);
161244 for(ii=0; ii<pCur->nPoint; ii++){
161245 if( ii>0 || pCur->bPoint ) printf(" ");
161246 tracePoint(&pCur->aPoint[ii], ii, pCur);
161304 static int rtreeStepToLeaf(RtreeCursor *pCur){
161306 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
161311 int nConstraint = pCur->nConstraint;
161317 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
161318 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
161327 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
161350 RTREE_QUEUE_TRACE(pCur, "POP-S:");
161351 rtreeSearchPointPop(pCur);
161354 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
161359 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
161363 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
161364 rtreeSearchPointPop(pCur);
161367 pCur->atEOF = p==0;
176739 JsonEachCursor *pCur;
176742 pCur = sqlite3_malloc( sizeof(*pCur) );
176743 if( pCur==0 ) return SQLITE_NOMEM;
176744 memset(pCur, 0, sizeof(*pCur));
176745 *ppCursor = &pCur->base;
176753 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
176754 pCur->bRecursive = 1;
