Lines Matching defs:pCur
6300 ** ^The current value of the requested parameter is written into *pCur
6310 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
48134 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
48135 sqlite3BtreeEnter(pCur->pBtree);
48137 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
48138 sqlite3BtreeLeave(pCur->pBtree);
48694 ** Invalidate the overflow page-list cache for cursor pCur, if any.
48696 static void invalidateOverflowCache(BtCursor *pCur){
48697 assert( cursorHoldsMutex(pCur) );
48698 sqlite3_free(pCur->aOverflow);
48699 pCur->aOverflow = 0;
48827 static int saveCursorPosition(BtCursor *pCur){
48830 assert( CURSOR_VALID==pCur->eState );
48831 assert( 0==pCur->pKey );
48832 assert( cursorHoldsMutex(pCur) );
48834 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
48838 ** stores the integer key in pCur->nKey. In this case this value is
48839 ** all that is required. Otherwise, if pCur is not open on an intKey
48840 ** table, then malloc space for and store the pCur->nKey bytes of key
48843 if( 0==pCur->apPage[0]->intKey ){
48844 void *pKey = sqlite3Malloc( (int)pCur->nKey );
48846 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
48848 pCur->pKey = pKey;
48856 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
48860 for(i=0; i<=pCur->iPage; i++){
48861 releasePage(pCur->apPage[i]);
48862 pCur->apPage[i] = 0;
48864 pCur->iPage = -1;
48865 pCur->eState = CURSOR_REQUIRESEEK;
48868 invalidateOverflowCache(pCur);
48896 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
48897 assert( cursorHoldsMutex(pCur) );
48898 sqlite3_free(pCur->pKey);
48899 pCur->pKey = 0;
48900 pCur->eState = CURSOR_INVALID;
48909 BtCursor *pCur, /* Cursor open on the btree to be searched */
48923 pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
48926 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
48930 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
48932 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
48944 static int btreeRestoreCursorPosition(BtCursor *pCur){
48946 assert( cursorHoldsMutex(pCur) );
48947 assert( pCur->eState>=CURSOR_REQUIRESEEK );
48948 if( pCur->eState==CURSOR_FAULT ){
48949 return pCur->skipNext;
48951 pCur->eState = CURSOR_INVALID;
48952 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
48954 sqlite3_free(pCur->pKey);
48955 pCur->pKey = 0;
48956 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
48974 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
48977 rc = restoreCursorPosition(pCur);
48982 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
50283 BtCursor *pCur;
50288 pCur = pBt->pCursor;
50289 while( pCur ){
50290 BtCursor *pTmp = pCur;
50291 pCur = pCur->pNext;
51501 BtCursor *pCur;
51503 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
51504 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
51704 ** on pCur to initialize the memory space prior to invoking this routine.
51711 BtCursor *pCur /* Space for new cursor */
51740 pCur->pgnoRoot = (Pgno)iTable;
51741 pCur->iPage = -1;
51742 pCur->pKeyInfo = pKeyInfo;
51743 pCur->pBtree = p;
51744 pCur->pBt = pBt;
51745 pCur->wrFlag = (u8)wrFlag;
51746 pCur->pNext = pBt->pCursor;
51747 if( pCur->pNext ){
51748 pCur->pNext->pPrev = pCur;
51750 pBt->pCursor = pCur;
51751 pCur->eState = CURSOR_INVALID;
51752 pCur->cachedRowid = 0;
51760 BtCursor *pCur /* Write new cursor here */
51764 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
51795 ** as pCur and having the same root page number as pCur. The value is
51805 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
51807 for(p=pCur->pBt->pCursor; p; p=p->pNext){
51808 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
51810 assert( pCur->cachedRowid==iRowid );
51819 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
51820 return pCur->cachedRowid;
51827 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
51828 Btree *pBtree = pCur->pBtree;
51831 BtShared *pBt = pCur->pBt;
51833 sqlite3BtreeClearCursor(pCur);
51834 if( pCur->pPrev ){
51835 pCur->pPrev->pNext = pCur->pNext;
51837 pBt->pCursor = pCur->pNext;
51839 if( pCur->pNext ){
51840 pCur->pNext->pPrev = pCur->pPrev;
51842 for(i=0; i<=pCur->iPage; i++){
51843 releasePage(pCur->apPage[i]);
51846 invalidateOverflowCache(pCur);
51847 /* sqlite3_free(pCur); */
51869 static void assertCellInfo(BtCursor *pCur){
51871 int iPage = pCur->iPage;
51873 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
51874 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
51881 static void getCellInfo(BtCursor *pCur){
51882 if( pCur->info.nSize==0 ){
51883 int iPage = pCur->iPage;
51884 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
51885 pCur->validNKey = 1;
51887 assertCellInfo(pCur);
51892 #define getCellInfo(pCur) \
51893 if( pCur->info.nSize==0 ){ \
51894 int iPage = pCur->iPage; \
51895 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
51896 pCur->validNKey = 1; \
51898 assertCellInfo(pCur); \
51908 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
51909 return pCur && pCur->eState==CURSOR_VALID;
51925 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
51926 assert( cursorHoldsMutex(pCur) );
51927 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
51928 if( pCur->eState!=CURSOR_VALID ){
51931 getCellInfo(pCur);
51932 *pSize = pCur->info.nKey;
51949 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
51950 assert( cursorHoldsMutex(pCur) );
51951 assert( pCur->eState==CURSOR_VALID );
51952 getCellInfo(pCur);
51953 *pSize = pCur->info.nData;
52067 ** for the entry that the pCur cursor is pointing to. If the eOp
52094 BtCursor *pCur, /* Cursor pointing to entry to read from */
52104 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
52105 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
52108 assert( pCur->eState==CURSOR_VALID );
52109 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52110 assert( cursorHoldsMutex(pCur) );
52112 getCellInfo(pCur);
52113 aPayload = pCur->info.pCell + pCur->info.nHeader;
52114 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
52116 if( NEVER(offset+amt > nKey+pCur->info.nData)
52117 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
52124 if( offset<pCur->info.nLocal ){
52126 if( a+offset>pCur->info.nLocal ){
52127 a = pCur->info.nLocal - offset;
52134 offset -= pCur->info.nLocal;
52141 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
52151 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
52152 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
52153 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
52156 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
52165 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
52167 nextPage = pCur->aOverflow[iIdx];
52176 if( pCur->aOverflow ){
52177 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
52178 pCur->aOverflow[iIdx] = nextPage;
52190 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
52191 nextPage = pCur->aOverflow[iIdx+1];
52226 ** Read part of the key associated with cursor pCur. Exactly
52230 ** The caller must ensure that pCur is pointing to a valid row
52237 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
52238 assert( cursorHoldsMutex(pCur) );
52239 assert( pCur->eState==CURSOR_VALID );
52240 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
52241 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52242 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
52246 ** Read part of the data associated with cursor pCur. Exactly
52254 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
52258 if ( pCur->eState==CURSOR_INVALID ){
52263 assert( cursorHoldsMutex(pCur) );
52264 rc = restoreCursorPosition(pCur);
52266 assert( pCur->eState==CURSOR_VALID );
52267 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
52268 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52269 rc = accessPayload(pCur, offset, amt, pBuf, 0);
52276 ** pCur cursor is pointing to. The pointer is to the beginning of
52294 BtCursor *pCur, /* Cursor pointing to entry to read from */
52303 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
52304 assert( pCur->eState==CURSOR_VALID );
52305 assert( cursorHoldsMutex(pCur) );
52306 pPage = pCur->apPage[pCur->iPage];
52307 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52308 if( NEVER(pCur->info.nSize==0) ){
52309 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
52310 &pCur->info);
52312 aPayload = pCur->info.pCell;
52313 aPayload += pCur->info.nHeader;
52317 nKey = (int)pCur->info.nKey;
52321 nLocal = pCur->info.nLocal - nKey;
52323 nLocal = pCur->info.nLocal;
52332 ** For the entry that cursor pCur is point to, return as
52345 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
52347 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52348 assert( cursorHoldsMutex(pCur) );
52349 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
52350 p = (const void*)fetchPayload(pCur, pAmt, 0);
52354 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
52356 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52357 assert( cursorHoldsMutex(pCur) );
52358 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
52359 p = (const void*)fetchPayload(pCur, pAmt, 1);
52374 static int moveToChild(BtCursor *pCur, u32 newPgno){
52376 int i = pCur->iPage;
52378 BtShared *pBt = pCur->pBt;
52380 assert( cursorHoldsMutex(pCur) );
52381 assert( pCur->eState==CURSOR_VALID );
52382 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
52383 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
52388 pCur->apPage[i+1] = pNewPage;
52389 pCur->aiIdx[i+1] = 0;
52390 pCur->iPage++;
52392 pCur->info.nSize = 0;
52393 pCur->validNKey = 0;
52394 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
52423 ** pCur->idx is set to the cell index that contains the pointer
52425 ** right-most child page then pCur->idx is set to one more than
52428 static void moveToParent(BtCursor *pCur){
52429 assert( cursorHoldsMutex(pCur) );
52430 assert( pCur->eState==CURSOR_VALID );
52431 assert( pCur->iPage>0 );
52432 assert( pCur->apPage[pCur->iPage] );
52434 pCur->apPage[pCur->iPage-1],
52435 pCur->aiIdx[pCur->iPage-1],
52436 pCur->apPage[pCur->iPage]->pgno
52438 releasePage(pCur->apPage[pCur->iPage]);
52439 pCur->iPage--;
52440 pCur->info.nSize = 0;
52441 pCur->validNKey = 0;
52465 static int moveToRoot(BtCursor *pCur){
52468 Btree *p = pCur->pBtree;
52471 assert( cursorHoldsMutex(pCur) );
52475 if( pCur->eState>=CURSOR_REQUIRESEEK ){
52476 if( pCur->eState==CURSOR_FAULT ){
52477 assert( pCur->skipNext!=SQLITE_OK );
52478 return pCur->skipNext;
52480 sqlite3BtreeClearCursor(pCur);
52483 if( pCur->iPage>=0 ){
52485 for(i=1; i<=pCur->iPage; i++){
52486 releasePage(pCur->apPage[i]);
52488 pCur->iPage = 0;
52489 }else if( pCur->pgnoRoot==0 ){
52490 pCur->eState = CURSOR_INVALID;
52493 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
52495 pCur->eState = CURSOR_INVALID;
52498 pCur->iPage = 0;
52500 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
52504 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
52505 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
52516 pRoot = pCur->apPage[0];
52517 assert( pRoot->pgno==pCur->pgnoRoot );
52518 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
52520 pCur->aiIdx[0] = 0;
52521 pCur->info.nSize = 0;
52522 pCur->atLast = 0;
52523 pCur->validNKey = 0;
52529 pCur->eState = CURSOR_VALID;
52530 rc = moveToChild(pCur, subpage);
52532 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
52544 static int moveToLeftmost(BtCursor *pCur){
52549 assert( cursorHoldsMutex(pCur) );
52550 assert( pCur->eState==CURSOR_VALID );
52551 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
52552 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52553 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
52554 rc = moveToChild(pCur, pgno);
52569 static int moveToRightmost(BtCursor *pCur){
52574 assert( cursorHoldsMutex(pCur) );
52575 assert( pCur->eState==CURSOR_VALID );
52576 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
52578 pCur->aiIdx[pCur->iPage] = pPage->nCell;
52579 rc = moveToChild(pCur, pgno);
52582 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
52583 pCur->info.nSize = 0;
52584 pCur->validNKey = 0;
52593 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
52596 assert( cursorHoldsMutex(pCur) );
52597 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52598 rc = moveToRoot(pCur);
52600 if( pCur->eState==CURSOR_INVALID ){
52601 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52604 assert( pCur->apPage[pCur->iPage]->nCell>0 );
52606 rc = moveToLeftmost(pCur);
52616 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
52619 assert( cursorHoldsMutex(pCur) );
52620 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52623 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
52628 for(ii=0; ii<pCur->iPage; ii++){
52629 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
52631 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
52632 assert( pCur->apPage[pCur->iPage]->leaf );
52637 rc = moveToRoot(pCur);
52639 if( CURSOR_INVALID==pCur->eState ){
52640 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52643 assert( pCur->eState==CURSOR_VALID );
52645 rc = moveToRightmost(pCur);
52646 pCur->atLast = rc==SQLITE_OK ?1:0;
52681 BtCursor *pCur, /* The cursor to be moved */
52689 assert( cursorHoldsMutex(pCur) );
52690 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52692 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
52696 if( pCur->eState==CURSOR_VALID && pCur->validNKey
52697 && pCur->apPage[0]->intKey
52699 if( pCur->info.nKey==intKey ){
52703 if( pCur->atLast && pCur->info.nKey<intKey ){
52709 rc = moveToRoot(pCur);
52713 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
52714 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
52715 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
52716 if( pCur->eState==CURSOR_INVALID ){
52718 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52721 assert( pCur->apPage[0]->intKey || pIdxKey );
52725 MemPage *pPage = pCur->apPage[pCur->iPage];
52739 pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
52741 pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
52746 assert( idx==pCur->aiIdx[pCur->iPage] );
52747 pCur->info.nSize = 0;
52764 pCur->validNKey = 1;
52765 pCur->info.nKey = nCellKey;
52794 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
52795 nCell = (int)pCur->info.nKey;
52801 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
52829 pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
52841 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52846 pCur->aiIdx[pCur->iPage] = (u16)lwr;
52847 pCur->info.nSize = 0;
52848 pCur->validNKey = 0;
52849 rc = moveToChild(pCur, chldPg);
52864 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
52869 return (CURSOR_VALID!=pCur->eState);
52878 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
52883 assert( cursorHoldsMutex(pCur) );
52884 rc = restoreCursorPosition(pCur);
52889 if( CURSOR_INVALID==pCur->eState ){
52893 if( pCur->skipNext>0 ){
52894 pCur->skipNext = 0;
52898 pCur->skipNext = 0;
52900 pPage = pCur->apPage[pCur->iPage];
52901 idx = ++pCur->aiIdx[pCur->iPage];
52905 pCur->info.nSize = 0;
52906 pCur->validNKey = 0;
52909 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
52911 rc = moveToLeftmost(pCur);
52916 if( pCur->iPage==0 ){
52918 pCur->eState = CURSOR_INVALID;
52921 moveToParent(pCur);
52922 pPage = pCur->apPage[pCur->iPage];
52923 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
52926 rc = sqlite3BtreeNext(pCur, pRes);
52936 rc = moveToLeftmost(pCur);
52947 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
52951 assert( cursorHoldsMutex(pCur) );
52952 rc = restoreCursorPosition(pCur);
52956 pCur->atLast = 0;
52957 if( CURSOR_INVALID==pCur->eState ){
52961 if( pCur->skipNext<0 ){
52962 pCur->skipNext = 0;
52966 pCur->skipNext = 0;
52968 pPage = pCur->apPage[pCur->iPage];
52971 int idx = pCur->aiIdx[pCur->iPage];
52972 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
52976 rc = moveToRightmost(pCur);
52978 while( pCur->aiIdx[pCur->iPage]==0 ){
52979 if( pCur->iPage==0 ){
52980 pCur->eState = CURSOR_INVALID;
52984 moveToParent(pCur);
52986 pCur->info.nSize = 0;
52987 pCur->validNKey = 0;
52989 pCur->aiIdx[pCur->iPage]--;
52990 pPage = pCur->apPage[pCur->iPage];
52992 rc = sqlite3BtreePrevious(pCur, pRes);
54793 ** The page that pCur currently points to has just been modified in
54802 static int balance(BtCursor *pCur){
54804 const int nMin = pCur->pBt->usableSize * 2 / 3;
54812 int iPage = pCur->iPage;
54813 MemPage *pPage = pCur->apPage[iPage];
54823 rc = balance_deeper(pPage, &pCur->apPage[1]);
54825 pCur->iPage = 1;
54826 pCur->aiIdx[0] = 0;
54827 pCur->aiIdx[1] = 0;
54828 assert( pCur->apPage[1]->nOverflow );
54836 MemPage * const pParent = pCur->apPage[iPage-1];
54837 int const iIdx = pCur->aiIdx[iPage-1];
54883 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
54904 pCur->iPage--;
54925 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
54927 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
54928 ** a positive value if pCur points at an etry that is larger than
54932 ** cursor pCur is pointing at the existing copy of a row that is to be
54933 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
54938 BtCursor *pCur, /* Insert data into the table of this cursor */
54950 Btree *p = pCur->pBtree;
54955 if( pCur->eState==CURSOR_FAULT ){
54956 assert( pCur->skipNext!=SQLITE_OK );
54957 return pCur->skipNext;
54960 assert( cursorHoldsMutex(pCur) );
54961 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
54962 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
54969 assert( (pKey==0)==(pCur->pKeyInfo==0) );
54974 if( pCur->pKeyInfo==0 ){
54989 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
54992 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
54995 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
54997 pPage = pCur->apPage[pCur->iPage];
55002 pCur->pgnoRoot, nKey, nData, pPage->pgno,
55012 idx = pCur->aiIdx[pCur->iPage];
55030 idx = ++pCur->aiIdx[pCur->iPage];
55057 pCur->info.nSize = 0;
55058 pCur->validNKey = 0;
55060 rc = balance(pCur);
55066 pCur->apPage[pCur->iPage]->nOverflow = 0;
55067 pCur->eState = CURSOR_INVALID;
55069 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
55079 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
55080 Btree *p = pCur->pBtree;
55088 assert( cursorHoldsMutex(pCur) );
55091 assert( pCur->wrFlag );
55092 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
55093 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
55095 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
55096 || NEVER(pCur->eState!=CURSOR_VALID)
55103 if( pCur->pKeyInfo==0 ){
55104 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
55107 iCellDepth = pCur->iPage;
55108 iCellIdx = pCur->aiIdx[iCellDepth];
55109 pPage = pCur->apPage[iCellDepth];
55121 rc = sqlite3BtreePrevious(pCur, ¬Used);
55130 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
55144 MemPage *pLeaf = pCur->apPage[pCur->iPage];
55146 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
55168 ** pCur is pointing to the leaf page from which a cell was removed to
55177 rc = balance(pCur);
55178 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
55179 while( pCur->iPage>iCellDepth ){
55180 releasePage(pCur->apPage[pCur->iPage--]);
55182 rc = balance(pCur);
55186 moveToRoot(pCur);
55621 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
55628 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
55632 if( pCur->pgnoRoot==0 ){
55636 rc = moveToRoot(pCur);
55649 pPage = pCur->apPage[pCur->iPage];
55657 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
55666 if( pCur->iPage==0 ){
55671 moveToParent(pCur);
55672 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
55674 pCur->aiIdx[pCur->iPage]++;
55675 pPage = pCur->apPage[pCur->iPage];
55681 iIdx = pCur->aiIdx[pCur->iPage];
55683 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
55685 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
56403 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
56404 assert( cursorHoldsMutex(pCur) );
56405 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
56406 invalidateOverflowCache(pCur);
56407 pCur->isIncrblobHandle = 1;
58034 ** The data or key is taken from the entry that pCur is currently pointing
58046 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
58056 assert( sqlite3BtreeCursorIsValid(pCur) );
58062 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
58064 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
58077 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
58079 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
61347 ** pCur points at an index entry created using the OP_MakeRecord opcode.
61351 ** pCur might be pointing to text obtained from a corrupt database file.
61354 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
61369 assert( sqlite3BtreeCursorIsValid(pCur) );
61370 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
61371 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
61376 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
61441 BtCursor *pCur = pC->pCursor;
61444 assert( sqlite3BtreeCursorIsValid(pCur) );
61445 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
61446 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
63833 VdbeCursor *pCur;
64044 VdbeCursor *pCur;
64057 VdbeCursor *pCur;
64072 VdbeCursor *pCur;
66640 VdbeCursor *pCur;
66692 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
66693 if( u.aw.pCur==0 ) goto no_mem;
66694 u.aw.pCur->nullRow = 1;
66695 u.aw.pCur->isOrdered = 1;
66696 rc = sqlite3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
66697 u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
66707 u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
66708 u.aw.pCur->isIndex = !u.aw.pCur->isTable;
69307 VdbeCursor *pCur;
69313 u.ck.pCur = 0;
69325 u.ck.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
69326 if( u.ck.pCur ){
69327 u.ck.pCur->pVtabCursor = u.ck.pVtabCursor;
69328 u.ck.pCur->pModule = u.ck.pVtabCursor->pVtab->pModule;
69366 VdbeCursor *pCur;
69374 u.cl.pCur = p->apCsr[pOp->p1];
69377 assert( u.cl.pCur->pVtabCursor );
69378 u.cl.pVtabCursor = u.cl.pCur->pVtabCursor;
69408 u.cl.pCur->nullRow = 0;
69429 VdbeCursor *pCur = p->apCsr[pOp->p1];
69430 assert( pCur->pVtabCursor );
69434 if( pCur->nullRow ){
69438 u.cm.pVtab = pCur->pVtabCursor->pVtab;
69451 rc = u.cm.pModule->xColumn(pCur->pVtabCursor, &u.cm.sContext, pOp->p2);
69485 VdbeCursor *pCur;
69489 u.cn.pCur = p->apCsr[pOp->p1];
69490 assert( u.cn.pCur->pVtabCursor );
69491 if( u.cn.pCur->nullRow ){
69494 u.cn.pVtab = u.cn.pCur->pVtabCursor->pVtab;
69505 rc = u.cn.pModule->xNext(u.cn.pCur->pVtabCursor);
69509 u.cn.res = u.cn.pModule->xEof(u.cn.pCur->pVtabCursor);