xref: /third_party/sqlite/src/sqlite3.c

55616 ** The Pager.eState variable stores the current 'state' of a pager. A
55950 ** eState
56139   u8 eState;                  /* Pager state (OPEN, READER, WRITER_LOCKED..) */
56357   assert( p->eState==PAGER_OPEN
56358        || p->eState==PAGER_READER
56359        || p->eState==PAGER_WRITER_LOCKED
56360        || p->eState==PAGER_WRITER_CACHEMOD
56361        || p->eState==PAGER_WRITER_DBMOD
56362        || p->eState==PAGER_WRITER_FINISHED
56363        || p->eState==PAGER_ERROR
56393     assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
56403   switch( p->eState ){
56511       , p->eState==PAGER_OPEN            ? "OPEN" :
56512         p->eState==PAGER_READER          ? "READER" :
56513         p->eState==PAGER_WRITER_LOCKED   ? "WRITER_LOCKED" :
56514         p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
56515         p->eState==PAGER_WRITER_DBMOD    ? "WRITER_DBMOD" :
56516         p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
56517         p->eState==PAGER_ERROR           ? "ERROR" : "?error?"
56773   assert( pPager->eState!=PAGER_ERROR );
57330   assert( pPager->eState==PAGER_READER
57331        || pPager->eState==PAGER_OPEN
57332        || pPager->eState==PAGER_ERROR
57342     pPager->eState = PAGER_OPEN;
57370     if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
57378     assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
57379     pPager->eState = PAGER_OPEN;
57392       pPager->eState = PAGER_OPEN;
57394       pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
57435     pPager->eState = PAGER_ERROR;
57529   **      eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
57533   **      read-transaction, this function is called with eState==PAGER_READER
57537   assert( pPager->eState!=PAGER_ERROR );
57538   if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
57643   pPager->eState = PAGER_READER;
57667   if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
57669     if( pPager->eState>=PAGER_WRITER_LOCKED ){
57674       assert( pPager->eState==PAGER_READER );
57811   assert( pPager->eState>=PAGER_WRITER_CACHEMOD
57812        || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
57814   assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
57900   assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
57911    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
58167   assert( pPager->eState!=PAGER_ERROR );
58168   assert( pPager->eState!=PAGER_READER );
58171    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
58486    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
58536   assert( pPager->eState>=PAGER_READER && !MEMDB );
58761   assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
58798   assert( pPager->eState==PAGER_OPEN );
58851   assert( pPager->eState==PAGER_OPEN );
58922   assert( pPager->eState!=PAGER_ERROR );
58923   assert( pPager->eState>=PAGER_WRITER_LOCKED );
59288     if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
59350   assert( pPager->eState!=PAGER_OPEN );      /* Called only by OP_MaxPgcnt */
59425   assert( pPager->eState>=PAGER_READER );
59426   assert( pPager->eState!=PAGER_WRITER_FINISHED );
59518   assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
59790   assert( pPager->eState==PAGER_WRITER_CACHEMOD
59791        || pPager->eState==PAGER_WRITER_DBMOD
59893   pPager->eState = PAGER_WRITER_DBMOD;
59935   assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
60170      || pPager->eState==PAGER_WRITER_CACHEMOD
60521     pPager->eState = PAGER_READER;     /* Pretend we already have a lock */
60664   assert( pPager->eState==PAGER_OPEN );
60785   assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
60788   if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
60879           pPager->eState = PAGER_OPEN;
60893         ** In order to get pager_unlock() to do this, set Pager.eState to
60906       assert( pPager->eState==PAGER_OPEN );
60969   if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
60977     assert( pPager->eState==PAGER_OPEN );
60979     pPager->eState = PAGER_READER;
61069   assert( pPager->eState>=PAGER_READER );
61174    && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
61189   assert( pPager->eState>=PAGER_READER );
61207       if( pPager->eState>PAGER_READER || pPager->tempFile ){
61342   assert( pPager->eState==PAGER_WRITER_LOCKED );
61405     assert( pPager->eState==PAGER_WRITER_LOCKED );
61406     pPager->eState = PAGER_WRITER_CACHEMOD;
61433   assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
61436   if( pPager->eState==PAGER_READER ){
61472       ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
61479       pPager->eState = PAGER_WRITER_LOCKED;
61486     assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
61487     assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
61563   assert( pPager->eState==PAGER_WRITER_LOCKED
61564        || pPager->eState==PAGER_WRITER_CACHEMOD
61565        || pPager->eState==PAGER_WRITER_DBMOD
61581   if( pPager->eState==PAGER_WRITER_LOCKED ){
61585   assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
61606       if( pPager->eState!=PAGER_WRITER_DBMOD ){
61744   assert( pPager->eState>=PAGER_WRITER_LOCKED );
61827   assert( pPager->eState==PAGER_WRITER_CACHEMOD
61828        || pPager->eState==PAGER_WRITER_DBMOD
61934     assert( pPager->eState==PAGER_WRITER_CACHEMOD
61935          || pPager->eState==PAGER_WRITER_DBMOD
61936          || pPager->eState==PAGER_WRITER_LOCKED
61979   assert( pPager->eState==PAGER_WRITER_LOCKED
61980        || pPager->eState==PAGER_WRITER_CACHEMOD
61981        || pPager->eState==PAGER_WRITER_DBMOD
61982        || pPager->eState==PAGER_ERROR
61996   if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
62166         assert( pPager->eState==PAGER_WRITER_DBMOD );
62181     pPager->eState = PAGER_WRITER_FINISHED;
62211   assert( pPager->eState==PAGER_WRITER_LOCKED
62212        || pPager->eState==PAGER_WRITER_FINISHED
62213        || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
62228   if( pPager->eState==PAGER_WRITER_LOCKED
62233     pPager->eState = PAGER_READER;
62277   if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
62278   if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
62285   }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
62286     int eState = pPager->eState;
62288     if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
62294       pPager->eState = PAGER_ERROR;
62302   assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
62359   a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
62360   a[4] = pPager->eState;
62425   assert( pPager->eState>=PAGER_WRITER_LOCKED );
62466   assert( pPager->eState>=PAGER_WRITER_LOCKED );
62563      && pPager->eState>=PAGER_WRITER_CACHEMOD
62566       pPager->eState = PAGER_ERROR;
62703   assert( pPager->eState==PAGER_WRITER_CACHEMOD
62704        || pPager->eState==PAGER_WRITER_DBMOD
62929     assert( pPager->eState!=PAGER_ERROR );
62958         int state = pPager->eState;
62963         if( pPager->eState==PAGER_READER ){
62975         assert( state==pPager->eState );
63000   if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
63169   assert( pPager->eState==PAGER_OPEN   || pbOpen );
63170   assert( pPager->eState==PAGER_READER || !pbOpen );
63183       pPager->eState = PAGER_OPEN;
63353   assert( pPager->eState>=PAGER_READER );
68080 ** The meaning of skipNext depends on the value of eState:
68082 **   eState            Meaning of skipNext
68088 **                     eState=SKIPNEXT if skipNext!=0
68092   u8 eState;                /* One of the CURSOR_XXX constants (see below) */
68097                    ** Error code if eState==CURSOR_FAULT */
68131 ** Potential values for BtCursor.eState.
69175         p->eState = CURSOR_INVALID;
69273 ** when this function is called (i.e. have eState==CURSOR_VALID). This
69286   assert( CURSOR_VALID==pCur->eState );
69323 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
69329   assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
69336   if( pCur->eState==CURSOR_SKIPNEXT ){
69337     pCur->eState = CURSOR_VALID;
69345     pCur->eState = CURSOR_REQUIRESEEK;
69400       if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
69422   pCur->eState = CURSOR_INVALID;
69470   assert( pCur->eState>=CURSOR_REQUIRESEEK );
69471   if( pCur->eState==CURSOR_FAULT ){
69474   pCur->eState = CURSOR_INVALID;
69483     assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
69485     if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
69486       pCur->eState = CURSOR_SKIPNEXT;
69493   (p->eState>=CURSOR_REQUIRESEEK ? \
69512   assert( offsetof(BtCursor, eState)==0 );
69513   assert( sizeof(pCur->eState)==1 );
69524   assert( offsetof(BtCursor, eState)==0 );
69545   assert( pCur->eState!=CURSOR_VALID );
69551   if( pCur->eState!=CURSOR_VALID ){
72008      && pCur->eState!=CURSOR_FAULT ) r++;
72952         if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
72961         p->eState = CURSOR_FAULT;
73216   pCur->eState = CURSOR_INVALID;
73360   return pCur && pCur->eState==CURSOR_VALID;
73365   return pCur->eState==CURSOR_VALID;
73376   assert( pCur->eState==CURSOR_VALID );
73401   assert( pCur->eState==CURSOR_VALID );
73415 ** that the cursor has Cursor.eState==CURSOR_VALID.
73419   assert( pCur->eState==CURSOR_VALID );
73439   assert( pCur->eState==CURSOR_VALID );
73598   assert( pCur->eState==CURSOR_VALID );
73786   assert( pCur->eState==CURSOR_VALID );
73804   if ( pCur->eState==CURSOR_INVALID ){
73812   if( pCur->eState==CURSOR_VALID ){
73846   assert( pCur->eState==CURSOR_VALID );
73895   assert( pCur->eState==CURSOR_VALID );
73944   assert( pCur->eState==CURSOR_VALID );
73990   assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
74003     pCur->eState = CURSOR_INVALID;
74007     if( pCur->eState>=CURSOR_REQUIRESEEK ){
74008       if( pCur->eState==CURSOR_FAULT ){
74017       pCur->eState = CURSOR_INVALID;
74047     pCur->eState = CURSOR_VALID;
74052     pCur->eState = CURSOR_VALID;
74055     pCur->eState = CURSOR_INVALID;
74074   assert( pCur->eState==CURSOR_VALID );
74099   assert( pCur->eState==CURSOR_VALID );
74145   if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
74164     assert( pCur->eState==CURSOR_VALID );
74215   assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
74219   if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
74263   assert( pCur->eState==CURSOR_VALID );
74400   assert( pCur->eState==CURSOR_VALID );
74470   if( pCur->eState==CURSOR_VALID
74508   assert( pCur->eState==CURSOR_VALID );
74651   return (CURSOR_VALID!=pCur->eState);
74669   if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1;
74705   if( pCur->eState!=CURSOR_VALID ){
74711     if( CURSOR_INVALID==pCur->eState ){
74714     if( pCur->eState==CURSOR_SKIPNEXT ){
74715       pCur->eState = CURSOR_VALID;
74734         pCur->eState = CURSOR_INVALID;
74759   if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
74799   if( pCur->eState!=CURSOR_VALID ){
74804     if( CURSOR_INVALID==pCur->eState ){
74807     if( CURSOR_SKIPNEXT==pCur->eState ){
74808       pCur->eState = CURSOR_VALID;
74823         pCur->eState = CURSOR_INVALID;
74847   if( pCur->eState!=CURSOR_VALID
77353      && pOther->eState==CURSOR_VALID
77674   if( pCur->eState>=CURSOR_REQUIRESEEK ){
77675     testcase( pCur->eState==CURSOR_REQUIRESEEK );
77676     testcase( pCur->eState==CURSOR_FAULT );
77781   assert( pCur->eState==CURSOR_VALID
77782        || (pCur->eState==CURSOR_INVALID && loc) );
77788     if( NEVER(pCur->eState>CURSOR_INVALID) ){
77905     pCur->eState = CURSOR_INVALID;
77917       pCur->eState = CURSOR_REQUIRESEEK;
78074   if( pCur->eState!=CURSOR_VALID ){
78075     if( pCur->eState>=CURSOR_REQUIRESEEK ){
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 );
78236       pCur->eState = CURSOR_SKIPNEXT;
78247         pCur->eState = CURSOR_REQUIRESEEK;
79615   assert( pCsr->eState!=CURSOR_REQUIRESEEK );
79616   if( pCsr->eState!=CURSOR_VALID ){
176359     int eState;                   /* Parser state when parsing URI */
176405     ** Within this loop, variable eState may be set to 0, 1 or 2, depending
176412     eState = 0;
176430               && (eState!=0 || c!='?')
176431               && (eState!=1 || (c!='=' && c!='&'))
176432               && (eState!=2 || c!='&')
176445       }else if( eState==1 && (c=='&' || c=='=') ){
176454           eState = 2;
176457       }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
176459         eState = 1;
176463     if( eState==1 ) zFile[iOut++] = '\0';
186046     int eState = 0;
186066       switch( eState ){
186070           eState = 1;
186087           eState = 2;
186092             eState = 0;
186094             eState = 3;
186102         default: assert( eState==3 );
186110           eState = 2;
233027   int eState;                     /* See above */
233086     if( pCtx->eState==2 ){
233090         pCtx->eState = 1;
233093         pCtx->eState = 0;
233102       if( pCtx->eState ){
233110           pCtx->eState = 2;
233113           pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
233114           if( pCtx->eState ){
233193         sCtx.eState = fts5IndexColsetTest(pColset, 0);
233194         assert( sCtx.eState==0 || sCtx.eState==1 );
236897   int eState;                     /* 0==closed, 1==open, 2==synced */
237085       assert( p->ts.eState==0 );
237086       p->ts.eState = 1;
237091       assert( p->ts.eState==1 || p->ts.eState==2 );
237092       p->ts.eState = 2;
237096       assert( p->ts.eState==2 );
237097       p->ts.eState = 0;
237101       assert( p->ts.eState==1 || p->ts.eState==2 || p->ts.eState==0 );
237102       p->ts.eState = 0;
237106       assert( p->ts.eState>=1 );
237113       assert( p->ts.eState>=1 );
237120       assert( p->ts.eState>=1 );
238456   assert( pTab->ts.eState==1 || pTab->ts.eState==2 );

Indexes created Thu Nov 07 10:32:03 CST 2024