Lines Matching refs:pCur
6278 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
47390 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
47391 sqlite3BtreeEnter(pCur->pBtree);
47393 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
47394 sqlite3BtreeLeave(pCur->pBtree);
47952 static void invalidateOverflowCache(BtCursor *pCur){
47953 assert( cursorHoldsMutex(pCur) );
47954 sqlite3_free(pCur->aOverflow);
47955 pCur->aOverflow = 0;
48083 static int saveCursorPosition(BtCursor *pCur){
48086 assert( CURSOR_VALID==pCur->eState );
48087 assert( 0==pCur->pKey );
48088 assert( cursorHoldsMutex(pCur) );
48090 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
48099 if( 0==pCur->apPage[0]->intKey ){
48100 void *pKey = sqlite3Malloc( (int)pCur->nKey );
48102 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
48104 pCur->pKey = pKey;
48112 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
48116 for(i=0; i<=pCur->iPage; i++){
48117 releasePage(pCur->apPage[i]);
48118 pCur->apPage[i] = 0;
48120 pCur->iPage = -1;
48121 pCur->eState = CURSOR_REQUIRESEEK;
48124 invalidateOverflowCache(pCur);
48152 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
48153 assert( cursorHoldsMutex(pCur) );
48154 sqlite3_free(pCur->pKey);
48155 pCur->pKey = 0;
48156 pCur->eState = CURSOR_INVALID;
48165 BtCursor *pCur, /* Cursor open on the btree to be searched */
48177 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
48183 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
48197 static int btreeRestoreCursorPosition(BtCursor *pCur){
48199 assert( cursorHoldsMutex(pCur) );
48200 assert( pCur->eState>=CURSOR_REQUIRESEEK );
48201 if( pCur->eState==CURSOR_FAULT ){
48202 return pCur->skipNext;
48204 pCur->eState = CURSOR_INVALID;
48205 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
48207 sqlite3_free(pCur->pKey);
48208 pCur->pKey = 0;
48209 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
48227 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
48230 rc = restoreCursorPosition(pCur);
48235 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
49536 BtCursor *pCur;
49541 pCur = pBt->pCursor;
49542 while( pCur ){
49543 BtCursor *pTmp = pCur;
49544 pCur = pCur->pNext;
50753 BtCursor *pCur;
50755 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
50756 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
50963 BtCursor *pCur /* Space for new cursor */
50991 pCur->pgnoRoot = (Pgno)iTable;
50992 pCur->iPage = -1;
50993 pCur->pKeyInfo = pKeyInfo;
50994 pCur->pBtree = p;
50995 pCur->pBt = pBt;
50996 pCur->wrFlag = (u8)wrFlag;
50997 pCur->pNext = pBt->pCursor;
50998 if( pCur->pNext ){
50999 pCur->pNext->pPrev = pCur;
51001 pBt->pCursor = pCur;
51002 pCur->eState = CURSOR_INVALID;
51003 pCur->cachedRowid = 0;
51011 BtCursor *pCur /* Write new cursor here */
51015 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
51056 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
51058 for(p=pCur->pBt->pCursor; p; p=p->pNext){
51059 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
51061 assert( pCur->cachedRowid==iRowid );
51070 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
51071 return pCur->cachedRowid;
51078 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
51079 Btree *pBtree = pCur->pBtree;
51082 BtShared *pBt = pCur->pBt;
51084 sqlite3BtreeClearCursor(pCur);
51085 if( pCur->pPrev ){
51086 pCur->pPrev->pNext = pCur->pNext;
51088 pBt->pCursor = pCur->pNext;
51090 if( pCur->pNext ){
51091 pCur->pNext->pPrev = pCur->pPrev;
51093 for(i=0; i<=pCur->iPage; i++){
51094 releasePage(pCur->apPage[i]);
51097 invalidateOverflowCache(pCur);
51120 static void assertCellInfo(BtCursor *pCur){
51122 int iPage = pCur->iPage;
51124 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
51125 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
51132 static void getCellInfo(BtCursor *pCur){
51133 if( pCur->info.nSize==0 ){
51134 int iPage = pCur->iPage;
51135 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
51136 pCur->validNKey = 1;
51138 assertCellInfo(pCur);
51143 #define getCellInfo(pCur) \
51144 if( pCur->info.nSize==0 ){ \
51145 int iPage = pCur->iPage; \
51146 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
51147 pCur->validNKey = 1; \
51149 assertCellInfo(pCur); \
51159 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
51160 return pCur && pCur->eState==CURSOR_VALID;
51176 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
51177 assert( cursorHoldsMutex(pCur) );
51178 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
51179 if( pCur->eState!=CURSOR_VALID ){
51182 getCellInfo(pCur);
51183 *pSize = pCur->info.nKey;
51200 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
51201 assert( cursorHoldsMutex(pCur) );
51202 assert( pCur->eState==CURSOR_VALID );
51203 getCellInfo(pCur);
51204 *pSize = pCur->info.nData;
51345 BtCursor *pCur, /* Cursor pointing to entry to read from */
51355 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
51356 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
51359 assert( pCur->eState==CURSOR_VALID );
51360 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51361 assert( cursorHoldsMutex(pCur) );
51363 getCellInfo(pCur);
51364 aPayload = pCur->info.pCell + pCur->info.nHeader;
51365 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
51367 if( NEVER(offset+amt > nKey+pCur->info.nData)
51368 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
51375 if( offset<pCur->info.nLocal ){
51377 if( a+offset>pCur->info.nLocal ){
51378 a = pCur->info.nLocal - offset;
51385 offset -= pCur->info.nLocal;
51392 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
51402 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
51403 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
51404 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
51407 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
51416 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
51418 nextPage = pCur->aOverflow[iIdx];
51427 if( pCur->aOverflow ){
51428 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
51429 pCur->aOverflow[iIdx] = nextPage;
51441 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
51442 nextPage = pCur->aOverflow[iIdx+1];
51488 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
51489 assert( cursorHoldsMutex(pCur) );
51490 assert( pCur->eState==CURSOR_VALID );
51491 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
51492 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
51493 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
51505 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
51509 if ( pCur->eState==CURSOR_INVALID ){
51514 assert( cursorHoldsMutex(pCur) );
51515 rc = restoreCursorPosition(pCur);
51517 assert( pCur->eState==CURSOR_VALID );
51518 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
51519 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
51520 rc = accessPayload(pCur, offset, amt, pBuf, 0);
51545 BtCursor *pCur, /* Cursor pointing to entry to read from */
51554 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
51555 assert( pCur->eState==CURSOR_VALID );
51556 assert( cursorHoldsMutex(pCur) );
51557 pPage = pCur->apPage[pCur->iPage];
51558 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51559 if( NEVER(pCur->info.nSize==0) ){
51560 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
51561 &pCur->info);
51563 aPayload = pCur->info.pCell;
51564 aPayload += pCur->info.nHeader;
51568 nKey = (int)pCur->info.nKey;
51572 nLocal = pCur->info.nLocal - nKey;
51574 nLocal = pCur->info.nLocal;
51596 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
51598 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
51599 assert( cursorHoldsMutex(pCur) );
51600 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
51601 p = (const void*)fetchPayload(pCur, pAmt, 0);
51605 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
51607 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
51608 assert( cursorHoldsMutex(pCur) );
51609 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
51610 p = (const void*)fetchPayload(pCur, pAmt, 1);
51625 static int moveToChild(BtCursor *pCur, u32 newPgno){
51627 int i = pCur->iPage;
51629 BtShared *pBt = pCur->pBt;
51631 assert( cursorHoldsMutex(pCur) );
51632 assert( pCur->eState==CURSOR_VALID );
51633 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
51634 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
51639 pCur->apPage[i+1] = pNewPage;
51640 pCur->aiIdx[i+1] = 0;
51641 pCur->iPage++;
51643 pCur->info.nSize = 0;
51644 pCur->validNKey = 0;
51645 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
51679 static void moveToParent(BtCursor *pCur){
51680 assert( cursorHoldsMutex(pCur) );
51681 assert( pCur->eState==CURSOR_VALID );
51682 assert( pCur->iPage>0 );
51683 assert( pCur->apPage[pCur->iPage] );
51685 pCur->apPage[pCur->iPage-1],
51686 pCur->aiIdx[pCur->iPage-1],
51687 pCur->apPage[pCur->iPage]->pgno
51689 releasePage(pCur->apPage[pCur->iPage]);
51690 pCur->iPage--;
51691 pCur->info.nSize = 0;
51692 pCur->validNKey = 0;
51716 static int moveToRoot(BtCursor *pCur){
51719 Btree *p = pCur->pBtree;
51722 assert( cursorHoldsMutex(pCur) );
51726 if( pCur->eState>=CURSOR_REQUIRESEEK ){
51727 if( pCur->eState==CURSOR_FAULT ){
51728 assert( pCur->skipNext!=SQLITE_OK );
51729 return pCur->skipNext;
51731 sqlite3BtreeClearCursor(pCur);
51734 if( pCur->iPage>=0 ){
51736 for(i=1; i<=pCur->iPage; i++){
51737 releasePage(pCur->apPage[i]);
51739 pCur->iPage = 0;
51741 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
51743 pCur->eState = CURSOR_INVALID;
51746 pCur->iPage = 0;
51752 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
51753 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
51764 pRoot = pCur->apPage[0];
51765 assert( pRoot->pgno==pCur->pgnoRoot );
51766 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
51768 pCur->aiIdx[0] = 0;
51769 pCur->info.nSize = 0;
51770 pCur->atLast = 0;
51771 pCur->validNKey = 0;
51777 pCur->eState = CURSOR_VALID;
51778 rc = moveToChild(pCur, subpage);
51780 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
51792 static int moveToLeftmost(BtCursor *pCur){
51797 assert( cursorHoldsMutex(pCur) );
51798 assert( pCur->eState==CURSOR_VALID );
51799 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
51800 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51801 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
51802 rc = moveToChild(pCur, pgno);
51817 static int moveToRightmost(BtCursor *pCur){
51822 assert( cursorHoldsMutex(pCur) );
51823 assert( pCur->eState==CURSOR_VALID );
51824 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
51826 pCur->aiIdx[pCur->iPage] = pPage->nCell;
51827 rc = moveToChild(pCur, pgno);
51830 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
51831 pCur->info.nSize = 0;
51832 pCur->validNKey = 0;
51841 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
51844 assert( cursorHoldsMutex(pCur) );
51845 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
51846 rc = moveToRoot(pCur);
51848 if( pCur->eState==CURSOR_INVALID ){
51849 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51852 assert( pCur->apPage[pCur->iPage]->nCell>0 );
51854 rc = moveToLeftmost(pCur);
51864 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
51867 assert( cursorHoldsMutex(pCur) );
51868 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
51871 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
51876 for(ii=0; ii<pCur->iPage; ii++){
51877 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
51879 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
51880 assert( pCur->apPage[pCur->iPage]->leaf );
51885 rc = moveToRoot(pCur);
51887 if( CURSOR_INVALID==pCur->eState ){
51888 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51891 assert( pCur->eState==CURSOR_VALID );
51893 rc = moveToRightmost(pCur);
51894 pCur->atLast = rc==SQLITE_OK ?1:0;
51929 BtCursor *pCur, /* The cursor to be moved */
51937 assert( cursorHoldsMutex(pCur) );
51938 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
51940 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
51944 if( pCur->eState==CURSOR_VALID && pCur->validNKey
51945 && pCur->apPage[0]->intKey
51947 if( pCur->info.nKey==intKey ){
51951 if( pCur->atLast && pCur->info.nKey<intKey ){
51957 rc = moveToRoot(pCur);
51961 assert( pCur->apPage[pCur->iPage] );
51962 assert( pCur->apPage[pCur->iPage]->isInit );
51963 assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID );
51964 if( pCur->eState==CURSOR_INVALID ){
51966 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51969 assert( pCur->apPage[0]->intKey || pIdxKey );
51973 MemPage *pPage = pCur->apPage[pCur->iPage];
51987 pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
51989 pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
51994 assert( idx==pCur->aiIdx[pCur->iPage] );
51995 pCur->info.nSize = 0;
52012 pCur->validNKey = 1;
52013 pCur->info.nKey = nCellKey;
52042 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
52043 nCell = (int)pCur->info.nKey;
52049 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
52077 pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
52089 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52094 pCur->aiIdx[pCur->iPage] = (u16)lwr;
52095 pCur->info.nSize = 0;
52096 pCur->validNKey = 0;
52097 rc = moveToChild(pCur, chldPg);
52112 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
52117 return (CURSOR_VALID!=pCur->eState);
52126 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
52131 assert( cursorHoldsMutex(pCur) );
52132 rc = restoreCursorPosition(pCur);
52137 if( CURSOR_INVALID==pCur->eState ){
52141 if( pCur->skipNext>0 ){
52142 pCur->skipNext = 0;
52146 pCur->skipNext = 0;
52148 pPage = pCur->apPage[pCur->iPage];
52149 idx = ++pCur->aiIdx[pCur->iPage];
52153 pCur->info.nSize = 0;
52154 pCur->validNKey = 0;
52157 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
52159 rc = moveToLeftmost(pCur);
52164 if( pCur->iPage==0 ){
52166 pCur->eState = CURSOR_INVALID;
52169 moveToParent(pCur);
52170 pPage = pCur->apPage[pCur->iPage];
52171 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
52174 rc = sqlite3BtreeNext(pCur, pRes);
52184 rc = moveToLeftmost(pCur);
52195 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
52199 assert( cursorHoldsMutex(pCur) );
52200 rc = restoreCursorPosition(pCur);
52204 pCur->atLast = 0;
52205 if( CURSOR_INVALID==pCur->eState ){
52209 if( pCur->skipNext<0 ){
52210 pCur->skipNext = 0;
52214 pCur->skipNext = 0;
52216 pPage = pCur->apPage[pCur->iPage];
52219 int idx = pCur->aiIdx[pCur->iPage];
52220 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
52224 rc = moveToRightmost(pCur);
52226 while( pCur->aiIdx[pCur->iPage]==0 ){
52227 if( pCur->iPage==0 ){
52228 pCur->eState = CURSOR_INVALID;
52232 moveToParent(pCur);
52234 pCur->info.nSize = 0;
52235 pCur->validNKey = 0;
52237 pCur->aiIdx[pCur->iPage]--;
52238 pPage = pCur->apPage[pCur->iPage];
52240 rc = sqlite3BtreePrevious(pCur, pRes);
54047 static int balance(BtCursor *pCur){
54049 const int nMin = pCur->pBt->usableSize * 2 / 3;
54057 int iPage = pCur->iPage;
54058 MemPage *pPage = pCur->apPage[iPage];
54068 rc = balance_deeper(pPage, &pCur->apPage[1]);
54070 pCur->iPage = 1;
54071 pCur->aiIdx[0] = 0;
54072 pCur->aiIdx[1] = 0;
54073 assert( pCur->apPage[1]->nOverflow );
54081 MemPage * const pParent = pCur->apPage[iPage-1];
54082 int const iIdx = pCur->aiIdx[iPage-1];
54128 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
54149 pCur->iPage--;
54183 BtCursor *pCur, /* Insert data into the table of this cursor */
54195 Btree *p = pCur->pBtree;
54200 if( pCur->eState==CURSOR_FAULT ){
54201 assert( pCur->skipNext!=SQLITE_OK );
54202 return pCur->skipNext;
54205 assert( cursorHoldsMutex(pCur) );
54206 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
54207 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
54214 assert( (pKey==0)==(pCur->pKeyInfo==0) );
54219 if( pCur->pKeyInfo==0 ){
54234 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
54237 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
54240 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
54242 pPage = pCur->apPage[pCur->iPage];
54247 pCur->pgnoRoot, nKey, nData, pPage->pgno,
54257 idx = pCur->aiIdx[pCur->iPage];
54275 idx = ++pCur->aiIdx[pCur->iPage];
54302 pCur->info.nSize = 0;
54303 pCur->validNKey = 0;
54305 rc = balance(pCur);
54311 pCur->apPage[pCur->iPage]->nOverflow = 0;
54312 pCur->eState = CURSOR_INVALID;
54314 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
54324 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
54325 Btree *p = pCur->pBtree;
54333 assert( cursorHoldsMutex(pCur) );
54336 assert( pCur->wrFlag );
54337 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
54338 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
54340 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
54341 || NEVER(pCur->eState!=CURSOR_VALID)
54348 if( pCur->pKeyInfo==0 ){
54349 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
54352 iCellDepth = pCur->iPage;
54353 iCellIdx = pCur->aiIdx[iCellDepth];
54354 pPage = pCur->apPage[iCellDepth];
54366 rc = sqlite3BtreePrevious(pCur, ¬Used);
54375 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
54389 MemPage *pLeaf = pCur->apPage[pCur->iPage];
54391 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
54422 rc = balance(pCur);
54423 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
54424 while( pCur->iPage>iCellDepth ){
54425 releasePage(pCur->apPage[pCur->iPage--]);
54427 rc = balance(pCur);
54431 moveToRoot(pCur);
54873 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
54876 rc = moveToRoot(pCur);
54889 pPage = pCur->apPage[pCur->iPage];
54906 if( pCur->iPage==0 ){
54911 moveToParent(pCur);
54912 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
54914 pCur->aiIdx[pCur->iPage]++;
54915 pPage = pCur->apPage[pCur->iPage];
54921 iIdx = pCur->aiIdx[pCur->iPage];
54923 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
54925 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
55643 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
55644 assert( cursorHoldsMutex(pCur) );
55645 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
55646 invalidateOverflowCache(pCur);
55647 pCur->isIncrblobHandle = 1;
57289 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
57299 assert( sqlite3BtreeCursorIsValid(pCur) );
57305 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
57307 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
57320 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
57322 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
60604 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
60619 assert( sqlite3BtreeCursorIsValid(pCur) );
60620 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
60626 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
60691 BtCursor *pCur = pC->pCursor;
60694 assert( sqlite3BtreeCursorIsValid(pCur) );
60695 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
63075 VdbeCursor *pCur;
63276 VdbeCursor *pCur;
63289 VdbeCursor *pCur;
63304 VdbeCursor *pCur;
65843 VdbeCursor *pCur;
65895 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
65896 if( u.aw.pCur==0 ) goto no_mem;
65897 u.aw.pCur->nullRow = 1;
65898 u.aw.pCur->isOrdered = 1;
65899 rc = sqlite3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
65900 u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
65908 u.aw.pCur->pCursor = 0;
65916 u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
65917 u.aw.pCur->isIndex = !u.aw.pCur->isTable;
68410 VdbeCursor *pCur;
68416 u.ch.pCur = 0;
68428 u.ch.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
68429 if( u.ch.pCur ){
68430 u.ch.pCur->pVtabCursor = u.ch.pVtabCursor;
68431 u.ch.pCur->pModule = u.ch.pVtabCursor->pVtab->pModule;
68469 VdbeCursor *pCur;
68477 u.ci.pCur = p->apCsr[pOp->p1];
68480 assert( u.ci.pCur->pVtabCursor );
68481 u.ci.pVtabCursor = u.ci.pCur->pVtabCursor;
68511 u.ci.pCur->nullRow = 0;
68532 VdbeCursor *pCur = p->apCsr[pOp->p1];
68533 assert( pCur->pVtabCursor );
68537 if( pCur->nullRow ){
68541 u.cj.pVtab = pCur->pVtabCursor->pVtab;
68554 rc = u.cj.pModule->xColumn(pCur->pVtabCursor, &u.cj.sContext, pOp->p2);
68588 VdbeCursor *pCur;
68592 u.ck.pCur = p->apCsr[pOp->p1];
68593 assert( u.ck.pCur->pVtabCursor );
68594 if( u.ck.pCur->nullRow ){
68597 u.ck.pVtab = u.ck.pCur->pVtabCursor->pVtab;
68608 rc = u.ck.pModule->xNext(u.ck.pCur->pVtabCursor);
68612 u.ck.res = u.ck.pModule->xEof(u.ck.pCur->pVtabCursor);
