Lines Matching refs:pCur
8987 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
70530 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
70531 sqlite3BtreeEnter(pCur->pBtree);
70534 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
70535 sqlite3BtreeLeave(pCur->pBtree);
71106 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
71233 static void btreeReleaseAllCursorPages(BtCursor *pCur){
71235 if( pCur->iPage>=0 ){
71236 for(i=0; i<pCur->iPage; i++){
71237 releasePageNotNull(pCur->apPage[i]);
71239 releasePageNotNull(pCur->pPage);
71240 pCur->iPage = -1;
71257 static int saveCursorKey(BtCursor *pCur){
71259 assert( CURSOR_VALID==pCur->eState );
71260 assert( 0==pCur->pKey );
71261 assert( cursorHoldsMutex(pCur) );
71263 if( pCur->curIntKey ){
71265 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
71274 pCur->nKey = sqlite3BtreePayloadSize(pCur);
71275 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
71277 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
71279 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
71280 pCur->pKey = pKey;
71288 assert( !pCur->curIntKey || !pCur->pKey );
71299 static int saveCursorPosition(BtCursor *pCur){
71302 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
71303 assert( 0==pCur->pKey );
71304 assert( cursorHoldsMutex(pCur) );
71306 if( pCur->curFlags & BTCF_Pinned ){
71309 if( pCur->eState==CURSOR_SKIPNEXT ){
71310 pCur->eState = CURSOR_VALID;
71312 pCur->skipNext = 0;
71315 rc = saveCursorKey(pCur);
71317 btreeReleaseAllCursorPages(pCur);
71318 pCur->eState = CURSOR_REQUIRESEEK;
71321 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
71391 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
71392 assert( cursorHoldsMutex(pCur) );
71393 sqlite3_free(pCur->pKey);
71394 pCur->pKey = 0;
71395 pCur->eState = CURSOR_INVALID;
71404 BtCursor *pCur, /* Cursor open on the btree to be searched */
71414 KeyInfo *pKeyInfo = pCur->pKeyInfo;
71422 rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes);
71424 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
71427 rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes);
71439 static int btreeRestoreCursorPosition(BtCursor *pCur){
71442 assert( cursorOwnsBtShared(pCur) );
71443 assert( pCur->eState>=CURSOR_REQUIRESEEK );
71444 if( pCur->eState==CURSOR_FAULT ){
71445 return pCur->skipNext;
71447 pCur->eState = CURSOR_INVALID;
71451 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
71454 sqlite3_free(pCur->pKey);
71455 pCur->pKey = 0;
71456 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
71457 if( skipNext ) pCur->skipNext = skipNext;
71458 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
71459 pCur->eState = CURSOR_SKIPNEXT;
71482 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
71483 assert( EIGHT_BYTE_ALIGNMENT(pCur)
71484 || pCur==sqlite3BtreeFakeValidCursor() );
71486 assert( sizeof(pCur->eState)==1 );
71487 return CURSOR_VALID != *(u8*)pCur;
71514 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
71517 assert( pCur!=0 );
71518 assert( pCur->eState!=CURSOR_VALID );
71519 rc = restoreCursorPosition(pCur);
71524 if( pCur->eState!=CURSOR_VALID ){
71538 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
71563 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
71565 pCur->hints = x;
73413 BtCursor *pCur = pBt->pCursor;
73414 pBt->pCursor = pCur->pNext; /* Unlink the cursor */
73415 memset(pCur, 0, sizeof(*pCur));
73463 BtCursor *pCur = pBt->pCursor;
73464 while( pCur ){
73465 BtCursor *pTmp = pCur;
73466 pCur = pCur->pNext;
74003 BtCursor *pCur;
74005 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
74006 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
74007 && pCur->eState!=CURSOR_FAULT ) r++;
75191 BtCursor *pCur /* Space for new cursor */
75227 pCur->pgnoRoot = iTable;
75228 pCur->iPage = -1;
75229 pCur->pKeyInfo = pKeyInfo;
75230 pCur->pBtree = p;
75231 pCur->pBt = pBt;
75232 pCur->curFlags = 0;
75238 pCur->curFlags = BTCF_Multiple;
75241 pCur->eState = CURSOR_INVALID;
75242 pCur->pNext = pBt->pCursor;
75243 pBt->pCursor = pCur;
75245 pCur->curFlags |= BTCF_WriteFlag;
75246 pCur->curPagerFlags = 0;
75249 pCur->curPagerFlags = PAGER_GET_READONLY;
75258 BtCursor *pCur /* Space for new cursor */
75262 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
75271 BtCursor *pCur /* Write new cursor here */
75274 return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur);
75276 return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
75308 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
75309 Btree *pBtree = pCur->pBtree;
75311 BtShared *pBt = pCur->pBt;
75314 if( pBt->pCursor==pCur ){
75315 pBt->pCursor = pCur->pNext;
75319 if( pPrev->pNext==pCur ){
75320 pPrev->pNext = pCur->pNext;
75326 btreeReleaseAllCursorPages(pCur);
75328 sqlite3_free(pCur->aOverflow);
75329 sqlite3_free(pCur->pKey);
75338 pCur->pBtree = 0;
75360 static void assertCellInfo(BtCursor *pCur){
75363 btreeParseCell(pCur->pPage, pCur->ix, &info);
75364 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
75369 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
75370 if( pCur->info.nSize==0 ){
75371 pCur->curFlags |= BTCF_ValidNKey;
75372 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
75374 assertCellInfo(pCur);
75384 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
75385 return pCur && pCur->eState==CURSOR_VALID;
75388 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
75389 assert( pCur!=0 );
75390 return pCur->eState==CURSOR_VALID;
75399 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
75400 assert( cursorHoldsMutex(pCur) );
75401 assert( pCur->eState==CURSOR_VALID );
75402 assert( pCur->curIntKey );
75403 getCellInfo(pCur);
75404 return pCur->info.nKey;
75410 SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor *pCur){
75411 assert( (pCur->curFlags & BTCF_Pinned)==0 );
75412 pCur->curFlags |= BTCF_Pinned;
75414 SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor *pCur){
75415 assert( (pCur->curFlags & BTCF_Pinned)!=0 );
75416 pCur->curFlags &= ~BTCF_Pinned;
75423 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
75424 assert( cursorHoldsMutex(pCur) );
75425 assert( pCur->eState==CURSOR_VALID );
75426 getCellInfo(pCur);
75427 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
75428 (i64)(pCur->info.pPayload - pCur->pPage->aData);
75440 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
75441 assert( cursorHoldsMutex(pCur) );
75442 assert( pCur->eState==CURSOR_VALID );
75443 getCellInfo(pCur);
75444 return pCur->info.nPayload;
75460 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
75461 assert( cursorHoldsMutex(pCur) );
75462 assert( pCur->eState==CURSOR_VALID );
75463 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
75604 BtCursor *pCur, /* Cursor pointing to entry to read from */
75613 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
75614 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
75621 assert( pCur->eState==CURSOR_VALID );
75622 if( pCur->ix>=pPage->nCell ){
75625 assert( cursorHoldsMutex(pCur) );
75627 getCellInfo(pCur);
75628 aPayload = pCur->info.pPayload;
75629 assert( offset+amt <= pCur->info.nPayload );
75632 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
75642 if( offset<pCur->info.nLocal ){
75644 if( a+offset>pCur->info.nLocal ){
75645 a = pCur->info.nLocal - offset;
75652 offset -= pCur->info.nLocal;
75660 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
75669 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
75670 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
75671 if( pCur->aOverflow==0
75672 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
75678 aNew = (Pgno*)sqlite3Realloc(pCur->aOverflow, nOvfl*2*sizeof(Pgno));
75683 pCur->aOverflow = aNew;
75686 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
75687 pCur->curFlags |= BTCF_ValidOvfl;
75690 assert( pCur->aOverflow[0]==nextPage
75691 || pCur->aOverflow[0]==0
75693 assert( pCur->aOverflow[0]!=0 || pCur->aOverflow[offset/ovflSize]==0 );
75699 if( pCur->aOverflow[offset/ovflSize] ){
75701 nextPage = pCur->aOverflow[iIdx];
75710 assert( pCur->aOverflow[iIdx]==0
75711 || pCur->aOverflow[iIdx]==nextPage
75713 pCur->aOverflow[iIdx] = nextPage;
75722 assert( pCur->curFlags & BTCF_ValidOvfl );
75723 assert( pCur->pBtree->db==pBt->db );
75724 if( pCur->aOverflow[iIdx+1] ){
75725 nextPage = pCur->aOverflow[iIdx+1];
75815 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
75816 assert( cursorHoldsMutex(pCur) );
75817 assert( pCur->eState==CURSOR_VALID );
75818 assert( pCur->iPage>=0 && pCur->pPage );
75819 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
75829 BtCursor *pCur,
75835 if ( pCur->eState==CURSOR_INVALID ){
75838 assert( cursorOwnsBtShared(pCur) );
75839 rc = btreeRestoreCursorPosition(pCur);
75840 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
75842 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
75843 if( pCur->eState==CURSOR_VALID ){
75844 assert( cursorOwnsBtShared(pCur) );
75845 return accessPayload(pCur, offset, amt, pBuf, 0);
75847 return accessPayloadChecked(pCur, offset, amt, pBuf);
75872 BtCursor *pCur, /* Cursor pointing to entry to read from */
75876 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
75877 assert( pCur->eState==CURSOR_VALID );
75878 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
75879 assert( cursorOwnsBtShared(pCur) );
75880 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
75881 assert( pCur->info.nSize>0 );
75882 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
75883 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
75884 amt = pCur->info.nLocal;
75885 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
75889 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
75892 return (void*)pCur->info.pPayload;
75910 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
75911 return fetchPayload(pCur, pAmt);
75924 static int moveToChild(BtCursor *pCur, u32 newPgno){
75926 assert( cursorOwnsBtShared(pCur) );
75927 assert( pCur->eState==CURSOR_VALID );
75928 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
75929 assert( pCur->iPage>=0 );
75930 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
75933 pCur->info.nSize = 0;
75934 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
75935 pCur->aiIdx[pCur->iPage] = pCur->ix;
75936 pCur->apPage[pCur->iPage] = pCur->pPage;
75937 pCur->ix = 0;
75938 pCur->iPage++;
75939 rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
75940 assert( pCur->pPage!=0 || rc!=SQLITE_OK );
75942 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
75944 releasePage(pCur->pPage);
75948 pCur->pPage = pCur->apPage[--pCur->iPage];
75983 static void moveToParent(BtCursor *pCur){
75985 assert( cursorOwnsBtShared(pCur) );
75986 assert( pCur->eState==CURSOR_VALID );
75987 assert( pCur->iPage>0 );
75988 assert( pCur->pPage );
75990 pCur->apPage[pCur->iPage-1],
75991 pCur->aiIdx[pCur->iPage-1],
75992 pCur->pPage->pgno
75994 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
75995 pCur->info.nSize = 0;
75996 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
75997 pCur->ix = pCur->aiIdx[pCur->iPage-1];
75998 pLeaf = pCur->pPage;
75999 pCur->pPage = pCur->apPage[--pCur->iPage];
76024 static int moveToRoot(BtCursor *pCur){
76028 assert( cursorOwnsBtShared(pCur) );
76032 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
76033 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
76035 if( pCur->iPage>=0 ){
76036 if( pCur->iPage ){
76037 releasePageNotNull(pCur->pPage);
76038 while( --pCur->iPage ){
76039 releasePageNotNull(pCur->apPage[pCur->iPage]);
76041 pRoot = pCur->pPage = pCur->apPage[0];
76044 }else if( pCur->pgnoRoot==0 ){
76045 pCur->eState = CURSOR_INVALID;
76048 assert( pCur->iPage==(-1) );
76049 if( pCur->eState>=CURSOR_REQUIRESEEK ){
76050 if( pCur->eState==CURSOR_FAULT ){
76051 assert( pCur->skipNext!=SQLITE_OK );
76052 return pCur->skipNext;
76054 sqlite3BtreeClearCursor(pCur);
76056 rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
76057 pCur->curPagerFlags);
76059 pCur->eState = CURSOR_INVALID;
76062 pCur->iPage = 0;
76063 pCur->curIntKey = pCur->pPage->intKey;
76065 pRoot = pCur->pPage;
76066 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
76079 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
76080 return SQLITE_CORRUPT_PAGE(pCur->pPage);
76084 pCur->ix = 0;
76085 pCur->info.nSize = 0;
76086 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
76089 pCur->eState = CURSOR_VALID;
76094 pCur->eState = CURSOR_VALID;
76095 rc = moveToChild(pCur, subpage);
76097 pCur->eState = CURSOR_INVALID;
76110 static int moveToLeftmost(BtCursor *pCur){
76115 assert( cursorOwnsBtShared(pCur) );
76116 assert( pCur->eState==CURSOR_VALID );
76117 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
76118 assert( pCur->ix<pPage->nCell );
76119 pgno = get4byte(findCell(pPage, pCur->ix));
76120 rc = moveToChild(pCur, pgno);
76135 static int moveToRightmost(BtCursor *pCur){
76140 assert( cursorOwnsBtShared(pCur) );
76141 assert( pCur->eState==CURSOR_VALID );
76142 while( !(pPage = pCur->pPage)->leaf ){
76144 pCur->ix = pPage->nCell;
76145 rc = moveToChild(pCur, pgno);
76148 pCur->ix = pPage->nCell-1;
76149 assert( pCur->info.nSize==0 );
76150 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
76158 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
76161 assert( cursorOwnsBtShared(pCur) );
76162 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76163 rc = moveToRoot(pCur);
76165 assert( pCur->pPage->nCell>0 );
76167 rc = moveToLeftmost(pCur);
76169 assert( pCur->pgnoRoot==0 || (pCur->pPage!=0 && pCur->pPage->nCell==0) );
76184 static int cursorIsAtLastEntry(BtCursor *pCur){
76186 for(ii=0; ii<pCur->iPage; ii++){
76187 if( pCur->aiIdx[ii]!=pCur->apPage[ii]->nCell ) return 0;
76189 return pCur->ix==pCur->pPage->nCell-1 && pCur->pPage->leaf!=0;
76197 static SQLITE_NOINLINE int btreeLast(BtCursor *pCur, int *pRes){
76198 int rc = moveToRoot(pCur);
76200 assert( pCur->eState==CURSOR_VALID );
76202 rc = moveToRightmost(pCur);
76204 pCur->curFlags |= BTCF_AtLast;
76206 pCur->curFlags &= ~BTCF_AtLast;
76209 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76215 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
76216 assert( cursorOwnsBtShared(pCur) );
76217 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76220 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
76221 assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
76225 return btreeLast(pCur, pRes);
76252 BtCursor *pCur, /* The cursor to be moved */
76259 assert( cursorOwnsBtShared(pCur) );
76260 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76262 assert( pCur->pKeyInfo==0 );
76263 assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
76267 if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
76268 if( pCur->info.nKey==intKey ){
76272 if( pCur->info.nKey<intKey ){
76273 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
76274 assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
76282 if( pCur->info.nKey+1==intKey ){
76284 rc = sqlite3BtreeNext(pCur, 0);
76286 getCellInfo(pCur);
76287 if( pCur->info.nKey==intKey ){
76298 pCur->pBtree->nSeek++; /* Performance measurement during testing */
76301 rc = moveToRoot(pCur);
76304 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76310 assert( pCur->pPage );
76311 assert( pCur->pPage->isInit );
76312 assert( pCur->eState==CURSOR_VALID );
76313 assert( pCur->pPage->nCell > 0 );
76314 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
76315 assert( pCur->curIntKey );
76320 MemPage *pPage = pCur->pPage;
76354 pCur->ix = (u16)idx;
76359 pCur->curFlags |= BTCF_ValidNKey;
76360 pCur->info.nKey = nCellKey;
76361 pCur->info.nSize = 0;
76372 assert( pCur->ix<pCur->pPage->nCell );
76373 pCur->ix = (u16)idx;
76384 pCur->ix = (u16)lwr;
76385 rc = moveToChild(pCur, chldPg);
76389 pCur->info.nSize = 0;
76390 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76411 BtCursor *pCur,
76416 MemPage *pPage = pCur->pPage;
76447 static int cursorOnLastPage(BtCursor *pCur){
76449 assert( pCur->eState==CURSOR_VALID );
76450 for(i=0; i<pCur->iPage; i++){
76451 MemPage *pPage = pCur->apPage[i];
76452 if( pCur->aiIdx[i]<pPage->nCell ) return 0;
76484 BtCursor *pCur, /* The cursor to be moved */
76491 assert( cursorOwnsBtShared(pCur) );
76492 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76494 assert( pCur->pKeyInfo!=0 );
76497 pCur->pBtree->nSeek++; /* Performance measurement during testing */
76519 if( pCur->eState==CURSOR_VALID
76520 && pCur->pPage->leaf
76521 && cursorOnLastPage(pCur)
76524 if( pCur->ix==pCur->pPage->nCell-1
76525 && (c = indexCellCompare(pCur, pCur->ix, pIdxKey, xRecordCompare))<=0
76531 if( pCur->iPage>0
76532 && indexCellCompare(pCur, 0, pIdxKey, xRecordCompare)<=0
76535 pCur->curFlags &= ~BTCF_ValidOvfl;
76536 if( !pCur->pPage->isInit ){
76544 rc = moveToRoot(pCur);
76547 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76555 assert( pCur->pPage );
76556 assert( pCur->pPage->isInit );
76557 assert( pCur->eState==CURSOR_VALID );
76558 assert( pCur->pPage->nCell > 0 );
76559 assert( pCur->curIntKey==0 );
76564 MemPage *pPage = pCur->pPage;
76617 pPage->xParseCell(pPage, pCellBody, &pCur->info);
76618 nCell = (int)pCur->info.nKey;
76623 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
76632 pCur->ix = (u16)idx;
76633 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
76635 pCur->curFlags &= ~BTCF_ValidOvfl;
76645 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
76655 pCur->ix = (u16)idx;
76666 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
76667 pCur->ix = (u16)idx;
76684 pCur->info.nSize = 0;
76685 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
76686 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
76689 pCur->aiIdx[pCur->iPage] = (u16)lwr;
76690 pCur->apPage[pCur->iPage] = pCur->pPage;
76691 pCur->ix = 0;
76692 pCur->iPage++;
76693 rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
76695 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
76697 releasePage(pCur->pPage);
76701 pCur->pPage = pCur->apPage[--pCur->iPage];
76708 pCur->info.nSize = 0;
76709 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76721 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
76726 return (CURSOR_VALID!=pCur->eState);
76734 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
76738 assert( cursorOwnsBtShared(pCur) );
76739 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76744 if( pCur->eState!=CURSOR_VALID ) return 0;
76745 if( NEVER(pCur->pPage->leaf==0) ) return -1;
76747 n = pCur->pPage->nCell;
76748 for(i=0; i<pCur->iPage; i++){
76749 n *= pCur->apPage[i]->nCell;
76774 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
76779 assert( cursorOwnsBtShared(pCur) );
76780 if( pCur->eState!=CURSOR_VALID ){
76781 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76782 rc = restoreCursorPosition(pCur);
76786 if( CURSOR_INVALID==pCur->eState ){
76789 if( pCur->eState==CURSOR_SKIPNEXT ){
76790 pCur->eState = CURSOR_VALID;
76791 if( pCur->skipNext>0 ) return SQLITE_OK;
76795 pPage = pCur->pPage;
76796 idx = ++pCur->ix;
76804 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
76806 return moveToLeftmost(pCur);
76809 if( pCur->iPage==0 ){
76810 pCur->eState = CURSOR_INVALID;
76813 moveToParent(pCur);
76814 pPage = pCur->pPage;
76815 }while( pCur->ix>=pPage->nCell );
76817 return sqlite3BtreeNext(pCur, 0);
76825 return moveToLeftmost(pCur);
76828 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
76831 assert( cursorOwnsBtShared(pCur) );
76833 pCur->info.nSize = 0;
76834 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
76835 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
76836 pPage = pCur->pPage;
76837 if( (++pCur->ix)>=pPage->nCell ){
76838 pCur->ix--;
76839 return btreeNext(pCur);
76844 return moveToLeftmost(pCur);
76868 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
76872 assert( cursorOwnsBtShared(pCur) );
76873 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
76874 assert( pCur->info.nSize==0 );
76875 if( pCur->eState!=CURSOR_VALID ){
76876 rc = restoreCursorPosition(pCur);
76880 if( CURSOR_INVALID==pCur->eState ){
76883 if( CURSOR_SKIPNEXT==pCur->eState ){
76884 pCur->eState = CURSOR_VALID;
76885 if( pCur->skipNext<0 ) return SQLITE_OK;
76889 pPage = pCur->pPage;
76895 int idx = pCur->ix;
76896 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
76898 rc = moveToRightmost(pCur);
76900 while( pCur->ix==0 ){
76901 if( pCur->iPage==0 ){
76902 pCur->eState = CURSOR_INVALID;
76905 moveToParent(pCur);
76907 assert( pCur->info.nSize==0 );
76908 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
76910 pCur->ix--;
76911 pPage = pCur->pPage;
76913 rc = sqlite3BtreePrevious(pCur, 0);
76920 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
76921 assert( cursorOwnsBtShared(pCur) );
76924 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
76925 pCur->info.nSize = 0;
76926 if( pCur->eState!=CURSOR_VALID
76927 || pCur->ix==0
76928 || pCur->pPage->leaf==0
76930 return btreePrevious(pCur);
76932 pCur->ix--;
79535 static int anotherValidCursor(BtCursor *pCur){
79537 for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
79538 if( pOther!=pCur
79540 && pOther->pPage==pCur->pPage
79542 return SQLITE_CORRUPT_PAGE(pCur->pPage);
79558 static int balance(BtCursor *pCur){
79568 MemPage *pPage = pCur->pPage;
79571 if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
79577 }else if( (iPage = pCur->iPage)==0 ){
79578 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
79586 rc = balance_deeper(pPage, &pCur->apPage[1]);
79588 pCur->iPage = 1;
79589 pCur->ix = 0;
79590 pCur->aiIdx[0] = 0;
79591 pCur->apPage[0] = pPage;
79592 pCur->pPage = pCur->apPage[1];
79593 assert( pCur->pPage->nOverflow );
79604 MemPage * const pParent = pCur->apPage[iPage-1];
79605 int const iIdx = pCur->aiIdx[iPage-1];
79655 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
79657 pCur->hints&BTREE_BULKLOAD);
79677 pCur->iPage--;
79678 assert( pCur->iPage>=0 );
79679 pCur->pPage = pCur->apPage[pCur->iPage];
79737 BtCursor *pCur, /* Cursor pointing to cell to overwrite */
79743 MemPage *pPage = pCur->pPage; /* Page being written */
79748 assert( pCur->info.nLocal<nTotal ); /* pCur is an overflow cell */
79751 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
79752 0, pCur->info.nLocal);
79756 iOffset = pCur->info.nLocal;
79759 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
79787 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
79789 MemPage *pPage = pCur->pPage; /* Page being written */
79791 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
79792 || pCur->info.pPayload < pPage->aData + pPage->cellOffset
79796 if( pCur->info.nLocal==nTotal ){
79798 return btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
79799 0, pCur->info.nLocal);
79802 return btreeOverwriteOverflowCell(pCur, pX);
79838 BtCursor *pCur, /* Insert data into the table of this cursor */
79848 Btree *p = pCur->pBtree;
79853 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
79866 if( pCur->curFlags & BTCF_Multiple ){
79867 rc = saveAllCursors(p->pBt, pCur->pgnoRoot, pCur);
79869 if( loc && pCur->iPage<0 ){
79875 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
79882 if( pCur->eState>=CURSOR_REQUIRESEEK ){
79883 testcase( pCur->eState==CURSOR_REQUIRESEEK );
79884 testcase( pCur->eState==CURSOR_FAULT );
79885 rc = moveToRoot(pCur);
79889 assert( cursorOwnsBtShared(pCur) );
79890 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
79893 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
79900 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
79902 if( pCur->pKeyInfo==0 ){
79907 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
79915 assert( pCur->curFlags & BTCF_ValidNKey );
79916 assert( pX->nKey==pCur->info.nKey );
79925 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
79929 if( pCur->info.nSize!=0
79930 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
79933 return btreeOverwriteCell(pCur, pX);
79941 rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
79961 r.pKeyInfo = pCur->pKeyInfo;
79966 rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc);
79968 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
79979 getCellInfo(pCur);
79980 if( pCur->info.nKey==pX->nKey ){
79985 return btreeOverwriteCell(pCur, &x2);
79989 assert( pCur->eState==CURSOR_VALID
79990 || (pCur->eState==CURSOR_INVALID && loc) || CORRUPT_DB );
79992 pPage = pCur->pPage;
79996 if( NEVER(pCur->eState>CURSOR_INVALID) ){
80006 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
80034 idx = pCur->ix;
80035 pCur->info.nSize = 0;
80051 testcase( pCur->curFlags & BTCF_ValidOvfl );
80052 invalidateOverflowCache(pCur);
80079 idx = ++pCur->ix;
80080 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
80110 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
80111 rc = balance(pCur);
80117 pCur->pPage->nOverflow = 0;
80118 pCur->eState = CURSOR_INVALID;
80120 btreeReleaseAllCursorPages(pCur);
80121 if( pCur->pKeyInfo ){
80122 assert( pCur->pKey==0 );
80123 pCur->pKey = sqlite3Malloc( pX->nKey );
80124 if( pCur->pKey==0 ){
80127 memcpy(pCur->pKey, pX->pKey, pX->nKey);
80130 pCur->eState = CURSOR_REQUIRESEEK;
80131 pCur->nKey = pX->nKey;
80134 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
80269 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
80270 Btree *p = pCur->pBtree;
80280 assert( cursorOwnsBtShared(pCur) );
80283 assert( pCur->curFlags & BTCF_WriteFlag );
80284 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
80285 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
80287 if( pCur->eState!=CURSOR_VALID ){
80288 if( pCur->eState>=CURSOR_REQUIRESEEK ){
80289 rc = btreeRestoreCursorPosition(pCur);
80290 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
80291 if( rc || pCur->eState!=CURSOR_VALID ) return rc;
80293 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
80296 assert( pCur->eState==CURSOR_VALID );
80298 iCellDepth = pCur->iPage;
80299 iCellIdx = pCur->ix;
80300 pPage = pCur->pPage;
80337 rc = saveCursorKey(pCur);
80352 rc = sqlite3BtreePrevious(pCur, 0);
80359 if( pCur->curFlags & BTCF_Multiple ){
80360 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
80366 if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
80367 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
80385 MemPage *pLeaf = pCur->pPage;
80394 if( iCellDepth<pCur->iPage-1 ){
80395 n = pCur->apPage[iCellDepth+1]->pgno;
80397 n = pCur->pPage->pgno;
80428 assert( pCur->pPage->nOverflow==0 );
80429 assert( pCur->pPage->nFree>=0 );
80430 if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
80435 rc = balance(pCur);
80437 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
80438 releasePageNotNull(pCur->pPage);
80439 pCur->iPage--;
80440 while( pCur->iPage>iCellDepth ){
80441 releasePage(pCur->apPage[pCur->iPage--]);
80443 pCur->pPage = pCur->apPage[pCur->iPage];
80444 rc = balance(pCur);
80449 assert( (pCur->iPage==iCellDepth || CORRUPT_DB) );
80450 assert( pPage==pCur->pPage || CORRUPT_DB );
80452 pCur->eState = CURSOR_SKIPNEXT;
80454 pCur->skipNext = -1;
80455 pCur->ix = pPage->nCell-1;
80457 pCur->skipNext = 1;
80460 rc = moveToRoot(pCur);
80462 btreeReleaseAllCursorPages(pCur);
80463 pCur->eState = CURSOR_REQUIRESEEK;
80732 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
80733 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
80932 SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3 *db, BtCursor *pCur, i64 *pnEntry){
80936 rc = moveToRoot(pCur);
80953 pPage = pCur->pPage;
80970 if( pCur->iPage==0 ){
80973 return moveToRoot(pCur);
80975 moveToParent(pCur);
80976 }while ( pCur->ix>=pCur->pPage->nCell );
80978 pCur->ix++;
80979 pPage = pCur->pPage;
80985 iIdx = pCur->ix;
80987 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
80989 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
81919 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
81920 pCur->curFlags |= BTCF_Incrblob;
81921 pCur->pBtree->hasIncrblobCur = 1;
84051 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
84058 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
84062 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
84074 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
84081 assert( sqlite3BtreeCursorIsValid(pCur) );
84087 pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
84094 rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem);
89997 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
90010 assert( sqlite3BtreeCursorIsValid(pCur) );
90011 nCellKey = sqlite3BtreePayloadSize(pCur);
90016 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
90084 BtCursor *pCur;
90088 pCur = pC->uc.pCursor;
90089 assert( sqlite3BtreeCursorIsValid(pCur) );
90090 nCellKey = sqlite3BtreePayloadSize(pCur);
90098 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
97397 VdbeCursor *pCur;
97402 pCur = p->apCsr[pOp->p1];
97403 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
97404 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
97405 assert( pCur->eCurType==CURTYPE_BTREE );
97406 sqlite3BtreeClearCursor(pCur->uc.pCursor);
97469 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
97470 if( pCur==0 ) goto no_mem;
97471 pCur->iDb = iDb;
97472 pCur->nullRow = 1;
97473 pCur->isOrdered = 1;
97474 pCur->pgnoRoot = p2;
97476 pCur->wrFlag = wrFlag;
97478 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
97479 pCur->pKeyInfo = pKeyInfo;
97484 pCur->isTable = pOp->p4type!=P4_KEYINFO;
97491 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
98267 VdbeCursor *pCur;
98270 pCur = p->apCsr[pOp->p1];
98271 VdbeBranchTaken(pCur==0 || pCur->nullRow, 2);
98272 if( pCur==0 || pCur->nullRow ){
99853 BtCursor *pCur;
99857 pCur = pC->uc.pCursor;
99858 assert( sqlite3BtreeCursorIsValid(pCur) );
99859 nCellKey = sqlite3BtreePayloadSize(pCur);
99867 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
101278 VdbeCursor *pCur;
101284 pCur = 0;
101300 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
101301 if( pCur ){
101302 pCur->uc.pVCur = pVCur;
101415 VdbeCursor *pCur;
101422 pCur = p->apCsr[pOp->p1];
101425 assert( pCur!=0 );
101426 assert( pCur->eCurType==CURTYPE_VTAB );
101427 pVCur = pCur->uc.pVCur;
101445 pCur->nullRow = 0;
101474 VdbeCursor *pCur = p->apCsr[pOp->p1];
101475 assert( pCur!=0 );
101479 if( pCur->nullRow ){
101483 assert( pCur->eCurType==CURTYPE_VTAB );
101484 pVtab = pCur->uc.pVCur->pVtab;
101501 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
101527 VdbeCursor *pCur;
101529 pCur = p->apCsr[pOp->p1];
101530 assert( pCur!=0 );
101531 assert( pCur->eCurType==CURTYPE_VTAB );
101532 if( pCur->nullRow ){
101535 pVtab = pCur->uc.pVCur->pVtab;
101545 rc = pModule->xNext(pCur->uc.pVCur);
101548 res = pModule->xEof(pCur->uc.pVCur);
105687 bytecodevtab_cursor *pCur;
105688 pCur = sqlite3_malloc( sizeof(*pCur) );
105689 if( pCur==0 ) return SQLITE_NOMEM;
105690 memset(pCur, 0, sizeof(*pCur));
105691 sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1);
105692 *ppCursor = &pCur->base;
105699 static void bytecodevtabCursorClear(bytecodevtab_cursor *pCur){
105700 sqlite3_free(pCur->zP4);
105701 pCur->zP4 = 0;
105702 sqlite3VdbeMemRelease(&pCur->sub);
105703 sqlite3VdbeMemSetNull(&pCur->sub);
105704 if( pCur->needFinalize ){
105705 sqlite3_finalize(pCur->pStmt);
105707 pCur->pStmt = 0;
105708 pCur->needFinalize = 0;
105709 pCur->zType = 0;
105710 pCur->zSchema = 0;
105711 pCur->zName = 0;
105718 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
105719 bytecodevtabCursorClear(pCur);
105720 sqlite3_free(pCur);
105729 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
105732 if( pCur->zP4 ){
105733 sqlite3_free(pCur->zP4);
105734 pCur->zP4 = 0;
105736 if( pCur->zName ){
105737 pCur->zName = 0;
105738 pCur->zType = 0;
105739 pCur->zSchema = 0;
105742 (Vdbe*)pCur->pStmt,
105743 pCur->showSubprograms ? &pCur->sub : 0,
105745 &pCur->iRowid,
105746 &pCur->iAddr,
105747 &pCur->aOp);
105749 sqlite3VdbeMemSetNull(&pCur->sub);
105750 pCur->aOp = 0;
105760 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
105761 return pCur->aOp==0;
105773 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
105775 Op *pOp = pCur->aOp + pCur->iAddr;
105780 if( i<=2 && pCur->zType==0 ){
105787 pCur->zSchema = db->aDb[iDb].zDbSName;
105791 pCur->zName = pTab->zName;
105792 pCur->zType = "table";
105796 if( pCur->zName==0 ){
105800 pCur->zName = pIdx->zName;
105801 pCur->zType = "index";
105811 sqlite3_result_int(ctx, pCur->iAddr);
105828 if( pCur->zP4==0 ){
105829 pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp);
105832 sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC);
105835 char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4);
105844 Op *aOp = pCur->aOp;
105847 if( pCur->iRowid==pCur->iAddr+1 ){
105872 sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC);
105875 sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC);
105878 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
105892 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
105893 *pRowid = pCur->iRowid;
105908 bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor;
105913 bytecodevtabCursorClear(pCur);
105914 pCur->iRowid = 0;
105915 pCur->iAddr = 0;
105916 pCur->showSubprograms = idxNum==0;
105923 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
105924 pCur->needFinalize = 1;
105927 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
105929 if( pCur->pStmt==0 ){
209705 JsonEachCursor *pCur;
209708 pCur = sqlite3DbMallocZero(pVtab->db, sizeof(*pCur));
209709 if( pCur==0 ) return SQLITE_NOMEM;
209710 pCur->db = pVtab->db;
209711 jsonStringZero(&pCur->path);
209712 *ppCursor = &pCur->base;
209720 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
209721 pCur->bRecursive = 1;
211758 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
211759 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
211765 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
211767 int ii = 1 - pCur->bPoint;
211769 assert( pCur->bPoint || pCur->nPoint );
211770 if( pCur->aNode[ii]==0 ){
211772 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
211773 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
211775 return pCur->aNode[ii];
211782 RtreeCursor *pCur, /* The cursor */
211788 if( pCur->nPoint>=pCur->nPointAlloc ){
211789 int nNew = pCur->nPointAlloc*2 + 8;
211790 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
211792 pCur->aPoint = pNew;
211793 pCur->nPointAlloc = nNew;
211795 i = pCur->nPoint++;
211796 pNew = pCur->aPoint + i;
211803 pParent = pCur->aPoint + j;
211805 rtreeSearchPointSwap(pCur, j, i);
211817 RtreeCursor *pCur, /* The cursor */
211822 pFirst = rtreeSearchPointFirst(pCur);
211823 pCur->anQueue[iLevel]++;
211828 if( pCur->bPoint ){
211830 pNew = rtreeEnqueue(pCur, rScore, iLevel);
211832 ii = (int)(pNew - pCur->aPoint) + 1;
211835 assert( pCur->aNode[ii]==0 );
211836 pCur->aNode[ii] = pCur->aNode[0];
211838 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
211840 pCur->aNode[0] = 0;
211841 *pNew = pCur->sPoint;
211843 pCur->sPoint.rScore = rScore;
211844 pCur->sPoint.iLevel = iLevel;
211845 pCur->bPoint = 1;
211846 return &pCur->sPoint;
211848 return rtreeEnqueue(pCur, rScore, iLevel);
211854 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
211861 printf(" %p\n", pCur->aNode[idx]);
211866 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
211869 if( pCur->bPoint ){
211870 tracePoint(&pCur->sPoint, -1, pCur);
211872 for(ii=0; ii<pCur->nPoint; ii++){
211873 if( ii>0 || pCur->bPoint ) printf(" ");
211874 tracePoint(&pCur->aPoint[ii], ii, pCur);
211932 static int rtreeStepToLeaf(RtreeCursor *pCur){
211934 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
211939 int nConstraint = pCur->nConstraint;
211945 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
211947 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
211956 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
211977 for(ii=0; ii<pCur->nPoint; ii++){
211978 if( pCur->aPoint[ii].id==x.id ){
211989 RTREE_QUEUE_TRACE(pCur, "POP-S:");
211990 rtreeSearchPointPop(pCur);
211993 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
211998 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
212002 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
212003 rtreeSearchPointPop(pCur);
212006 pCur->atEOF = p==0;
257456 stmt_cursor *pCur;
257457 pCur = sqlite3_malloc64( sizeof(*pCur) );
257458 if( pCur==0 ) return SQLITE_NOMEM;
257459 memset(pCur, 0, sizeof(*pCur));
257460 pCur->db = ((stmt_vtab*)p)->db;
257461 *ppCursor = &pCur->base;
257465 static void stmtCsrReset(stmt_cursor *pCur){
257468 for(pRow=pCur->pRow; pRow; pRow=pNext){
257472 pCur->pRow = 0;
257489 stmt_cursor *pCur = (stmt_cursor*)cur;
257490 StmtRow *pNext = pCur->pRow->pNext;
257491 sqlite3_free(pCur->pRow);
257492 pCur->pRow = pNext;
257505 stmt_cursor *pCur = (stmt_cursor*)cur;
257506 StmtRow *pRow = pCur->pRow;
257520 stmt_cursor *pCur = (stmt_cursor*)cur;
257521 *pRowid = pCur->pRow->iRowid;
257530 stmt_cursor *pCur = (stmt_cursor*)cur;
257531 return pCur->pRow==0;
257545 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
257554 stmtCsrReset(pCur);
257555 ppRow = &pCur->pRow;
257556 for(p=sqlite3_next_stmt(pCur->db, 0); p; p=sqlite3_next_stmt(pCur->db, p)){