Lines Matching refs:pCur
8683 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
63184 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
63185 sqlite3BtreeEnter(pCur->pBtree);
63188 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
63189 sqlite3BtreeLeave(pCur->pBtree);
63699 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
63826 static void btreeReleaseAllCursorPages(BtCursor *pCur){
63828 if( pCur->iPage>=0 ){
63829 for(i=0; i<pCur->iPage; i++){
63830 releasePageNotNull(pCur->apPage[i]);
63832 releasePageNotNull(pCur->pPage);
63833 pCur->iPage = -1;
63850 static int saveCursorKey(BtCursor *pCur){
63852 assert( CURSOR_VALID==pCur->eState );
63853 assert( 0==pCur->pKey );
63854 assert( cursorHoldsMutex(pCur) );
63856 if( pCur->curIntKey ){
63858 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
63867 pCur->nKey = sqlite3BtreePayloadSize(pCur);
63868 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
63870 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
63872 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
63873 pCur->pKey = pKey;
63881 assert( !pCur->curIntKey || !pCur->pKey );
63892 static int saveCursorPosition(BtCursor *pCur){
63895 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
63896 assert( 0==pCur->pKey );
63897 assert( cursorHoldsMutex(pCur) );
63899 if( pCur->eState==CURSOR_SKIPNEXT ){
63900 pCur->eState = CURSOR_VALID;
63902 pCur->skipNext = 0;
63905 rc = saveCursorKey(pCur);
63907 btreeReleaseAllCursorPages(pCur);
63908 pCur->eState = CURSOR_REQUIRESEEK;
63911 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
63981 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
63982 assert( cursorHoldsMutex(pCur) );
63983 sqlite3_free(pCur->pKey);
63984 pCur->pKey = 0;
63985 pCur->eState = CURSOR_INVALID;
63994 BtCursor *pCur, /* Cursor open on the btree to be searched */
64004 KeyInfo *pKeyInfo = pCur->pKeyInfo;
64016 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
64019 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
64031 static int btreeRestoreCursorPosition(BtCursor *pCur){
64034 assert( cursorOwnsBtShared(pCur) );
64035 assert( pCur->eState>=CURSOR_REQUIRESEEK );
64036 if( pCur->eState==CURSOR_FAULT ){
64037 return pCur->skipNext;
64039 pCur->eState = CURSOR_INVALID;
64043 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
64046 sqlite3_free(pCur->pKey);
64047 pCur->pKey = 0;
64048 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
64049 if( skipNext ) pCur->skipNext = skipNext;
64050 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
64051 pCur->eState = CURSOR_SKIPNEXT;
64074 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
64075 assert( EIGHT_BYTE_ALIGNMENT(pCur)
64076 || pCur==sqlite3BtreeFakeValidCursor() );
64078 assert( sizeof(pCur->eState)==1 );
64079 return CURSOR_VALID != *(u8*)pCur;
64106 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
64109 assert( pCur!=0 );
64110 assert( pCur->eState!=CURSOR_VALID );
64111 rc = restoreCursorPosition(pCur);
64116 if( pCur->eState!=CURSOR_VALID ){
64130 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
64138 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
64140 pCur->hints = x;
65353 BtCursor *pCur, /* Cursor to receive the page, or NULL */
65359 assert( pCur==0 || ppPage==&pCur->pPage );
65360 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
65361 assert( pCur==0 || pCur->iPage>0 );
65384 if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
65393 if( pCur ){
65394 pCur->iPage--;
65395 pCur->pPage = pCur->apPage[pCur->iPage];
65895 BtCursor *pCur;
65900 pCur = pBt->pCursor;
65901 while( pCur ){
65902 BtCursor *pTmp = pCur;
65903 pCur = pCur->pNext;
66438 BtCursor *pCur;
66440 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
66441 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
66442 && pCur->eState!=CURSOR_FAULT ) r++;
67541 BtCursor *pCur /* Space for new cursor */
67576 pCur->pgnoRoot = (Pgno)iTable;
67577 pCur->iPage = -1;
67578 pCur->pKeyInfo = pKeyInfo;
67579 pCur->pBtree = p;
67580 pCur->pBt = pBt;
67581 pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0;
67582 pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY;
67588 pCur->curFlags |= BTCF_Multiple;
67591 pCur->pNext = pBt->pCursor;
67592 pBt->pCursor = pCur;
67593 pCur->eState = CURSOR_INVALID;
67601 BtCursor *pCur /* Write new cursor here */
67608 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
67642 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
67643 Btree *pBtree = pCur->pBtree;
67645 BtShared *pBt = pCur->pBt;
67648 if( pBt->pCursor==pCur ){
67649 pBt->pCursor = pCur->pNext;
67653 if( pPrev->pNext==pCur ){
67654 pPrev->pNext = pCur->pNext;
67660 btreeReleaseAllCursorPages(pCur);
67662 sqlite3_free(pCur->aOverflow);
67663 sqlite3_free(pCur->pKey);
67665 pCur->pBtree = 0;
67687 static void assertCellInfo(BtCursor *pCur){
67690 btreeParseCell(pCur->pPage, pCur->ix, &info);
67691 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
67696 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
67697 if( pCur->info.nSize==0 ){
67698 pCur->curFlags |= BTCF_ValidNKey;
67699 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
67701 assertCellInfo(pCur);
67711 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
67712 return pCur && pCur->eState==CURSOR_VALID;
67715 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
67716 assert( pCur!=0 );
67717 return pCur->eState==CURSOR_VALID;
67726 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
67727 assert( cursorHoldsMutex(pCur) );
67728 assert( pCur->eState==CURSOR_VALID );
67729 assert( pCur->curIntKey );
67730 getCellInfo(pCur);
67731 return pCur->info.nKey;
67739 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
67740 assert( cursorHoldsMutex(pCur) );
67741 assert( pCur->eState==CURSOR_VALID );
67742 getCellInfo(pCur);
67743 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
67744 (i64)(pCur->info.pPayload - pCur->pPage->aData);
67757 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
67758 assert( cursorHoldsMutex(pCur) );
67759 assert( pCur->eState==CURSOR_VALID );
67760 getCellInfo(pCur);
67761 return pCur->info.nPayload;
67777 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
67778 assert( cursorHoldsMutex(pCur) );
67779 assert( pCur->eState==CURSOR_VALID );
67780 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
67921 BtCursor *pCur, /* Cursor pointing to entry to read from */
67930 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
67931 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
67938 assert( pCur->eState==CURSOR_VALID );
67939 assert( pCur->ix<pPage->nCell );
67940 assert( cursorHoldsMutex(pCur) );
67942 getCellInfo(pCur);
67943 aPayload = pCur->info.pPayload;
67944 assert( offset+amt <= pCur->info.nPayload );
67947 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
67957 if( offset<pCur->info.nLocal ){
67959 if( a+offset>pCur->info.nLocal ){
67960 a = pCur->info.nLocal - offset;
67967 offset -= pCur->info.nLocal;
67975 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
67984 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
67985 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
67986 if( pCur->aOverflow==0
67987 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
67990 pCur->aOverflow, nOvfl*2*sizeof(Pgno)
67995 pCur->aOverflow = aNew;
67998 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
67999 pCur->curFlags |= BTCF_ValidOvfl;
68005 if( pCur->aOverflow[offset/ovflSize] ){
68007 nextPage = pCur->aOverflow[iIdx];
68015 assert( pCur->aOverflow[iIdx]==0
68016 || pCur->aOverflow[iIdx]==nextPage
68018 pCur->aOverflow[iIdx] = nextPage;
68027 assert( pCur->curFlags & BTCF_ValidOvfl );
68028 assert( pCur->pBtree->db==pBt->db );
68029 if( pCur->aOverflow[iIdx+1] ){
68030 nextPage = pCur->aOverflow[iIdx+1];
68120 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
68121 assert( cursorHoldsMutex(pCur) );
68122 assert( pCur->eState==CURSOR_VALID );
68123 assert( pCur->iPage>=0 && pCur->pPage );
68124 assert( pCur->ix<pCur->pPage->nCell );
68125 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
68135 BtCursor *pCur,
68141 if ( pCur->eState==CURSOR_INVALID ){
68144 assert( cursorOwnsBtShared(pCur) );
68145 rc = btreeRestoreCursorPosition(pCur);
68146 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
68148 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
68149 if( pCur->eState==CURSOR_VALID ){
68150 assert( cursorOwnsBtShared(pCur) );
68151 return accessPayload(pCur, offset, amt, pBuf, 0);
68153 return accessPayloadChecked(pCur, offset, amt, pBuf);
68178 BtCursor *pCur, /* Cursor pointing to entry to read from */
68182 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
68183 assert( pCur->eState==CURSOR_VALID );
68184 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68185 assert( cursorOwnsBtShared(pCur) );
68186 assert( pCur->ix<pCur->pPage->nCell );
68187 assert( pCur->info.nSize>0 );
68188 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
68189 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
68190 amt = pCur->info.nLocal;
68191 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
68195 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
68198 return (void*)pCur->info.pPayload;
68216 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
68217 return fetchPayload(pCur, pAmt);
68230 static int moveToChild(BtCursor *pCur, u32 newPgno){
68231 BtShared *pBt = pCur->pBt;
68233 assert( cursorOwnsBtShared(pCur) );
68234 assert( pCur->eState==CURSOR_VALID );
68235 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
68236 assert( pCur->iPage>=0 );
68237 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
68240 pCur->info.nSize = 0;
68241 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68242 pCur->aiIdx[pCur->iPage] = pCur->ix;
68243 pCur->apPage[pCur->iPage] = pCur->pPage;
68244 pCur->ix = 0;
68245 pCur->iPage++;
68246 return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags);
68279 static void moveToParent(BtCursor *pCur){
68281 assert( cursorOwnsBtShared(pCur) );
68282 assert( pCur->eState==CURSOR_VALID );
68283 assert( pCur->iPage>0 );
68284 assert( pCur->pPage );
68286 pCur->apPage[pCur->iPage-1],
68287 pCur->aiIdx[pCur->iPage-1],
68288 pCur->pPage->pgno
68290 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
68291 pCur->info.nSize = 0;
68292 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68293 pCur->ix = pCur->aiIdx[pCur->iPage-1];
68294 pLeaf = pCur->pPage;
68295 pCur->pPage = pCur->apPage[--pCur->iPage];
68320 static int moveToRoot(BtCursor *pCur){
68324 assert( cursorOwnsBtShared(pCur) );
68328 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
68329 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
68331 if( pCur->iPage>=0 ){
68332 if( pCur->iPage ){
68333 releasePageNotNull(pCur->pPage);
68334 while( --pCur->iPage ){
68335 releasePageNotNull(pCur->apPage[pCur->iPage]);
68337 pCur->pPage = pCur->apPage[0];
68340 }else if( pCur->pgnoRoot==0 ){
68341 pCur->eState = CURSOR_INVALID;
68344 assert( pCur->iPage==(-1) );
68345 if( pCur->eState>=CURSOR_REQUIRESEEK ){
68346 if( pCur->eState==CURSOR_FAULT ){
68347 assert( pCur->skipNext!=SQLITE_OK );
68348 return pCur->skipNext;
68350 sqlite3BtreeClearCursor(pCur);
68352 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage,
68353 0, pCur->curPagerFlags);
68355 pCur->eState = CURSOR_INVALID;
68358 pCur->iPage = 0;
68359 pCur->curIntKey = pCur->pPage->intKey;
68361 pRoot = pCur->pPage;
68362 assert( pRoot->pgno==pCur->pgnoRoot );
68375 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
68376 return SQLITE_CORRUPT_PAGE(pCur->pPage);
68380 pCur->ix = 0;
68381 pCur->info.nSize = 0;
68382 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
68384 pRoot = pCur->pPage;
68386 pCur->eState = CURSOR_VALID;
68391 pCur->eState = CURSOR_VALID;
68392 rc = moveToChild(pCur, subpage);
68394 pCur->eState = CURSOR_INVALID;
68407 static int moveToLeftmost(BtCursor *pCur){
68412 assert( cursorOwnsBtShared(pCur) );
68413 assert( pCur->eState==CURSOR_VALID );
68414 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
68415 assert( pCur->ix<pPage->nCell );
68416 pgno = get4byte(findCell(pPage, pCur->ix));
68417 rc = moveToChild(pCur, pgno);
68432 static int moveToRightmost(BtCursor *pCur){
68437 assert( cursorOwnsBtShared(pCur) );
68438 assert( pCur->eState==CURSOR_VALID );
68439 while( !(pPage = pCur->pPage)->leaf ){
68441 pCur->ix = pPage->nCell;
68442 rc = moveToChild(pCur, pgno);
68445 pCur->ix = pPage->nCell-1;
68446 assert( pCur->info.nSize==0 );
68447 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
68455 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
68458 assert( cursorOwnsBtShared(pCur) );
68459 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68460 rc = moveToRoot(pCur);
68462 assert( pCur->pPage->nCell>0 );
68464 rc = moveToLeftmost(pCur);
68466 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68477 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
68480 assert( cursorOwnsBtShared(pCur) );
68481 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68484 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
68489 for(ii=0; ii<pCur->iPage; ii++){
68490 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
68492 assert( pCur->ix==pCur->pPage->nCell-1 );
68493 assert( pCur->pPage->leaf );
68498 rc = moveToRoot(pCur);
68500 assert( pCur->eState==CURSOR_VALID );
68502 rc = moveToRightmost(pCur);
68504 pCur->curFlags |= BTCF_AtLast;
68506 pCur->curFlags &= ~BTCF_AtLast;
68509 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68547 BtCursor *pCur, /* The cursor to be moved */
68556 assert( cursorOwnsBtShared(pCur) );
68557 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68559 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
68560 assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
68565 && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
68567 if( pCur->info.nKey==intKey ){
68571 if( pCur->info.nKey<intKey ){
68572 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
68580 if( pCur->info.nKey+1==intKey ){
68582 rc = sqlite3BtreeNext(pCur, 0);
68584 getCellInfo(pCur);
68585 if( pCur->info.nKey==intKey ){
68608 rc = moveToRoot(pCur);
68611 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68617 assert( pCur->pPage );
68618 assert( pCur->pPage->isInit );
68619 assert( pCur->eState==CURSOR_VALID );
68620 assert( pCur->pPage->nCell > 0 );
68621 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
68622 assert( pCur->curIntKey || pIdxKey );
68626 MemPage *pPage = pCur->pPage;
68641 pCur->ix = (u16)idx;
68662 pCur->ix = (u16)idx;
68667 pCur->curFlags |= BTCF_ValidNKey;
68668 pCur->info.nKey = nCellKey;
68669 pCur->info.nSize = 0;
68716 pPage->xParseCell(pPage, pCellBody, &pCur->info);
68717 nCell = (int)pCur->info.nKey;
68722 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
68731 pCur->ix = (u16)idx;
68732 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
68733 pCur->curFlags &= ~BTCF_ValidOvfl;
68743 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
68753 pCur->ix = (u16)idx;
68765 assert( pCur->ix<pCur->pPage->nCell );
68766 pCur->ix = (u16)idx;
68777 pCur->ix = (u16)lwr;
68778 rc = moveToChild(pCur, chldPg);
68782 pCur->info.nSize = 0;
68783 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68795 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
68800 return (CURSOR_VALID!=pCur->eState);
68808 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
68812 assert( cursorOwnsBtShared(pCur) );
68813 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68818 if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
68819 if( NEVER(pCur->pPage->leaf==0) ) return -1;
68821 n = pCur->pPage->nCell;
68822 for(i=0; i<pCur->iPage; i++){
68823 n *= pCur->apPage[i]->nCell;
68848 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
68853 assert( cursorOwnsBtShared(pCur) );
68854 if( pCur->eState!=CURSOR_VALID ){
68855 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68856 rc = restoreCursorPosition(pCur);
68860 if( CURSOR_INVALID==pCur->eState ){
68863 if( pCur->eState==CURSOR_SKIPNEXT ){
68864 pCur->eState = CURSOR_VALID;
68865 if( pCur->skipNext>0 ) return SQLITE_OK;
68869 pPage = pCur->pPage;
68870 idx = ++pCur->ix;
68891 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
68893 return moveToLeftmost(pCur);
68896 if( pCur->iPage==0 ){
68897 pCur->eState = CURSOR_INVALID;
68900 moveToParent(pCur);
68901 pPage = pCur->pPage;
68902 }while( pCur->ix>=pPage->nCell );
68904 return sqlite3BtreeNext(pCur, 0);
68912 return moveToLeftmost(pCur);
68915 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
68918 assert( cursorOwnsBtShared(pCur) );
68920 pCur->info.nSize = 0;
68921 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68922 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
68923 pPage = pCur->pPage;
68924 if( (++pCur->ix)>=pPage->nCell ){
68925 pCur->ix--;
68926 return btreeNext(pCur);
68931 return moveToLeftmost(pCur);
68955 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
68959 assert( cursorOwnsBtShared(pCur) );
68960 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
68961 assert( pCur->info.nSize==0 );
68962 if( pCur->eState!=CURSOR_VALID ){
68963 rc = restoreCursorPosition(pCur);
68967 if( CURSOR_INVALID==pCur->eState ){
68970 if( CURSOR_SKIPNEXT==pCur->eState ){
68971 pCur->eState = CURSOR_VALID;
68972 if( pCur->skipNext<0 ) return SQLITE_OK;
68976 pPage = pCur->pPage;
68979 int idx = pCur->ix;
68980 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
68982 rc = moveToRightmost(pCur);
68984 while( pCur->ix==0 ){
68985 if( pCur->iPage==0 ){
68986 pCur->eState = CURSOR_INVALID;
68989 moveToParent(pCur);
68991 assert( pCur->info.nSize==0 );
68992 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
68994 pCur->ix--;
68995 pPage = pCur->pPage;
68997 rc = sqlite3BtreePrevious(pCur, 0);
69004 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
69005 assert( cursorOwnsBtShared(pCur) );
69008 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
69009 pCur->info.nSize = 0;
69010 if( pCur->eState!=CURSOR_VALID
69011 || pCur->ix==0
69012 || pCur->pPage->leaf==0
69014 return btreePrevious(pCur);
69016 pCur->ix--;
71480 static int balance(BtCursor *pCur){
71482 const int nMin = pCur->pBt->usableSize * 2 / 3;
71490 int iPage = pCur->iPage;
71491 MemPage *pPage = pCur->pPage;
71503 rc = balance_deeper(pPage, &pCur->apPage[1]);
71505 pCur->iPage = 1;
71506 pCur->ix = 0;
71507 pCur->aiIdx[0] = 0;
71508 pCur->apPage[0] = pPage;
71509 pCur->pPage = pCur->apPage[1];
71510 assert( pCur->pPage->nOverflow );
71518 MemPage * const pParent = pCur->apPage[iPage-1];
71519 int const iIdx = pCur->aiIdx[iPage-1];
71569 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
71571 pCur->hints&BTREE_BULKLOAD);
71591 pCur->iPage--;
71592 assert( pCur->iPage>=0 );
71593 pCur->pPage = pCur->apPage[pCur->iPage];
71649 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
71653 MemPage *pPage = pCur->pPage; /* Page being written */
71658 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd ){
71662 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
71663 0, pCur->info.nLocal);
71665 if( pCur->info.nLocal==nTotal ) return SQLITE_OK;
71668 iOffset = pCur->info.nLocal;
71671 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
71727 BtCursor *pCur, /* Insert data into the table of this cursor */
71737 Btree *p = pCur->pBtree;
71744 if( pCur->eState==CURSOR_FAULT ){
71745 assert( pCur->skipNext!=SQLITE_OK );
71746 return pCur->skipNext;
71749 assert( cursorOwnsBtShared(pCur) );
71750 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
71753 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
71760 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
71773 if( pCur->curFlags & BTCF_Multiple ){
71774 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
71778 if( pCur->pKeyInfo==0 ){
71782 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
71789 assert( pCur->curFlags & BTCF_ValidNKey );
71790 assert( pX->nKey==pCur->info.nKey );
71791 assert( pCur->info.nSize!=0 );
71800 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
71804 if( pCur->info.nSize!=0
71805 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
71808 return btreeOverwriteCell(pCur, pX);
71816 rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
71835 r.pKeyInfo = pCur->pKeyInfo;
71843 rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
71845 rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
71855 getCellInfo(pCur);
71856 if( pCur->info.nKey==pX->nKey ){
71861 return btreeOverwriteCell(pCur, &x2);
71866 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
71868 pPage = pCur->pPage;
71877 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
71886 idx = pCur->ix;
71920 idx = ++pCur->ix;
71921 pCur->curFlags &= ~BTCF_ValidNKey;
71949 pCur->info.nSize = 0;
71952 pCur->curFlags &= ~(BTCF_ValidNKey);
71953 rc = balance(pCur);
71959 pCur->pPage->nOverflow = 0;
71960 pCur->eState = CURSOR_INVALID;
71962 btreeReleaseAllCursorPages(pCur);
71963 if( pCur->pKeyInfo ){
71964 assert( pCur->pKey==0 );
71965 pCur->pKey = sqlite3Malloc( pX->nKey );
71966 if( pCur->pKey==0 ){
71969 memcpy(pCur->pKey, pX->pKey, pX->nKey);
71972 pCur->eState = CURSOR_REQUIRESEEK;
71973 pCur->nKey = pX->nKey;
71976 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
71999 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
72000 Btree *p = pCur->pBtree;
72011 assert( cursorOwnsBtShared(pCur) );
72014 assert( pCur->curFlags & BTCF_WriteFlag );
72015 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
72016 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
72018 if( pCur->eState==CURSOR_REQUIRESEEK ){
72019 rc = btreeRestoreCursorPosition(pCur);
72022 assert( pCur->eState==CURSOR_VALID );
72024 iCellDepth = pCur->iPage;
72025 iCellIdx = pCur->ix;
72026 pPage = pCur->pPage;
72046 rc = saveCursorKey(pCur);
72061 rc = sqlite3BtreePrevious(pCur, 0);
72068 if( pCur->curFlags & BTCF_Multiple ){
72069 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
72075 if( pCur->pKeyInfo==0 ){
72076 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
72094 MemPage *pLeaf = pCur->pPage;
72103 if( iCellDepth<pCur->iPage-1 ){
72104 n = pCur->apPage[iCellDepth+1]->pgno;
72106 n = pCur->pPage->pgno;
72137 rc = balance(pCur);
72138 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
72139 releasePageNotNull(pCur->pPage);
72140 pCur->iPage--;
72141 while( pCur->iPage>iCellDepth ){
72142 releasePage(pCur->apPage[pCur->iPage--]);
72144 pCur->pPage = pCur->apPage[pCur->iPage];
72145 rc = balance(pCur);
72150 assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
72151 assert( pPage==pCur->pPage || CORRUPT_DB );
72153 pCur->eState = CURSOR_SKIPNEXT;
72155 pCur->skipNext = -1;
72156 pCur->ix = pPage->nCell-1;
72158 pCur->skipNext = 1;
72161 rc = moveToRoot(pCur);
72163 btreeReleaseAllCursorPages(pCur);
72164 pCur->eState = CURSOR_REQUIRESEEK;
72429 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
72430 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
72630 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
72634 rc = moveToRoot(pCur);
72651 pPage = pCur->pPage;
72668 if( pCur->iPage==0 ){
72671 return moveToRoot(pCur);
72673 moveToParent(pCur);
72674 }while ( pCur->ix>=pCur->pPage->nCell );
72676 pCur->ix++;
72677 pPage = pCur->pPage;
72683 iIdx = pCur->ix;
72685 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
72687 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
73545 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
73546 pCur->curFlags |= BTCF_Incrblob;
73547 pCur->pBtree->hasIncrblobCur = 1;
75550 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
75557 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
75561 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
75573 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
75582 assert( sqlite3BtreeCursorIsValid(pCur) );
75588 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
75596 rc = vdbeMemFromBtreeResize(pCur, offset, amt, pMem);
80968 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
80981 assert( sqlite3BtreeCursorIsValid(pCur) );
80982 nCellKey = sqlite3BtreePayloadSize(pCur);
80987 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
81055 BtCursor *pCur;
81059 pCur = pC->uc.pCursor;
81060 assert( sqlite3BtreeCursorIsValid(pCur) );
81061 nCellKey = sqlite3BtreePayloadSize(pCur);
81069 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
87092 VdbeCursor *pCur;
87097 pCur = p->apCsr[pOp->p1];
87098 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
87099 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
87162 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
87163 if( pCur==0 ) goto no_mem;
87164 pCur->nullRow = 1;
87165 pCur->isOrdered = 1;
87166 pCur->pgnoRoot = p2;
87168 pCur->wrFlag = wrFlag;
87170 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
87171 pCur->pKeyInfo = pKeyInfo;
87176 pCur->isTable = pOp->p4type!=P4_KEYINFO;
87185 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
90479 VdbeCursor *pCur;
90485 pCur = 0;
90501 pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
90502 if( pCur ){
90503 pCur->uc.pVCur = pVCur;
90542 VdbeCursor *pCur;
90549 pCur = p->apCsr[pOp->p1];
90552 assert( pCur->eCurType==CURTYPE_VTAB );
90553 pVCur = pCur->uc.pVCur;
90572 pCur->nullRow = 0;
90600 VdbeCursor *pCur = p->apCsr[pOp->p1];
90601 assert( pCur->eCurType==CURTYPE_VTAB );
90605 if( pCur->nullRow ){
90609 pVtab = pCur->uc.pVCur->pVtab;
90622 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
90651 VdbeCursor *pCur;
90654 pCur = p->apCsr[pOp->p1];
90655 assert( pCur->eCurType==CURTYPE_VTAB );
90656 if( pCur->nullRow ){
90659 pVtab = pCur->uc.pVCur->pVtab;
90669 rc = pModule->xNext(pCur->uc.pVCur);
90672 res = pModule->xEof(pCur->uc.pVCur);
180866 JsonEachCursor *pCur;
180869 pCur = sqlite3_malloc( sizeof(*pCur) );
180870 if( pCur==0 ) return SQLITE_NOMEM;
180871 memset(pCur, 0, sizeof(*pCur));
180872 *ppCursor = &pCur->base;
180880 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
180881 pCur->bRecursive = 1;
182758 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
182759 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
182765 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
182767 int ii = 1 - pCur->bPoint;
182769 assert( pCur->bPoint || pCur->nPoint );
182770 if( pCur->aNode[ii]==0 ){
182772 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
182773 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
182775 return pCur->aNode[ii];
182782 RtreeCursor *pCur, /* The cursor */
182788 if( pCur->nPoint>=pCur->nPointAlloc ){
182789 int nNew = pCur->nPointAlloc*2 + 8;
182790 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
182792 pCur->aPoint = pNew;
182793 pCur->nPointAlloc = nNew;
182795 i = pCur->nPoint++;
182796 pNew = pCur->aPoint + i;
182803 pParent = pCur->aPoint + j;
182805 rtreeSearchPointSwap(pCur, j, i);
182817 RtreeCursor *pCur, /* The cursor */
182822 pFirst = rtreeSearchPointFirst(pCur);
182823 pCur->anQueue[iLevel]++;
182828 if( pCur->bPoint ){
182830 pNew = rtreeEnqueue(pCur, rScore, iLevel);
182832 ii = (int)(pNew - pCur->aPoint) + 1;
182834 assert( pCur->aNode[ii]==0 );
182835 pCur->aNode[ii] = pCur->aNode[0];
182837 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
182839 pCur->aNode[0] = 0;
182840 *pNew = pCur->sPoint;
182842 pCur->sPoint.rScore = rScore;
182843 pCur->sPoint.iLevel = iLevel;
182844 pCur->bPoint = 1;
182845 return &pCur->sPoint;
182847 return rtreeEnqueue(pCur, rScore, iLevel);
182853 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
182860 printf(" %p\n", pCur->aNode[idx]);
182865 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
182868 if( pCur->bPoint ){
182869 tracePoint(&pCur->sPoint, -1, pCur);
182871 for(ii=0; ii<pCur->nPoint; ii++){
182872 if( ii>0 || pCur->bPoint ) printf(" ");
182873 tracePoint(&pCur->aPoint[ii], ii, pCur);
182931 static int rtreeStepToLeaf(RtreeCursor *pCur){
182933 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
182938 int nConstraint = pCur->nConstraint;
182944 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
182945 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
182954 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
182977 RTREE_QUEUE_TRACE(pCur, "POP-S:");
182978 rtreeSearchPointPop(pCur);
182981 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
182986 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
182990 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
182991 rtreeSearchPointPop(pCur);
182994 pCur->atEOF = p==0;
222915 stmt_cursor *pCur;
222916 pCur = sqlite3_malloc( sizeof(*pCur) );
222917 if( pCur==0 ) return SQLITE_NOMEM;
222918 memset(pCur, 0, sizeof(*pCur));
222919 pCur->db = ((stmt_vtab*)p)->db;
222920 *ppCursor = &pCur->base;
222937 stmt_cursor *pCur = (stmt_cursor*)cur;
222938 pCur->iRowid++;
222939 pCur->pStmt = sqlite3_next_stmt(pCur->db, pCur->pStmt);
222952 stmt_cursor *pCur = (stmt_cursor*)cur;
222955 sqlite3_result_text(ctx, sqlite3_sql(pCur->pStmt), -1, SQLITE_TRANSIENT);
222959 sqlite3_result_int(ctx, sqlite3_column_count(pCur->pStmt));
222963 sqlite3_result_int(ctx, sqlite3_stmt_readonly(pCur->pStmt));
222967 sqlite3_result_int(ctx, sqlite3_stmt_busy(pCur->pStmt));
222981 sqlite3_result_int(ctx, sqlite3_stmt_status(pCur->pStmt,
222994 stmt_cursor *pCur = (stmt_cursor*)cur;
222995 *pRowid = pCur->iRowid;
223004 stmt_cursor *pCur = (stmt_cursor*)cur;
223005 return pCur->pStmt==0;
223019 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
223020 pCur->pStmt = 0;
223021 pCur->iRowid = 0;