• Home
  • Raw
  • Download

Lines Matching refs:pCur

8683 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
63200 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
63201 sqlite3BtreeEnter(pCur->pBtree);
63204 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
63205 sqlite3BtreeLeave(pCur->pBtree);
63715 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
63842 static void btreeReleaseAllCursorPages(BtCursor *pCur){
63844 if( pCur->iPage>=0 ){
63845 for(i=0; i<pCur->iPage; i++){
63846 releasePageNotNull(pCur->apPage[i]);
63848 releasePageNotNull(pCur->pPage);
63849 pCur->iPage = -1;
63866 static int saveCursorKey(BtCursor *pCur){
63868 assert( CURSOR_VALID==pCur->eState );
63869 assert( 0==pCur->pKey );
63870 assert( cursorHoldsMutex(pCur) );
63872 if( pCur->curIntKey ){
63874 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
63883 pCur->nKey = sqlite3BtreePayloadSize(pCur);
63884 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
63886 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
63888 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
63889 pCur->pKey = pKey;
63897 assert( !pCur->curIntKey || !pCur->pKey );
63908 static int saveCursorPosition(BtCursor *pCur){
63911 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
63912 assert( 0==pCur->pKey );
63913 assert( cursorHoldsMutex(pCur) );
63915 if( pCur->eState==CURSOR_SKIPNEXT ){
63916 pCur->eState = CURSOR_VALID;
63918 pCur->skipNext = 0;
63921 rc = saveCursorKey(pCur);
63923 btreeReleaseAllCursorPages(pCur);
63924 pCur->eState = CURSOR_REQUIRESEEK;
63927 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
63997 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
63998 assert( cursorHoldsMutex(pCur) );
63999 sqlite3_free(pCur->pKey);
64000 pCur->pKey = 0;
64001 pCur->eState = CURSOR_INVALID;
64010 BtCursor *pCur, /* Cursor open on the btree to be searched */
64020 KeyInfo *pKeyInfo = pCur->pKeyInfo;
64032 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
64035 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
64047 static int btreeRestoreCursorPosition(BtCursor *pCur){
64050 assert( cursorOwnsBtShared(pCur) );
64051 assert( pCur->eState>=CURSOR_REQUIRESEEK );
64052 if( pCur->eState==CURSOR_FAULT ){
64053 return pCur->skipNext;
64055 pCur->eState = CURSOR_INVALID;
64059 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
64062 sqlite3_free(pCur->pKey);
64063 pCur->pKey = 0;
64064 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
64065 if( skipNext ) pCur->skipNext = skipNext;
64066 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
64067 pCur->eState = CURSOR_SKIPNEXT;
64090 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
64091 assert( EIGHT_BYTE_ALIGNMENT(pCur)
64092 || pCur==sqlite3BtreeFakeValidCursor() );
64094 assert( sizeof(pCur->eState)==1 );
64095 return CURSOR_VALID != *(u8*)pCur;
64122 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
64125 assert( pCur!=0 );
64126 assert( pCur->eState!=CURSOR_VALID );
64127 rc = restoreCursorPosition(pCur);
64132 if( pCur->eState!=CURSOR_VALID ){
64146 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
64154 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
64156 pCur->hints = x;
65369 BtCursor *pCur, /* Cursor to receive the page, or NULL */
65375 assert( pCur==0 || ppPage==&pCur->pPage );
65376 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
65377 assert( pCur==0 || pCur->iPage>0 );
65400 if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
65409 if( pCur ){
65410 pCur->iPage--;
65411 pCur->pPage = pCur->apPage[pCur->iPage];
65911 BtCursor *pCur;
65916 pCur = pBt->pCursor;
65917 while( pCur ){
65918 BtCursor *pTmp = pCur;
65919 pCur = pCur->pNext;
66454 BtCursor *pCur;
66456 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
66457 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
66458 && pCur->eState!=CURSOR_FAULT ) r++;
67557 BtCursor *pCur /* Space for new cursor */
67592 pCur->pgnoRoot = (Pgno)iTable;
67593 pCur->iPage = -1;
67594 pCur->pKeyInfo = pKeyInfo;
67595 pCur->pBtree = p;
67596 pCur->pBt = pBt;
67597 pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0;
67598 pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY;
67604 pCur->curFlags |= BTCF_Multiple;
67607 pCur->pNext = pBt->pCursor;
67608 pBt->pCursor = pCur;
67609 pCur->eState = CURSOR_INVALID;
67617 BtCursor *pCur /* Write new cursor here */
67624 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
67658 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
67659 Btree *pBtree = pCur->pBtree;
67661 BtShared *pBt = pCur->pBt;
67664 if( pBt->pCursor==pCur ){
67665 pBt->pCursor = pCur->pNext;
67669 if( pPrev->pNext==pCur ){
67670 pPrev->pNext = pCur->pNext;
67676 btreeReleaseAllCursorPages(pCur);
67678 sqlite3_free(pCur->aOverflow);
67679 sqlite3_free(pCur->pKey);
67681 pCur->pBtree = 0;
67703 static void assertCellInfo(BtCursor *pCur){
67706 btreeParseCell(pCur->pPage, pCur->ix, &info);
67707 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
67712 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
67713 if( pCur->info.nSize==0 ){
67714 pCur->curFlags |= BTCF_ValidNKey;
67715 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
67717 assertCellInfo(pCur);
67727 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
67728 return pCur && pCur->eState==CURSOR_VALID;
67731 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
67732 assert( pCur!=0 );
67733 return pCur->eState==CURSOR_VALID;
67742 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
67743 assert( cursorHoldsMutex(pCur) );
67744 assert( pCur->eState==CURSOR_VALID );
67745 assert( pCur->curIntKey );
67746 getCellInfo(pCur);
67747 return pCur->info.nKey;
67755 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
67756 assert( cursorHoldsMutex(pCur) );
67757 assert( pCur->eState==CURSOR_VALID );
67758 getCellInfo(pCur);
67759 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
67760 (i64)(pCur->info.pPayload - pCur->pPage->aData);
67773 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
67774 assert( cursorHoldsMutex(pCur) );
67775 assert( pCur->eState==CURSOR_VALID );
67776 getCellInfo(pCur);
67777 return pCur->info.nPayload;
67793 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
67794 assert( cursorHoldsMutex(pCur) );
67795 assert( pCur->eState==CURSOR_VALID );
67796 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
67937 BtCursor *pCur, /* Cursor pointing to entry to read from */
67946 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
67947 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
67954 assert( pCur->eState==CURSOR_VALID );
67955 assert( pCur->ix<pPage->nCell );
67956 assert( cursorHoldsMutex(pCur) );
67958 getCellInfo(pCur);
67959 aPayload = pCur->info.pPayload;
67960 assert( offset+amt <= pCur->info.nPayload );
67963 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
67973 if( offset<pCur->info.nLocal ){
67975 if( a+offset>pCur->info.nLocal ){
67976 a = pCur->info.nLocal - offset;
67983 offset -= pCur->info.nLocal;
67991 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
68000 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
68001 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
68002 if( pCur->aOverflow==0
68003 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
68006 pCur->aOverflow, nOvfl*2*sizeof(Pgno)
68011 pCur->aOverflow = aNew;
68014 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
68015 pCur->curFlags |= BTCF_ValidOvfl;
68021 if( pCur->aOverflow[offset/ovflSize] ){
68023 nextPage = pCur->aOverflow[iIdx];
68031 assert( pCur->aOverflow[iIdx]==0
68032 || pCur->aOverflow[iIdx]==nextPage
68034 pCur->aOverflow[iIdx] = nextPage;
68043 assert( pCur->curFlags & BTCF_ValidOvfl );
68044 assert( pCur->pBtree->db==pBt->db );
68045 if( pCur->aOverflow[iIdx+1] ){
68046 nextPage = pCur->aOverflow[iIdx+1];
68136 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
68137 assert( cursorHoldsMutex(pCur) );
68138 assert( pCur->eState==CURSOR_VALID );
68139 assert( pCur->iPage>=0 && pCur->pPage );
68140 assert( pCur->ix<pCur->pPage->nCell );
68141 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
68151 BtCursor *pCur,
68157 if ( pCur->eState==CURSOR_INVALID ){
68160 assert( cursorOwnsBtShared(pCur) );
68161 rc = btreeRestoreCursorPosition(pCur);
68162 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
68164 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
68165 if( pCur->eState==CURSOR_VALID ){
68166 assert( cursorOwnsBtShared(pCur) );
68167 return accessPayload(pCur, offset, amt, pBuf, 0);
68169 return accessPayloadChecked(pCur, offset, amt, pBuf);
68194 BtCursor *pCur, /* Cursor pointing to entry to read from */
68198 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
68199 assert( pCur->eState==CURSOR_VALID );
68200 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68201 assert( cursorOwnsBtShared(pCur) );
68202 assert( pCur->ix<pCur->pPage->nCell );
68203 assert( pCur->info.nSize>0 );
68204 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
68205 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
68206 amt = pCur->info.nLocal;
68207 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
68211 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
68214 return (void*)pCur->info.pPayload;
68232 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
68233 return fetchPayload(pCur, pAmt);
68246 static int moveToChild(BtCursor *pCur, u32 newPgno){
68247 BtShared *pBt = pCur->pBt;
68249 assert( cursorOwnsBtShared(pCur) );
68250 assert( pCur->eState==CURSOR_VALID );
68251 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
68252 assert( pCur->iPage>=0 );
68253 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
68256 pCur->info.nSize = 0;
68257 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68258 pCur->aiIdx[pCur->iPage] = pCur->ix;
68259 pCur->apPage[pCur->iPage] = pCur->pPage;
68260 pCur->ix = 0;
68261 pCur->iPage++;
68262 return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags);
68295 static void moveToParent(BtCursor *pCur){
68297 assert( cursorOwnsBtShared(pCur) );
68298 assert( pCur->eState==CURSOR_VALID );
68299 assert( pCur->iPage>0 );
68300 assert( pCur->pPage );
68302 pCur->apPage[pCur->iPage-1],
68303 pCur->aiIdx[pCur->iPage-1],
68304 pCur->pPage->pgno
68306 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
68307 pCur->info.nSize = 0;
68308 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68309 pCur->ix = pCur->aiIdx[pCur->iPage-1];
68310 pLeaf = pCur->pPage;
68311 pCur->pPage = pCur->apPage[--pCur->iPage];
68336 static int moveToRoot(BtCursor *pCur){
68340 assert( cursorOwnsBtShared(pCur) );
68344 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
68345 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
68347 if( pCur->iPage>=0 ){
68348 if( pCur->iPage ){
68349 releasePageNotNull(pCur->pPage);
68350 while( --pCur->iPage ){
68351 releasePageNotNull(pCur->apPage[pCur->iPage]);
68353 pCur->pPage = pCur->apPage[0];
68356 }else if( pCur->pgnoRoot==0 ){
68357 pCur->eState = CURSOR_INVALID;
68360 assert( pCur->iPage==(-1) );
68361 if( pCur->eState>=CURSOR_REQUIRESEEK ){
68362 if( pCur->eState==CURSOR_FAULT ){
68363 assert( pCur->skipNext!=SQLITE_OK );
68364 return pCur->skipNext;
68366 sqlite3BtreeClearCursor(pCur);
68368 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage,
68369 0, pCur->curPagerFlags);
68371 pCur->eState = CURSOR_INVALID;
68374 pCur->iPage = 0;
68375 pCur->curIntKey = pCur->pPage->intKey;
68377 pRoot = pCur->pPage;
68378 assert( pRoot->pgno==pCur->pgnoRoot );
68391 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
68392 return SQLITE_CORRUPT_PAGE(pCur->pPage);
68396 pCur->ix = 0;
68397 pCur->info.nSize = 0;
68398 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
68400 pRoot = pCur->pPage;
68402 pCur->eState = CURSOR_VALID;
68407 pCur->eState = CURSOR_VALID;
68408 rc = moveToChild(pCur, subpage);
68410 pCur->eState = CURSOR_INVALID;
68423 static int moveToLeftmost(BtCursor *pCur){
68428 assert( cursorOwnsBtShared(pCur) );
68429 assert( pCur->eState==CURSOR_VALID );
68430 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
68431 assert( pCur->ix<pPage->nCell );
68432 pgno = get4byte(findCell(pPage, pCur->ix));
68433 rc = moveToChild(pCur, pgno);
68448 static int moveToRightmost(BtCursor *pCur){
68453 assert( cursorOwnsBtShared(pCur) );
68454 assert( pCur->eState==CURSOR_VALID );
68455 while( !(pPage = pCur->pPage)->leaf ){
68457 pCur->ix = pPage->nCell;
68458 rc = moveToChild(pCur, pgno);
68461 pCur->ix = pPage->nCell-1;
68462 assert( pCur->info.nSize==0 );
68463 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
68471 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
68474 assert( cursorOwnsBtShared(pCur) );
68475 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68476 rc = moveToRoot(pCur);
68478 assert( pCur->pPage->nCell>0 );
68480 rc = moveToLeftmost(pCur);
68482 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68493 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
68496 assert( cursorOwnsBtShared(pCur) );
68497 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68500 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
68505 for(ii=0; ii<pCur->iPage; ii++){
68506 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
68508 assert( pCur->ix==pCur->pPage->nCell-1 );
68509 assert( pCur->pPage->leaf );
68514 rc = moveToRoot(pCur);
68516 assert( pCur->eState==CURSOR_VALID );
68518 rc = moveToRightmost(pCur);
68520 pCur->curFlags |= BTCF_AtLast;
68522 pCur->curFlags &= ~BTCF_AtLast;
68525 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68563 BtCursor *pCur, /* The cursor to be moved */
68572 assert( cursorOwnsBtShared(pCur) );
68573 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68575 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
68576 assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
68581 && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
68583 if( pCur->info.nKey==intKey ){
68587 if( pCur->info.nKey<intKey ){
68588 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
68596 if( pCur->info.nKey+1==intKey ){
68598 rc = sqlite3BtreeNext(pCur, 0);
68600 getCellInfo(pCur);
68601 if( pCur->info.nKey==intKey ){
68624 rc = moveToRoot(pCur);
68627 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68633 assert( pCur->pPage );
68634 assert( pCur->pPage->isInit );
68635 assert( pCur->eState==CURSOR_VALID );
68636 assert( pCur->pPage->nCell > 0 );
68637 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
68638 assert( pCur->curIntKey || pIdxKey );
68642 MemPage *pPage = pCur->pPage;
68657 pCur->ix = (u16)idx;
68678 pCur->ix = (u16)idx;
68683 pCur->curFlags |= BTCF_ValidNKey;
68684 pCur->info.nKey = nCellKey;
68685 pCur->info.nSize = 0;
68732 pPage->xParseCell(pPage, pCellBody, &pCur->info);
68733 nCell = (int)pCur->info.nKey;
68738 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
68747 pCur->ix = (u16)idx;
68748 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
68749 pCur->curFlags &= ~BTCF_ValidOvfl;
68759 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
68769 pCur->ix = (u16)idx;
68781 assert( pCur->ix<pCur->pPage->nCell );
68782 pCur->ix = (u16)idx;
68793 pCur->ix = (u16)lwr;
68794 rc = moveToChild(pCur, chldPg);
68798 pCur->info.nSize = 0;
68799 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68811 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
68816 return (CURSOR_VALID!=pCur->eState);
68824 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
68828 assert( cursorOwnsBtShared(pCur) );
68829 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68834 if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
68835 if( NEVER(pCur->pPage->leaf==0) ) return -1;
68837 n = pCur->pPage->nCell;
68838 for(i=0; i<pCur->iPage; i++){
68839 n *= pCur->apPage[i]->nCell;
68864 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
68869 assert( cursorOwnsBtShared(pCur) );
68870 if( pCur->eState!=CURSOR_VALID ){
68871 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68872 rc = restoreCursorPosition(pCur);
68876 if( CURSOR_INVALID==pCur->eState ){
68879 if( pCur->eState==CURSOR_SKIPNEXT ){
68880 pCur->eState = CURSOR_VALID;
68881 if( pCur->skipNext>0 ) return SQLITE_OK;
68885 pPage = pCur->pPage;
68886 idx = ++pCur->ix;
68907 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
68909 return moveToLeftmost(pCur);
68912 if( pCur->iPage==0 ){
68913 pCur->eState = CURSOR_INVALID;
68916 moveToParent(pCur);
68917 pPage = pCur->pPage;
68918 }while( pCur->ix>=pPage->nCell );
68920 return sqlite3BtreeNext(pCur, 0);
68928 return moveToLeftmost(pCur);
68931 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
68934 assert( cursorOwnsBtShared(pCur) );
68936 pCur->info.nSize = 0;
68937 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
68938 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
68939 pPage = pCur->pPage;
68940 if( (++pCur->ix)>=pPage->nCell ){
68941 pCur->ix--;
68942 return btreeNext(pCur);
68947 return moveToLeftmost(pCur);
68971 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
68975 assert( cursorOwnsBtShared(pCur) );
68976 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
68977 assert( pCur->info.nSize==0 );
68978 if( pCur->eState!=CURSOR_VALID ){
68979 rc = restoreCursorPosition(pCur);
68983 if( CURSOR_INVALID==pCur->eState ){
68986 if( CURSOR_SKIPNEXT==pCur->eState ){
68987 pCur->eState = CURSOR_VALID;
68988 if( pCur->skipNext<0 ) return SQLITE_OK;
68992 pPage = pCur->pPage;
68995 int idx = pCur->ix;
68996 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
68998 rc = moveToRightmost(pCur);
69000 while( pCur->ix==0 ){
69001 if( pCur->iPage==0 ){
69002 pCur->eState = CURSOR_INVALID;
69005 moveToParent(pCur);
69007 assert( pCur->info.nSize==0 );
69008 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
69010 pCur->ix--;
69011 pPage = pCur->pPage;
69013 rc = sqlite3BtreePrevious(pCur, 0);
69020 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
69021 assert( cursorOwnsBtShared(pCur) );
69024 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
69025 pCur->info.nSize = 0;
69026 if( pCur->eState!=CURSOR_VALID
69027 || pCur->ix==0
69028 || pCur->pPage->leaf==0
69030 return btreePrevious(pCur);
69032 pCur->ix--;
71496 static int balance(BtCursor *pCur){
71498 const int nMin = pCur->pBt->usableSize * 2 / 3;
71506 int iPage = pCur->iPage;
71507 MemPage *pPage = pCur->pPage;
71519 rc = balance_deeper(pPage, &pCur->apPage[1]);
71521 pCur->iPage = 1;
71522 pCur->ix = 0;
71523 pCur->aiIdx[0] = 0;
71524 pCur->apPage[0] = pPage;
71525 pCur->pPage = pCur->apPage[1];
71526 assert( pCur->pPage->nOverflow );
71534 MemPage * const pParent = pCur->apPage[iPage-1];
71535 int const iIdx = pCur->aiIdx[iPage-1];
71585 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
71587 pCur->hints&BTREE_BULKLOAD);
71607 pCur->iPage--;
71608 assert( pCur->iPage>=0 );
71609 pCur->pPage = pCur->apPage[pCur->iPage];
71665 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
71669 MemPage *pPage = pCur->pPage; /* Page being written */
71674 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd ){
71678 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
71679 0, pCur->info.nLocal);
71681 if( pCur->info.nLocal==nTotal ) return SQLITE_OK;
71684 iOffset = pCur->info.nLocal;
71687 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
71743 BtCursor *pCur, /* Insert data into the table of this cursor */
71753 Btree *p = pCur->pBtree;
71760 if( pCur->eState==CURSOR_FAULT ){
71761 assert( pCur->skipNext!=SQLITE_OK );
71762 return pCur->skipNext;
71765 assert( cursorOwnsBtShared(pCur) );
71766 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
71769 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
71776 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
71789 if( pCur->curFlags & BTCF_Multiple ){
71790 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
71794 if( pCur->pKeyInfo==0 ){
71798 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
71805 assert( pCur->curFlags & BTCF_ValidNKey );
71806 assert( pX->nKey==pCur->info.nKey );
71807 assert( pCur->info.nSize!=0 );
71816 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
71820 if( pCur->info.nSize!=0
71821 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
71824 return btreeOverwriteCell(pCur, pX);
71832 rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
71851 r.pKeyInfo = pCur->pKeyInfo;
71859 rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
71861 rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
71871 getCellInfo(pCur);
71872 if( pCur->info.nKey==pX->nKey ){
71877 return btreeOverwriteCell(pCur, &x2);
71882 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
71884 pPage = pCur->pPage;
71893 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
71902 idx = pCur->ix;
71936 idx = ++pCur->ix;
71937 pCur->curFlags &= ~BTCF_ValidNKey;
71965 pCur->info.nSize = 0;
71968 pCur->curFlags &= ~(BTCF_ValidNKey);
71969 rc = balance(pCur);
71975 pCur->pPage->nOverflow = 0;
71976 pCur->eState = CURSOR_INVALID;
71978 btreeReleaseAllCursorPages(pCur);
71979 if( pCur->pKeyInfo ){
71980 assert( pCur->pKey==0 );
71981 pCur->pKey = sqlite3Malloc( pX->nKey );
71982 if( pCur->pKey==0 ){
71985 memcpy(pCur->pKey, pX->pKey, pX->nKey);
71988 pCur->eState = CURSOR_REQUIRESEEK;
71989 pCur->nKey = pX->nKey;
71992 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
72015 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
72016 Btree *p = pCur->pBtree;
72027 assert( cursorOwnsBtShared(pCur) );
72030 assert( pCur->curFlags & BTCF_WriteFlag );
72031 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
72032 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
72034 if( pCur->eState==CURSOR_REQUIRESEEK ){
72035 rc = btreeRestoreCursorPosition(pCur);
72038 assert( pCur->eState==CURSOR_VALID );
72040 iCellDepth = pCur->iPage;
72041 iCellIdx = pCur->ix;
72042 pPage = pCur->pPage;
72062 rc = saveCursorKey(pCur);
72077 rc = sqlite3BtreePrevious(pCur, 0);
72084 if( pCur->curFlags & BTCF_Multiple ){
72085 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
72091 if( pCur->pKeyInfo==0 ){
72092 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
72110 MemPage *pLeaf = pCur->pPage;
72119 if( iCellDepth<pCur->iPage-1 ){
72120 n = pCur->apPage[iCellDepth+1]->pgno;
72122 n = pCur->pPage->pgno;
72153 rc = balance(pCur);
72154 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
72155 releasePageNotNull(pCur->pPage);
72156 pCur->iPage--;
72157 while( pCur->iPage>iCellDepth ){
72158 releasePage(pCur->apPage[pCur->iPage--]);
72160 pCur->pPage = pCur->apPage[pCur->iPage];
72161 rc = balance(pCur);
72166 assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
72167 assert( pPage==pCur->pPage || CORRUPT_DB );
72169 pCur->eState = CURSOR_SKIPNEXT;
72171 pCur->skipNext = -1;
72172 pCur->ix = pPage->nCell-1;
72174 pCur->skipNext = 1;
72177 rc = moveToRoot(pCur);
72179 btreeReleaseAllCursorPages(pCur);
72180 pCur->eState = CURSOR_REQUIRESEEK;
72445 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
72446 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
72646 SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
72650 rc = moveToRoot(pCur);
72667 pPage = pCur->pPage;
72684 if( pCur->iPage==0 ){
72687 return moveToRoot(pCur);
72689 moveToParent(pCur);
72690 }while ( pCur->ix>=pCur->pPage->nCell );
72692 pCur->ix++;
72693 pPage = pCur->pPage;
72699 iIdx = pCur->ix;
72701 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
72703 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
73561 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
73562 pCur->curFlags |= BTCF_Incrblob;
73563 pCur->pBtree->hasIncrblobCur = 1;
75566 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
75573 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
75577 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
75589 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
75598 assert( sqlite3BtreeCursorIsValid(pCur) );
75604 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
75612 rc = vdbeMemFromBtreeResize(pCur, offset, amt, pMem);
80984 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
80997 assert( sqlite3BtreeCursorIsValid(pCur) );
80998 nCellKey = sqlite3BtreePayloadSize(pCur);
81003 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
81071 BtCursor *pCur;
81075 pCur = pC->uc.pCursor;
81076 assert( sqlite3BtreeCursorIsValid(pCur) );
81077 nCellKey = sqlite3BtreePayloadSize(pCur);
81085 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
87108 VdbeCursor *pCur;
87113 pCur = p->apCsr[pOp->p1];
87114 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
87115 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
87178 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
87179 if( pCur==0 ) goto no_mem;
87180 pCur->nullRow = 1;
87181 pCur->isOrdered = 1;
87182 pCur->pgnoRoot = p2;
87184 pCur->wrFlag = wrFlag;
87186 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
87187 pCur->pKeyInfo = pKeyInfo;
87192 pCur->isTable = pOp->p4type!=P4_KEYINFO;
87201 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
90495 VdbeCursor *pCur;
90501 pCur = 0;
90517 pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
90518 if( pCur ){
90519 pCur->uc.pVCur = pVCur;
90558 VdbeCursor *pCur;
90565 pCur = p->apCsr[pOp->p1];
90568 assert( pCur->eCurType==CURTYPE_VTAB );
90569 pVCur = pCur->uc.pVCur;
90588 pCur->nullRow = 0;
90616 VdbeCursor *pCur = p->apCsr[pOp->p1];
90617 assert( pCur->eCurType==CURTYPE_VTAB );
90621 if( pCur->nullRow ){
90625 pVtab = pCur->uc.pVCur->pVtab;
90638 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
90667 VdbeCursor *pCur;
90670 pCur = p->apCsr[pOp->p1];
90671 assert( pCur->eCurType==CURTYPE_VTAB );
90672 if( pCur->nullRow ){
90675 pVtab = pCur->uc.pVCur->pVtab;
90685 rc = pModule->xNext(pCur->uc.pVCur);
90688 res = pModule->xEof(pCur->uc.pVCur);
180894 JsonEachCursor *pCur;
180897 pCur = sqlite3_malloc( sizeof(*pCur) );
180898 if( pCur==0 ) return SQLITE_NOMEM;
180899 memset(pCur, 0, sizeof(*pCur));
180900 *ppCursor = &pCur->base;
180908 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
180909 pCur->bRecursive = 1;
182786 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
182787 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
182793 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
182795 int ii = 1 - pCur->bPoint;
182797 assert( pCur->bPoint || pCur->nPoint );
182798 if( pCur->aNode[ii]==0 ){
182800 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
182801 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
182803 return pCur->aNode[ii];
182810 RtreeCursor *pCur, /* The cursor */
182816 if( pCur->nPoint>=pCur->nPointAlloc ){
182817 int nNew = pCur->nPointAlloc*2 + 8;
182818 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
182820 pCur->aPoint = pNew;
182821 pCur->nPointAlloc = nNew;
182823 i = pCur->nPoint++;
182824 pNew = pCur->aPoint + i;
182831 pParent = pCur->aPoint + j;
182833 rtreeSearchPointSwap(pCur, j, i);
182845 RtreeCursor *pCur, /* The cursor */
182850 pFirst = rtreeSearchPointFirst(pCur);
182851 pCur->anQueue[iLevel]++;
182856 if( pCur->bPoint ){
182858 pNew = rtreeEnqueue(pCur, rScore, iLevel);
182860 ii = (int)(pNew - pCur->aPoint) + 1;
182862 assert( pCur->aNode[ii]==0 );
182863 pCur->aNode[ii] = pCur->aNode[0];
182865 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
182867 pCur->aNode[0] = 0;
182868 *pNew = pCur->sPoint;
182870 pCur->sPoint.rScore = rScore;
182871 pCur->sPoint.iLevel = iLevel;
182872 pCur->bPoint = 1;
182873 return &pCur->sPoint;
182875 return rtreeEnqueue(pCur, rScore, iLevel);
182881 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
182888 printf(" %p\n", pCur->aNode[idx]);
182893 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
182896 if( pCur->bPoint ){
182897 tracePoint(&pCur->sPoint, -1, pCur);
182899 for(ii=0; ii<pCur->nPoint; ii++){
182900 if( ii>0 || pCur->bPoint ) printf(" ");
182901 tracePoint(&pCur->aPoint[ii], ii, pCur);
182959 static int rtreeStepToLeaf(RtreeCursor *pCur){
182961 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
182966 int nConstraint = pCur->nConstraint;
182972 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
182973 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
182982 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
183005 RTREE_QUEUE_TRACE(pCur, "POP-S:");
183006 rtreeSearchPointPop(pCur);
183009 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
183014 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
183018 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
183019 rtreeSearchPointPop(pCur);
183022 pCur->atEOF = p==0;
222943 stmt_cursor *pCur;
222944 pCur = sqlite3_malloc( sizeof(*pCur) );
222945 if( pCur==0 ) return SQLITE_NOMEM;
222946 memset(pCur, 0, sizeof(*pCur));
222947 pCur->db = ((stmt_vtab*)p)->db;
222948 *ppCursor = &pCur->base;
222965 stmt_cursor *pCur = (stmt_cursor*)cur;
222966 pCur->iRowid++;
222967 pCur->pStmt = sqlite3_next_stmt(pCur->db, pCur->pStmt);
222980 stmt_cursor *pCur = (stmt_cursor*)cur;
222983 sqlite3_result_text(ctx, sqlite3_sql(pCur->pStmt), -1, SQLITE_TRANSIENT);
222987 sqlite3_result_int(ctx, sqlite3_column_count(pCur->pStmt));
222991 sqlite3_result_int(ctx, sqlite3_stmt_readonly(pCur->pStmt));
222995 sqlite3_result_int(ctx, sqlite3_stmt_busy(pCur->pStmt));
223009 sqlite3_result_int(ctx, sqlite3_stmt_status(pCur->pStmt,
223022 stmt_cursor *pCur = (stmt_cursor*)cur;
223023 *pRowid = pCur->iRowid;
223032 stmt_cursor *pCur = (stmt_cursor*)cur;
223033 return pCur->pStmt==0;
223047 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
223048 pCur->pStmt = 0;
223049 pCur->iRowid = 0;