Lines Matching defs:pCur
6476 ** ^The current value of the requested parameter is written into *pCur
6486 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
49267 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
49268 sqlite3BtreeEnter(pCur->pBtree);
49270 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
49271 sqlite3BtreeLeave(pCur->pBtree);
49825 ** Invalidate the overflow page-list cache for cursor pCur, if any.
49827 static void invalidateOverflowCache(BtCursor *pCur){
49828 assert( cursorHoldsMutex(pCur) );
49829 sqlite3_free(pCur->aOverflow);
49830 pCur->aOverflow = 0;
49958 static int saveCursorPosition(BtCursor *pCur){
49961 assert( CURSOR_VALID==pCur->eState );
49962 assert( 0==pCur->pKey );
49963 assert( cursorHoldsMutex(pCur) );
49965 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
49969 ** stores the integer key in pCur->nKey. In this case this value is
49970 ** all that is required. Otherwise, if pCur is not open on an intKey
49971 ** table, then malloc space for and store the pCur->nKey bytes of key
49974 if( 0==pCur->apPage[0]->intKey ){
49975 void *pKey = sqlite3Malloc( (int)pCur->nKey );
49977 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
49979 pCur->pKey = pKey;
49987 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
49991 for(i=0; i<=pCur->iPage; i++){
49992 releasePage(pCur->apPage[i]);
49993 pCur->apPage[i] = 0;
49995 pCur->iPage = -1;
49996 pCur->eState = CURSOR_REQUIRESEEK;
49999 invalidateOverflowCache(pCur);
50027 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
50028 assert( cursorHoldsMutex(pCur) );
50029 sqlite3_free(pCur->pKey);
50030 pCur->pKey = 0;
50031 pCur->eState = CURSOR_INVALID;
50040 BtCursor *pCur, /* Cursor open on the btree to be searched */
50054 pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
50057 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
50061 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
50063 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
50075 static int btreeRestoreCursorPosition(BtCursor *pCur){
50077 assert( cursorHoldsMutex(pCur) );
50078 assert( pCur->eState>=CURSOR_REQUIRESEEK );
50079 if( pCur->eState==CURSOR_FAULT ){
50080 return pCur->skipNext;
50082 pCur->eState = CURSOR_INVALID;
50083 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
50085 sqlite3_free(pCur->pKey);
50086 pCur->pKey = 0;
50087 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
50105 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
50108 rc = restoreCursorPosition(pCur);
50113 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
51418 BtCursor *pCur;
51423 pCur = pBt->pCursor;
51424 while( pCur ){
51425 BtCursor *pTmp = pCur;
51426 pCur = pCur->pNext;
52646 BtCursor *pCur;
52648 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
52649 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
52847 ** on pCur to initialize the memory space prior to invoking this routine.
52854 BtCursor *pCur /* Space for new cursor */
52883 pCur->pgnoRoot = (Pgno)iTable;
52884 pCur->iPage = -1;
52885 pCur->pKeyInfo = pKeyInfo;
52886 pCur->pBtree = p;
52887 pCur->pBt = pBt;
52888 pCur->wrFlag = (u8)wrFlag;
52889 pCur->pNext = pBt->pCursor;
52890 if( pCur->pNext ){
52891 pCur->pNext->pPrev = pCur;
52893 pBt->pCursor = pCur;
52894 pCur->eState = CURSOR_INVALID;
52895 pCur->cachedRowid = 0;
52903 BtCursor *pCur /* Write new cursor here */
52907 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
52938 ** as pCur and having the same root page number as pCur. The value is
52948 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
52950 for(p=pCur->pBt->pCursor; p; p=p->pNext){
52951 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
52953 assert( pCur->cachedRowid==iRowid );
52962 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
52963 return pCur->cachedRowid;
52970 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
52971 Btree *pBtree = pCur->pBtree;
52974 BtShared *pBt = pCur->pBt;
52976 sqlite3BtreeClearCursor(pCur);
52977 if( pCur->pPrev ){
52978 pCur->pPrev->pNext = pCur->pNext;
52980 pBt->pCursor = pCur->pNext;
52982 if( pCur->pNext ){
52983 pCur->pNext->pPrev = pCur->pPrev;
52985 for(i=0; i<=pCur->iPage; i++){
52986 releasePage(pCur->apPage[i]);
52989 invalidateOverflowCache(pCur);
52990 /* sqlite3_free(pCur); */
53012 static void assertCellInfo(BtCursor *pCur){
53014 int iPage = pCur->iPage;
53016 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
53017 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
53024 static void getCellInfo(BtCursor *pCur){
53025 if( pCur->info.nSize==0 ){
53026 int iPage = pCur->iPage;
53027 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
53028 pCur->validNKey = 1;
53030 assertCellInfo(pCur);
53035 #define getCellInfo(pCur) \
53036 if( pCur->info.nSize==0 ){ \
53037 int iPage = pCur->iPage; \
53038 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
53039 pCur->validNKey = 1; \
53041 assertCellInfo(pCur); \
53051 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
53052 return pCur && pCur->eState==CURSOR_VALID;
53068 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
53069 assert( cursorHoldsMutex(pCur) );
53070 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
53071 if( pCur->eState!=CURSOR_VALID ){
53074 getCellInfo(pCur);
53075 *pSize = pCur->info.nKey;
53092 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
53093 assert( cursorHoldsMutex(pCur) );
53094 assert( pCur->eState==CURSOR_VALID );
53095 getCellInfo(pCur);
53096 *pSize = pCur->info.nData;
53210 ** for the entry that the pCur cursor is pointing to. If the eOp
53237 BtCursor *pCur, /* Cursor pointing to entry to read from */
53247 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
53248 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
53251 assert( pCur->eState==CURSOR_VALID );
53252 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53253 assert( cursorHoldsMutex(pCur) );
53255 getCellInfo(pCur);
53256 aPayload = pCur->info.pCell + pCur->info.nHeader;
53257 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
53259 if( NEVER(offset+amt > nKey+pCur->info.nData)
53260 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
53267 if( offset<pCur->info.nLocal ){
53269 if( a+offset>pCur->info.nLocal ){
53270 a = pCur->info.nLocal - offset;
53277 offset -= pCur->info.nLocal;
53284 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
53294 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
53295 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
53296 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
53299 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
53308 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
53310 nextPage = pCur->aOverflow[iIdx];
53319 if( pCur->aOverflow ){
53320 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
53321 pCur->aOverflow[iIdx] = nextPage;
53333 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
53334 nextPage = pCur->aOverflow[iIdx+1];
53403 ** Read part of the key associated with cursor pCur. Exactly
53407 ** The caller must ensure that pCur is pointing to a valid row
53414 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53415 assert( cursorHoldsMutex(pCur) );
53416 assert( pCur->eState==CURSOR_VALID );
53417 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53418 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53419 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
53423 ** Read part of the data associated with cursor pCur. Exactly
53431 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53435 if ( pCur->eState==CURSOR_INVALID ){
53440 assert( cursorHoldsMutex(pCur) );
53441 rc = restoreCursorPosition(pCur);
53443 assert( pCur->eState==CURSOR_VALID );
53444 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53445 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53446 rc = accessPayload(pCur, offset, amt, pBuf, 0);
53453 ** pCur cursor is pointing to. The pointer is to the beginning of
53471 BtCursor *pCur, /* Cursor pointing to entry to read from */
53480 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
53481 assert( pCur->eState==CURSOR_VALID );
53482 assert( cursorHoldsMutex(pCur) );
53483 pPage = pCur->apPage[pCur->iPage];
53484 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53485 if( NEVER(pCur->info.nSize==0) ){
53486 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
53487 &pCur->info);
53489 aPayload = pCur->info.pCell;
53490 aPayload += pCur->info.nHeader;
53494 nKey = (int)pCur->info.nKey;
53498 nLocal = pCur->info.nLocal - nKey;
53500 nLocal = pCur->info.nLocal;
53509 ** For the entry that cursor pCur is point to, return as
53522 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
53524 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53525 assert( cursorHoldsMutex(pCur) );
53526 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53527 p = (const void*)fetchPayload(pCur, pAmt, 0);
53531 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
53533 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53534 assert( cursorHoldsMutex(pCur) );
53535 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53536 p = (const void*)fetchPayload(pCur, pAmt, 1);
53551 static int moveToChild(BtCursor *pCur, u32 newPgno){
53553 int i = pCur->iPage;
53555 BtShared *pBt = pCur->pBt;
53557 assert( cursorHoldsMutex(pCur) );
53558 assert( pCur->eState==CURSOR_VALID );
53559 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
53560 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
53565 pCur->apPage[i+1] = pNewPage;
53566 pCur->aiIdx[i+1] = 0;
53567 pCur->iPage++;
53569 pCur->info.nSize = 0;
53570 pCur->validNKey = 0;
53571 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
53600 ** pCur->idx is set to the cell index that contains the pointer
53602 ** right-most child page then pCur->idx is set to one more than
53605 static void moveToParent(BtCursor *pCur){
53606 assert( cursorHoldsMutex(pCur) );
53607 assert( pCur->eState==CURSOR_VALID );
53608 assert( pCur->iPage>0 );
53609 assert( pCur->apPage[pCur->iPage] );
53618 pCur->apPage[pCur->iPage-1],
53619 pCur->aiIdx[pCur->iPage-1],
53620 pCur->apPage[pCur->iPage]->pgno
53623 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
53625 releasePage(pCur->apPage[pCur->iPage]);
53626 pCur->iPage--;
53627 pCur->info.nSize = 0;
53628 pCur->validNKey = 0;
53652 static int moveToRoot(BtCursor *pCur){
53655 Btree *p = pCur->pBtree;
53658 assert( cursorHoldsMutex(pCur) );
53662 if( pCur->eState>=CURSOR_REQUIRESEEK ){
53663 if( pCur->eState==CURSOR_FAULT ){
53664 assert( pCur->skipNext!=SQLITE_OK );
53665 return pCur->skipNext;
53667 sqlite3BtreeClearCursor(pCur);
53670 if( pCur->iPage>=0 ){
53672 for(i=1; i<=pCur->iPage; i++){
53673 releasePage(pCur->apPage[i]);
53675 pCur->iPage = 0;
53676 }else if( pCur->pgnoRoot==0 ){
53677 pCur->eState = CURSOR_INVALID;
53680 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
53682 pCur->eState = CURSOR_INVALID;
53685 pCur->iPage = 0;
53687 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
53691 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
53692 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
53703 pRoot = pCur->apPage[0];
53704 assert( pRoot->pgno==pCur->pgnoRoot );
53705 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
53707 pCur->aiIdx[0] = 0;
53708 pCur->info.nSize = 0;
53709 pCur->atLast = 0;
53710 pCur->validNKey = 0;
53716 pCur->eState = CURSOR_VALID;
53717 rc = moveToChild(pCur, subpage);
53719 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
53731 static int moveToLeftmost(BtCursor *pCur){
53736 assert( cursorHoldsMutex(pCur) );
53737 assert( pCur->eState==CURSOR_VALID );
53738 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53739 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53740 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
53741 rc = moveToChild(pCur, pgno);
53756 static int moveToRightmost(BtCursor *pCur){
53761 assert( cursorHoldsMutex(pCur) );
53762 assert( pCur->eState==CURSOR_VALID );
53763 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53765 pCur->aiIdx[pCur->iPage] = pPage->nCell;
53766 rc = moveToChild(pCur, pgno);
53769 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
53770 pCur->info.nSize = 0;
53771 pCur->validNKey = 0;
53780 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
53783 assert( cursorHoldsMutex(pCur) );
53784 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53785 rc = moveToRoot(pCur);
53787 if( pCur->eState==CURSOR_INVALID ){
53788 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53791 assert( pCur->apPage[pCur->iPage]->nCell>0 );
53793 rc = moveToLeftmost(pCur);
53803 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
53806 assert( cursorHoldsMutex(pCur) );
53807 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53810 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
53815 for(ii=0; ii<pCur->iPage; ii++){
53816 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
53818 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
53819 assert( pCur->apPage[pCur->iPage]->leaf );
53824 rc = moveToRoot(pCur);
53826 if( CURSOR_INVALID==pCur->eState ){
53827 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53830 assert( pCur->eState==CURSOR_VALID );
53832 rc = moveToRightmost(pCur);
53833 pCur->atLast = rc==SQLITE_OK ?1:0;
53868 BtCursor *pCur, /* The cursor to be moved */
53876 assert( cursorHoldsMutex(pCur) );
53877 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53879 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
53883 if( pCur->eState==CURSOR_VALID && pCur->validNKey
53884 && pCur->apPage[0]->intKey
53886 if( pCur->info.nKey==intKey ){
53890 if( pCur->atLast && pCur->info.nKey<intKey ){
53896 rc = moveToRoot(pCur);
53900 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
53901 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
53902 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
53903 if( pCur->eState==CURSOR_INVALID ){
53905 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53908 assert( pCur->apPage[0]->intKey || pIdxKey );
53912 MemPage *pPage = pCur->apPage[pCur->iPage];
53926 pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
53928 pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
53933 assert( idx==pCur->aiIdx[pCur->iPage] );
53934 pCur->info.nSize = 0;
53951 pCur->validNKey = 1;
53952 pCur->info.nKey = nCellKey;
53986 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
53987 nCell = (int)pCur->info.nKey;
53993 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
54020 pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
54032 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
54037 pCurpCur->iPage] = (u16)lwr;
54038 pCur->info.nSize = 0;
54039 pCur->validNKey = 0;
54040 rc = moveToChild(pCur, chldPg);
54055 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
54060 return (CURSOR_VALID!=pCur->eState);
54069 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
54074 assert( cursorHoldsMutex(pCur) );
54075 rc = restoreCursorPosition(pCur);
54080 if( CURSOR_INVALID==pCur->eState ){
54084 if( pCur->skipNext>0 ){
54085 pCur->skipNext = 0;
54089 pCur->skipNext = 0;
54091 pPage = pCur->apPage[pCur->iPage];
54092 idx = ++pCur->aiIdx[pCur->iPage];
54097 ** the page while cursor pCur is holding a reference to it. Which can
54102 pCur->info.nSize = 0;
54103 pCur->validNKey = 0;
54106 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
54108 rc = moveToLeftmost(pCur);
54113 if( pCur->iPage==0 ){
54115 pCur->eState = CURSOR_INVALID;
54118 moveToParent(pCur);
54119 pPage = pCur->apPage[pCur->iPage];
54120 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
54123 rc = sqlite3BtreeNext(pCur, pRes);
54133 rc = moveToLeftmost(pCur);
54144 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
54148 assert( cursorHoldsMutex(pCur) );
54149 rc = restoreCursorPosition(pCur);
54153 pCur->atLast = 0;
54154 if( CURSOR_INVALID==pCur->eState ){
54158 if( pCur->skipNext<0 ){
54159 pCur->skipNext = 0;
54163 pCur->skipNext = 0;
54165 pPage = pCur->apPage[pCur->iPage];
54168 int idx = pCur->aiIdx[pCur->iPage];
54169 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
54173 rc = moveToRightmost(pCur);
54175 while( pCur->aiIdx[pCur->iPage]==0 ){
54176 if( pCur->iPage==0 ){
54177 pCur->eState = CURSOR_INVALID;
54181 moveToParent(pCur);
54183 pCur->info.nSize = 0;
54184 pCur->validNKey = 0;
54186 pCur->aiIdx[pCur->iPage]--;
54187 pPage = pCur->apPage[pCur->iPage];
54189 rc = sqlite3BtreePrevious(pCur, pRes);
56005 ** The page that pCur currently points to has just been modified in
56014 static int balance(BtCursor *pCur){
56016 const int nMin = pCur->pBt->usableSize * 2 / 3;
56024 int iPage = pCur->iPage;
56025 MemPage *pPage = pCur->apPage[iPage];
56035 rc = balance_deeper(pPage, &pCur->apPage[1]);
56037 pCur->iPage = 1;
56038 pCur->aiIdx[0] = 0;
56039 pCur->aiIdx[1] = 0;
56040 assert( pCur->apPage[1]->nOverflow );
56048 MemPage * const pParent = pCur->apPage[iPage-1];
56049 int const iIdx = pCur->aiIdx[iPage-1];
56095 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
56116 pCur->iPage--;
56137 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
56139 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
56140 ** a positive value if pCur points at an etry that is larger than
56144 ** cursor pCur is pointing at the existing copy of a row that is to be
56145 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
56150 BtCursor *pCur, /* Insert data into the table of this cursor */
56162 Btree *p = pCur->pBtree;
56167 if( pCur->eState==CURSOR_FAULT ){
56168 assert( pCur->skipNext!=SQLITE_OK );
56169 return pCur->skipNext;
56172 assert( cursorHoldsMutex(pCur) );
56173 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE
56175 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56182 assert( (pKey==0)==(pCur->pKeyInfo==0) );
56187 if( pCur->pKeyInfo==0 ){
56202 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56205 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
56208 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
56210 pPage = pCur->apPage[pCur->iPage];
56215 pCur->pgnoRoot, nKey, nData, pPage->pgno,
56225 idx = pCur->aiIdx[pCur->iPage];
56243 idx = ++pCur->aiIdx[pCur->iPage];
56270 pCur->info.nSize = 0;
56271 pCur->validNKey = 0;
56273 rc = balance(pCur);
56279 pCur->apPage[pCur->iPage]->nOverflow = 0;
56280 pCur->eState = CURSOR_INVALID;
56282 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
56292 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
56293 Btree *p = pCur->pBtree;
56301 assert( cursorHoldsMutex(pCur) );
56304 assert( pCur->wrFlag );
56305 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56306 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
56308 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
56309 || NEVER(pCur->eState!=CURSOR_VALID)
56316 if( pCur->pKeyInfo==0 ){
56317 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
56320 iCellDepth = pCur->iPage;
56321 iCellIdx = pCur->aiIdx[iCellDepth];
56322 pPage = pCur->apPage[iCellDepth];
56334 rc = sqlite3BtreePrevious(pCur, ¬Used);
56343 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56357 MemPage *pLeaf = pCur->apPage[pCur->iPage];
56359 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
56381 ** pCur is pointing to the leaf page from which a cell was removed to
56390 rc = balance(pCur);
56391 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
56392 while( pCur->iPage>iCellDepth ){
56393 releasePage(pCur->apPage[pCur->iPage--]);
56395 rc = balance(pCur);
56399 moveToRoot(pCur);
56836 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
56843 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
56847 if( pCur->pgnoRoot==0 ){
56851 rc = moveToRoot(pCur);
56864 pPage = pCur->apPage[pCur->iPage];
56872 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
56881 if( pCur->iPage==0 ){
56886 moveToParent(pCur);
56887 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
56889 pCur->aiIdx[pCur->iPage]++;
56890 pPage = pCur->apPage[pCur->iPage];
56896 iIdx = pCur->aiIdx[pCur->iPage];
56898 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
56900 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
57619 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
57620 assert( cursorHoldsMutex(pCur) );
57621 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57622 invalidateOverflowCache(pCur);
57623 pCur->isIncrblobHandle = 1;
59267 ** The data or key is taken from the entry that pCur is currently pointing
59279 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
59289 assert( sqlite3BtreeCursorIsValid(pCur) );
59295 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
59297 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
59310 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
59312 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
62578 ** pCur points at an index entry created using the OP_MakeRecord opcode.
62582 ** pCur might be pointing to text obtained from a corrupt database file.
62585 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
62600 assert( sqlite3BtreeCursorIsValid(pCur) );
62601 VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
62602 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
62607 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
62672 BtCursor *pCur = pC->pCursor;
62675 assert( sqlite3BtreeCursorIsValid(pCur) );
62676 VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
62677 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
65186 VdbeCursor *pCur;
65397 VdbeCursor *pCur;
65410 VdbeCursor *pCur;
65425 VdbeCursor *pCur;
68018 VdbeCursor *pCur;
68070 u.ax.pCur = allocateCursor(p, pOp->p1, u.ax.nField, u.ax.iDb, 1);
68071 if( u.ax.pCur==0 ) goto no_mem;
68072 u.ax.pCur->nullRow = 1;
68073 u.ax.pCur->isOrdered = 1;
68074 rc = sqlite3BtreeCursor(u.ax.pX, u.ax.p2, u.ax.wrFlag, u.ax.pKeyInfo, u.ax.pCur->pCursor);
68075 u.ax.pCur->pKeyInfo = u.ax.pKeyInfo;
68085 u.ax.pCur->isTable = pOp->p4type!=P4_KEYINFO;
68086 u.ax.pCur->isIndex = !u.ax.pCur->isTable;
70696 VdbeCursor *pCur;
70702 u.cl.pCur = 0;
70714 u.cl.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
70715 if( u.cl.pCur ){
70716 u.cl.pCur->pVtabCursor = u.cl.pVtabCursor;
70717 u.cl.pCur->pModule = u.cl.pVtabCursor->pVtab->pModule;
70755 VdbeCursor *pCur;
70763 u.cm.pCur = p->apCsr[pOp->p1];
70766 assert( u.cm.pCur->pVtabCursor );
70767 u.cm.pVtabCursor = u.cm.pCur->pVtabCursor;
70797 u.cm.pCur->nullRow = 0;
70818 VdbeCursor *pCur = p->apCsr[pOp->p1];
70819 assert( pCur->pVtabCursor );
70823 if( pCur->nullRow ){
70827 u.cn.pVtab = pCur->pVtabCursor->pVtab;
70840 rc = u.cn.pModule->xColumn(pCur->pVtabCursor, &u.cn.sContext, pOp->p2);
70874 VdbeCursor *pCur;
70878 u.co.pCur = p->apCsr[pOp->p1];
70879 assert( u.co.pCur->pVtabCursor );
70880 if( u.co.pCur->nullRow ){
70883 u.co.pVtab = u.co.pCur->pVtabCursor->pVtab;
70894 rc = u.co.pModule->xNext(u.co.pCur->pVtabCursor);
70898 u.co.res = u.co.pModule->xEof(u.co.pCur->pVtabCursor);
