Lines Matching full:pcur
5601 ** ^The current value of the requested parameter is written into *pCur
5608 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
37581 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
37582 sqlite3BtreeEnter(pCur->pBtree);
37584 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
37585 sqlite3BtreeLeave(pCur->pBtree);
38204 ** Invalidate the overflow page-list cache for cursor pCur, if any.
38206 static void invalidateOverflowCache(BtCursor *pCur){
38207 assert( cursorHoldsMutex(pCur) );
38208 sqlite3_free(pCur->aOverflow);
38209 pCur->aOverflow = 0;
38340 static int saveCursorPosition(BtCursor *pCur){
38343 assert( CURSOR_VALID==pCur->eState );
38344 assert( 0==pCur->pKey );
38345 assert( cursorHoldsMutex(pCur) );
38347 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
38351 ** stores the integer key in pCur->nKey. In this case this value is
38352 ** all that is required. Otherwise, if pCur is not open on an intKey
38353 ** table, then malloc space for and store the pCur->nKey bytes of key
38356 if( 0==pCur->apPage[0]->intKey ){
38357 void *pKey = sqlite3Malloc( (int)pCur->nKey );
38359 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
38361 pCur->pKey = pKey;
38369 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
38373 for(i=0; i<=pCur->iPage; i++){
38374 releasePage(pCur->apPage[i]);
38375 pCur->apPage[i] = 0;
38377 pCur->iPage = -1;
38378 pCur->eState = CURSOR_REQUIRESEEK;
38381 invalidateOverflowCache(pCur);
38409 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
38410 assert( cursorHoldsMutex(pCur) );
38411 sqlite3_free(pCur->pKey);
38412 pCur->pKey = 0;
38413 pCur->eState = CURSOR_INVALID;
38422 BtCursor *pCur, /* Cursor open on the btree to be searched */
38434 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
38440 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
38454 static int btreeRestoreCursorPosition(BtCursor *pCur){
38456 assert( cursorHoldsMutex(pCur) );
38457 assert( pCur->eState>=CURSOR_REQUIRESEEK );
38458 if( pCur->eState==CURSOR_FAULT ){
38459 return pCur->skipNext;
38461 pCur->eState = CURSOR_INVALID;
38462 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
38464 sqlite3_free(pCur->pKey);
38465 pCur->pKey = 0;
38466 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
38484 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
38487 rc = restoreCursorPosition(pCur);
38492 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
39751 BtCursor *pCur;
39756 pCur = pBt->pCursor;
39757 while( pCur ){
39758 BtCursor *pTmp = pCur;
39759 pCur = pCur->pNext;
40871 BtCursor *pCur;
40873 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
40874 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
41066 ** on pCur to initialize the memory space prior to invoking this routine.
41073 BtCursor *pCur /* Space for new cursor */
41101 pCur->pgnoRoot = (Pgno)iTable;
41102 pCur->iPage = -1;
41103 pCur->pKeyInfo = pKeyInfo;
41104 pCur->pBtree = p;
41105 pCur->pBt = pBt;
41106 pCur->wrFlag = (u8)wrFlag;
41107 pCur->pNext = pBt->pCursor;
41108 if( pCur->pNext ){
41109 pCur->pNext->pPrev = pCur;
41111 pBt->pCursor = pCur;
41112 pCur->eState = CURSOR_INVALID;
41113 pCur->cachedRowid = 0;
41121 BtCursor *pCur /* Write new cursor here */
41125 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
41156 ** as pCur and having the same root page number as pCur. The value is
41166 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
41168 for(p=pCur->pBt->pCursor; p; p=p->pNext){
41169 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
41171 assert( pCur->cachedRowid==iRowid );
41180 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
41181 return pCur->cachedRowid;
41188 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
41189 Btree *pBtree = pCur->pBtree;
41192 BtShared *pBt = pCur->pBt;
41194 sqlite3BtreeClearCursor(pCur);
41195 if( pCur->pPrev ){
41196 pCur->pPrev->pNext = pCur->pNext;
41198 pBt->pCursor = pCur->pNext;
41200 if( pCur->pNext ){
41201 pCur->pNext->pPrev = pCur->pPrev;
41203 for(i=0; i<=pCur->iPage; i++){
41204 releasePage(pCur->apPage[i]);
41207 invalidateOverflowCache(pCur);
41208 /* sqlite3_free(pCur); */
41230 static void assertCellInfo(BtCursor *pCur){
41232 int iPage = pCur->iPage;
41234 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
41235 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
41242 static void getCellInfo(BtCursor *pCur){
41243 if( pCur->info.nSize==0 ){
41244 int iPage = pCur->iPage;
41245 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
41246 pCur->validNKey = 1;
41248 assertCellInfo(pCur);
41253 #define getCellInfo(pCur) \
41254 if( pCur->info.nSize==0 ){ \
41255 int iPage = pCur->iPage; \
41256 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
41257 pCur->validNKey = 1; \
41259 assertCellInfo(pCur); \
41269 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
41270 return pCur && pCur->eState==CURSOR_VALID;
41286 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
41287 assert( cursorHoldsMutex(pCur) );
41288 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
41289 if( pCur->eState!=CURSOR_VALID ){
41292 getCellInfo(pCur);
41293 *pSize = pCur->info.nKey;
41310 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
41311 assert( cursorHoldsMutex(pCur) );
41312 assert( pCur->eState==CURSOR_VALID );
41313 getCellInfo(pCur);
41314 *pSize = pCur->info.nData;
41428 ** for the entry that the pCur cursor is pointing to. If the eOp
41455 BtCursor *pCur, /* Cursor pointing to entry to read from */
41465 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
41466 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
41469 assert( pCur->eState==CURSOR_VALID );
41470 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41471 assert( cursorHoldsMutex(pCur) );
41473 getCellInfo(pCur);
41474 aPayload = pCur->info.pCell + pCur->info.nHeader;
41475 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
41477 if( NEVER(offset+amt > nKey+pCur->info.nData)
41478 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
41485 if( offset<pCur->info.nLocal ){
41487 if( a+offset>pCur->info.nLocal ){
41488 a = pCur->info.nLocal - offset;
41495 offset -= pCur->info.nLocal;
41502 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
41512 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
41513 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
41514 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
41517 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
41526 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
41528 nextPage = pCur->aOverflow[iIdx];
41537 if( pCur->aOverflow ){
41538 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
41539 pCur->aOverflow[iIdx] = nextPage;
41551 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
41552 nextPage = pCur->aOverflow[iIdx+1];
41587 ** Read part of the key associated with cursor pCur. Exactly
41591 ** The caller must ensure that pCur is pointing to a valid row
41598 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41599 assert( cursorHoldsMutex(pCur) );
41600 assert( pCur->eState==CURSOR_VALID );
41601 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
41602 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
41603 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
41607 ** Read part of the data associated with cursor pCur. Exactly
41615 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41619 if ( pCur->eState==CURSOR_INVALID ){
41624 assert( cursorHoldsMutex(pCur) );
41625 rc = restoreCursorPosition(pCur);
41627 assert( pCur->eState==CURSOR_VALID );
41628 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
41629 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
41630 rc = accessPayload(pCur, offset, amt, pBuf, 0);
41637 ** pCur cursor is pointing to. The pointer is to the beginning of
41655 BtCursor *pCur, /* Cursor pointing to entry to read from */
41664 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
41665 assert( pCur->eState==CURSOR_VALID );
41666 assert( cursorHoldsMutex(pCur) );
41667 pPage = pCur->apPage[pCur->iPage];
41668 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41669 if( NEVER(pCur->info.nSize==0) ){
41670 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
41671 &pCur->info);
41673 aPayload = pCur->info.pCell;
41674 aPayload += pCur->info.nHeader;
41678 nKey = (int)pCur->info.nKey;
41682 nLocal = pCur->info.nLocal - nKey;
41684 nLocal = pCur->info.nLocal;
41693 ** For the entry that cursor pCur is point to, return as
41706 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
41708 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41709 assert( cursorHoldsMutex(pCur) );
41710 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
41711 p = (const void*)fetchPayload(pCur, pAmt, 0);
41715 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
41717 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41718 assert( cursorHoldsMutex(pCur) );
41719 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
41720 p = (const void*)fetchPayload(pCur, pAmt, 1);
41735 static int moveToChild(BtCursor *pCur, u32 newPgno){
41737 int i = pCur->iPage;
41739 BtShared *pBt = pCur->pBt;
41741 assert( cursorHoldsMutex(pCur) );
41742 assert( pCur->eState==CURSOR_VALID );
41743 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
41744 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
41749 pCur->apPage[i+1] = pNewPage;
41750 pCur->aiIdx[i+1] = 0;
41751 pCur->iPage++;
41753 pCur->info.nSize = 0;
41754 pCur->validNKey = 0;
41755 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
41784 ** pCur->idx is set to the cell index that contains the pointer
41786 ** right-most child page then pCur->idx is set to one more than
41789 static void moveToParent(BtCursor *pCur){
41790 assert( cursorHoldsMutex(pCur) );
41791 assert( pCur->eState==CURSOR_VALID );
41792 assert( pCur->iPage>0 );
41793 assert( pCur->apPage[pCur->iPage] );
41795 pCur->apPage[pCur->iPage-1],
41796 pCur->aiIdx[pCur->iPage-1],
41797 pCur->apPage[pCur->iPage]->pgno
41799 releasePage(pCur->apPage[pCur->iPage]);
41800 pCur->iPage--;
41801 pCur->info.nSize = 0;
41802 pCur->validNKey = 0;
41826 static int moveToRoot(BtCursor *pCur){
41829 Btree *p = pCur->pBtree;
41832 assert( cursorHoldsMutex(pCur) );
41836 if( pCur->eState>=CURSOR_REQUIRESEEK ){
41837 if( pCur->eState==CURSOR_FAULT ){
41838 assert( pCur->skipNext!=SQLITE_OK );
41839 return pCur->skipNext;
41841 sqlite3BtreeClearCursor(pCur);
41844 if( pCur->iPage>=0 ){
41846 for(i=1; i<=pCur->iPage; i++){
41847 releasePage(pCur->apPage[i]);
41849 pCur->iPage = 0;
41851 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
41853 pCur->eState = CURSOR_INVALID;
41856 pCur->iPage = 0;
41858 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
41862 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
41863 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
41874 pRoot = pCur->apPage[0];
41875 assert( pRoot->pgno==pCur->pgnoRoot );
41876 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
41878 pCur->aiIdx[0] = 0;
41879 pCur->info.nSize = 0;
41880 pCur->atLast = 0;
41881 pCur->validNKey = 0;
41887 pCur->eState = CURSOR_VALID;
41888 rc = moveToChild(pCur, subpage);
41890 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
41902 static int moveToLeftmost(BtCursor *pCur){
41907 assert( cursorHoldsMutex(pCur) );
41908 assert( pCur->eState==CURSOR_VALID );
41909 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
41910 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41911 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
41912 rc = moveToChild(pCur, pgno);
41927 static int moveToRightmost(BtCursor *pCur){
41932 assert( cursorHoldsMutex(pCur) );
41933 assert( pCur->eState==CURSOR_VALID );
41934 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
41936 pCur->aiIdx[pCur->iPage] = pPage->nCell;
41937 rc = moveToChild(pCur, pgno);
41940 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
41941 pCur->info.nSize = 0;
41942 pCur->validNKey = 0;
41951 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
41954 assert( cursorHoldsMutex(pCur) );
41955 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41956 rc = moveToRoot(pCur);
41958 if( pCur->eState==CURSOR_INVALID ){
41959 assert( pCur->apPage[pCur->iPage]->nCell==0 );
41963 assert( pCur->apPage[pCur->iPage]->nCell>0 );
41965 rc = moveToLeftmost(pCur);
41975 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
41978 assert( cursorHoldsMutex(pCur) );
41979 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41982 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
41987 for(ii=0; ii<pCur->iPage; ii++){
41988 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
41990 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
41991 assert( pCur->apPage[pCur->iPage]->leaf );
41996 rc = moveToRoot(pCur);
41998 if( CURSOR_INVALID==pCur->eState ){
41999 assert( pCur->apPage[pCur->iPage]->nCell==0 );
42002 assert( pCur->eState==CURSOR_VALID );
42004 rc = moveToRightmost(pCur);
42005 pCur->atLast = rc==SQLITE_OK ?1:0;
42040 BtCursor *pCur, /* The cursor to be moved */
42048 assert( cursorHoldsMutex(pCur) );
42049 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
42051 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
42055 if( pCur->eState==CURSOR_VALID && pCur->validNKey
42056 && pCur->apPage[0]->intKey
42058 if( pCur->info.nKey==intKey ){
42062 if( pCur->atLast && pCur->info.nKey<intKey ){
42068 rc = moveToRoot(pCur);
42072 assert( pCur->apPage[pCur->iPage] );
42073 assert( pCur->apPage[pCur->iPage]->isInit );
42074 assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID );
42075 if( pCur->eState==CURSOR_INVALID ){
42077 assert( pCur->apPage[pCur->iPage]->nCell==0 );
42080 assert( pCur->apPage[0]->intKey || pIdxKey );
42084 MemPage *pPage = pCur->apPage[pCur->iPage];
42098 pCur->aiIdx[pCur->iPage] = (u16)upr;
42100 pCur->aiIdx[pCur->iPage] = (u16)((upr+lwr)/2);
42103 int idx = pCur->aiIdx[pCur->iPage]; /* Index of current cell in pPage */
42106 pCur->info.nSize = 0;
42123 pCur->validNKey = 1;
42124 pCur->info.nKey = nCellKey;
42153 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
42154 nCell = (int)pCur->info.nKey;
42160 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
42188 pCur->aiIdx[pCur->iPage] = (u16)((lwr+upr)/2);
42200 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
42205 pCur->aiIdx[pCur->iPage] = (u16)lwr;
42206 pCur->info.nSize = 0;
42207 pCur->validNKey = 0;
42208 rc = moveToChild(pCur, chldPg);
42223 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
42228 return (CURSOR_VALID!=pCur->eState);
42237 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
42242 assert( cursorHoldsMutex(pCur) );
42243 rc = restoreCursorPosition(pCur);
42248 if( CURSOR_INVALID==pCur->eState ){
42252 if( pCur->skipNext>0 ){
42253 pCur->skipNext = 0;
42257 pCur->skipNext = 0;
42259 pPage = pCur->apPage[pCur->iPage];
42260 idx = ++pCur->aiIdx[pCur->iPage];
42264 pCur->info.nSize = 0;
42265 pCur->validNKey = 0;
42268 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
42270 rc = moveToLeftmost(pCur);
42275 if( pCur->iPage==0 ){
42277 pCur->eState = CURSOR_INVALID;
42280 moveToParent(pCur);
42281 pPage = pCur->apPage[pCur->iPage];
42282 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
42285 rc = sqlite3BtreeNext(pCur, pRes);
42295 rc = moveToLeftmost(pCur);
42306 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
42310 assert( cursorHoldsMutex(pCur) );
42311 rc = restoreCursorPosition(pCur);
42315 pCur->atLast = 0;
42316 if( CURSOR_INVALID==pCur->eState ){
42320 if( pCur->skipNext<0 ){
42321 pCur->skipNext = 0;
42325 pCur->skipNext = 0;
42327 pPage = pCur->apPage[pCur->iPage];
42330 int idx = pCur->aiIdx[pCur->iPage];
42331 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
42335 rc = moveToRightmost(pCur);
42337 while( pCur->aiIdx[pCur->iPage]==0 ){
42338 if( pCur->iPage==0 ){
42339 pCur->eState = CURSOR_INVALID;
42343 moveToParent(pCur);
42345 pCur->info.nSize = 0;
42346 pCur->validNKey = 0;
42348 pCur->aiIdx[pCur->iPage]--;
42349 pPage = pCur->apPage[pCur->iPage];
42351 rc = sqlite3BtreePrevious(pCur, pRes);
44107 ** The page that pCur currently points to has just been modified in
44116 static int balance(BtCursor *pCur){
44118 const int nMin = pCur->pBt->usableSize * 2 / 3;
44126 int iPage = pCur->iPage;
44127 MemPage *pPage = pCur->apPage[iPage];
44137 rc = balance_deeper(pPage, &pCur->apPage[1]);
44139 pCur->iPage = 1;
44140 pCur->aiIdx[0] = 0;
44141 pCur->aiIdx[1] = 0;
44142 assert( pCur->apPage[1]->nOverflow );
44150 MemPage * const pParent = pCur->apPage[iPage-1];
44151 int const iIdx = pCur->aiIdx[iPage-1];
44197 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
44218 pCur->iPage--;
44239 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
44241 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
44242 ** a positive value if pCur points at an etry that is larger than
44246 ** cursor pCur is pointing at the existing copy of a row that is to be
44247 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
44252 BtCursor *pCur, /* Insert data into the table of this cursor */
44264 Btree *p = pCur->pBtree;
44269 if( pCur->eState==CURSOR_FAULT ){
44270 assert( pCur->skipNext!=SQLITE_OK );
44271 return pCur->skipNext;
44274 assert( cursorHoldsMutex(pCur) );
44275 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
44276 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
44283 assert( (pKey==0)==(pCur->pKeyInfo==0) );
44288 if( pCur->pKeyInfo==0 ){
44303 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
44306 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
44309 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
44311 pPage = pCur->apPage[pCur->iPage];
44316 pCur->pgnoRoot, nKey, nData, pPage->pgno,
44326 idx = pCur->aiIdx[pCur->iPage];
44344 idx = ++pCur->aiIdx[pCur->iPage];
44371 pCur->info.nSize = 0;
44372 pCur->validNKey = 0;
44374 rc = balance(pCur);
44380 pCur->apPage[pCur->iPage]->nOverflow = 0;
44381 pCur->eState = CURSOR_INVALID;
44383 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
44393 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
44394 Btree *p = pCur->pBtree;
44402 assert( cursorHoldsMutex(pCur) );
44405 assert( pCur->wrFlag );
44406 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
44407 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
44409 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
44410 || NEVER(pCur->eState!=CURSOR_VALID)
44417 if( pCur->pKeyInfo==0 ){
44418 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
44421 iCellDepth = pCur->iPage;
44422 iCellIdx = pCur->aiIdx[iCellDepth];
44423 pPage = pCur->apPage[iCellDepth];
44435 rc = sqlite3BtreePrevious(pCur, ¬Used);
44444 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
44458 MemPage *pLeaf = pCur->apPage[pCur->iPage];
44460 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
44482 ** pCur is pointing to the leaf page from which a cell was removed to
44491 rc = balance(pCur);
44492 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
44493 while( pCur->iPage>iCellDepth ){
44494 releasePage(pCur->apPage[pCur->iPage--]);
44496 rc = balance(pCur);
44500 moveToRoot(pCur);
44922 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
44929 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
44932 rc = moveToRoot(pCur);
44945 pPage = pCur->apPage[pCur->iPage];
44953 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
44962 if( pCur->iPage==0 ){
44967 moveToParent(pCur);
44968 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
44970 pCur->aiIdx[pCur->iPage]++;
44971 pPage = pCur->apPage[pCur->iPage];
44977 iIdx = pCur->aiIdx[pCur->iPage];
44979 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
44981 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
45673 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
45674 assert( cursorHoldsMutex(pCur) );
45675 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
45676 assert(!pCur->isIncrblobHandle);
45677 assert(!pCur->aOverflow);
45678 pCur->isIncrblobHandle = 1;
47173 ** The data or key is taken from the entry that pCur is currently pointing
47185 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
47195 assert( sqlite3BtreeCursorIsValid(pCur) );
47201 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
47203 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
47216 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
47218 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
50328 ** pCur points at an index entry created using the OP_MakeRecord opcode.
50332 ** pCur might be pointing to text obtained from a corrupt database file.
50335 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
50350 assert( sqlite3BtreeCursorIsValid(pCur) );
50351 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
50352 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
50357 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
50422 BtCursor *pCur = pC->pCursor;
50425 assert( sqlite3BtreeCursorIsValid(pCur) );
50426 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
50427 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
52732 VdbeCursor *pCur;
52921 VdbeCursor *pCur;
52934 VdbeCursor *pCur;
52949 VdbeCursor *pCur;
55420 VdbeCursor *pCur;
55469 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
55470 if( u.aw.pCur==0 ) goto no_mem;
55471 u.aw.pCur->nullRow = 1;
55472 rc = sqlite3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
55473 u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
55481 u.aw.pCur->pCursor = 0;
55489 u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
55490 u.aw.pCur->isIndex = !u.aw.pCur->isTable;
57813 VdbeCursor *pCur;
57819 u.cf.pCur = 0;
57833 u.cf.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
57834 if( u.cf.pCur ){
57835 u.cf.pCur->pVtabCursor = u.cf.pVtabCursor;
57836 u.cf.pCur->pModule = u.cf.pVtabCursor->pVtab->pModule;
57874 VdbeCursor *pCur;
57882 u.cg.pCur = p->apCsr[pOp->p1];
57884 assert( u.cg.pCur->pVtabCursor );
57885 u.cg.pVtabCursor = u.cg.pCur->pVtabCursor;
57917 u.cg.pCur->nullRow = 0;
57938 VdbeCursor *pCur = p->apCsr[pOp->p1];
57939 assert( pCur->pVtabCursor );
57942 if( pCur->nullRow ){
57946 u.ch.pVtab = pCur->pVtabCursor->pVtab;
57959 rc = u.ch.pModule->xColumn(pCur->pVtabCursor, &u.ch.sContext, pOp->p2);
57995 VdbeCursor *pCur;
57999 u.ci.pCur = p->apCsr[pOp->p1];
58000 assert( u.ci.pCur->pVtabCursor );
58001 if( u.ci.pCur->nullRow ){
58004 u.ci.pVtab = u.ci.pCur->pVtabCursor->pVtab;
58015 rc = u.ci.pModule->xNext(u.ci.pCur->pVtabCursor);
58021 u.ci.res = u.ci.pModule->xEof(u.ci.pCur->pVtabCursor);
106396 Fts3Cursor *pCur, /* The fulltest search cursor */
106420 pVtab = (Fts3Table *)pCur->base.pVtab;
106431 Fts3Expr *pIter = pCur->pExpr;
