Lines Matching defs:pCur
8745 ** ^The current value of the requested parameter is written into *pCur
8755 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
68581 SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
68582 sqlite3BtreeEnter(pCur->pBtree);
68585 SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
68586 sqlite3BtreeLeave(pCur->pBtree);
69133 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
69260 static void btreeReleaseAllCursorPages(BtCursor *pCur){
69262 if( pCur->iPage>=0 ){
69263 for(i=0; i<pCur->iPage; i++){
69264 releasePageNotNull(pCur->apPage[i]);
69266 releasePageNotNull(pCur->pPage);
69267 pCur->iPage = -1;
69274 ** function saves the current cursor key in variables pCur->nKey and
69275 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
69279 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
69280 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
69281 ** set to point to a malloced buffer pCur->nKey bytes in size containing
69284 static int saveCursorKey(BtCursor *pCur){
69286 assert( CURSOR_VALID==pCur->eState );
69287 assert( 0==pCur->pKey );
69288 assert( cursorHoldsMutex(pCur) );
69290 if( pCur->curIntKey ){
69292 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
69301 pCur->nKey = sqlite3BtreePayloadSize(pCur);
69302 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
69304 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
69306 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
69307 pCur->pKey = pKey;
69315 assert( !pCur->curIntKey || !pCur->pKey );
69326 static int saveCursorPosition(BtCursor *pCur){
69329 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
69330 assert( 0==pCur->pKey );
69331 assert( cursorHoldsMutex(pCur) );
69333 if( pCur->curFlags & BTCF_Pinned ){
69336 if( pCur->eState==CURSOR_SKIPNEXT ){
69337 pCur->eState = CURSOR_VALID;
69339 pCur->skipNext = 0;
69342 rc = saveCursorKey(pCur);
69344 btreeReleaseAllCursorPages(pCur);
69345 pCur->eState = CURSOR_REQUIRESEEK;
69348 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
69418 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
69419 assert( cursorHoldsMutex(pCur) );
69420 sqlite3_free(pCur->pKey);
69421 pCur->pKey = 0;
69422 pCur->eState = CURSOR_INVALID;
69431 BtCursor *pCur, /* Cursor open on the btree to be searched */
69441 KeyInfo *pKeyInfo = pCur->pKeyInfo;
69449 rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes);
69451 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
69454 rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes);
69466 static int btreeRestoreCursorPosition(BtCursor *pCur){
69469 assert( cursorOwnsBtShared(pCur) );
69470 assert( pCur->eState>=CURSOR_REQUIRESEEK );
69471 if( pCur->eState==CURSOR_FAULT ){
69472 return pCur->skipNext;
69474 pCur->eState = CURSOR_INVALID;
69478 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
69481 sqlite3_free(pCur->pKey);
69482 pCur->pKey = 0;
69483 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
69484 if( skipNext ) pCur->skipNext = skipNext;
69485 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
69486 pCur->eState = CURSOR_SKIPNEXT;
69509 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
69510 assert( EIGHT_BYTE_ALIGNMENT(pCur)
69511 || pCur==sqlite3BtreeFakeValidCursor() );
69513 assert( sizeof(pCur->eState)==1 );
69514 return CURSOR_VALID != *(u8*)pCur;
69541 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
69544 assert( pCur!=0 );
69545 assert( pCur->eState!=CURSOR_VALID );
69546 rc = restoreCursorPosition(pCur);
69551 if( pCur->eState!=CURSOR_VALID ){
69565 SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){
69573 SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){
69575 pCur->hints = x;
70886 ** If pCur!=0 then the page is being fetched as part of a moveToChild()
70888 ** And if the fetch fails, this routine must decrement pCur->iPage.
70890 ** The page is fetched as read-write unless pCur is not NULL and is
70900 BtCursor *pCur, /* Cursor to receive the page, or NULL */
70906 assert( pCur==0 || ppPage==&pCur->pPage );
70907 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
70908 assert( pCur==0 || pCur->iPage>0 );
70931 if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
70940 if( pCur ){
70941 pCur->iPage--;
70942 pCur->pPage = pCur->apPage[pCur->iPage];
71415 BtCursor *pCur = pBt->pCursor;
71416 pBt->pCursor = pCur->pNext; /* Unlink the cursor */
71417 memset(pCur, 0, sizeof(*pCur));
71465 BtCursor *pCur = pBt->pCursor;
71466 while( pCur ){
71467 BtCursor *pTmp = pCur;
71468 pCur = pCur->pNext;
72004 BtCursor *pCur;
72006 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
72007 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
72008 && pCur->eState!=CURSOR_FAULT ) r++;
73159 ** on pCur to initialize the memory space prior to invoking this routine.
73166 BtCursor *pCur /* Space for new cursor */
73202 pCur->pgnoRoot = iTable;
73203 pCur->iPage = -1;
73204 pCur->pKeyInfo = pKeyInfo;
73205 pCur->pBtree = p;
73206 pCur->pBt = pBt;
73207 pCur->curFlags = 0;
73213 pCur->curFlags = BTCF_Multiple;
73216 pCur->eState = CURSOR_INVALID;
73217 pCur->pNext = pBt->pCursor;
73218 pBt->pCursor = pCur;
73220 pCur->curFlags |= BTCF_WriteFlag;
73221 pCur->curPagerFlags = 0;
73224 pCur->curPagerFlags = PAGER_GET_READONLY;
73233 BtCursor *pCur /* Space for new cursor */
73237 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
73246 BtCursor *pCur /* Write new cursor here */
73249 return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur);
73251 return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
73283 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
73284 Btree *pBtree = pCur->pBtree;
73286 BtShared *pBt = pCur->pBt;
73289 if( pBt->pCursor==pCur ){
73290 pBt->pCursor = pCur->pNext;
73294 if( pPrev->pNext==pCur ){
73295 pPrev->pNext = pCur->pNext;
73301 btreeReleaseAllCursorPages(pCur);
73303 sqlite3_free(pCur->aOverflow);
73304 sqlite3_free(pCur->pKey);
73313 pCur->pBtree = 0;
73335 static void assertCellInfo(BtCursor *pCur){
73338 btreeParseCell(pCur->pPage, pCur->ix, &info);
73339 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
73344 static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){
73345 if( pCur->info.nSize==0 ){
73346 pCur->curFlags |= BTCF_ValidNKey;
73347 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
73349 assertCellInfo(pCur);
73359 SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
73360 return pCur && pCur->eState==CURSOR_VALID;
73363 SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){
73364 assert( pCur!=0 );
73365 return pCur->eState==CURSOR_VALID;
73374 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){
73375 assert( cursorHoldsMutex(pCur) );
73376 assert( pCur->eState==CURSOR_VALID );
73377 assert( pCur->curIntKey );
73378 getCellInfo(pCur);
73379 return pCur->info.nKey;
73385 SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor *pCur){
73386 assert( (pCur->curFlags & BTCF_Pinned)==0 );
73387 pCur->curFlags |= BTCF_Pinned;
73389 SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor *pCur){
73390 assert( (pCur->curFlags & BTCF_Pinned)!=0 );
73391 pCur->curFlags &= ~BTCF_Pinned;
73399 SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){
73400 assert( cursorHoldsMutex(pCur) );
73401 assert( pCur->eState==CURSOR_VALID );
73402 getCellInfo(pCur);
73403 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
73404 (i64)(pCur->info.pPayload - pCur->pPage->aData);
73409 ** Return the number of bytes of payload for the entry that pCur is
73417 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
73418 assert( cursorHoldsMutex(pCur) );
73419 assert( pCur->eState==CURSOR_VALID );
73420 getCellInfo(pCur);
73421 return pCur->info.nPayload;
73437 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
73438 assert( cursorHoldsMutex(pCur) );
73439 assert( pCur->eState==CURSOR_VALID );
73440 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
73553 ** for the entry that the pCur cursor is pointing to. The eOp
73581 BtCursor *pCur, /* Cursor pointing to entry to read from */
73590 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
73591 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
73598 assert( pCur->eState==CURSOR_VALID );
73599 if( pCur->ix>=pPage->nCell ){
73602 assert( cursorHoldsMutex(pCur) );
73604 getCellInfo(pCur);
73605 aPayload = pCur->info.pPayload;
73606 assert( offset+amt <= pCur->info.nPayload );
73609 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
73612 ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
73619 if( offset<pCur->info.nLocal ){
73621 if( a+offset>pCur->info.nLocal ){
73622 a = pCur->info.nLocal - offset;
73629 offset -= pCur->info.nLocal;
73637 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
73646 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
73647 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
73648 if( pCur->aOverflow==0
73649 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
73652 pCur->aOverflow, nOvfl*2*sizeof(Pgno)
73657 pCur->aOverflow = aNew;
73660 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
73661 pCur->curFlags |= BTCF_ValidOvfl;
73667 if( pCur->aOverflow[offset/ovflSize] ){
73669 nextPage = pCur->aOverflow[iIdx];
73678 assert( pCur->aOverflow[iIdx]==0
73679 || pCur->aOverflow[iIdx]==nextPage
73681 pCur->aOverflow[iIdx] = nextPage;
73690 assert( pCur->curFlags & BTCF_ValidOvfl );
73691 assert( pCur->pBtree->db==pBt->db );
73692 if( pCur->aOverflow[iIdx+1] ){
73693 nextPage = pCur->aOverflow[iIdx+1];
73768 ** Read part of the payload for the row at which that cursor pCur is currently
73772 ** pCur can be pointing to either a table or an index b-tree.
73774 ** pCur is pointing to an index b-tree then the key section is read.
73776 ** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing
73784 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73785 assert( cursorHoldsMutex(pCur) );
73786 assert( pCur->eState==CURSOR_VALID );
73787 assert( pCur->iPage>=0 && pCur->pPage );
73788 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
73798 BtCursor *pCur,
73804 if ( pCur->eState==CURSOR_INVALID ){
73807 assert( cursorOwnsBtShared(pCur) );
73808 rc = btreeRestoreCursorPosition(pCur);
73809 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
73811 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73812 if( pCur->eState==CURSOR_VALID ){
73813 assert( cursorOwnsBtShared(pCur) );
73814 return accessPayload(pCur, offset, amt, pBuf, 0);
73816 return accessPayloadChecked(pCur, offset, amt, pBuf);
73823 ** pCur cursor is pointing to. The pointer is to the beginning of
73841 BtCursor *pCur, /* Cursor pointing to entry to read from */
73845 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
73846 assert( pCur->eState==CURSOR_VALID );
73847 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
73848 assert( cursorOwnsBtShared(pCur) );
73849 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
73850 assert( pCur->info.nSize>0 );
73851 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
73852 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
73853 amt = pCur->info.nLocal;
73854 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
73858 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
73861 return (void*)pCur->info.pPayload;
73866 ** For the entry that cursor pCur is point to, return as
73879 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){
73880 return fetchPayload(pCur, pAmt);
73893 static int moveToChild(BtCursor *pCur, u32 newPgno){
73894 assert( cursorOwnsBtShared(pCur) );
73895 assert( pCur->eState==CURSOR_VALID );
73896 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
73897 assert( pCur->iPage>=0 );
73898 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
73901 pCur->info.nSize = 0;
73902 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
73903 pCur->aiIdx[pCur->iPage] = pCur->ix;
73904 pCur->apPage[pCur->iPage] = pCur->pPage;
73905 pCur->ix = 0;
73906 pCur->iPage++;
73907 return getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur,
73908 pCur->curPagerFlags);
73936 ** pCur->idx is set to the cell index that contains the pointer
73938 ** right-most child page then pCur->idx is set to one more than
73941 static void moveToParent(BtCursor *pCur){
73943 assert( cursorOwnsBtShared(pCur) );
73944 assert( pCur->eState==CURSOR_VALID );
73945 assert( pCur->iPage>0 );
73946 assert( pCur->pPage );
73948 pCur->apPage[pCur->iPage-1],
73949 pCur->aiIdx[pCur->iPage-1],
73950 pCur->pPage->pgno
73952 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
73953 pCur->info.nSize = 0;
73954 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
73955 pCur->ix = pCur->aiIdx[pCur->iPage-1];
73956 pLeaf = pCur->pPage;
73957 pCur->pPage = pCur->apPage[--pCur->iPage];
73982 static int moveToRoot(BtCursor *pCur){
73986 assert( cursorOwnsBtShared(pCur) );
73990 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
73991 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
73993 if( pCur->iPage>=0 ){
73994 if( pCur->iPage ){
73995 releasePageNotNull(pCur->pPage);
73996 while( --pCur->iPage ){
73997 releasePageNotNull(pCur->apPage[pCur->iPage]);
73999 pRoot = pCur->pPage = pCur->apPage[0];
74002 }else if( pCur->pgnoRoot==0 ){
74003 pCur->eState = CURSOR_INVALID;
74006 assert( pCur->iPage==(-1) );
74007 if( pCur->eState>=CURSOR_REQUIRESEEK ){
74008 if( pCur->eState==CURSOR_FAULT ){
74009 assert( pCur->skipNext!=SQLITE_OK );
74010 return pCur->skipNext;
74012 sqlite3BtreeClearCursor(pCur);
74014 rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
74015 0, pCur->curPagerFlags);
74017 pCur->eState = CURSOR_INVALID;
74020 pCur->iPage = 0;
74021 pCur->curIntKey = pCur->pPage->intKey;
74023 pRoot = pCur->pPage;
74024 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
74026 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
74033 ** if pCur->iPage>=0). But this is not so if the database is corrupted
74037 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
74038 return SQLITE_CORRUPT_PAGE(pCur->pPage);
74042 pCur->ix = 0;
74043 pCur->info.nSize = 0;
74044 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
74047 pCur->eState = CURSOR_VALID;
74052 pCur->eState = CURSOR_VALID;
74053 rc = moveToChild(pCur, subpage);
74055 pCur->eState = CURSOR_INVALID;
74068 static int moveToLeftmost(BtCursor *pCur){
74073 assert( cursorOwnsBtShared(pCur) );
74074 assert( pCur->eState==CURSOR_VALID );
74075 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
74076 assert( pCur->ix<pPage->nCell );
74077 pgno = get4byte(findCell(pPage, pCur->ix));
74078 rc = moveToChild(pCur, pgno);
74093 static int moveToRightmost(BtCursor *pCur){
74098 assert( cursorOwnsBtShared(pCur) );
74099 assert( pCur->eState==CURSOR_VALID );
74100 while( !(pPage = pCur->pPage)->leaf ){
74102 pCur->ix = pPage->nCell;
74103 rc = moveToChild(pCur, pgno);
74106 pCur->ix = pPage->nCell-1;
74107 assert( pCur->info.nSize==0 );
74108 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
74116 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
74119 assert( cursorOwnsBtShared(pCur) );
74120 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
74121 rc = moveToRoot(pCur);
74123 assert( pCur->pPage->nCell>0 );
74125 rc = moveToLeftmost(pCur);
74127 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
74138 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
74141 assert( cursorOwnsBtShared(pCur) );
74142 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
74145 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
74150 for(ii=0; ii<pCur->iPage; ii++){
74151 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
74153 assert( pCur->ix==pCur->pPage->nCell-1 || CORRUPT_DB );
74154 testcase( pCur->ix!=pCur->pPage->nCell-1 );
74156 assert( pCur->pPage->leaf );
74162 rc = moveToRoot(pCur);
74164 assert( pCur->eState==CURSOR_VALID );
74166 rc = moveToRightmost(pCur);
74168 pCur->curFlags |= BTCF_AtLast;
74170 pCur->curFlags &= ~BTCF_AtLast;
74173 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
74204 BtCursor *pCur, /* The cursor to be moved */
74211 assert( cursorOwnsBtShared(pCur) );
74212 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
74214 assert( pCur->pKeyInfo==0 );
74215 assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
74219 if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
74220 if( pCur->info.nKey==intKey ){
74224 if( pCur->info.nKey<intKey ){
74225 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
74233 if( pCur->info.nKey+1==intKey ){
74235 rc = sqlite3BtreeNext(pCur, 0);
74237 getCellInfo(pCur);
74238 if( pCur->info.nKey==intKey ){
74249 pCur->pBtree->nSeek++; /* Performance measurement during testing */
74252 rc = moveToRoot(pCur);
74255 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
74261 assert( pCur->pPage );
74262 assert( pCur->pPage->isInit );
74263 assert( pCur->eState==CURSOR_VALID );
74264 assert( pCur->pPage->nCell > 0 );
74265 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
74266 assert( pCur->curIntKey );
74271 MemPage *pPage = pCur->pPage;
74305 pCur->ix = (u16)idx;
74310 pCur->curFlags |= BTCF_ValidNKey;
74311 pCur->info.nKey = nCellKey;
74312 pCur->info.nSize = 0;
74323 assert( pCur->ix<pCur->pPage->nCell );
74324 pCur->ix = (u16)idx;
74335 pCur->ix = (u16)lwr;
74336 rc = moveToChild(pCur, chldPg);
74340 pCur->info.nSize = 0;
74341 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
74346 ** Compare the "idx"-th cell on the page the cursor pCur is currently
74351 ** Return value negative: Cell at pCur[idx] less than pIdxKey
74353 ** Return value is zero: Cell at pCur[idx] equals pIdxKey
74356 ** of the cell at pCur[idx] and pIdxKey.
74362 BtCursor *pCur,
74367 MemPage *pPage = pCur->pPage;
74395 ** Return true (non-zero) if pCur is current pointing to the last
74398 static int cursorOnLastPage(BtCursor *pCur){
74400 assert( pCur->eState==CURSOR_VALID );
74401 for(i=0; i<pCur->iPage; i++){
74402 MemPage *pPage = pCur->apPage[i];
74403 if( pCur->aiIdx[i]<pPage->nCell ) return 0;
74435 BtCursor *pCur, /* The cursor to be moved */
74442 assert( cursorOwnsBtShared(pCur) );
74443 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
74445 assert( pCur->pKeyInfo!=0 );
74448 pCur->pBtree->nSeek++; /* Performance measurement during testing */
74470 if( pCur->eState==CURSOR_VALID
74471 && pCur->pPage->leaf
74472 && cursorOnLastPage(pCur)
74475 if( pCur->ix==pCur->pPage->nCell-1
74476 && (c = indexCellCompare(pCur, pCur->ix, pIdxKey, xRecordCompare))<=0
74482 if( pCur->iPage>0
74483 && indexCellCompare(pCur, 0, pIdxKey, xRecordCompare)<=0
74486 pCur->curFlags &= ~BTCF_ValidOvfl;
74487 if( !pCur->pPage->isInit ){
74495 rc = moveToRoot(pCur);
74498 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
74506 assert( pCur->pPage );
74507 assert( pCur->pPage->isInit );
74508 assert( pCur->eState==CURSOR_VALID );
74509 assert( pCur->pPage->nCell > 0 );
74510 assert( pCur->curIntKey==0 );
74515 MemPage *pPage = pCur->pPage;
74568 pPage->xParseCell(pPage, pCellBody, &pCur->info);
74569 nCell = (int)pCur->info.nKey;
74574 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
74583 pCur->ix = (u16)idx;
74584 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
74586 pCur->curFlags &= ~BTCF_ValidOvfl;
74596 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
74606 pCur->ix = (u16)idx;
74617 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
74618 pCur->ix = (u16)idx;
74628 pCur->ix = (u16)lwr;
74629 rc = moveToChild(pCur, chldPg);
74633 pCur->info.nSize = 0;
74634 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
74646 SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
74651 return (CURSOR_VALID!=pCur->eState);
74655 ** Return an estimate for the number of rows in the table that pCur is
74659 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){
74663 assert( cursorOwnsBtShared(pCur) );
74664 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
74669 if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
74670 if( NEVER(pCur->pPage->leaf==0) ) return -1;
74672 n = pCur->pPage->nCell;
74673 for(i=0; i<pCur->iPage; i++){
74674 n *= pCur->apPage[i]->nCell;
74699 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
74704 assert( cursorOwnsBtShared(pCur) );
74705 if( pCur->eState!=CURSOR_VALID ){
74706 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
74707 rc = restoreCursorPosition(pCur);
74711 if( CURSOR_INVALID==pCur->eState ){
74714 if( pCur->eState==CURSOR_SKIPNEXT ){
74715 pCur->eState = CURSOR_VALID;
74716 if( pCur->skipNext>0 ) return SQLITE_OK;
74720 pPage = pCur->pPage;
74721 idx = ++pCur->ix;
74728 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
74730 return moveToLeftmost(pCur);
74733 if( pCur->iPage==0 ){
74734 pCur->eState = CURSOR_INVALID;
74737 moveToParent(pCur);
74738 pPage = pCur->pPage;
74739 }while( pCur->ix>=pPage->nCell );
74741 return sqlite3BtreeNext(pCur, 0);
74749 return moveToLeftmost(pCur);
74752 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
74755 assert( cursorOwnsBtShared(pCur) );
74757 pCur->info.nSize = 0;
74758 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
74759 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
74760 pPage = pCur->pPage;
74761 if( (++pCur->ix)>=pPage->nCell ){
74762 pCur->ix--;
74763 return btreeNext(pCur);
74768 return moveToLeftmost(pCur);
74792 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
74796 assert( cursorOwnsBtShared(pCur) );
74797 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
74798 assert( pCur->info.nSize==0 );
74799 if( pCur->eState!=CURSOR_VALID ){
74800 rc = restoreCursorPosition(pCur);
74804 if( CURSOR_INVALID==pCur->eState ){
74807 if( CURSOR_SKIPNEXT==pCur->eState ){
74808 pCur->eState = CURSOR_VALID;
74809 if( pCur->skipNext<0 ) return SQLITE_OK;
74813 pPage = pCur->pPage;
74816 int idx = pCur->ix;
74817 rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
74819 rc = moveToRightmost(pCur);
74821 while( pCur->ix==0 ){
74822 if( pCur->iPage==0 ){
74823 pCur->eState = CURSOR_INVALID;
74826 moveToParent(pCur);
74828 assert( pCur->info.nSize==0 );
74829 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
74831 pCur->ix--;
74832 pPage = pCur->pPage;
74834 rc = sqlite3BtreePrevious(pCur, 0);
74841 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
74842 assert( cursorOwnsBtShared(pCur) );
74845 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
74846 pCur->info.nSize = 0;
74847 if( pCur->eState!=CURSOR_VALID
74848 || pCur->ix==0
74849 || pCur->pPage->leaf==0
74851 return btreePrevious(pCur);
74853 pCur->ix--;
77339 ** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid
77340 ** on the same B-tree as pCur.
77349 static int anotherValidCursor(BtCursor *pCur){
77351 for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
77352 if( pOther!=pCur
77354 && pOther->pPage==pCur->pPage
77363 ** The page that pCur currently points to has just been modified in
77372 static int balance(BtCursor *pCur){
77382 MemPage *pPage = pCur->pPage;
77385 if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
77391 }else if( (iPage = pCur->iPage)==0 ){
77392 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
77400 rc = balance_deeper(pPage, &pCur->apPage[1]);
77402 pCur->iPage = 1;
77403 pCur->ix = 0;
77404 pCur->aiIdx[0] = 0;
77405 pCur->apPage[0] = pPage;
77406 pCur->pPage = pCur->apPage[1];
77407 assert( pCur->pPage->nOverflow );
77418 MemPage * const pParent = pCur->apPage[iPage-1];
77419 int const iIdx = pCur->aiIdx[iPage-1];
77469 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
77471 pCur->hints&BTREE_BULKLOAD);
77491 pCur->iPage--;
77492 assert( pCur->iPage>=0 );
77493 pCur->pPage = pCur->apPage[pCur->iPage];
77546 ** Overwrite the cell that cursor pCur is pointing to with fresh content
77549 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
77553 MemPage *pPage = pCur->pPage; /* Page being written */
77558 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
77559 || pCur->info.pPayload < pPage->aData + pPage->cellOffset
77564 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
77565 0, pCur->info.nLocal);
77567 if( pCur->info.nLocal==nTotal ) return SQLITE_OK;
77570 iOffset = pCur->info.nLocal;
77573 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
77600 ** is described by the pX object. The pCur cursor is used only to
77614 ** sqlite3BtreeIndexMoveto() to seek cursor pCur to (pKey,nKey) has already
77617 ** to be inserted. If seekResult<0 then pCur points to a cell that is
77618 ** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell
77621 ** If seekResult==0, that means pCur is pointing at some unknown location.
77629 BtCursor *pCur, /* Insert data into the table of this cursor */
77639 Btree *p = pCur->pBtree;
77645 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
77658 if( pCur->curFlags & BTCF_Multiple ){
77659 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
77661 if( loc && pCur->iPage<0 ){
77674 if( pCur->eState>=CURSOR_REQUIRESEEK ){
77675 testcase( pCur->eState==CURSOR_REQUIRESEEK );
77676 testcase( pCur->eState==CURSOR_FAULT );
77677 rc = moveToRoot(pCur);
77681 assert( cursorOwnsBtShared(pCur) );
77682 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
77685 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
77692 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
77694 if( pCur->pKeyInfo==0 ){
77699 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
77707 assert( pCur->curFlags & BTCF_ValidNKey );
77708 assert( pX->nKey==pCur->info.nKey );
77717 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
77721 if( pCur->info.nSize!=0
77722 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
77725 return btreeOverwriteCell(pCur, pX);
77733 rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
77753 r.pKeyInfo = pCur->pKeyInfo;
77758 rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc);
77760 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
77771 getCellInfo(pCur);
77772 if( pCur->info.nKey==pX->nKey ){
77777 return btreeOverwriteCell(pCur, &x2);
77781 assert( pCur->eState==CURSOR_VALID
77782 || (pCur->eState==CURSOR_INVALID && loc) );
77784 pPage = pCur->pPage;
77788 if( NEVER(pCur->eState>CURSOR_INVALID) ){
77798 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
77821 idx = pCur->ix;
77837 testcase( pCur->curFlags & BTCF_ValidOvfl );
77838 invalidateOverflowCache(pCur);
77865 idx = ++pCur->ix;
77866 pCur->curFlags &= ~BTCF_ValidNKey;
77894 pCur->info.nSize = 0;
77897 pCur->curFlags &= ~(BTCF_ValidNKey);
77898 rc = balance(pCur);
77904 pCur->pPage->nOverflow = 0;
77905 pCur->eState = CURSOR_INVALID;
77907 btreeReleaseAllCursorPages(pCur);
77908 if( pCur->pKeyInfo ){
77909 assert( pCur->pKey==0 );
77910 pCur->pKey = sqlite3Malloc( pX->nKey );
77911 if( pCur->pKey==0 ){
77914 memcpy(pCur->pKey, pX->pKey, pX->nKey);
77917 pCur->eState = CURSOR_REQUIRESEEK;
77918 pCur->nKey = pX->nKey;
77921 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
78056 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
78057 Btree *p = pCur->pBtree;
78067 assert( cursorOwnsBtShared(pCur) );
78070 assert( pCur->curFlags & BTCF_WriteFlag );
78071 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
78072 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
78074 if( pCur->eState!=CURSOR_VALID ){
78075 if( pCur->eState>=CURSOR_REQUIRESEEK ){
78076 rc = btreeRestoreCursorPosition(pCur);
78077 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
78078 if( rc || pCur->eState!=CURSOR_VALID ) return rc;
78083 assert( pCur->eState==CURSOR_VALID );
78085 iCellDepth = pCur->iPage;
78086 iCellIdx = pCur->ix;
78087 pPage = pCur->pPage;
78121 rc = saveCursorKey(pCur);
78136 rc = sqlite3BtreePrevious(pCur, 0);
78143 if( pCur->curFlags & BTCF_Multiple ){
78144 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
78150 if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
78151 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
78169 MemPage *pLeaf = pCur->pPage;
78178 if( iCellDepth<pCur->iPage-1 ){
78179 n = pCur->apPage[iCellDepth+1]->pgno;
78181 n = pCur->pPage->pgno;
78203 ** pCur is pointing to the leaf page from which a cell was removed to
78212 assert( pCur->pPage->nOverflow==0 );
78213 assert( pCur->pPage->nFree>=0 );
78214 if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
78219 rc = balance(pCur);
78221 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
78222 releasePageNotNull(pCur->pPage);
78223 pCur->iPage--;
78224 while( pCur->iPage>iCellDepth ){
78225 releasePage(pCur->apPage[pCur->iPage--]);
78227 pCur->pPage = pCur->apPage[pCur->iPage];
78228 rc = balance(pCur);
78233 assert( (pCur->iPage==iCellDepth || CORRUPT_DB) );
78234 assert( pPage==pCur->pPage || CORRUPT_DB );
78236 pCur->eState = CURSOR_SKIPNEXT;
78238 pCur->skipNext = -1;
78239 pCur->ix = pPage->nCell-1;
78241 pCur->skipNext = 1;
78244 rc = moveToRoot(pCur);
78246 btreeReleaseAllCursorPages(pCur);
78247 pCur->eState = CURSOR_REQUIRESEEK;
78512 ** Delete all information from the single table that pCur is open on.
78514 ** This routine only work for pCur on an ephemeral table.
78516 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){
78517 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
78709 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
78716 SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3 *db, BtCursor *pCur, i64 *pnEntry){
78720 rc = moveToRoot(pCur);
78737 pPage = pCur->pPage;
78745 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
78754 if( pCur->iPage==0 ){
78757 return moveToRoot(pCur);
78759 moveToParent(pCur);
78760 }while ( pCur->ix>=pCur->pPage->nCell );
78762 pCur->ix++;
78763 pPage = pCur->pPage;
78769 iIdx = pCur->ix;
78771 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
78773 rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
79653 SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){
79654 pCur->curFlags |= BTCF_Incrblob;
79655 pCur->pBtree->hasIncrblobCur = 1;
81782 ** The data is payload from the entry that pCur is currently pointing
81796 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
81803 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
81807 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
81819 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
81826 assert( sqlite3BtreeCursorIsValid(pCur) );
81832 pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
81839 rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem);
87502 ** pCur points at an index entry created using the OP_MakeRecord opcode.
87506 ** pCur might be pointing to text obtained from a corrupt database file.
87509 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
87522 assert( sqlite3BtreeCursorIsValid(pCur) );
87523 nCellKey = sqlite3BtreePayloadSize(pCur);
87528 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
87596 BtCursor *pCur;
87600 pCur = pC->uc.pCursor;
87601 assert( sqlite3BtreeCursorIsValid(pCur) );
87602 nCellKey = sqlite3BtreePayloadSize(pCur);
87610 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
94529 VdbeCursor *pCur;
94534 pCur = p->apCsr[pOp->p1];
94535 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
94536 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
94537 assert( pCur->eCurType==CURTYPE_BTREE );
94538 sqlite3BtreeClearCursor(pCur->uc.pCursor);
94601 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
94602 if( pCur==0 ) goto no_mem;
94603 pCur->iDb = iDb;
94604 pCur->nullRow = 1;
94605 pCur->isOrdered = 1;
94606 pCur->pgnoRoot = p2;
94608 pCur->wrFlag = wrFlag;
94610 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
94611 pCur->pKeyInfo = pKeyInfo;
94616 pCur->isTable = pOp->p4type!=P4_KEYINFO;
94623 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
95397 VdbeCursor *pCur;
95400 pCur = p->apCsr[pOp->p1];
95401 VdbeBranchTaken(pCur==0 || pCur->nullRow, 2);
95402 if( pCur==0 || pCur->nullRow ){
96956 BtCursor *pCur;
96960 pCur = pC->uc.pCursor;
96961 assert( sqlite3BtreeCursorIsValid(pCur) );
96962 nCellKey = sqlite3BtreePayloadSize(pCur);
96970 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
98354 VdbeCursor *pCur;
98360 pCur = 0;
98376 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
98377 if( pCur ){
98378 pCur->uc.pVCur = pVCur;
98445 VdbeCursor *pCur;
98452 pCur = p->apCsr[pOp->p1];
98455 assert( pCur!=0 );
98456 assert( pCur->eCurType==CURTYPE_VTAB );
98457 pVCur = pCur->uc.pVCur;
98475 pCur->nullRow = 0;
98503 VdbeCursor *pCur = p->apCsr[pOp->p1];
98504 assert( pCur!=0 );
98508 if( pCur->nullRow ){
98512 assert( pCur->eCurType==CURTYPE_VTAB );
98513 pVtab = pCur->uc.pVCur->pVtab;
98527 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
98553 VdbeCursor *pCur;
98555 pCur = p->apCsr[pOp->p1];
98556 assert( pCur!=0 );
98557 assert( pCur->eCurType==CURTYPE_VTAB );
98558 if( pCur->nullRow ){
98561 pVtab = pCur->uc.pVCur->pVtab;
98571 rc = pModule->xNext(pCur->uc.pVCur);
98574 res = pModule->xEof(pCur->uc.pVCur);
102657 bytecodevtab_cursor *pCur;
102658 pCur = sqlite3_malloc( sizeof(*pCur) );
102659 if( pCur==0 ) return SQLITE_NOMEM;
102660 memset(pCur, 0, sizeof(*pCur));
102661 sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1);
102662 *ppCursor = &pCur->base;
102669 static void bytecodevtabCursorClear(bytecodevtab_cursor *pCur){
102670 sqlite3_free(pCur->zP4);
102671 pCur->zP4 = 0;
102672 sqlite3VdbeMemRelease(&pCur->sub);
102673 sqlite3VdbeMemSetNull(&pCur->sub);
102674 if( pCur->needFinalize ){
102675 sqlite3_finalize(pCur->pStmt);
102677 pCur->pStmt = 0;
102678 pCur->needFinalize = 0;
102679 pCur->zType = 0;
102680 pCur->zSchema = 0;
102681 pCur->zName = 0;
102688 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
102689 bytecodevtabCursorClear(pCur);
102690 sqlite3_free(pCur);
102699 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
102702 if( pCur->zP4 ){
102703 sqlite3_free(pCur->zP4);
102704 pCur->zP4 = 0;
102706 if( pCur->zName ){
102707 pCur->zName = 0;
102708 pCur->zType = 0;
102709 pCur->zSchema = 0;
102712 (Vdbe*)pCur->pStmt,
102713 pCur->showSubprograms ? &pCur->sub : 0,
102715 &pCur->iRowid,
102716 &pCur->iAddr,
102717 &pCur->aOp);
102719 sqlite3VdbeMemSetNull(&pCur->sub);
102720 pCur->aOp = 0;
102730 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
102731 return pCur->aOp==0;
102743 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
102745 Op *pOp = pCur->aOp + pCur->iAddr;
102750 if( i<=2 && pCur->zType==0 ){
102757 pCur->zSchema = db->aDb[iDb].zDbSName;
102761 pCur->zName = pTab->zName;
102762 pCur->zType = "table";
102766 if( pCur->zName==0 ){
102770 pCur->zName = pIdx->zName;
102771 pCur->zType = "index";
102781 sqlite3_result_int(ctx, pCur->iAddr);
102798 if( pCur->zP4==0 ){
102799 pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp);
102802 sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC);
102805 char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4);
102814 Op *aOp = pCur->aOp;
102817 if( pCur->iRowid==pCur->iAddr+1 ){
102827 sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC);
102830 sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC);
102833 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
102847 bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur;
102848 *pRowid = pCur->iRowid;
102863 bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor;
102867 bytecodevtabCursorClear(pCur);
102868 pCur->iRowid = 0;
102869 pCur->iAddr = 0;
102870 pCur->showSubprograms = idxNum==0;
102877 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
102878 pCur->needFinalize = 1;
102881 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
102883 if( pCur->pStmt==0 ){
200430 JsonEachCursor *pCur;
200433 pCur = sqlite3_malloc( sizeof(*pCur) );
200434 if( pCur==0 ) return SQLITE_NOMEM;
200435 memset(pCur, 0, sizeof(*pCur));
200436 *ppCursor = &pCur->base;
200444 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
200445 pCur->bRecursive = 1;
202381 static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){
202382 return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0;
202388 static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
202390 int ii = 1 - pCur->bPoint;
202392 assert( pCur->bPoint || pCur->nPoint );
202393 if( pCur->aNode[ii]==0 ){
202395 id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
202396 *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
202398 return pCur->aNode[ii];
202405 RtreeCursor *pCur, /* The cursor */
202411 if( pCur->nPoint>=pCur->nPointAlloc ){
202412 int nNew = pCur->nPointAlloc*2 + 8;
202413 pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
202415 pCur->aPoint = pNew;
202416 pCur->nPointAlloc = nNew;
202418 i = pCur->nPoint++;
202419 pNew = pCur->aPoint + i;
202426 pParent = pCur->aPoint + j;
202428 rtreeSearchPointSwap(pCur, j, i);
202440 RtreeCursor *pCur, /* The cursor */
202445 pFirst = rtreeSearchPointFirst(pCur);
202446 pCur->anQueue[iLevel]++;
202451 if( pCur->bPoint ){
202453 pNew = rtreeEnqueue(pCur, rScore, iLevel);
202455 ii = (int)(pNew - pCur->aPoint) + 1;
202458 assert( pCur->aNode[ii]==0 );
202459 pCur->aNode[ii] = pCur->aNode[0];
202461 nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
202463 pCur->aNode[0] = 0;
202464 *pNew = pCur->sPoint;
202466 pCur->sPoint.rScore = rScore;
202467 pCur->sPoint.iLevel = iLevel;
202468 pCur->bPoint = 1;
202469 return &pCur->sPoint;
202471 return rtreeEnqueue(pCur, rScore, iLevel);
202477 static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){
202484 printf(" %p\n", pCur->aNode[idx]);
202489 static void traceQueue(RtreeCursor *pCur, const char *zPrefix){
202492 if( pCur->bPoint ){
202493 tracePoint(&pCur->sPoint, -1, pCur);
202495 for(ii=0; ii<pCur->nPoint; ii++){
202496 if( ii>0 || pCur->bPoint ) printf(" ");
202497 tracePoint(&pCur->aPoint[ii], ii, pCur);
202550 ** Continue the search on cursor pCur until the front of the queue
202555 static int rtreeStepToLeaf(RtreeCursor *pCur){
202557 Rtree *pRtree = RTREE_OF_CURSOR(pCur);
202562 int nConstraint = pCur->nConstraint;
202568 while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){
202570 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
202579 RtreeConstraint *pConstraint = pCur->aConstraint + ii;
202600 for(ii=0; ii<pCur->nPoint; ii++){
202601 if( pCur->aPoint[ii].id==x.id ){
202612 RTREE_QUEUE_TRACE(pCur, "POP-S:");
202613 rtreeSearchPointPop(pCur);
202616 p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
202621 RTREE_QUEUE_TRACE(pCur, "PUSH-S:");
202625 RTREE_QUEUE_TRACE(pCur, "POP-Se:");
202626 rtreeSearchPointPop(pCur);
202629 pCur->atEOF = p==0;
244387 stmt_cursor *pCur;
244388 pCur = sqlite3_malloc64( sizeof(*pCur) );
244389 if( pCur==0 ) return SQLITE_NOMEM;
244390 memset(pCur, 0, sizeof(*pCur));
244391 pCur->db = ((stmt_vtab*)p)->db;
244392 *ppCursor = &pCur->base;
244396 static void stmtCsrReset(stmt_cursor *pCur){
244399 for(pRow=pCur->pRow; pRow; pRow=pNext){
244403 pCur->pRow = 0;
244420 stmt_cursor *pCur = (stmt_cursor*)cur;
244421 StmtRow *pNext = pCur->pRow->pNext;
244422 sqlite3_free(pCur->pRow);
244423 pCur->pRow = pNext;
244436 stmt_cursor *pCur = (stmt_cursor*)cur;
244437 StmtRow *pRow = pCur->pRow;
244451 stmt_cursor *pCur = (stmt_cursor*)cur;
244452 *pRowid = pCur->pRow->iRowid;
244461 stmt_cursor *pCur = (stmt_cursor*)cur;
244462 return pCur->pRow==0;
244476 stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
244481 stmtCsrReset(pCur);
244482 ppRow = &pCur->pRow;
244483 for(p=sqlite3_next_stmt(pCur->db, 0); p; p=sqlite3_next_stmt(pCur->db, p)){