Lines Matching refs:pCur
6422 ** ^The current value of the requested parameter is written into *pCur
6432 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
51434 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
51435 sqlite3BtreeEnter(pCur->pBtree);
51437 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
51438 sqlite3BtreeLeave(pCur->pBtree);
52012 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
52134 static void btreeReleaseAllCursorPages(BtCursor *pCur){
52136 for(i=0; i<=pCur->iPage; i++){
52137 releasePage(pCur->apPage[i]);
52138 pCur->apPage[i] = 0;
52140 pCur->iPage = -1;
52151 static int saveCursorPosition(BtCursor *pCur){
52154 assert( CURSOR_VALID==pCur->eState );
52155 assert( 0==pCur->pKey );
52156 assert( cursorHoldsMutex(pCur) );
52158 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
52162 ** stores the integer key in pCur->nKey. In this case this value is
52163 ** all that is required. Otherwise, if pCur is not open on an intKey
52164 ** table, then malloc space for and store the pCur->nKey bytes of key
52167 if( 0==pCur->apPage[0]->intKey ){
52168 void *pKey = sqlite3Malloc( (int)pCur->nKey );
52170 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
52172 pCur->pKey = pKey;
52180 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
52183 btreeReleaseAllCursorPages(pCur);
52184 pCur->eState = CURSOR_REQUIRESEEK;
52187 invalidateOverflowCache(pCur);
52219 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
52220 assert( cursorHoldsMutex(pCur) );
52221 sqlite3_free(pCur->pKey);
52222 pCur->pKey = 0;
52223 pCur->eState = CURSOR_INVALID;
52232 BtCursor *pCur, /* Cursor open on the btree to be searched */
52246 pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
52249 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
52251 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
52257 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
52259 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
52271 static int btreeRestoreCursorPosition(BtCursor *pCur){
52273 assert( cursorHoldsMutex(pCur) );
52274 assert( pCur->eState>=CURSOR_REQUIRESEEK );
52275 if( pCur->eState==CURSOR_FAULT ){
52276 return pCur->skipNext;
52278 pCur->eState = CURSOR_INVALID;
52279 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
52281 sqlite3_free(pCur->pKey);
52282 pCur->pKey = 0;
52283 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
52284 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
52285 pCur->eState = CURSOR_SKIPNEXT;
52312 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
52315 if( pCur->eState==CURSOR_VALID ){
52319 rc = restoreCursorPosition(pCur);
52324 if( pCur->eState!=CURSOR_VALID || NEVER(pCur->skipNext!=0) ){
53652 BtCursor *pCur;
53657 pCur = pBt->pCursor;
53658 while( pCur ){
53659 BtCursor *pTmp = pCur;
53660 pCur = pCur->pNext;
54116 BtCursor *pCur;
54118 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
54119 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
54120 && pCur->eState!=CURSOR_FAULT ) r++;
55154 ** on pCur to initialize the memory space prior to invoking this routine.
55161 BtCursor *pCur /* Space for new cursor */
55190 pCur->pgnoRoot = (Pgno)iTable;
55191 pCur->iPage = -1;
55192 pCur->pKeyInfo = pKeyInfo;
55193 pCur->pBtree = p;
55194 pCur->pBt = pBt;
55196 pCur->curFlags = wrFlag;
55197 pCur->pNext = pBt->pCursor;
55198 if( pCur->pNext ){
55199 pCur->pNext->pPrev = pCur;
55201 pBt->pCursor = pCur;
55202 pCur->eState = CURSOR_INVALID;
55210 BtCursor *pCur /* Write new cursor here */
55214 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
55247 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
55248 Btree *pBtree = pCur->pBtree;
55251 BtShared *pBt = pCur->pBt;
55253 sqlite3BtreeClearCursor(pCur);
55254 if( pCur->pPrev ){
55255 pCur->pPrev->pNext = pCur->pNext;
55257 pBt->pCursor = pCur->pNext;
55259 if( pCur->pNext ){
55260 pCur->pNext->pPrev = pCur->pPrev;
55262 for(i=0; i<=pCur->iPage; i++){
55263 releasePage(pCur->apPage[i]);
55266 sqlite3DbFree(pBtree->db, pCur->aOverflow);
55267 /* sqlite3_free(pCur); */
55289 static void assertCellInfo(BtCursor *pCur){
55291 int iPage = pCur->iPage;
55293 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
55294 assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 );
55301 static void getCellInfo(BtCursor *pCur){
55302 if( pCur->info.nSize==0 ){
55303 int iPage = pCur->iPage;
55304 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
55305 pCur->curFlags |= BTCF_ValidNKey;
55307 assertCellInfo(pCur);
55312 #define getCellInfo(pCur) \
55313 if( pCur->info.nSize==0 ){ \
55314 int iPage = pCur->iPage; \
55315 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
55316 pCur->curFlags |= BTCF_ValidNKey; \
55318 assertCellInfo(pCur); \
55328 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
55329 return pCur && pCur->eState==CURSOR_VALID;
55345 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
55346 assert( cursorHoldsMutex(pCur) );
55347 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
55348 if( pCur->eState!=CURSOR_VALID ){
55351 getCellInfo(pCur);
55352 *pSize = pCur->info.nKey;
55369 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
55370 assert( cursorHoldsMutex(pCur) );
55371 assert( pCur->eState==CURSOR_VALID );
55372 getCellInfo(pCur);
55373 *pSize = pCur->info.nData;
55487 ** for the entry that the pCur cursor is pointing to. The eOp
55516 BtCursor *pCur, /* Cursor pointing to entry to read from */
55526 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
55527 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
55533 assert( pCur->eState==CURSOR_VALID );
55534 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
55535 assert( cursorHoldsMutex(pCur) );
55538 getCellInfo(pCur);
55539 aPayload = pCur->info.pCell + pCur->info.nHeader;
55540 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
55542 bEnd = (offset+amt==nKey+pCur->info.nData);
55545 if( NEVER(offset+amt > nKey+pCur->info.nData)
55546 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
55553 if( offset<pCur->info.nLocal ){
55555 if( a+offset>pCur->info.nLocal ){
55556 a = pCur->info.nLocal - offset;
55563 offset -= pCur->info.nLocal;
55570 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
55580 if( eOp!=2 && (pCur->curFlags & BTCF_ValidOvfl)==0 ){
55581 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
55582 if( nOvfl>pCur->nOvflAlloc ){
55584 pCur->pBtree->db, pCur->aOverflow, nOvfl*2*sizeof(Pgno)
55589 pCur->nOvflAlloc = nOvfl*2;
55590 pCur->aOverflow = aNew;
55594 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
55595 pCur->curFlags |= BTCF_ValidOvfl;
55603 if( (pCur->curFlags & BTCF_ValidOvfl)!=0 && pCur->aOverflow[offset/ovflSize] ){
55605 nextPage = pCur->aOverflow[iIdx];
55612 if( (pCur->curFlags & BTCF_ValidOvfl)!=0 ){
55613 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
55614 pCur->aOverflow[iIdx] = nextPage;
55628 assert( pCur->curFlags & BTCF_ValidOvfl );
55629 if( pCur->aOverflow[iIdx+1] ){
55630 nextPage = pCur->aOverflow[iIdx+1];
55703 ** Read part of the key associated with cursor pCur. Exactly
55707 ** The caller must ensure that pCur is pointing to a valid row
55714 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
55715 assert( cursorHoldsMutex(pCur) );
55716 assert( pCur->eState==CURSOR_VALID );
55717 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
55718 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55719 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
55723 ** Read part of the data associated with cursor pCur. Exactly
55731 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
55735 if ( pCur->eState==CURSOR_INVALID ){
55740 assert( cursorHoldsMutex(pCur) );
55741 rc = restoreCursorPosition(pCur);
55743 assert( pCur->eState==CURSOR_VALID );
55744 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
55745 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55746 rc = accessPayload(pCur, offset, amt, pBuf, 0);
55753 ** pCur cursor is pointing to. The pointer is to the beginning of
55771 BtCursor *pCur, /* Cursor pointing to entry to read from */
55774 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
55775 assert( pCur->eState==CURSOR_VALID );
55776 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
55777 assert( cursorHoldsMutex(pCur) );
55778 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55779 assert( pCur->info.nSize>0 );
55780 *pAmt = pCur->info.nLocal;
55781 return (void*)(pCur->info.pCell + pCur->info.nHeader);
55786 ** For the entry that cursor pCur is point to, return as
55799 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){
55800 return fetchPayload(pCur, pAmt);
55802 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
55803 return fetchPayload(pCur, pAmt);
55816 static int moveToChild(BtCursor *pCur, u32 newPgno){
55818 int i = pCur->iPage;
55820 BtShared *pBt = pCur->pBt;
55822 assert( cursorHoldsMutex(pCur) );
55823 assert( pCur->eState==CURSOR_VALID );
55824 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
55825 assert( pCur->iPage>=0 );
55826 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
55830 (pCur->curFlags & BTCF_WriteFlag)==0 ? PAGER_GET_READONLY : 0);
55832 pCur->apPage[i+1] = pNewPage;
55833 pCur->aiIdx[i+1] = 0;
55834 pCur->iPage++;
55836 pCur->info.nSize = 0;
55837 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
55838 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
55867 ** pCur->idx is set to the cell index that contains the pointer
55869 ** right-most child page then pCur->idx is set to one more than
55872 static void moveToParent(BtCursor *pCur){
55873 assert( cursorHoldsMutex(pCur) );
55874 assert( pCur->eState==CURSOR_VALID );
55875 assert( pCur->iPage>0 );
55876 assert( pCur->apPage[pCur->iPage] );
55885 pCur->apPage[pCur->iPage-1],
55886 pCur->aiIdx[pCur->iPage-1],
55887 pCur->apPage[pCur->iPage]->pgno
55890 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
55892 releasePage(pCur->apPage[pCur->iPage]);
55893 pCur->iPage--;
55894 pCur->info.nSize = 0;
55895 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
55919 static int moveToRoot(BtCursor *pCur){
55923 assert( cursorHoldsMutex(pCur) );
55927 if( pCur->eState>=CURSOR_REQUIRESEEK ){
55928 if( pCur->eState==CURSOR_FAULT ){
55929 assert( pCur->skipNext!=SQLITE_OK );
55930 return pCur->skipNext;
55932 sqlite3BtreeClearCursor(pCur);
55935 if( pCur->iPage>=0 ){
55936 while( pCur->iPage ) releasePage(pCur->apPage[pCur->iPage--]);
55937 }else if( pCur->pgnoRoot==0 ){
55938 pCur->eState = CURSOR_INVALID;
55941 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0],
55942 (pCur->curFlags & BTCF_WriteFlag)==0 ? PAGER_GET_READONLY : 0);
55944 pCur->eState = CURSOR_INVALID;
55947 pCur->iPage = 0;
55949 pRoot = pCur->apPage[0];
55950 assert( pRoot->pgno==pCur->pgnoRoot );
55952 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
55959 ** if pCur->iPage>=0). But this is not so if the database is corrupted
55963 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
55967 pCur->aiIdx[0] = 0;
55968 pCur->info.nSize = 0;
55969 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
55972 pCur->eState = CURSOR_VALID;
55977 pCur->eState = CURSOR_VALID;
55978 rc = moveToChild(pCur, subpage);
55980 pCur->eState = CURSOR_INVALID;
55992 static int moveToLeftmost(BtCursor *pCur){
55997 assert( cursorHoldsMutex(pCur) );
55998 assert( pCur->eState==CURSOR_VALID );
55999 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
56000 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
56001 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
56002 rc = moveToChild(pCur, pgno);
56017 static int moveToRightmost(BtCursor *pCur){
56022 assert( cursorHoldsMutex(pCur) );
56023 assert( pCur->eState==CURSOR_VALID );
56024 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
56026 pCur->aiIdx[pCur->iPage] = pPage->nCell;
56027 rc = moveToChild(pCur, pgno);
56030 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
56031 pCur->info.nSize = 0;
56032 pCur->curFlags &= ~BTCF_ValidNKey;
56041 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
56044 assert( cursorHoldsMutex(pCur) );
56045 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
56046 rc = moveToRoot(pCur);
56048 if( pCur->eState==CURSOR_INVALID ){
56049 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56052 assert( pCur->apPage[pCur->iPage]->nCell>0 );
56054 rc = moveToLeftmost(pCur);
56064 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
56067 assert( cursorHoldsMutex(pCur) );
56068 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
56071 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
56076 for(ii=0; ii<pCur->iPage; ii++){
56077 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
56079 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
56080 assert( pCur->apPage[pCur->iPage]->leaf );
56085 rc = moveToRoot(pCur);
56087 if( CURSOR_INVALID==pCur->eState ){
56088 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56091 assert( pCur->eState==CURSOR_VALID );
56093 rc = moveToRightmost(pCur);
56095 pCur->curFlags |= BTCF_AtLast;
56097 pCur->curFlags &= ~BTCF_AtLast;
56134 BtCursor *pCur, /* The cursor to be moved */
56143 assert( cursorHoldsMutex(pCur) );
56144 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
56146 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
56150 if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
56151 && pCur->apPage[0]->intKey
56153 if( pCur->info.nKey==intKey ){
56157 if( (pCur->curFlags & BTCF_AtLast)!=0 && pCur->info.nKey<intKey ){
56174 rc = moveToRoot(pCur);
56178 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
56179 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
56180 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
56181 if( pCur->eState==CURSOR_INVALID ){
56183 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56186 assert( pCur->apPage[0]->intKey || pIdxKey );
56190 MemPage *pPage = pCur->apPage[pCur->iPage];
56205 pCur->aiIdx[pCur->iPage] = (u16)idx;
56224 pCur->curFlags |= BTCF_ValidNKey;
56225 pCur->info.nKey = nCellKey;
56226 pCur->aiIdx[pCur->iPage] = (u16)idx;
56273 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
56274 nCell = (int)pCur->info.nKey;
56280 pCur->aiIdx[pCur->iPage] = (u16)idx;
56281 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 2);
56298 pCur->aiIdx[pCur->iPage] = (u16)idx;
56310 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
56311 pCur->aiIdx[pCur->iPage] = (u16)idx;
56322 pCur->aiIdx[pCur->iPage] = (u16)lwr;
56323 rc = moveToChild(pCur, chldPg);
56327 pCur->info.nSize = 0;
56328 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
56340 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
56345 return (CURSOR_VALID!=pCur->eState);
56363 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
56368 assert( cursorHoldsMutex(pCur) );
56371 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
56372 if( pCur->eState!=CURSOR_VALID ){
56373 invalidateOverflowCache(pCur);
56374 rc = restoreCursorPosition(pCur);
56379 if( CURSOR_INVALID==pCur->eState ){
56383 if( pCur->skipNext ){
56384 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
56385 pCur->eState = CURSOR_VALID;
56386 if( pCur->skipNext>0 ){
56387 pCur->skipNext = 0;
56391 pCur->skipNext = 0;
56395 pPage = pCur->apPage[pCur->iPage];
56396 idx = ++pCur->aiIdx[pCur->iPage];
56401 ** the page while cursor pCur is holding a reference to it. Which can
56406 pCur->info.nSize = 0;
56407 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
56410 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
56415 rc = moveToLeftmost(pCur);
56420 if( pCur->iPage==0 ){
56422 pCur->eState = CURSOR_INVALID;
56425 moveToParent(pCur);
56426 pPage = pCur->apPage[pCur->iPage];
56427 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
56430 rc = sqlite3BtreeNext(pCur, pRes);
56440 rc = moveToLeftmost(pCur);
56460 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
56464 assert( cursorHoldsMutex(pCur) );
56467 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
56468 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl);
56469 if( pCur->eState!=CURSOR_VALID ){
56470 if( ALWAYS(pCur->eState>=CURSOR_REQUIRESEEK) ){
56471 rc = btreeRestoreCursorPosition(pCur);
56477 if( CURSOR_INVALID==pCur->eState ){
56481 if( pCur->skipNext ){
56482 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
56483 pCur->eState = CURSOR_VALID;
56484 if( pCur->skipNext<0 ){
56485 pCur->skipNext = 0;
56489 pCur->skipNext = 0;
56493 pPage = pCur->apPage[pCur->iPage];
56496 int idx = pCur->aiIdx[pCur->iPage];
56497 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
56502 rc = moveToRightmost(pCur);
56504 while( pCur->aiIdx[pCur->iPage]==0 ){
56505 if( pCur->iPage==0 ){
56506 pCur->eState = CURSOR_INVALID;
56510 moveToParent(pCur);
56512 pCur->info.nSize = 0;
56513 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
56515 pCur->aiIdx[pCur->iPage]--;
56516 pPage = pCur->apPage[pCur->iPage];
56518 rc = sqlite3BtreePrevious(pCur, pRes);
58371 ** The page that pCur currently points to has just been modified in
58380 static int balance(BtCursor *pCur){
58382 const int nMin = pCur->pBt->usableSize * 2 / 3;
58390 int iPage = pCur->iPage;
58391 MemPage *pPage = pCur->apPage[iPage];
58401 rc = balance_deeper(pPage, &pCur->apPage[1]);
58403 pCur->iPage = 1;
58404 pCur->aiIdx[0] = 0;
58405 pCur->aiIdx[1] = 0;
58406 assert( pCur->apPage[1]->nOverflow );
58414 MemPage * const pParent = pCur->apPage[iPage-1];
58415 int const iIdx = pCur->aiIdx[iPage-1];
58461 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
58462 rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1, pCur->hints);
58482 pCur->iPage--;
58503 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
58505 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
58506 ** a positive value if pCur points at an etry that is larger than
58510 ** cursor pCur is pointing at the existing copy of a row that is to be
58511 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
58516 BtCursor *pCur, /* Insert data into the table of this cursor */
58528 Btree *p = pCur->pBtree;
58533 if( pCur->eState==CURSOR_FAULT ){
58534 assert( pCur->skipNext!=SQLITE_OK );
58535 return pCur->skipNext;
58538 assert( cursorHoldsMutex(pCur) );
58539 assert( (pCur->curFlags & BTCF_WriteFlag)!=0 && pBt->inTransaction==TRANS_WRITE
58541 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
58548 assert( (pKey==0)==(pCur->pKeyInfo==0) );
58561 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
58564 if( pCur->pKeyInfo==0 ){
58572 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && nKey>0 && pCur->info.nKey==nKey-1 ){
58578 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
58581 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
58583 pPage = pCur->apPage[pCur->iPage];
58588 pCur->pgnoRoot, nKey, nData, pPage->pgno,
58598 idx = pCur->aiIdx[pCur->iPage];
58616 idx = ++pCur->aiIdx[pCur->iPage];
58643 pCur->info.nSize = 0;
58645 pCur->curFlags &= ~(BTCF_ValidNKey);
58646 rc = balance(pCur);
58652 pCur->apPage[pCur->iPage]->nOverflow = 0;
58653 pCur->eState = CURSOR_INVALID;
58655 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
58665 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
58666 Btree *p = pCur->pBtree;
58674 assert( cursorHoldsMutex(pCur) );
58677 assert( pCur->curFlags & BTCF_WriteFlag );
58678 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
58679 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
58681 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
58682 || NEVER(pCur->eState!=CURSOR_VALID)
58687 iCellDepth = pCur->iPage;
58688 iCellIdx = pCur->aiIdx[iCellDepth];
58689 pPage = pCur->apPage[iCellDepth];
58701 rc = sqlite3BtreePrevious(pCur, ¬Used);
58710 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
58715 if( pCur->pKeyInfo==0 ){
58716 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
58731 MemPage *pLeaf = pCur->apPage[pCur->iPage];
58733 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
58755 ** pCur is pointing to the leaf page from which a cell was removed to
58764 rc = balance(pCur);
58765 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
58766 while( pCur->iPage>iCellDepth ){
58767 releasePage(pCur->apPage[pCur->iPage--]);
58769 rc = balance(pCur);
58773 moveToRoot(pCur);
59023 ** Delete all information from the single table that pCur is open on.
59025 ** This routine only work for pCur on an ephemeral table.
59027 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
59028 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
59228 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
59235 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
59239 if( pCur->pgnoRoot==0 ){
59243 rc = moveToRoot(pCur);
59256 pPage = pCur->apPage[pCur->iPage];
59264 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
59273 if( pCur->iPage==0 ){
59278 moveToParent(pCur);
59279 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
59281 pCur->aiIdx[pCur->iPage]++;
59282 pPage = pCur->apPage[pCur->iPage];
59288 iIdx = pCur->aiIdx[pCur->iPage];
59290 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
59292 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
60034 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
60035 pCur->curFlags |= BTCF_Incrblob;
61627 ** The data or key is taken from the entry that pCur is currently pointing
61639 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
61649 assert( sqlite3BtreeCursorIsValid(pCur) );
61655 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
61657 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
61668 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
61670 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
66055 ** pCur points at an index entry created using the OP_MakeRecord opcode.
66059 ** pCur might be pointing to text obtained from a corrupt database file.
66062 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
66077 assert( sqlite3BtreeCursorIsValid(pCur) );
66078 VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
66079 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
66084 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
66149 BtCursor *pCur = pC->pCursor;
66152 assert( sqlite3BtreeCursorIsValid(pCur) );
66153 VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
66154 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
71275 VdbeCursor *pCur;
71279 pCur = p->apCsr[pOp->p1];
71280 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
71281 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
71295 VdbeCursor *pCur;
71355 pCur = allocateCursor(p, pOp->p1, nField, iDb, 1);
71356 if( pCur==0 ) goto no_mem;
71357 pCur->nullRow = 1;
71358 pCur->isOrdered = 1;
71359 pCur->pgnoRoot = p2;
71360 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->pCursor);
71361 pCur->pKeyInfo = pKeyInfo;
71363 sqlite3BtreeCursorHints(pCur->pCursor, (pOp->p5 & OPFLAG_BULKCSR));
71373 pCur->isTable = pOp->p4type!=P4_KEYINFO;
74032 VdbeCursor *pCur;
74038 pCur = 0;
74050 pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
74051 if( pCur ){
74052 pCur->pVtabCursor = pVtabCursor;
74090 VdbeCursor *pCur;
74097 pCur = p->apCsr[pOp->p1];
74100 assert( pCur->pVtabCursor );
74101 pVtabCursor = pCur->pVtabCursor;
74130 pCur->nullRow = 0;
74150 VdbeCursor *pCur = p->apCsr[pOp->p1];
74151 assert( pCur->pVtabCursor );
74155 if( pCur->nullRow ){
74159 pVtab = pCur->pVtabCursor->pVtab;
74172 rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
74205 VdbeCursor *pCur;
74208 pCur = p->apCsr[pOp->p1];
74209 assert( pCur->pVtabCursor );
74210 if( pCur->nullRow ){
74213 pVtab = pCur->pVtabCursor->pVtab;
74224 rc = pModule->xNext(pCur->pVtabCursor);
74228 res = pModule->xEof(pCur->pVtabCursor);
145821 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
145822 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
145828 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
145830 int ii = 1 - pCur->bPoint;
145832 assert( pCur->bPoint || pCur->nPoint );
145833 if( pCur->aNode[ii]==0 ){
145835 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
145836 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
145838 return pCur->aNode[ii];
145845 RtreeCursor *pCur, /* The cursor */
145851 if( pCur->nPoint>=pCur->nPointAlloc ){
145852 int nNew = pCur->nPointAlloc*2 + 8;
145853 pNew = sqlite3_realloc(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
145855 pCur->aPoint = pNew;
145856 pCur->nPointAlloc = nNew;
145858 i = pCur->nPoint++;
145859 pNew = pCur->aPoint + i;
145866 pParent = pCur->aPoint + j;
145868 rtreeSearchPointSwap(pCur, j, i);
145880 RtreeCursor *pCur, /* The cursor */
145885 pFirst = rtreeSearchPointFirst(pCur);
145886 pCur->anQueue[iLevel]++;
145891 if( pCur->bPoint ){
145893 pNew = rtreeEnqueue(pCur, rScore, iLevel);
145895 ii = (int)(pNew - pCur->aPoint) + 1;
145897 assert( pCur->aNode[ii]==0 );
145898 pCur->aNode[ii] = pCur->aNode[0];
145900 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
145902 pCur->aNode[0] = 0;
145903 *pNew = pCur->sPoint;
145905 pCur->sPoint.rScore = rScore;
145906 pCur->sPoint.iLevel = iLevel;
145907 pCur->bPoint = 1;
145908 return &pCur->sPoint;
145910 return rtreeEnqueue(pCur, rScore, iLevel);
145916 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
145923 printf(" %p\n", pCur->aNode[idx]);
145928 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
145931 if( pCur->bPoint ){
145932 tracePoint(&pCur->sPoint, -1, pCur);
145934 for(ii=0; ii<pCur->nPoint; ii++){
145935 if( ii>0 || pCur->bPoint ) printf(" ");
145936 tracePoint(&pCur->aPoint[ii], ii, pCur);
145989 ** Continue the search on cursor pCur until the front of the queue
145994 static int rtreeStepToLeaf(RtreeCursor *pCur){
145996 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
146001 int nConstraint = pCur->nConstraint;
146007 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
146008 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
146017 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
146040 RTREE_QUEUE_TRACE(pCur, "POP-S:");
146041 rtreeSearchPointPop(pCur);
146044 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
146049 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
146053 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
146054 rtreeSearchPointPop(pCur);
146057 pCur->atEOF = p==0;