Lines Matching refs:pCur
8224 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
60406 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
60407 sqlite3BtreeEnter(pCur->pBtree);
60410 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
60411 sqlite3BtreeLeave(pCur->pBtree);
60921 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
61048 static void btreeReleaseAllCursorPages(BtCursor *pCur){
61050 if( pCur->iPage>=0 ){
61051 for(i=0; i<pCur->iPage; i++){
61052 releasePageNotNull(pCur->apPage[i]);
61054 releasePageNotNull(pCur->pPage);
61055 pCur->iPage = -1;
61072 static int saveCursorKey(BtCursor *pCur){
61074 assert( CURSOR_VALID==pCur->eState );
61075 assert( 0==pCur->pKey );
61076 assert( cursorHoldsMutex(pCur) );
61078 if( pCur->curIntKey ){
61080 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
61084 pCur->nKey = sqlite3BtreePayloadSize(pCur);
61085 pKey = sqlite3Malloc( pCur->nKey );
61087 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
61089 pCur->pKey = pKey;
61097 assert( !pCur->curIntKey || !pCur->pKey );
61108 static int saveCursorPosition(BtCursor *pCur){
61111 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
61112 assert( 0==pCur->pKey );
61113 assert( cursorHoldsMutex(pCur) );
61115 if( pCur->eState==CURSOR_SKIPNEXT ){
61116 pCur->eState = CURSOR_VALID;
61118 pCur->skipNext = 0;
61121 rc = saveCursorKey(pCur);
61123 btreeReleaseAllCursorPages(pCur);
61124 pCur->eState = CURSOR_REQUIRESEEK;
61127 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
61197 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
61198 assert( cursorHoldsMutex(pCur) );
61199 sqlite3_free(pCur->pKey);
61200 pCur->pKey = 0;
61201 pCur->eState = CURSOR_INVALID;
61210 BtCursor *pCur, /* Cursor open on the btree to be searched */
61221 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pCur->pKeyInfo);
61223 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
61231 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
61234 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
61246 static int btreeRestoreCursorPosition(BtCursor *pCur){
61249 assert( cursorOwnsBtShared(pCur) );
61250 assert( pCur->eState>=CURSOR_REQUIRESEEK );
61251 if( pCur->eState==CURSOR_FAULT ){
61252 return pCur->skipNext;
61254 pCur->eState = CURSOR_INVALID;
61255 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
61257 sqlite3_free(pCur->pKey);
61258 pCur->pKey = 0;
61259 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
61260 pCur->skipNext |= skipNext;
61261 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
61262 pCur->eState = CURSOR_SKIPNEXT;
61285 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
61286 return pCur->eState!=CURSOR_VALID;
61313 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
61316 assert( pCur!=0 );
61317 assert( pCur->eState!=CURSOR_VALID );
61318 rc = restoreCursorPosition(pCur);
61323 if( pCur->eState!=CURSOR_VALID ){
61326 assert( pCur->skipNext==0 );
61338 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
61346 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
61348 pCur->hints = x;
62511 BtCursor *pCur, /* Cursor to receive the page, or NULL */
62517 assert( pCur==0 || ppPage==&pCur->pPage );
62518 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
62519 assert( pCur==0 || pCur->iPage>0 );
62543 if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
62551 if( pCur ){
62552 pCur->iPage--;
62553 pCur->pPage = pCur->apPage[pCur->iPage];
63052 BtCursor *pCur;
63057 pCur = pBt->pCursor;
63058 while( pCur ){
63059 BtCursor *pTmp = pCur;
63060 pCur = pCur->pNext;
63587 BtCursor *pCur;
63589 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
63590 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
63591 && pCur->eState!=CURSOR_FAULT ) r++;
64673 BtCursor *pCur /* Space for new cursor */
64708 pCur->pgnoRoot = (Pgno)iTable;
64709 pCur->iPage = -1;
64710 pCur->pKeyInfo = pKeyInfo;
64711 pCur->pBtree = p;
64712 pCur->pBt = pBt;
64713 pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0;
64714 pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY;
64720 pCur->curFlags |= BTCF_Multiple;
64723 pCur->pNext = pBt->pCursor;
64724 pBt->pCursor = pCur;
64725 pCur->eState = CURSOR_INVALID;
64733 BtCursor *pCur /* Write new cursor here */
64740 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
64774 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
64775 Btree *pBtree = pCur->pBtree;
64777 BtShared *pBt = pCur->pBt;
64780 if( pBt->pCursor==pCur ){
64781 pBt->pCursor = pCur->pNext;
64785 if( pPrev->pNext==pCur ){
64786 pPrev->pNext = pCur->pNext;
64792 btreeReleaseAllCursorPages(pCur);
64794 sqlite3_free(pCur->aOverflow);
64795 sqlite3_free(pCur->pKey);
64810 static void assertCellInfo(BtCursor *pCur){
64813 btreeParseCell(pCur->pPage, pCur->ix, &info);
64814 assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 );
64819 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
64820 if( pCur->info.nSize==0 ){
64821 pCur->curFlags |= BTCF_ValidNKey;
64822 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
64824 assertCellInfo(pCur);
64834 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
64835 return pCur && pCur->eState==CURSOR_VALID;
64838 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
64839 assert( pCur!=0 );
64840 return pCur->eState==CURSOR_VALID;
64849 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
64850 assert( cursorHoldsMutex(pCur) );
64851 assert( pCur->eState==CURSOR_VALID );
64852 assert( pCur->curIntKey );
64853 getCellInfo(pCur);
64854 return pCur->info.nKey;
64862 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
64863 assert( cursorHoldsMutex(pCur) );
64864 assert( pCur->eState==CURSOR_VALID );
64865 getCellInfo(pCur);
64866 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
64867 (i64)(pCur->info.pPayload - pCur->pPage->aData);
64880 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
64881 assert( cursorHoldsMutex(pCur) );
64882 assert( pCur->eState==CURSOR_VALID );
64883 getCellInfo(pCur);
64884 return pCur->info.nPayload;
65025 BtCursor *pCur, /* Cursor pointing to entry to read from */
65034 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
65035 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
65042 assert( pCur->eState==CURSOR_VALID );
65043 assert( pCur->ix<pPage->nCell );
65044 assert( cursorHoldsMutex(pCur) );
65046 getCellInfo(pCur);
65047 aPayload = pCur->info.pPayload;
65048 assert( offset+amt <= pCur->info.nPayload );
65051 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
65061 if( offset<pCur->info.nLocal ){
65063 if( a+offset>pCur->info.nLocal ){
65064 a = pCur->info.nLocal - offset;
65071 offset -= pCur->info.nLocal;
65079 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
65088 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
65089 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
65090 if( nOvfl>pCur->nOvflAlloc ){
65092 pCur->aOverflow, nOvfl*2*sizeof(Pgno)
65097 pCur->nOvflAlloc = nOvfl*2;
65098 pCur->aOverflow = aNew;
65101 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
65102 pCur->curFlags |= BTCF_ValidOvfl;
65108 if( pCur->aOverflow[offset/ovflSize] ){
65110 nextPage = pCur->aOverflow[iIdx];
65118 assert( pCur->aOverflow[iIdx]==0
65119 || pCur->aOverflow[iIdx]==nextPage
65121 pCur->aOverflow[iIdx] = nextPage;
65130 assert( pCur->curFlags & BTCF_ValidOvfl );
65131 assert( pCur->pBtree->db==pBt->db );
65132 if( pCur->aOverflow[iIdx+1] ){
65133 nextPage = pCur->aOverflow[iIdx+1];
65227 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
65228 assert( cursorHoldsMutex(pCur) );
65229 assert( pCur->eState==CURSOR_VALID );
65230 assert( pCur->iPage>=0 && pCur->pPage );
65231 assert( pCur->ix<pCur->pPage->nCell );
65232 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
65242 BtCursor *pCur,
65248 if ( pCur->eState==CURSOR_INVALID ){
65251 assert( cursorOwnsBtShared(pCur) );
65252 rc = btreeRestoreCursorPosition(pCur);
65253 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
65255 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
65256 if( pCur->eState==CURSOR_VALID ){
65257 assert( cursorOwnsBtShared(pCur) );
65258 return accessPayload(pCur, offset, amt, pBuf, 0);
65260 return accessPayloadChecked(pCur, offset, amt, pBuf);
65285 BtCursor *pCur, /* Cursor pointing to entry to read from */
65289 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
65290 assert( pCur->eState==CURSOR_VALID );
65291 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
65292 assert( cursorOwnsBtShared(pCur) );
65293 assert( pCur->ix<pCur->pPage->nCell );
65294 assert( pCur->info.nSize>0 );
65295 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
65296 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
65297 amt = pCur->info.nLocal;
65298 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
65302 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
65305 return (void*)pCur->info.pPayload;
65323 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
65324 return fetchPayload(pCur, pAmt);
65337 static int moveToChild(BtCursor *pCur, u32 newPgno){
65338 BtShared *pBt = pCur->pBt;
65340 assert( cursorOwnsBtShared(pCur) );
65341 assert( pCur->eState==CURSOR_VALID );
65342 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
65343 assert( pCur->iPage>=0 );
65344 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
65347 pCur->info.nSize = 0;
65348 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
65349 pCur->aiIdx[pCur->iPage] = pCur->ix;
65350 pCur->apPage[pCur->iPage] = pCur->pPage;
65351 pCur->ix = 0;
65352 pCur->iPage++;
65353 return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags);
65386 static void moveToParent(BtCursor *pCur){
65388 assert( cursorOwnsBtShared(pCur) );
65389 assert( pCur->eState==CURSOR_VALID );
65390 assert( pCur->iPage>0 );
65391 assert( pCur->pPage );
65393 pCur->apPage[pCur->iPage-1],
65394 pCur->aiIdx[pCur->iPage-1],
65395 pCur->pPage->pgno
65397 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
65398 pCur->info.nSize = 0;
65399 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
65400 pCur->ix = pCur->aiIdx[pCur->iPage-1];
65401 pLeaf = pCur->pPage;
65402 pCur->pPage = pCur->apPage[--pCur->iPage];
65427 static int moveToRoot(BtCursor *pCur){
65431 assert( cursorOwnsBtShared(pCur) );
65435 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
65436 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
65438 if( pCur->iPage>=0 ){
65439 if( pCur->iPage ){
65440 releasePageNotNull(pCur->pPage);
65441 while( --pCur->iPage ){
65442 releasePageNotNull(pCur->apPage[pCur->iPage]);
65444 pCur->pPage = pCur->apPage[0];
65447 }else if( pCur->pgnoRoot==0 ){
65448 pCur->eState = CURSOR_INVALID;
65451 assert( pCur->iPage==(-1) );
65452 if( pCur->eState>=CURSOR_REQUIRESEEK ){
65453 if( pCur->eState==CURSOR_FAULT ){
65454 assert( pCur->skipNext!=SQLITE_OK );
65455 return pCur->skipNext;
65457 sqlite3BtreeClearCursor(pCur);
65459 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage,
65460 0, pCur->curPagerFlags);
65462 pCur->eState = CURSOR_INVALID;
65465 pCur->iPage = 0;
65466 pCur->curIntKey = pCur->pPage->intKey;
65468 pRoot = pCur->pPage;
65469 assert( pRoot->pgno==pCur->pgnoRoot );
65482 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
65483 return SQLITE_CORRUPT_PAGE(pCur->pPage);
65487 pCur->ix = 0;
65488 pCur->info.nSize = 0;
65489 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
65491 pRoot = pCur->pPage;
65493 pCur->eState = CURSOR_VALID;
65498 pCur->eState = CURSOR_VALID;
65499 rc = moveToChild(pCur, subpage);
65501 pCur->eState = CURSOR_INVALID;
65514 static int moveToLeftmost(BtCursor *pCur){
65519 assert( cursorOwnsBtShared(pCur) );
65520 assert( pCur->eState==CURSOR_VALID );
65521 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
65522 assert( pCur->ix<pPage->nCell );
65523 pgno = get4byte(findCell(pPage, pCur->ix));
65524 rc = moveToChild(pCur, pgno);
65539 static int moveToRightmost(BtCursor *pCur){
65544 assert( cursorOwnsBtShared(pCur) );
65545 assert( pCur->eState==CURSOR_VALID );
65546 while( !(pPage = pCur->pPage)->leaf ){
65548 pCur->ix = pPage->nCell;
65549 rc = moveToChild(pCur, pgno);
65552 pCur->ix = pPage->nCell-1;
65553 assert( pCur->info.nSize==0 );
65554 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
65562 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
65565 assert( cursorOwnsBtShared(pCur) );
65566 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
65567 rc = moveToRoot(pCur);
65569 assert( pCur->pPage->nCell>0 );
65571 rc = moveToLeftmost(pCur);
65573 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
65584 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
65587 assert( cursorOwnsBtShared(pCur) );
65588 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
65591 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
65596 for(ii=0; ii<pCur->iPage; ii++){
65597 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
65599 assert( pCur->ix==pCur->pPage->nCell-1 );
65600 assert( pCur->pPage->leaf );
65605 rc = moveToRoot(pCur);
65607 assert( pCur->eState==CURSOR_VALID );
65609 rc = moveToRightmost(pCur);
65611 pCur->curFlags |= BTCF_AtLast;
65613 pCur->curFlags &= ~BTCF_AtLast;
65616 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
65654 BtCursor *pCur, /* The cursor to be moved */
65663 assert( cursorOwnsBtShared(pCur) );
65664 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
65666 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
65667 assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
65672 && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
65674 if( pCur->info.nKey==intKey ){
65678 if( pCur->info.nKey<intKey ){
65679 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
65687 if( pCur->info.nKey+1==intKey && !pCur->skipNext ){
65689 rc = sqlite3BtreeNext(pCur, 0);
65691 getCellInfo(pCur);
65692 if( pCur->info.nKey==intKey ){
65715 rc = moveToRoot(pCur);
65718 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
65724 assert( pCur->pPage );
65725 assert( pCur->pPage->isInit );
65726 assert( pCur->eState==CURSOR_VALID );
65727 assert( pCur->pPage->nCell > 0 );
65728 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
65729 assert( pCur->curIntKey || pIdxKey );
65733 MemPage *pPage = pCur->pPage;
65748 pCur->ix = (u16)idx;
65769 pCur->ix = (u16)idx;
65774 pCur->curFlags |= BTCF_ValidNKey;
65775 pCur->info.nKey = nCellKey;
65776 pCur->info.nSize = 0;
65823 pPage->xParseCell(pPage, pCellBody, &pCur->info);
65824 nCell = (int)pCur->info.nKey;
65838 pCur->ix = (u16)idx;
65839 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
65840 pCur->curFlags &= ~BTCF_ValidOvfl;
65850 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
65860 pCur->ix = (u16)idx;
65872 assert( pCur->ix<pCur->pPage->nCell );
65873 pCur->ix = (u16)idx;
65884 pCur->ix = (u16)lwr;
65885 rc = moveToChild(pCur, chldPg);
65889 pCur->info.nSize = 0;
65890 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
65902 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
65907 return (CURSOR_VALID!=pCur->eState);
65915 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
65919 assert( cursorOwnsBtShared(pCur) );
65920 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
65925 if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
65926 if( NEVER(pCur->pPage->leaf==0) ) return -1;
65928 n = pCur->pPage->nCell;
65929 for(i=0; i<pCur->iPage; i++){
65930 n *= pCur->apPage[i]->nCell;
65955 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
65960 assert( cursorOwnsBtShared(pCur) );
65961 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
65962 if( pCur->eState!=CURSOR_VALID ){
65963 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
65964 rc = restoreCursorPosition(pCur);
65968 if( CURSOR_INVALID==pCur->eState ){
65971 if( pCur->skipNext ){
65972 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
65973 pCur->eState = CURSOR_VALID;
65974 if( pCur->skipNext>0 ){
65975 pCur->skipNext = 0;
65978 pCur->skipNext = 0;
65982 pPage = pCur->pPage;
65983 idx = ++pCur->ix;
65995 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
65997 return moveToLeftmost(pCur);
66000 if( pCur->iPage==0 ){
66001 pCur->eState = CURSOR_INVALID;
66004 moveToParent(pCur);
66005 pPage = pCur->pPage;
66006 }while( pCur->ix>=pPage->nCell );
66008 return sqlite3BtreeNext(pCur, 0);
66016 return moveToLeftmost(pCur);
66019 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
66022 assert( cursorOwnsBtShared(pCur) );
66024 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
66025 pCur->info.nSize = 0;
66026 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
66027 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
66028 pPage = pCur->pPage;
66029 if( (++pCur->ix)>=pPage->nCell ){
66030 pCur->ix--;
66031 return btreeNext(pCur);
66036 return moveToLeftmost(pCur);
66060 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
66064 assert( cursorOwnsBtShared(pCur) );
66065 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
66066 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
66067 assert( pCur->info.nSize==0 );
66068 if( pCur->eState!=CURSOR_VALID ){
66069 rc = restoreCursorPosition(pCur);
66073 if( CURSOR_INVALID==pCur->eState ){
66076 if( pCur->skipNext ){
66077 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
66078 pCur->eState = CURSOR_VALID;
66079 if( pCur->skipNext<0 ){
66080 pCur->skipNext = 0;
66083 pCur->skipNext = 0;
66087 pPage = pCur->pPage;
66090 int idx = pCur->ix;
66091 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
66093 rc = moveToRightmost(pCur);
66095 while( pCur->ix==0 ){
66096 if( pCur->iPage==0 ){
66097 pCur->eState = CURSOR_INVALID;
66100 moveToParent(pCur);
66102 assert( pCur->info.nSize==0 );
66103 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
66105 pCur->ix--;
66106 pPage = pCur->pPage;
66108 rc = sqlite3BtreePrevious(pCur, 0);
66115 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
66116 assert( cursorOwnsBtShared(pCur) );
66118 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
66120 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
66121 pCur->info.nSize = 0;
66122 if( pCur->eState!=CURSOR_VALID
66123 || pCur->ix==0
66124 || pCur->pPage->leaf==0
66126 return btreePrevious(pCur);
66128 pCur->ix--;
68438 static int balance(BtCursor *pCur){
68440 const int nMin = pCur->pBt->usableSize * 2 / 3;
68448 int iPage = pCur->iPage;
68449 MemPage *pPage = pCur->pPage;
68460 rc = balance_deeper(pPage, &pCur->apPage[1]);
68462 pCur->iPage = 1;
68463 pCur->ix = 0;
68464 pCur->aiIdx[0] = 0;
68465 pCur->apPage[0] = pPage;
68466 pCur->pPage = pCur->apPage[1];
68467 assert( pCur->pPage->nOverflow );
68475 MemPage * const pParent = pCur->apPage[iPage-1];
68476 int const iIdx = pCur->aiIdx[iPage-1];
68523 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
68525 pCur->hints&BTREE_BULKLOAD);
68545 pCur->iPage--;
68546 assert( pCur->iPage>=0 );
68547 pCur->pPage = pCur->apPage[pCur->iPage];
68589 BtCursor *pCur, /* Insert data into the table of this cursor */
68599 Btree *p = pCur->pBtree;
68606 if( pCur->eState==CURSOR_FAULT ){
68607 assert( pCur->skipNext!=SQLITE_OK );
68608 return pCur->skipNext;
68611 assert( cursorOwnsBtShared(pCur) );
68612 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
68615 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
68622 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
68635 if( pCur->curFlags & BTCF_Multiple ){
68636 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
68640 if( pCur->pKeyInfo==0 ){
68644 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
68649 ((pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey) );
68654 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
68657 rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
68663 r.pKeyInfo = pCur->pKeyInfo;
68671 rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
68673 rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
68677 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
68679 pPage = pCur->pPage;
68684 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
68693 idx = pCur->ix;
68727 idx = ++pCur->ix;
68728 pCur->curFlags &= ~BTCF_ValidNKey;
68756 pCur->info.nSize = 0;
68759 pCur->curFlags &= ~(BTCF_ValidNKey);
68760 rc = balance(pCur);
68766 pCur->pPage->nOverflow = 0;
68767 pCur->eState = CURSOR_INVALID;
68769 btreeReleaseAllCursorPages(pCur);
68770 if( pCur->pKeyInfo ){
68771 assert( pCur->pKey==0 );
68772 pCur->pKey = sqlite3Malloc( pX->nKey );
68773 if( pCur->pKey==0 ){
68776 memcpy(pCur->pKey, pX->pKey, pX->nKey);
68779 pCur->eState = CURSOR_REQUIRESEEK;
68780 pCur->nKey = pX->nKey;
68783 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
68806 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
68807 Btree *p = pCur->pBtree;
68818 assert( cursorOwnsBtShared(pCur) );
68821 assert( pCur->curFlags & BTCF_WriteFlag );
68822 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
68823 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
68824 assert( pCur->ix<pCur->pPage->nCell );
68825 assert( pCur->eState==CURSOR_VALID );
68828 iCellDepth = pCur->iPage;
68829 iCellIdx = pCur->ix;
68830 pPage = pCur->pPage;
68848 rc = saveCursorKey(pCur);
68863 rc = sqlite3BtreePrevious(pCur, 0);
68870 if( pCur->curFlags & BTCF_Multiple ){
68871 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
68877 if( pCur->pKeyInfo==0 ){
68878 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
68896 MemPage *pLeaf = pCur->pPage;
68901 if( iCellDepth<pCur->iPage-1 ){
68902 n = pCur->apPage[iCellDepth+1]->pgno;
68904 n = pCur->pPage->pgno;
68935 rc = balance(pCur);
68936 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
68937 releasePageNotNull(pCur->pPage);
68938 pCur->iPage--;
68939 while( pCur->iPage>iCellDepth ){
68940 releasePage(pCur->apPage[pCur->iPage--]);
68942 pCur->pPage = pCur->apPage[pCur->iPage];
68943 rc = balance(pCur);
68948 assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
68949 assert( pPage==pCur->pPage || CORRUPT_DB );
68951 pCur->eState = CURSOR_SKIPNEXT;
68953 pCur->skipNext = -1;
68954 pCur->ix = pPage->nCell-1;
68956 pCur->skipNext = 1;
68959 rc = moveToRoot(pCur);
68961 btreeReleaseAllCursorPages(pCur);
68962 pCur->eState = CURSOR_REQUIRESEEK;
69227 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
69228 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
69425 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
69429 rc = moveToRoot(pCur);
69446 pPage = pCur->pPage;
69463 if( pCur->iPage==0 ){
69466 return moveToRoot(pCur);
69468 moveToParent(pCur);
69469 }while ( pCur->ix>=pCur->pPage->nCell );
69471 pCur->ix++;
69472 pPage = pCur->pPage;
69478 iIdx = pCur->ix;
69480 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
69482 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
70321 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
70322 pCur->curFlags |= BTCF_Incrblob;
70323 pCur->pBtree->hasIncrblobCur = 1;
72213 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
72221 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
72233 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
72242 assert( sqlite3BtreeCursorIsValid(pCur) );
72248 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
72256 rc = vdbeMemFromBtreeResize(pCur, offset, amt, pMem);
77395 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
77408 assert( sqlite3BtreeCursorIsValid(pCur) );
77409 nCellKey = sqlite3BtreePayloadSize(pCur);
77414 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
77480 BtCursor *pCur;
77484 pCur = pC->uc.pCursor;
77485 assert( sqlite3BtreeCursorIsValid(pCur) );
77486 nCellKey = sqlite3BtreePayloadSize(pCur);
77494 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
83403 VdbeCursor *pCur;
83408 pCur = p->apCsr[pOp->p1];
83409 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
83410 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
83472 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
83473 if( pCur==0 ) goto no_mem;
83474 pCur->nullRow = 1;
83475 pCur->isOrdered = 1;
83476 pCur->pgnoRoot = p2;
83478 pCur->wrFlag = wrFlag;
83480 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
83481 pCur->pKeyInfo = pKeyInfo;
83486 pCur->isTable = pOp->p4type!=P4_KEYINFO;
83495 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
86605 VdbeCursor *pCur;
86611 pCur = 0;
86627 pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
86628 if( pCur ){
86629 pCur->uc.pVCur = pVCur;
86668 VdbeCursor *pCur;
86675 pCur = p->apCsr[pOp->p1];
86678 assert( pCur->eCurType==CURTYPE_VTAB );
86679 pVCur = pCur->uc.pVCur;
86698 pCur->nullRow = 0;
86725 VdbeCursor *pCur = p->apCsr[pOp->p1];
86726 assert( pCur->eCurType==CURTYPE_VTAB );
86730 if( pCur->nullRow ){
86734 pVtab = pCur->uc.pVCur->pVtab;
86746 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
86774 VdbeCursor *pCur;
86777 pCur = p->apCsr[pOp->p1];
86778 assert( pCur->eCurType==CURTYPE_VTAB );
86779 if( pCur->nullRow ){
86782 pVtab = pCur->uc.pVCur->pVtab;
86792 rc = pModule->xNext(pCur->uc.pVCur);
86795 res = pModule->xEof(pCur->uc.pVCur);
168396 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
168397 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
168403 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
168405 int ii = 1 - pCur->bPoint;
168407 assert( pCur->bPoint || pCur->nPoint );
168408 if( pCur->aNode[ii]==0 ){
168410 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
168411 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
168413 return pCur->aNode[ii];
168420 RtreeCursor *pCur, /* The cursor */
168426 if( pCur->nPoint>=pCur->nPointAlloc ){
168427 int nNew = pCur->nPointAlloc*2 + 8;
168428 pNew = sqlite3_realloc(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
168430 pCur->aPoint = pNew;
168431 pCur->nPointAlloc = nNew;
168433 i = pCur->nPoint++;
168434 pNew = pCur->aPoint + i;
168441 pParent = pCur->aPoint + j;
168443 rtreeSearchPointSwap(pCur, j, i);
168455 RtreeCursor *pCur, /* The cursor */
168460 pFirst = rtreeSearchPointFirst(pCur);
168461 pCur->anQueue[iLevel]++;
168466 if( pCur->bPoint ){
168468 pNew = rtreeEnqueue(pCur, rScore, iLevel);
168470 ii = (int)(pNew - pCur->aPoint) + 1;
168472 assert( pCur->aNode[ii]==0 );
168473 pCur->aNode[ii] = pCur->aNode[0];
168475 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
168477 pCur->aNode[0] = 0;
168478 *pNew = pCur->sPoint;
168480 pCur->sPoint.rScore = rScore;
168481 pCur->sPoint.iLevel = iLevel;
168482 pCur->bPoint = 1;
168483 return &pCur->sPoint;
168485 return rtreeEnqueue(pCur, rScore, iLevel);
168491 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
168498 printf(" %p\n", pCur->aNode[idx]);
168503 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
168506 if( pCur->bPoint ){
168507 tracePoint(&pCur->sPoint, -1, pCur);
168509 for(ii=0; ii<pCur->nPoint; ii++){
168510 if( ii>0 || pCur->bPoint ) printf(" ");
168511 tracePoint(&pCur->aPoint[ii], ii, pCur);
168569 static int rtreeStepToLeaf(RtreeCursor *pCur){
168571 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
168576 int nConstraint = pCur->nConstraint;
168582 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
168583 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
168592 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
168615 RTREE_QUEUE_TRACE(pCur, "POP-S:");
168616 rtreeSearchPointPop(pCur);
168619 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
168624 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
168628 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
168629 rtreeSearchPointPop(pCur);
168632 pCur->atEOF = p==0;
185555 JsonEachCursor *pCur;
185558 pCur = sqlite3_malloc( sizeof(*pCur) );
185559 if( pCur==0 ) return SQLITE_NOMEM;
185560 memset(pCur, 0, sizeof(*pCur));
185561 *ppCursor = &pCur->base;
185569 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
185570 pCur->bRecursive = 1;
207511 stmt_cursor *pCur;
207512 pCur = sqlite3_malloc( sizeof(*pCur) );
207513 if( pCur==0 ) return SQLITE_NOMEM;
207514 memset(pCur, 0, sizeof(*pCur));
207515 pCur->db = ((stmt_vtab*)p)->db;
207516 *ppCursor = &pCur->base;
207533 stmt_cursor *pCur = (stmt_cursor*)cur;
207534 pCur->iRowid++;
207535 pCur->pStmt = sqlite3_next_stmt(pCur->db, pCur->pStmt);
207548 stmt_cursor *pCur = (stmt_cursor*)cur;
207551 sqlite3_result_text(ctx, sqlite3_sql(pCur->pStmt), -1, SQLITE_TRANSIENT);
207555 sqlite3_result_int(ctx, sqlite3_column_count(pCur->pStmt));
207559 sqlite3_result_int(ctx, sqlite3_stmt_readonly(pCur->pStmt));
207563 sqlite3_result_int(ctx, sqlite3_stmt_busy(pCur->pStmt));
207577 sqlite3_result_int(ctx, sqlite3_stmt_status(pCur->pStmt,
207590 stmt_cursor *pCur = (stmt_cursor*)cur;
207591 *pRowid = pCur->iRowid;
207600 stmt_cursor *pCur = (stmt_cursor*)cur;
207601 return pCur->pStmt==0;
207615 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
207616 pCur->pStmt = 0;
207617 pCur->iRowid = 0;