Lines Matching refs:pCur
6009 ** ^The current value of the requested parameter is written into *pCur
6019 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
45160 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
45161 sqlite3BtreeEnter(pCur->pBtree);
45163 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
45164 sqlite3BtreeLeave(pCur->pBtree);
45792 ** Invalidate the overflow page-list cache for cursor pCur, if any.
45794 static void invalidateOverflowCache(BtCursor *pCur){
45795 assert( cursorHoldsMutex(pCur) );
45796 sqlite3_free(pCur->aOverflow);
45797 pCur->aOverflow = 0;
45925 static int saveCursorPosition(BtCursor *pCur){
45928 assert( CURSOR_VALID==pCur->eState );
45929 assert( 0==pCur->pKey );
45930 assert( cursorHoldsMutex(pCur) );
45932 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
45936 ** stores the integer key in pCur->nKey. In this case this value is
45937 ** all that is required. Otherwise, if pCur is not open on an intKey
45938 ** table, then malloc space for and store the pCur->nKey bytes of key
45941 if( 0==pCur->apPage[0]->intKey ){
45942 void *pKey = sqlite3Malloc( (int)pCur->nKey );
45944 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
45946 pCur->pKey = pKey;
45954 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
45958 for(i=0; i<=pCur->iPage; i++){
45959 releasePage(pCur->apPage[i]);
45960 pCur->apPage[i] = 0;
45962 pCur->iPage = -1;
45963 pCur->eState = CURSOR_REQUIRESEEK;
45966 invalidateOverflowCache(pCur);
45994 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
45995 assert( cursorHoldsMutex(pCur) );
45996 sqlite3_free(pCur->pKey);
45997 pCur->pKey = 0;
45998 pCur->eState = CURSOR_INVALID;
46007 BtCursor *pCur, /* Cursor open on the btree to be searched */
46019 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
46025 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
46039 static int btreeRestoreCursorPosition(BtCursor *pCur){
46041 assert( cursorHoldsMutex(pCur) );
46042 assert( pCur->eState>=CURSOR_REQUIRESEEK );
46043 if( pCur->eState==CURSOR_FAULT ){
46044 return pCur->skipNext;
46046 pCur->eState = CURSOR_INVALID;
46047 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
46049 sqlite3_free(pCur->pKey);
46050 pCur->pKey = 0;
46051 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
46069 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
46072 rc = restoreCursorPosition(pCur);
46077 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
47375 BtCursor *pCur;
47380 pCur = pBt->pCursor;
47381 while( pCur ){
47382 BtCursor *pTmp = pCur;
47383 pCur = pCur->pNext;
48581 BtCursor *pCur;
48583 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
48584 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
48784 ** on pCur to initialize the memory space prior to invoking this routine.
48791 BtCursor *pCur /* Space for new cursor */
48819 pCur->pgnoRoot = (Pgno)iTable;
48820 pCur->iPage = -1;
48821 pCur->pKeyInfo = pKeyInfo;
48822 pCur->pBtree = p;
48823 pCur->pBt = pBt;
48824 pCur->wrFlag = (u8)wrFlag;
48825 pCur->pNext = pBt->pCursor;
48826 pCur->pNext ){
48827 pCur->pNext->pPrev = pCur;
48829 pBt->pCursor = pCur;
48830 pCur->eState = CURSOR_INVALID;
48831 pCur->cachedRowid = 0;
48839 BtCursor *pCur /* Write new cursor here */
48843 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
48874 ** as pCur and having the same root page number as pCur. The value is
48884 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
48886 for(p=pCur->pBt->pCursor; p; p=p->pNext){
48887 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
48889 assert( pCur->cachedRowid==iRowid );
48898 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
48899 return pCur->cachedRowid;
48906 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
48907 Btree *pBtree = pCur->pBtree;
48910 BtShared *pBt = pCur->pBt;
48912 sqlite3BtreeClearCursor(pCur);
48913 if( pCur->pPrev ){
48914 pCur->pPrev->pNext = pCur->pNext;
48916 pBt->pCursor = pCur->pNext;
48918 if( pCur->pNext ){
48919 pCur->pNext->pPrev = pCur->pPrev;
48921 for(i=0; i<=pCur->iPage; i++){
48922 releasePage(pCur->apPage[i]);
48925 invalidateOverflowCache(pCur);
48926 /* sqlite3_free(pCur); */
48948 static void assertCellInfo(BtCursor *pCur){
48950 int iPage = pCur->iPage;
48952 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
48953 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
48960 static void getCellInfo(BtCursor *pCur){
48961 if( pCur->info.nSize==0 ){
48962 int iPage = pCur->iPage;
48963 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
48964 pCur->validNKey = 1;
48966 assertCellInfo(pCur);
48971 #define getCellInfo(pCur) \
48972 if( pCur->info.nSize==0 ){ \
48973 int iPage = pCur->iPage; \
48974 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
48975 pCur->validNKey = 1; \
48977 assertCellInfo(pCur); \
48987 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
48988 return pCur && pCur->eState==CURSOR_VALID;
49004 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
49005 assert( cursorHoldsMutex(pCur) );
49006 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
49007 if( pCur->eState!=CURSOR_VALID ){
49010 getCellInfo(pCur);
49011 *pSize = pCur->info.nKey;
49028 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
49029 assert( cursorHoldsMutex(pCur) );
49030 assert( pCur->eState==CURSOR_VALID );
49031 getCellInfo(pCur);
49032 *pSize = pCur->info.nData;
49146 ** for the entry that the pCur cursor is pointing to. If the eOp
49173 BtCursor *pCur, /* Cursor pointing to entry to read from */
49183 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
49184 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
49187 assert( pCur->eState==CURSOR_VALID );
49188 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
49189 assert( cursorHoldsMutex(pCur) );
49191 getCellInfo(pCur);
49192 aPayload = pCur->info.pCell + pCur->info.nHeader;
49193 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
49195 if( NEVER(offset+amt > nKey+pCur->info.nData)
49196 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
49203 if( offset<pCur->info.nLocal ){
49205 if( a+offset>pCur->info.nLocal ){
49206 a = pCur->info.nLocal - offset;
49213 offset -= pCur->info.nLocal;
49220 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
49230 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
49231 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
49232 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
49235 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
49244 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
49246 nextPage = pCur->aOverflow[iIdx];
49255 if( pCur->aOverflow ){
49256 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
49257 pCur->aOverflow[iIdx] = nextPage;
49269 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
49270 nextPage = pCur->aOverflow[iIdx+1];
49305 ** Read part of the key associated with cursor pCur. Exactly
49309 ** The caller must ensure that pCur is pointing to a valid row
49316 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
49317 assert( cursorHoldsMutex(pCur) );
49318 assert( pCur->eState==CURSOR_VALID );
49319 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
49320 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
49321 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
49325 ** Read part of the data associated with cursor pCur. Exactly
49333 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
49337 if ( pCur->eState==CURSOR_INVALID ){
49342 assert( cursorHoldsMutex(pCur) );
49343 rc = restoreCursorPosition(pCur);
49345 assert( pCur->eState==CURSOR_VALID );
49346 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
49347 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
49348 rc = accessPayload(pCur, offset, amt, pBuf, 0);
49355 ** pCur cursor is pointing to. The pointer is to the beginning of
49373 BtCursor *pCur, /* Cursor pointing to entry to read from */
49382 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
49383 assert( pCur->eState==CURSOR_VALID );
49384 assert( cursorHoldsMutex(pCur) );
49385 pPage = pCur->apPage[pCur->iPage];
49386 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
49387 if( NEVER(pCur->info.nSize==0) ){
49388 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
49389 &pCur->info);
49391 aPayload = pCur->info.pCell;
49392 aPayload += pCur->info.nHeader;
49396 nKey = (int)pCur->info.nKey;
49400 nLocal = pCur->info.nLocal - nKey;
49402 nLocal = pCur->info.nLocal;
49411 ** For the entry that cursor pCur is point to, return as
49424 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
49426 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
49427 assert( cursorHoldsMutex(pCur) );
49428 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
49429 p = (const void*)fetchPayload(pCur, pAmt, 0);
49433 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
49435 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
49436 assert( cursorHoldsMutex(pCur) );
49437 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
49438 p = (const void*)fetchPayload(pCur, pAmt, 1);
49453 static int moveToChild(BtCursor *pCur, u32 newPgno){
49455 int i = pCur->iPage;
49457 BtShared *pBt = pCur->pBt;
49459 assert( cursorHoldsMutex(pCur) );
49460 assert( pCur->eState==CURSOR_VALID );
49461 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
49462 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
49467 pCur->apPage[i+1] = pNewPage;
49468 pCur->aiIdx[i+1] = 0;
49469 pCur->iPage++;
49471 pCur->info.nSize = 0;
49472 pCur->validNKey = 0;
49473 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
49502 ** pCur->idx is set to the cell index that contains the pointer
49504 ** right-most child page then pCur->idx is set to one more than
49507 static void moveToParent(BtCursor *pCur){
49508 assert( cursorHoldsMutex(pCur) );
49509 assert( pCur->eState==CURSOR_VALID );
49510 assert( pCur->iPage>0 );
49511 assert( pCur->apPage[pCur->iPage] );
49513 pCur->apPage[pCur->iPage-1],
49514 pCur->aiIdx[pCur->iPage-1],
49515 pCur->apPage[pCur->iPage]->pgno
49517 releasePage(pCur->apPage[pCur->iPage]);
49518 pCur->iPage--;
49519 pCur->info.nSize = 0;
49520 pCur->validNKey = 0;
49544 static int moveToRoot(BtCursor *pCur){
49547 Btree *p = pCur->pBtree;
49550 assert( cursorHoldsMutex(pCur) );
49554 if( pCur->eState>=CURSOR_REQUIRESEEK ){
49555 if( pCur->eState==CURSOR_FAULT ){
49556 assert( pCur->skipNext!=SQLITE_OK );
49557 return pCur->skipNext;
49559 sqlite3BtreeClearCursor(pCur);
49562 if( pCur->iPage>=0 ){
49564 for(i=1; i<=pCur->iPage; i++){
49565 releasePage(pCur->apPage[i]);
49567 pCur->iPage = 0;
49569 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
49571 pCur->eState = CURSOR_INVALID;
49574 pCur->iPage = 0;
49576 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
49580 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
49581 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
49592 pRoot = pCur->apPage[0];
49593 assert( pRoot->pgno==pCur->pgnoRoot );
49594 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
49596 pCur->aiIdx[0] = 0;
49597 pCur->info.nSize = 0;
49598 pCur->atLast = 0;
49599 pCur->validNKey = 0;
49605 pCur->eState = CURSOR_VALID;
49606 rc = moveToChild(pCur, subpage);
49608 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
49620 static int moveToLeftmost(BtCursor *pCur){
49625 assert( cursorHoldsMutex(pCur) );
49626 assert( pCur->eState==CURSOR_VALID );
49627 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
49628 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
49629 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
49630 rc = moveToChild(pCur, pgno);
49645 static int moveToRightmost(BtCursor *pCur){
49650 assert( cursorHoldsMutex(pCur) );
49651 assert( pCur->eState==CURSOR_VALID );
49652 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
49654 pCur->aiIdx[pCur->iPage] = pPage->nCell;
49655 rc = moveToChild(pCur, pgno);
49658 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
49659 pCur->info.nSize = 0;
49660 pCur->validNKey = 0;
49669 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
49672 assert( cursorHoldsMutex(pCur) );
49673 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
49674 rc = moveToRoot(pCur);
49676 if( pCur->eState==CURSOR_INVALID ){
49677 assert( pCur->apPage[pCur->iPage]->nCell==0 );
49680 assert( pCur->apPage[pCur->iPage]->nCell>0 );
49682 rc = moveToLeftmost(pCur);
49692 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
49695 assert( cursorHoldsMutex(pCur) );
49696 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
49699 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
49704 for(ii=0; ii<pCur->iPage; ii++){
49705 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
49707 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
49708 assert( pCur->apPage[pCur->iPage]->leaf );
49713 rc = moveToRoot(pCur);
49715 if( CURSOR_INVALID==pCur->eState ){
49716 assert( pCur->apPage[pCur->iPage]->nCell==0 );
49719 assert( pCur->eState==CURSOR_VALID );
49721 rc = moveToRightmost(pCur);
49722 pCur->atLast = rc==SQLITE_OK ?1:0;
49757 BtCursor *pCur, /* The cursor to be moved */
49765 assert( cursorHoldsMutex(pCur) );
49766 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
49768 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
49772 if( pCur->eState==CURSOR_VALID && pCur->validNKey
49773 && pCur->apPage[0]->intKey
49775 if( pCur->info.nKey==intKey ){
49779 if( pCur->atLast && pCur->info.nKey<intKey ){
49785 rc = moveToRoot(pCur);
49789 assert( pCur->apPage[pCur->iPage] );
49790 pCur->apPage[pCur->iPage]->isInit );
49791 assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID );
49792 if( pCur->eState==CURSOR_INVALID ){
49794 assert( pCur->apPage[pCur->iPage]->nCell==0 );
49797 assert( pCur->apPage[0]->intKey || pIdxKey );
49801 MemPage *pPage = pCur->apPage[pCur->iPage];
49815 pCur->aiIdx[pCur->iPage] = (u16)upr;
49817 pCur->aiIdx[pCur->iPage] = (u16)((upr+lwr)/2);
49820 int idx = pCur->aiIdx[pCur->iPage]; /* Index of current cell in pPage */
49823 pCur->info.nSize = 0;
49840 pCur->validNKey = 1;
49841 pCur->info.nKey = nCellKey;
49870 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
49871 nCell = (int)pCur->info.nKey;
49877 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
49905 pCur->aiIdx[pCur->iPage] = (u16)((lwr+upr)/2);
49917 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
49922 pCur->aiIdx[pCur->iPage] = (u16)lwr;
49923 pCur->info.nSize = 0;
49924 pCur->validNKey = 0;
49925 rc = moveToChild(pCur, chldPg);
49940 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
49945 return (CURSOR_VALID!=pCur->eState);
49954 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
49959 assert( cursorHoldsMutex(pCur) );
49960 rc = restoreCursorPosition(pCur);
49965 if( CURSOR_INVALID==pCur->eState ){
49969 if( pCur->skipNext>0 ){
49970 pCur->skipNext = 0;
49974 pCur->skipNext = 0;
49976 pPage = pCur->apPage[pCur->iPage];
49977 idx = ++pCur->aiIdx[pCur->iPage];
49981 pCur->info.nSize = 0;
49982 pCur->validNKey = 0;
49985 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
49987 rc = moveToLeftmost(pCur);
49992 if( pCur->iPage==0 ){
49994 pCur->eState = CURSOR_INVALID;
49997 moveToParent(pCur);
49998 pPage = pCur->apPage[pCur->iPage];
49999 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
50002 rc = sqlite3BtreeNext(pCur, pRes);
50012 rc = moveToLeftmost(pCur);
50023 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
50027 assert( cursorHoldsMutex(pCur) );
50028 rc = restoreCursorPosition(pCur);
50032 pCur->atLast = 0;
50033 if( CURSOR_INVALID==pCur->eState ){
50037 if( pCur->skipNext<0 ){
50038 pCur->skipNext = 0;
50042 pCur->skipNext = 0;
50044 pPage = pCur->apPage[pCur->iPage];
50047 int idx = pCur->aiIdx[pCur->iPage];
50048 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
50052 rc = moveToRightmost(pCur);
50054 while( pCur->aiIdx[pCur->iPage]==0 ){
50055 if( pCur->iPage==0 ){
50056 pCur->eState = CURSOR_INVALID;
50060 moveToParent(pCur);
50062 pCur->info.nSize = 0;
50063 pCur->validNKey = 0;
50065 pCur->aiIdx[pCur->iPage]--;
50066 pPage = pCur->apPage[pCur->iPage];
50068 rc = sqlite3BtreePrevious(pCur, pRes);
51852 ** The page that pCur currently points to has just been modified in
51861 static int balance(BtCursor *pCur){
51863 const int nMin = pCur->pBt->usableSize * 2 / 3;
51871 int iPage = pCur->iPage;
51872 MemPage *pPage = pCur->apPage[iPage];
51882 rc = balance_deeper(pPage, &pCur->apPage[1]);
51884 pCur->iPage = 1;
51885 pCur->aiIdx[0] = 0;
51886 pCur->aiIdx[1] = 0;
51887 assert( pCur->apPage[1]->nOverflow );
51895 MemPage * const pParent = pCur->apPage[iPage-1];
51896 int const iIdx = pCur->aiIdx[iPage-1];
51942 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
51963 pCur->iPage--;
51984 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
51986 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
51987 ** a positive value if pCur points at an etry that is larger than
51991 ** cursor pCur is pointing at the existing copy of a row that is to be
51992 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
51997 BtCursor *pCur, /* Insert data into the table of this cursor */
52009 Btree *p = pCur->pBtree;
52014 if( pCur->eState==CURSOR_FAULT ){
52015 assert( pCur->skipNext!=SQLITE_OK );
52016 return pCur->skipNext;
52019 assert( cursorHoldsMutex(pCur) );
52020 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
52021 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
52028 assert( (pKey==0)==(pCur->pKeyInfo==0) );
52033 if( pCur->pKeyInfo==0 ){
52048 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
52051 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
52054 assert( pCur->eState==CURSOR_VALID || (pCur
52056 pPage = pCur->apPage[pCur->iPage];
52061 pCur->pgnoRoot, nKey, nData, pPage->pgno,
52071 idx = pCur->aiIdx[pCur->iPage];
52089 idx = ++pCur->aiIdx[pCur->iPage];
52116 pCur->info.nSize = 0;
52117 pCur->validNKey = 0;
52119 rc = balance(pCur);
52125 pCur->apPage[pCur->iPage]->nOverflow = 0;
52126 pCur->eState = CURSOR_INVALID;
52128 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
52138 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
52139 Btree *p = pCur->pBtree;
52147 assert( cursorHoldsMutex(pCur) );
52150 assert( pCur->wrFlag );
52151 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
52152 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
52154 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
52155 || NEVER(pCur->eState!=CURSOR_VALID)
52162 if( pCur->pKeyInfo==0 ){
52163 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
52166 iCellDepth = pCur->iPage;
52167 iCellIdx = pCur->aiIdx[iCellDepth];
52168 pPage = pCur->apPage[iCellDepth];
52180 rc = sqlite3BtreePrevious(pCur, ¬Used);
52189 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
52203 MemPage *pLeaf = pCur->apPage[pCur->iPage];
52205 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
52227 ** pCur is pointing to the leaf page from which a cell was removed to
52236 rc = balance(pCur);
52237 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
52238 while( pCur->iPage>iCellDepth ){
52239 releasePage(pCur->apPage[pCur->iPage--]);
52241 rc = balance(pCur);
52245 moveToRoot(pCur);
52680 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
52687 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
52690 rc = moveToRoot(pCur);
52703 pPage = pCur->apPage[pCur->iPage];
52711 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
52720 if( pCur->iPage==0 ){
52725 moveToParent(pCur);
52726 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
52728 pCur->aiIdx[pCur->iPage]++;
52729 pPage = pCur->apPage[pCur->iPage];
52735 iIdx = pCur->aiIdx[pCur->iPage];
52737 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
52739 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
53455 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
53456 assert( cursorHoldsMutex(pCur) );
53457 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53458 invalidateOverflowCache(pCur);
53459 pCur->isIncrblobHandle = 1;
55045 ** The data or key is taken from the entry that pCur is currently pointing
55057 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
55067 assert( sqlite3BtreeCursorIsValid(pCur) );
55073 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
55075 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
55088 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
55090 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
58271 ** pCur points at an index entry created using the OP_MakeRecord opcode.
58275 ** pCur might be pointing to text obtained from a corrupt database file.
58278 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
58293 assert( sqlite3BtreeCursorIsValid(pCur) );
58294 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
58295 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
58300 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
58365 BtCursor *pCur = pC->pCursor;
58368 assert( sqlite3BtreeCursorIsValid(pCur) );
58369 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
58370 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
60730 VdbeCursor *pCur;
60926 VdbeCursor *pCur;
60939 VdbeCursor *pCur;
60954 VdbeCursor *pCur;
63434 VdbeCursor *pCur;
63485 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
63486 if( u.aw.pCur==0 ) goto no_mem;
63487 u.aw.pCur->nullRow = 1;
63488 u.aw.pCur->isOrdered = 1;
63489 rc = sqlite3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
63490 u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
63498 u.aw.pCur->pCursor = 0;
63506 u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
63507 u.aw.pCur->isIndex = !u.aw.pCur->isTable;
66009 VdbeCursor *pCur;
66015 u.cg.pCur = 0;
66027 u.cg.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
66028 if( u.cg.pCur ){
66029 u.cg.pCur->pVtabCursor = u.cg.pVtabCursor;
66030 u.cg.pCur->pModule = u.cg.pVtabCursor->pVtab->pModule;
66068 VdbeCursor *pCur;
66076 u.ch.pCur = p->apCsr[pOp->p1];
66079 assert( u.ch.pCur->pVtabCursor );
66080 u.ch.pVtabCursor = u.ch.pCur->pVtabCursor;
66110 u.ch.pCur->nullRow = 0;
66131 VdbeCursor *pCur = p->apCsr[pOp->p1];
66132 assert( pCur->pVtabCursor );
66136 if( pCur->nullRow ){
66140 u.ci.pVtab = pCur->pVtabCursor->pVtab;
66153 rc = u.ci.pModule->xColumn(pCur->pVtabCursor, &u.ci.sContext, pOp->p2);
66187 VdbeCursor *pCur;
66191 u.cj.pCur = p->apCsr[pOp->p1];
66192 assert( u.cj.pCur->pVtabCursor );
66193 if( u.cj.pCur->nullRow ){
66196 u.cj.pVtab = u.cj.pCur->pVtabCursor->pVtab;
66207 rc = u.cj.pModule->xNext(u.cj.pCur->pVtabCursor);
66211 u.cj.res = u.cj.pModule->xEof(u.cj.pCur->pVtabCursor);
