Lines Matching refs:assert
13285 # define ALWAYS(X) ((X)?1:(assert(0),0))
13286 # define NEVER(X) ((X)?(assert(0),1):0)
13317 # define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)
20605 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusValue()
20606 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusValue()
20607 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusValue()
20625 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusUp()
20626 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusUp()
20627 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusUp()
20636 assert( N>=0 ); in sqlite3StatusDown()
20637 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusDown()
20638 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusDown()
20640 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusDown()
20651 assert( X>=0 ); in sqlite3StatusHighwater()
20653 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusHighwater()
20654 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusHighwater()
20655 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusHighwater()
20657 assert( op==SQLITE_STATUS_MALLOC_SIZE in sqlite3StatusHighwater()
20767 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); in sqlite3_db_status()
20768 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); in sqlite3_db_status()
20882 assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 ); in sqlite3_db_status()
20883 assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 ); in sqlite3_db_status()
21041 assert( zFormat[2]>='a' && zFormat[2]<='f' ); in getDigits()
22388 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
22393 assert( dirSync==0 || dirSync==1 ); in sqlite3OsDelete()
22479 assert( pFile ); in sqlite3OsCloseFree()
22532 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ); in vfsUnlink()
22573 assert(vfsList); in sqlite3_vfs_register()
22887 assert( nByte>0 ); in sqlite3MemMalloc()
22914 assert( pPrior!=0 ); in sqlite3MemFree()
22926 assert( pPrior!=0 ); in sqlite3MemSize()
22930 assert( pPrior!=0 ); in sqlite3MemSize()
22959 assert( pPrior!=0 && nByte>0 ); in sqlite3MemRealloc()
22960 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
23183 assert( mem.nCurrent[i]>=0 ); in adjustStats()
23201 assert( p->iForeGuard==(int)FOREGUARD ); in sqlite3MemsysGetHeader()
23205 assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); in sqlite3MemsysGetHeader()
23210 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); in sqlite3MemsysGetHeader()
23231 assert( (sizeof(struct MemBlockHdr)&7) == 0 ); in sqlite3MemInit()
23292 assert( mem.disallow==0 ); in sqlite3MemMalloc()
23317 assert(pBt[0]); in sqlite3MemMalloc()
23346 assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 in sqlite3MemFree()
23353 assert( pHdr->pPrev->pNext==pHdr ); in sqlite3MemFree()
23356 assert( mem.pFirst==pHdr ); in sqlite3MemFree()
23360 assert( pHdr->pNext->pPrev==pHdr ); in sqlite3MemFree()
23363 assert( mem.pLast==pHdr ); in sqlite3MemFree()
23387 assert( mem.disallow==0 ); in sqlite3MemRealloc()
23388 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
23426 assert( pHdr->iForeGuard==FOREGUARD ); in sqlite3MemdebugSetType()
23445 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugHasType()
23467 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugNoType()
23722 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3UnlinkFromList()
23741 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Unlink()
23742 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Unlink()
23743 assert( i>=1 ); in memsys3Unlink()
23745 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Unlink()
23746 assert( size>=2 ); in memsys3Unlink()
23760 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3LinkIntoList()
23775 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Link()
23776 assert( i>=1 ); in memsys3Link()
23777 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Link()
23779 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Link()
23780 assert( size>=2 ); in memsys3Link()
23810 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3OutOfMemory()
23826 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Checkout()
23827 assert( i>=1 ); in memsys3Checkout()
23828 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); in memsys3Checkout()
23829 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); in memsys3Checkout()
23843 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FromMaster()
23844 assert( mem3.szMaster>=nBlock ); in memsys3FromMaster()
23856 assert( newi > mem3.iMaster+1 ); in memsys3FromMaster()
23890 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Merge()
23894 assert( (size&1)==0 ); in memsys3Merge()
23897 assert( i > mem3.aPool[i-1].u.hdr.prevSize ); in memsys3Merge()
23931 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3MallocUnsafe()
23932 assert( sizeof(Mem3Block)==8 ); in memsys3MallocUnsafe()
23938 assert( nBlock>=2 ); in memsys3MallocUnsafe()
24012 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FreeUnsafe()
24013 assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); in memsys3FreeUnsafe()
24015 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); in memsys3FreeUnsafe()
24017 assert( i+size<=mem3.nPool+1 ); in memsys3FreeUnsafe()
24051 assert( p!=0 ); in memsys3Size()
24053 assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); in memsys3Size()
24073 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ in memsys3Malloc()
24084 assert( pPrior ); in memsys3Free()
24131 assert( sizeof(Mem3Block)==8 ); in memsys3Init()
24182 assert( 0 ); in sqlite3Memsys3Dump()
24187 assert( 0 ); in sqlite3Memsys3Dump()
24192 assert( 0 ); in sqlite3Memsys3Dump()
24413 assert( i>=0 && i<mem5.nBlock ); in memsys5Unlink()
24414 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Unlink()
24415 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Unlink()
24435 assert( sqlite3_mutex_held(mem5.mutex) ); in memsys5Link()
24436 assert( i>=0 && i<mem5.nBlock ); in memsys5Link()
24437 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Link()
24438 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Link()
24443 assert( x<mem5.nBlock ); in memsys5Link()
24465 assert( p!=0 ); in memsys5Size()
24467 assert( i>=0 && i<mem5.nBlock ); in memsys5Size()
24489 assert( nByte>0 ); in memsys5MallocUnsafe()
24562 assert( iBlock>=0 && iBlock<mem5.nBlock ); in memsys5FreeUnsafe()
24563 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 ); in memsys5FreeUnsafe()
24564 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 ); in memsys5FreeUnsafe()
24568 assert( iBlock+size-1<(u32)mem5.nBlock ); in memsys5FreeUnsafe()
24574 assert( mem5.currentCount>0 ); in memsys5FreeUnsafe()
24575 assert( mem5.currentOut>=(size*mem5.szAtom) ); in memsys5FreeUnsafe()
24578 assert( mem5.currentOut>0 || mem5.currentCount==0 ); in memsys5FreeUnsafe()
24579 assert( mem5.currentCount>0 || mem5.currentOut==0 ); in memsys5FreeUnsafe()
24587 assert( iBuddy>=0 ); in memsys5FreeUnsafe()
24635 assert( pPrior!=0 ); in memsys5Free()
24656 assert( pPrior!=0 ); in memsys5Realloc()
24657 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ in memsys5Realloc()
24658 assert( nBytes>=0 ); in memsys5Realloc()
24727 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 ); in memsys5Init()
24731 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */ in memsys5Init()
24756 assert((iOffset+nAlloc)>mem5.nBlock); in memsys5Init()
24941 assert( SQLITE_MUTEX_RECURSIVE==1 && SQLITE_MUTEX_FAST==0 ); in checkMutexAlloc()
24973 assert( SQLITE_MUTEX_RECURSIVE<2 ); in checkMutexFree()
24974 assert( SQLITE_MUTEX_FAST<2 ); in checkMutexFree()
24975 assert( SQLITE_MUTEX_WARNONCONTENTION<2 ); in checkMutexFree()
25051 assert( pCheck->iType==SQLITE_MUTEX_RECURSIVE ); in sqlite3MutexWarnOnContention()
25091 assert( sqlite3GlobalConfig.mutex.xMutexInit ); in sqlite3MutexInit()
25126 assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); in sqlite3_mutex_alloc()
25134 assert( GLOBAL(int, mutexIsInit) ); in sqlite3MutexAlloc()
25135 assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); in sqlite3MutexAlloc()
25144 assert( sqlite3GlobalConfig.mutex.xMutexFree ); in sqlite3_mutex_free()
25155 assert( sqlite3GlobalConfig.mutex.xMutexEnter ); in sqlite3_mutex_enter()
25167 assert( sqlite3GlobalConfig.mutex.xMutexTry ); in sqlite3_mutex_try()
25181 assert( sqlite3GlobalConfig.mutex.xMutexLeave ); in sqlite3_mutex_leave()
25192 assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld ); in sqlite3_mutex_held()
25196 assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld ); in sqlite3_mutex_notheld()
25346 assert( p->cnt==0 ); in debugMutexFree()
25369 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexEnter()
25374 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexTry()
25387 assert( debugMutexHeld(pX) ); in debugMutexLeave()
25389 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexLeave()
25635 assert( p==0 || p->id==iType ); in pthreadMutexAlloc()
25647 assert( p->nRef==0 ); in pthreadMutexFree()
25674 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexEnter()
25693 assert( p->nRef==0 ); in pthreadMutexEnter()
25703 assert( p->nRef>0 || p->owner==0 ); in pthreadMutexEnter()
25717 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexTry()
25736 assert( p->nRef==0 ); in pthreadMutexTry()
25773 assert( pthreadMutexHeld(p) ); in pthreadMutexLeave()
25778 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexLeave()
26359 assert( p==0 || p->id==iType );
26370 assert( p );
26371 assert( p->nRef==0 && p->owner==0 );
26398 assert( p );
26399 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
26401 assert( p );
26403 assert( winMutex_isInit==1 );
26406 assert( p->nRef>0 || p->owner==0 );
26421 assert( p );
26422 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
26435 assert( winMutex_isInit==1 );
26436 assert( winMutex_isNt>=-1 && winMutex_isNt<=1 );
26440 assert( winMutex_isNt==0 || winMutex_isNt==1 );
26470 assert( p );
26472 assert( p->nRef>0 );
26473 assert( p->owner==tid );
26476 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
26478 assert( winMutex_isInit==1 );
26694 assert( sqlite3_mutex_held(mem0.mutex) );
26695 assert( n>0 );
26756 assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */
26794 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
26798 assert( p!=0 );
26802 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
26803 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
26805 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
26806 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
26811 assert( sqlite3_mutex_held(db->mutex) );
26816 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
26817 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
26826 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
26827 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
26853 assert( db==0 || sqlite3_mutex_held(db->mutex) );
26854 assert( p!=0 );
26871 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
26872 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
26873 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
26878 assert( db==0 || sqlite3_mutex_held(db->mutex) );
26888 assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
26889 assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
26929 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
26981 assert( db!=0 );
27021 assert( db!=0 );
27022 assert( sqlite3_mutex_held(db->mutex) );
27023 assert( db->pnBytesFreed==0 );
27025 assert( db->mallocFailed==0 );
27043 assert( db!=0 );
27044 assert( sqlite3_mutex_held(db->mutex) );
27045 assert( db->pnBytesFreed==0 );
27061 assert( db!=0 );
27063 assert( sqlite3_mutex_held(db->mutex) );
27069 assert( db!=0 );
27070 assert( p!=0 );
27079 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
27080 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
27128 assert( db!=0 );
27132 assert( (n&0x7fffffff)==n );
27192 assert( db->lookaside.bDisable>0 );
27223 assert( db!=0 );
27224 assert( sqlite3_mutex_held(db->mutex) );
27369 assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG );
27467 assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
27832 assert( precision>0 );
27842 assert( bufpt>zOut );
27968 assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
28052 assert( bArgList==0 );
28067 assert( bArgList==0 );
28068 assert( k>=0 && k<pSrc->nSrc );
28078 assert( xtype==etINVALID );
28115 assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
28146 assert( p->zText!=0 || p->nChar==0 );
28192 assert( z!=0 || N==0 );
28193 assert( p->zText!=0 || p->nChar==0 || p->accError );
28194 assert( N>=0 );
28195 assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
28199 assert( p->zText );
28220 assert( p->mxAlloc>0 && !isMalloced(p) );
28338 assert( db!=0 );
28551 assert( moreToFollow==0 || moreToFollow==1 );
28585 assert( acc.nChar>0 );
29031 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
29032 assert( pExpr->pRight );
29033 assert( pExpr->pRight->op==TK_TRUEFALSE );
29342 assert( N>0 );
29442 assert( ppThread!=0 );
29443 assert( xTask!=0 );
29445 assert( sqlite3GlobalConfig.bCoreMutex!=0 );
29474 assert( ppOut!=0 );
29511 assert( p!=0 );
29519 assert( p->id==GetCurrentThreadId() );
29521 assert( p->xTask!=0 );
29536 assert( ppThread!=0 );
29537 assert( xTask!=0 );
29571 assert( ppOut!=0 );
29576 assert( p->tid==0 );
29578 assert( p->id!=0 && p->id!=GetCurrentThreadId() );
29580 assert( rc!=WAIT_IO_COMPLETION );
29582 assert( bRc );
29616 assert( ppThread!=0 );
29617 assert( xTask!=0 );
29635 assert( ppOut!=0 );
29870 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
29871 assert( pMem->flags&MEM_Str );
29872 assert( pMem->enc!=desiredEnc );
29873 assert( pMem->enc!=0 );
29874 assert( pMem->n>=0 );
29893 assert( rc==SQLITE_NOMEM );
29948 assert( desiredEnc==SQLITE_UTF16BE );
29958 assert( desiredEnc==SQLITE_UTF8 );
29975 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
30011 assert( pMem->n>=0 );
30054 assert( z<=zTerm );
30109 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
30110 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
30111 assert( m.z || db->mallocFailed );
30156 assert( n>0 && n<=4 );
30163 assert( c==t );
30164 assert( (z-zBuf)==n );
30171 assert( n>0 && n<=4 );
30175 assert( c==i );
30176 assert( (z-zBuf)==n );
30183 assert( n>0 && n<=4 );
30187 assert( c==i );
30188 assert( (z-zBuf)==n );
30343 assert( db!=0 );
30382 assert( db!=0 );
30469 assert( z[i] );
30484 assert( sqlite3Isquote(p->u.zToken[0]) );
30565 assert( E>=0 && E<=307 );
30620 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
30628 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
30749 }else{ assert( e>=342 );
30837 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
30842 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
30893 assert( u<=LARGEST_INT64 );
30900 assert( u<=LARGEST_INT64 );
30910 assert( u-1==LARGEST_INT64 );
31071 assert( n<=9 );
31131 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
31132 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
31338 assert( n>3 && n<=9 );
31390 assert( n>5 && n<=9 );
31403 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
31454 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
31708 assert( sizeof(x)==8 && sizeof(a)==8 );
31738 assert( x<=60 );
31792 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */
31807 assert( pIn[1]<=pIn[0] );
31872 assert( pNew!=0 );
31886 assert( pH!=0 );
32018 assert( elem!=0 );
32049 assert( pEntry->count>0 );
32055 assert( pH->first==0 );
32056 assert( pH->count==0 );
32066 assert( pH!=0 );
32067 assert( pKey!=0 );
32090 assert( pH!=0 );
32091 assert( pKey!=0 );
32111 assert( pH->htsize>0 );
33231 assert( sqlite3_mutex_notheld(unixBigLock) ); /* Not a recursive mutex */
33235 assert( sqlite3_mutex_held(unixBigLock) );
33292 assert( 0 );
33294 assert( p->l_whence==SEEK_SET );
33311 assert( 0 );
33356 assert( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
33463 assert( zAbsoluteName[0]=='/' );
33502 assert( pId->nRef>0 );
33507 assert( *pp==pId );
33688 assert( pFile->pInode );
33692 assert( pFile->pInode );
33801 assert( unixFileMutexHeld(pFile) );
33818 assert( unixMutexHeld() );
33819 assert( unixFileMutexNotheld(pFile) );
33823 assert( pInode->pShmNode==0 );
33828 assert( pInode->pPrev->pNext==pInode );
33831 assert( inodeList==pInode );
33835 assert( pInode->pNext->pPrev==pInode );
33863 assert( unixMutexHeld() );
33910 assert( unixMutexHeld() );
33930 assert( unixMutexHeld() );
34006 assert( pFile );
34007 assert( pFile->eFileLock<=SHARED_LOCK );
34099 assert( pInode!=0 );
34100 assert( sqlite3_mutex_held(pInode->pLockMutex) );
34104 assert( pInode->nLock==0 );
34192 assert( pFile );
34213 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
34214 assert( eFileLock!=PENDING_LOCK );
34215 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
34238 assert( eFileLock==SHARED_LOCK );
34239 assert( pFile->eFileLock==0 );
34240 assert( pInode->nShared>0 );
34274 assert( pInode->nShared==0 );
34275 assert( pInode->eFileLock==0 );
34276 assert( rc==SQLITE_OK );
34315 assert( 0!=pFile->eFileLock );
34318 assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
34376 assert( unixFileMutexHeld(pFile) );
34402 assert( pFile );
34407 assert( eFileLock<=SHARED_LOCK );
34413 assert( pInode->nShared!=0 );
34415 assert( pInode->eFileLock==pFile->eFileLock );
34441 assert( handleNFSUnlock==0 );
34503 lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
34537 assert( pInode->nLock>=0 );
34558 assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
34618 assert( pInode!=0 );
34621 assert( unixFileMutexNotheld(pFile) );
34627 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
34733 assert( pFile );
34822 assert( pFile );
34825 assert( eFileLock<=SHARED_LOCK );
34841 assert( eFileLock==NO_LOCK );
34862 assert( id!=0 );
34913 assert( pFile );
34990 assert( pFile );
35033 assert( pFile );
35036 assert( eFileLock<=SHARED_LOCK );
35065 assert( id!=0 );
35100 assert( pFile );
35197 assert( pFile );
35198 assert( pSem );
35201 assert( eFileLock<=SHARED_LOCK );
35234 assert( pFile );
35235 assert( unixFileMutexNotheld(pFile) );
35344 assert( pFile );
35411 assert( pFile );
35431 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
35432 assert( eFileLock!=PENDING_LOCK );
35433 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
35456 assert( eFileLock==SHARED_LOCK );
35457 assert( pFile->eFileLock==0 );
35458 assert( pInode->nShared>0 );
35487 assert( pInode->nShared==0 );
35488 assert( pInode->eFileLock==0 );
35527 assert( 0!=pFile->eFileLock );
35597 assert( pFile );
35602 assert( eFileLock<=SHARED_LOCK );
35608 assert( pInode->nShared!=0 );
35610 assert( pInode->eFileLock==pFile->eFileLock );
35624 assert( pFile->inNormalWrite==0
35675 assert( pInode->nLock>=0 );
35693 assert( id!=0 );
35695 assert( unixFileMutexNotheld(pFile) );
35781 assert( cnt==(cnt&0x1ffff) );
35782 assert( id->h>2 );
35831 assert( id );
35832 assert( offset>=0 );
35833 assert( amt>0 );
35838 assert( pFile->pPreallocatedUnused==0
35891 assert( nBuf==(nBuf&0x1ffff) );
35892 assert( fd>2 );
35893 assert( piErrno!=0 );
35945 assert( id );
35946 assert( amt>0 );
35951 assert( pFile->pPreallocatedUnused==0
36213 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
36222 assert( pFile );
36244 assert( rc==SQLITE_CANTOPEN );
36258 assert( pFile );
36308 assert( id );
36377 assert( iWrite>=buf.st_size );
36378 assert( ((iWrite+1)%nBlk)==0 );
36553 assert( pFd->deviceCharacteristics==0 || pFd->sectorSize!=0 );
36800 assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) );
36801 assert( pShmNode->nRef>0 || unixMutexHeld() );
36804 assert( n==1 || lockType!=F_RDLCK );
36807 assert( n>=1 && n<=SQLITE_SHM_NLOCK );
36834 assert( lockType==F_WRLCK );
36845 assert( lockType==F_WRLCK );
36869 assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */
36882 assert( unixMutexHeld() );
36886 assert( p->pInode==pFd->pInode );
36962 assert( lock.l_type==F_UNLCK || lock.l_type==F_RDLCK );
37015 assert( pDbFd->pShm==0 );
37020 assert( unixFileMutexNotheld(pDbFd) );
37171 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
37172 assert( pShmNode->pInode==pDbFd->pInode );
37173 assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
37174 assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
37216 assert( (nByte % pgsz)==0 );
37299 assert( pShmNode==pDbFd->pInode->pShmNode );
37300 assert( pShmNode->pInode==pDbFd->pInode );
37301 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
37302 assert( n>=1 );
37303 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
37307 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
37308 assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
37309 assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
37312 assert( n>1 || mask==(1<<ofst) );
37320 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
37381 assert( (p->sharedMask & mask)==0 );
37403 assert( fd->pMethods->xLock==nolockLock
37431 assert( pShmNode==pDbFd->pInode->pShmNode );
37432 assert( pShmNode->pInode==pDbFd->pInode );
37447 assert( unixFileMutexNotheld(pDbFd) );
37449 assert( pShmNode->nRef>0 );
37475 assert( pFd->nFetchOut==0 );
37510 assert( pFd->nFetchOut==0 );
37511 assert( nNew>pFd->mmapSize );
37512 assert( nNew<=pFd->mmapSizeMax );
37513 assert( nNew>0 );
37514 assert( pFd->mmapSizeActual>=pFd->mmapSize );
37515 assert( MAP_FAILED!=0 );
37592 assert( nMap>=0 || pFd->nFetchOut==0 );
37593 assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
37607 assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
37667 assert( (p==0)==(pFd->nFetchOut==0) );
37670 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
37678 assert( pFd->nFetchOut>=0 );
38000 assert( pNew->pInode==NULL );
38003 assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
38107 assert( zFilename!=0 );
38215 assert( nBuf>2 );
38280 assert( sqlite3_mutex_notheld(pInode->pLockMutex) );
38464 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
38465 assert(isCreate==0 || isReadWrite);
38466 assert(isExclusive==0 || isCreate);
38467 assert(isDelete==0 || isCreate);
38471 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
38472 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
38473 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
38474 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
38477 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
38510 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
38514 assert(isDelete && !isNewJrnl);
38523 assert( zName[strlen(zName)+1]==0 );
38542 assert( !p->pPreallocatedUnused );
38543 assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
38548 assert( !isExclusive || (openFlags & O_CREAT)!=0 );
38578 assert( fd>=0 );
38662 assert( zPath==0 || zPath[0]=='/'
38709 assert( rc==SQLITE_CANTOPEN );
38735 assert( pResOut!=0 );
38739 assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE );
38801 assert( pVfs->mxPathname==MAX_PATHNAME );
38856 assert( rc!=SQLITE_OK || zIn!=zOut || zIn[0]=='/' );
38937 assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
38962 assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
39307 assert(lockPath!=NULL);
39440 assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
39569 assert( nTries>1 );
39595 assert( nTries==3 );
39897 assert( (int)strlen(conchPath) == len+7 );
39947 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
39959 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
40113 assert( 0 ); /* The call assures that only valid opcodes are sent */
40360 assert( ArraySize(aSyscall)==29 );
41030 #define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 )
41031 #define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 )
41841 assert( hHeap!=0 );
41842 assert( hHeap!=INVALID_HANDLE_VALUE );
41844 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
41891 assert( winMemGetHeap()!=NULL );
41892 assert( winMemGetOwned() );
41893 assert( sqlite3_memory_used()==0 );
41895 assert( winMemGetHeap()==NULL );
41896 assert( !winMemGetOwned() );
41897 assert( sqlite3_memory_used()==0 );
41899 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
41900 assert( rc!=SQLITE_OK || winMemGetOwned() );
41901 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
41923 assert( nMin==-1 || nMin==0 || nMin<SQLITE_WIN32_DBG_BUF_SIZE );
41971 assert( sleepObj!=NULL );
42059 assert( hHeap!=0 );
42060 assert( hHeap!=INVALID_HANDLE_VALUE );
42062 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
42064 assert( nBytes>=0 );
42081 assert( hHeap!=0 );
42082 assert( hHeap!=INVALID_HANDLE_VALUE );
42084 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
42102 assert( hHeap!=0 );
42103 assert( hHeap!=INVALID_HANDLE_VALUE );
42105 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
42107 assert( nBytes>=0 );
42130 assert( hHeap!=0 );
42131 assert( hHeap!=INVALID_HANDLE_VALUE );
42133 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) );
42159 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
42160 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
42181 assert( pWinMemData->bOwned );
42191 assert( !pWinMemData->bOwned );
42193 assert( pWinMemData->hHeap!=0 );
42194 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
42196 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
42208 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
42209 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
42212 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
42214 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
42513 assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE
42516 assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) );
42673 assert( errcode!=SQLITE_OK );
43041 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
43049 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE
43244 assert( id!=0 );
43246 assert( pFile->pShm==0 );
43248 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
43309 assert( id!=0 );
43310 assert( amt>0 );
43311 assert( offset>=0 );
43386 assert( amt>0 );
43387 assert( pFile );
43443 assert( nWrite==0 || nWrite<=(DWORD)nRem );
43513 assert( pFile );
43592 assert( pFile );
43594 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
43663 assert( id!=0 );
43664 assert( pSize!=0 );
43827 assert( id!=0 );
43848 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
43849 assert( locktype!=PENDING_LOCK );
43850 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
43890 assert( pFile->locktype==NO_LOCK );
43902 assert( pFile->locktype==SHARED_LOCK );
43921 assert( pFile->locktype>=SHARED_LOCK );
43969 assert( id!=0 );
44002 assert( pFile!=0 );
44003 assert( locktype<=SHARED_LOCK );
44377 assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );
44419 assert( winShmMutexHeld() );
44503 assert( pDbFd->pShm==0 ); /* Not previously opened */
44633 assert( pShmNode->nRef>0 );
44659 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
44660 assert( n>=1 );
44661 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
44665 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
44668 assert( n>1 || mask==(1<<ofst) );
44676 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
44737 assert( (p->sharedMask & mask)==0 );
44810 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
44937 assert( pFile!=0 );
44989 assert( nMap>=0 || pFd->nFetchOut==0 );
45043 assert( (nMap % winSysInfo.dwPageSize)==0 );
45044 assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff );
45131 assert( (p==0)==(pFd->nFetchOut==0) );
45134 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
45149 assert( pFd->nFetchOut>=0 );
45331 assert( nDir>0 );
45622 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
45623 assert(isCreate==0 || isReadWrite);
45624 assert(isExclusive==0 || isCreate);
45625 assert(isDelete==0 || isCreate);
45629 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
45630 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
45631 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
45632 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
45635 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
45641 assert( pFile!=0 );
45656 assert( isDelete && !isOpenJournal );
45669 assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
46057 assert(!"Invalid flags argument");
46139 assert( nFull>=pVfs->mxPathname );
46670 assert( ArraySize(aSyscall)==80 );
46679 assert( winSysInfo.dwAllocationGranularity>0 );
46680 assert( winSysInfo.dwPageSize>0 );
47059 assert( pOutFlags!=0 ); /* True because flags==SQLITE_OPEN_MAIN_DB */
47462 assert( sizeof(*p)==BITVEC_SZ );
47476 assert( p!=0 );
47517 assert( i>0 );
47518 assert( i<=p->iSize );
47587 assert( i>0 );
47869 assert( pPg!=0 );
47870 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
47872 assert( pCache!=0 ); /* Every page has an associated PCache */
47874 assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */
47875 assert( pCache->pDirty!=pPg ); /* CLEAN pages not on dirty list */
47876 assert( pCache->pDirtyTail!=pPg );
47880 assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */
47924 assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
47925 assert( pPage->pDirtyPrev || pPage==p->pDirty );
47935 assert( pPage==p->pDirtyTail );
47945 assert( pPage==p->pDirty );
47947 assert( p->bPurgeable || p->eCreate==2 );
47949 assert( p->bPurgeable==0 || p->eCreate==1 );
47958 assert( pPage->pDirtyNext->pDirtyPrev==0 );
47963 assert( p->eCreate==2 );
48061 assert( szExtra>=8 ); /* First 8 bytes will be zeroed */
48077 assert( pCache->nRefSum==0 && pCache->pDirty==0 );
48128 assert( pCache!=0 );
48129 assert( pCache->pCache!=0 );
48130 assert( createFlag==3 || createFlag==0 );
48131 assert( pCache->eCreate==((pCache->bPurgeable && pCache->pDirty) ? 1 : 2) );
48141 assert( eCreate==0 || eCreate==1 || eCreate==2 );
48142 assert( createFlag==0 || pCache->eCreate==eCreate );
48143 assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) );
48223 assert( pPage!=0 );
48225 assert( pPgHdr->pPage==0 );
48250 assert( pPage!=0 );
48258 assert( sqlite3PcachePageSanity(pPgHdr) );
48267 assert( p->nRef>0 );
48282 assert(p->nRef>0);
48283 assert( sqlite3PcachePageSanity(p) );
48294 assert( p->nRef==1 );
48295 assert( sqlite3PcachePageSanity(p) );
48308 assert( p->nRef>0 );
48309 assert( sqlite3PcachePageSanity(p) );
48315 assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY );
48318 assert( sqlite3PcachePageSanity(p) );
48327 assert( sqlite3PcachePageSanity(p) );
48328 assert( (p->flags & PGHDR_DIRTY)!=0 );
48329 assert( (p->flags & PGHDR_CLEAN)==0 );
48334 assert( sqlite3PcachePageSanity(p) );
48379 assert( p->nRef>0 );
48380 assert( newPgno>0 );
48381 assert( sqlite3PcachePageSanity(p) );
48410 assert( p->pgno>0 );
48412 assert( p->flags&PGHDR_DIRTY );
48433 assert( pCache->pCache!=0 );
48452 assert( pA!=0 && pB!=0 );
48550 assert( pCache->pCache!=0 );
48567 assert( pCache->pCache!=0 );
48580 assert( p->pCache!=0 );
48596 assert( pCache->pCache!=0 );
48884 # define pcache1EnterMutex(X) assert((X)->mutex==0)
48885 # define pcache1LeaveMutex(X) assert((X)->mutex==0)
48977 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
48985 assert( pcache1.nFreeSlot>=0 );
49024 assert( pcache1.nFreeSlot<=pcache1.nSlot );
49027 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
49051 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
49067 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
49077 assert( pcache1.separateCache==0 );
49078 assert( pCache->pGroup==&pcache1.grp );
49113 assert( p!=0 );
49115 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
49134 assert( sz<=65536+8 ); /* These allocations are never very large */
49184 assert( sqlite3_mutex_held(p->pGroup->mutex) );
49221 assert( pPage!=0 );
49222 assert( PAGE_IS_UNPINNED(pPage) );
49223 assert( pPage->pLruNext );
49224 assert( pPage->pLruPrev );
49225 assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) );
49231 assert( pPage->isAnchor==0 );
49232 assert( pPage->pCache->pGroup->lru.isAnchor==1 );
49250 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
49266 assert( sqlite3_mutex_held(pGroup->mutex) );
49270 assert( p->pCache->pGroup==pGroup );
49271 assert( PAGE_IS_UNPINNED(p) );
49294 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
49295 assert( pCache->iMaxKey >= iLimit );
49296 assert( pCache->nHash > 0 );
49314 assert( h<pCache->nHash );
49330 assert( nPage<0 || pCache->nPage==(unsigned)nPage );
49341 assert( pcache1.isInit==0 );
49394 assert( pcache1.isInit!=0 );
49411 assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
49412 assert( szExtra < 300 );
49520 assert( pCache->nPage >= pCache->nRecyclable );
49522 assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
49523 assert( pCache->n90pct == pCache->nMax*9/10 );
49533 assert( pCache->nHash>0 && pCache->apHash );
49542 assert( PAGE_IS_UNPINNED(pPage) );
49678 assert( pPage==0 || pCache->iMaxKey>=iKey );
49692 assert( offsetof(PgHdr1,page)==0 );
49693 assert( pCache->bPurgeable || createFlag!=1 );
49694 assert( pCache->bPurgeable || pCache->nMin==0 );
49695 assert( pCache->bPurgeable==0 || pCache->nMin==10 );
49696 assert( pCache->nMin==0 || pCache->bPurgeable );
49697 assert( pCache->nHash>0 );
49723 assert( pPage->pCache==pCache );
49729 assert( pPage->pLruNext==0 );
49730 assert( PAGE_IS_PINNED(pPage) );
49759 assert( pPage->iKey==iOld );
49760 assert( pPage->pCache==pCache );
49807 assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
49810 assert( pGroup->nMaxPage >= pCache->nMax );
49812 assert( pGroup->nMinPage >= pCache->nMin );
49871 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
49872 assert( sqlite3_mutex_notheld(pcache1.mutex) );
49884 assert( PAGE_IS_UNPINNED(p) );
49908 assert( PAGE_IS_UNPINNED(p) );
50105 assert( p!=0 );
50134 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
50168 assert( pA!=0 && pB!=0 );
50170 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
50171 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
50229 assert( pIn!=0 );
50242 assert( (*ppLast)->pRight==0 );
50300 assert( pList!=0 );
50328 assert( p!=0 );
50329 assert( p->pForest==0 ); /* Cannot be used with sqlite3RowSetText() */
50365 assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 );
51456 assert( p->eState==PAGER_OPEN
51469 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
51470 assert( p->tempFile==0 || pPager->changeCountDone );
51475 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
51476 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
51487 assert( !isOpen(p->fd) );
51488 assert( p->noSync );
51489 assert( p->journalMode==PAGER_JOURNALMODE_OFF
51492 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
51493 assert( pagerUseWal(p)==0 );
51499 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
51500 assert( p->eLock!=PENDING_LOCK );
51504 assert( !MEMDB );
51505 assert( pPager->errCode==SQLITE_OK );
51506 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
51510 assert( pPager->errCode==SQLITE_OK );
51511 assert( p->eLock!=UNKNOWN_LOCK );
51512 assert( p->eLock>=SHARED_LOCK );
51516 assert( p->eLock!=UNKNOWN_LOCK );
51517 assert( pPager->errCode==SQLITE_OK );
51519 assert( p->eLock>=RESERVED_LOCK );
51521 assert( pPager->dbSize==pPager->dbOrigSize );
51522 assert( pPager->dbOrigSize==pPager->dbFileSize );
51523 assert( pPager->dbOrigSize==pPager->dbHintSize );
51524 assert( pPager->setMaster==0 );
51528 assert( p->eLock!=UNKNOWN_LOCK );
51529 assert( pPager->errCode==SQLITE_OK );
51536 assert( p->eLock>=RESERVED_LOCK );
51537 assert( isOpen(p->jfd)
51542 assert( pPager->dbOrigSize==pPager->dbFileSize );
51543 assert( pPager->dbOrigSize==pPager->dbHintSize );
51547 assert( p->eLock==EXCLUSIVE_LOCK );
51548 assert( pPager->errCode==SQLITE_OK );
51549 assert( !pagerUseWal(pPager) );
51550 assert( p->eLock>=EXCLUSIVE_LOCK );
51551 assert( isOpen(p->jfd)
51556 assert( pPager->dbOrigSize<=pPager->dbHintSize );
51560 assert( p->eLock==EXCLUSIVE_LOCK );
51561 assert( pPager->errCode==SQLITE_OK );
51562 assert( !pagerUseWal(pPager) );
51563 assert( isOpen(p->jfd)
51575 assert( pPager->errCode!=SQLITE_OK );
51576 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
51742 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
51743 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
51744 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
51746 assert( pPager->eLock>=eLock );
51769 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
51800 assert( !MEMDB );
51806 assert( isOpen(pPager->fd) );
51823 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
51824 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
51868 assert( pPager->eState!=PAGER_ERROR );
51869 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
51965 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
51966 assert( offset>=c );
51967 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
51994 assert( isOpen(pPager->jfd) );
51995 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
52049 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
52087 assert( isOpen(pPager->fd) || pPager->noSync );
52136 assert( pPager->journalHdr <= pPager->journalOff );
52171 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
52292 assert( pPager->setMaster==0 );
52293 assert( !pagerUseWal(pPager) );
52302 assert( pPager->journalHdr <= pPager->journalOff );
52399 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
52424 assert( pPager->eState==PAGER_READER
52434 assert( !isOpen(pPager->jfd) );
52446 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
52447 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
52448 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
52449 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
52450 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
52451 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
52472 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
52482 assert( pPager->errCode==SQLITE_OK || !MEMDB );
52522 assert( rc==SQLITE_OK || !MEMDB );
52523 assert(
52631 assert( assert_pager_state(pPager) );
52632 assert( pPager->eState!=PAGER_ERROR );
52638 assert( isOpen(pPager->jfd) || pPager->pInJournal==0
52642 assert( !pagerUseWal(pPager) );
52675 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
52676 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
52716 assert( rc2==SQLITE_OK );
52724 assert( pPager->eLock==EXCLUSIVE_LOCK );
52764 assert( assert_pager_state(pPager) );
52770 assert( pPager->eState==PAGER_READER );
52892 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
52893 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
52894 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
52895 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
52898 assert( aData ); /* Temp storage must have already been allocated */
52899 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
52907 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
52910 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
52928 assert( !isSavepnt );
52996 assert( pPg || !MEMDB );
52997 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
53013 assert( !pagerUseWal(pPager) );
53060 assert( isSavepnt );
53061 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
53064 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
53227 assert( !isOpen(pJournal) );
53256 assert( pPager->eState!=PAGER_ERROR );
53257 assert( pPager->eState!=PAGER_READER );
53264 assert( pPager->eLock==EXCLUSIVE_LOCK );
53295 assert( MAX_SECTOR_SIZE>=512 );
53325 assert( isOpen(pPager->fd) || pPager->tempFile );
53413 assert( isOpen(pPager->jfd) );
53466 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
53535 assert( 0 );
53615 assert( pPager->eState>=PAGER_READER && !MEMDB );
53616 assert( isOpen(pPager->fd) );
53705 assert( pagerUseWal(pPager) );
53777 assert( pPager->pWal );
53778 assert( pList );
53782 assert( p->pgno < p->pDirty->pgno );
53786 assert( pList->pDirty==0 || isCommit );
53800 assert( pList );
53838 assert( pagerUseWal(pPager) );
53839 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
53876 assert( pPager->eState==PAGER_OPEN );
53877 assert( pPager->eLock>=SHARED_LOCK );
53878 assert( isOpen(pPager->fd) );
53879 assert( pPager->tempFile==0 );
53929 assert( pPager->eState==PAGER_OPEN );
53930 assert( pPager->eLock>=SHARED_LOCK );
54000 assert( pPager->eState!=PAGER_ERROR );
54001 assert( pPager->eState>=PAGER_WRITER_LOCKED );
54027 assert( pagerUseWal(pPager)==0 || szJ==0 );
54042 assert( rc!=SQLITE_DONE );
54057 assert( rc!=SQLITE_DONE );
54072 assert( rc!=SQLITE_DONE );
54074 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
54088 assert( offset==(i64)ii*(4+pPager->pageSize) );
54091 assert( rc!=SQLITE_DONE );
54275 assert( rc!=SQLITE_OK || isOpen(pFile) );
54309 assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
54310 assert( ap[1]==pBusyHandlerArg );
54358 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
54397 assert( nReserve>=0 && nReserve<1000 );
54428 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
54477 assert( isOpen(pPager->fd) || pPager->tempFile );
54483 assert( !pagerUseWal(pPager) );
54503 assert( pPager->eState>=PAGER_READER );
54504 assert( pPager->eState!=PAGER_WRITER_FINISHED );
54531 assert( (pPager->eLock>=locktype)
54566 assert( pPg->flags&PGHDR_DIRTY );
54567 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
54588 assert( pPager->dbSize>=nPage );
54589 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
54652 assert( pPager->nExtra>=8 );
54666 assert( p->pExtra==(void *)&p[1] );
54667 assert( p->pPage==0 );
54668 assert( p->flags==PGHDR_MMAP );
54669 assert( p->pPager==pPager );
54670 assert( p->nRef==1 );
54690 assert( pPager->fd->pMethods->iVersion>=3 );
54717 assert( pPager->zFilename && pPager->zFilename[0] );
54747 assert( db || pagerUseWal(pPager)==0 );
54748 assert( assert_pager_state(pPager) );
54757 assert( db || pPager->pWal==0 );
54800 assert( !pPager->aSavepoint && !pPager->pInJournal );
54801 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
54861 assert( pPager->eState==PAGER_WRITER_CACHEMOD
54864 assert( assert_pager_state(pPager) );
54865 assert( !pagerUseWal(pPager) );
54871 assert( !pPager->tempFile );
54874 assert( isOpen(pPager->jfd) );
54965 assert( assert_pager_state(pPager) );
55005 assert( !pagerUseWal(pPager) );
55006 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
55007 assert( pPager->eLock==EXCLUSIVE_LOCK );
55008 assert( isOpen(pPager->fd) || pList->pDirty==0 );
55015 assert( pPager->tempFile && rc==SQLITE_OK );
55022 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
55047 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
55125 assert( pPager->useJournal );
55126 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
55127 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
55128 assert( pagerUseWal(pPager)
55156 assert( pPager->nSavepoint>0 );
55192 assert( pPg->pPager==pPager );
55193 assert( pPg->flags&PGHDR_DIRTY );
55248 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
55269 assert( assert_pager_state(pPager) );
55382 assert( nUri>=0 );
55421 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
55432 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
55436 assert( nPathname>0 );
55459 assert( !memDb );
55477 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
55488 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
55489 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
55490 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
55529 assert( pPager->memDb==0 );
55537 assert( nExtra>=8 && nExtra<1000 );
55565 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
55567 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
55572 assert( useJournal || pPager->tempFile );
55575 assert( pPager->fullSync==0 );
55576 assert( pPager->extraSync==0 );
55577 assert( pPager->syncFlags==0 );
55578 assert( pPager->walSyncFlags==0 );
55590 assert( isOpen(pPager->fd) || tempFile );
55647 assert( pPager->useJournal );
55648 assert( isOpen(pPager->fd) );
55649 assert( pPager->eState==PAGER_OPEN );
55651 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
55674 assert( pPager->tempFile==0 );
55768 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
55769 assert( assert_pager_state(pPager) );
55770 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
55771 assert( pPager->errCode==SQLITE_OK );
55776 assert( !MEMDB );
55777 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
55781 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
55841 assert( !pPager->tempFile );
55843 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
55860 assert( rc==SQLITE_OK );
55891 assert( pPager->eState==PAGER_OPEN );
55892 assert( (pPager->eLock==SHARED_LOCK)
55945 assert( pPager->pWal==0 || rc==SQLITE_OK );
55950 assert( rc==SQLITE_OK );
55960 assert( !MEMDB );
55962 assert( pPager->eState==PAGER_OPEN );
55980 assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
56053 assert( pPager->errCode==SQLITE_OK );
56054 assert( pPager->eState>=PAGER_READER );
56055 assert( assert_pager_state(pPager) );
56056 assert( pPager->hasHeldSharedLock==1 );
56070 assert( pPg==(*ppPage) );
56071 assert( pPg->pgno==pgno );
56072 assert( pPg->pPager==pPager || pPg->pPager==0 );
56078 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
56096 assert( !isOpen(pPager->fd) || !MEMDB );
56121 assert( pPg->pPager==pPager );
56133 assert( rc!=SQLITE_OK );
56162 assert( USEFETCH(pPager) );
56164 assert( pPager->xCodec==0 );
56174 assert( pPager->eState>=PAGER_READER );
56175 assert( assert_pager_state(pPager) );
56176 assert( pPager->hasHeldSharedLock==1 );
56177 assert( pPager->errCode==SQLITE_OK );
56201 assert( rc==SQLITE_OK );
56224 assert( pPager->errCode!=SQLITE_OK );
56254 assert( pPager!=0 );
56255 assert( pgno!=0 );
56256 assert( pPager->pPCache!=0 );
56258 assert( pPage==0 || pPager->hasHeldSharedLock );
56277 assert( pPg!=0 );
56279 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
56285 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
56292 assert( pPg!=0 );
56293 assert( pPg->pgno==1 );
56294 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
56327 assert( pPager->eState==PAGER_WRITER_LOCKED );
56328 assert( assert_pager_state(pPager) );
56329 assert( pPager->pInJournal==0 );
56367 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
56388 assert( pPager->eState==PAGER_WRITER_LOCKED );
56416 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
56420 assert( pPager->pInJournal==0 );
56469 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
56470 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
56471 assert( assert_pager_state(pPager) );
56491 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
56493 assert( pPager->journalHdr<=pPager->journalOff );
56522 assert( pPager->pInJournal!=0 );
56525 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
56527 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
56546 assert( pPager->eState==PAGER_WRITER_LOCKED
56550 assert( assert_pager_state(pPager) );
56551 assert( pPager->errCode==0 );
56552 assert( pPager->readOnly==0 );
56568 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
56569 assert( assert_pager_state(pPager) );
56578 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
56582 assert( pagerUseWal(pPager)==0 );
56644 assert( !MEMDB );
56645 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
56662 assert(nPage>0);
56663 assert(pg1<=pPg->pgno);
56664 assert((pg1+nPage)>pPg->pgno);
56695 assert( !MEMDB );
56705 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
56726 assert( (pPg->flags & PGHDR_MMAP)==0 );
56727 assert( pPager->eState>=PAGER_WRITER_LOCKED );
56728 assert( assert_pager_state(pPager) );
56735 assert( pPager->tempFile==0 );
56810 assert( pPager->eState==PAGER_WRITER_CACHEMOD
56813 assert( assert_pager_state(pPager) );
56827 assert( isDirectMode==0 );
56836 assert( !pPager->tempFile && isOpen(pPager->fd) );
56840 assert( pPgHdr==0 || rc==SQLITE_OK );
56858 assert( pPager->dbFileSize>0 );
56896 assert( !MEMDB );
56915 assert( assert_pager_state(pPager) );
56917 assert( pPager->eState==PAGER_WRITER_CACHEMOD
56921 assert( assert_pager_state(pPager) );
56962 assert( pPager->eState==PAGER_WRITER_LOCKED
56967 assert( assert_pager_state(pPager) );
56981 assert( MEMDB==0 || pPager->tempFile );
56982 assert( isOpen(pPager->fd) || pPager->tempFile );
57000 assert( rc==SQLITE_OK );
57049 assert( isOpen(pPager->jfd)
57077 assert( bBatch==0 );
57136 assert( rc!=SQLITE_IOERR_BLOCKED );
57149 assert( pPager->eState==PAGER_WRITER_DBMOD );
57193 assert( pPager->eState==PAGER_WRITER_LOCKED
57197 assert( assert_pager_state(pPager) );
57214 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
57259 assert( assert_pager_state(pPager) );
57285 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
57286 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
57367 assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
57373 assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
57374 assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
57375 assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1
57408 assert( pPager->eState>=PAGER_WRITER_LOCKED );
57409 assert( assert_pager_state(pPager) );
57410 assert( nSavepoint>nCurrent && pPager->useJournal );
57443 assert( pPager->nSavepoint==nSavepoint );
57448 assert( pPager->eState>=PAGER_WRITER_LOCKED );
57449 assert( assert_pager_state(pPager) );
57496 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
57497 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
57520 assert( rc==SQLITE_OK );
57533 assert(rc!=SQLITE_DONE);
57694 assert( pPg->nRef>0 );
57695 assert( pPager->eState==PAGER_WRITER_CACHEMOD
57698 assert( assert_pager_state(pPager) );
57703 assert( pPager->tempFile || !MEMDB );
57746 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
57748 assert( pPg->flags&PGHDR_DIRTY );
57758 assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
57806 assert( pPager->pTmpSpace!=0 );
57827 assert( pPg->pgno!=iNew );
57836 assert( pPg->nRef>0 || pPg->pPager->memDb );
57859 assert( eMode==PAGER_LOCKINGMODE_QUERY
57862 assert( PAGER_LOCKINGMODE_QUERY<0 );
57863 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
57864 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
57895 assert( eMode==PAGER_JOURNALMODE_DELETE
57906 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
57912 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
57921 assert( pPager->eState!=PAGER_ERROR );
57928 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
57929 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
57930 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
57931 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
57932 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
57933 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
57935 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
57952 assert( state==PAGER_OPEN || state==PAGER_READER );
57957 assert( rc==SQLITE_OK );
57968 assert( state==pPager->eState );
57992 assert( assert_pager_state(pPager) );
58027 assert( MEMDB==0 || pPager->tempFile );
58082 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
58102 assert( pPager->pWal==0 && pPager->tempFile==0 );
58103 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
58150 assert( assert_pager_state(pPager) );
58151 assert( pPager->eState==PAGER_OPEN || pbOpen );
58152 assert( pPager->eState==PAGER_READER || !pbOpen );
58153 assert( pbOpen==0 || *pbOpen==0 );
58154 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
58186 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
58290 assert( pPager->pWal );
58306 assert( pPager->eState>=PAGER_READER );
58906 assert( pWal->apWiData[iPage]==0 );
58914 assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 );
58925 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
58943 assert( pWal->nWiData>0 && pWal->apWiData[0] );
58951 assert( pWal->nWiData>0 && pWal->apWiData[0] );
58994 assert( nByte>=8 );
58995 assert( (nByte&0x00000007)==0 );
58996 assert( nByte<=65536 );
59030 assert( pWal->writeLock );
59061 assert( WAL_FRAME_HDRSIZE==24 );
59093 assert( WAL_FRAME_HDRSIZE==24 );
59202 assert( iPage>0 );
59203 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
59244 assert( rc==SQLITE_OK || iHash>0 );
59267 assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
59306 assert( pWal->writeLock );
59317 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
59318 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
59326 assert( iLimit>0 );
59350 assert( sLoc.aHash[iKey]==j );
59376 assert( idx <= HASHTABLE_NSLOT/2 + 1 );
59395 assert( !sLoc.aPgno[idx] );
59414 assert( nEntry==idx );
59430 assert( sLoc.aHash[iKey]==i );
59463 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
59464 assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
59465 assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
59466 assert( pWal->writeLock );
59664 assert( zWalName && zWalName[0] );
59665 assert( pDbFd );
59673 assert( 120==WALINDEX_LOCK_OFFSET );
59674 assert( 136==WALINDEX_HDR_SIZE );
59676 assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
59679 assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
59750 assert( iMin<0xffffffff );
59807 assert( nLeft>0 && nRight>0 );
59824 assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
59825 assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );
59869 assert( nList<=HASHTABLE_NPAGE && nList>0 );
59870 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
59877 assert( iSub<ArraySize(aSub) );
59879 assert( p->aList && p->nList<=(1<<iSub) );
59880 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
59890 assert( iSub<ArraySize(aSub) );
59892 assert( p->nList<=(1<<iSub) );
59893 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
59897 assert( aMerge==aList );
59904 assert( aContent[aList[i]] > aContent[aList[i-1]] );
59942 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
60063 assert( pInfo->aReadMark[0]==0 );
60124 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
60144 assert( y<=pWal->hdr.mxFrame );
60161 assert( rc==SQLITE_OK || pIter==0 );
60190 assert( walFramePgno(pWal, iFrame)==iDbpage );
60240 assert( pWal->writeLock );
60246 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
60384 assert( pWal->nWiData>0 && pWal->apWiData[0] );
60450 assert( pChanged );
60453 assert( rc!=SQLITE_READONLY ); /* READONLY changed to OK in walIndexPage */
60461 assert( page0==0 );
60462 assert( pWal->writeLock==0 );
60463 assert( pWal->readOnly & WAL_SHM_RDONLY );
60475 assert( page0!=0 || pWal->writeLock==0 );
60487 assert( badHdr==0 || pWal->writeLock==0 );
60523 assert( pWal->nWiData>0 && pWal->apWiData[0]==0 );
60573 assert( pWal->bShmUnreliable );
60574 assert( pWal->readOnly & WAL_SHM_RDONLY );
60575 assert( pWal->nWiData>0 && pWal->apWiData[0] );
60610 assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */
60765 assert( pWal->readLock<0 ); /* Not currently locked */
60768 assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 );
60798 assert( rc==SQLITE_OK );
60835 assert( pWal->nWiData>0 );
60836 assert( pWal->apWiData[0]!=0 );
60889 assert( thisMark!=READMARK_NOT_USED );
60910 assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
60960 assert( mxReadMark<=pWal->hdr.mxFrame );
60989 assert( pWal->readLock>=0 );
61094 assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 );
61095 assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame );
61121 assert( pWal->readLock>0 );
61174 assert( pWal->readLock>=0 || pWal->lockError );
61228 assert( iFrame>iRead || CORRUPT_DB );
61245 assert( pWal->bShmUnreliable || pWal->minFrame>0 );
61252 assert( iRead==iRead2 );
61311 assert( pWal->readLock>=0 );
61312 assert( pWal->writeLock==0 && pWal->iReCksum==0 );
61392 assert( walFramePgno(pWal, iFrame)!=1 );
61407 assert( pWal->writeLock );
61423 assert( pWal->writeLock );
61424 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
61463 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
61491 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
61534 assert( WAL_SYNC_FLAGS(p->syncFlags)!=0 );
61591 assert( pWal->iReCksum>0 );
61643 assert( pList );
61644 assert( pWal->writeLock );
61648 assert( (isCommit!=0)==(nTruncate!=0) );
61712 assert( (int)pWal->szPage==szPage );
61734 assert( rc==SQLITE_OK || iWrite==0 );
61754 assert( iOffset==walFrameOffset(iFrame, szPage) );
61798 assert( rc==SQLITE_OK );
61881 assert( pWal->ckptLock==0 );
61882 assert( pWal->writeLock==0 );
61886 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
62009 assert( pWal->writeLock==0 );
62010 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
62018 assert( pWal->readLock>=0 || pWal->lockError );
62019 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
62033 assert( pWal->exclusiveMode==WAL_NORMAL_MODE );
62034 assert( pWal->readLock>=0 );
62063 assert( pWal->readLock>=0 && pWal->writeLock==0 );
62134 assert( pWal );
62148 assert( pWal==0 || pWal->readLock>=0 );
62828 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
62829 assert( p->pBt->inTransaction>=p->inTrans );
62905 assert( p->locked==0 );
62906 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
62907 assert( sqlite3_mutex_held(p->db->mutex) );
62920 assert( p->locked==1 );
62921 assert( sqlite3_mutex_held(pBt->mutex) );
62922 assert( sqlite3_mutex_held(p->db->mutex) );
62923 assert( p->db==pBt->db );
62953 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
62954 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
62955 assert( p->pNext==0 || p->pNext->db==p->db );
62956 assert( p->pPrev==0 || p->pPrev->db==p->db );
62957 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
62960 assert( !p->locked || p->wantToLock>0 );
62961 assert( p->sharable || p->wantToLock==0 );
62964 assert( sqlite3_mutex_held(p->db->mutex) );
62968 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
63001 assert( pLater->sharable );
63002 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
63003 assert( !pLater->locked || pLater->wantToLock>0 );
63021 assert( sqlite3_mutex_held(p->db->mutex) );
63023 assert( p->wantToLock>0 );
63039 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
63040 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
63041 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
63042 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
63067 assert( sqlite3_mutex_held(db->mutex) );
63083 assert( sqlite3_mutex_held(db->mutex) );
63131 assert( db!=0 );
63133 assert( iDb>=0 && iDb<db->nDb );
63137 assert( p!=0 );
63467 assert( sqlite3BtreeHoldsMutex(p) );
63468 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
63469 assert( p->db!=0 );
63470 assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 );
63476 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
63477 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
63502 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
63503 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
63507 assert( p==pBt->pWriter );
63540 assert( sqlite3BtreeHoldsMutex(p) );
63541 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
63542 assert( p->db!=0 );
63548 assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK );
63552 assert( p->sharable );
63553 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
63581 assert( WRITE_LOCK>READ_LOCK );
63603 assert( sqlite3BtreeHoldsMutex(p) );
63604 assert( p->sharable || 0==*ppIter );
63605 assert( p->inTrans>0 );
63609 assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
63610 assert( pLock->pBtree->inTrans>=pLock->eLock );
63613 assert( pLock->iTable!=1 || pLock==&p->lock );
63622 assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
63650 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
63681 assert( cursorHoldsMutex(p) );
63698 assert( sqlite3_mutex_held(pBt->mutex) );
63726 assert( sqlite3BtreeHoldsMutex(pBtree) );
63781 assert( pgno<=pBt->nPage );
63843 assert( CURSOR_VALID==pCur->eState );
63844 assert( 0==pCur->pKey );
63845 assert( cursorHoldsMutex(pCur) );
63872 assert( !pCur->curIntKey || !pCur->pKey );
63886 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
63887 assert( 0==pCur->pKey );
63888 assert( cursorHoldsMutex(pCur) );
63932 assert( sqlite3_mutex_held(pBt->mutex) );
63933 assert( pExcept==0 || pExcept->pBt==pBt );
63973 assert( cursorHoldsMutex(pCur) );
63996 assert( nKey==(i64)(int)nKey );
64025 assert( cursorOwnsBtShared(pCur) );
64026 assert( pCur->eState>=CURSOR_REQUIRESEEK );
64039 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
64066 assert( EIGHT_BYTE_ALIGNMENT(pCur)
64068 assert( offsetof(BtCursor, eState)==0 );
64069 assert( sizeof(pCur->eState)==1 );
64080 assert( offsetof(BtCursor, eState)==0 );
64100 assert( pCur!=0 );
64101 assert( pCur->eState!=CURSOR_VALID );
64130 assert( x==BTREE_SEEK_EQ || x==BTREE_BULKLOAD || x==0 );
64148 assert( sqlite3_mutex_held(pBt->mutex) );
64178 assert( sqlite3_mutex_held(pBt->mutex) );
64180 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
64182 assert( pBt->autoVacuum );
64205 assert( offset <= (int)pBt->usableSize-5 );
64235 assert( sqlite3_mutex_held(pBt->mutex) );
64249 assert( offset <= (int)pBt->usableSize-5 );
64250 assert( pEType!=0 );
64337 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64338 assert( pPage->leaf==0 );
64339 assert( pPage->childPtrSize==4 );
64358 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64359 assert( pPage->leaf==0 || pPage->leaf==1 );
64360 assert( pPage->intKeyLeaf );
64361 assert( pPage->childPtrSize==0 );
64425 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64426 assert( pPage->leaf==0 || pPage->leaf==1 );
64427 assert( pPage->intKeyLeaf==0 );
64519 assert( nSize==debuginfo.nSize || CORRUPT_DB );
64537 assert( pPage->childPtrSize==4 );
64540 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
64563 assert( pCell!=0 );
64606 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
64607 assert( pPage->pBt!=0 );
64608 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
64609 assert( pPage->nOverflow==0 );
64610 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64616 assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB );
64651 assert( cbrk+(iFree-top) <= usableSize );
64677 assert( pc>=iCellFirst && pc<=iCellLast );
64683 assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
64700 assert( pPage->nFree>=0 );
64704 assert( cbrk>=iCellFirst );
64709 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
64736 assert( pc>0 );
64802 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
64803 assert( pPage->pBt );
64804 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64805 assert( nByte>=0 ); /* Minimum cell size is 4 */
64806 assert( pPage->nFree>=nByte );
64807 assert( pPage->nOverflow==0 );
64808 assert( nByte < (int)(pPage->pBt->usableSize-8) );
64810 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
64812 assert( gap<=65536 );
64819 assert( top<=(int)pPage->pBt->usableSize ); /* Prevent by getAndInitPage() */
64838 assert( pSpace>=data && (pSpace - data)<65536 );
64851 assert( pPage->nCell>0 || CORRUPT_DB );
64852 assert( pPage->nFree>=0 );
64856 assert( gap+2+nByte<=top );
64868 assert( top+nByte <= (int)pPage->pBt->usableSize );
64896 assert( pPage->pBt!=0 );
64897 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
64898 assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize );
64899 assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize );
64900 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64901 assert( iSize>=4 ); /* Minimum cell size is 4 */
64902 assert( iStart<=pPage->pBt->usableSize-4 );
64922 assert( iFreeBlk>iPtr || iFreeBlk==0 );
64995 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
64996 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64997 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
65005 assert( (PTF_LEAFDATA|PTF_INTKEY)==5 );
65008 assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 );
65023 assert( (PTF_ZERODATA)==2 );
65026 assert( (PTF_ZERODATA|PTF_LEAF)==10 );
65055 assert( pPage->pBt!=0 );
65056 assert( pPage->pBt->db!=0 );
65057 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65058 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
65059 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
65060 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
65061 assert( pPage->isInit==1 );
65062 assert( pPage->nFree<0 );
65172 assert( pPage->pBt!=0 );
65173 assert( pPage->pBt->db!=0 );
65174 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65175 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
65176 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
65177 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
65178 assert( pPage->isInit==0 );
65187 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
65206 assert( pPage->nCell>0
65227 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
65228 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
65229 assert( sqlite3PagerGetData(pPage->pDbPage) == data );
65230 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
65231 assert( sqlite3_mutex_held(pBt->mutex) );
65247 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
65267 assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
65291 assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY );
65292 assert( sqlite3_mutex_held(pBt->mutex) );
65306 assert( sqlite3_mutex_held(pBt->mutex) );
65322 assert( sqlite3BtreeHoldsMutex(p) );
65323 assert( ((p->pBt->nPage)&0x80000000)==0 );
65349 assert( sqlite3_mutex_held(pBt->mutex) );
65350 assert( pCur==0 || ppPage==&pCur->pPage );
65351 assert( pCur==0 || bReadOnly==pCur->curPagerFlags );
65352 assert( pCur==0 || pCur->iPage>0 );
65370 assert( (*ppPage)->pgno==pgno );
65371 assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) );
65389 assert( pgno!=0 || rc==SQLITE_CORRUPT );
65400 assert( pPage->aData );
65401 assert( pPage->pBt );
65402 assert( pPage->pDbPage!=0 );
65403 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
65404 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
65405 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65412 assert( pPage!=0 );
65413 assert( pPage->aData );
65414 assert( pPage->pBt );
65415 assert( pPage->pDbPage!=0 );
65416 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
65417 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
65418 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65463 assert( sqlite3PagerPageRefcount(pData)>0 );
65465 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65484 assert( pBt->db );
65485 assert( sqlite3_mutex_held(pBt->db->mutex) );
65540 assert( db!=0 );
65541 assert( pVfs!=0 );
65542 assert( sqlite3_mutex_held(db->mutex) );
65543 assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
65546 assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
65549 assert( (flags & BTREE_SINGLE)==0 || isTempDb );
65603 assert( pBt->nRef>0 );
65643 assert( sizeof(i64)==8 );
65644 assert( sizeof(u64)==8 );
65645 assert( sizeof(u32)==4 );
65646 assert( sizeof(u16)==2 );
65647 assert( sizeof(Pgno)==4 );
65710 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
65792 assert( sqlite3_mutex_held(mutexOpen) );
65795 assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 );
65811 assert( sqlite3_mutex_notheld(pBt->mutex) );
65889 assert( sqlite3_mutex_held(p->db->mutex) );
65911 assert( p->wantToLock==0 && p->locked==0 );
65918 assert( !pBt->pCursor );
65929 assert( p->wantToLock==0 );
65930 assert( p->locked==0 );
65948 assert( sqlite3_mutex_held(p->db->mutex) );
65968 assert( sqlite3_mutex_held(p->db->mutex) );
65982 assert( sqlite3_mutex_held(p->db->mutex) );
66004 assert( sqlite3_mutex_held(p->db->mutex) );
66035 assert( nReserve>=-1 && nReserve<=255 );
66047 assert( nReserve>=0 && nReserve<=255 );
66050 assert( (pageSize & 7)==0 );
66051 assert( !pBt->pCursor );
66082 assert( sqlite3_mutex_held(p->pBt->mutex) );
66143 assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 );
66144 assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) );
66247 assert( sqlite3_mutex_held(pBt->mutex) );
66248 assert( pBt->pPage1==0 );
66340 assert( (pageSize & 7)==0 );
66404 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
66448 assert( sqlite3_mutex_held(pBt->mutex) );
66449 assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
66452 assert( pPage1->aData );
66453 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
66469 assert( sqlite3_mutex_held(pBt->mutex) );
66474 assert( pP1!=0 );
66479 assert( sizeof(zMagicHeader)==16 );
66484 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
66493 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
66494 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
66566 assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
66654 assert( p->lock.pBtree==p && p->lock.iTable==1 );
66668 assert( !pBt->pWriter );
66722 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
66761 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
66762 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
66834 assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
66836 assert( sqlite3_mutex_held(pBt->mutex) );
66837 assert( pDbPage->pBt==pBt );
66919 assert( sqlite3_mutex_held(pBt->mutex) );
66920 assert( iLastPg>nFin );
66952 assert( iFreePg==iLastPg );
66986 assert( iFreePg<iLastPg );
67042 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
67084 assert( sqlite3_mutex_held(pBt->mutex) );
67086 assert(pBt->autoVacuum);
67124 assert( nRef>=sqlite3PagerRefcount(pPager) );
67188 assert( sqlite3BtreeHoldsMutex(p) );
67259 assert( pBt->inTransaction==TRANS_WRITE );
67260 assert( pBt->nTransaction>0 );
67320 assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
67360 assert( writeOnly==1 || writeOnly==0 );
67361 assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
67371 assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
67379 assert( TRANS_WRITE==pBt->inTransaction );
67396 assert( countValidCursors(pBt, 1)==0 );
67428 assert( p->inTrans==TRANS_WRITE );
67429 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
67430 assert( iStatement>0 );
67431 assert( iStatement>p->db->nSavepoint );
67432 assert( pBt->inTransaction==TRANS_WRITE );
67459 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
67460 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
67478 assert( pBt->nPage>0 );
67537 assert( sqlite3BtreeHoldsMutex(p) );
67538 assert( wrFlag==0
67547 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1)) );
67548 assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
67551 assert( p->inTrans>TRANS_NONE );
67552 assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
67553 assert( pBt->pPage1 && pBt->pPage1->aData );
67554 assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 );
67561 assert( wrFlag==0 );
67638 assert( pBt->pCursor!=0 );
67682 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
67707 assert( pCur!=0 );
67718 assert( cursorHoldsMutex(pCur) );
67719 assert( pCur->eState==CURSOR_VALID );
67720 assert( pCur->curIntKey );
67731 assert( cursorHoldsMutex(pCur) );
67732 assert( pCur->eState==CURSOR_VALID );
67749 assert( cursorHoldsMutex(pCur) );
67750 assert( pCur->eState==CURSOR_VALID );
67769 assert( cursorHoldsMutex(pCur) );
67770 assert( pCur->eState==CURSOR_VALID );
67803 assert( sqlite3_mutex_held(pBt->mutex) );
67804 assert(pPgnoNext);
67832 assert( next==0 || rc==SQLITE_DONE );
67835 assert( rc==SQLITE_OK || pPage==0 );
67927 assert( pPage );
67928 assert( eOp==0 || eOp==1 );
67929 assert( pCur->eState==CURSOR_VALID );
67930 assert( pCur->ix<pPage->nCell );
67931 assert( cursorHoldsMutex(pCur) );
67935 assert( offset+amt <= pCur->info.nPayload );
67937 assert( aPayload > pPage->aData );
68003 assert( rc==SQLITE_OK && amt>0 );
68006 assert( pCur->aOverflow[iIdx]==0
68018 assert( pCur->curFlags & BTCF_ValidOvfl );
68019 assert( pCur->pBtree->db==pBt->db );
68057 assert( aWrite>=pBufStart ); /* due to (6) */
68112 assert( cursorHoldsMutex(pCur) );
68113 assert( pCur->eState==CURSOR_VALID );
68114 assert( pCur->iPage>=0 && pCur->pPage );
68115 assert( pCur->ix<pCur->pPage->nCell );
68135 assert( cursorOwnsBtShared(pCur) );
68141 assert( cursorOwnsBtShared(pCur) );
68173 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
68174 assert( pCur->eState==CURSOR_VALID );
68175 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68176 assert( cursorOwnsBtShared(pCur) );
68177 assert( pCur->ix<pCur->pPage->nCell );
68178 assert( pCur->info.nSize>0 );
68179 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
68180 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
68185 assert( CORRUPT_DB );
68224 assert( cursorOwnsBtShared(pCur) );
68225 assert( pCur->eState==CURSOR_VALID );
68226 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
68227 assert( pCur->iPage>=0 );
68251 assert( iIdx<=pParent->nCell );
68253 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
68255 assert( get4byte(findCell(pParent, iIdx))==iChild );
68272 assert( cursorOwnsBtShared(pCur) );
68273 assert( pCur->eState==CURSOR_VALID );
68274 assert( pCur->iPage>0 );
68275 assert( pCur->pPage );
68315 assert( cursorOwnsBtShared(pCur) );
68316 assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
68317 assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
68318 assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
68319 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
68320 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
68335 assert( pCur->iPage==(-1) );
68338 assert( pCur->skipNext!=SQLITE_OK );
68353 assert( pRoot->pgno==pCur->pgnoRoot );
68365 assert( pRoot->intKey==1 || pRoot->intKey==0 );
68403 assert( cursorOwnsBtShared(pCur) );
68404 assert( pCur->eState==CURSOR_VALID );
68406 assert( pCur->ix<pPage->nCell );
68428 assert( cursorOwnsBtShared(pCur) );
68429 assert( pCur->eState==CURSOR_VALID );
68437 assert( pCur->info.nSize==0 );
68438 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
68449 assert( cursorOwnsBtShared(pCur) );
68450 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68453 assert( pCur->pPage->nCell>0 );
68457 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68471 assert( cursorOwnsBtShared(pCur) );
68472 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68481 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
68483 assert( pCur->ix==pCur->pPage->nCell-1 );
68484 assert( pCur->pPage->leaf );
68491 assert( pCur->eState==CURSOR_VALID );
68500 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68547 assert( cursorOwnsBtShared(pCur) );
68548 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68549 assert( pRes );
68550 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
68551 assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
68591 assert( pIdxKey->default_rc==1
68602 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
68608 assert( pCur->pPage );
68609 assert( pCur->pPage->isInit );
68610 assert( pCur->eState==CURSOR_VALID );
68611 assert( pCur->pPage->nCell > 0 );
68612 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
68613 assert( pCur->curIntKey || pIdxKey );
68626 assert( pPage->nCell>0 );
68627 assert( pPage->intKey==(pIdxKey==0) );
68630 assert( biasRight==0 || biasRight==1 );
68652 assert( nCellKey==intKey );
68665 assert( lwr+upr>=0 );
68732 assert(
68741 assert( c==0 );
68749 assert( lwr+upr>=0 );
68753 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
68754 assert( pPage->isInit );
68756 assert( pCur->ix<pCur->pPage->nCell );
68774 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68803 assert( cursorOwnsBtShared(pCur) );
68804 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
68844 assert( cursorOwnsBtShared(pCur) );
68846 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
68909 assert( cursorOwnsBtShared(pCur) );
68910 assert( flags==0 || flags==1 );
68950 assert( cursorOwnsBtShared(pCur) );
68951 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
68952 assert( pCur->info.nSize==0 );
68968 assert( pPage->isInit );
68982 assert( pCur->info.nSize==0 );
68983 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
68996 assert( cursorOwnsBtShared(pCur) );
68997 assert( flags==0 || flags==1 );
69048 assert( sqlite3_mutex_held(pBt->mutex) );
69049 assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
69073 assert( nearby>0 );
69074 assert( pBt->autoVacuum );
69121 assert( pTrunk!=0 );
69122 assert( pTrunk->aData!=0 );
69130 assert( pPrevTrunk==0 );
69194 assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
69308 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
69322 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
69333 assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) );
69338 assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 );
69339 assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 );
69363 assert( sqlite3_mutex_held(pBt->mutex) );
69364 assert( CORRUPT_DB || iPage>1 );
69365 assert( !pMemPage || pMemPage->pgno==iPage );
69420 assert( pBt->usableSize>32 );
69506 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69519 assert( pBt->usableSize > 4 );
69522 assert( nOvfl>0 ||
69595 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69599 assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
69608 assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */
69612 assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
69628 assert( nSrc<=nPayload );
69666 assert( nHeader==(int)(info.pPayload - pCell) );
69667 assert( info.nKey==pX->nKey );
69668 assert( *pnSize == info.nSize );
69669 assert( spaceLeft == info.nLocal );
69680 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
69684 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
69740 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
69744 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
69776 assert( idx>=0 && idx<pPage->nCell );
69777 assert( CORRUPT_DB || sz==cellSize(pPage, idx) );
69778 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
69779 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69780 assert( pPage->nFree>=0 );
69838 assert( *pRC==SQLITE_OK );
69839 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
69840 assert( MX_CELL(pPage->pBt)<=10921 );
69841 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
69842 assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) );
69843 assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
69844 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69850 assert( sz==pPage->xCellSize(pPage, pCell) || (sz==8 && iChild>0) );
69851 assert( pPage->nFree>=0 );
69864 assert( j < ArraySize(pPage->apOvfl)-1 );
69873 assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
69874 assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */
69881 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
69883 assert( &data[pPage->cellOffset]==pPage->aCellIdx );
69888 assert( idx >= 0 );
69889 assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB );
69890 assert( idx+sz <= (int)pPage->pBt->usableSize );
69909 assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );
70019 assert( idx>=0 && idx+N<=p->nCell );
70021 assert( p->apCell[idx]!=0 );
70025 assert( CORRUPT_DB ||
70037 assert( N>=0 && N<p->nCell );
70038 assert( p->szCell[N]==0 );
70043 assert( N>=0 && N<p->nCell );
70080 assert( i<iEnd );
70092 assert( sz>0 );
70107 assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
70167 assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */
70183 assert( (pSlot+sz)<=pCArray->apCell[i]
70189 assert( CORRUPT_DB );
70238 sz = pCArray->szCell[i]; assert( sz>0 );
70241 assert( pFree>aData && (pFree - aData)<65536 );
70255 assert( pFree>aData && (pFree - aData)<65536 );
70296 assert( nCell>=0 );
70305 assert( nCell>=nTail );
70315 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
70316 assert( nAdd>=0 );
70343 assert( nCell>=0 );
70363 assert( 0==memcmp(pCell, &aData[iOff],
70406 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
70407 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
70408 assert( pPage->nOverflow==1 );
70411 assert( pPage->nFree>=0 );
70412 assert( pParent->nFree>=0 );
70428 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
70429 assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
70509 assert( pPage->isInit );
70520 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
70525 assert( n==pPage->pgno && e==PTRMAP_BTREE );
70531 assert( n==pPage->pgno && e==PTRMAP_BTREE );
70566 assert( pFrom->isInit );
70567 assert( pFrom->nFree>=iToHdr );
70568 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
70677 assert( sqlite3_mutex_held(pBt->mutex) );
70678 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
70685 assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
70686 assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx );
70691 assert( pParent->nFree>=0 );
70708 assert( bBulk==0 || bBulk==1 );
70792 assert( szScratch<=7*(int)pBt->pageSize );
70800 assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
70863 assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */
70870 assert( b.nCell<nMaxCells );
70880 assert( b.nCell<nMaxCells );
70884 assert( sz<=pBt->maxLocal+23 );
70885 assert( iSpace1 <= (int)pBt->pageSize );
70888 assert( leafCorrection==0 || leafCorrection==4 );
70891 assert( leafCorrection==0 );
70892 assert( pOld->hdrOffset==0 );
70897 assert( leafCorrection==4 );
70901 assert( b.szCell[b.nCell]==3 || CORRUPT_DB );
70902 assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB );
70940 assert( p->nFree>=0 );
71012 assert( d<nMaxCells );
71013 assert( r<nMaxCells );
71040 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
71060 assert( i>0 );
71101 assert( CORRUPT_DB );
71136 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
71174 assert( iOld<nNew || iOld<nOld );
71212 assert( j<nMaxCells );
71213 assert( b.apCell[j]!=0 );
71245 assert(leafCorrection==4);
71250 assert( sz<=pBt->maxLocal+23 );
71251 assert( iOvflSpace <= (int)pBt->pageSize );
71254 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
71281 assert( iPg>=0 && iPg<nNew );
71292 assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] );
71296 assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] );
71311 assert( apNew[iPg]->nOverflow==0 );
71312 assert( apNew[iPg]->nCell==nNewCell );
71317 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
71319 assert( nOld>0 );
71320 assert( nNew>0 );
71338 assert( nNew==1 || CORRUPT_DB );
71341 assert( apNew[0]->nFree ==
71358 assert( pParent->isInit );
71420 assert( pRoot->nOverflow>0 );
71421 assert( sqlite3_mutex_held(pBt->mutex) );
71440 assert( sqlite3PagerIswriteable(pChild->pDbPage) );
71441 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
71442 assert( pChild->nCell==pRoot->nCell || CORRUPT_DB );
71492 assert( balance_deeper_called==0 );
71501 assert( pCur->pPage->nOverflow );
71537 assert( balance_quick_called==0 );
71583 assert( pCur->iPage>=0 );
71660 assert( nTotal>=0 );
71661 assert( iOffset>=0 );
71733 assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags );
71736 assert( pCur->skipNext!=SQLITE_OK );
71740 assert( cursorOwnsBtShared(pCur) );
71741 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
71744 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
71751 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
71770 assert( pX->pKey==0 );
71780 assert( pCur->curFlags & BTCF_ValidNKey );
71781 assert( pX->nKey==pCur->info.nKey );
71782 assert( pCur->info.nSize!=0 );
71783 assert( loc==0 );
71794 assert( pX->nData>=0 && pX->nZero>=0 );
71801 assert( loc==0 );
71816 assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 );
71857 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
71860 assert( pPage->intKey || pX->nKey>=0 );
71861 assert( pPage->leaf || !pPage->intKey );
71870 assert( pPage->isInit );
71872 assert( newCell!=0 );
71875 assert( szNew==pPage->xCellSize(pPage, newCell) );
71876 assert( szNew <= MX_CELL_SIZE(pBt) );
71880 assert( idx<pPage->nCell );
71902 assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
71910 assert( pPage->leaf );
71914 assert( pPage->leaf );
71917 assert( pPage->nOverflow==0 || rc==SQLITE_OK );
71918 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
71942 assert( rc==SQLITE_OK );
71955 assert( pCur->pKey==0 );
71967 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
72002 assert( cursorOwnsBtShared(pCur) );
72003 assert( pBt->inTransaction==TRANS_WRITE );
72004 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
72005 assert( pCur->curFlags & BTCF_WriteFlag );
72006 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
72007 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
72008 assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
72013 assert( pCur->eState==CURSOR_VALID );
72053 assert( rc!=SQLITE_DONE );
72102 assert( MX_CELL_SIZE(pBt) >= nCell );
72104 assert( pTmp!=0 );
72141 assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
72142 assert( pPage==pCur->pPage || CORRUPT_DB );
72143 assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell );
72181 assert( sqlite3BtreeHoldsMutex(p) );
72182 assert( pBt->inTransaction==TRANS_WRITE );
72183 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
72216 assert( pgnoRoot>=3 || CORRUPT_DB );
72260 assert( eType!=PTRMAP_ROOTPAGE );
72261 assert( eType!=PTRMAP_FREEPAGE );
72293 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
72305 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
72313 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
72342 assert( sqlite3_mutex_held(pBt->mutex) );
72367 assert( pPage->intKey || CORRUPT_DB );
72400 assert( p->inTrans==TRANS_WRITE );
72449 assert( sqlite3BtreeHoldsMutex(p) );
72450 assert( p->inTrans==TRANS_WRITE );
72451 assert( iTable>=2 );
72519 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
72562 assert( p->inTrans>TRANS_NONE );
72563 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
72564 assert( pBt->pPage1 );
72565 assert( idx>=0 && idx<=15 );
72592 assert( idx>=1 && idx<=15 );
72594 assert( p->inTrans==TRANS_WRITE );
72595 assert( pBt->pPage1!=0 );
72602 assert( pBt->autoVacuum || iMeta==0 );
72603 assert( iMeta==0 || iMeta==1 );
72730 assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 );
72738 assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 );
72983 assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */
72989 assert( rc==SQLITE_CORRUPT );
72999 assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */
73004 assert( pPage->nCell==nCell );
73009 assert( pPage->aCellIdx==&data[cellStart] );
73037 assert( pCellIdx==&data[cellStart + i*2] );
73067 assert( pc + info.nSize - 4 <= usableSize );
73125 assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
73127 assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */
73136 assert( j==0 || j>i+size ); /* Enforced by btreeComputeFreeSpace() */
73137 assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
73217 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
73219 assert( nRef>=0 );
73326 assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
73340 assert( p->pBt->pPager!=0 );
73353 assert( p->pBt->pPager!=0 );
73361 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
73394 assert( p );
73395 assert( sqlite3_mutex_held(p->db->mutex) );
73400 assert( p );
73401 assert( sqlite3_mutex_held(p->db->mutex) );
73443 assert( sqlite3_mutex_held(p->db->mutex) );
73446 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
73460 assert( p->inTrans!=TRANS_NONE );
73463 assert( READ_LOCK+1==WRITE_LOCK );
73464 assert( isWriteLock==0 || isWriteLock==1 );
73490 assert( cursorOwnsBtShared(pCsr) );
73491 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
73492 assert( pCsr->curFlags & BTCF_Incrblob );
73498 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
73512 assert( rc==SQLITE_OK );
73524 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
73526 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
73527 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
73528 assert( pCsr->pPage->intKey );
73551 assert( iVersion==1 || iVersion==2 );
73866 assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 );
73867 assert( p->bDestLocked );
73868 assert( !isFatalError(p->rc) );
73869 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
73870 assert( zSrcData );
73956 assert( sqlite3BtreeHoldsMutex(p->pSrc) );
74038 assert( nSrcPage>=0 );
74096 assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
74097 assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
74107 assert( nDestTruncate>0 );
74126 assert( pFile );
74127 assert( nDestTruncate==0
74201 assert( rc2==SQLITE_OK );
74313 assert( p!=0 );
74315 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
74322 assert( p->pDestDb );
74326 assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
74351 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
74372 assert( sqlite3BtreeIsInTrans(pTo) );
74403 assert( b.rc!=SQLITE_OK );
74412 assert( sqlite3BtreeIsInTrans(pTo)==0 );
74453 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
74459 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
74462 assert( (p->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) );
74466 assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 );
74476 assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
74481 assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind
74489 assert( (p->flags & MEM_Cleared)==0 );
74493 assert( p->szMalloc==0
74505 assert(
74579 assert( !sqlite3VdbeMemIsRowSet(pMem) );
74580 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
74585 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74594 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
74595 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
74596 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
74610 assert( sqlite3VdbeCheckMemInvariants(pMem) );
74611 assert( !sqlite3VdbeMemIsRowSet(pMem) );
74616 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
74619 assert( pMem->szMalloc==0
74638 assert( pMem->z!=pMem->zMalloc );
74642 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
74665 assert( CORRUPT_DB || szNew>0 );
74666 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
74670 assert( (pMem->flags & MEM_Dyn)==0 );
74697 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74698 assert( !sqlite3VdbeMemIsRowSet(pMem) );
74721 assert( pMem->flags & MEM_Zero );
74722 assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
74724 assert( !sqlite3VdbeMemIsRowSet(pMem) );
74725 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74748 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74776 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74777 assert( !(fg&MEM_Zero) );
74778 assert( !(fg&(MEM_Str|MEM_Blob)) );
74779 assert( fg&(MEM_Int|MEM_Real) );
74780 assert( !sqlite3VdbeMemIsRowSet(pMem) );
74781 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
74798 assert( fg & MEM_Real );
74801 assert( pMem->z!=0 );
74821 assert( pFunc!=0 );
74822 assert( pFunc->xFinalize!=0 );
74823 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
74824 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74833 assert( (pMem->flags & MEM_Dyn)==0 );
74851 assert( pFunc!=0 );
74852 assert( pFunc->xValue!=0 );
74853 assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
74854 assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
74878 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
74879 assert( VdbeMemDynamic(p) );
74882 assert( (p->flags & MEM_Agg)==0 );
74886 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
74922 assert( sqlite3VdbeCheckMemInvariants(p) );
74976 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
74977 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
74984 assert( pMem->z || pMem->n==0 );
75004 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75005 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
75034 assert( pMem->flags & MEM_Real );
75035 assert( !sqlite3VdbeMemIsRowSet(pMem) );
75036 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75037 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
75061 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75062 assert( !sqlite3VdbeMemIsRowSet(pMem) );
75063 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
75075 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75076 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
75106 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
75107 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75122 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
75140 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
75160 assert( aff==SQLITE_AFF_TEXT );
75161 assert( MEM_Str==(MEM_Blob>>3) );
75164 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
75177 assert( (flags & ~MEM_TypeMask)==0 );
75258 assert( pMem->flags==MEM_Null );
75301 assert( db!=0 );
75302 assert( !sqlite3VdbeMemIsRowSet(pMem) );
75317 assert( p->db!=0 );
75349 assert( (mFlags&MEM_Int)==0 || pMem->u.i==pX->u.i );
75350 assert( (mFlags&MEM_Real)==0 || pMem->u.r==pX->u.r );
75351 assert( (mFlags&MEM_Str)==0 || (pMem->n==pX->n && pMem->z==pX->z) );
75352 assert( (mFlags&MEM_Blob)==0 || sqlite3BlobCompare(pMem,pX)==0 );
75373 assert( !VdbeMemDynamic(pTo) );
75377 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
75378 assert( pTo->db==pFrom->db );
75383 assert( srcType==MEM_Ephem || srcType==MEM_Static );
75395 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
75416 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
75417 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
75418 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
75452 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
75453 assert( !sqlite3VdbeMemIsRowSet(pMem) );
75468 assert( enc!=0 );
75573 assert( sqlite3BtreeCursorIsValid(pCur) );
75574 assert( !VdbeMemDynamic(pMem) );
75578 assert( !sqlite3VdbeMemIsRowSet(pMem) );
75580 assert( zData!=0 );
75599 assert( pVal!=0 );
75600 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
75601 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
75602 assert( !sqlite3VdbeMemIsRowSet(pVal) );
75603 assert( (pVal->flags & (MEM_Null))==0 );
75611 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
75619 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
75621 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
75624 assert( sqlite3VdbeMemConsistentDualRep(pVal) );
75643 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
75644 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
75645 assert( !sqlite3VdbeMemIsRowSet(pVal) );
75647 assert( sqlite3VdbeMemConsistentDualRep(pVal) );
75706 assert( pRec->pKeyInfo->nAllField==nCol );
75707 assert( pRec->pKeyInfo->enc==ENC(db) );
75769 assert( pCtx!=0 );
75770 assert( (p->flags & EP_TokenOnly)==0 );
75774 assert( pFunc );
75799 assert( pCtx->pParse->rc==SQLITE_OK );
75809 assert( rc==SQLITE_OK );
75861 assert( pExpr!=0 );
75873 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
75940 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
75941 assert( pExpr->u.zToken[1]=='\'' );
75946 assert( zVal[nVal]=='\'' );
75973 assert( *ppVal==0 );
75977 assert( pCtx==0 ); sqlite3ValueFree(pVal);
76084 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
76106 assert( pVal==0 || pVal->db==db );
76223 assert( iCol>0 );
76299 assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
76352 assert( pParse->aLabel==0 );
76353 assert( pParse->nLabel==0 );
76354 assert( p->nOpAlloc==0 );
76355 assert( pParse->szOpAlloc==0 );
76380 assert( p->zSql==0 );
76412 assert( zId!=0 );
76427 assert( pA->db==pB->db );
76487 assert( nOp<=(1024/sizeof(Op)) );
76488 assert( nNew>=(v->nOpAlloc+nOp) );
76526 assert( p->nOpAlloc<=p->nOp );
76528 assert( p->nOpAlloc>p->nOp );
76536 assert( p->magic==VDBE_MAGIC_INIT );
76537 assert( op>=0 && op<0xff );
76821 assert( v->magic==VDBE_MAGIC_INIT );
76822 assert( j<-p->nLabel );
76823 assert( j>=0 );
76832 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
76892 assert( p->iAddr<nOp );
77006 assert( p->nWrite==0 || p->usesStmtJournal );
77076 assert( pOp->p2>=0 );
77085 assert( pOp->p2>=0 );
77095 assert( (pOp - p->aOp) >= 3 );
77096 assert( pOp[-1].opcode==OP_Integer );
77107 assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
77108 assert( ADDR(pOp->p2)<-pParse->nLabel );
77117 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
77126 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
77133 assert( p->magic==VDBE_MAGIC_INIT );
77147 assert( p->nOp + N <= p->nOpAlloc );
77162 assert( p->aOp[i].opcode!=OP_ResultRow );
77191 assert( aOp && !p->db->mallocFailed );
77194 assert( DbMaskAllZero(p->btreeMask) );
77217 assert( nOp>0 );
77218 assert( p->magic==VDBE_MAGIC_INIT );
77227 assert( aOp->p2>=0 );
77298 assert( p->nOp>0 || p->db->mallocFailed );
77335 assert( db );
77412 assert( addr>=0 && addr<p->nOp );
77472 assert( p!=0 );
77474 assert( p->magic==VDBE_MAGIC_INIT );
77475 assert( p->aOp!=0 || db->mallocFailed );
77480 assert( p->nOp>0 );
77481 assert( addr<p->nOp );
77496 assert( n<0 );
77514 assert( n!=P4_INT32 && n!=P4_VTAB );
77515 assert( n<=0 );
77519 assert( pP4!=0 );
77520 assert( p->nOp>0 );
77522 assert( pOp->p4type==P4_NOTUSED );
77535 assert( v!=0 );
77536 assert( pIdx!=0 );
77549 assert( p->nOp>0 || p->aOp==0 );
77550 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
77552 assert( p->aOp );
77602 assert( p->magic==VDBE_MAGIC_INIT );
77606 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
77795 assert( nTemp>=20 );
77801 assert( pKeyInfo->aSortOrder!=0 );
77859 assert( pMem->flags & MEM_Blob );
77905 assert( zP4!=0 );
77919 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
77920 assert( i<(int)sizeof(p->btreeMask)*8 );
78046 assert( (&p[1])==pEnd || p[0].db==p[1].db );
78047 assert( sqlite3VdbeCheckMemInvariants(p) );
78099 assert( sqlite3VdbeFrameIsValid(pFrame) );
78113 assert( sqlite3VdbeFrameIsValid(p) );
78155 assert( p->explain );
78156 assert( p->magic==VDBE_MAGIC_RUN );
78157 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
78186 assert( p->nMem>9 );
78264 assert( pMem->z!=0 );
78283 assert( p->db->mallocFailed );
78292 assert( pMem->z!=0 );
78300 assert( p->db->mallocFailed );
78311 assert( p->db->mallocFailed );
78410 assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
78420 assert( EIGHT_BYTE_ALIGNMENT(pBuf) );
78432 assert( p!=0 );
78433 assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET );
78437 assert( p->nOp>0 );
78444 assert( p->aMem[i].db==p->db );
78493 assert( p!=0 );
78494 assert( p->nOp>0 );
78495 assert( pParse!=0 );
78496 assert( p->magic==VDBE_MAGIC_INIT );
78497 assert( pParse==p->pParse );
78499 assert( db->mallocFailed==0 );
78519 assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
78521 assert( x.nFree>=0 );
78522 assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
78592 assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
78604 assert( pCx->uc.pCursor!=0 );
78613 assert( pVCur->pVtab->nRef>0 );
78680 assert( p->nFrame==0 );
78693 assert( p->pAuxData==0 );
78736 assert( idx<p->nResColumn );
78737 assert( var<COLNAME_N );
78739 assert( !zName || xDel!=SQLITE_DYNAMIC );
78742 assert( p->aColName!=0 );
78745 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
78806 assert( i!=1 );
78896 assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
78925 assert( zFile[0]!=0 );
78966 assert( rc!=SQLITE_BUSY );
79032 assert( cnt==db->nVdbeActive );
79033 assert( nWrite==db->nVdbeWrite );
79034 assert( nRead==db->nVdbeRead );
79056 assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
79057 assert( db->nStatement>0 );
79058 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
79316 assert( db->nVdbeActive>=db->nVdbeRead );
79317 assert( db->nVdbeRead>=db->nVdbeWrite );
79318 assert( db->nVdbeWrite>=0 );
79334 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
79380 assert( v->db->init.busy==0 );
79440 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
79442 for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
79499 assert( (rc & p->db->errMask)==rc );
79551 assert( p->db==0 || p->db==db );
79593 assert( p!=0 );
79595 assert( sqlite3_mutex_held(db->mutex) );
79600 assert( db->pVdbe==p );
79621 assert( p->deferredMoveto );
79622 assert( p->isTable );
79623 assert( p->eCurType==CURTYPE_BTREE );
79644 assert( p->eCurType==CURTYPE_BTREE );
79645 assert( p->uc.pCursor!=0 );
79646 assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) );
79658 assert( p->eCurType==CURTYPE_BTREE );
79680 assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
79745 assert( pLen!=0 );
79780 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
79781 assert( pMem->n>=0 );
79817 assert( serial_type<12
79823 assert( serial_type<128 );
79901 assert( sizeof(v)==sizeof(pMem->u.r) );
79908 assert( i>0 );
79918 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
79974 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
79976 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
80097 assert( pKeyInfo->aSortOrder!=0 );
80122 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
80140 assert( CORRUPT_DB );
80146 assert( u<=pKeyInfo->nKeyField + 1 );
80195 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
80196 assert( pKeyInfo->aSortOrder!=0 );
80197 assert( pKeyInfo->nKeyField>0 );
80198 assert( idx1<=szHdr1 || CORRUPT_DB );
80226 assert( mem1.szMalloc==0 ); /* See comment below */
80239 assert( mem1.szMalloc==0 );
80280 assert( nKey>=0 );
80281 assert( szHdr<=(u32)nKey );
80286 assert( nField <= pKeyInfo->nAllField );
80357 assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
80358 assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
80418 assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
80468 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
80469 assert( pMem1->enc==SQLITE_UTF8 ||
80476 assert( !pColl || pColl->xCmp );
80499 assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
80588 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
80590 assert( pPKey2->pKeyInfo->aSortOrder!=0 );
80591 assert( pPKey2->pKeyInfo->nKeyField>0 );
80592 assert( idx1<=szHdr1 || CORRUPT_DB );
80678 assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
80714 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
80715 assert( mem1.szMalloc==0 ); /* See comment below */
80729 assert( mem1.szMalloc==0 );
80734 assert( CORRUPT_DB
80771 assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB );
80842 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) );
80860 assert( pPKey2->aMem[0].flags & MEM_Str );
80901 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res)
80943 assert( flags & MEM_Str );
80972 assert( sqlite3BtreeCursorIsValid(pCur) );
80974 assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
80988 assert( m.n>=0 );
81049 assert( pC->eCurType==CURTYPE_BTREE );
81051 assert( sqlite3BtreeCursorIsValid(pCur) );
81074 assert( sqlite3_mutex_held(db->mutex) );
81135 assert( iVar>0 );
81138 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
81157 assert( iVar>0 );
81158 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
81249 assert( db->pPreUpdate==0 );
81262 assert( pCsr->nField==pTab->nCol
81359 assert( p->startTime>0 );
81360 assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
81361 assert( db->init.busy==0 );
81362 assert( p->zSql!=0 );
81432 assert( (rc & (db->errMask))==rc );
81454 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
81471 assert( p->flags==MEM_Null && p->z==0 );
81635 assert( xDel!=SQLITE_DYNAMIC );
81652 assert( n>=0 );
81653 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81662 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81663 assert( xDel!=SQLITE_DYNAMIC );
81671 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81675 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81681 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81687 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81691 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81695 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81705 assert( sqlite3_mutex_held(pOut->db->mutex) );
81712 assert( sqlite3_mutex_held(pOut->db->mutex) );
81722 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81732 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81733 assert( xDel!=SQLITE_DYNAMIC );
81748 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81757 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81766 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81771 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81775 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81780 assert( sqlite3_mutex_held(pOut->db->mutex) );
81800 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81808 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
81852 assert(p);
81902 assert( db->nVdbeWrite>0 || db->autoCommit==0
81911 assert( p->startTime==0 );
81941 assert( p->rc==SQLITE_OK );
81961 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
81964 assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
82021 assert( v->expired==0 );
82033 assert( p && p->pFunc );
82048 assert( p && p->pOut );
82067 assert( p );
82082 assert( p->pVdbe!=0 );
82100 assert( (pMem->flags & MEM_Agg)==0 );
82121 assert( p && p->pFunc && p->pFunc->xFinalize );
82122 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
82144 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
82148 assert( pCtx->pVdbe!=0 );
82178 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
82182 assert( pVdbe!=0 );
82223 assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
82295 assert( pVm->db );
82333 assert( p->db!=0 );
82334 assert( sqlite3_mutex_held(p->db->mutex) );
82441 assert( db!=0 );
82446 assert( db->mallocFailed==0 );
82597 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
82662 assert( xDel!=SQLITE_DYNAMIC );
82736 assert( xDel!=SQLITE_DYNAMIC );
82803 assert( (n & 0x7FFFFFFF)==n );
82852 assert( pTo->db==pFrom->db );
82853 assert( pTo->nVar==pFrom->nVar );
82881 assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
82885 assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
83189 assert( p->op==SQLITE_UPDATE );
83197 assert( iIdx>=0 && iIdx<p->pCsr->nField );
83323 assert( n>0 && tokenType!=TK_ILLEGAL );
83383 assert( (zRawSql - zStart) > 0 );
83391 assert( n>0 );
83394 assert( zRawSql[0] || nToken==0 );
83398 assert( sqlite3Isdigit(zRawSql[1]) );
83404 assert( zRawSql[0]==':' || zRawSql[0]=='$' ||
83411 assert( idx>0 );
83415 assert( idx>0 && idx<=p->nVar );
83458 assert( pVar->flags & MEM_Blob );
83646 assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */
83647 assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */
83648 assert( I<M ); /* I can only be 2 if M is 3 or 4 */
83656 assert( (I & mNever)==0 );
83744 assert( iCur>=0 && iCur<p->nCursor );
83789 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
83830 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
83889 assert( (pMem->flags & (MEM_Int|MEM_Real))==0 );
83890 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
83934 assert( (f & (MEM_Static|MEM_Ephem))==0 );
83937 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
83940 assert( (f & (MEM_Static|MEM_Dyn))==0 );
83967 assert( (f & (MEM_Static|MEM_Ephem))==0 );
83970 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
83973 assert( (f & (MEM_Static|MEM_Dyn))==0 );
84152 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
84168 assert( pOp->p2>0 );
84169 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
84215 assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
84220 assert( 0 < db->nProgressOps );
84231 assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
84232 assert( p->bIsReader || p->readOnly!=0 );
84234 assert( p->explain==0 );
84269 assert( rc==SQLITE_OK );
84271 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
84306 assert( pOp->p1>0 );
84307 assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
84308 assert( memIsValid(&aMem[pOp->p1]) );
84309 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
84313 assert( pOp->p2>0 );
84314 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
84315 assert( memIsValid(&aMem[pOp->p2]) );
84316 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
84320 assert( pOp->p3>0 );
84321 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
84322 assert( memIsValid(&aMem[pOp->p3]) );
84323 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
84327 assert( pOp->p2>0 );
84328 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
84332 assert( pOp->p3>0 );
84333 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
84415 assert( db->nProgressOps!=0 );
84434 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
84436 assert( VdbeMemDynamic(pIn1)==0 );
84456 assert( pIn1->flags==MEM_Int );
84474 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
84475 assert( pOp->p2>=0 && pOp->p2<p->nOp );
84476 assert( pOp->p3>=0 && pOp->p3<p->nOp );
84478 assert( !VdbeMemDynamic(pOut) );
84496 assert( pIn1->flags==MEM_Int );
84497 assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
84499 assert( pCaller->opcode==OP_Yield );
84500 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
84522 assert( VdbeMemDynamic(pIn1)==0 );
84609 assert( pOp->p5<=4 );
84628 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
84632 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
84633 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
84658 assert( pOp->p4.pI64!=0 );
84673 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
84688 assert( pOp->p4.z!=0 );
84696 assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
84699 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
84700 assert( VdbeMemDynamic(pOut)==0 );
84714 assert( rc==SQLITE_OK );
84731 assert( pOp->p4.z!=0 );
84740 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
84742 assert( pIn3->flags & MEM_Int );
84766 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
84792 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
84805 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
84824 assert( pOp->p1>0 && pOp->p1<=p->nVar );
84825 assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
84856 assert( n>0 && p1>0 && p2>0 );
84857 assert( p1+n<=p2 || p2+n<=p1 );
84862 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
84863 assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
84864 assert( memIsValid(pIn1) );
84894 assert( pOut!=pIn1 );
84926 assert( pOut!=pIn1 );
84945 assert( (pIn1->flags & MEM_Int)!=0 );
84963 assert( p->nResColumn==pOp->p2 );
84964 assert( pOp->p1>0 );
84965 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
84971 assert( db->flags&SQLITE_CountRows );
84972 assert( p->usesStmtJournal );
84991 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
84993 assert( rc==SQLITE_OK );
85004 assert( memIsValid(&pMem[i]) );
85006 assert( (pMem[i].flags & MEM_Ephem)==0
85043 assert( pIn1!=pOut );
85216 assert( pOp->p4type==P4_COLLSEQ );
85277 assert( op==OP_ShiftRight || op==OP_ShiftLeft );
85281 assert( OP_ShiftRight==OP_ShiftLeft+1 );
85383 assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
85517 assert( (flags1 & MEM_Cleared)==0 );
85518 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
85553 assert( flags3==pIn3->flags );
85580 assert( pIn1!=pIn3 );
85590 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
85600 assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
85601 assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
85614 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
85616 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
85630 assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq );
85631 assert( res2==0 || res2==1 );
85660 assert( pOp>aOp );
85661 assert( pOp[-1].opcode==OP_Lt || pOp[-1].opcode==OP_Gt );
85662 assert( pOp[-1].p5 & SQLITE_STOREP2 );
85682 assert( pOp->p4type==P4_INTARRAY );
85683 assert( pOp->p4.ai );
85684 assert( pOp[1].opcode==OP_Compare );
85685 assert( pOp[1].p5 & OPFLAG_PERMUTE );
85723 assert( pOp>aOp );
85724 assert( pOp[-1].opcode==OP_Permutation );
85725 assert( pOp[-1].p4type==P4_INTARRAY );
85727 assert( aPermute!=0 );
85731 assert( n>0 );
85732 assert( pKeyInfo!=0 );
85739 assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
85740 assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
85742 assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
85743 assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
85748 assert( memIsValid(&aMem[p1+idx]) );
85749 assert( memIsValid(&aMem[p2+idx]) );
85752 assert( i<pKeyInfo->nKeyField );
85846 assert( pOp->p4type==P4_INT32 );
85847 assert( pOp->p4.i==0 || pOp->p4.i==1 );
85848 assert( pOp->p3==0 || pOp->p3==1 );
85909 assert( p->aOp[0].opcode==OP_Init );
85993 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
85994 assert( p->apCsr[pOp->p1]!=0 );
86020 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
86082 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
86085 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
86086 assert( pC!=0 );
86087 assert( p2<pC->nField );
86089 assert( pC->eCurType!=CURTYPE_VTAB );
86090 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
86091 assert( pC->eCurType!=CURTYPE_SORTER );
86098 assert( pC->seekResult>0 );
86100 assert( pReg->flags & MEM_Blob );
86101 assert( memIsValid(pReg) );
86110 assert( pC->eCurType==CURTYPE_BTREE );
86111 assert( pCrsr );
86112 assert( sqlite3BtreeCursorIsValid(pCrsr) );
86115 assert( pC->szRow<=pC->payloadSize );
86116 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
86161 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
86248 assert( p2<pC->nHdrParsed );
86249 assert( rc==SQLITE_OK );
86250 assert( sqlite3VdbeCheckMemInvariants(pDest) );
86254 assert( t==pC->aType[p2] );
86336 assert( zAffinity!=0 );
86337 assert( pOp->p2>0 );
86338 assert( zAffinity[pOp->p2]==0 );
86341 assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
86342 assert( memIsValid(pIn1) );
86403 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
86410 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
86416 assert( pData0<=pLast );
86421 assert( zAffinity[0]==0 || pRec<=pLast );
86444 assert( memIsValid(pRec) );
86454 assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
86513 assert( pData0<=pLast );
86524 assert( i==nHdr );
86525 assert( j==nByte );
86527 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
86550 assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
86552 assert( pCrsr );
86584 assert( db->pSavepoint==0 || db->autoCommit==0 );
86585 assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
86586 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
86587 assert( checkSavepointCount(db) );
86588 assert( p->bIsReader );
86605 assert( db->autoCommit==0 || db->nVTrans==0 );
86716 assert( pSavepoint==db->pSavepoint );
86753 assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
86754 assert( desiredAutoCommit==1 || iRollback==0 );
86755 assert( db->nVdbeActive>0 ); /* At least this one VM is active */
86756 assert( p->bIsReader );
86760 assert( desiredAutoCommit==1 );
86782 assert( db->nStatement==0 );
86840 assert( p->bIsReader );
86841 assert( p->readOnly==0 || pOp->p2==0 );
86842 assert( pOp->p1>=0 && pOp->p1<db->nDb );
86843 assert( DbMaskTest(p->btreeMask, pOp->p1) );
86866 assert( sqlite3BtreeIsInTrans(pBt) );
86868 assert( db->nStatement>=0 && db->nSavepoint>=0 );
86885 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
86937 assert( p->bIsReader );
86940 assert( pOp->p3<SQLITE_N_BTREE_META );
86941 assert( iDb>=0 && iDb<db->nDb );
86942 assert( db->aDb[iDb].pBt!=0 );
86943 assert( DbMaskTest(p->btreeMask, iDb) );
86965 assert( pOp->p2<SQLITE_N_BTREE_META );
86966 assert( pOp->p1>=0 && pOp->p1<db->nDb );
86967 assert( DbMaskTest(p->btreeMask, pOp->p1) );
86968 assert( p->readOnly==0 );
86970 assert( pDb->pBt!=0 );
86971 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
87086 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
87087 assert( pOp->p4type==P4_KEYINFO );
87090 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
87098 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
87099 assert( p->bIsReader );
87100 assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
87112 assert( iDb>=0 && iDb<db->nDb );
87113 assert( DbMaskTest(p->btreeMask, iDb) );
87116 assert( pX!=0 );
87118 assert( OPFLAG_FORDELETE==BTREE_FORDELETE );
87120 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
87128 assert( p2>0 );
87129 assert( p2<=(p->nMem+1 - p->nCursor) );
87130 assert( pOp->opcode==OP_OpenWrite );
87132 assert( memIsValid(pIn2) );
87133 assert( (pIn2->flags & MEM_Int)!=0 );
87140 assert( p2>=2 );
87144 assert( pKeyInfo->enc==ENC(db) );
87145 assert( pKeyInfo->db==db );
87150 assert( pOp->p1>=0 );
87151 assert( nField>=0 );
87170 assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
87171 assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
87195 assert( pOrig->pBtx!=0 ); /* Only ephemeral cursors can be duplicated */
87210 assert( rc==SQLITE_OK );
87255 assert( pOp->p1>=0 );
87256 assert( pOp->p2>=0 );
87280 assert( pOp->p4type==P4_KEYINFO );
87284 assert( pCx->pgnoRoot==MASTER_ROOT+1 );
87285 assert( pKeyInfo->db==db );
87286 assert( pKeyInfo->enc==ENC(db) );
87317 assert( pOp->p1>=0 );
87318 assert( pOp->p2>=0 );
87322 assert( pCx->pKeyInfo->db==db );
87323 assert( pCx->pKeyInfo->enc==ENC(db) );
87338 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87340 assert( isSorter(pC) );
87366 assert( pOp->p1>=0 );
87367 assert( pOp->p3>=0 );
87378 assert( pOp->p5==0 );
87388 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87408 assert( pC->eCurType==CURTYPE_BTREE );
87512 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87513 assert( pOp->p2!=0 );
87515 assert( pC!=0 );
87516 assert( pC->eCurType==CURTYPE_BTREE );
87517 assert( OP_SeekLE == OP_SeekLT+1 );
87518 assert( OP_SeekGE == OP_SeekLT+2 );
87519 assert( OP_SeekGT == OP_SeekLT+3 );
87520 assert( pC->isOrdered );
87521 assert( pC->uc.pCursor!=0 );
87531 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
87561 assert( OP_SeekGE==(OP_SeekGT-1) );
87562 assert( OP_SeekLT==(OP_SeekLE-1) );
87563 assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
87570 assert( OP_SeekLE==(OP_SeekLT+1) );
87571 assert( OP_SeekGT==(OP_SeekGE+1) );
87572 assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
87588 assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
87589 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
87590 assert( pOp[1].p1==pOp[0].p1 );
87591 assert( pOp[1].p2==pOp[0].p2 );
87592 assert( pOp[1].p3==pOp[0].p3 );
87593 assert( pOp[1].p4.i==pOp[0].p4.i );
87597 assert( pOp->p4type==P4_INT32 );
87598 assert( nField>0 );
87610 assert( oc!=OP_SeekGT || r.default_rc==-1 );
87611 assert( oc!=OP_SeekLE || r.default_rc==-1 );
87612 assert( oc!=OP_SeekGE || r.default_rc==+1 );
87613 assert( oc!=OP_SeekLT || r.default_rc==+1 );
87617 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
87625 assert( res!=0 );
87634 if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT );
87650 assert( oc==OP_SeekLT || oc==OP_SeekLE );
87670 assert( pOp->p2>0 );
87675 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
87692 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87694 assert( pC!=0 );
87695 assert( pOp->p2==0 || pOp->p2==1 );
87788 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87790 assert( pC!=0 );
87810 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87811 assert( pOp->p4type==P4_INT32 );
87813 assert( pC!=0 );
87818 assert( pC->eCurType==CURTYPE_BTREE );
87819 assert( pC->uc.pCursor!=0 );
87820 assert( pC->isTable==0 );
87827 assert( memIsValid(&r.aMem[ii]) );
87828 assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
87835 assert( pIn3->flags & MEM_Blob );
87837 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
87945 assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
87946 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87948 assert( pC!=0 );
87952 assert( pC->isTable );
87953 assert( pC->eCurType==CURTYPE_BTREE );
87955 assert( pCrsr!=0 );
87959 assert( rc==SQLITE_OK || res==0 );
87967 assert( rc==SQLITE_OK );
87987 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
87988 assert( p->apCsr[pOp->p1]!=0 );
87989 assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
88022 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88024 assert( pC!=0 );
88025 assert( pC->isTable );
88026 assert( pC->eCurType==CURTYPE_BTREE );
88027 assert( pC->uc.pCursor!=0 );
88042 assert( pC->isTable );
88062 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
88075 assert( pOp->p3>0 );
88079 assert( pOp->p3<=pFrame->nMem );
88083 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
88087 assert( memIsValid(pMem) );
88091 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
88107 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
88122 assert( v>0 ); /* EV: R-40812-03570 */
88178 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88179 assert( memIsValid(pData) );
88181 assert( pC!=0 );
88182 assert( pC->eCurType==CURTYPE_BTREE );
88183 assert( pC->uc.pCursor!=0 );
88184 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
88185 assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
88190 assert( pKey->flags & MEM_Int );
88191 assert( memIsValid(pKey) );
88196 assert( pC->iDb>=0 );
88199 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
88221 assert( pData->flags & (MEM_Blob|MEM_Str) );
88240 assert( db->xUpdateCallback!=0 );
88241 assert( pTab->aCol!=0 );
88291 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88293 assert( pC!=0 );
88294 assert( pC->eCurType==CURTYPE_BTREE );
88295 assert( pC->uc.pCursor!=0 );
88296 assert( pC->deferredMoveto==0 );
88305 assert( pC->movetoTarget==iKey );
88315 assert( pC->iDb>=0 );
88316 assert( pOp->p4.pTab!=0 );
88330 assert( !(opflags & OPFLAG_ISUPDATE)
88344 assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
88345 assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
88346 assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
88373 assert( pC->iDb>=0 );
88413 assert( isSorter(pC) );
88414 assert( pOp->p4type==P4_INT32 );
88442 assert( isSorter(pC) );
88444 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
88445 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88486 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88488 assert( pC!=0 );
88489 assert( pC->eCurType==CURTYPE_BTREE );
88490 assert( isSorter(pC)==0 );
88491 assert( pC->nullRow==0 );
88492 assert( pC->uc.pCursor!=0 );
88503 assert( pC->deferredMoveto==0 );
88504 assert( sqlite3BtreeCursorIsValid(pCrsr) );
88540 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88542 assert( pC!=0 );
88543 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
88551 assert( pC->uc.pVCur!=0 );
88554 assert( pModule->xRowid );
88560 assert( pC->eCurType==CURTYPE_BTREE );
88561 assert( pC->uc.pCursor!=0 );
88583 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88585 assert( pC!=0 );
88589 assert( pC->uc.pCursor!=0 );
88626 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88628 assert( pC!=0 );
88629 assert( pC->eCurType==CURTYPE_BTREE );
88632 assert( pCrsr!=0 );
88637 assert( pOp->p2==0 );
88666 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88668 assert( pC!=0 );
88670 assert( pCrsr );
88730 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88731 assert( pOp->p5==0 );
88733 assert( pC!=0 );
88734 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
88742 assert( pC->eCurType==CURTYPE_BTREE );
88744 assert( pCrsr );
88751 assert( pOp->p2>0 && pOp->p2<p->nOp );
88821 assert( isSorter(pC) );
88826 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88827 assert( pOp->p5<ArraySize(p->aCounter) );
88829 assert( pC!=0 );
88830 assert( pC->deferredMoveto==0 );
88831 assert( pC->eCurType==CURTYPE_BTREE );
88832 assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
88833 assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
88837 assert( pOp->opcode!=OP_Next
88841 assert( pOp->opcode!=OP_Prev
88904 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88907 assert( pC!=0 );
88908 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
88910 assert( pIn2->flags & MEM_Blob );
88912 assert( pC->eCurType==CURTYPE_BTREE || pOp->opcode==OP_SorterInsert );
88913 assert( pC->isTable==0 );
88927 assert( pC->deferredMoveto==0 );
88947 assert( pOp->p3>0 );
88948 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
88949 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
88951 assert( pC!=0 );
88952 assert( pC->eCurType==CURTYPE_BTREE );
88955 assert( pCrsr!=0 );
88956 assert( pOp->p5==0 );
88967 assert( pC->deferredMoveto==0 );
89007 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
89009 assert( pC!=0 );
89010 assert( pC->eCurType==CURTYPE_BTREE );
89011 assert( pC->uc.pCursor!=0 );
89012 assert( pC->isTable==0 );
89013 assert( pC->deferredMoveto==0 );
89014 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
89032 assert( pOp->p3>=0 && pOp->p3<p->nCursor );
89034 assert( pTabCur!=0 );
89035 assert( pTabCur->eCurType==CURTYPE_BTREE );
89036 assert( pTabCur->uc.pCursor!=0 );
89037 assert( pTabCur->isTable );
89041 assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
89049 assert( pOp->opcode==OP_IdxRowid );
89107 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
89109 assert( pC!=0 );
89110 assert( pC->isOrdered );
89111 assert( pC->eCurType==CURTYPE_BTREE );
89112 assert( pC->uc.pCursor!=0);
89113 assert( pC->deferredMoveto==0 );
89114 assert( pOp->p5==0 || pOp->p5==1 );
89115 assert( pOp->p4type==P4_INT32 );
89119 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
89122 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
89130 assert( memIsValid(&r.aMem[i]) );
89137 assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
89139 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
89142 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
89183 assert( p->readOnly==0 );
89184 assert( pOp->p1>1 );
89193 assert( DbMaskTest(p->btreeMask, iDb) );
89203 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
89234 assert( p->readOnly==0 );
89235 assert( DbMaskTest(p->btreeMask, pOp->p2) );
89242 assert( memIsValid(&aMem[pOp->p3]) );
89262 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
89264 assert( pC!=0 );
89268 assert( pC->eCurType==CURTYPE_BTREE );
89269 assert( pC->isEphemeral );
89292 assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
89293 assert( pOp->p1>=0 && pOp->p1<db->nDb );
89294 assert( DbMaskTest(p->btreeMask, pOp->p1) );
89295 assert( p->readOnly==0 );
89297 assert( pDb->pBt!=0 );
89338 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
89343 assert( iDb>=0 && iDb<db->nDb );
89344 assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
89367 assert( db->init.busy==0 );
89371 assert( !db->mallocFailed );
89402 assert( pOp->p1>=0 && pOp->p1<db->nDb );
89479 assert( p->bIsReader );
89482 assert( nRoot>0 );
89483 assert( aRoot[0]==nRoot );
89484 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
89486 assert( (pnErr->flags & MEM_Int)!=0 );
89487 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
89489 assert( pOp->p5<db->nDb );
89490 assert( DbMaskTest(p->btreeMask, pOp->p5) );
89495 assert( z==0 );
89519 assert( (pIn2->flags & MEM_Int)!=0 );
89523 assert( sqlite3VdbeMemIsRowSet(pIn1) );
89540 assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
89586 assert( pIn3->flags&MEM_Int );
89594 assert( sqlite3VdbeMemIsRowSet(pIn1) );
89595 assert( pOp->p4type==P4_INT32 );
89596 assert( iSet==-1 || iSet>=0 );
89638 assert( pProgram->nOp>0 );
89674 assert( nMem>0 );
89715 assert( pRt->xDel==sqlite3VdbeFrameMemDel );
89716 assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
89718 assert( pProgram->nCsr==pFrame->nChildCsr );
89719 assert( (int)(pOp - aOp)==pFrame->pc );
89727 assert( pFrame->pAuxData==0 );
89846 assert( memIsValid(pIn1) );
89869 assert( pIn1->flags&MEM_Int );
89901 assert( pIn1->flags & MEM_Int );
89902 assert( pIn3->flags & MEM_Int );
89929 assert( pIn1->flags&MEM_Int );
89946 assert( pIn1->flags&MEM_Int );
89998 assert( pOp->p4type==P4_FUNCDEF );
90000 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
90001 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
90002 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
90019 assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
90029 assert( pOp->p4type==P4_FUNCCTX );
90037 assert( pMem->uTemp==0x1122e0e3 );
90055 assert( memIsValid(pCtx->argv[i]) );
90061 assert( pCtx->pOut->flags==MEM_Null );
90062 assert( pCtx->isError==0 );
90063 assert( pCtx->skipFlag==0 );
90077 assert( pOp[-1].opcode==OP_CollSeq );
90087 assert( pCtx->pOut->flags==MEM_Null );
90088 assert( pCtx->skipFlag==0 );
90121 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
90122 assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
90124 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
90165 assert( p->readOnly==0 );
90168 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
90209 assert( eNew==PAGER_JOURNALMODE_DELETE
90217 assert( pOp->p1>=0 && pOp->p1<db->nDb );
90218 assert( p->readOnly==0 );
90270 assert( sqlite3BtreeIsInTrans(pBt)==0 );
90302 assert( p->readOnly==0 );
90320 assert( pOp->p1>=0 && pOp->p1<db->nDb );
90321 assert( DbMaskTest(p->btreeMask, pOp->p1) );
90322 assert( p->readOnly==0 );
90352 assert( pOp->p2==0 || pOp->p2==1 );
90381 assert( p1>=0 && p1<db->nDb );
90382 assert( DbMaskTest(p->btreeMask, p1) );
90383 assert( isWriteLock==0 || isWriteLock==1 );
90431 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
90432 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
90434 assert( rc==SQLITE_OK );
90436 assert( zTab || db->mallocFailed );
90456 assert( p->errorAction==OE_Abort && p->usesStmtJournal );
90475 assert( p->bIsReader );
90497 assert( db->mallocFailed );
90541 assert( memIsValid(pQuery) );
90543 assert( pCur->eCurType==CURTYPE_VTAB );
90549 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
90592 assert( pCur->eCurType==CURTYPE_VTAB );
90593 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
90602 assert( pModule->xColumn );
90646 assert( pCur->eCurType==CURTYPE_VTAB );
90652 assert( pModule->xNext );
90689 assert( pVtab->pModule->xRename );
90690 assert( memIsValid(pName) );
90691 assert( p->readOnly==0 );
90693 assert( pName->flags & MEM_Str );
90745 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
90748 assert( p->readOnly==0 );
90758 assert( pOp->p4type==P4_VTAB );
90764 assert( memIsValid(pX) );
90774 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
90876 assert( pOp->p4type==P4_FUNCDEF );
90878 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
90879 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
90880 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
90891 assert( OP_PureFunc == OP_PureFunc0+2 );
90892 assert( OP_Function == OP_Function0+2 );
90901 assert( pOp->p4type==P4_FUNCCTX );
90917 assert( memIsValid(pCtx->argv[i]) );
90922 assert( pCtx->isError==0 );
90988 assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
90991 assert( pOp==p->aOp || pOp->opcode==OP_Trace );
91032 assert( pOp->p2>0 );
91056 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
91057 assert( pOp->p4type==P4_EXPR );
91060 assert( pC->eCurType==CURTYPE_BTREE );
91096 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
91123 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
91145 assert( rc );
91177 assert( rc!=SQLITE_OK || nExtraDelete==0
91202 assert( db->u1.isInterrupted );
91282 assert( v->aOp[v->pc].opcode==OP_NotExists );
91320 assert( rc!=SQLITE_OK || zErr==0 );
91321 assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
91455 assert( pBlob->pStmt || db->mallocFailed );
91491 assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
91498 assert( aOp!=0 );
91612 assert( db == v->db );
91709 assert( rc!=SQLITE_SCHEMA );
91713 assert( rc==SQLITE_OK || p->pStmt==0 );
92221 assert( p->aBuffer );
92237 assert( nRead>0 );
92241 assert( rc!=SQLITE_IOERR_SHORT_READ );
92286 assert( aNext!=p->aAlloc );
92359 assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 );
92454 assert( pFile->iEof>iStart );
92455 assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 );
92456 assert( pReadr->aBuffer==0 );
92457 assert( pReadr->aMap==0 );
92579 assert( (s1>0 && s1<7) || s1==8 || s1==9 );
92580 assert( (s2>0 && s2<7) || s2==8 || s2==9 );
92606 assert( res!=0 );
92682 assert( pCsr->pKeyInfo && pCsr->pBtx==0 );
92683 assert( pCsr->eCurType==CURTYPE_SORTER );
92727 assert( pSorter->iMemory==0 );
92771 assert( pTask->list.aMemory==0 );
92837 assert( pTask->bDone==1 );
92852 assert( pTask->pThread==0 && pTask->bDone==0 );
92895 assert( nReader<=SORTER_MAX_MERGE_COUNT );
92947 assert( pSorter->bUseThreads || pSorter->pReader==0 );
92979 assert( pCsr->eCurType==CURTYPE_SORTER );
93068 assert( p1!=0 && p2!=0 );
93138 assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
93162 assert( pTask->pUnpacked->errCode==SQLITE_OK
93211 assert( p->iBufEnd<p->nBuffer );
93279 assert( pList->szPMA>0 );
93284 assert( rc!=SQLITE_OK || pTask->file.pFd );
93285 assert( pTask->file.iEof==0 );
93286 assert( pTask->nPMA==0 );
93318 assert( rc!=SQLITE_OK || pList->pList==0 );
93319 assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
93404 assert( pTask->bDone==0 );
93455 assert( pTask->pThread==0 && pTask->bDone==0 );
93456 assert( pTask->list.pList==0 );
93457 assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
93494 assert( pCsr->eCurType==CURTYPE_SORTER );
93505 assert( pSorter );
93538 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
93602 assert( pIncr->bEof==0 );
93621 assert( pIncr->pMerger->pTask==pTask );
93648 assert( pIncr->bUseThread );
93756 assert( iOut<pMerger->nTree && iOut>0 );
93777 assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */
93839 assert( pMerger!=0 );
93842 assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
93845 assert( pMerger->pTask==0 );
93911 assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
93930 assert( pTask->file2.iEof>0 );
93954 assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK );
93997 assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK );
94147 assert( pSorter->bUseThreads || pSorter->nTask==1 );
94156 assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 );
94188 assert( pMain==0 );
94230 assert( pSorter->bUseThreads==0 || pSorter->nTask>1 );
94249 assert( pIncr->pTask!=pLast );
94263 assert( p->pIncr==0 || (
94300 assert( pCsr->eCurType==CURTYPE_SORTER );
94302 assert( pSorter );
94321 assert( pSorter->list.pList );
94331 assert( pSorter->pReader==0 );
94352 assert( pCsr->eCurType==CURTYPE_SORTER );
94354 assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
94356 assert( pSorter->pReader==0 || pSorter->pMerger==0 );
94357 assert( pSorter->bUseThreads==0 || pSorter->pReader );
94358 assert( pSorter->bUseThreads==1 || pSorter->pMerger );
94367 assert( pSorter->pMerger!=0 );
94368 assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
94417 assert( pCsr->eCurType==CURTYPE_SORTER );
94458 assert( pCsr->eCurType==CURTYPE_SORTER );
94467 assert( r2->nField==nKeyCol );
94589 assert( (iAmt+iOfst)<=p->endpoint.iOffset );
94590 assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 );
94601 assert( pChunk!=0 );
94701 assert( iOfst==p->endpoint.iOffset || iOfst==0 );
94705 assert( p->nChunkSize>iAmt );
94709 assert( iOfst>0 || p->pFirst==0 );
94725 assert( p->pFirst );
94728 assert( !p->pFirst );
94854 assert( MEMJOURNAL_DFLT_FILECHUNKSIZE==fileChunkSize(p->nChunkSize) );
94984 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
95040 assert( rc==WRC_Continue );
95061 assert( pSrc!=0 );
95186 assert( iCol>=0 && iCol<pEList->nExpr );
95188 assert( pOrig!=0 );
95208 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
95312 assert( pNC ); /* the name context cannot be NULL. */
95313 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
95314 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
95335 assert( db->aDb[i].zDbSName );
95345 assert( pNC && cnt==0 );
95353 assert( pTab!=0 && pTab->zName!=0 );
95354 assert( pTab->nCol>0 );
95374 assert( zTabName!=0 );
95407 assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
95425 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
95538 assert( pEList!=0 );
95543 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
95544 assert( pExpr->x.pList==0 );
95545 assert( pExpr->x.pSelect==0 );
95562 assert( zTab==0 && zDb==0 );
95591 assert( pExpr->op==TK_ID );
95651 assert( pMatch->iCursor==pExpr->iTable );
95665 assert( pNC!=0 );
95672 assert( pTopNC!=0 );
95715 assert( (validMask&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr))==0 );
95735 assert( r>=0.0 );
95756 assert( pNC!=0 );
95758 assert( pParse==pWalker->pParse );
95765 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
95779 assert( pSrcList && pSrcList->nSrc==1 );
95781 assert( HasRowid(pItem->pTab) && pItem->pTab->pSelect==0 );
95818 assert( pRight->op==TK_DOT );
95847 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
95923 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
96003 assert( pDef!=0 );
96005 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
96028 assert( pNC->nRef>=nRef );
96043 assert( !ExprHasProperty(pExpr, EP_Reduced) );
96066 assert( pExpr->pLeft!=0 );
96074 assert( pExpr->pRight!=0 );
96158 assert( sqlite3ExprIsInteger(pE, &i)==0 );
96248 assert( pEList!=0 );
96281 assert(pDup);
96301 assert( pParent->op==TK_COLLATE );
96303 assert( pParent->pLeft==pE );
96353 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
96491 assert( p!=0 );
96516 assert( (p->selFlags & SF_Expanded)!=0 );
96517 assert( (p->selFlags & SF_Resolved)==0 );
96538 assert( p->pSrc->nSrc==1 && p->pOrderBy );
96539 assert( pSub->pPrior && pSub->pOrderBy==0 );
96566 assert( pItem->fg.isCorrelated==0 && nRef<=0 );
96585 assert( (p->selFlags & SF_Aggregate)==0 );
96588 assert( NC_MinMaxAgg==SF_MinMaxAgg );
96609 assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 );
96789 assert( EP_Agg==NC_HasAgg );
96790 assert( EP_Win==NC_HasWin );
96835 assert( p!=0 );
96870 assert( type==0 || pTab!=0 );
96871 assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr || pTab==0 );
96914 assert( iCol<pTab->nCol );
96940 assert( pExpr->flags&EP_xIsSelect );
96946 assert( !ExprHasProperty(pExpr, EP_IntValue) );
96954 assert( pExpr->pLeft->flags&EP_xIsSelect );
96988 assert( zC!=0 );
97000 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
97001 assert( pExpr->x.pList->nExpr>0 );
97002 assert( pExpr->op==TK_FUNCTION );
97005 assert( pExpr->op==TK_COLLATE );
97060 assert( p->x.pList==0 || p->pRight==0 );
97098 assert( p!=0 );
97134 assert( aff1==0 || aff2==0 );
97145 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
97148 assert( pExpr->pLeft );
97206 assert( pLeft );
97291 assert( i<sqlite3ExprVectorSize(pVector) );
97293 assert( pVector->op2==0 || pVector->op==TK_REGISTER );
97331 assert( pVector->flags & EP_xIsSelect );
97353 assert( pRet==0 || pRet->iTable==0 );
97407 assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT );
97452 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
97457 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
97459 assert( p5==0 || pExpr->op!=op );
97460 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
97473 assert( i>=0 && i<nLeft );
97495 assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE );
97650 assert( db!=0 );
97655 assert( iValue>=0 );
97669 assert( pToken->z!=0 || pToken->n==0 );
97712 assert( db->mallocFailed );
97770 assert( pParse->db->mallocFailed );
97839 assert( pToken );
97850 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
97878 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
97880 assert( z!=0 );
97881 assert( z[0]!=0 );
97882 assert( n==(u32)sqlite3Strlen30(z) );
97885 assert( z[0]=='?' );
97941 assert( p!=0 );
97943 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
97945 assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed );
97946 assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced)
97950 assert( p->pLeft==0 );
97951 assert( p->pRight==0 );
97952 assert( p->x.pSelect==0 );
97957 assert( p->x.pList==0 || p->pRight==0 );
97967 assert( p->op==TK_FUNCTION );
98037 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
98038 assert( EXPR_FULLSIZE<=0xfff );
98039 assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 );
98047 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
98048 assert( !ExprHasProperty(p, EP_FromJoin) );
98049 assert( !ExprHasProperty(p, EP_MemToken) );
98050 assert( !ExprHasProperty(p, EP_NoReduce) );
98054 assert( p->pRight==0 );
98111 assert( db!=0 );
98112 assert( p );
98113 assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE );
98114 assert( pzBuffer==0 || dupFlags==EXPRDUP_REDUCE );
98141 assert( ExprHasProperty(p, EP_Reduced)==0 );
98183 assert( ExprHasProperty(pNew, EP_WinFunc) );
98193 assert( p->iColumn==0 || p->pRight==0 );
98194 assert( p->pRight==0 || p->pRight==p->pLeft );
98241 assert( ExprHasProperty(pExpr, EP_WinFunc) );
98280 assert( flags==0 || flags==EXPRDUP_REDUCE );
98288 assert( db!=0 );
98303 assert( pNewExpr->iColumn==0 || i>0 );
98305 assert( pOldExpr->pLeft==pOldExpr->pRight );
98308 assert( i>0 );
98309 assert( pItem[-1].pExpr!=0 );
98310 assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
98311 assert( pPriorSelectCol==pItem[-1].pExpr->pLeft );
98338 assert( db!=0 );
98378 assert( db!=0 );
98405 assert( db!=0 );
98441 assert( p==0 );
98469 assert( db!=0 );
98486 assert( offsetof(struct ExprList_item,zName)==sizeof(pItem->pExpr) );
98487 assert( offsetof(struct ExprList_item,pExpr)==0 );
98540 assert( pList->nExpr==iFirst+i+1 );
98548 assert( pFirst!=0 );
98549 assert( pFirst->op==TK_SELECT_COLUMN );
98575 assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC>=0 && SQLITE_SO_DESC>0 );
98576 assert( p->nExpr>0 );
98578 assert( p->a[p->nExpr-1].sortOrder==SQLITE_SO_ASC );
98598 assert( pList!=0 || pParse->db->mallocFailed!=0 );
98601 assert( pList->nExpr>0 );
98603 assert( pItem->zName==0 );
98627 assert( pList!=0 || db->mallocFailed!=0 );
98630 assert( pList->nExpr>0 );
98659 assert( pList->nExpr>0 );
98679 assert( pList!=0 );
98682 assert( pExpr!=0 );
98707 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
98723 assert( pExpr->op==TK_TRUEFALSE );
98724 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
98943 assert( isInit==0 || isInit==1 );
98977 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
98992 assert( v!=(-2147483647-1) );
99069 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
99112 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
99116 assert( pSrc!=0 );
99120 assert( pTab!=0 );
99121 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
99124 assert( pEList!=0 );
99129 assert( pRes->iTable==pSrc->a[0].iCursor ); /* Not a correlated subquery */
99162 assert( !ExprHasProperty(pIn, EP_xIsSelect) );
99266 assert( pX->op==TK_IN );
99295 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
99296 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
99297 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
99305 assert(v); /* sqlite3GetVdbe() has always been previously called */
99340 assert( idxaff==SQLITE_AFF_TEXT );
99374 assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr );
99377 assert( pIdx->azColl[j] );
99390 assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) );
99399 assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 );
99447 assert( pX->op==TK_IN );
99480 assert( pExpr->op==TK_IN );
99570 assert( v!=0 );
99656 assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
99657 assert( pEList!=0 );
99658 assert( pEList->nExpr>0 );
99659 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
99685 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
99749 assert( v!=0 );
99752 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
99753 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
99923 assert( v!=0 ); /* OOM detected prior to this routine */
99930 assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH
99939 assert( cnt==1 );
99978 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
99995 assert( destIfNull==destIfFalse );
100130 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
100148 assert( i>=0 );
100155 assert( z!=0 );
100190 assert( pIdx->aColExpr );
100191 assert( pIdx->aColExpr->nExpr>iIdxCol );
100246 assert( v!=0 );
100259 assert( iFrom>=iTo+nReg || iFrom+nReg<=iTo );
100332 assert( target>0 && target<=pParse->nMem );
100334 assert( pParse->db->mallocFailed );
100349 assert( pCol->iMem>0 );
100371 assert( SQLITE_AFF_BLOB=='A' );
100372 assert( SQLITE_AFF_TEXT=='B' );
100406 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100412 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100425 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100426 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
100427 assert( pExpr->u.zToken[1]=='\'' );
100430 assert( z[n]=='\'' );
100437 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100438 assert( pExpr->u.zToken!=0 );
100439 assert( pExpr->u.zToken[0]!=0 );
100443 assert( pExpr->u.zToken[0]=='?' || strcmp(pExpr->u.zToken, z)==0 );
100484 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
100485 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
100486 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
100487 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
100488 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
100489 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
100507 assert( TK_AND==OP_And ); testcase( op==TK_AND );
100508 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
100509 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
100510 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
100511 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
100512 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
100513 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
100514 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
100515 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
100516 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
100517 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
100527 assert( pLeft );
100533 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100550 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
100551 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
100572 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
100573 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
100587 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100616 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
100623 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100642 assert( nFarg>=2 );
100657 assert( nFarg>=1 );
100669 assert( nFarg==1 );
100701 assert( nFarg==1 );
100702 assert( pFarg->a[0].pExpr!=0 );
100705 assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
100706 assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
100779 assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT );
100853 assert( pExpr->iTable==0 || pExpr->iTable==1 );
100854 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
100855 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
100856 assert( p1>=0 && p1<(pTab->nCol*2+2) );
100914 default: assert( op==TK_CASE ); {
100925 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
100926 assert(pExpr->x.pList->nExpr > 0);
100948 assert( pTest!=0 );
100971 assert( pExpr->affinity==OE_Rollback
100984 assert( !ExprHasProperty(pExpr, EP_IntValue) );
101018 assert( ConstFactorOk(pParse) );
101084 assert( target>0 && target<=pParse->nMem );
101089 assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
101138 assert( target>0 );
101139 assert( pExpr->op!=TK_REGISTER );
101177 assert( pList!=0 );
101178 assert( target>0 );
101179 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
101257 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
101315 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
101375 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
101376 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
101377 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
101378 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
101379 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
101382 assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
101391 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
101392 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
101451 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
101477 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
101478 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
101479 assert( pExpr->op!=TK_NE || op==OP_Eq );
101480 assert( pExpr->op!=TK_EQ || op==OP_Ne );
101481 assert( pExpr->op!=TK_LT || op==OP_Ge );
101482 assert( pExpr->op!=TK_LE || op==OP_Gt );
101483 assert( pExpr->op!=TK_GT || op==OP_Le );
101484 assert( pExpr->op!=TK_GE || op==OP_Lt );
101545 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
101546 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
101547 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
101548 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
101549 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq);
101552 assert(TK_NE==OP_Ne); testcase(op==OP_Ne);
101720 assert( ExprHasProperty(pA,EP_WinFunc)==ExprHasProperty(pB,EP_WinFunc) );
102046 assert( pExpr->op==TK_AGG_FUNCTION );
102101 assert( pNC->ncFlags & NC_UAggInfo );
102113 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
102191 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
102195 assert( !ExprHasProperty(pExpr, EP_IntValue) );
102208 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
102247 assert( pNC->pSrcList!=0 );
102458 assert( pSrc->nSrc==1 );
102459 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
102629 assert( pNew );
102631 assert( sqlite3BtreeHoldsAllMutexes(db) );
102638 assert( pTab );
102651 assert( pDflt==0 || pDflt->op==TK_SPAN );
102686 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
102688 assert( db->mallocFailed == 1 );
102762 assert( pParse->pNewTable==0 );
102763 assert( sqlite3BtreeHoldsAllMutexes(db) );
102784 assert( pTab->addColOffset>0 );
102799 assert( pNew->nCol>0 );
102801 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
102805 assert( db->mallocFailed );
102887 assert( iSchema>=0 );
102916 assert( pNew->n>0 );
103013 assert( p->p!=pPtr );
103037 assert( pPtr || pParse->db->mallocFailed );
103124 assert( pPtr!=0 );
103309 assert( p->zErrMsg==0 );
103310 assert( rc!=SQLITE_OK || zErr==0 );
103326 assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
103379 assert( nQuot>=nNew );
103435 assert( pNew->pTabSchema );
103473 assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) );
103476 assert( rc==SQLITE_OK );
103637 assert( sParse.pNewTable->pSelect==0 );
103701 assert( rc==SQLITE_OK );
103740 assert( pWalker->pParse->db->mallocFailed );
104195 assert( sqlite3BtreeHoldsAllMutexes(db) );
104196 assert( sqlite3VdbeDb(v)==db );
104242 assert( i<ArraySize(aTable) );
104299 assert( db!=0 );
104311 assert( db!=0 );
104327 assert( db!=0 );
104409 assert( nCol>0 );
104412 assert( nKeyCol<=nCol );
104413 assert( nKeyCol>0 );
104459 assert( (pSpace - (u8*)p)==n );
104504 assert( pNew->iCol==pOld->iCol );
104529 assert( pOld->isPSample==0 && pNew->isPSample==0 );
104530 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
104552 assert( IsStat4 || nEqZero==0 );
104564 assert( pNew->anEq[pNew->iCol]>0 );
104575 assert( pOld->iCol>pNew->iCol );
104576 assert( sampleIsBetter(p, pNew, pOld) );
104610 assert( p->nSample==0
104633 assert( iMin>=0 );
104663 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
104734 assert( p->nCol>0 );
104735 assert( iChng<p->nCol );
104836 assert( argc==2 );
104837 assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ
104843 assert( argc==1 );
104883 assert( p->current.anEq[i] );
104885 assert( z[0]=='\0' && z>zRet );
104907 assert( p->iGet<p->nSample );
104931 assert( z[0]=='\0' && z>zRet );
104955 assert( regOut!=regStat4 && regOut!=regStat4+1 );
104959 assert( iParam==STAT_GET_STAT1 );
105017 assert( sqlite3BtreeHoldsAllMutexes(db) );
105019 assert( iDb>=0 );
105020 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105113 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
105212 assert( regRowid==(regStat4+2) );
105221 assert( k>=0 && k<pIdx->nColumn );
105229 assert( regChng==(regStat4+1) );
105237 assert( "BBB"[0]==SQLITE_AFF_TEXT );
105299 assert( "BBB"[0]==SQLITE_AFF_TEXT );
105340 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105357 assert( pTab!=0 );
105358 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
105396 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
105401 assert( pName2!=0 || pName1==0 );
105462 assert( z!=0 );
105474 assert( aOut==0 );
105476 assert( aLog!=0 );
105482 assert( pIndex!=0 ); {
105524 assert( argc==3 );
105704 assert( db->lookaside.bDisable );
105727 assert( pIdx==0 || bStat3 || pIdx->nSample==0 );
105732 assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 );
105756 assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) );
105820 assert( db->lookaside.bDisable );
105868 assert( iDb>=0 && iDb<db->nDb );
105869 assert( db->aDb[iDb].pBt!=0 );
105872 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105901 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
106052 assert( z && zName );
106086 assert( pVfs );
106172 assert( zErrDyn==0 || rc!=SQLITE_OK );
106186 assert( iDb>=2 );
106320 assert( v || db->mallocFailed );
106324 assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
106395 assert( db->nDb>iDb );
106718 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
106719 assert( !IN_RENAME_OBJECT || db->xAuth==0 );
106731 assert( pTabList );
106743 assert( iCol<pTab->nCol );
106746 assert( pTab->iPKey<pTab->nCol );
106751 assert( iDb>=0 && iDb<db->nDb );
106776 assert( !IN_RENAME_OBJECT || db->xAuth==0 );
106821 assert( pParse );
106901 assert( iDb>=0 );
106937 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
106977 assert( pParse->pToplevel==0 );
106989 assert( !pParse->isMultiWrite
107015 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
107071 assert( pParse->pAinc==0 || pParse->nTab>0 );
107099 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
107148 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
107160 assert( sqlite3SchemaMutexHeld(db, j, 0) );
107250 assert( p->pSchema==0 || p->zDatabase==0 );
107276 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
107280 assert( pSchema );
107282 assert( sqlite3SchemaMutexHeld(db, j, 0) );
107316 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107374 assert( iDb<db->nDb );
107377 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107431 assert( pTable!=0 );
107473 assert( pIndex->pSchema==pTable->pSchema
107480 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
107481 assert( pOld==pIndex || pOld==0 );
107502 assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) );
107520 assert( db!=0 );
107521 assert( iDb>=0 && iDb<db->nDb );
107522 assert( zTabName );
107523 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107628 assert( pName2!=0 );
107641 assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
107761 assert( isTemp==0 || isTemp==1 );
107762 assert( isView==0 || isView==1 );
107798 assert( !db->init.busy || CORRUPT_DB );
107811 assert( db->mallocFailed );
107823 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
107825 assert( pParse->pNewTable==0 );
107834 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
108014 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
108052 assert( zIn!=0 );
108229 assert( pCExpr!=0 );
108254 assert( autoInc==0 || autoInc==1 );
108323 assert( pIdx->nKeyCol==1 );
108390 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
108496 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
108497 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
108506 assert( pCol->affinity==SQLITE_AFF_BLOB
108510 assert( k<=n );
108524 assert( pIdx->isResized==0 );
108564 assert( x<pIdx->pTable->nCol );
108599 assert( (pIdx->colNotIdxed>>63)==1 );
108648 assert( v );
108663 assert( pParse->pNewTable==pTab );
108671 assert( pPk!=0 );
108687 assert( pPk!=0 );
108697 assert( db->init.busy==0 );
108726 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
108727 assert( pIdx->nColumn>=j );
108736 assert( j<pPk->nColumn );
108742 assert( pPk->nColumn==j );
108743 assert( pTab->nCol==j );
108815 assert( !db->mallocFailed );
108841 assert( (p->tabFlags & TF_HasPrimaryKey)==0
108843 assert( (p->tabFlags & TF_HasPrimaryKey)!=0
108935 assert(pParse->nTab==1);
108945 assert( p->aCol==0 );
109004 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109025 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109028 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
109039 assert( !pSelect && pCons && pEnd );
109103 assert( sEnd.z[0]!=0 || sEnd.n==0 );
109109 assert( n>0 );
109147 assert( pTable );
109184 assert( pTable->nCol>=0 );
109193 assert( pTable->pSelect );
109232 assert( pTable->aCol==0 );
109237 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
109268 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
109307 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109390 assert( pIdx->pSchema==pTab->pSchema );
109399 assert( iDb>=0 && iDb<pParse->db->nDb );
109440 assert( v!=0 );
109455 assert( pTrigger->pSchema==pTab->pSchema ||
109514 assert( pParse->nErr==0 );
109515 assert( pName->nSrc==1 );
109518 assert( isView==0 || isView==LOCATE_VIEW );
109527 assert( iDb>=0 && iDb<db->nDb );
109640 assert( pTo!=0 );
109720 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
109729 assert( pNextTo->pPrevTo==0 );
109758 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
109807 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
109952 assert( pName1 && pName2 );
109955 assert( pName && pName->z );
109974 assert(0);
109977 assert( db->mallocFailed==0 || pTab==0 );
109987 assert( pName==0 );
109988 assert( pStart==0 );
109995 assert( pTab!=0 );
109996 assert( pParse->nErr==0 );
110039 assert( pName->z!=0 );
110054 assert( !db->init.busy );
110105 assert( pList->nExpr==1 );
110117 assert( pExpr!=0 );
110128 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
110134 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
110135 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
110150 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
110198 assert( j<=0x7fff );
110211 assert( nExtra>=nColl );
110235 assert( x>=0 );
110245 assert( i==pIndex->nColumn );
110255 assert( HasRowid(pTab)
110293 assert( IsUniqueIndex(pIdx) );
110294 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
110295 assert( IsUniqueIndex(pIndex) );
110301 assert( pIdx->aiColumn[k]>=0 );
110340 assert( pParse->nErr==0 );
110343 assert( !IN_SPECIAL_PARSE );
110344 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
110356 assert( p==pIndex ); /* Malloc must have failed */
110459 assert( pParse->pNewIndex==0 );
110499 assert( !pIdx->hasStat1 );
110505 if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10; assert( 10==sqlite3LogEst(2) );
110506 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
110512 a[i] = 23; assert( 23==sqlite3LogEst(5) );
110515 assert( 0==sqlite3LogEst(1) );
110529 assert( pParse->nErr==0 ); /* Never called with prior errors */
110533 assert( pName->nSrc==1 );
110726 assert( iStart>=0 );
110727 assert( nExtra>=1 );
110728 assert( pSrc!=0 );
110729 assert( iStart<=pSrc->nSrc );
110746 assert( db->mallocFailed );
110814 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
110815 assert( pParse!=0 );
110816 assert( pParse->db!=0 );
110854 assert(pList || pParse->db->mallocFailed );
110925 assert( p->nSrc>0 );
110927 assert( (pTable==0)==(pDatabase==0) );
110928 assert( pItem->zName==0 || pDatabase!=0 );
110933 assert( pAlias!=0 );
110943 assert( p==0 );
110955 assert( pIndexedBy!=0 );
110958 assert( p->nSrc>0 );
110960 assert( pItem->fg.notIndexed==0 );
110961 assert( pItem->fg.isIndexedBy==0 );
110962 assert( pItem->fg.isTabFunc==0 );
110981 assert( pItem->fg.notIndexed==0 );
110982 assert( pItem->fg.isIndexedBy==0 );
110983 assert( pItem->fg.isTabFunc==0 );
111024 assert( pParse!=0 );
111026 assert( db!=0 );
111050 assert( pParse!=0 );
111051 assert( pParse->db!=0 );
111052 assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
111074 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
111108 assert( db->aDb[1].pSchema );
111126 assert( iDb>=0 && iDb<pParse->db->nDb );
111127 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
111128 assert( iDb<SQLITE_MAX_ATTACHED+2 );
111129 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
111220 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
111248 assert( pIdx->aiColumn[j]>=0 );
111293 assert( zColl!=0 );
111296 assert( z!=0 || pIndex->aiColumn[i]<0 );
111338 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
111340 assert( pDb!=0 );
111384 assert( pName1->z );
111435 assert( sqlite3KeyInfoIsWriteable(pKey) );
111443 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
111496 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
111556 assert( !db->xCollNeeded || !db->xCollNeeded16 );
111637 assert( !p || p->xCmp );
111664 assert( p==pColl );
111710 assert( pDel==0 || pDel==pColl );
111748 assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
111749 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
111844 assert( zName[0]>='a' && zName[0]<='z' );
111847 assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
111892 assert( nArg>=(-2) );
111893 assert( nArg>=(-1) || createFlag==0 );
112057 assert( pItem && pSrc->nSrc==1 );
112095 assert( pTab->tabFlags & TF_Shadow );
112145 assert( pFrom->nSrc==1 );
112148 assert( pFrom->a[0].pOn==0 );
112149 assert( pFrom->a[0].pUsing==0 );
112309 assert( pTabList->nSrc==1 );
112356 assert( iDb<db->nDb );
112359 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
112363 assert(!isView || pTrigger);
112367 assert( pTabList->nSrc==1 );
112442 assert( !isView );
112449 assert( pIdx->pSchema==pTab->pSchema );
112468 assert( pPk!=0 );
112488 assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
112489 assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
112500 assert( pPk->aiColumn[i]>=0 );
112561 assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
112562 assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
112570 assert( nKey==nPk ); /* OP_Found will use an unpacked key */
112572 assert( pPk!=0 || pTab->pSelect!=0 );
112583 assert( nKey==0 ); /* OP_Found will use a composite key */
112587 assert( nKey==1 );
112595 assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
112725 assert( v );
112876 assert( iIdxCur+i!=iDataCur || pPk==pIdx );
113016 assert( context->pVdbe!=0 );
113018 assert( pOp->opcode==OP_CollSeq );
113019 assert( pOp->p4type==P4_COLLSEQ );
113028 assert( context->isError<=0 );
113046 assert( argc>1 );
113049 assert( pColl );
113050 assert( mask==-1 || mask==0 );
113074 assert( i>=0 && i<ArraySize(azType) );
113075 assert( SQLITE_INTEGER==1 );
113076 assert( SQLITE_FLOAT==2 );
113077 assert( SQLITE_TEXT==3 );
113078 assert( SQLITE_BLOB==4 );
113079 assert( SQLITE_NULL==5 );
113096 assert( argc==1 );
113134 assert( argc==1 );
113279 assert( argc==3 || argc==2 );
113291 assert( len==sqlite3_value_bytes(argv[0]) );
113338 assert( p1>=0 && p2>=0 );
113366 assert( argc==1 || argc==2 );
113406 assert( nByte>0 );
113432 assert( z2==(char*)sqlite3_value_text(argv[0]) );
113451 assert( z2==(char*)sqlite3_value_text(argv[0]) );
113509 assert( argc==1 );
113679 assert( matchOther<0x80 ); /* '[' is a single-byte character */
113849 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
113950 assert( argc==1 );
113974 assert( argc==1 );
113999 assert( argc==1 );
114022 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
114063 assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
114138 assert( argc==1 );
114142 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
114165 assert( argc==1 );
114199 assert( argc==3 );
114204 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
114207 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
114212 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
114217 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
114221 assert( zRep==sqlite3_value_text(argv[2]) );
114223 assert( nOut<SQLITE_MAX_LENGTH );
114262 assert( j+nStr-i+1<=nOut );
114265 assert( j<=nOut );
114294 assert( zIn==sqlite3_value_text(argv[0]) );
114404 assert( argc==1 );
114492 assert( argc==1 );
114514 assert( argc==1 );
114521 assert( p->cnt>0 );
114523 assert( type==SQLITE_INTEGER || p->approx );
114590 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
114689 assert( argc==1 || argc==2 );
114720 assert( argc==1 || argc==2 );
114784 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
114849 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
114871 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
114872 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
114873 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
115215 assert( ppIdx && *ppIdx==0 );
115216 assert( !paiCol || *paiCol==0 );
115217 assert( pParse );
115240 assert( nCol>1 );
115432 assert( pIdx->aiColumn[i]>=0 );
115433 assert( aiCol[i]!=pTab->iPKey );
115461 assert( nIncr==1 );
115581 assert( pIdx==0 || pIdx->pTable==pTab );
115582 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
115583 assert( pIdx!=0 || pFKey->nCol==1 );
115584 assert( pIdx!=0 || HasRowid(pTab) );
115609 assert( iCol>=0 );
115640 assert( pIdx!=0 );
115643 assert( iCol>=0 );
115738 assert( v ); /* VDBE has already been allocated */
115739 assert( pTab->pSelect==0 ); /* Not a view */
115899 assert( (regOld==0)!=(regNew==0) );
115935 assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
115955 assert( pFKey->nCol==1 || (aiFree && pIdx) );
115967 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
116022 assert( regOld==0 && regNew!=0 );
116032 assert( aiCol || pFKey->nCol==1 );
116100 assert( pIdx->aiColumn[i]>=0 );
116229 assert( aiCol || pFKey->nCol==1 );
116240 assert( iFromCol>=0 );
116241 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
116242 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
116353 assert( pStep!=0 );
116417 assert( db==0 || IsVirtual(pTab)
116438 assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
116487 assert( !IsVirtual(pTab) );
116489 assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
116497 assert( pPk!=0 );
116498 assert( pPk->tnum==pTab->tnum );
116550 assert( x==XN_EXPR );
116551 assert( pIdx->aColExpr!=0 );
116602 assert( zColAff!=0 );
116629 assert( pOp!=0 );
116644 assert( pOp->p4.pVtab!=0 );
116645 assert( pOp->p4type==P4_VTAB );
116683 assert( pParse->db->aDb[iDb].pSchema!=0 );
116735 assert( pParse->pTriggerTab==0 );
116736 assert( sqlite3IsToplevel(pParse) );
116738 assert( v ); /* We failed long ago if this is not so */
116758 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
116805 assert( v );
116821 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
117020 assert( pTabList->nSrc==1 );
117026 assert( iDb<db->nDb );
117048 assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
117081 assert( !pTrigger );
117082 assert( pList==0 );
117125 ipkColumn = i; assert( !withoutRowid );
117167 assert( pSelect->pEList );
117219 assert( useTempTable==0 );
117275 assert( pIdx );
117341 assert( !withoutRowid );
117345 assert( pSelect==0 ); /* Otherwise useTempTable is true */
117357 assert( !IsVirtual(pTab) );
117373 assert( pSelect==0 ); /* Otherwise useTempTable is true */
117598 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
117767 assert( v!=0 );
117768 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
117807 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
117812 assert( onError==OE_Replace );
117839 assert( onError==OE_Ignore );
117916 assert( pUpsert->pUpsertSet==0 );
118026 assert( HasRowid(pTab) );
118207 assert( pPk->aiColumn[i]>=0 );
118229 assert( x>=0 );
118246 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
118271 assert( onError==OE_Replace );
118355 assert( update_flags==0
118361 assert( v!=0 );
118362 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
118372 assert( pParse->nested==0 );
118456 assert( op==OP_OpenRead || op==OP_OpenWrite );
118457 assert( op==OP_OpenWrite || p5==0 );
118466 assert( v!=0 );
118478 assert( pIdx->pSchema==pTab->pSchema );
118520 assert( pDest && pSrc );
118521 assert( pDest->pTable!=pSrc->pTable );
118533 assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
118623 assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
118651 assert( pEList!=0 );
118655 assert( pEList->a[0].pExpr );
118711 assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN );
118712 assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN );
118776 assert( HasRowid(pDest) || destHasUniqueIdx );
118819 assert( (pDest->tabFlags & TF_Autoincrement)==0 );
118844 assert( pSrcIdx );
118958 assert( rc==SQLITE_OK || pStmt==0 );
118987 assert( azCols[i]!=0 );
119042 assert( (rc&db->errMask)==rc );
120326 assert( sqlite3_mutex_held(db->mutex) );
120416 assert( (rc&0xff)==rc );
121406 assert( SQLITE_FullFSync==PAGER_FULLFSYNC );
121407 assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC );
121408 assert( SQLITE_CacheSpill==PAGER_CACHESPILL );
121409 assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)
121411 assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
121438 assert( action==OE_None ); break;
121457 assert( PAGER_JOURNALMODE_DELETE==0 );
121458 assert( PAGER_JOURNALMODE_PERSIST==1 );
121459 assert( PAGER_JOURNALMODE_OFF==2 );
121460 assert( PAGER_JOURNALMODE_TRUNCATE==3 );
121461 assert( PAGER_JOURNALMODE_MEMORY==4 );
121462 assert( PAGER_JOURNALMODE_WAL==5 );
121463 assert( eMode>=0 && eMode<=ArraySize(azModeName) );
121564 assert( pId2 );
121671 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121691 assert( pBt!=0 );
121718 assert( pBt!=0 );
121794 assert(pDb==&db->aDb[0]);
121805 assert( eMode==PAGER_LOCKINGMODE_NORMAL
121884 assert( pBt!=0 );
121889 assert( eAuto>=0 && eAuto<=2 );
121963 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121997 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122034 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122301 assert( pCol->pDflt==0 || pCol->pDflt->op==TK_SPAN );
122361 assert( pParse->nMem<=pPragma->nPragCName );
122405 assert( db->aDb[i].zDbSName!=0 );
122558 assert( pParse->nErr>0 || pFK==0 );
122568 assert( x==0 );
122593 assert( pFK->nCol==1 );
122656 assert( iDb>=0 );
122657 assert( iDb==0 || pId2->z );
122691 assert( sqlite3SchemaMutexHeld(db, i, 0) );
122749 assert( pParse->nMem>=8+j );
122750 assert( sqlite3NoTempsInRange(pParse,1,7+j) );
122827 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
122932 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
122933 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
122934 assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
123192 szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 );
123230 assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT );
123437 assert( strlen(zBuf) < sizeof(zBuf)-1 );
123490 assert( j < 2 );
123547 assert( pCsr->pPragma );
123577 assert( j<ArraySize(pCsr->azArg) );
123578 assert( pCsr->azArg[j]==0 );
123676 assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
123680 assert( sqlite3HashFind(&db->aModule, zName)==0 );
123766 assert( argc==3 );
123768 assert( sqlite3_mutex_held(db->mutex) );
123776 assert( iDb>=0 && iDb<db->nDb );
123791 assert( db->init.busy );
123797 assert( (rc&0xFF)==(rcp&0xFF) );
123802 assert( iDb==1 );
123856 assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
123857 assert( iDb>=0 && iDb<db->nDb );
123858 assert( db->aDb[iDb].pSchema );
123859 assert( sqlite3_mutex_held(db->mutex) );
123860 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
123890 assert( iDb==1 );
124002 assert( db->init.busy );
124079 assert( sqlite3_mutex_held(db->mutex) );
124080 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
124081 assert( db->init.busy==0 );
124083 assert( db->nDb>0 );
124091 assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
124110 assert( sqlite3_mutex_held(db->mutex) );
124135 assert( pParse->checkSchema );
124136 assert( sqlite3_mutex_held(db->mutex) );
124158 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124191 assert( sqlite3_mutex_held(db->mutex) );
124194 assert( i<db->nDb );
124199 assert( i>=0 && i<db->nDb );
124212 assert( db->lookaside.bDisable >= pParse->disableLookaside );
124238 assert( ppStmt && *ppStmt==0 );
124240 assert( sqlite3_mutex_held(db->mutex) );
124277 assert( sqlite3BtreeHoldsMutex(pBt) );
124312 assert( 0==sParse.nQueryLoop );
124354 assert(!(*ppStmt));
124404 assert( rc==SQLITE_OK || *ppStmt==0 );
124409 assert( (rc&db->errMask)==rc );
124430 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
124432 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
124434 assert( sqlite3_mutex_held(db->mutex) );
124441 assert( pNew==0 );
124444 assert( pNew!=0 );
124471 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
124489 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
124511 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
124587 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
124599 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
124614 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
124763 assert( pParse->db->mallocFailed );
124797 assert( pNew->pSrc!=0 || pParse->nErr>0 );
124799 assert( pNew!=&standin );
124879 assert( pB!=0 );
124924 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
124964 assert( iLeft<iRight );
124965 assert( pSrc->nSrc>iRight );
124966 assert( pSrc->a[iLeft].pTab );
124967 assert( pSrc->a[iRight].pTab );
124975 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
125011 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
125229 assert( bSeq==0 || bSeq==1 );
125244 assert( nData==1 || regData==regOrigData || regOrigData==0 );
125247 assert( nPrefixReg==nExpr+bSeq );
125253 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
125506 assert( v );
125507 assert( p->pEList!=0 );
125511 assert( iContinue!=0 );
125605 assert( eDest==SRT_Set || eDest==SRT_Mem
125619 assert( pSort!=0 );
125620 assert( hasDistinct==0 );
125668 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
125679 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
125737 assert( pSort==0 );
125741 assert( regResult==regOrig );
125769 assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
125792 assert( nResultCol<=pDest->nSdst );
125796 assert( nResultCol==pDest->nSdst );
125797 assert( regResult==iParm );
125833 assert( pSO );
125875 assert( eDest==SRT_Discard );
125916 assert( p->nRef>0 );
125927 assert( p->nRef>0 );
125972 assert( sqlite3KeyInfoIsWriteable(pInfo) );
126058 assert( addrBreak<0 );
126133 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
126174 assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
126186 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
126265 assert( pExpr!=0 );
126266 assert( pNC->pSrcList!=0 );
126267 assert( pExpr->op!=TK_AGG_COLUMN ); /* This routine runes before aggregates
126310 assert( pTab && pExpr->y.pTab==pTab );
126330 assert( !pS );
126333 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
126347 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
126366 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
126378 assert( pzOrigTab && pzOrigCol );
126484 assert( v!=0 );
126485 assert( pTabList!=0 );
126493 assert( p!=0 );
126494 assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */
126495 assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */
126504 assert( pTab!=0 );
126506 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
126575 assert( nCol==(i16)nCol );
126588 assert( pColExpr!=0 );
126590 assert( pColExpr->op!=TK_AGG_COLUMN );
126595 assert( pTab!=0 );
126599 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
126668 assert( pSelect!=0 );
126669 assert( (pSelect->selFlags & SF_Resolved)!=0 );
126670 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
126722 assert( db->lookaside.bDisable );
126725 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
126792 assert( pLimit->op==TK_LIMIT );
126793 assert( pLimit->pLeft!=0 );
126796 assert( v!=0 );
126840 assert( iCol>=0 );
126879 assert( sqlite3KeyInfoIsWriteable(pRet) );
127048 assert( p->pPrior==0 );
127095 assert( p->selFlags & SF_MultiValue );
127097 assert( p->selFlags & SF_Values );
127098 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
127099 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
127101 assert( p->pPrior->pNext==p );
127162 assert( p && p->pPrior ); /* Calling function guarantees this much */
127163 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
127175 assert( v!=0 ); /* The VDBE already created by calling function */
127180 assert( p->pEList );
127195 assert( p->pEList && pPrior->pEList );
127196 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
127223 assert( !pPrior->pLimit );
127276 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
127283 assert( p->pOrderBy==0 );
127285 assert( p->addrOpenEphm[0] == -1 );
127288 assert( p->pEList );
127293 assert( !pPrior->pOrderBy );
127305 assert( p->op==TK_UNION );
127333 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
127336 assert( p->pEList );
127351 default: assert( p->op==TK_INTERSECT ); {
127365 assert( p->pOrderBy==0 );
127368 assert( p->addrOpenEphm[0] == -1 );
127371 assert( p->pEList );
127384 assert( p->addrOpenEphm[1] == -1 );
127405 assert( p->pEList );
127449 assert( p->pNext==0 );
127469 assert( pLoop->addrOpenEphm[1]<0 );
127557 assert( pDest->eDest!=SRT_Exists );
127558 assert( pDest->eDest!=SRT_Table );
127594 assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 );
127623 assert( pDest->eDest==SRT_Output );
127769 assert( p->pOrderBy!=0 );
127770 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
127773 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
127782 assert( pPrior->pOrderBy==0 );
127784 assert( pOrderBy );
127795 assert( pItem->u.x.iOrderByCol>0 );
127821 assert( pItem->u.x.iOrderByCol>0 );
127822 assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
127843 assert( nOrderBy>=nExpr || db->mallocFailed );
127849 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
128078 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
128079 assert( pExpr->pRight==0 );
128144 assert( pSrc!=0 );
128331 assert( p!=0 );
128332 assert( p->pPrior==0 );
128335 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
128339 assert( pSub!=0 );
128346 assert( pSubSrc );
128426 assert( pSub->pSrc!=0 );
128427 assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
128452 assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 );
128580 assert( pParent==p ); /* First time through the loop */
128583 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
128615 assert( pSrc->a[i+iFrom].fg.isTabFunc==0 );
128649 assert( pParent->pOrderBy==0 );
128724 assert( pColumn->op==TK_COLUMN );
128730 assert( pExpr->op==TK_COLUMN );
128768 assert( pRight!=0 );
128769 assert( pLeft!=0 );
128807 assert( pExpr->pLeft==0 );
128958 assert( (pX->selFlags & (SF_Recursive))==0 );
129027 assert( *ppMinMax==0 );
129028 assert( pFunc->op==TK_AGG_FUNCTION );
129041 assert( pOrderBy!=0 || db->mallocFailed );
129061 assert( !p->pGroupBy );
129070 assert( pTab && !pTab->pSelect && pExpr );
129168 assert( (p->selFlags & SF_Converted)==0 );
129170 assert( pNew->pPrior!=0 );
129232 assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) );
129234 assert( pParse->pWith!=pWith );
129265 assert( pFrom->pTab==0 );
129286 assert( pFrom->pTab==0 );
129292 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
129296 assert( pFrom->pSelect );
129325 assert( pTab->nTabRef==1 ||
129333 assert( pPrior->pWith==0 );
129386 assert( pParse->pWith==pWith );
129406 assert( pSel );
129418 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
129463 assert( p->pSrc!=0 );
129482 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
129484 assert( pFrom->pTab==0 );
129493 assert( pSel!=0 );
129494 assert( pFrom->pTab==0 );
129500 assert( pFrom->pTab==0 );
129517 assert( pFrom->pSelect==0 );
129553 assert( pE->op!=TK_DOT || pE->pRight!=0 );
129554 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
129574 assert( pE->op!=TK_DOT || pRight!=0 );
129594 assert( pE->pLeft!=0 );
129595 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
129622 assert( zName );
129744 assert( 0 );
129795 assert( p->selFlags & SF_Resolved );
129802 assert( pTab!=0 );
129852 assert( p!=0 || pParse->db->mallocFailed );
129879 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
129881 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
129885 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
129893 assert( !ExprHasProperty(pE, EP_xIsSelect) );
129917 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
129947 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
129966 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
130249 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
130250 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
130251 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
130252 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
130254 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
130268 assert( p->pEList!=0 );
130337 assert( pSub->pGroupBy==0 );
130468 assert( pItem->addrFillSub==0 );
130542 assert( pItem->addrFillSub==0 );
130558 assert( pPrior->pSelect!=0 );
130616 assert( sDistinct.isTnct );
130690 assert( WHERE_USE_LIMIT==SF_FixedLimit );
130720 assert( p->pEList==pEList );
130780 assert( 66==sqlite3LogEst(100) );
130783 assert( 0==sqlite3LogEst(1) );
130818 assert( pWhere==p->pWhere );
130819 assert( pHaving==p->pHaving );
130820 assert( pGroupBy==p->pGroupBy );
130833 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
131166 assert( p->pGroupBy==0 );
131174 assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
131175 assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
131213 assert( p->pEList==pEList );
131390 assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
131434 assert( azResult!=0 );
131503 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
131546 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
131547 assert( pName2!=0 );
131548 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
131549 assert( op>0 && op<0xff );
131595 assert( pTableName->nSrc==1 );
131627 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
131633 assert( !db->init.busy );
131704 assert( pParse->pNewTrigger==0 );
131715 assert( pParse->pNewTrigger==pTrigger );
131754 assert( !db->init.busy );
131786 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
131793 assert( pTab!=0 );
131801 assert( IN_RENAME_OBJECT || !pParse->pNewTrigger );
131892 assert(pSelect != 0 || db->mallocFailed);
132013 assert( pName->nSrc==1 );
132016 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
132020 assert( sqlite3SchemaMutexHeld(db, j, 0) );
132058 assert( iDb>=0 && iDb<db->nDb );
132060 assert( pTable );
132061 assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
132077 assert( pTable!=0 );
132095 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
132148 assert( pList==0 || IsVirtual(pTab)==0 );
132180 assert( pSrc->nSrc>0 );
132185 assert( iDb<db->nDb );
132206 assert( pParse->pTriggerTab && pParse->pToplevel );
132207 assert( pStepList );
132208 assert( v!=0 );
132224 assert( pParse->okConstFactor==0 );
132261 default: assert( pStep->op==TK_SELECT ); {
132302 assert( pFrom->zErrMsg==0 || pFrom->nErr );
132303 assert( pTo->zErrMsg==0 || pTo->nErr );
132333 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
132334 assert( pTop->pVdbe );
132419 assert( !pSubParse->pAinc && !pSubParse->pZombieTab );
132420 assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
132442 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
132478 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
132552 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
132553 assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
132554 assert( (op==TK_UPDATE)==(pChanges!=0) );
132561 assert( p->pSchema!=0 );
132562 assert( p->pTabSchema!=0 );
132563 assert( p->pSchema==p->pTabSchema
132614 assert( isNew==1 || isNew==0 );
132695 assert( pTab!=0 );
132701 assert( i<pTab->nCol );
132733 assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */
132737 assert( iIdxCol==XN_EXPR );
132738 assert( pIdx->aColExpr!=0 );
132739 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
132841 assert( pTabList->nSrc==1 );
132855 assert( pTrigger || tmask==0 );
132972 assert( (chngRowid & chngPk)==0 );
132973 assert( chngRowid==0 || chngRowid==1 );
132974 assert( chngPk==0 || chngPk==1 );
133092 assert( pPk!=0 );
133147 assert( iCur!=iDataCur || !HasRowid(pTab) );
133167 assert( pPk->aiColumn[i]>=0 );
133206 assert( pPk );
133235 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
133344 assert( regOldRowid>0 );
133374 assert( regNew==regNewRowid+1 );
133381 assert( hasFK==0 && chngKey==0 );
133530 assert( v );
133562 assert( pPk!=0 );
133563 assert( pPk->nKeyCol==1 );
133572 assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
133718 assert( pTabList->nSrc==1 );
133719 assert( pTabList->a[0].pTab!=0 );
133720 assert( pUpsert!=0 );
133721 assert( pUpsert->pUpsertTarget!=0 );
133745 assert( pUpsert->pUpsertIdx==0 );
133778 assert( pIdx->aColExpr!=0 );
133779 assert( pIdx->aColExpr->nExpr>ii );
133834 assert( v!=0 );
133835 assert( pUpsert!=0 );
133853 assert( pPk->aiColumn[i]>=0 );
133921 assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 );
133934 assert( rc!=SQLITE_ROW );
134101 assert( (db->nDb-1)==nDb );
134103 assert( strcmp(pDb->zDbSName,"vacuum_db")==0 );
134190 assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 );
134232 assert( 1==sqlite3BtreeIsInTrans(pTemp) );
134233 assert( pOut!=0 || 1==sqlite3BtreeIsInTrans(pMain) );
134257 assert( rc==SQLITE_OK );
134355 assert( pDel==0 || pDel==pMod );
134443 assert( IsVirtual(pTab) );
134455 assert( db );
134456 assert( pVTab->nRef>0 );
134457 assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
134487 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
134492 assert( db2 );
134504 assert( !db || pRet );
134519 assert( IsVirtual(p) );
134520 assert( sqlite3BtreeHoldsAllMutexes(db) );
134521 assert( sqlite3_mutex_held(db->mutex) );
134558 assert( sqlite3BtreeHoldsAllMutexes(db) );
134559 assert( sqlite3_mutex_held(db->mutex) );
134638 assert( 0==pTable->pIndex );
134642 assert( pTable->nModuleArg==0 );
134646 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
134661 assert( iDb>=0 ); /* The database the table is being created in */
134755 assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
134759 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
134786 assert(pArg->z <= p->z);
134841 assert( &db->pVtabCtx );
134842 assert( xConstruct );
134851 assert( sCtx.pTab==pTab );
134903 assert(zType[i-1]==' ');
134932 assert( pTab );
135005 assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
135059 assert( IsVirtual(pTab) );
135079 assert( pTab->pIndex==0 );
135080 assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
135091 assert( pIdx->pNext==0 );
135111 assert( (rc&0xff)==rc );
135133 assert( p->pVtab );
135140 assert( xDestroy!=0 ); /* Checked before the virtual table is created */
135144 assert( pTab->pVTable==p && p->pNext==0 );
135297 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
135298 assert( iSavepoint>=-1 );
135363 assert( pVtab!=0 );
135364 assert( pVtab->pModule!=0 );
135380 assert( x==sqlite3UpperToLower[x] );
135416 assert( IsVirtual(pTab) );
135462 assert( pTab->nModuleArg==0 );
135507 assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
135508 assert( OE_Ignore==4 && OE_Replace==5 );
135509 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
135533 assert( p->pTab==0 || IsVirtual(p->pTab) );
136195 assert( nTerm>=1 );
136307 assert( pLoop->u.btree.pIndex!=0 );
136309 assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
136337 assert( flags&WHERE_TOP_LIMIT);
136440 assert( pTerm!=0 );
136452 assert( pTerm!=0 );
136473 assert( pParse->db->mallocFailed );
136476 assert( v!=0 );
136574 assert( pOrigLhs->a[iField].pExpr!=0 );
136645 assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
136646 assert( iTarget>0 );
136670 assert( pX->op==TK_IN );
136680 assert( pLoop->aLTerm[i]!=0 );
136707 assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
136824 assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 );
136828 assert( pIdx!=0 );
136837 assert( zAff!=0 || pParse->db->mallocFailed );
136860 assert( zAff==0 || (int)strlen(zAff)>=nEq );
136864 assert( pTerm!=0 );
136931 assert( pLevel->iLikeRepCntr>0 );
136933 assert( pOp!=0 );
136934 assert( pOp->opcode==OP_String8
136964 assert( pHint->pIdx!=0 );
137036 assert( pExpr->iColumn>=0 );
137074 assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor );
137185 assert( iIdxCur>0 );
137186 assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
137198 assert( pIdx->aiColumn[i]<pTab->nCol );
137216 assert( nReg>0 );
137222 assert( p->op==TK_SELECT );
137230 assert( nReg<=pList->nExpr );
137236 assert( nReg==1 );
137295 assert( aColExpr->a[iIdxCol].pExpr!=0 );
137387 assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
137459 assert( pLevel->u.in.aInLoop!=0 || db->mallocFailed );
137461 assert( iIn>0 );
137463 assert( pOp->opcode==OP_Column || pOp->opcode==OP_Rowid );
137464 assert( pOp->opcode!=OP_Column || pOp->p3==iReg+j+2 );
137465 assert( pOp->opcode!=OP_Rowid || pOp->p2==iReg+j+2 );
137473 assert( pCompare!=0 || db->mallocFailed );
137504 assert( pLoop->u.btree.nEq==1 );
137506 assert( pTerm!=0 );
137507 assert( pTerm->pExpr!=0 );
137533 assert( pStart!=0 || pEnd!=0 );
137554 assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */
137555 assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */
137556 assert( TK_GE==TK_GT+3 ); /* ... is correcct. */
137558 assert( (pStart->wtFlags & TERM_VNULL)==0 );
137561 assert( pX!=0 );
137571 assert( pX->op!=TK_GT || op==OP_SeekGE );
137572 assert( pX->op!=TK_GE || op==OP_SeekGE );
137573 assert( pX->op!=TK_LT || op==OP_SeekLE );
137574 assert( pX->op!=TK_LE || op==OP_SeekLE );
137595 assert( pX!=0 );
137596 assert( (pEnd->wtFlags & TERM_VNULL)==0 );
137616 assert( pLevel->p5==0 );
137697 assert( nEq>=pLoop->nSkip );
137707 assert( pWInfo->pOrderBy==0
137714 assert( pLoop->nSkip==0 );
137727 assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
137735 assert( pRangeStart!=0 ); /* LIKE opt constraints */
137736 assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */
137745 assert( (bRev & ~1)==0 );
137757 assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 );
137777 assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq );
137830 assert( op!=0 );
137859 assert( pParse->db->mallocFailed );
137962 assert( pLevel->p5==0 );
138029 assert( pTerm!=0 );
138030 assert( pTerm->eOperator & WO_OR );
138031 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
138133 assert( (pTabItem[0].fg.jointype & JT_LEFT)==0
138145 assert( pSubWInfo || pParse->nErr || db->mallocFailed );
138232 assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
138237 assert( pSubWInfo->a[0].iIdxCur==iCovCur );
138271 assert( bRev==0 || bRev==1 );
138321 assert( pE!=0 );
138382 assert( !ExprHasProperty(pE, EP_FromJoin) );
138383 assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
138415 assert( pWInfo->untestedTerms );
138418 assert( pTerm->pExpr );
138530 assert( TK_GT>TK_EQ && TK_GT<TK_GE );
138531 assert( TK_LT>TK_EQ && TK_LT<TK_GE );
138532 assert( TK_LE>TK_EQ && TK_LE<TK_GE );
138533 assert( TK_GE==TK_EQ+4 );
138552 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
138568 assert( TK_LT==TK_GT+2 );
138569 assert( TK_GE==TK_LE+2 );
138570 assert( TK_GT>TK_EQ );
138571 assert( TK_GT<TK_LE );
138572 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
138582 assert( allowedOp(op) );
138590 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
138593 assert( op!=TK_ISNULL || c==WO_ISNULL );
138594 assert( op!=TK_IN || c==WO_IN );
138595 assert( op!=TK_EQ || c==WO_EQ );
138596 assert( op!=TK_LT || c==WO_LT );
138597 assert( op!=TK_LE || c==WO_LE );
138598 assert( op!=TK_GT || c==WO_GT );
138599 assert( op!=TK_GE || c==WO_GE );
138600 assert( op!=TK_IS || c==WO_IS );
138655 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
138841 assert( pVtab!=0 );
138842 assert( pVtab->pModule!=0 );
138947 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
138948 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
138956 assert( eOp & (WO_GT|WO_GE) );
138963 for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
139079 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
139080 assert( pExpr->op==TK_OR );
139090 assert( pOrWc->nTerm>=2 );
139100 assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
139119 assert( pAndTerm->pExpr );
139211 assert( pOrTerm->eOperator & WO_EQ );
139216 assert( j==1 );
139227 assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
139238 assert( j==1 );
139239 assert( IsPowerOfTwo(chngToIN) );
139240 assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) );
139249 assert( pOrTerm->eOperator & WO_EQ );
139285 assert( pOrTerm->eOperator & WO_EQ );
139286 assert( pOrTerm->leftCursor==iCursor );
139287 assert( pOrTerm->u.leftColumn==iColumn );
139292 assert( pLeft!=0 );
139298 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
139422 assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE );
139423 assert( TK_IS<TK_GE && TK_ISNULL<TK_GE && TK_IN<TK_GE );
139424 assert( op<=TK_GE );
139484 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
139488 assert( pExpr->pRight==0 );
139524 assert( op==TK_IN );
139525 assert( pLeft->op==TK_VECTOR );
139541 assert( pTerm->iField==0 );
139595 assert( pList!=0 );
139596 assert( pList->nExpr==2 );
139618 assert( pWC->op==TK_AND );
139937 assert( p->op!=TK_IF_NULL_ROW );
139944 assert( p->x.pList==0 );
140011 assert( pTab!=0 );
140135 assert( pInner->addrNxt!=0 );
140144 assert( pWInfo->iContinue!=0 );
140239 assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
140257 assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
140274 assert( pScan->iEquiv<=pScan->nEquiv );
140279 assert( pWC!=0 );
140315 assert(pX->pLeft);
140507 assert( pIdx!=0 );
140508 assert( iCol>=0 && iCol<pIdx->nColumn );
140515 assert( j==(-2) );
140756 assert( v!=0 );
140768 assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */
140798 assert( nKeyCol>0 );
140846 assert( (u32)n==pLoop->u.btree.nEq );
140864 assert( n==nKeyCol );
140869 assert( pLevel->iIdxCur>=0 );
140951 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
140958 assert( pTerm->u.leftColumn>=(-1) );
141010 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
141031 assert( pTerm->u.leftColumn>=(-1) );
141049 assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
141050 assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
141051 assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
141052 assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
141053 assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
141054 assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
141150 assert( pRec!=0 );
141151 assert( pIdx->nSample>0 );
141152 assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol );
141241 assert( i<pIdx->nSample );
141242 assert( iCol==nField-1 );
141244 assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
141251 assert( i<=pIdx->nSample && i>=0 );
141253 assert( i==pIdx->nSample
141263 assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0
141268 assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
141277 assert( iCol==nField-1 );
141328 nRet -= 20; assert( 20==sqlite3LogEst(4) );
141340 assert( iCol>=0 && iCol<pIdx->nColumn );
141446 assert( *pbDone==0 );
141561 assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 );
141562 assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 );
141563 assert( p->aSortOrder!=0 );
141612 if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) );
141614 nNew = 10; assert( 10==sqlite3LogEst(2) );
141631 assert( pLower || pUpper );
141633 assert( pUpper==0 || (pUpper->wtFlags & TERM_VNULL)==0 );
141691 assert( nEq>=1 );
141692 assert( nEq<=p->nColumn );
141693 assert( p->aSample!=0 );
141694 assert( p->nSample>0 );
141695 assert( pBuilder->nRecValid<nEq );
141756 assert( p->aSample!=0 );
141769 assert( pBuilder->nRecValid==nRecValid );
141961 assert( pWInfo!=0 );
142088 assert( p->rSetup==0 || pTemplate->rSetup==0
142094 assert( p->rSetup>=pTemplate->rSetup );
142130 assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */
142307 assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
142462 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
142463 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
142467 assert( pNew->u.btree.nBtm==0 );
142472 assert( pNew->u.btree.nEq<pProbe->nColumn );
142529 assert( nInMul==0
142540 nIn = 46; assert( 46==sqlite3LogEst(25) );
142553 assert( nIn>0 ); /* RHS always has 2 or more terms... The parser
142595 assert( saved_nEq==pNew->u.btree.nEq );
142622 assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
142623 assert( pTop->wtFlags & TERM_LIKEOPT );
142624 assert( pTop->eOperator==WO_LT );
142631 assert( eOp & (WO_LT|WO_LE) );
142648 assert( pNew->nOut==saved_nOut );
142655 assert( eOp & (WO_ISNULL|WO_EQ|WO_IN|WO_IS) );
142657 assert( pNew->nOut==saved_nOut );
142659 assert( (eOp & WO_IN) || nIn==0 );
142755 assert( 42==sqlite3LogEst(18) );
142908 assert( !IsVirtual(pSrc->pTab) );
142985 pNew->nOut = 43; assert( 43==sqlite3LogEst(20) );
143019 assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 );
143156 assert( (mUsable & mPrereq)==mPrereq );
143175 assert( pIdxInfo->needToFreeIdxStr==0 );
143199 assert( pNew->nLSlot>=nConstraint );
143223 assert( iTerm<pNew->nLSlot );
143237 *pbIn = 1; assert( (mExclude & WO_IN)==0 );
143253 assert( pNew->nLTerm<=pNew->nLSlot );
143347 assert( (mPrereq & mUnusable)==0 );
143353 assert( IsVirtual(pSrc->pTab) );
143389 assert( bIn==0 );
143402 assert( mNext>0 );
143523 assert( rc==SQLITE_OK || sCur.n==0 );
143710 assert( pOrderBy!=0 );
143755 assert( wctrlFlags & WHERE_ORDERBY_LIMIT );
143779 assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
143780 assert( pIndex->aiColumn[nColumn-1]==XN_ROWID
143793 assert( j>=pLoop->u.btree.nEq
143821 assert( (pLoop->aLTerm[i]->eOperator & WO_IN) );
143964 assert( pWInfo->wctrlFlags & WHERE_GROUPBY );
143965 assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP );
144006 assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
144060 assert( nLoop<=pWInfo->pTabList->nSrc );
144096 assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] );
144097 assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX );
144104 aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) );
144106 assert( aFrom[0].isOrdered==0 );
144138 assert( 10==sqlite3LogEst(2) );
144335 assert( pWInfo->nLevel==nLoop );
144391 assert( pWInfo->sorted==0 );
144431 assert( pWInfo->pTabList->nSrc>=1 );
144453 assert( pLoop->aLTermSpace==pLoop->aLTerm );
144481 assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] );
144635 assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || (
144641 assert( (wctrlFlags & WHERE_OR_SUBCLAUSE)==0
144703 assert( pWInfo->eOnePass==ONEPASS_OFF ); /* ONEPASS defaults to OFF */
144708 assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) );
144754 assert( m>=mx );
144966 assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
144970 assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
145018 assert( pTabItem->iCursor==pLevel->iTabCur );
145026 assert( n<=pTab->nCol );
145048 assert( iAuxArg!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 );
145059 assert( wctrlFlags & WHERE_ONEPASS_DESIRED );
145073 assert( pIx->pSchema==pTab->pSchema );
145074 assert( iIndexCur>=0 );
145235 assert( pLoop->wsFlags & WHERE_IN_EARLYOUT );
145266 assert( (ws & WHERE_IDX_ONLY)==0 || (ws & WHERE_INDEXED)!=0 );
145268 assert( pLevel->iTabCur==pTabList->a[pLevel->iFrom].iCursor );
145292 assert( pWInfo->nLevel<=pTabList->nSrc );
145299 assert( pTab!=0 );
145372 assert( pIdx->pTable==pTab );
145376 assert( x>=0 );
145384 assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0
145743 UNUSED_PARAMETER(nArg); assert( nArg==0 );
145756 UNUSED_PARAMETER(nArg); assert( nArg==0 );
145788 UNUSED_PARAMETER(nArg); assert( nArg==0 );
145801 UNUSED_PARAMETER(nArg); assert( nArg==0 );
145837 assert( nArg==1 ); UNUSED_PARAMETER(nArg);
145857 assert( nArg==1 ); UNUSED_PARAMETER(nArg);
145874 assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal );
145986 assert(0); /*NO_TEST*/
146187 assert( pWin->pOwner==pExpr );
146199 assert( ExprHasProperty(pExpr, EP_Static)==0 );
146465 assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS );
146466 assert( eStart==TK_CURRENT || eStart==TK_PRECEDING
146468 assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING
146470 assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) );
146471 assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) );
146572 assert( pWin->pOrderBy==0 );
146587 assert( p->op==TK_FUNCTION );
146669 assert( pKeyInfo->aSortOrder[0]==0 );
146715 assert( eCond>=0 && eCond<ArraySize(azErr) );
146723 assert( eCond==3 || eCond==4 );
146729 assert( eCond==0 || eCond==1 || eCond==2 );
146817 assert( pFunc->zName==nth_valueName
146820 assert( bInverse==0 || bInverse==1 );
146826 assert( nArg==0 || nArg==pWin->pOwner->x.pList->nExpr );
146827 assert( nArg || pWin->pOwner->x.pList==0 );
146836 assert( nArg>0 );
146922 assert( pMWin->regStartRowid==0 );
147137 assert( pWin->eStart!=TK_UNBOUNDED );
147229 assert( op==OP_Ge || op==OP_Gt || op==OP_Le );
147230 assert( p->pMWin->pOrderBy && p->pMWin->pOrderBy->nExpr==1 );
147235 default: assert( op==OP_Le ); op = OP_Ge; break;
147253 assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le );
147291 assert( regCountdown==0 && jumpOnEof==0 );
147298 assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP );
147335 assert( pMWin->regEndRowid );
147343 assert( op==WINDOW_AGGSTEP );
147347 assert( pMWin->regEndRowid );
147819 assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT
147822 assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT
147825 assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT
147969 assert( pMWin->eEnd==TK_FOLLOWING );
148081 assert( pMWin->eEnd==TK_FOLLOWING );
150194 assert( pParser->yytos!=0 );
150195 assert( pParser->yytos > pParser->yystack );
150297 assert( stateno <= YY_SHIFT_COUNT );
150303 assert( i>=0 );
150305 assert( iLookAhead!=YYNOCODE );
150306 assert( iLookAhead < YYNTOKEN );
150319 assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
150369 assert( stateno<=YY_REDUCE_COUNT );
150372 assert( iLookAhead!=YYNOCODE );
150379 assert( i>=0 && i<YY_ACTTAB_COUNT );
150380 assert( yy_lookahead[i]==iLookAhead );
150442 assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
151278 assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
151424 assert( yyLookahead!=YYNOCODE );
152020 assert( t.n>=2 );
152381 assert( yymsp[-2].minor.yy455!=0 );
152388 assert( yymsp[-1].minor.yy455!=0 );
152542 assert( yymsp[0].minor.yy295!=0 );
152643 assert( yylhsminor.yy295!=0 );
152666 /* (319) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=319);
152683 /* (336) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=336);
152684 /* (337) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=337);
152690 /* (343) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=343);
152692 /* (345) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=345);
152693 /* (346) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=346);
152694 /* (347) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=347);
152698 /* (351) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=351);
152701 /* (354) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=354);
152702 /* (355) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=355);
152725 assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
152732 assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );
152735 assert( yyact!=YY_ERROR_ACTION );
152809 assert( yypParser->yytos==yypParser->yystack );
152855 assert( yypParser->yytos!=0 );
152874 assert( yyact==yypParser->yytos->stateno );
152890 assert( yyact == YY_ERROR_ACTION );
153928 assert( zSql!=0 );
153935 assert( pzErrMsg!=0 );
153954 assert( pParse->pNewTable==0 );
153955 assert( pParse->pNewTrigger==0 );
153956 assert( pParse->nVar==0 );
153957 assert( pParse->pVList==0 );
153969 assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER
153974 assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
153997 assert( n==6 );
154000 assert( n==4 );
154003 assert( n==6 );
154016 assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
154019 assert( nErr==0 );
154038 assert( pzErrMsg!=0 );
154087 assert( nErr==0 || pParse->rc!=SQLITE_OK );
154127 assert( pStr!=0 ); /* sqlite3_str_new() never returns NULL */
154164 assert( pStr->nChar>=iStartIN );
154772 assert( SQLITE_PTRSIZE==sizeof(char*) );
154880 assert( sqlite3GlobalConfig.nRefInitMutex==0 );
154897 assert(sizeof(x)==8);
154898 assert(sizeof(x)==sizeof(y));
154900 assert( sqlite3IsNaN(y) );
155336 assert( sz > (int)sizeof(LookasideSlot*) );
155519 assert( pKey1 && pKey2 );
155542 assert( p==0 || p->xCmp!=binCollFunc || p->pUser!=0
155694 assert( sqlite3_mutex_held(db->mutex) );
155824 assert( db->nDb<=2 );
155825 assert( db->aDb==db->aDbStatic );
155886 assert( sqlite3LookasideUsed(db,0)==0 );
155904 assert( sqlite3_mutex_held(db->mutex) );
156160 assert( count>=0 );
156329 assert( sqlite3_mutex_held(db->mutex) );
156330 assert( xValue==0 || xSFunc==0 );
156341 assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
156382 assert( !db->mallocFailed );
156390 assert(p || db->mallocFailed);
156458 assert( rc!=SQLITE_OK );
156533 assert( !db->mallocFailed );
156886 assert( SQLITE_CHECKPOINT_PASSIVE==0 );
156887 assert( SQLITE_CHECKPOINT_FULL==1 );
156888 assert( SQLITE_CHECKPOINT_RESTART==2 );
156889 assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
156959 assert( sqlite3_mutex_held(db->mutex) );
156960 assert( !pnLog || *pnLog==-1 );
156961 assert( !pnCkpt || *pnCkpt==-1 );
157033 assert( !db->mallocFailed );
157135 assert( sqlite3_mutex_held(db->mutex) );
157279 assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
157280 assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
157281 assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
157282 assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
157283 assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
157284 assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
157285 assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
157286 assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
157287 assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
157289 assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
157290 assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
157291 assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
157292 assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
157347 assert( *pzErrMsg==0 );
157414 assert( octet>=0 && octet<256 );
157687 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
157754 assert( db->pDfltColl!=0 );
157769 assert( SQLITE_OPEN_READONLY == 0x01 );
157770 assert( SQLITE_OPEN_READWRITE == 0x02 );
157771 assert( SQLITE_OPEN_CREATE == 0x04 );
157920 assert( db->mutex!=0 || isThreadsafe==0
157925 assert( db!=0 || rc==SQLITE_NOMEM );
157994 assert( *ppDb || rc==SQLITE_NOMEM );
158037 assert( !db->mallocFailed );
158062 assert( !db->mallocFailed );
158364 assert( pPager!=0 );
158366 assert( fd!=0 );
158517 assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
159034 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) )
159066 assert( p->pUnlockConnection || p->pBlockingConnection );
159071 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
159072 assert( db==0 || p->pUnlockConnection!=db );
159073 assert( db==0 || p->pBlockingConnection!=db );
159188 assert( !db->mallocFailed );
159250 assert( p->xUnlockNotify );
159257 assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
159258 assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
160049 # define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x))
160051 # define assert_fts3_nc(x) assert(x)
160573 SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; }
160574 SQLITE_PRIVATE int sqlite3Fts3Never(int b) { assert( !b ); return b; }
160599 assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
160649 assert( a & 0x80 );
160657 assert( 0==(a & 0x80000000) );
160658 assert( *pi>=0 );
160758 assert( p->nPendingData==0 );
160759 assert( p->pSegments==0 );
160963 assert( p->bHasStat==p->bFts4 );
160997 assert( p->nPgsz>0 || rc!=SQLITE_OK );
161267 assert( nPrefix>=0 );
161420 assert( strlen(argv[0])==4 );
161421 assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4)
161537 assert( iOpt==6 );
161549 assert( iOpt==SizeofArray(aFts4Opt) );
161600 assert( nString==0 );
161610 assert( pTokenizer );
161614 assert( zPrefix );
161680 assert( zCsr <= &((char *)p)[nByte] );
161752 assert( p->pSegments==0 );
161935 assert( p->pSegments==0 );
161998 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
162000 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
162130 assert( nPrefix>=0 && nSuffix>=0 );
162145 assert( zBuffer );
162215 assert( piLeaf || piLeaf2 );
162219 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
162256 assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) );
162518 assert( isSaveLeft==0 || isExact==0 );
162520 assert( p!=0 && *p1!=0 && *p2!=0 );
162554 assert( p );
162566 assert( pp && p );
162572 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
162731 assert( *pbFirst || *piPrev==0 );
162732 assert( *pbFirst==0 || iWrite>0 );
162844 assert( (p-aOut)<=n1+n2+FTS3_VARINT_MAX-1 );
162882 assert( nDist>0 );
163079 assert( iOut>0 );
163224 assert( iIndex>=0 && iIndex<p->nIndex );
163225 assert( iLevel==FTS3_SEGCURSOR_ALL
163229 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
163230 assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
163231 assert( isPrefix==0 || isScan==0 );
163433 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
163503 assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
163504 assert( p->pSegments==0 );
163512 assert( iIdx==nVal );
163539 assert( p->base.zErrMsg==0 );
163635 assert( iCol>=0 && iCol<=p->nColumn+2 );
163670 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
163728 assert( rc==SQLITE_OK || mxLevel==0 );
163765 assert( p->pSegments==0 );
163766 assert( p->nPendingData==0 );
163767 assert( p->inTransaction!=1 );
163782 assert( p->nPendingData==0 );
163783 assert( p->inTransaction!=0 );
163784 assert( p->pSegments==0 );
163797 assert( p->inTransaction!=0 );
163822 assert( p==pStart || c==0 );
163889 assert( nVal>=1 );
163926 assert( nVal==1 );
163928 assert( pCsr );
163954 assert( nVal==1 );
163957 assert( p );
163983 assert( nVal==1 || nVal==2 );
164051 assert( p->nPendingData==0 );
164094 assert( ((Fts3Table *)pVtab)->inTransaction );
164095 assert( ((Fts3Table *)pVtab)->mxSavepoint <= iSavepoint );
164112 assert( p->inTransaction );
164113 assert( p->mxSavepoint >= iSavepoint );
164126 assert( p->inTransaction );
164297 assert( rc!=SQLITE_OK );
164342 assert( pExpr->pPhrase->iDoclistToken==0 );
164370 assert( iToken!=p->iDoclistToken );
164436 assert( pToken->pDeferred==0 || pToken->pSegcsr==0 );
164446 assert( pToken->pSegcsr==0 );
164469 assert( pPhrase->doclist.bFreeList==0 );
164496 assert( iPrev>=0 );
164619 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
164644 assert( nDoclist>0 );
164645 assert( *pbEof==0 );
164646 assert( p || *piDocid==0 );
164647 assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
164699 assert( nDoclist>0 );
164700 assert( *pbEof==0 );
164701 assert( p || *piDocid==0 );
164702 assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) );
164764 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
164799 assert( p->bIgnore==0 );
164800 assert( pPhrase->aToken[iToken].pSegcsr==0 );
164807 assert( pToken->pDeferred==0 );
164808 assert( pToken->pSegcsr || pPhrase->iDoclistToken>=0 );
164810 assert( p->bIgnore==0 );
164853 assert( p->bIncr==1 );
164865 assert( p->nToken<=MAX_INCR_PHRASE_TOKENS );
164866 assert( p->iDoclistToken<MAX_INCR_PHRASE_TOKENS );
164881 assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) );
164882 assert( rc!=SQLITE_OK || bMaxSet );
165056 assert( pExpr->eType==FTSQUERY_OR
165060 assert( pExpr->pLeft && pExpr->pRight );
165112 assert( a );
165126 assert( pCsr->nRowAvg>0 );
165186 assert( rc!=SQLITE_OK || nDocSize>0 );
165223 assert( pTC );
165248 assert( rc==SQLITE_OK || pList==0 );
165376 assert( pPhrase->doclist.pList );
165384 assert( pPhrase->doclist.pList[nNew]=='\0' );
165385 assert( nNew<=pPhrase->doclist.nList && nNew>0 );
165443 assert( pExpr->bEof==0 );
165451 assert( !pLeft->bDeferred || !pRight->bDeferred );
165481 assert( pRight->eType==FTSQUERY_PHRASE );
165506 assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
165507 assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
165535 assert( *pRc!=SQLITE_OK || pRight->bStart );
165611 assert( p->pRight->pPhrase->doclist.nList>0 );
165634 assert( p->pParent && p->pParent->pLeft==p );
165728 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
165804 assert( pCsr->isEof==0 );
165812 assert( sqlite3_data_count(pCsr->pStmt)==0 );
165856 assert( pToken->pDeferred==0 );
165933 assert( pExpr->eType==FTSQUERY_PHRASE );
165950 assert( pRoot->bStart );
165955 assert( pE->aMI==0 );
165968 assert( sqlite3_data_count(pCsr->pStmt)==0 );
166001 assert( pRoot->bEof==0 );
166048 assert( pCsr->nDoc>0 );
166056 assert( pExpr->aMI );
166101 assert( iCol>=0 && iCol<pTab->nColumn );
166140 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
166154 assert( pTest->eType==FTSQUERY_NEAR || pTest->eType==FTSQUERY_PHRASE );
166156 assert( pTest->eType==FTSQUERY_PHRASE );
166585 assert( iCol==0 );
166604 default: assert( eState==3 );
166646 assert( idxStr==0 );
166647 assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
166679 assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) );
166734 assert( p->isEof==0 );
166757 assert( iCol==4 );
166960 assert( rc==SQLITE_OK || pCsr==0 );
167144 assert( nToken==ii );
167179 assert( nTemp==0 );
167264 assert( nKey==4 );
167376 assert( p->eType!=FTSQUERY_PHRASE );
167384 assert( p->eType==FTSQUERY_AND );
167407 assert( pSplit->pParent->pRight==pSplit );
167446 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
167488 assert( pRet && pPrev );
167520 assert( pPrev && pPrev->pLeft && pPrev->pRight==0 );
167533 assert( nByte>0 );
167535 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
167628 assert( p->pParent==0 || p->pParent->pLeft==p );
167629 assert( p->pLeft && p->pRight );
167637 assert( pParent==0 || pParent->pLeft==p );
167652 assert( pFree );
167677 assert( pParent->pParent==0 || pParent->pParent->pLeft==pParent );
167682 assert( pParent==pRoot );
167700 assert( pFree!=0 );
167727 assert( pFree==0 );
167748 assert( pLeft && pRight );
167805 assert( rc==SQLITE_OK || *ppExpr==0 );
167884 assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
167899 assert( pDel==0 || pDel->pParent==0 );
167901 assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft );
167909 assert( p==p->pParent->pRight || p==p->pParent->pLeft );
168049 assert( rc==SQLITE_OK || pExpr==0 );
168171 assert( pNew!=0 );
168172 assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
168188 assert( pH!=0 );
168255 assert( keyClass==FTS3_HASH_BINARY );
168270 assert( keyClass==FTS3_HASH_BINARY );
168312 assert( (new_size & (new_size-1))==0 );
168387 assert( pH->first==0 );
168388 assert( pH->count==0 );
168403 assert( xHash!=0 );
168405 assert( (pH->htsize & (pH->htsize-1))==0 );
168448 assert( pH!=0 );
168450 assert( xHash!=0 );
168452 assert( (pH->htsize & (pH->htsize-1))==0 );
168471 assert( pH->htsize>0 );
168486 assert( pH->htsize>0 );
168487 assert( (pH->htsize & (pH->htsize-1))==0 );
168651 assert( x>='a' && x<='z' );
168660 assert( x>='a' && x<='z' );
169236 assert( argc==1 || argc==2 );
169346 assert( n==0 );
169375 assert( rc!=SQLITE_OK || *ppTok );
169599 assert( rc==SQLITE_OK );
169600 assert( p1==p2 );
169602 assert( rc==SQLITE_ERROR );
169603 assert( p2==0 );
169604 assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
169609 assert( rc==SQLITE_OK );
169611 assert( rc==SQLITE_OK );
169612 assert( p2==p1 );
170109 assert( (rc==SQLITE_OK)==(pMod!=0) );
170174 assert( pInfo->estimatedCost>1000000.0 );
170319 assert( iCol==4 );
170772 assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
170773 assert( eStmt<SizeofArray(azSql) && eStmt>=0 );
170792 assert( rc==SQLITE_OK || pStmt==0 );
170949 assert( p->nIndex>0 );
170950 assert( iIndex>=0 && iIndex<p->nIndex );
170983 assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 );
170984 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
170985 assert( iIndex>=0 && iIndex<p->nIndex );
171074 assert( !p || p->iLastDocid<=iDocid );
171079 assert( p->nData<p->nSpace );
171080 assert( p->aData[p->nData]==0 );
171100 assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
171146 assert( 0==fts3HashFind(pHash, zToken, nToken) );
171186 assert( pTokenizer && pModule );
171248 assert( iLangid>=0 );
171249 assert( bDelete==1 || bDelete==0 );
171413 assert( p->zContentTbl==0 || bContent==0 );
171450 assert( *pbFound==0 );
171513 assert( iLangid>=0 );
171514 assert( p->nIndex>=1 );
171583 assert( pnBlob );
171658 assert( !pReader->pBlob
171720 assert( pReader->aNode );
171730 assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock || CORRUPT_DB );
171741 assert( pReader->pBlob==0 );
171749 assert( !fts3SegReaderIsPending(pReader) );
171806 assert( pReader->aDoclist );
171807 assert( !pReader->pOffsetList );
171846 assert( p );
171881 assert( *p==0 );
171936 assert( p->bFts4 );
171937 assert( pgsz>0 );
171992 assert( zRoot!=0 || nRoot==0 );
171994 assert( zRoot!=0 || CORRUPT_DB );
172183 assert( rc!=0 );
172207 assert( pLhs->aNode && pRhs->aNode );
172219 assert( pLhs->aNode && pRhs->aNode );
172264 assert( nSuspect<=nSegment );
172281 assert( xCmp(apSegment[i], apSegment[i+1])<0 );
172422 assert( pTree->aData==(char *)&pTree[1] );
172505 assert( iHeight>=1 && iHeight<128 );
172556 assert( iNextLeaf==iFree );
172578 assert( pRight==0 || p->zMalloc==0 );
172671 assert( nPrefix<nTerm );
172699 assert( nData+nReq<=pWriter->nSize );
172725 assert( pWriter->zTerm==pWriter->zMalloc );
172831 assert( iIndex>=0 && iIndex<p->nIndex );
172938 assert( iLevel>=0 || iLevel==FTS3_SEGCURSOR_ALL );
172988 assert( iCol>=0 );
173086 assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
173161 assert( pCsr->pFilter==0 );
173162 assert( zTerm && nTerm>0 );
173184 assert( iCol<0 || iCol<p->nColumn );
173205 assert( pCsr->zTerm==0 );
173206 assert( pCsr->nTerm==0 );
173207 assert( pCsr->aDoclist==0 );
173208 assert( pCsr->nDoclist==0 );
173264 assert( rc==SQLITE_OK );
173295 assert( isIgnoreEmpty || (isRequirePos && !isColFilter) );
173354 assert( nDoclist>0 || iDelta==iDocid );
173579 assert( iLevel==FTS3_SEGCURSOR_ALL
173583 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
173584 assert( iIndex>=0 && iIndex<p->nIndex );
173611 assert( FTS3_SEGCURSOR_PENDING==-1 );
173618 assert( csr.nSegment>0 );
173636 assert( pWriter || bIgnoreEmpty );
174004 assert( pCsr->nSegment==0 );
174124 assert( p->aNode );
174154 assert( p->iOff<=p->nNode );
174207 assert( nTerm>0 );
174258 assert( pNode->block.nAlloc>=p->nNodeSize );
174271 assert( 0 );
174314 assert( pNode->n>0 );
174315 assert( (pNode->a[0]=='\0')==(aDoclist!=0) );
174338 assert( pNode->n<=pNode->nAlloc );
174451 assert( *pRc || pNode->block.nAlloc==0 );
174452 assert( *pRc || pNode->key.nAlloc==0 );
174634 assert( reader.aNode );
174887 assert( p->bIgnoreSavepoint==0 );
174906 assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) );
174909 assert( pNode->nAlloc>=1 );
174961 assert( pNew->n<=pNew->nAlloc );
175083 assert( j<pCsr->nSegment && pSeg->iIdx==i );
175257 assert( nSeg>=2 );
175302 assert( bUseHint==1 || bUseHint==0 );
175417 assert( p->bFts4==0 );
175447 assert( p->bFts4==0 );
175505 assert( *pRc==SQLITE_OK );
175782 assert( pCsr->isRequireSeek==0 );
175870 assert( pToken->pDeferred==0 );
175946 assert( p->bHasStat==0 || p->bHasStat==1 );
175948 assert( p->pSegments==0 );
175949 assert(
176034 assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER );
176051 assert( p->iPrevDocid==*pRowid );
176250 assert( (u32*)p==&pBuf->aMatchinfo[1]
176299 assert( p->aRef[0]==1 );
176351 assert( pExpr->pLeft && pExpr->pRight );
176533 assert( iCsr>=iStart && (iCsr - iStart)<=64 );
176534 assert( i>=0 && i<=64 );
176571 assert( rc==SQLITE_OK || pCsr==0 );
176585 assert( rc!=SQLITE_OK || (
176672 assert( iScore>=0 );
176716 assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) );
176764 assert( (nSnippet-1-nRight)<=63 && (nSnippet-1-nRight)>=0 );
176797 assert( nShift<=nDesired );
176967 assert( p->flag==FTS3_MATCHINFO_LHITS_BM || p->flag==FTS3_MATCHINFO_LHITS );
176983 assert( *pIter==0x00 || *pIter==0x01 );
177000 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
177124 assert( cArg==FTS3_MATCHINFO_HITS );
177147 assert( sqlite3_data_count(pStmt)==1 );
177392 assert( zArg[i]==FTS3_MATCHINFO_HITS );
177587 assert( (mCovered&mSeen)==mCovered );
177591 assert( nFToken>0 );
177677 assert( pCsr->isRequireSeek==0 );
177783 assert( rc!=SQLITE_DONE );
177966 assert( bAlnum==0 || bAlnum==1 );
177970 assert( (sqlite3FtsUnicodeIsalnum((int)iCode) & 0xFFFFFFFE)==0 );
178035 assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 );
178369 assert( aEntry[0]<key );
178370 assert( key>=aEntry[iRes] );
178442 assert( key>=aDia[iRes] );
178565 assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 );
178575 assert( c>aEntry[0].iCode );
178587 assert( iRes>=0 && c>=aEntry[iRes].iCode );
178591 assert( ret>0 );
178919 assert( sizeof(aSpecial)==32 );
178920 assert( aSpecial['\b']=='b' );
178921 assert( aSpecial['\f']=='f' );
178922 assert( aSpecial['\n']=='n' );
178923 assert( aSpecial['\r']=='r' );
178924 assert( aSpecial['\t']=='t' );
178940 assert( p->nUsed<p->nAlloc );
178994 assert( p->bStatic );
179054 assert( pNode->eType==JSON_NULL );
179144 assert( pNode->eType==JSON_NULL );
179203 assert( (pNode->jnFlags & JNODE_RAW)==0 );
179229 assert( i<n-2 );
179231 assert( safe_isxdigit(c) );
179300 assert( pParse->nNode>=pParse->nAlloc );
179310 assert( pParse->nNode<pParse->nAlloc );
179463 assert( '-' < '0' );
179526 assert( pParse->iDepth==0 );
179576 assert( pParse->aUp==0 );
179858 assert( zErr!=0 && pCtx!=0 );
179889 assert( pNode->eType==JSON_OBJECT );
179923 assert( argc==1 );
179930 assert( x.aNode[i].eType==JSON_STRING );
180030 assert( p->nNode );
180041 assert( (pNode->jnFlags & JNODE_APPEND)==0 );
180109 assert( iTarget>=0 && iTarget<pParse->nNode );
180111 assert( (pPatch->jnFlags & JNODE_APPEND)==0 );
180120 assert( pPatch[i].eType==JSON_STRING );
180121 assert( pPatch[i].jnFlags & JNODE_LABEL );
180124 assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
180126 assert( pTarget[j].eType==JSON_STRING );
180127 assert( pTarget[j].jnFlags & JNODE_LABEL );
180128 assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
180184 assert( pResult!=0 || x.oom );
180254 assert( x.nNode );
180291 assert( x.nNode );
180340 assert( x.nNode );
180446 assert( pStr->bStatic );
180493 assert( i<pStr->nUsed );
180545 assert( pStr->bStatic );
180744 assert( pUp->eType==JSON_OBJECT );
180746 assert( pNode->eType==JSON_STRING );
180747 assert( pNode->jnFlags & JNODE_LABEL );
180842 assert( i==JEACH_JSON );
180874 assert( JEACH_ROOT == JEACH_JSON+1 );
180883 assert( iCol==0 || iCol==1 );
181602 assert( ((((char*)p) - (char*)0)&3)==0 ); /* p is always 4-byte aligned */
181656 assert( ((((char*)p) - (char*)0)&3)==0 ); /* p is always 4-byte aligned */
181657 assert( sizeof(RtreeCoord)==4 );
181658 assert( sizeof(u32)==4 );
181704 assert( p->nRef>0 );
181740 assert( pNode->pNext==0 );
181753 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
181819 assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
181968 assert( nCell<=nMaxCell );
182010 assert( pNode->nRef>0 );
182011 assert( pRtree->nNodeRef>0 );
182041 assert( iCell<NCELL(pNode) );
182131 assert( pRtree->nCursor==0 );
182133 assert( pRtree->nNodeRef==0 || pRtree->bCorrupt );
182230 assert( pRtree->nCursor>0 );
182316 assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY );
182317 assert( nCoord==2 || nCoord==4 || nCoord==6 || nCoord==8 || nCoord==10 );
182391 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
182393 assert( ((((char*)pCellData) - (char*)0)&3)==0 ); /* 4-byte aligned */
182431 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
182434 assert( ((((char*)pCellData) - (char*)0)&3)==0 ); /* 4-byte aligned */
182458 assert( nCell<200 );
182508 assert( i<j );
182537 assert( ii==0 || ii==1 );
182538 assert( pCur->bPoint || pCur->nPoint );
182540 assert( pRC!=0 );
182568 assert( iLevel<=RTREE_MAX_DEPTH );
182603 assert( pCur->aNode[ii]==0 );
182655 assert( i==0 || i==1 );
182717 assert( nCell<200 );
182822 assert( pRtree->eCoordType==RTREE_COORD_INT32 );
182945 assert( p!=0 ); /* Always returns pCsr->sPoint */
182968 assert( (idxStr==0 && argc==0)
183003 assert( pCsr->bPoint==1 );
183071 assert( pIdxInfo->idxStr==0 );
183141 assert( pRtree->nDim>=1 && pRtree->nDim<=5 );
183438 assert( left<=right );
183505 assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
183820 assert( pNode->nRef==1 );
183909 assert( pParent || pNode->iNode==1 );
184121 assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB );
184236 assert( iCol==0 || iCol%2 );
184287 assert(nData>=1);
184419 assert( pRtree->inWrTrans==0 );
184803 assert( RTREE_MAX_AUX_COLUMN<256 ); /* Aux columns counted by a u8 */
184887 assert( *ppVtab==0 );
184888 assert( pRtree->nBusy==1 );
185132 assert( bLeaf==0 || bLeaf==1 );
185226 assert( iNode==1 || aParent!=0 );
185227 assert( pCheck->nDim>0 );
186003 assert( r>=-0.5*GEOPOLY_PI && r<=2.0*GEOPOLY_PI );
186733 assert( *ppVtab==0 );
186734 assert( pRtree->nBusy==1 );
186812 assert( p!=0 ); /* Always returns pCsr->sPoint */
186830 assert( argc==1 );
186889 assert( pCsr->bPoint==1 );
187045 assert(nData>=1);
187124 assert( pRtree->nAux>=1 );
187543 assert( *zIn ); \
187735 assert(!pExpr);
187802 assert(nArg==1 || nArg==2);
187836 assert( cnt==0 );
187843 assert( 0 ); /* Unreachable */
187876 assert(!"Unexpected return value from ucol_strcoll()");
187905 assert(nArg==2);
187919 assert(p);
188197 assert(iStart<=iEnd);
189534 assert( argc==2 );
189625 assert( *pzErrmsg==0 );
189790 assert( argc==1 || argc==2 );
189908 assert( nByte>0 );
189953 assert( *pRc==SQLITE_OK );
190040 assert( p->rc==SQLITE_OK );
190167 assert( pIter->eType==0 );
190176 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
190254 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
190255 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
190325 assert( p->zErrmsg==0 );
190344 assert( i<pIter->nTblCol );
190597 assert( pIter->zIdx==0 );
190793 assert( pIter->pTmpInsert==0 );
190811 assert( sqlite3_value_int(apVal[0])!=0
190898 assert( pIter->bCleanup==0 );
190920 assert( pIter->eType!=RBU_PK_VTAB );
191148 assert( pUp==0 || pUp->pNext==0 );
191305 assert( p->rc || (p->dbMain==0 && p->dbRbu==0) );
191306 assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 );
191595 assert( p->nPagePerSector==0 );
191664 assert( p->rc==SQLITE_OK );
191679 assert( p->rc==SQLITE_OK );
191729 assert( p->eStage==RBU_STAGE_MOVE );
191730 assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
191853 assert( 0==sqlite3_stricmp(zName, zCol) );
191870 assert( p->rc==SQLITE_OK );
191871 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
191872 assert( eType==RBU_DELETE || eType==RBU_IDX_DELETE
191953 assert( eType==RBU_INSERT || eType==RBU_DELETE
191957 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
191975 assert( eType==RBU_UPDATE );
192049 assert( p->zErrmsg==0 );
192076 assert( pInsert==0 || rc==SQLITE_OK );
192128 assert( rbuIsVacuum(p) );
192221 assert( pIter->zTbl==0 );
192322 assert( p->rc==SQLITE_OK );
192358 assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
192374 assert( p->rc==SQLITE_OK );
192380 assert( pVfs );
192412 assert( nVal==1 );
192541 assert( pState || p->rc!=SQLITE_OK );
192556 assert( p->rc!=SQLITE_OK || p->eStage!=0 );
192761 assert( p->szTemp==0 );
192823 assert( 0 );
192836 assert( RBU_STAGE_OAL==1 );
192837 assert( RBU_STAGE_MOVE==2 );
192838 assert( RBU_STAGE_CKPT==4 );
192839 assert( RBU_STAGE_DONE==5 );
192840 assert( aRes[RBU_STAGE_OAL]==SQLITE_RBU_STATE_OAL );
192841 assert( aRes[RBU_STAGE_MOVE]==SQLITE_RBU_STATE_MOVE );
192842 assert( aRes[RBU_STAGE_CKPT]==SQLITE_RBU_STATE_CHECKPOINT );
192843 assert( aRes[RBU_STAGE_DONE]==SQLITE_RBU_STATE_DONE );
192848 assert( p->rc!=SQLITE_DONE || p->eStage==RBU_STAGE_DONE );
192849 assert( p->eStage==RBU_STAGE_OAL
192862 assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
192864 assert( rc!=SQLITE_DONE );
192879 assert( rc!=SQLITE_DONE );
192952 assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
192972 assert( pRbu->szTemp>=0 );
192988 assert( (p->openFlags & SQLITE_OPEN_MAIN_DB) );
193064 assert( p->pMainNext==0 && p->pRbuVfs->pMain!=p );
193113 assert( p->openFlags & SQLITE_OPEN_WAL );
193179 assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
193263 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
193301 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB)
193376 assert( WAL_CKPT_LOCK==1 );
193379 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
193423 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
193453 assert( p->apShm==0 );
193476 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
193602 assert( oflags & SQLITE_OPEN_MAIN_DB );
194049 assert( rc==SQLITE_OK || pTab==0 );
194274 assert( nPayload>=(u32)nLocal );
194275 assert( nLocal<=(nUsable-35) );
194291 assert( pPg==0 );
194419 assert( p==&pCsr->aPage[pCsr->iPage-1] );
194697 assert( rc==SQLITE_OK || pTab==0 );
194846 assert( argc>=1 );
194859 assert( argc>(idxNum>>1) );
194868 assert( pCsr->pgno==1 );
195424 assert( sizeof(double)==8 && sizeof(u64)==8 );
195438 assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
195532 assert( *pbNullPK==0 );
195533 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
195555 assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
195571 assert( eType==SQLITE_NULL );
195572 assert( pTab->bStat1==0 || i!=1 );
195623 assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
195627 assert( !isPK || (eType!=0 && eType!=SQLITE_NULL) );
195753 assert( a1 );
195797 assert( aOldRecord1 && aNewRecord1 );
195863 assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
195884 assert( rc==SQLITE_OK );
195888 assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
195899 assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
196013 assert( pazCol && pabPK );
196112 assert( pTab->azCol==0 || pTab->abPK==0 );
196249 assert( rc==SQLITE_OK );
196258 assert( trc==SQLITE_OK );
196261 assert( trc==SQLITE_OK );
196348 assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
196353 assert( rc==SQLITE_OK || pRet==0 );
196373 assert( sqlite3_mutex_held(db->mutex) );
196387 assert( pSession->rc==SQLITE_OK );
196515 assert( zRet==0 );
197133 assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
197208 assert( abPK[i]==0 );
197227 assert( (a - p->aRecord)==p->nRecord );
197312 assert( abPK[i]==0 );
197347 assert( eType==SQLITE_BLOB );
197403 assert( xOutput==0 || (pnChangeset==0 && ppChangeset==0 ) );
197620 assert( xInput==0 || (pChangeset==0 && nChangeset==0) );
197689 assert( nMove>=0 );
197819 assert( apOut[i]==0 );
197963 assert( p->rc==SQLITE_OK );
198019 assert( (paRec==0 && pnRec==0) || (paRec && pnRec) );
198061 assert( p->in.iNext==1 || p->zTab );
198108 assert( p->bPatchset==0 || p->apValue[i]==0 );
198110 assert( p->apValue[i]==0 );
198369 assert( rc==SQLITE_OK );
198434 assert( rc==SQLITE_OK );
198442 assert( rc==SQLITE_OK );
198836 assert( xValue==sqlite3changeset_old || xValue==sqlite3changeset_new );
198925 assert( eType==SQLITE_CHANGESET_REPLACE||eType==SQLITE_CHANGESET_OMIT );
198926 assert( eOp==SQLITE_DELETE || eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE );
198996 assert( eType==SQLITE_CHANGESET_CONFLICT || eType==SQLITE_CHANGESET_DATA );
198997 assert( SQLITE_CHANGESET_CONFLICT+1==SQLITE_CHANGESET_CONSTRAINT );
198998 assert( SQLITE_CHANGESET_DATA+1==SQLITE_CHANGESET_NOTFOUND );
199031 assert( pbReplace );
199091 assert( p->pDelete && p->pUpdate && p->pInsert && p->pSelect );
199092 assert( p->azCol && p->abPK );
199093 assert( !pbReplace || *pbReplace==0 );
199172 assert( op==SQLITE_INSERT );
199233 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
199243 assert( pIter->op==SQLITE_INSERT );
199303 assert( pApply->bDeferConstraints || pApply->constraints.nBuf==0 );
199346 assert( xConflict!=0 );
199501 assert( sApply.bRebase || sApply.rebase.nBuf==0 );
199747 assert( pNew==0 );
199768 assert( op2==SQLITE_UPDATE );
199773 assert( op2==SQLITE_INSERT );
199787 assert( op1==SQLITE_UPDATE );
199798 assert( op1==SQLITE_UPDATE && op2==SQLITE_DELETE );
199956 assert( xOutput==0 || (ppOut==0 && pnOut==0) );
200175 assert( pBuf->nBuf<=pBuf->nAlloc );
200315 assert( pChange->op==SQLITE_DELETE || pChange->op==SQLITE_INSERT );
200350 assert( pIter->op==SQLITE_DELETE );
201175 # define assert_nc(x) assert(sqlite3_fts5_may_be_corrupt || (x))
201177 # define assert_nc(x) assert(x)
202528 assert( pParser->fts5yytos!=0 );
202529 assert( pParser->fts5yytos > pParser->fts5yystack );
202631 assert( stateno <= fts5YY_SHIFT_COUNT );
202637 assert( i>=0 );
202639 assert( iLookAhead!=fts5YYNOCODE );
202640 assert( iLookAhead < fts5YYNFTS5TOKEN );
202653 assert( fts5yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
202703 assert( stateno<=fts5YY_REDUCE_COUNT );
202706 assert( iLookAhead!=fts5YYNOCODE );
202713 assert( i>=0 && i<fts5YY_ACTTAB_COUNT );
202714 assert( fts5yy_lookahead[i]==iLookAhead );
202776 …assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack) );
202918 … assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack));
203098 assert( fts5yyruleno<sizeof(fts5yyRuleInfoLhs)/sizeof(fts5yyRuleInfoLhs[0]) );
203105 assert( !(fts5yyact>fts5YY_MAX_SHIFT && fts5yyact<=fts5YY_MAX_SHIFTREDUCE) );
203108 assert( fts5yyact!=fts5YY_ERROR_ACTION );
203180 assert( fts5yypParser->fts5yytos==fts5yypParser->fts5yystack );
203226 assert( fts5yypParser->fts5yytos!=0 );
203245 assert( fts5yyact==fts5yypParser->fts5yytos->stateno );
203261 assert( fts5yyact == fts5YY_ERROR_ACTION );
203984 assert( rc!=SQLITE_OK || nRow>0 );
204654 assert( q=='[' || q=='\'' || q=='"' || q=='`' );
204695 assert( 0==fts5_iswhitespace(z[0]) );
204796 assert( pConfig->nPrefix<=FTS5_MAX_PREFIX_INDEXES );
204903 assert( pConfig->pTok==0 && pConfig->pTokApi==0 );
204935 assert( *pRc==SQLITE_OK );
205008 assert( p->zContentExprlist==0 );
205109 assert( pRet->eContent==FTS5_CONTENT_NORMAL
205185 assert( zSql || rc==SQLITE_NOMEM );
205314 assert( zRankArgs==0 );
205435 assert( rc==SQLITE_OK || p==0 );
205453 assert( 0==*pConfig->pzErrmsg );
205722 assert( sParse.rc!=SQLITE_OK || sParse.zErr==0 );
205787 assert( pTerm->pSynonym );
205788 assert( bDesc==0 || bDesc==1 );
205819 assert( pTerm->pSynonym );
205837 assert( aIter[nIter].bEof==0 );
206036 assert( pNear->nPhrase>1 );
206145 assert( (bDesc==0 && iRowid>=iLast) || (bDesc==1 && iRowid<=iLast) );
206248 assert( pNode->bNomatch==0 );
206274 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
206308 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
206391 assert( pNear->nPhrase>1
206436 assert( pNode->bEof==0 || pNode->bNomatch==0 );
206494 assert( Fts5NodeIsString(pNode) );
206505 assert( rc==SQLITE_OK );
206525 assert( pNode->eType==FTS5_TERM );
206526 assert( pNode->pNear->nPhrase==1 && pPhrase->nTerm==1 );
206527 assert( pPhrase->aTerm[0].pSynonym==0 );
206550 assert( pNode->bEof==0 );
206595 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
206625 assert( pAnd->bEof==0 );
206645 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
206690 assert( pNode->nChild==2 );
206698 assert( rc!=SQLITE_OK || cmp<=0 );
206760 default: assert( pNode->eType==FTS5_NOT ); {
206793 assert( pChild->bEof==0 || pChild->bEof==1 );
206808 assert( pNode->eType==FTS5_NOT );
206855 assert( pRoot->bEof==0 && rc==SQLITE_OK );
206870 assert( pRoot->bEof==0 && pRoot->bNomatch==0 );
206873 assert( pRoot->bNomatch==0 || (rc==SQLITE_OK && pRoot->bEof==0) );
206973 assert( pParse->rc!=SQLITE_OK );
206979 assert( pLast==pParse->apPhrase[pParse->nPhrase-2] );
207090 assert( pParse->pExpr==0 );
207307 assert( pParse->rc==SQLITE_OK );
207308 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
207328 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
207388 assert( pParse->rc!=SQLITE_OK );
207453 assert( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING
207473 assert( pNode->eType!=FTS5_EOF || pNode->nChild==0 );
207527 default: assert( pNode->eType==FTS5_NOT ); {
207562 assert( (eType!=FTS5_STRING && !pNear)
207600 assert( pParse->rc==SQLITE_OK );
207602 assert( pParse->zErr==0 );
207619 assert( pParse->rc!=SQLITE_OK );
207640 assert( pLeft->eType==FTS5_STRING
207645 assert( pRight->eType==FTS5_STRING
207655 assert( pPrev->eType==FTS5_STRING
207661 assert( pParse->apPhrase[pParse->nPhrase-1]==pRight->pNear->apPhrase[0] );
207677 assert( ap[0]==pPrev->pNear->apPhrase[0] );
207803 assert( pExpr->eType==FTS5_OR );
207876 assert( pExpr->eType==FTS5_OR );
208128 assert( pExpr->apExprPhrase[i]->nTerm==1 );
208266 assert( pNode->eType==FTS5_NOT );
208296 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
208297 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
208520 assert( nData==p->iSzPoslist );
208531 assert( p->bDel==0 || p->bDel==1 );
208611 assert( iHash==fts5HashKey(pHash->nSlot, (u8*)zKey, nToken+1) );
208655 assert( (p->nAlloc - p->nData) >= (9 + 4 + 1 + 3 + 5) );
208679 assert( iCol>=p->iCol );
208820 assert( p->nKey+1==(int)strlen(zKey) );
208853 assert( !sqlite3Fts5HashScanEof(p) );
209351 #define ASSERT_SZLEAF_OK(x) assert( \
209529 assert( p->pReader==0 );
209581 assert( (pRet==0)==(p->rc!=SQLITE_OK) );
209697 assert( pStruct->nRef==0 );
209953 assert( p->iStructVersion!=0 );
209954 assert( p->pStruct!=0 );
209985 assert( (pBuf)->nSpace>=((pBuf)->n+nBlob) ); \
209992 assert( (pBuf)->nSpace>=(pBuf)->n ); \
210008 assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
210028 assert( pLvl->nMerge<=pLvl->nSeg );
210132 assert( pTst->nMerge==0 );
210164 assert( pLvl->bEof==0 );
210195 assert( iLvl<pIter->nLvl );
210266 assert( pLvl->bEof==0 );
210315 assert( iLvl<pIter->nLvl );
210542 assert( pIter->term.n<=pIter->term.nSpace );
210592 assert( pIter->pLeaf==0 );
210683 assert( pIter->flags & FTS5_SEGITER_REVERSE );
210684 assert( pIter->flags & FTS5_SEGITER_ONETERM );
210699 assert( pIter->pLeaf==0 );
210749 assert( pIter->flags & FTS5_SEGITER_REVERSE );
210750 assert( pIter->pNextLeaf==0 );
210785 assert( p->rc==SQLITE_OK );
210786 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
210787 assert( p->pConfig->eDetail==FTS5_DETAIL_NONE );
210862 assert( pbNewTerm==0 || *pbNewTerm==0 );
210863 assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
210892 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
210964 assert( p->rc==SQLITE_OK );
210965 assert( pIter->iLeafOffset<=pIter->pLeaf->nn );
211077 assert( pIter->flags & FTS5_SEGITER_ONETERM );
211078 assert( pIter->pDlidx==0 );
211124 assert( p->rc==SQLITE_OK );
211142 assert( nKeep>=nMatch );
211264 assert( bGe==0 || (flags & FTS5INDEX_QUERY_DESC)==0 );
211265 assert( pTerm && nTerm );
211346 assert( p->pHash );
211347 assert( p->rc==SQLITE_OK );
211422 assert( pRes->iFirst==i2 );
211424 assert( pRes->iFirst==i1 );
211431 assert( pRes->bTermEq==1 );
211432 assert( p1->iRowid!=p2->iRowid );
211435 assert( pRes->bTermEq==0 );
211439 assert( pRes->iFirst==i1 );
211441 assert( pRes->iFirst==i2 );
211458 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
211463 assert( p1==pFirst
211506 assert( iOut<pIter->nSeg && iOut>0 );
211507 assert( pIter->bRev==0 || pIter->bRev==1 );
211536 assert( res!=0 );
211557 assert( iLeafPgno>pIter->iLeafPgno );
211566 assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno );
211600 assert( pIter->flags & FTS5_SEGITER_ONETERM );
211601 assert( pIter->pDlidx );
211602 assert( pIter->pLeaf );
211615 assert( pIter->pNextLeaf==0 );
211616 assert( iMatch<pIter->iRowid );
211622 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
211666 assert( p->rc==SQLITE_OK );
211699 assert( pNew->pLeaf );
211700 assert( pRes->bTermEq==0 || pOther->pLeaf );
211746 assert( pIter->base.bEof==0 );
211751 assert( p->rc==SQLITE_OK );
211768 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
211782 assert( pIter->bSkipEmpty );
211790 assert( p->rc==SQLITE_OK );
211958 assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
211977 assert( pSeg->pNextLeaf==0 );
212007 assert( sCtx.eState==0 || sCtx.eState==1 );
212087 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
212100 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
212101 assert( pIter->pColset==0 );
212151 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
212152 assert( pIter->pColset );
212193 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
212194 assert( pColset );
212241 assert( pConfig->eDetail==FTS5_DETAIL_COLUMNS );
212280 assert( (pTerm==0 && nTerm==0) || iLevel<0 );
212285 assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
212327 assert( iIter==nSeg );
212404 assert( p->rc
212416 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
212515 assert( p->pHash || p->nPendingData==0 );
212543 assert( bFlush==0 || (pWriter->nDlidx>0 && pWriter->aDlidx[0].buf.n>0) );
212548 assert( pDlidx->pgno!=0 );
212616 assert( pWriter->iBtPage || pWriter->nEmpty==0 );
212666 assert( pDlidx->bPrevValid );
212736 assert( pDlidx->buf.n==0 );
212753 assert( (pPage->pgidx.n==0)==(pWriter->bFirstTermInPage) );
212756 assert( 0==fts5GetU16(&pPage->buf.p[2]) );
212761 assert( pPage->pgidx.n==0 );
212804 assert( p->rc==SQLITE_OK );
212805 assert( pPage->buf.n>=4 );
212806 assert( pPage->buf.n>4 || pWriter->bFirstTermInPage );
212868 assert( p->rc || (pWriter->nDlidx>0 && pWriter->aDlidx[0].buf.n==0) );
212918 assert( p->pConfig->pgsz>0 );
212950 assert( pLeaf->pgno>=1 );
212985 assert( pWriter->writer.buf.n==0 );
212986 assert( pWriter->writer.pgidx.n==0 );
213115 assert( iLvl<pStruct->nLevel );
213116 assert( pLvl->nMerge<=pLvl->nSeg );
213122 assert( pLvlOut->nSeg>0 );
213157 assert( iLvl>=0 );
213229 assert( pSeg->pgnoLast>0 );
213259 assert( pStruct->nLevel>0 );
213278 assert( pStruct->aLevel[iLvl].nSeg==0 );
213332 assert( p->rc!=SQLITE_OK || pStruct->nLevel>0 );
213335 assert( p->rc!=SQLITE_OK || pStruct->nLevel>(iLvl+1) );
213407 assert( p->rc || pBuf->nSpace>=(pgsz + FTS5_DATA_PADDING) );
213408 assert( p->rc || pPgidx->nSpace>=(pgsz + FTS5_DATA_PADDING) );
213425 assert( writer.bFirstRowidInPage==0 );
213450 assert( pBuf->n<=pBuf->nSpace );
213487 assert( n>0 );
213503 assert( pBuf->n<=pBuf->nSpace );
213537 assert( p->pHash );
213569 assert( pStruct->aLevel[i].nMerge<=nThis );
213609 assert( p->rc==SQLITE_OK );
213619 assert( pNew==0 || pNew->nSegment>0 );
213679 assert( nData>0 );
213692 assert( pIter->aPoslist );
213737 assert( pBuf->n!=0 || (*piLastRowid)==0 );
213744 assert( (pBuf)->n!=0 || (iLastRowid)==0 ); \
213793 assert( iOut==0 || iRowid1>iOut );
213798 assert( iOut==0 || iRowid2>iOut );
213879 assert( iPos1>=0 && iPos2>=0 );
213913 assert( iPos2>=0 && iPos2!=iPrev );
213927 assert( out.n<=(p1->n+p2->n+9) );
213940 assert( out.n<=(p1->n+p2->n+9) );
214005 assert( i<nBuf );
214049 assert( p->rc==SQLITE_OK );
214073 assert( p->rc==SQLITE_OK );
214144 assert( rc!=SQLITE_OK || p->rc==SQLITE_OK );
214158 assert( p->pReader==0 );
214233 assert( p->rc==SQLITE_OK );
214234 assert( (iCol<0)==p->bDelete );
214271 assert( (flags & FTS5INDEX_QUERY_SCAN)==0 || flags==FTS5INDEX_QUERY_SCAN );
214289 assert( flags & FTS5INDEX_QUERY_PREFIX );
214315 assert( p->rc!=SQLITE_OK || pRet->pColset==0 );
214343 assert( pIter->pIndex->rc==SQLITE_OK );
214355 assert( pIter->pIndex->rc==SQLITE_OK );
214434 assert( p->rc==SQLITE_OK );
214460 assert( p->rc==SQLITE_OK );
214532 assert( pgno>iLeaf );
214544 assert( fts5DlidxIterPgno(pDlidx)>iLeaf );
215193 assert( nArg==2 );
215449 assert( p->pStruct==0 || p->iStructVersion!=0 );
215710 assert( p->ts.eState==0 );
215716 assert( p->ts.eState==1 );
215721 assert( p->ts.eState==2 );
215726 assert( p->ts.eState==1 || p->ts.eState==2 || p->ts.eState==0 );
215731 assert( p->ts.eState==1 );
215732 assert( iSavepoint>=0 );
215733 assert( iSavepoint>=p->ts.iSavepoint );
215738 assert( p->ts.eState==1 );
215739 assert( iSavepoint>=0 );
215740 assert( iSavepoint<=p->ts.iSavepoint );
215745 assert( p->ts.eState==1 );
215746 assert( iSavepoint>=-1 );
215747 assert( iSavepoint<=p->ts.iSavepoint );
215825 assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
215851 assert( pConfig->pzErrmsg==0 );
215988 assert( SQLITE_INDEX_CONSTRAINT_EQ<SQLITE_INDEX_CONSTRAINT_MATCH );
215989 assert( SQLITE_INDEX_CONSTRAINT_GT<SQLITE_INDEX_CONSTRAINT_MATCH );
215990 assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
215991 assert( SQLITE_INDEX_CONSTRAINT_GE<SQLITE_INDEX_CONSTRAINT_MATCH );
215992 assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
216252 assert( *pbSkip==0 );
216286 assert( (pCsr->ePlan<3)==
216289 assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
216392 assert( pTab->pSortCsr==0 );
216436 assert( pTab->p.base.zErrMsg==0 );
216486 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
216502 assert( rc!=SQLITE_OK );
216511 assert( pTab->p.base.zErrMsg==0 );
216610 assert( pCsr->pStmt==0 );
216611 assert( pCsr->pExpr==0 );
216612 assert( pCsr->csrflags==0 );
216613 assert( pCsr->pRank==0 );
216614 assert( pCsr->zRank==0 );
216615 assert( pCsr->zRankArgs==0 );
216617 assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg );
216631 assert( iCol>=0 && iCol<=pConfig->nCol );
216632 assert( iVal==nVal );
216658 assert( pRowidEq==0 && pRowidLe==0 && pRowidGe==0 && pRank==0 );
216659 assert( nVal==0 && pMatch==0 && bOrderByRank==0 && bDesc==0 );
216660 assert( pCsr->iLastRowid==LARGEST_INT64 );
216661 assert( pCsr->iFirstRowid==SMALLEST_INT64 );
216737 assert( pCsr->ePlan==FTS5_PLAN_MATCH
216758 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
216795 assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
216796 assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
216800 assert( pCsr->pExpr );
216820 assert( p->p.base.zErrMsg==0 );
216950 assert( pTab->ts.eState==1 );
216952 assert( pVtab->zErrMsg==0 );
216953 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
216954 assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER
216957 assert( pTab->p.pConfig->pzErrmsg==0 );
216993 assert( eType0==SQLITE_INTEGER || eType0==SQLITE_NULL );
216994 assert( nArg!=1 || eType0==SQLITE_INTEGER );
217661 assert( pCsr->pAux==0 );
217685 assert( argc>=1 );
217798 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
218044 assert( nArg>0 );
218091 assert( nArg==1 );
218104 assert( nArg==0 );
218301 assert( p->pConfig->bColumnsize || (
218307 assert( eStmt>=0 && eStmt<ArraySize(p->aStmt) );
218758 assert( pConfig->eContent!=FTS5_CONTENT_NORMAL || apVal==0 );
219073 assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
219216 assert( eStmt==FTS5_STMT_SCAN_ASC
219222 assert( p->aStmt[eStmt]==*pp );
219238 assert( eStmt==FTS5_STMT_SCAN_ASC
219276 assert( p->pConfig->bColumnsize );
219652 assert( (bToken==0 || bToken==1) );
219653 assert( (bTokenChars==0 || bTokenChars==1) );
219774 assert( p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_NONE
220011 assert( strlen(p->zSuffix)==p->nSuffix );
220012 assert( strlen(p->zOutput)==p->nOutput );
220087 assert( bCons==0 || bCons==1 );
220096 assert( nStem>0 );
220598 assert( nBuf>0 );
220755 assert( key>=aDia[iRes] );
220878 assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 );
220888 assert( c>aEntry[0].iCode );
220900 assert( iRes>=0 && c>=aEntry[iRes].iCode );
220904 assert( ret>0 );
221416 assert( iTest>=iLo && iTest<iHi );
221524 assert( n>3 && n<=9 );
221570 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
221571 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
221758 assert( n<=9 );
221783 assert( iVal>=(1 << 7) );
221990 assert( eType>=0 && eType<ArraySize(azSchema) );
222132 assert( rc==SQLITE_OK || pStmt==0 );
222225 assert( sqlite3Fts5IterEof(pIter)==0 );
222226 assert( pCsr->bEof==0 );
222276 assert( nTerm>=0 );
222291 assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
222336 assert( eDetail==FTS5_DETAIL_NONE );
222342 assert( pTab->eType==FTS5_VOCAB_INSTANCE );
222366 assert( pCsr->iCol<pCsr->pFts5->pConfig->nCol );
222465 assert( iCol==1 || iCol==2 || iCol==3 );
222477 assert( iCol==1 || iCol==2 );
222484 assert( eType==FTS5_VOCAB_INSTANCE );
222503 assert( iCol==3 );
