Lines Matching defs: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);
37364 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
37365 sqlite3BtreeEnter(pCur->pBtree);
37367 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
37368 sqlite3BtreeLeave(pCur->pBtree);
37987 ** Invalidate the overflow page-list cache for cursor pCur, if any.
37989 static void invalidateOverflowCache(BtCursor *pCur){
37990 assert( cursorHoldsMutex(pCur) );
37991 sqlite3_free(pCur->aOverflow);
37992 pCur->aOverflow = 0;
38123 static int saveCursorPosition(BtCursor *pCur){
38126 assert( CURSOR_VALID==pCur->eState );
38127 assert( 0==pCur->pKey );
38128 assert( cursorHoldsMutex(pCur) );
38130 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
38134 ** stores the integer key in pCur->nKey. In this case this value is
38135 ** all that is required. Otherwise, if pCur is not open on an intKey
38136 ** table, then malloc space for and store the pCur->nKey bytes of key
38139 if( 0==pCur->apPage[0]->intKey ){
38140 void *pKey = sqlite3Malloc( (int)pCur->nKey );
38142 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
38144 pCur->pKey = pKey;
38152 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
38156 for(i=0; i<=pCur->iPage; i++){
38157 releasePage(pCur->apPage[i]);
38158 pCur->apPage[i] = 0;
38160 pCur->iPage = -1;
38161 pCur->eState = CURSOR_REQUIRESEEK;
38164 invalidateOverflowCache(pCur);
38192 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
38193 assert( cursorHoldsMutex(pCur) );
38194 sqlite3_free(pCur->pKey);
38195 pCur->pKey = 0;
38196 pCur->eState = CURSOR_INVALID;
38205 BtCursor *pCur, /* Cursor open on the btree to be searched */
38217 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
38223 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
38237 static int btreeRestoreCursorPosition(BtCursor *pCur){
38239 assert( cursorHoldsMutex(pCur) );
38240 assert( pCur->eState>=CURSOR_REQUIRESEEK );
38241 if( pCur->eState==CURSOR_FAULT ){
38242 return pCur->skipNext;
38244 pCur->eState = CURSOR_INVALID;
38245 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
38247 sqlite3_free(pCur->pKey);
38248 pCur->pKey = 0;
38249 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
38267 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
38270 rc = restoreCursorPosition(pCur);
38275 if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
39534 BtCursor *pCur;
39539 pCur = pBt->pCursor;
39540 while( pCur ){
39541 BtCursor *pTmp = pCur;
39542 pCur = pCur->pNext;
40654 BtCursor *pCur;
40656 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
40657 if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
40849 ** on pCur to initialize the memory space prior to invoking this routine.
40856 BtCursor *pCur /* Space for new cursor */
40884 pCur->pgnoRoot = (Pgno)iTable;
40885 pCur->iPage = -1;
40886 pCur->pKeyInfo = pKeyInfo;
40887 pCur->pBtree = p;
40888 pCur->pBt = pBt;
40889 pCur->wrFlag = (u8)wrFlag;
40890 pCur->pNext = pBt->pCursor;
40891 if( pCur->pNext ){
40892 pCur->pNext->pPrev = pCur;
40894 pBt->pCursor = pCur;
40895 pCur->eState = CURSOR_INVALID;
40896 pCur->cachedRowid = 0;
40904 BtCursor *pCur /* Write new cursor here */
40908 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
40939 ** as pCur and having the same root page number as pCur. The value is
40949 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
40951 for(p=pCur->pBt->pCursor; p; p=p->pNext){
40952 if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
40954 assert( pCur->cachedRowid==iRowid );
40963 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
40964 return pCur->cachedRowid;
40971 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
40972 Btree *pBtree = pCur->pBtree;
40975 BtShared *pBt = pCur->pBt;
40977 sqlite3BtreeClearCursor(pCur);
40978 if( pCur->pPrev ){
40979 pCur->pPrev->pNext = pCur->pNext;
40981 pBt->pCursor = pCur->pNext;
40983 if( pCur->pNext ){
40984 pCur->pNext->pPrev = pCur->pPrev;
40986 for(i=0; i<=pCur->iPage; i++){
40987 releasePage(pCur->apPage[i]);
40990 invalidateOverflowCache(pCur);
40991 /* sqlite3_free(pCur); */
41013 static void assertCellInfo(BtCursor *pCur){
41015 int iPage = pCur->iPage;
41017 btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
41018 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
41025 static void getCellInfo(BtCursor *pCur){
41026 if( pCur->info.nSize==0 ){
41027 int iPage = pCur->iPage;
41028 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
41029 pCur->validNKey = 1;
41031 assertCellInfo(pCur);
41036 #define getCellInfo(pCur) \
41037 if( pCur->info.nSize==0 ){ \
41038 int iPage = pCur->iPage; \
41039 btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
41040 pCur->validNKey = 1; \
41042 assertCellInfo(pCur); \
41052 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
41053 return pCur && pCur->eState==CURSOR_VALID;
41069 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
41070 assert( cursorHoldsMutex(pCur) );
41071 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
41072 if( pCur->eState!=CURSOR_VALID ){
41075 getCellInfo(pCur);
41076 *pSize = pCur->info.nKey;
41093 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
41094 assert( cursorHoldsMutex(pCur) );
41095 assert( pCur->eState==CURSOR_VALID );
41096 getCellInfo(pCur);
41097 *pSize = pCur->info.nData;
41211 ** for the entry that the pCur cursor is pointing to. If the eOp
41238 BtCursor *pCur, /* Cursor pointing to entry to read from */
41248 MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
41249 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
41252 assert( pCur->eState==CURSOR_VALID );
41253 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41254 assert( cursorHoldsMutex(pCur) );
41256 getCellInfo(pCur);
41257 aPayload = pCur->info.pCell + pCur->info.nHeader;
41258 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
41260 if( NEVER(offset+amt > nKey+pCur->info.nData)
41261 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
41268 if( offset<pCur->info.nLocal ){
41270 if( a+offset>pCur->info.nLocal ){
41271 a = pCur->info.nLocal - offset;
41278 offset -= pCur->info.nLocal;
41285 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
41295 if( pCur->isIncrblobHandle && !pCur->aOverflow ){
41296 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
41297 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
41300 if( ALWAYS(nOvfl) && !pCur->aOverflow ){
41309 if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
41311 nextPage = pCur->aOverflow[iIdx];
41320 if( pCur->aOverflow ){
41321 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
41322 pCur->aOverflow[iIdx] = nextPage;
41334 if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
41335 nextPage = pCur->aOverflow[iIdx+1];
41370 ** Read part of the key associated with cursor pCur. Exactly
41374 ** The caller must ensure that pCur is pointing to a valid row
41381 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41382 assert( cursorHoldsMutex(pCur) );
41383 assert( pCur->eState==CURSOR_VALID );
41384 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
41385 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
41386 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
41390 ** Read part of the data associated with cursor pCur. Exactly
41398 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
41402 if ( pCur->eState==CURSOR_INVALID ){
41407 assert( cursorHoldsMutex(pCur) );
41408 rc = restoreCursorPosition(pCur);
41410 assert( pCur->eState==CURSOR_VALID );
41411 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
41412 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
41413 rc = accessPayload(pCur, offset, amt, pBuf, 0);
41420 ** pCur cursor is pointing to. The pointer is to the beginning of
41438 BtCursor *pCur, /* Cursor pointing to entry to read from */
41447 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
41448 assert( pCur->eState==CURSOR_VALID );
41449 assert( cursorHoldsMutex(pCur) );
41450 pPage = pCur->apPage[pCur->iPage];
41451 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41452 if( NEVER(pCur->info.nSize==0) ){
41453 btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
41454 &pCur->info);
41456 aPayload = pCur->info.pCell;
41457 aPayload += pCur->info.nHeader;
41461 nKey = (int)pCur->info.nKey;
41465 nLocal = pCur->info.nLocal - nKey;
41467 nLocal = pCur->info.nLocal;
41476 ** For the entry that cursor pCur is point to, return as
41489 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
41491 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41492 assert( cursorHoldsMutex(pCur) );
41493 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
41494 p = (const void*)fetchPayload(pCur, pAmt, 0);
41498 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
41500 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41501 assert( cursorHoldsMutex(pCur) );
41502 if( ALWAYS(pCur->eState==CURSOR_VALID) ){
41503 p = (const void*)fetchPayload(pCur, pAmt, 1);
41518 static int moveToChild(BtCursor *pCur, u32 newPgno){
41520 int i = pCur->iPage;
41522 BtShared *pBt = pCur->pBt;
41524 assert( cursorHoldsMutex(pCur) );
41525 assert( pCur->eState==CURSOR_VALID );
41526 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
41527 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
41532 pCur->apPage[i+1] = pNewPage;
41533 pCur->aiIdx[i+1] = 0;
41534 pCur->iPage++;
41536 pCur->info.nSize = 0;
41537 pCur->validNKey = 0;
41538 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
41567 ** pCur->idx is set to the cell index that contains the pointer
41569 ** right-most child page then pCur->idx is set to one more than
41572 static void moveToParent(BtCursor *pCur){
41573 assert( cursorHoldsMutex(pCur) );
41574 assert( pCur->eState==CURSOR_VALID );
41575 assert( pCur->iPage>0 );
41576 assert( pCur->apPage[pCur->iPage] );
41578 pCur->apPage[pCur->iPage-1],
41579 pCur->aiIdx[pCur->iPage-1],
41580 pCur->apPage[pCur->iPage]->pgno
41582 releasePage(pCur->apPage[pCur->iPage]);
41583 pCur->iPage--;
41584 pCur->info.nSize = 0;
41585 pCur->validNKey = 0;
41609 static int moveToRoot(BtCursor *pCur){
41612 Btree *p = pCur->pBtree;
41615 assert( cursorHoldsMutex(pCur) );
41619 if( pCur->eState>=CURSOR_REQUIRESEEK ){
41620 if( pCur->eState==CURSOR_FAULT ){
41621 assert( pCur->skipNext!=SQLITE_OK );
41622 return pCur->skipNext;
41624 sqlite3BtreeClearCursor(pCur);
41627 if( pCur->iPage>=0 ){
41629 for(i=1; i<=pCur->iPage; i++){
41630 releasePage(pCur->apPage[i]);
41632 pCur->iPage = 0;
41634 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
41636 pCur->eState = CURSOR_INVALID;
41639 pCur->iPage = 0;
41641 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
41645 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
41646 if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
41657 pRoot = pCur->apPage[0];
41658 assert( pRoot->pgno==pCur->pgnoRoot );
41659 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
41661 pCur->aiIdx[0] = 0;
41662 pCur->info.nSize = 0;
41663 pCur->atLast = 0;
41664 pCur->validNKey = 0;
41670 pCur->eState = CURSOR_VALID;
41671 rc = moveToChild(pCur, subpage);
41673 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
41685 static int moveToLeftmost(BtCursor *pCur){
41690 assert( cursorHoldsMutex(pCur) );
41691 assert( pCur->eState==CURSOR_VALID );
41692 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
41693 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
41694 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
41695 rc = moveToChild(pCur, pgno);
41710 static int moveToRightmost(BtCursor *pCur){
41715 assert( cursorHoldsMutex(pCur) );
41716 assert( pCur->eState==CURSOR_VALID );
41717 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
41719 pCur->aiIdx[pCur->iPage] = pPage->nCell;
41720 rc = moveToChild(pCur, pgno);
41723 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
41724 pCur->info.nSize = 0;
41725 pCur->validNKey = 0;
41734 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
41737 assert( cursorHoldsMutex(pCur) );
41738 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41739 rc = moveToRoot(pCur);
41741 if( pCur->eState==CURSOR_INVALID ){
41742 assert( pCur->apPage[pCur->iPage]->nCell==0 );
41746 assert( pCur->apPage[pCur->iPage]->nCell>0 );
41748 rc = moveToLeftmost(pCur);
41758 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
41761 assert( cursorHoldsMutex(pCur) );
41762 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41765 if( CURSOR_VALID==pCur->eState && pCur->atLast ){
41770 for(ii=0; ii<pCur->iPage; ii++){
41771 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
41773 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
41774 assert( pCur->apPage[pCur->iPage]->leaf );
41779 rc = moveToRoot(pCur);
41781 if( CURSOR_INVALID==pCur->eState ){
41782 assert( pCur->apPage[pCur->iPage]->nCell==0 );
41785 assert( pCur->eState==CURSOR_VALID );
41787 rc = moveToRightmost(pCur);
41788 pCur->atLast = rc==SQLITE_OK ?1:0;
41823 BtCursor *pCur, /* The cursor to be moved */
41831 assert( cursorHoldsMutex(pCur) );
41832 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
41834 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
41838 if( pCur->eState==CURSOR_VALID && pCur->validNKey
41839 && pCur->apPage[0]->intKey
41841 if( pCur->info.nKey==intKey ){
41845 if( pCur->atLast && pCur->info.nKey<intKey ){
41851 rc = moveToRoot(pCur);
41855 assert( pCur->apPage[pCur->iPage] );
41856 assert( pCur->apPage[pCur->iPage]->isInit );
41857 assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID );
41858 if( pCur->eState==CURSOR_INVALID ){
41860 assert( pCur->apPage[pCur->iPage]->nCell==0 );
41863 assert( pCur->apPage[0]->intKey || pIdxKey );
41867 MemPage *pPage = pCur->apPage[pCur->iPage];
41881 pCur->aiIdx[pCur->iPage] = (u16)upr;
41883 pCur->aiIdx[pCur->iPage] = (u16)((upr+lwr)/2);
41886 int idx = pCur->aiIdx[pCur->iPage]; /* Index of current cell in pPage */
41889 pCur->info.nSize = 0;
41906 pCur->validNKey = 1;
41907 pCur->info.nKey = nCellKey;
41936 btreeParseCellPtr(pPage, pCellBody, &pCur->info);
41937 nCell = (int)pCur->info.nKey;
41943 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
41971 pCur->aiIdx[pCur->iPage] = (u16)((lwr+upr)/2);
41983 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
41988 pCur->aiIdx[pCur->iPage] = (u16)lwr;
41989 pCur->info.nSize = 0;
41990 pCur->validNKey = 0;
41991 rc = moveToChild(pCur, chldPg);
42006 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
42011 return (CURSOR_VALID!=pCur->eState);
42020 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
42025 assert( cursorHoldsMutex(pCur) );
42026 rc = restoreCursorPosition(pCur);
42031 if( CURSOR_INVALID==pCur->eState ){
42035 if( pCur->skipNext>0 ){
42036 pCur->skipNext = 0;
42040 pCur->skipNext = 0;
42042 pPage = pCur->apPage[pCur->iPage];
42043 idx = ++pCur->aiIdx[pCur->iPage];
42047 pCur->info.nSize = 0;
42048 pCur->validNKey = 0;
42051 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
42053 rc = moveToLeftmost(pCur);
42058 if( pCur->iPage==0 ){
42060 pCur->eState = CURSOR_INVALID;
42063 moveToParent(pCur);
42064 pPage = pCur->apPage[pCur->iPage];
42065 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
42068 rc = sqlite3BtreeNext(pCur, pRes);
42078 rc = moveToLeftmost(pCur);
42089 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
42093 assert( cursorHoldsMutex(pCur) );
42094 rc = restoreCursorPosition(pCur);
42098 pCur->atLast = 0;
42099 if( CURSOR_INVALID==pCur->eState ){
42103 if( pCur->skipNext<0 ){
42104 pCur->skipNext = 0;
42108 pCur->skipNext = 0;
42110 pPage = pCur->apPage[pCur->iPage];
42113 int idx = pCur->aiIdx[pCur->iPage];
42114 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
42118 rc = moveToRightmost(pCur);
42120 while( pCur->aiIdx[pCur->iPage]==0 ){
42121 if( pCur->iPage==0 ){
42122 pCur->eState = CURSOR_INVALID;
42126 moveToParent(pCur);
42128 pCur->info.nSize = 0;
42129 pCur->validNKey = 0;
42131 pCur->aiIdx[pCur->iPage]--;
42132 pPage = pCur->apPage[pCur->iPage];
42134 rc = sqlite3BtreePrevious(pCur, pRes);
43890 ** The page that pCur currently points to has just been modified in
43899 static int balance(BtCursor *pCur){
43901 const int nMin = pCur->pBt->usableSize * 2 / 3;
43909 int iPage = pCur->iPage;
43910 MemPage *pPage = pCur->apPage[iPage];
43920 rc = balance_deeper(pPage, &pCur->apPage[1]);
43922 pCur->iPage = 1;
43923 pCur->aiIdx[0] = 0;
43924 pCur->aiIdx[1] = 0;
43925 assert( pCur->apPage[1]->nOverflow );
43933 MemPage * const pParent = pCur->apPage[iPage-1];
43934 int const iIdx = pCur->aiIdx[iPage-1];
43980 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
44001 pCur->iPage--;
44022 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
44024 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
44025 ** a positive value if pCur points at an etry that is larger than
44029 ** cursor pCur is pointing at the existing copy of a row that is to be
44030 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
44035 BtCursor *pCur, /* Insert data into the table of this cursor */
44047 Btree *p = pCur->pBtree;
44052 if( pCur->eState==CURSOR_FAULT ){
44053 assert( pCur->skipNext!=SQLITE_OK );
44054 return pCur->skipNext;
44057 assert( cursorHoldsMutex(pCur) );
44058 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
44059 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
44066 assert( (pKey==0)==(pCur->pKeyInfo==0) );
44071 if( pCur->pKeyInfo==0 ){
44086 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
44089 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
44092 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
44094 pPage = pCur->apPage[pCur->iPage];
44099 pCur->pgnoRoot, nKey, nData, pPage->pgno,
44109 idx = pCur->aiIdx[pCur->iPage];
44127 idx = ++pCur->aiIdx[pCur->iPage];
44154 pCur->info.nSize = 0;
44155 pCur->validNKey = 0;
44157 rc = balance(pCur);
44163 pCur->apPage[pCur->iPage]->nOverflow = 0;
44164 pCur->eState = CURSOR_INVALID;
44166 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
44176 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
44177 Btree *p = pCur->pBtree;
44185 assert( cursorHoldsMutex(pCur) );
44188 assert( pCur->wrFlag );
44189 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
44190 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
44192 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
44193 || NEVER(pCur->eState!=CURSOR_VALID)
44200 if( pCur->pKeyInfo==0 ){
44201 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
44204 iCellDepth = pCur->iPage;
44205 iCellIdx = pCur->aiIdx[iCellDepth];
44206 pPage = pCur->apPage[iCellDepth];
44218 rc = sqlite3BtreePrevious(pCur, ¬Used);
44227 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
44241 MemPage *pLeaf = pCur->apPage[pCur->iPage];
44243 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
44265 ** pCur is pointing to the leaf page from which a cell was removed to
44274 rc = balance(pCur);
44275 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
44276 while( pCur->iPage>iCellDepth ){
44277 releasePage(pCur->apPage[pCur->iPage--]);
44279 rc = balance(pCur);
44283 moveToRoot(pCur);
44705 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
44712 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
44715 rc = moveToRoot(pCur);
44728 pPage = pCur->apPage[pCur->iPage];
44736 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
44745 if( pCur->iPage==0 ){
44750 moveToParent(pCur);
44751 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
44753 pCur->aiIdx[pCur->iPage]++;
44754 pPage = pCur->apPage[pCur->iPage];
44760 iIdx = pCur->aiIdx[pCur->iPage];
44762 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
44764 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
45405 SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
45406 assert( cursorHoldsMutex(pCur) );
45407 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
45408 assert(!pCur->isIncrblobHandle);
45409 assert(!pCur->aOverflow);
45410 pCur->isIncrblobHandle = 1;
46905 ** The data or key is taken from the entry that pCur is currently pointing
46917 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
46927 assert( sqlite3BtreeCursorIsValid(pCur) );
46933 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
46935 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
46948 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
46950 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
50059 ** pCur points at an index entry created using the OP_MakeRecord opcode.
50063 ** pCur might be pointing to text obtained from a corrupt database file.
50066 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
50081 assert( sqlite3BtreeCursorIsValid(pCur) );
50082 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
50083 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
50088 rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
50153 BtCursor *pCur = pC->pCursor;
50156 assert( sqlite3BtreeCursorIsValid(pCur) );
50157 rc = sqlite3BtreeKeySize(pCur, &nCellKey);
50158 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
52434 VdbeCursor *pCur;
52623 VdbeCursor *pCur;
52636 VdbeCursor *pCur;
52651 VdbeCursor *pCur;
55124 VdbeCursor *pCur;
55173 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
55174 if( u.aw.pCur==0 ) goto no_mem;
55175 u.aw.pCur->nullRow = 1;
55176 rc = sqlite3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
55177 u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
55185 u.aw.pCur->pCursor = 0;
55193 u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
55194 u.aw.pCur->isIndex = !u.aw.pCur->isTable;
57523 VdbeCursor *pCur;
57529 u.cf.pCur = 0;
57545 u.cf.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
57546 if( u.cf.pCur ){
57547 u.cf.pCur->pVtabCursor = u.cf.pVtabCursor;
57548 u.cf.pCur->pModule = u.cf.pVtabCursor->pVtab->pModule;
57586 VdbeCursor *pCur;
57594 u.cg.pCur = p->apCsr[pOp->p1];
57596 assert( u.cg.pCur->pVtabCursor );
57597 u.cg.pVtabCursor = u.cg.pCur->pVtabCursor;
57631 u.cg.pCur->nullRow = 0;
57652 VdbeCursor *pCur = p->apCsr[pOp->p1];
57653 assert( pCur->pVtabCursor );
57656 if( pCur->nullRow ){
57660 u.ch.pVtab = pCur->pVtabCursor->pVtab;
57674 rc = u.ch.pModule->xColumn(pCur->pVtabCursor, &u.ch.sContext, pOp->p2);
57713 VdbeCursor *pCur;
57717 u.ci.pCur = p->apCsr[pOp->p1];
57718 assert( u.ci.pCur->pVtabCursor );
57719 if( u.ci.pCur->nullRow ){
57722 u.ci.pVtab = u.ci.pCur->pVtabCursor->pVtab;
57734 rc = u.ci.pModule->xNext(u.ci.pCur->pVtabCursor);
57740 u.ci.res = u.ci.pModule->xEof(u.ci.pCur->pVtabCursor);
106134 Fts3Cursor *pCur, /* The fulltest search cursor */
106158 pVtab = (Fts3Table *)pCur->base.pVtab;
106169 Fts3Expr *pIter = pCur->pExpr;