Lines Matching refs:pCur
9205 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
71540 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
71541 sqlite3BtreeEnter(pCur->pBtree);
71544 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
71545 sqlite3BtreeLeave(pCur->pBtree);
72116 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl) argument
72243 static void btreeReleaseAllCursorPages(BtCursor *pCur){
72245 if( pCur->iPage>=0 ){
72246 for(i=0; i<pCur->iPage; i++){
72247 releasePageNotNull(pCur->apPage[i]);
72249 releasePageNotNull(pCur->pPage);
72250 pCur->iPage = -1;
72267 static int saveCursorKey(BtCursor *pCur){
72269 assert( CURSOR_VALID==pCur->eState );
72270 assert( 0==pCur->pKey );
72271 assert( cursorHoldsMutex(pCur) );
72273 if( pCur->curIntKey ){
72275 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
72284 pCur->nKey = sqlite3BtreePayloadSize(pCur);
72285 pKey = sqlite3Malloc( ((i64)pCur->nKey) + 9 + 8 );
72287 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
72289 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
72290 pCur->pKey = pKey;
72298 assert( !pCur->curIntKey || !pCur->pKey );
72309 static int saveCursorPosition(BtCursor *pCur){
72312 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
72313 assert( 0==pCur->pKey );
72314 assert( cursorHoldsMutex(pCur) );
72316 if( pCur->curFlags & BTCF_Pinned ){
72319 if( pCur->eState==CURSOR_SKIPNEXT ){
72320 pCur->eState = CURSOR_VALID;
72322 pCur->skipNext = 0;
72325 rc = saveCursorKey(pCur);
72327 btreeReleaseAllCursorPages(pCur);
72328 pCur->eState = CURSOR_REQUIRESEEK;
72331 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
72401 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
72402 assert( cursorHoldsMutex(pCur) );
72403 sqlite3_free(pCur->pKey);
72404 pCur->pKey = 0;
72405 pCur->eState = CURSOR_INVALID;
72414 BtCursor *pCur, /* Cursor open on the btree to be searched */
72424 KeyInfo *pKeyInfo = pCur->pKeyInfo;
72432 rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes);
72434 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
72437 rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes);
72449 static int btreeRestoreCursorPosition(BtCursor *pCur){
72452 assert( cursorOwnsBtShared(pCur) );
72453 assert( pCur->eState>=CURSOR_REQUIRESEEK );
72454 if( pCur->eState==CURSOR_FAULT ){
72455 return pCur->skipNext;
72457 pCur->eState = CURSOR_INVALID;
72461 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
72464 sqlite3_free(pCur->pKey);
72465 pCur->pKey = 0;
72466 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
72467 if( skipNext ) pCur->skipNext = skipNext;
72468 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
72469 pCur->eState = CURSOR_SKIPNEXT;
72492 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
72493 assert( EIGHT_BYTE_ALIGNMENT(pCur)
72494 || pCur==sqlite3BtreeFakeValidCursor() );
72496 assert( sizeof(pCur->eState)==1 );
72497 return CURSOR_VALID != *(u8*)pCur;
72524 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
72527 assert( pCur!=0 );
72528 assert( pCur->eState!=CURSOR_VALID );
72529 rc = restoreCursorPosition(pCur);
72534 if( pCur->eState!=CURSOR_VALID ){
72548 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
72573 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
72575 pCur->hints = (u8)x;
74429 BtCursor *pCur = pBt->pCursor; local
74430 pBt->pCursor = pCur->pNext; /* Unlink the cursor */
74431 memset(pCur, 0, sizeof(*pCur));
74479 BtCursor *pCur = pBt->pCursor; local
74480 while( pCur ){
74481 BtCursor *pTmp = pCur;
74482 pCur = pCur->pNext;
75019 BtCursor *pCur; local
75021 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
75022 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
75023 && pCur->eState!=CURSOR_FAULT ) r++;
76214 BtCursor *pCur /* Space for new cursor */
76250 pCur->pgnoRoot = iTable;
76251 pCur->iPage = -1;
76252 pCur->pKeyInfo = pKeyInfo;
76253 pCur->pBtree = p;
76254 pCur->pBt = pBt;
76255 pCur->curFlags = 0;
76261 pCur->curFlags = BTCF_Multiple;
76264 pCur->eState = CURSOR_INVALID;
76265 pCur->pNext = pBt->pCursor;
76266 pBt->pCursor = pCur;
76268 pCur->curFlags |= BTCF_WriteFlag;
76269 pCur->curPagerFlags = 0;
76272 pCur->curPagerFlags = PAGER_GET_READONLY;
76281 BtCursor *pCur /* Space for new cursor */
76285 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
76294 BtCursor *pCur /* Write new cursor here */
76297 return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur);
76299 return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
76323 BtCursor *pCur /* Corresponding cursor */
76327 if( pBt->pCursor!=pCur ) return 0;
76328 if( pCur->pNext!=0 ) return 0;
76329 if( pCur->pBtree!=pBtree ) return 0;
76350 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
76351 Btree *pBtree = pCur->pBtree;
76353 BtShared *pBt = pCur->pBt;
76356 if( pBt->pCursor==pCur ){
76357 pBt->pCursor = pCur->pNext;
76361 if( pPrev->pNext==pCur ){
76362 pPrev->pNext = pCur->pNext;
76368 btreeReleaseAllCursorPages(pCur);
76370 sqlite3_free(pCur->aOverflow);
76371 sqlite3_free(pCur->pKey);
76380 pCur->pBtree = 0;
76402 static void assertCellInfo(BtCursor *pCur){
76405 btreeParseCell(pCur->pPage, pCur->ix, &info);
76406 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
76411 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
76412 if( pCur->info.nSize==0 ){
76413 pCur->curFlags |= BTCF_ValidNKey;
76414 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
76416 assertCellInfo(pCur);
76426 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
76427 return pCur && pCur->eState==CURSOR_VALID;
76430 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
76431 assert( pCur!=0 );
76432 return pCur->eState==CURSOR_VALID;
76441 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
76442 assert( cursorHoldsMutex(pCur) );
76443 assert( pCur->eState==CURSOR_VALID );
76444 assert( pCur->curIntKey );
76445 getCellInfo(pCur);
76446 return pCur->info.nKey;
76452 SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor *pCur){
76453 assert( (pCur->curFlags & BTCF_Pinned)==0 );
76454 pCur->curFlags |= BTCF_Pinned;
76456 SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor *pCur){
76457 assert( (pCur->curFlags & BTCF_Pinned)!=0 );
76458 pCur->curFlags &= ~BTCF_Pinned;
76465 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
76466 assert( cursorHoldsMutex(pCur) );
76467 assert( pCur->eState==CURSOR_VALID );
76468 getCellInfo(pCur);
76469 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
76470 (i64)(pCur->info.pPayload - pCur->pPage->aData);
76482 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
76483 assert( cursorHoldsMutex(pCur) );
76484 assert( pCur->eState==CURSOR_VALID );
76485 getCellInfo(pCur);
76486 return pCur->info.nPayload;
76502 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
76503 assert( cursorHoldsMutex(pCur) );
76504 assert( pCur->eState==CURSOR_VALID );
76505 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
76646 BtCursor *pCur, /* Cursor pointing to entry to read from */
76655 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
76656 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
76663 assert( pCur->eState==CURSOR_VALID );
76664 if( pCur->ix>=pPage->nCell ){
76667 assert( cursorHoldsMutex(pCur) );
76669 getCellInfo(pCur);
76670 aPayload = pCur->info.pPayload;
76671 assert( offset+amt <= pCur->info.nPayload );
76674 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
76684 if( offset<pCur->info.nLocal ){
76686 if( a+offset>pCur->info.nLocal ){
76687 a = pCur->info.nLocal - offset;
76694 offset -= pCur->info.nLocal;
76702 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
76711 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
76712 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
76713 if( pCur->aOverflow==0
76714 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
76720 aNew = (Pgno*)sqlite3Realloc(pCur->aOverflow, nOvfl*2*sizeof(Pgno));
76725 pCur->aOverflow = aNew;
76728 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
76729 pCur->curFlags |= BTCF_ValidOvfl;
76732 assert( pCur->aOverflow[0]==nextPage
76733 || pCur->aOverflow[0]==0
76735 assert( pCur->aOverflow[0]!=0 || pCur->aOverflow[offset/ovflSize]==0 );
76741 if( pCur->aOverflow[offset/ovflSize] ){
76743 nextPage = pCur->aOverflow[iIdx];
76752 assert( pCur->aOverflow[iIdx]==0
76753 || pCur->aOverflow[iIdx]==nextPage
76755 pCur->aOverflow[iIdx] = nextPage;
76764 assert( pCur->curFlags & BTCF_ValidOvfl );
76765 assert( pCur->pBtree->db==pBt->db );
76766 if( pCur->aOverflow[iIdx+1] ){
76767 nextPage = pCur->aOverflow[iIdx+1];
76857 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
76858 assert( cursorHoldsMutex(pCur) );
76859 assert( pCur->eState==CURSOR_VALID );
76860 assert( pCur->iPage>=0 && pCur->pPage );
76861 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
76871 BtCursor *pCur,
76877 if ( pCur->eState==CURSOR_INVALID ){
76880 assert( cursorOwnsBtShared(pCur) );
76881 rc = btreeRestoreCursorPosition(pCur);
76882 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
76884 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
76885 if( pCur->eState==CURSOR_VALID ){
76886 assert( cursorOwnsBtShared(pCur) );
76887 return accessPayload(pCur, offset, amt, pBuf, 0);
76889 return accessPayloadChecked(pCur, offset, amt, pBuf);
76914 BtCursor *pCur, /* Cursor pointing to entry to read from */
76918 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
76919 assert( pCur->eState==CURSOR_VALID );
76920 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76921 assert( cursorOwnsBtShared(pCur) );
76922 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
76923 assert( pCur->info.nSize>0 );
76924 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
76925 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
76926 amt = pCur->info.nLocal;
76927 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
76931 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
76934 return (void*)pCur->info.pPayload;
76952 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
76953 return fetchPayload(pCur, pAmt);
76966 static int moveToChild(BtCursor *pCur, u32 newPgno){
76968 assert( cursorOwnsBtShared(pCur) );
76969 assert( pCur->eState==CURSOR_VALID );
76970 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
76971 assert( pCur->iPage>=0 );
76972 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
76975 pCur->info.nSize = 0;
76976 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
76977 pCur->aiIdx[pCur->iPage] = pCur->ix;
76978 pCur->apPage[pCur->iPage] = pCur->pPage;
76979 pCur->ix = 0;
76980 pCur->iPage++;
76981 rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
76982 assert( pCur->pPage!=0 || rc!=SQLITE_OK );
76984 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
76986 releasePage(pCur->pPage);
76990 pCur->pPage = pCur->apPage[--pCur->iPage];
77025 static void moveToParent(BtCursor *pCur){
77027 assert( cursorOwnsBtShared(pCur) );
77028 assert( pCur->eState==CURSOR_VALID );
77029 assert( pCur->iPage>0 );
77030 assert( pCur->pPage );
77032 pCur->apPage[pCur->iPage-1],
77033 pCur->aiIdx[pCur->iPage-1],
77034 pCur->pPage->pgno
77036 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
77037 pCur->info.nSize = 0;
77038 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
77039 pCur->ix = pCur->aiIdx[pCur->iPage-1];
77040 pLeaf = pCur->pPage;
77041 pCur->pPage = pCur->apPage[--pCur->iPage];
77066 static int moveToRoot(BtCursor *pCur){
77070 assert( cursorOwnsBtShared(pCur) );
77074 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
77075 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
77077 if( pCur->iPage>=0 ){
77078 if( pCur->iPage ){
77079 releasePageNotNull(pCur->pPage);
77080 while( --pCur->iPage ){
77081 releasePageNotNull(pCur->apPage[pCur->iPage]);
77083 pRoot = pCur->pPage = pCur->apPage[0];
77086 }else if( pCur->pgnoRoot==0 ){
77087 pCur->eState = CURSOR_INVALID;
77090 assert( pCur->iPage==(-1) );
77091 if( pCur->eState>=CURSOR_REQUIRESEEK ){
77092 if( pCur->eState==CURSOR_FAULT ){
77093 assert( pCur->skipNext!=SQLITE_OK );
77094 return pCur->skipNext;
77096 sqlite3BtreeClearCursor(pCur);
77098 rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
77099 pCur->curPagerFlags);
77101 pCur->eState = CURSOR_INVALID;
77104 pCur->iPage = 0;
77105 pCur->curIntKey = pCur->pPage->intKey;
77107 pRoot = pCur->pPage;
77108 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
77121 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
77122 return SQLITE_CORRUPT_PAGE(pCur->pPage);
77126 pCur->ix = 0;
77127 pCur->info.nSize = 0;
77128 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
77131 pCur->eState = CURSOR_VALID;
77136 pCur->eState = CURSOR_VALID;
77137 rc = moveToChild(pCur, subpage);
77139 pCur->eState = CURSOR_INVALID;
77152 static int moveToLeftmost(BtCursor *pCur){
77157 assert( cursorOwnsBtShared(pCur) );
77158 assert( pCur->eState==CURSOR_VALID );
77159 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
77160 assert( pCur->ix<pPage->nCell );
77161 pgno = get4byte(findCell(pPage, pCur->ix));
77162 rc = moveToChild(pCur, pgno);
77177 static int moveToRightmost(BtCursor *pCur){
77182 assert( cursorOwnsBtShared(pCur) );
77183 assert( pCur->eState==CURSOR_VALID );
77184 while( !(pPage = pCur->pPage)->leaf ){
77186 pCur->ix = pPage->nCell;
77187 rc = moveToChild(pCur, pgno);
77190 pCur->ix = pPage->nCell-1;
77191 assert( pCur->info.nSize==0 );
77192 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
77200 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
77203 assert( cursorOwnsBtShared(pCur) );
77204 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
77205 rc = moveToRoot(pCur);
77207 assert( pCur->pPage->nCell>0 );
77209 rc = moveToLeftmost(pCur);
77211 assert( pCur->pgnoRoot==0 || (pCur->pPage!=0 && pCur->pPage->nCell==0) );
77226 static int cursorIsAtLastEntry(BtCursor *pCur){
77228 for(ii=0; ii<pCur->iPage; ii++){
77229 if( pCur->aiIdx[ii]!=pCur->apPage[ii]->nCell ) return 0;
77231 return pCur->ix==pCur->pPage->nCell-1 && pCur->pPage->leaf!=0;
77239 static SQLITE_NOINLINE int btreeLast(BtCursor *pCur, int *pRes){
77240 int rc = moveToRoot(pCur);
77242 assert( pCur->eState==CURSOR_VALID );
77244 rc = moveToRightmost(pCur);
77246 pCur->curFlags |= BTCF_AtLast;
77248 pCur->curFlags &= ~BTCF_AtLast;
77251 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
77257 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
77258 assert( cursorOwnsBtShared(pCur) );
77259 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
77262 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
77263 assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
77267 return btreeLast(pCur, pRes);
77294 BtCursor *pCur, /* The cursor to be moved */
77301 assert( cursorOwnsBtShared(pCur) );
77302 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
77304 assert( pCur->pKeyInfo==0 );
77305 assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
77309 if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
77310 if( pCur->info.nKey==intKey ){
77314 if( pCur->info.nKey<intKey ){
77315 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
77316 assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
77324 if( pCur->info.nKey+1==intKey ){
77326 rc = sqlite3BtreeNext(pCur, 0);
77328 getCellInfo(pCur);
77329 if( pCur->info.nKey==intKey ){
77340 pCur->pBtree->nSeek++; /* Performance measurement during testing */
77343 rc = moveToRoot(pCur);
77346 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
77352 assert( pCur->pPage );
77353 assert( pCur->pPage->isInit );
77354 assert( pCur->eState==CURSOR_VALID );
77355 assert( pCur->pPage->nCell > 0 );
77356 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
77357 assert( pCur->curIntKey );
77362 MemPage *pPage = pCur->pPage;
77396 pCur->ix = (u16)idx;
77401 pCur->curFlags |= BTCF_ValidNKey;
77402 pCur->info.nKey = nCellKey;
77403 pCur->info.nSize = 0;
77414 assert( pCur->ix<pCur->pPage->nCell );
77415 pCur->ix = (u16)idx;
77426 pCur->ix = (u16)lwr;
77427 rc = moveToChild(pCur, chldPg);
77431 pCur->info.nSize = 0;
77432 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
77453 BtCursor *pCur,
77458 MemPage *pPage = pCur->pPage;
77489 static int cursorOnLastPage(BtCursor *pCur){
77491 assert( pCur->eState==CURSOR_VALID );
77492 for(i=0; i<pCur->iPage; i++){
77493 MemPage *pPage = pCur->apPage[i];
77494 if( pCur->aiIdx[i]<pPage->nCell ) return 0;
77526 BtCursor *pCur, /* The cursor to be moved */
77533 assert( cursorOwnsBtShared(pCur) );
77534 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
77536 assert( pCur->pKeyInfo!=0 );
77539 pCur->pBtree->nSeek++; /* Performance measurement during testing */
77561 if( pCur->eState==CURSOR_VALID
77562 && pCur->pPage->leaf
77563 && cursorOnLastPage(pCur)
77566 if( pCur->ix==pCur->pPage->nCell-1
77567 && (c = indexCellCompare(pCur, pCur->ix, pIdxKey, xRecordCompare))<=0
77573 if( pCur->iPage>0
77574 && indexCellCompare(pCur, 0, pIdxKey, xRecordCompare)<=0
77577 pCur->curFlags &= ~(BTCF_ValidOvfl|BTCF_AtLast);
77578 if( !pCur->pPage->isInit ){
77586 rc = moveToRoot(pCur);
77589 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
77597 assert( pCur->pPage );
77598 assert( pCur->pPage->isInit );
77599 assert( pCur->eState==CURSOR_VALID );
77600 assert( pCur->pPage->nCell > 0 );
77601 assert( pCur->curIntKey==0 );
77606 MemPage *pPage = pCur->pPage;
77659 pPage->xParseCell(pPage, pCellBody, &pCur->info);
77660 nCell = (int)pCur->info.nKey;
77665 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
77674 pCur->ix = (u16)idx;
77675 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
77677 pCur->curFlags &= ~BTCF_ValidOvfl;
77687 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
77697 pCur->ix = (u16)idx;
77708 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
77709 pCur->ix = (u16)idx;
77726 pCur->info.nSize = 0;
77727 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
77728 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
77731 pCur->aiIdx[pCur->iPage] = (u16)lwr;
77732 pCur->apPage[pCur->iPage] = pCur->pPage;
77733 pCur->ix = 0;
77734 pCur->iPage++;
77735 rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
77737 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
77739 releasePage(pCur->pPage);
77743 pCur->pPage = pCur->apPage[--pCur->iPage];
77750 pCur->info.nSize = 0;
77751 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
77763 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
77768 return (CURSOR_VALID!=pCur->eState);
77776 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
77780 assert( cursorOwnsBtShared(pCur) );
77781 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
77786 if( pCur->eState!=CURSOR_VALID ) return 0;
77787 if( NEVER(pCur->pPage->leaf==0) ) return -1;
77789 n = pCur->pPage->nCell;
77790 for(i=0; i<pCur->iPage; i++){
77791 n *= pCur->apPage[i]->nCell;
77816 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
77821 assert( cursorOwnsBtShared(pCur) );
77822 if( pCur->eState!=CURSOR_VALID ){
77823 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
77824 rc = restoreCursorPosition(pCur);
77828 if( CURSOR_INVALID==pCur->eState ){
77831 if( pCur->eState==CURSOR_SKIPNEXT ){
77832 pCur->eState = CURSOR_VALID;
77833 if( pCur->skipNext>0 ) return SQLITE_OK;
77837 pPage = pCur->pPage;
77838 idx = ++pCur->ix;
77846 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
77848 return moveToLeftmost(pCur);
77851 if( pCur->iPage==0 ){
77852 pCur->eState = CURSOR_INVALID;
77855 moveToParent(pCur);
77856 pPage = pCur->pPage;
77857 }while( pCur->ix>=pPage->nCell );
77859 return sqlite3BtreeNext(pCur, 0);
77867 return moveToLeftmost(pCur);
77870 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
77873 assert( cursorOwnsBtShared(pCur) );
77875 pCur->info.nSize = 0;
77876 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
77877 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
77878 pPage = pCur->pPage;
77879 if( (++pCur->ix)>=pPage->nCell ){
77880 pCur->ix--;
77881 return btreeNext(pCur);
77886 return moveToLeftmost(pCur);
77910 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
77914 assert( cursorOwnsBtShared(pCur) );
77915 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
77916 assert( pCur->info.nSize==0 );
77917 if( pCur->eState!=CURSOR_VALID ){
77918 rc = restoreCursorPosition(pCur);
77922 if( CURSOR_INVALID==pCur->eState ){
77925 if( CURSOR_SKIPNEXT==pCur->eState ){
77926 pCur->eState = CURSOR_VALID;
77927 if( pCur->skipNext<0 ) return SQLITE_OK;
77931 pPage = pCur->pPage;
77937 int idx = pCur->ix;
77938 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
77940 rc = moveToRightmost(pCur);
77942 while( pCur->ix==0 ){
77943 if( pCur->iPage==0 ){
77944 pCur->eState = CURSOR_INVALID;
77947 moveToParent(pCur);
77949 assert( pCur->info.nSize==0 );
77950 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
77952 pCur->ix--;
77953 pPage = pCur->pPage;
77955 rc = sqlite3BtreePrevious(pCur, 0);
77962 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
77963 assert( cursorOwnsBtShared(pCur) );
77966 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
77967 pCur->info.nSize = 0;
77968 if( pCur->eState!=CURSOR_VALID
77969 || pCur->ix==0
77970 || pCur->pPage->leaf==0
77972 return btreePrevious(pCur);
77974 pCur->ix--;
80588 static int anotherValidCursor(BtCursor *pCur){
80590 for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
80591 if( pOther!=pCur
80593 && pOther->pPage==pCur->pPage
80595 return SQLITE_CORRUPT_PAGE(pCur->pPage);
80611 static int balance(BtCursor *pCur){
80621 MemPage *pPage = pCur->pPage;
80624 if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
80630 }else if( (iPage = pCur->iPage)==0 ){
80631 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
80639 rc = balance_deeper(pPage, &pCur->apPage[1]);
80641 pCur->iPage = 1;
80642 pCur->ix = 0;
80643 pCur->aiIdx[0] = 0;
80644 pCur->apPage[0] = pPage;
80645 pCur->pPage = pCur->apPage[1];
80646 assert( pCur->pPage->nOverflow );
80657 MemPage * const pParent = pCur->apPage[iPage-1];
80658 int const iIdx = pCur->aiIdx[iPage-1];
80708 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
80710 pCur->hints&BTREE_BULKLOAD);
80730 pCur->iPage--;
80731 assert( pCur->iPage>=0 );
80732 pCur->pPage = pCur->apPage[pCur->iPage];
80790 BtCursor *pCur, /* Cursor pointing to cell to overwrite */
80796 MemPage *pPage = pCur->pPage; /* Page being written */
80801 assert( pCur->info.nLocal<nTotal ); /* pCur is an overflow cell */
80804 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
80805 0, pCur->info.nLocal);
80809 iOffset = pCur->info.nLocal;
80812 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
80840 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
80842 MemPage *pPage = pCur->pPage; /* Page being written */
80844 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
80845 || pCur->info.pPayload < pPage->aData + pPage->cellOffset
80849 if( pCur->info.nLocal==nTotal ){
80851 return btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
80852 0, pCur->info.nLocal);
80855 return btreeOverwriteOverflowCell(pCur, pX);
80891 BtCursor *pCur, /* Insert data into the table of this cursor */
80901 Btree *p = pCur->pBtree;
80906 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
80919 if( pCur->curFlags & BTCF_Multiple ){
80920 rc = saveAllCursors(p->pBt, pCur->pgnoRoot, pCur);
80922 if( loc && pCur->iPage<0 ){
80928 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
80935 if( pCur->eState>=CURSOR_REQUIRESEEK ){
80936 testcase( pCur->eState==CURSOR_REQUIRESEEK );
80937 testcase( pCur->eState==CURSOR_FAULT );
80938 rc = moveToRoot(pCur);
80942 assert( cursorOwnsBtShared(pCur) );
80943 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
80946 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
80953 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
80955 if( pCur->pKeyInfo==0 ){
80960 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
80968 assert( pCur->curFlags & BTCF_ValidNKey );
80969 assert( pX->nKey==pCur->info.nKey );
80978 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
80982 if( pCur->info.nSize!=0
80983 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
80986 return btreeOverwriteCell(pCur, pX);
80994 rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
81014 r.pKeyInfo = pCur->pKeyInfo;
81019 rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc);
81021 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
81032 getCellInfo(pCur);
81033 if( pCur->info.nKey==pX->nKey ){
81038 return btreeOverwriteCell(pCur, &x2);
81042 assert( pCur->eState==CURSOR_VALID
81043 || (pCur->eState==CURSOR_INVALID && loc) || CORRUPT_DB );
81045 pPage = pCur->pPage;
81049 if( NEVER(pCur->eState>CURSOR_INVALID) ){
81059 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
81087 idx = pCur->ix;
81088 pCur->info.nSize = 0;
81104 testcase( pCur->curFlags & BTCF_ValidOvfl );
81105 invalidateOverflowCache(pCur);
81132 idx = ++pCur->ix;
81133 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
81163 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
81164 rc = balance(pCur);
81170 pCur->pPage->nOverflow = 0;
81171 pCur->eState = CURSOR_INVALID;
81173 btreeReleaseAllCursorPages(pCur);
81174 if( pCur->pKeyInfo ){
81175 assert( pCur->pKey==0 );
81176 pCur->pKey = sqlite3Malloc( pX->nKey );
81177 if( pCur->pKey==0 ){
81180 memcpy(pCur->pKey, pX->pKey, pX->nKey);
81183 pCur->eState = CURSOR_REQUIRESEEK;
81184 pCur->nKey = pX->nKey;
81187 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
81322 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
81323 Btree *p = pCur->pBtree;
81333 assert( cursorOwnsBtShared(pCur) );
81336 assert( pCur->curFlags & BTCF_WriteFlag );
81337 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
81338 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
81340 if( pCur->eState!=CURSOR_VALID ){
81341 if( pCur->eState>=CURSOR_REQUIRESEEK ){
81342 rc = btreeRestoreCursorPosition(pCur);
81343 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
81344 if( rc || pCur->eState!=CURSOR_VALID ) return rc;
81346 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
81349 assert( pCur->eState==CURSOR_VALID );
81351 iCellDepth = pCur->iPage;
81352 iCellIdx = pCur->ix;
81353 pPage = pCur->pPage;
81390 rc = saveCursorKey(pCur);
81405 rc = sqlite3BtreePrevious(pCur, 0);
81412 if( pCur->curFlags & BTCF_Multiple ){
81413 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
81419 if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
81420 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
81438 MemPage *pLeaf = pCur->pPage;
81447 if( iCellDepth<pCur->iPage-1 ){
81448 n = pCur->apPage[iCellDepth+1]->pgno;
81450 n = pCur->pPage->pgno;
81481 assert( pCur->pPage->nOverflow==0 );
81482 assert( pCur->pPage->nFree>=0 );
81483 if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
81488 rc = balance(pCur);
81490 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
81491 releasePageNotNull(pCur->pPage);
81492 pCur->iPage--;
81493 while( pCur->iPage>iCellDepth ){
81494 releasePage(pCur->apPage[pCur->iPage--]);
81496 pCur->pPage = pCur->apPage[pCur->iPage];
81497 rc = balance(pCur);
81502 assert( (pCur->iPage==iCellDepth || CORRUPT_DB) );
81503 assert( pPage==pCur->pPage || CORRUPT_DB );
81505 pCur->eState = CURSOR_SKIPNEXT;
81507 pCur->skipNext = -1;
81508 pCur->ix = pPage->nCell-1;
81510 pCur->skipNext = 1;
81513 rc = moveToRoot(pCur);
81515 btreeReleaseAllCursorPages(pCur);
81516 pCur->eState = CURSOR_REQUIRESEEK;
81785 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
81786 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
81985 SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3 *db, BtCursor *pCur, i64 *pnEntry){
81989 rc = moveToRoot(pCur);
82006 pPage = pCur->pPage;
82023 if( pCur->iPage==0 ){
82026 return moveToRoot(pCur);
82028 moveToParent(pCur);
82029 }while ( pCur->ix>=pCur->pPage->nCell );
82031 pCur->ix++;
82032 pPage = pCur->pPage;
82038 iIdx = pCur->ix;
82040 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
82042 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
82973 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
82974 pCur->curFlags |= BTCF_Incrblob;
82975 pCur->pBtree->hasIncrblobCur = 1;
85108 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
85115 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
85119 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
85131 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
85138 assert( sqlite3BtreeCursorIsValid(pCur) );
85144 pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
85151 rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem);
91072 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
91085 assert( sqlite3BtreeCursorIsValid(pCur) );
91086 nCellKey = sqlite3BtreePayloadSize(pCur);
91091 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
91159 BtCursor *pCur; local
91163 pCur = pC->uc.pCursor;
91164 assert( sqlite3BtreeCursorIsValid(pCur) );
91165 nCellKey = sqlite3BtreePayloadSize(pCur);
91173 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
98655 VdbeCursor *pCur;
98660 pCur = p->apCsr[pOp->p1];
98661 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
98662 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
98663 assert( pCur->eCurType==CURTYPE_BTREE );
98664 sqlite3BtreeClearCursor(pCur->uc.pCursor);
98727 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
98728 if( pCur==0 ) goto no_mem;
98729 pCur->iDb = iDb;
98730 pCur->nullRow = 1;
98731 pCur->isOrdered = 1;
98732 pCur->pgnoRoot = p2;
98734 pCur->wrFlag = wrFlag;
98736 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
98737 pCur->pKeyInfo = pKeyInfo;
98742 pCur->isTable = pOp->p4type!=P4_KEYINFO;
98749 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
99530 VdbeCursor *pCur;
99533 pCur = p->apCsr[pOp->p1];
99534 VdbeBranchTaken(pCur==0 || pCur->nullRow, 2);
99535 if( pCur==0 || pCur->nullRow ){
101117 BtCursor *pCur;
101121 pCur = pC->uc.pCursor;
101122 assert( sqlite3BtreeCursorIsValid(pCur) );
101123 nCellKey = sqlite3BtreePayloadSize(pCur);
101131 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
102555 VdbeCursor *pCur;
102561 pCur = 0;
102577 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
102578 if( pCur ){
102579 pCur->uc.pVCur = pVCur;
102692 VdbeCursor *pCur;
102699 pCur = p->apCsr[pOp->p1];
102702 assert( pCur!=0 );
102703 assert( pCur->eCurType==CURTYPE_VTAB );
102704 pVCur = pCur->uc.pVCur;
102723 pCur->nullRow = 0;
102752 VdbeCursor *pCur = p->apCsr[pOp->p1];
102753 assert( pCur!=0 );
102757 if( pCur->nullRow ){
102761 assert( pCur->eCurType==CURTYPE_VTAB );
102762 pVtab = pCur->uc.pVCur->pVtab;
102779 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
102805 VdbeCursor *pCur;
102807 pCur = p->apCsr[pOp->p1];
102808 assert( pCur!=0 );
102809 assert( pCur->eCurType==CURTYPE_VTAB );
102810 if( pCur->nullRow ){
102813 pVtab = pCur->uc.pVCur->pVtab;
102823 rc = pModule->xNext(pCur->uc.pVCur);
102826 res = pModule->xEof(pCur->uc.pVCur);
106995 bytecodevtab_cursor *pCur;
106996 pCur = sqlite3_malloc( sizeof(*pCur) );
106997 if( pCur==0 ) return SQLITE_NOMEM;
106998 memset(pCur, 0, sizeof(*pCur));
106999 sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1);
107000 *ppCursor = &pCur->base;
107007 static void bytecodevtabCursorClear(bytecodevtab_cursor *pCur){
107008 sqlite3_free(pCur->zP4);
107009 pCur->zP4 = 0;
107010 sqlite3VdbeMemRelease(&pCur->sub);
107011 sqlite3VdbeMemSetNull(&pCur->sub);
107012 if( pCur->needFinalize ){
107013 sqlite3_finalize(pCur->pStmt);
107015 pCur->pStmt = 0;
107016 pCur->needFinalize = 0;
107017 pCur->zType = 0;
107018 pCur->zSchema = 0;
107019 pCur->zName = 0;
107026 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
107027 bytecodevtabCursorClear(pCur);
107028 sqlite3_free(pCur);
107037 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
107040 if( pCur->zP4 ){
107041 sqlite3_free(pCur->zP4);
107042 pCur->zP4 = 0;
107044 if( pCur->zName ){
107045 pCur->zName = 0;
107046 pCur->zType = 0;
107047 pCur->zSchema = 0;
107050 (Vdbe*)pCur->pStmt,
107051 pCur->showSubprograms ? &pCur->sub : 0,
107053 &pCur->iRowid,
107054 &pCur->iAddr,
107055 &pCur->aOp);
107057 sqlite3VdbeMemSetNull(&pCur->sub);
107058 pCur->aOp = 0;
107068 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
107069 return pCur->aOp==0;
107081 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
107083 Op *pOp = pCur->aOp + pCur->iAddr;
107088 if( i<=2 && pCur->zType==0 ){
107095 pCur->zSchema = db->aDb[iDb].zDbSName;
107099 pCur->zName = pTab->zName;
107100 pCur->zType = "table";
107104 if( pCur->zName==0 ){
107108 pCur->zName = pIdx->zName;
107109 pCur->zType = "index";
107119 sqlite3_result_int(ctx, pCur->iAddr);
107136 if( pCur->zP4==0 ){
107137 pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp);
107140 sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC);
107143 char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4);
107152 Op *aOp = pCur->aOp;
107155 if( pCur->iRowid==pCur->iAddr+1 ){
107180 sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC);
107183 sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC);
107186 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
107200 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
107201 *pRowid = pCur->iRowid;
107216 bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor;
107221 bytecodevtabCursorClear(pCur);
107222 pCur->iRowid = 0;
107223 pCur->iAddr = 0;
107224 pCur->showSubprograms = idxNum==0;
107231 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
107232 pCur->needFinalize = 1;
107235 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
107237 if( pCur->pStmt==0 ){
212848 JsonEachCursor *pCur;
212851 pCur = sqlite3DbMallocZero(pVtab->db, sizeof(*pCur));
212852 if( pCur==0 ) return SQLITE_NOMEM;
212853 pCur->db = pVtab->db;
212854 jsonStringZero(&pCur->path);
212855 *ppCursor = &pCur->base;
212863 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
212864 pCur->bRecursive = 1;
214914 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
214915 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
214921 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
214923 int ii = 1 - pCur->bPoint;
214925 assert( pCur->bPoint || pCur->nPoint );
214926 if( pCur->aNode[ii]==0 ){
214928 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
214929 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
214931 return pCur->aNode[ii];
214938 RtreeCursor *pCur, /* The cursor */
214944 if( pCur->nPoint>=pCur->nPointAlloc ){
214945 int nNew = pCur->nPointAlloc*2 + 8;
214946 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
214948 pCur->aPoint = pNew;
214949 pCur->nPointAlloc = nNew;
214951 i = pCur->nPoint++;
214952 pNew = pCur->aPoint + i;
214959 pParent = pCur->aPoint + j;
214961 rtreeSearchPointSwap(pCur, j, i);
214973 RtreeCursor *pCur, /* The cursor */
214978 pFirst = rtreeSearchPointFirst(pCur);
214979 pCur->anQueue[iLevel]++;
214984 if( pCur->bPoint ){
214986 pNew = rtreeEnqueue(pCur, rScore, iLevel);
214988 ii = (int)(pNew - pCur->aPoint) + 1;
214991 assert( pCur->aNode[ii]==0 );
214992 pCur->aNode[ii] = pCur->aNode[0];
214994 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
214996 pCur->aNode[0] = 0;
214997 *pNew = pCur->sPoint;
214999 pCur->sPoint.rScore = rScore;
215000 pCur->sPoint.iLevel = iLevel;
215001 pCur->bPoint = 1;
215002 return &pCur->sPoint;
215004 return rtreeEnqueue(pCur, rScore, iLevel);
215010 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
215017 printf(" %p\n", pCur->aNode[idx]);
215022 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
215025 if( pCur->bPoint ){
215026 tracePoint(&pCur->sPoint, -1, pCur);
215028 for(ii=0; ii<pCur->nPoint; ii++){
215029 if( ii>0 || pCur->bPoint ) printf(" ");
215030 tracePoint(&pCur->aPoint[ii], ii, pCur);
215088 static int rtreeStepToLeaf(RtreeCursor *pCur){
215090 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
215095 int nConstraint = pCur->nConstraint;
215101 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
215103 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
215112 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
215133 for(ii=0; ii<pCur->nPoint; ii++){
215134 if( pCur->aPoint[ii].id==x.id ){
215145 RTREE_QUEUE_TRACE(pCur, "POP-S:");
215146 rtreeSearchPointPop(pCur);
215149 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
215154 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
215158 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
215159 rtreeSearchPointPop(pCur);
215162 pCur->atEOF = p==0;
262675 stmt_cursor *pCur;
262676 pCur = sqlite3_malloc64( sizeof(*pCur) );
262677 if( pCur==0 ) return SQLITE_NOMEM;
262678 memset(pCur, 0, sizeof(*pCur));
262679 pCur->db = ((stmt_vtab*)p)->db;
262680 *ppCursor = &pCur->base;
262684 static void stmtCsrReset(stmt_cursor *pCur){
262687 for(pRow=pCur->pRow; pRow; pRow=pNext){
262691 pCur->pRow = 0;
262708 stmt_cursor *pCur = (stmt_cursor*)cur;
262709 StmtRow *pNext = pCur->pRow->pNext;
262710 sqlite3_free(pCur->pRow);
262711 pCur->pRow = pNext;
262724 stmt_cursor *pCur = (stmt_cursor*)cur;
262725 StmtRow *pRow = pCur->pRow;
262739 stmt_cursor *pCur = (stmt_cursor*)cur;
262740 *pRowid = pCur->pRow->iRowid;
262749 stmt_cursor *pCur = (stmt_cursor*)cur;
262750 return pCur->pRow==0;
262764 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
262773 stmtCsrReset(pCur);
262774 ppRow = &pCur->pRow;
262775 for(p=sqlite3_next_stmt(pCur->db, 0); p; p=sqlite3_next_stmt(pCur->db, p)){