Lines Matching refs:assert
524 # define ALWAYS(X) ((X)?1:(assert(0),0))
525 # define NEVER(X) ((X)?(assert(0),1):0)
13026 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusValue()
13036 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusAdd()
13048 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusSet()
13103 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); in sqlite3_db_status()
13104 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); in sqlite3_db_status()
14474 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
14558 assert( pFile ); in sqlite3OsCloseFree()
14612 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ); in vfsUnlink()
14649 assert(vfsList); in sqlite3_vfs_register()
14856 assert( nByte>0 ); in sqlite3MemMalloc()
14879 assert( pPrior!=0 ); in sqlite3MemFree()
14908 assert( pPrior!=0 && nByte>0 ); in sqlite3MemRealloc()
14909 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
15111 assert( mem.nCurrent[i]>=0 ); in adjustStats()
15129 assert( p->iForeGuard==(int)FOREGUARD ); in sqlite3MemsysGetHeader()
15133 assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); in sqlite3MemsysGetHeader()
15138 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); in sqlite3MemsysGetHeader()
15159 assert( (sizeof(struct MemBlockHdr)&7) == 0 ); in sqlite3MemInit()
15220 assert( mem.disallow==0 ); in sqlite3MemMalloc()
15245 assert(pBt[0]); in sqlite3MemMalloc()
15274 assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 in sqlite3MemFree()
15281 assert( pHdr->pPrev->pNext==pHdr ); in sqlite3MemFree()
15284 assert( mem.pFirst==pHdr ); in sqlite3MemFree()
15288 assert( pHdr->pNext->pPrev==pHdr ); in sqlite3MemFree()
15291 assert( mem.pLast==pHdr ); in sqlite3MemFree()
15315 assert( mem.disallow==0 ); in sqlite3MemRealloc()
15316 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
15354 assert( pHdr->iForeGuard==FOREGUARD ); in sqlite3MemdebugSetType()
15373 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugHasType()
15395 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugNoType()
15649 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3UnlinkFromList()
15668 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Unlink()
15669 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Unlink()
15670 assert( i>=1 ); in memsys3Unlink()
15672 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Unlink()
15673 assert( size>=2 ); in memsys3Unlink()
15687 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3LinkIntoList()
15702 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Link()
15703 assert( i>=1 ); in memsys3Link()
15704 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Link()
15706 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Link()
15707 assert( size>=2 ); in memsys3Link()
15737 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3OutOfMemory()
15753 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Checkout()
15754 assert( i>=1 ); in memsys3Checkout()
15755 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); in memsys3Checkout()
15756 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); in memsys3Checkout()
15770 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FromMaster()
15771 assert( mem3.szMaster>=nBlock ); in memsys3FromMaster()
15783 assert( newi > mem3.iMaster+1 ); in memsys3FromMaster()
15817 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Merge()
15821 assert( (size&1)==0 ); in memsys3Merge()
15824 assert( i > mem3.aPool[i-1].u.hdr.prevSize ); in memsys3Merge()
15858 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3MallocUnsafe()
15859 assert( sizeof(Mem3Block)==8 ); in memsys3MallocUnsafe()
15865 assert( nBlock>=2 ); in memsys3MallocUnsafe()
15939 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FreeUnsafe()
15940 assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); in memsys3FreeUnsafe()
15942 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); in memsys3FreeUnsafe()
15944 assert( i+size<=mem3.nPool+1 ); in memsys3FreeUnsafe()
15980 assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); in memsys3Size()
16000 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ in memsys3Malloc()
16011 assert( pPrior ); in memsys3Free()
16058 assert( sizeof(Mem3Block)==8 ); in memsys3Init()
16109 assert( 0 ); in sqlite3Memsys3Dump()
16114 assert( 0 ); in sqlite3Memsys3Dump()
16119 assert( 0 ); in sqlite3Memsys3Dump()
16337 assert( i>=0 && i<mem5.nBlock ); in memsys5Unlink()
16338 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Unlink()
16339 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Unlink()
16359 assert( sqlite3_mutex_held(mem5.mutex) ); in memsys5Link()
16360 assert( i>=0 && i<mem5.nBlock ); in memsys5Link()
16361 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Link()
16362 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Link()
16367 assert( x<mem5.nBlock ); in memsys5Link()
16394 assert( i>=0 && i<mem5.nBlock ); in memsys5Size()
16408 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5UnlinkFirst()
16410 assert( iFirst>=0 ); in memsys5UnlinkFirst()
16436 assert( nByte>0 ); in memsys5MallocUnsafe()
16501 assert( iBlock>=0 && iBlock<mem5.nBlock ); in memsys5FreeUnsafe()
16502 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 ); in memsys5FreeUnsafe()
16503 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 ); in memsys5FreeUnsafe()
16507 assert( iBlock+size-1<(u32)mem5.nBlock ); in memsys5FreeUnsafe()
16511 assert( mem5.currentCount>0 ); in memsys5FreeUnsafe()
16512 assert( mem5.currentOut>=(size*mem5.szAtom) ); in memsys5FreeUnsafe()
16515 assert( mem5.currentOut>0 || mem5.currentCount==0 ); in memsys5FreeUnsafe()
16516 assert( mem5.currentCount>0 || mem5.currentOut==0 ); in memsys5FreeUnsafe()
16526 assert( iBuddy>=0 ); in memsys5FreeUnsafe()
16564 assert( pPrior!=0 ); in memsys5Free()
16585 assert( pPrior!=0 ); in memsys5Realloc()
16586 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ in memsys5Realloc()
16587 assert( nBytes>=0 ); in memsys5Realloc()
16658 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 ); in memsys5Init()
16662 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */ in memsys5Init()
16687 assert((iOffset+nAlloc)>mem5.nBlock); in memsys5Init()
16864 assert( GLOBAL(int, mutexIsInit) ); in sqlite3MutexAlloc()
17049 assert( id-2 >= 0 ); in debugMutexAlloc()
17050 assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) ); in debugMutexAlloc()
17064 assert( p->cnt==0 ); in debugMutexFree()
17065 assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); in debugMutexFree()
17082 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexEnter()
17087 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexTry()
17100 assert( debugMutexHeld(pX) ); in debugMutexLeave()
17102 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexLeave()
17280 assert( iType-2 >= 0 ); in os2MutexAlloc()
17281 assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) ); in os2MutexAlloc()
17301 assert( ulCount==0 ); in os2MutexFree()
17302 assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); in os2MutexFree()
17356 assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) ); in os2MutexEnter()
17364 assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) ); in os2MutexTry()
17381 assert( os2MutexHeld(p) ); in os2MutexLeave()
17582 assert( iType-2 >= 0 ); in pthreadMutexAlloc()
17583 assert( iType-2 < ArraySize(staticMutexes) ); in pthreadMutexAlloc()
17601 assert( p->nRef==0 ); in pthreadMutexFree()
17602 assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexFree()
17619 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexEnter()
17638 assert( p->nRef==0 ); in pthreadMutexEnter()
17648 assert( p->nRef>0 || p->owner==0 ); in pthreadMutexEnter()
17662 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexTry()
17681 assert( p->nRef==0 ); in pthreadMutexTry()
17718 assert( pthreadMutexHeld(p) ); in pthreadMutexLeave()
17723 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexLeave()
17965 assert( winMutex_isInit==1 ); in winMutexAlloc()
17966 assert( iType-2 >= 0 ); in winMutexAlloc()
17967 assert( iType-2 < ArraySize(winMutex_staticMutexes) ); in winMutexAlloc()
17985 assert( p ); in winMutexFree()
17986 assert( p->nRef==0 && p->owner==0 ); in winMutexFree()
17987 assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); in winMutexFree()
18006 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); in winMutexEnter()
18010 assert( p->nRef>0 || p->owner==0 ); in winMutexEnter()
18023 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); in winMutexTry()
18061 assert( p->nRef>0 ); in winMutexLeave()
18062 assert( p->owner==tid ); in winMutexLeave()
18065 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in winMutexLeave()
18361 assert( sqlite3_mutex_held(mem0.mutex) ); in mallocWithAlarm()
18411 assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-04675-44850 */ in sqlite3Malloc()
18448 assert( n>0 ); in sqlite3ScratchMalloc()
18470 assert( sqlite3_mutex_notheld(mem0.mutex) ); in sqlite3ScratchMalloc()
18478 assert( scratchAllocOut<=1 ); in sqlite3ScratchMalloc()
18492 assert( scratchAllocOut>=1 && scratchAllocOut<=2 ); in sqlite3ScratchFree()
18504 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch ); in sqlite3ScratchFree()
18509 assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) ); in sqlite3ScratchFree()
18510 assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) ); in sqlite3ScratchFree()
18543 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); in sqlite3MallocSize()
18544 assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) ); in sqlite3MallocSize()
18548 assert( db==0 || sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocSize()
18552 assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) ); in sqlite3DbMallocSize()
18553 assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) ); in sqlite3DbMallocSize()
18554 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); in sqlite3DbMallocSize()
18564 assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) ); in sqlite3_free()
18565 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); in sqlite3_free()
18582 assert( db==0 || sqlite3_mutex_held(db->mutex) ); in sqlite3DbFree()
18596 assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) ); in sqlite3DbFree()
18597 assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) ); in sqlite3DbFree()
18598 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); in sqlite3DbFree()
18635 assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) ); in sqlite3Realloc()
18636 assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) ); in sqlite3Realloc()
18650 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */ in sqlite3Realloc()
18709 assert( db==0 || sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocRaw()
18710 assert( db==0 || db->pnBytesFreed==0 ); in sqlite3DbMallocRaw()
18753 assert( db!=0 ); in sqlite3DbRealloc()
18754 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbRealloc()
18769 assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) ); in sqlite3DbRealloc()
18770 assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) ); in sqlite3DbRealloc()
18811 assert( (n&0x7fffffff)==n ); in sqlite3DbStrDup()
18823 assert( (n&0x7fffffff)==n ); in sqlite3DbStrNDup()
18867 assert( !db || sqlite3_mutex_held(db->mutex) ); in sqlite3ApiExit()
19437 assert( precision>0 ); in sqlite3VXPrintf()
19447 assert( bufpt>buf ); in sqlite3VXPrintf()
19579 assert( k>=0 && k<pSrc->nSrc ); in sqlite3VXPrintf()
19589 assert( xtype==etINVALID ); in sqlite3VXPrintf()
19625 assert( z!=0 || N==0 ); in sqlite3StrAccumAppend()
19735 assert( db!=0 ); in sqlite3VMPrintf()
20265 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); in sqlite3VdbeMemTranslate()
20266 assert( pMem->flags&MEM_Str ); in sqlite3VdbeMemTranslate()
20267 assert( pMem->enc!=desiredEnc ); in sqlite3VdbeMemTranslate()
20268 assert( pMem->enc!=0 ); in sqlite3VdbeMemTranslate()
20269 assert( pMem->n>=0 ); in sqlite3VdbeMemTranslate()
20288 assert( rc==SQLITE_NOMEM ); in sqlite3VdbeMemTranslate()
20344 assert( desiredEnc==SQLITE_UTF16BE ); in sqlite3VdbeMemTranslate()
20355 assert( desiredEnc==SQLITE_UTF8 ); in sqlite3VdbeMemTranslate()
20372 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); in sqlite3VdbeMemTranslate()
20405 assert( pMem->n>=0 ); in sqlite3VdbeMemHandleBom()
20448 assert( z<=zTerm ); in sqlite3Utf8CharLen()
20503 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); in sqlite3Utf16to8()
20504 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); in sqlite3Utf16to8()
20505 assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed ); in sqlite3Utf16to8()
20506 assert( m.z || db->mallocFailed ); in sqlite3Utf16to8()
20527 assert( db->mallocFailed ); in sqlite3Utf8to16()
20530 assert( m.z==m.zMalloc ); in sqlite3Utf8to16()
20577 assert( n>0 && n<=4 ); in sqlite3UtfSelfTest()
20584 assert( c==t ); in sqlite3UtfSelfTest()
20585 assert( (z-zBuf)==n ); in sqlite3UtfSelfTest()
20592 assert( n>0 && n<=4 ); in sqlite3UtfSelfTest()
20596 assert( c==i ); in sqlite3UtfSelfTest()
20597 assert( (z-zBuf)==n ); in sqlite3UtfSelfTest()
20604 assert( n>0 && n<=4 ); in sqlite3UtfSelfTest()
20608 assert( c==i ); in sqlite3UtfSelfTest()
20609 assert( (z-zBuf)==n ); in sqlite3UtfSelfTest()
21114 assert( u<=LARGEST_INT64 ); in sqlite3Atoi64()
21121 assert( u<=LARGEST_INT64 ); in sqlite3Atoi64()
21129 assert( u-1==LARGEST_INT64 ); in sqlite3Atoi64()
21130 assert( (*pNum)==SMALLEST_INT64 ); in sqlite3Atoi64()
21236 assert( n<=9 ); in sqlite3PutVarint()
21307 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); in sqlite3GetVarint()
21308 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); in sqlite3GetVarint()
21513 assert( n>3 && n<=9 ); in sqlite3GetVarint32()
21565 assert( n>5 && n<=9 ); in sqlite3GetVarint32()
21607 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); in sqlite3HexToInt()
21742 assert( iA1*iB0==0 || iA0*iB1==0 ); in sqlite3MulInt64()
21821 assert( pNew!=0 ); in sqlite3HashInit()
21835 assert( pH!=0 ); in sqlite3HashClear()
21854 assert( nKey>=0 ); in strHash()
21985 assert( pEntry->count>=0 ); in removeElementGivenHash()
21990 assert( pH->first==0 ); in removeElementGivenHash()
21991 assert( pH->count==0 ); in removeElementGivenHash()
22004 assert( pH!=0 ); in sqlite3HashFind()
22005 assert( pKey!=0 ); in sqlite3HashFind()
22006 assert( nKey>=0 ); in sqlite3HashFind()
22035 assert( pH!=0 ); in sqlite3HashInsert()
22036 assert( pKey!=0 ); in sqlite3HashInsert()
22037 assert( nKey>=0 ); in sqlite3HashInsert()
22051 assert(nKey==elem->nKey); in sqlite3HashInsert()
22064 assert( pH->htsize>0 ); in sqlite3HashInsert()
22545 assert( id!=0 );
22577 assert( id!=0 );
22609 assert( id!=0 );
22616 assert( amt>0 );
22634 assert( id!=0 );
22690 assert( id!=0 );
22773 assert( pFile!=0 );
22787 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
22788 assert( locktype!=PENDING_LOCK );
22789 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
22815 assert( pFile->locktype==NO_LOCK );
22826 assert( pFile->locktype==SHARED_LOCK );
22850 assert( pFile->locktype>=SHARED_LOCK );
22903 assert( pFile!=0 );
22955 assert( pFile!=0 );
22956 assert( locktype<=SHARED_LOCK );
23287 assert( sqlite3_mutex_held(pNode->mutex) || pNode->nRef==0 );
23536 assert( szRegion==pNode->szRegion );
23622 assert(*ppLink);
23665 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
23666 assert( n>=1 );
23667 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
23671 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
23674 assert( n>1 || mask==(1<<ofst) );
23685 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
23746 assert( (p->sharedMask & mask)==0 );
23937 assert( id!=0 );
23946 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
23947 assert(isCreate==0 || isReadWrite);
23948 assert(isExclusive==0 || isCreate);
23949 assert(isDelete==0 || isCreate);
23953 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
23954 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
23955 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
23956 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
23959 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
23972 assert(isDelete && !isOpenJournal);
24108 assert( !"Invalid flags argument" );
24327 assert(zBuf[0]=='\0');
25158 assert( 0 );
25160 assert( p->l_whence==SEEK_SET );
25177 assert( 0 );
25370 assert( zAbsoluteName[0]=='/' );
25409 assert( pId->nRef>0 );
25414 assert( *pp==pId );
25622 assert( errcode!=SQLITE_OK );
25675 assert( unixMutexHeld() );
25679 assert( pInode->pShmNode==0 );
25682 assert( pInode->pPrev->pNext==pInode );
25685 assert( inodeList==pInode );
25689 assert( pInode->pNext->pPrev==pInode );
25717 assert( unixMutexHeld() );
25801 assert( pFile );
25856 assert( unixMutexHeld() );
25857 assert( pInode!=0 );
25863 assert( pInode->nLock==0 );
25950 assert( pFile );
25970 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
25971 assert( eFileLock!=PENDING_LOCK );
25972 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
25995 assert( eFileLock==SHARED_LOCK );
25996 assert( pFile->eFileLock==0 );
25997 assert( pInode->nShared>0 );
26031 assert( pInode->nShared==0 );
26032 assert( pInode->eFileLock==0 );
26033 assert( rc==SQLITE_OK );
26072 assert( 0!=pFile->eFileLock );
26075 assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
26159 assert( pFile );
26164 assert( eFileLock<=SHARED_LOCK );
26171 assert( pInode->nShared!=0 );
26173 assert( pInode->eFileLock==pFile->eFileLock );
26188 assert( pFile->inNormalWrite==0
26208 assert( handleNFSUnlock==0 );
26274 lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
26311 assert( pInode->nLock>=0 );
26378 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
26482 assert( pFile );
26582 assert( pFile );
26585 assert( eFileLock<=SHARED_LOCK );
26601 assert( eFileLock==NO_LOCK );
26677 assert( pFile );
26756 assert( pFile );
26799 assert( pFile );
26802 assert( eFileLock<=SHARED_LOCK );
26867 assert( pFile );
26966 assert( pFile );
26967 assert( pSem );
26970 assert( eFileLock<=SHARED_LOCK );
27003 assert( pFile );
27112 assert( pFile );
27180 assert( pFile );
27200 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
27201 assert( eFileLock!=PENDING_LOCK );
27202 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
27225 assert( eFileLock==SHARED_LOCK );
27226 assert( pFile->eFileLock==0 );
27227 assert( pInode->nShared>0 );
27256 assert( pInode->nShared==0 );
27257 assert( pInode->eFileLock==0 );
27296 assert( 0!=pFile->eFileLock );
27366 assert( pFile );
27371 assert( eFileLock<=SHARED_LOCK );
27377 assert( pInode->nShared!=0 );
27379 assert( pInode->eFileLock==pFile->eFileLock );
27393 assert( pFile->inNormalWrite==0
27444 assert( pInode->nLock>=0 );
27584 assert( id );
27589 assert( pFile->pUnused==0
27663 assert( id );
27664 assert( amt>0 );
27669 assert( pFile->pUnused==0
27908 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
27917 assert( pFile );
27952 assert( pFile );
27992 assert( id );
28250 assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
28253 assert( n==1 || lockType!=F_RDLCK );
28256 assert( n>=1 && n<SQLITE_SHM_NLOCK );
28285 assert( lockType==F_WRLCK );
28296 assert( lockType==F_WRLCK );
28317 assert( unixMutexHeld() );
28320 assert( p->pInode==pFd->pInode );
28386 assert( pDbFd->pShm==0 );
28539 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
28540 assert( pShmNode->pInode==pDbFd->pInode );
28541 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
28542 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
28642 assert( pShmNode==pDbFd->pInode->pShmNode );
28643 assert( pShmNode->pInode==pDbFd->pInode );
28644 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
28645 assert( n>=1 );
28646 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
28650 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
28651 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
28652 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
28655 assert( n>1 || mask==(1<<ofst) );
28663 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
28724 assert( (p->sharedMask & mask)==0 );
28770 assert( pShmNode==pDbFd->pInode->pShmNode );
28771 assert( pShmNode->pInode==pDbFd->pInode );
28787 assert( pShmNode->nRef>0 );
29114 assert( pNew->pInode==NULL );
29126 assert( zFilename==0 || zFilename[0]=='/'
29129 assert( zFilename==0 || zFilename[0]=='/' );
29558 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
29559 assert(isCreate==0 || isReadWrite);
29560 assert(isExclusive==0 || isCreate);
29561 assert(isDelete==0 || isCreate);
29565 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
29566 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
29567 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
29568 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
29571 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
29593 assert(isDelete && !syncDir);
29615 assert( !p->pUnused );
29616 assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
29635 assert( fd>=0 );
29801 assert(!"Invalid flags argument");
29837 assert( pVfs->mxPathname==MAX_PATHNAME );
29922 assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
29947 assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
30284 assert(lockPath!=NULL);
30415 assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
30546 assert( nTries>1 );
30572 assert( nTries==3 );
30873 assert( (int)strlen(conchPath) == len+7 );
30923 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
30934 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
31085 assert( 0 ); /* The call assures that only valid opcodes are sent */
31330 assert( ArraySize(aSyscall)==18 );
31735 #define winMemAssertMagic() assert( win_mem_data.magic==WINMEM_MAGIC )
31814 assert( hHeap!=0 );
31815 assert( hHeap!=INVALID_HANDLE_VALUE );
31817 assert ( HeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
31819 assert( nBytes>=0 );
31836 assert( hHeap!=0 );
31837 assert( hHeap!=INVALID_HANDLE_VALUE );
31839 assert ( HeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
31857 assert( hHeap!=0 );
31858 assert( hHeap!=INVALID_HANDLE_VALUE );
31860 assert ( HeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
31862 assert( nBytes>=0 );
31885 assert( hHeap!=0 );
31886 assert( hHeap!=INVALID_HANDLE_VALUE );
31888 assert ( HeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
31914 assert( pWinMemData->magic==WINMEM_MAGIC );
31928 assert( pWinMemData->hHeap!=0 );
31929 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
31931 assert( HeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
31944 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
31946 assert( HeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
32206 assert( errcode!=SQLITE_OK );
32519 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
32527 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE || nNumberOfBytesToUnlockLow == 1);
32643 assert( id!=0 );
32644 assert( pFile->pShm==0 );
32686 assert( id!=0 );
32722 assert( amt>0 );
32723 assert( pFile );
32769 assert( pFile );
32825 assert( pFile );
32827 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
32873 assert( id!=0 );
32979 assert( id!=0 );
32993 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
32994 assert( locktype!=PENDING_LOCK );
32995 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
33023 assert( pFile->locktype==NO_LOCK );
33035 assert( pFile->locktype==SHARED_LOCK );
33054 assert( pFile->locktype>=SHARED_LOCK );
33100 assert( id!=0 );
33131 assert( pFile!=0 );
33132 assert( locktype<=SHARED_LOCK );
33232 assert( id!=0 );
33377 assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
33423 assert( winShmMutexHeld() );
33472 assert( pDbFd->pShm==0 ); /* Not previously opened */
33606 assert( pShmNode->nRef>0 );
33632 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
33633 assert( n>=1 );
33634 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
33638 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
33641 assert( n>1 || mask==(1<<ofst) );
33649 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
33710 assert( (p->sharedMask & mask)==0 );
33776 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
34060 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
34061 assert(isCreate==0 || isReadWrite);
34062 assert(isExclusive==0 || isCreate);
34063 assert(isDelete==0 || isCreate);
34067 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
34068 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
34069 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
34070 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
34073 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
34079 assert( id!=0 );
34088 assert(isDelete && !isOpenJournal);
34345 assert(!"Invalid flags argument");
34753 assert(winSysInfo.dwAllocationGranularity > 0);
34881 assert( sizeof(*p)==BITVEC_SZ );
34933 assert( i>0 );
34934 assert( i<=p->iSize );
35003 assert( i>0 );
35215 # define expensive_assert(X) assert(X)
35233 assert( p->nRef || (p->flags&PGHDR_NEED_SYNC) );
35245 assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
35246 assert( pPage->pDirtyPrev || pPage==p->pDirty );
35260 assert( pPage==p->pDirtyTail );
35266 assert( pPage==p->pDirty );
35282 assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
35286 assert( pPage->pDirtyNext->pDirtyPrev==0 );
35367 assert( pCache->nRef==0 && pCache->pDirty==0 );
35388 assert( pCache!=0 );
35389 assert( createFlag==1 || createFlag==0 );
35390 assert( pgno>0 );
35456 assert( pPage->pCache==pCache );
35457 assert( pPage->pgno==pgno );
35458 assert( pPage->pData==(void *)&pPage[1] );
35459 assert( pPage->pExtra==(void *)&((char *)&pPage[1])[pCache->szPage] );
35478 assert( p->nRef>0 );
35497 assert(p->nRef>0);
35508 assert( p->nRef==1 );
35526 assert( p->nRef>0 );
35573 assert( p->nRef>0 );
35574 assert( newPgno>0 );
35602 assert( p->pgno>0 );
35604 assert( p->flags&PGHDR_DIRTY );
36053 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
36062 assert( pcache1.nFreeSlot>=0 );
36097 assert( pcache1.nFreeSlot<=pcache1.nSlot );
36101 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
36120 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
36141 assert( pList->pLast==0 );
36151 assert( sqlite3_mutex_held(pGroup->mutex) );
36183 assert( pGroup->isBusy==0 );
36184 assert( sqlite3_mutex_held(pGroup->mutex) );
36194 assert( pList->nByte!=nByte );
36211 assert( sqlite3_mutex_held(pGroup->mutex) );
36242 assert( pPg );
36247 assert( pList->pFirst==pBlock );
36248 assert( pBlock->pPrev==0 );
36249 assert( pList->pLast->pNext==0 );
36265 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
36298 assert( pPg==(void *)&pBlock->aData[i*pList->nByte] );
36299 assert( pBlock->mUsed & ((Bitmask)1<<i) );
36331 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
36395 assert( sqlite3_mutex_held(p->pGroup->mutex) );
36443 assert( sqlite3_mutex_held(pGroup->mutex) );
36475 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
36488 assert( sqlite3_mutex_held(pGroup->mutex) );
36491 assert( p->pCache->pGroup==pGroup );
36511 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
36527 assert( pCache->nPage==nPage );
36538 assert( pcache1.isInit==0 );
36556 assert( pcache1.isInit!=0 );
36703 assert( pCache->bPurgeable || createFlag!=1 );
36704 assert( pCache->bPurgeable || pCache->nMin==0 );
36705 assert( pCache->bPurgeable==0 || pCache->nMin==10 );
36706 assert( pCache->nMin==0 || pCache->bPurgeable );
36735 assert( nPinned>=0 );
36736 assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
36737 assert( pCache->n90pct == pCache->nMax*9/10 );
36809 assert( pPage->pCache==pCache );
36815 assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
36816 assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
36850 assert( pPage->iKey==iOld );
36851 assert( pPage->pCache==pCache );
36898 assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
36947 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
36948 assert( sqlite3_mutex_notheld(pcache1.mutex) );
37115 assert( N >= ROUND8(sizeof(*p)) );
37157 assert( p!=0 );
37180 assert( p->pEntry==0 ); /* Fires if INSERT after SMALLEST */
37201 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
37202 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
37216 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
37219 assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v );
37233 assert( p->isSorted==0 );
37265 assert( pIn!=0 );
37278 assert( (*ppLast)->pRight==0 );
37330 assert( pList!=0 );
38343 assert( p->eState==PAGER_OPEN
38356 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
38357 assert( p->tempFile==0 || pPager->changeCountDone );
38362 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
38363 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
38374 assert( p->noSync );
38375 assert( p->journalMode==PAGER_JOURNALMODE_OFF
38378 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
38379 assert( pagerUseWal(p)==0 );
38385 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
38386 assert( p->eLock!=PENDING_LOCK );
38390 assert( !MEMDB );
38391 assert( pPager->errCode==SQLITE_OK );
38392 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
38396 assert( pPager->errCode==SQLITE_OK );
38397 assert( p->eLock!=UNKNOWN_LOCK );
38398 assert( p->eLock>=SHARED_LOCK || p->noReadlock );
38402 assert( p->eLock!=UNKNOWN_LOCK );
38403 assert( pPager->errCode==SQLITE_OK );
38405 assert( p->eLock>=RESERVED_LOCK );
38407 assert( pPager->dbSize==pPager->dbOrigSize );
38408 assert( pPager->dbOrigSize==pPager->dbFileSize );
38409 assert( pPager->dbOrigSize==pPager->dbHintSize );
38410 assert( pPager->setMaster==0 );
38414 assert( p->eLock!=UNKNOWN_LOCK );
38415 assert( pPager->errCode==SQLITE_OK );
38422 assert( p->eLock>=RESERVED_LOCK );
38423 assert( isOpen(p->jfd)
38428 assert( pPager->dbOrigSize==pPager->dbFileSize );
38429 assert( pPager->dbOrigSize==pPager->dbHintSize );
38433 assert( p->eLock==EXCLUSIVE_LOCK );
38434 assert( pPager->errCode==SQLITE_OK );
38435 assert( !pagerUseWal(pPager) );
38436 assert( p->eLock>=EXCLUSIVE_LOCK );
38437 assert( isOpen(p->jfd)
38441 assert( pPager->dbOrigSize<=pPager->dbHintSize );
38445 assert( p->eLock==EXCLUSIVE_LOCK );
38446 assert( pPager->errCode==SQLITE_OK );
38447 assert( !pagerUseWal(pPager) );
38448 assert( isOpen(p->jfd)
38459 assert( pPager->errCode!=SQLITE_OK );
38460 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
38592 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
38593 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
38594 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
38596 assert( pPager->eLock>=eLock );
38619 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
38649 assert( !MEMDB );
38655 assert( isOpen(pPager->fd) );
38660 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
38661 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
38703 assert( pPager->eState!=PAGER_ERROR );
38704 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
38798 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
38799 assert( offset>=c );
38800 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
38827 assert( isOpen(pPager->jfd) );
38881 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
38919 assert( isOpen(pPager->fd) || pPager->noSync );
38968 assert( pPager->journalHdr <= pPager->journalOff );
39003 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
39124 assert( pPager->setMaster==0 );
39125 assert( !pagerUseWal(pPager) );
39134 assert( isOpen(pPager->jfd) );
39135 assert( pPager->journalHdr <= pPager->journalOff );
39238 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
39263 assert( pPager->eState==PAGER_READER
39273 assert( !isOpen(pPager->jfd) );
39285 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
39286 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
39287 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
39288 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
39289 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
39290 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
39311 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
39322 assert( !MEMDB );
39355 assert( rc==SQLITE_OK || !MEMDB );
39356 assert(
39438 assert( assert_pager_state(pPager) );
39439 assert( pPager->eState!=PAGER_ERROR );
39445 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
39447 assert( !pagerUseWal(pPager) );
39451 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
39471 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
39505 assert( rc2==SQLITE_OK );
39538 assert( assert_pager_state(pPager) );
39544 assert( pPager->eState==PAGER_READER );
39647 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
39648 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
39649 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
39650 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
39653 assert( aData ); /* Temp storage must have already been allocated */
39654 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
39662 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
39665 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
39683 assert( !isSavepnt );
39751 assert( pPg || !MEMDB );
39752 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
39768 assert( !pagerUseWal(pPager) );
39795 assert( isSavepnt );
39796 assert( pPager->doNotSpill==0 );
39799 assert( pPager->doNotSpill==1 );
39836 assert( !pagerUseWal(pPager) );
39980 assert( !isOpen(pJournal) );
40009 assert( pPager->eState!=PAGER_ERROR );
40010 assert( pPager->eState!=PAGER_READER );
40017 assert( pPager->eLock==EXCLUSIVE_LOCK );
40055 assert( isOpen(pPager->fd) || pPager->tempFile );
40068 assert( MAX_SECTOR_SIZE>=512 );
40144 assert( isOpen(pPager->jfd) );
40197 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
40265 assert( 0 );
40273 assert(
40338 assert( pPager->eState>=PAGER_READER && !MEMDB );
40339 assert( isOpen(pPager->fd) );
40342 assert( pPager->tempFile );
40503 assert( pPager->pWal );
40507 assert( p->pgno < p->pDirty->pgno );
40521 assert( pList );
40557 assert( pagerUseWal(pPager) );
40558 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
40594 assert( pPager->eState==PAGER_OPEN );
40595 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
40606 assert( isOpen(pPager->fd) || pPager->tempFile );
40652 assert( pPager->eState==PAGER_OPEN );
40653 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
40724 assert( pPager->eState!=PAGER_ERROR );
40725 assert( pPager->eState>=PAGER_WRITER_LOCKED );
40751 assert( pagerUseWal(pPager)==0 || szJ==0 );
40766 assert( rc!=SQLITE_DONE );
40781 assert( rc!=SQLITE_DONE );
40796 assert( rc!=SQLITE_DONE );
40798 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
40812 assert( offset==ii*(4+pPager->pageSize) );
40815 assert( rc!=SQLITE_DONE );
40883 assert( level>=1 && level<=3 );
40940 assert( rc!=SQLITE_OK || isOpen(pFile) );
41018 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
41047 assert( nReserve>=0 && nReserve<1000 );
41077 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
41078 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
41123 assert( isOpen(pPager->fd) || pPager->tempFile );
41129 assert( !pagerUseWal(pPager) );
41149 assert( pPager->eState>=PAGER_READER );
41150 assert( pPager->eState!=PAGER_WRITER_FINISHED );
41177 assert( (pPager->eLock>=locktype)
41212 assert( pPg->flags&PGHDR_DIRTY );
41213 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
41229 assert( pPager->dbSize>=nPage );
41230 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
41278 assert( assert_pager_state(pPager) );
41320 assert( !pPager->aSavepoint && !pPager->pInJournal );
41321 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
41381 assert( pPager->eState==PAGER_WRITER_CACHEMOD
41384 assert( assert_pager_state(pPager) );
41385 assert( !pagerUseWal(pPager) );
41391 assert( !pPager->tempFile );
41394 assert( isOpen(pPager->jfd) );
41485 assert( assert_pager_state(pPager) );
41525 assert( !pagerUseWal(pPager) );
41526 assert( pPager->eState==PAGER_WRITER_DBMOD );
41527 assert( pPager->eLock==EXCLUSIVE_LOCK );
41534 assert( pPager->tempFile && rc==SQLITE_OK );
41541 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
41563 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
41640 assert( pPager->useJournal );
41641 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
41642 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
41643 assert( pagerUseWal(pPager)
41666 assert( pPager->nSavepoint>0 );
41695 assert( pPg->pPager==pPager );
41696 assert( pPg->flags&PGHDR_DIRTY );
41772 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
41924 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
41935 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
41939 assert( nPathname>0 );
41962 assert( !memDb );
41975 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
41987 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
41988 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
41989 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
42017 assert( pPager->memDb==0 );
42026 assert( !pPager->pTmpSpace );
42033 assert( nExtra<1000 );
42052 assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
42056 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
42058 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
42063 assert( useJournal || pPager->tempFile );
42073 assert( isOpen(pPager->fd) || tempFile );
42128 assert( pPager->useJournal );
42129 assert( isOpen(pPager->fd) );
42130 assert( pPager->eState==PAGER_OPEN );
42132 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
42247 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
42248 assert( assert_pager_state(pPager) );
42249 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
42255 assert( !MEMDB );
42256 assert( pPager->noReadlock==0 || pPager->readOnly );
42261 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
42317 assert( !pPager->tempFile );
42319 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
42336 assert( rc==SQLITE_OK );
42367 assert( pPager->eState==PAGER_OPEN );
42368 assert( (pPager->eLock==SHARED_LOCK)
42418 assert( pPager->pWal==0 || rc==SQLITE_OK );
42423 assert( rc==SQLITE_OK );
42433 assert( !MEMDB );
42435 assert( pPager->eState==PAGER_OPEN );
42515 assert( pPager->eState>=PAGER_READER );
42516 assert( assert_pager_state(pPager) );
42537 assert( (*ppPage)->pgno==pgno );
42538 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
42543 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
42586 assert( pPg->pPager==pPager );
42598 assert( rc!=SQLITE_OK );
42621 assert( pPager!=0 );
42622 assert( pgno!=0 );
42623 assert( pPager->pPCache!=0 );
42624 assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
42671 assert( pPager->eState==PAGER_WRITER_LOCKED );
42672 assert( assert_pager_state(pPager) );
42673 assert( pPager->pInJournal==0 );
42705 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
42726 assert( pPager->eState==PAGER_WRITER_LOCKED );
42754 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
42758 assert( pPager->pInJournal==0 );
42807 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
42808 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
42809 assert( assert_pager_state(pPager) );
42832 assert( pPager->eState==PAGER_WRITER_LOCKED
42836 assert( assert_pager_state(pPager) );
42861 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
42862 assert( assert_pager_state(pPager) );
42869 assert( !pagerUseWal(pPager) );
42877 assert( pagerUseWal(pPager)==0 );
42886 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
42888 assert( pPager->journalHdr<=pPager->journalOff );
42917 assert( pPager->pInJournal!=0 );
42920 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
42923 assert( rc==SQLITE_NOMEM );
42975 assert( pPager->eState>=PAGER_WRITER_LOCKED );
42976 assert( pPager->eState!=PAGER_ERROR );
42977 assert( assert_pager_state(pPager) );
42990 assert( !MEMDB );
42991 assert( pPager->doNotSyncSpill==0 );
43008 assert(nPage>0);
43009 assert(pg1<=pPg->pgno);
43010 assert((pg1+nPage)>pPg->pgno);
43041 assert( !MEMDB );
43051 assert( pPager->doNotSyncSpill==1 );
43119 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43122 assert( assert_pager_state(pPager) );
43136 assert( isDirectMode==0 );
43145 assert( !pPager->tempFile && isOpen(pPager->fd) );
43149 assert( pPgHdr==0 || rc==SQLITE_OK );
43167 assert( pPager->dbFileSize>0 );
43196 assert( !MEMDB );
43199 assert( !MEMDB );
43218 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43222 assert( assert_pager_state(pPager) );
43262 assert( pPager->eState==PAGER_WRITER_LOCKED
43267 assert( assert_pager_state(pPager) );
43295 assert( rc==SQLITE_OK );
43331 assert( isOpen(pPager->jfd)
43413 assert( rc!=SQLITE_IOERR_BLOCKED );
43423 assert( pPager->eState==PAGER_WRITER_DBMOD );
43467 assert( pPager->eState==PAGER_WRITER_LOCKED
43471 assert( assert_pager_state(pPager) );
43488 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
43532 assert( assert_pager_state(pPager) );
43557 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
43558 assert( rc==SQLITE_OK || rc==SQLITE_FULL || (rc&0xFF)==SQLITE_IOERR );
43642 assert( pPager->eState>=PAGER_WRITER_LOCKED );
43643 assert( assert_pager_state(pPager) );
43680 assert( pPager->nSavepoint==nSavepoint );
43720 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
43721 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
43744 assert( rc==SQLITE_OK );
43757 assert(rc!=SQLITE_DONE);
43857 assert( pPg->nRef>0 );
43858 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43861 assert( assert_pager_state(pPager) );
43909 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
43910 assert( pPg->flags&PGHDR_DIRTY );
43920 assert( !pPgOld || pPgOld->nRef==1 );
43941 assert( pPgOld );
43965 assert( pPager->pTmpSpace!=0 );
43983 assert( pPg->nRef>0 || pPg->pPager->memDb );
44006 assert( eMode==PAGER_LOCKINGMODE_QUERY
44009 assert( PAGER_LOCKINGMODE_QUERY<0 );
44010 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
44011 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
44049 assert( eMode==PAGER_JOURNALMODE_DELETE
44060 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
44066 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
44075 assert( pPager->eState!=PAGER_ERROR );
44082 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
44083 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
44084 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
44085 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
44086 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
44087 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
44089 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
44106 assert( state==PAGER_OPEN || state==PAGER_READER );
44111 assert( rc==SQLITE_OK );
44122 assert( state==pPager->eState );
44144 assert( assert_pager_state(pPager) );
44214 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
44234 assert( pPager->pWal==0 && pPager->tempFile==0 );
44235 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK || pPager->noReadlock);
44281 assert( assert_pager_state(pPager) );
44282 assert( pPager->eState==PAGER_OPEN || pbOpen );
44283 assert( pPager->eState==PAGER_READER || !pbOpen );
44284 assert( pbOpen==0 || *pbOpen==0 );
44285 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
44317 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
44916 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
44924 assert( pWal->nWiData>0 && pWal->apWiData[0] );
44932 assert( pWal->nWiData>0 && pWal->apWiData[0] );
44975 assert( nByte>=8 );
44976 assert( (nByte&0x00000007)==0 );
45010 assert( pWal->writeLock );
45041 assert( WAL_FRAME_HDRSIZE==24 );
45069 assert( WAL_FRAME_HDRSIZE==24 );
45178 assert( iPage>0 );
45179 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
45211 assert( rc==SQLITE_OK || iHash>0 );
45240 assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
45280 assert( pWal->writeLock );
45291 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
45292 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
45299 assert( iLimit>0 );
45323 assert( aHash[iKey]==i );
45351 assert( idx <= HASHTABLE_NSLOT/2 + 1 );
45369 assert( !aPgno[idx] );
45388 assert( nEntry==idx );
45402 assert( aHash[iKey]==i );
45436 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
45437 assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
45438 assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
45439 assert( pWal->writeLock );
45625 assert( zWalName && zWalName[0] );
45626 assert( pDbFd );
45633 assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
45636 assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
45700 assert( iMin<0xffffffff );
45757 assert( nLeft>0 && nRight>0 );
45774 assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
45775 assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );
45819 assert( nList<=HASHTABLE_NPAGE && nList>0 );
45820 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
45827 assert( p->aList && p->nList<=(1<<iSub) );
45828 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
45838 assert( p->nList<=(1<<iSub) );
45839 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
45843 assert( aMerge==aList );
45850 assert( aContent[aList[i]] > aContent[aList[i-1]] );
45887 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
46040 assert( pIter );
46054 assert( y<=pWal->hdr.mxFrame );
46093 assert( walFramePgno(pWal, iFrame)==iDbpage );
46136 assert( pWal->writeLock );
46140 assert( mxSafeFrame==pWal->hdr.mxFrame );
46224 assert( pWal->nWiData>0 && pWal->apWiData[0] );
46284 assert( pChanged );
46289 assert( page0 || pWal->writeLock==0 );
46301 assert( badHdr==0 || pWal->writeLock==0 );
46400 assert( pWal->readLock<0 ); /* Not currently locked */
46503 assert( thisMark!=READMARK_NOT_USED );
46526 assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
46561 assert( mxReadMark<=pWal->hdr.mxFrame );
46628 assert( pWal->readLock>=0 || pWal->lockError );
46682 assert( iFrame>iRead );
46704 assert( iRead==iRead2 );
46758 assert( pWal->readLock>=0 );
46836 assert( walFramePgno(pWal, iFrame)!=1 );
46841 assert( rc==SQLITE_OK );
46852 assert( pWal->writeLock );
46868 assert( pWal->writeLock );
46869 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
46908 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
46951 assert( pInfo->aReadMark[0]==0 );
46964 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
46991 assert( pList );
46992 assert( pWal->writeLock );
47038 assert( (int)pWal->szPage==szPage );
47075 assert( isCommit );
47076 assert( iSegment>0 );
47166 assert( pWal->ckptLock==0 );
47167 assert( pWal->writeLock==0 );
47277 assert( pWal->writeLock==0 );
47278 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
47286 assert( pWal->readLock>=0 || pWal->lockError );
47287 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
47301 assert( pWal->exclusiveMode==0 );
47302 assert( pWal->readLock>=0 );
47945 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
47946 assert( p->pBt->inTransaction>=p->inTrans );
47998 assert( p->locked==0 );
47999 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
48000 assert( sqlite3_mutex_held(p->db->mutex) );
48013 assert( p->locked==1 );
48014 assert( sqlite3_mutex_held(pBt->mutex) );
48015 assert( sqlite3_mutex_held(p->db->mutex) );
48016 assert( p->db==pBt->db );
48045 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
48046 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
48047 assert( p->pNext==0 || p->pNext->db==p->db );
48048 assert( p->pPrev==0 || p->pPrev->db==p->db );
48049 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
48052 assert( !p->locked || p->wantToLock>0 );
48053 assert( p->sharable || p->wantToLock==0 );
48056 assert( sqlite3_mutex_held(p->db->mutex) );
48060 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
48082 assert( pLater->sharable );
48083 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
48084 assert( !pLater->locked || pLater->wantToLock>0 );
48102 assert( p->wantToLock>0 );
48118 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
48119 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
48120 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
48121 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
48160 assert( sqlite3_mutex_held(db->mutex) );
48169 assert( sqlite3_mutex_held(db->mutex) );
48222 assert( db!=0 );
48224 assert( iDb>=0 && iDb<db->nDb );
48228 assert( p!=0 );
48485 assert( sqlite3BtreeHoldsMutex(p) );
48486 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
48487 assert( p->db!=0 );
48488 assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
48494 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
48495 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
48520 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
48521 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
48525 assert( p==pBt->pWriter );
48558 assert( sqlite3BtreeHoldsMutex(p) );
48559 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
48560 assert( p->db!=0 );
48566 assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
48570 assert( p->sharable );
48571 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
48599 assert( WRITE_LOCK>READ_LOCK );
48621 assert( sqlite3BtreeHoldsMutex(p) );
48622 assert( p->sharable || 0==*ppIter );
48623 assert( p->inTrans>0 );
48627 assert( pBt->isExclusive==0 || pBt->pWriter==pLock->pBtree );
48628 assert( pLock->pBtree->inTrans>=pLock->eLock );
48631 assert( pLock->iTable!=1 || pLock==&p->lock );
48640 assert( pBt->isPending==0 || pBt->pWriter );
48670 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
48697 assert( cursorHoldsMutex(pCur) );
48708 assert( sqlite3_mutex_held(pBt->mutex) );
48734 assert( sqlite3BtreeHoldsMutex(pBtree) );
48787 assert( pgno<=pBt->nPage );
48830 assert( CURSOR_VALID==pCur->eState );
48831 assert( 0==pCur->pKey );
48832 assert( cursorHoldsMutex(pCur) );
48835 assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
48856 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
48879 assert( sqlite3_mutex_held(pBt->mutex) );
48880 assert( pExcept==0 || pExcept->pBt==pBt );
48897 assert( cursorHoldsMutex(pCur) );
48921 assert( nKey==(i64)(int)nKey );
48946 assert( cursorHoldsMutex(pCur) );
48947 assert( pCur->eState>=CURSOR_REQUIRESEEK );
48956 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
49003 assert( sqlite3_mutex_held(pBt->mutex) );
49033 assert( sqlite3_mutex_held(pBt->mutex) );
49035 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
49037 assert( pBt->autoVacuum );
49053 assert( offset <= (int)pBt->usableSize-5 );
49083 assert( sqlite3_mutex_held(pBt->mutex) );
49097 assert( offset <= (int)pBt->usableSize-5 );
49098 assert( pEType!=0 );
49131 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49164 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49167 assert( pPage->leaf==0 || pPage->leaf==1 );
49169 assert( n==4-4*pPage->leaf );
49287 assert( nSize==debuginfo.nSize );
49308 assert( pCell!=0 );
49310 assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
49340 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49341 assert( pPage->pBt!=0 );
49342 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
49343 assert( pPage->nOverflow==0 );
49344 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49350 assert( nCell==get2byte(&data[hdr+3]) );
49371 assert( pc>=iCellFirst && pc<=iCellLast );
49383 assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
49389 assert( cbrk>=iCellFirst );
49395 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49424 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49425 assert( pPage->pBt );
49426 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49427 assert( nByte>=0 ); /* Minimum cell size is 4 */
49428 assert( pPage->nFree>=nByte );
49429 assert( pPage->nOverflow==0 );
49431 assert( nByte < usableSize-8 );
49434 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
49489 assert( gap+nByte<=top );
49501 assert( top+nByte <= (int)pPage->pBt->usableSize );
49519 assert( pPage->pBt!=0 );
49520 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49521 assert( start>=pPage->hdrOffset+6+pPage->childPtrSize );
49522 assert( (start + size) <= (int)pPage->pBt->usableSize );
49523 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49524 assert( size>=0 ); /* Minimum cell size is 4 */
49544 assert( start<=iLast );
49554 assert( pbegin>addr || pbegin==0 );
49564 assert( pbegin>addr );
49565 assert( pbegin <= (int)pPage->pBt->usableSize-4 );
49591 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49610 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
49611 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49612 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
49643 assert( pPage->pBt!=0 );
49644 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49645 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
49646 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
49647 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
49666 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
49757 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
49758 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
49759 assert( sqlite3PagerGetData(pPage->pDbPage) == data );
49760 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
49761 assert( sqlite3_mutex_held(pBt->mutex) );
49775 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
49816 assert( sqlite3_mutex_held(pBt->mutex) );
49830 assert( sqlite3_mutex_held(pBt->mutex) );
49846 assert( sqlite3BtreeHoldsMutex(p) );
49847 assert( ((p->pBt->nPage)&0x8000000)==0 );
49865 assert( sqlite3_mutex_held(pBt->mutex) );
49880 assert( pgno!=0 || rc==SQLITE_CORRUPT );
49890 assert( pPage->aData );
49891 assert( pPage->pBt );
49892 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
49893 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
49894 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49910 assert( sqlite3PagerPageRefcount(pData)>0 );
49912 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49931 assert( pBt->db );
49932 assert( sqlite3_mutex_held(pBt->db->mutex) );
49988 assert( db!=0 );
49989 assert( pVfs!=0 );
49990 assert( sqlite3_mutex_held(db->mutex) );
49991 assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
49994 assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
49997 assert( (flags & BTREE_SINGLE)==0 || isTempDb );
50040 assert( pBt->nRef>0 );
50080 assert( sizeof(i64)==8 || sizeof(i64)==4 );
50081 assert( sizeof(u64)==8 || sizeof(u64)==4 );
50082 assert( sizeof(u32)==4 );
50083 assert( sizeof(u16)==2 );
50084 assert( sizeof(Pgno)==4 );
50138 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
50214 assert( sqlite3_mutex_held(mutexOpen) );
50232 assert( sqlite3_mutex_notheld(pBt->mutex) );
50286 assert( sqlite3_mutex_held(p->db->mutex) );
50308 assert( p->wantToLock==0 && p->locked==0 );
50315 assert( !pBt->pCursor );
50326 assert( p->wantToLock==0 );
50327 assert( p->locked==0 );
50353 assert( sqlite3_mutex_held(p->db->mutex) );
50376 assert( sqlite3_mutex_held(p->db->mutex) );
50377 assert( level>=1 && level<=3 );
50392 assert( sqlite3_mutex_held(p->db->mutex) );
50394 assert( pBt && pBt->pPager );
50423 assert( nReserve>=-1 && nReserve<=255 );
50432 assert( nReserve>=0 && nReserve<=255 );
50435 assert( (pageSize & 7)==0 );
50436 assert( !pBt->pPage1 && !pBt->pCursor );
50562 assert( sqlite3_mutex_held(pBt->mutex) );
50563 assert( pBt->pPage1==0 );
50637 assert( (pageSize & 7)==0 );
50686 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
50706 assert( sqlite3_mutex_held(pBt->mutex) );
50707 assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE );
50709 assert( pBt->pPage1->aData );
50710 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
50711 assert( pBt->pPage1->aData );
50727 assert( sqlite3_mutex_held(pBt->mutex) );
50732 assert( pP1!=0 );
50737 assert( sizeof(zMagicHeader)==16 );
50742 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
50751 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
50752 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
50880 assert( p->lock.pBtree==p && p->lock.iTable==1 );
50894 assert( !pBt->pWriter );
50944 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50987 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50988 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
51059 assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
51061 assert( sqlite3_mutex_held(pBt->mutex) );
51062 assert( pDbPage->pBt==pBt );
51144 assert( sqlite3_mutex_held(pBt->mutex) );
51145 assert( iLastPg>nFin );
51177 assert( iFreePg==iLastPg );
51205 assert( iFreePg<iLastPg );
51254 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
51283 assert( sqlite3_mutex_held(pBt->mutex) );
51285 assert(pBt->autoVacuum);
51331 assert( nRef==sqlite3PagerRefcount(pPager) );
51391 assert( sqlite3BtreeHoldsMutex(p) );
51460 assert( pBt->inTransaction==TRANS_WRITE );
51461 assert( pBt->nTransaction>0 );
51576 assert( TRANS_WRITE==pBt->inTransaction );
51593 assert( countWriteCursors(pBt)==0 );
51624 assert( p->inTrans==TRANS_WRITE );
51625 assert( pBt->readOnly==0 );
51626 assert( iStatement>0 );
51627 assert( iStatement>p->db->nSavepoint );
51628 assert( pBt->inTransaction==TRANS_WRITE );
51655 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
51656 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
51667 assert( pBt->nPage>0 );
51715 assert( sqlite3BtreeHoldsMutex(p) );
51716 assert( wrFlag==0 || wrFlag==1 );
51722 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
51723 assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
51726 assert( p->inTrans>TRANS_NONE );
51727 assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
51728 assert( pBt->pPage1 && pBt->pPage1->aData );
51734 assert( wrFlag==0 );
51810 assert( pCur->cachedRowid==iRowid );
51874 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
51926 assert( cursorHoldsMutex(pCur) );
51927 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
51950 assert( cursorHoldsMutex(pCur) );
51951 assert( pCur->eState==CURSOR_VALID );
51986 assert( sqlite3_mutex_held(pBt->mutex) );
51987 assert(pPgnoNext);
52015 assert( next==0 || rc==SQLITE_DONE );
52018 assert( rc==SQLITE_OK || pPage==0 );
52107 assert( pPage );
52108 assert( pCur->eState==CURSOR_VALID );
52109 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52110 assert( cursorHoldsMutex(pCur) );
52177 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
52238 assert( cursorHoldsMutex(pCur) );
52239 assert( pCur->eState==CURSOR_VALID );
52240 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
52241 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52263 assert( cursorHoldsMutex(pCur) );
52266 assert( pCur->eState==CURSOR_VALID );
52267 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
52268 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52303 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
52304 assert( pCur->eState==CURSOR_VALID );
52305 assert( cursorHoldsMutex(pCur) );
52307 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52324 assert( nLocal<=nKey );
52347 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52348 assert( cursorHoldsMutex(pCur) );
52356 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52357 assert( cursorHoldsMutex(pCur) );
52380 assert( cursorHoldsMutex(pCur) );
52381 assert( pCur->eState==CURSOR_VALID );
52382 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
52409 assert( iIdx<=pParent->nCell );
52411 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
52413 assert( get4byte(findCell(pParent, iIdx))==iChild );
52429 assert( cursorHoldsMutex(pCur) );
52430 assert( pCur->eState==CURSOR_VALID );
52431 assert( pCur->iPage>0 );
52432 assert( pCur->apPage[pCur->iPage] );
52471 assert( cursorHoldsMutex(pCur) );
52472 assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
52473 assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
52474 assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
52477 assert( pCur->skipNext!=SQLITE_OK );
52504 assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
52517 assert( pRoot->pgno==pCur->pgnoRoot );
52518 assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
52549 assert( cursorHoldsMutex(pCur) );
52550 assert( pCur->eState==CURSOR_VALID );
52552 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52574 assert( cursorHoldsMutex(pCur) );
52575 assert( pCur->eState==CURSOR_VALID );
52596 assert( cursorHoldsMutex(pCur) );
52597 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52601 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52604 assert( pCur->apPage[pCur->iPage]->nCell>0 );
52619 assert( cursorHoldsMutex(pCur) );
52620 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52629 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
52631 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
52632 assert( pCur->apPage[pCur->iPage]->leaf );
52640 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52643 assert( pCur->eState==CURSOR_VALID );
52689 assert( cursorHoldsMutex(pCur) );
52690 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
52691 assert( pRes );
52692 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
52713 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
52714 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
52715 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
52718 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52721 assert( pCur->apPage[0]->intKey || pIdxKey );
52734 assert( pPage->nCell>0 );
52735 assert( pPage->intKey==(pIdxKey==0) );
52746 assert( idx==pCur->aiIdx[pCur->iPage] );
52761 assert( nCellKey>intKey );
52831 assert( lwr==upr+1 );
52832 assert( pPage->isInit );
52841 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52883 assert( cursorHoldsMutex(pCur) );
52888 assert( pRes!=0 );
52902 assert( pPage->isInit );
52903 assert( idx<=pPage->nCell );
52951 assert( cursorHoldsMutex(pCur) );
52969 assert( pPage->isInit );
53037 assert( sqlite3_mutex_held(pBt->mutex) );
53057 assert( nearby>0 );
53058 assert( pBt->autoVacuum );
53102 assert( pPrevTrunk==0 );
53121 assert( *pPgno==iTrunk );
53164 assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
53247 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
53261 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
53271 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
53285 assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
53309 assert( sqlite3_mutex_held(pBt->mutex) );
53310 assert( iPage>1 );
53311 assert( !pMemPage || pMemPage->pgno==iPage );
53363 assert( pBt->usableSize>32 );
53440 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53449 assert( pBt->usableSize > 4 );
53452 assert( ovflPgno==0 || nOvfl>0 );
53527 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53531 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
53546 assert( info.nHeader==nHeader );
53547 assert( info.nKey==nKey );
53548 assert( info.nData==(u32)(nData+nZero) );
53608 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
53612 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
53628 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
53632 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
53637 assert( pSrc );
53674 assert( idx>=0 && idx<pPage->nCell );
53675 assert( sz==cellSize(pPage, idx) );
53676 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
53677 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53694 assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
53743 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
53744 assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
53745 assert( pPage->nOverflow<=ArraySize(pPage->aOvfl) );
53746 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53752 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
53762 assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) );
53771 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
53780 assert( idx >= end+2 );
53781 assert( idx+sz <= (int)pPage->pBt->usableSize );
53790 assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
53825 assert( pPage->nOverflow==0 );
53826 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53827 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
53829 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
53832 assert( pPage->nCell==0 );
53833 assert( get2byteNotZero(&data[hdr+5])==nUsable );
53896 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53897 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
53898 assert( pPage->nOverflow==1 );
53916 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
53917 assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
53984 assert( pPage->isInit );
53995 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
54000 assert( n==pPage->pgno && e==PTRMAP_BTREE );
54006 assert( n==pPage->pgno && e==PTRMAP_BTREE );
54041 assert( pFrom->isInit );
54042 assert( pFrom->nFree>=iToHdr );
54043 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
54146 assert( sqlite3_mutex_held(pBt->mutex) );
54147 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
54158 assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
54159 assert( pParent->nOverflow==0 || pParent->aOvfl[0].idx==iParentIdx );
54263 assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
54298 assert( nCell<nMaxCells );
54308 assert( nCell<nMaxCells );
54317 assert( nCell<nMaxCells );
54321 assert( sz<=pBt->maxLocal+23 );
54322 assert( iSpace1 <= (int)pBt->pageSize );
54325 assert( leafCorrection==0 || leafCorrection==4 );
54328 assert( leafCorrection==0 );
54329 assert( pOld->hdrOffset==0 );
54334 assert( leafCorrection==4 );
54362 assert( i<nMaxCells );
54395 assert( d<nMaxCells );
54396 assert( r<nMaxCells );
54412 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
54437 assert( i>0 );
54500 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
54511 assert( j<nMaxCells );
54514 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
54515 assert( pNew->nOverflow==0 );
54522 assert( i<nNew-1 || j==nCell );
54528 assert( j<nMaxCells );
54560 assert(leafCorrection==4);
54565 assert( sz<=pBt->maxLocal+23 );
54566 assert( iOvflSpace <= (int)pBt->pageSize );
54569 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
54575 assert( j==nCell );
54576 assert( nOld>0 );
54577 assert( nNew>0 );
54598 assert( nNew==1 );
54599 assert( apNew[0]->nFree ==
54658 assert(nOverflow>0 || iOverflow<i );
54659 assert(nOverflow<2 || pOld->aOvfl[0].idx==pOld->aOvfl[1].idx-1);
54660 assert(nOverflow<3 || pOld->aOvfl[1].idx==pOld->aOvfl[2].idx-1);
54675 assert( j<nOld );
54676 assert( k<nNew );
54709 assert( pParent->isInit );
54754 assert( pRoot->nOverflow>0 );
54755 assert( sqlite3_mutex_held(pBt->mutex) );
54774 assert( sqlite3PagerIswriteable(pChild->pDbPage) );
54775 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
54776 assert( pChild->nCell==pRoot->nCell );
54822 assert( (balance_deeper_called++)==0 );
54828 assert( pCur->apPage[1]->nOverflow );
54861 assert( (balance_quick_called++)==0 );
54956 assert( pCur->skipNext!=SQLITE_OK );
54960 assert( cursorHoldsMutex(pCur) );
54961 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
54962 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
54969 assert( (pKey==0)==(pCur->pKeyInfo==0) );
54995 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
54998 assert( pPage->intKey || nKey>=0 );
54999 assert( pPage->leaf || !pPage->intKey );
55004 assert( pPage->isInit );
55010 assert( szNew==cellSizePtr(pPage, newCell) );
55011 assert( szNew <= MX_CELL_SIZE(pBt) );
55015 assert( idx<pPage->nCell );
55029 assert( pPage->leaf );
55032 assert( pPage->leaf );
55035 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
55069 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
55088 assert( cursorHoldsMutex(pCur) );
55089 assert( pBt->inTransaction==TRANS_WRITE );
55090 assert( !pBt->readOnly );
55091 assert( pCur->wrFlag );
55092 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
55093 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
55151 assert( MX_CELL_SIZE(pBt) >= nCell );
55209 assert( sqlite3BtreeHoldsMutex(p) );
55210 assert( pBt->inTransaction==TRANS_WRITE );
55211 assert( !pBt->readOnly );
55244 assert( pgnoRoot>=3 );
55280 assert( eType!=PTRMAP_ROOTPAGE );
55281 assert( eType!=PTRMAP_FREEPAGE );
55313 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
55325 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
55333 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
55360 assert( sqlite3_mutex_held(pBt->mutex) );
55380 assert( pPage->intKey );
55411 assert( p->inTrans==TRANS_WRITE );
55451 assert( sqlite3BtreeHoldsMutex(p) );
55452 assert( p->inTrans==TRANS_WRITE );
55531 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
55575 assert( p->inTrans>TRANS_NONE );
55576 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
55577 assert( pBt->pPage1 );
55578 assert( idx>=0 && idx<=15 );
55599 assert( idx>=1 && idx<=15 );
55601 assert( p->inTrans==TRANS_WRITE );
55602 assert( pBt->pPage1!=0 );
55609 assert( pBt->autoVacuum || iMeta==0 );
55610 assert( iMeta==0 || iMeta==1 );
55912 assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */
55945 assert( sz==info.nPayload );
56033 assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */
56055 assert( i<=usableSize-4 ); /* Enforced by btreeInitPage() */
56057 assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */
56060 assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */
56061 assert( j<=usableSize-4 ); /* Enforced by btreeInitPage() */
56113 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
56212 assert( p->pBt->pPager!=0 );
56225 assert( p->pBt->pPager!=0 );
56233 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
56266 assert( p );
56267 assert( sqlite3_mutex_held(p->db->mutex) );
56272 assert( p );
56273 assert( sqlite3_mutex_held(p->db->mutex) );
56315 assert( sqlite3_mutex_held(p->db->mutex) );
56318 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
56332 assert( p->inTrans!=TRANS_NONE );
56335 assert( READ_LOCK+1==WRITE_LOCK );
56336 assert( isWriteLock==0 || isWriteLock==1 );
56362 assert( cursorHoldsMutex(pCsr) );
56363 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
56364 assert( pCsr->isIncrblobHandle );
56370 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
56385 assert( !pCsr->pBt->readOnly && pCsr->pBt->inTransaction==TRANS_WRITE );
56386 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
56387 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
56388 assert( pCsr->apPage[pCsr->iPage]->intKey );
56404 assert( cursorHoldsMutex(pCur) );
56405 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
56420 assert( iVersion==1 || iVersion==2 );
56675 assert( p->bDestLocked );
56676 assert( !isFatalError(p->rc) );
56677 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
56678 assert( zSrcData );
56761 assert( sqlite3BtreeHoldsMutex(p->pSrc) );
56830 assert( nSrcPage>=0 );
56882 assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
56883 assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
56910 assert( pFile );
56911 assert( (i64)nDestTruncate*(i64)pgszDest >= iSize || (
56970 assert( rc2==SQLITE_OK );
57068 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
57075 assert( p->pDestDb );
57079 assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
57101 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
57140 assert( b.rc!=SQLITE_OK );
57193 assert( (pMem->flags&MEM_RowSet)==0 );
57194 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
57199 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57208 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
57209 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
57210 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
57229 assert( 1 >=
57235 assert( (pMem->flags&MEM_RowSet)==0 );
57275 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57276 assert( (pMem->flags&MEM_RowSet)==0 );
57302 assert( pMem->flags&MEM_Blob );
57303 assert( (pMem->flags&MEM_RowSet)==0 );
57304 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57328 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57359 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57360 assert( !(fg&MEM_Zero) );
57361 assert( !(fg&(MEM_Str|MEM_Blob)) );
57362 assert( fg&(MEM_Int|MEM_Real) );
57363 assert( (pMem->flags&MEM_RowSet)==0 );
57364 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57380 assert( fg & MEM_Real );
57402 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
57403 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57410 assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
57424 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
57427 assert( (p->flags & MEM_Agg)==0 );
57430 assert( (p->flags&MEM_RowSet)==0 );
57507 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57508 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57516 assert( pMem->z || pMem->n==0 );
57532 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57533 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57554 assert( pMem->flags & MEM_Real );
57555 assert( (pMem->flags & MEM_RowSet)==0 );
57556 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57557 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57583 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57584 assert( (pMem->flags & MEM_RowSet)==0 );
57585 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57597 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57598 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
57615 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
57616 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57625 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
57702 assert( db!=0 );
57703 assert( (pMem->flags & MEM_RowSet)==0 );
57709 assert( pMem->zMalloc );
57712 assert( pMem->u.pRowSet!=0 );
57722 assert( p->db!=0 );
57767 assert( (pFrom->flags & MEM_RowSet)==0 );
57773 assert( srcType==MEM_Ephem || srcType==MEM_Static );
57785 assert( (pFrom->flags & MEM_RowSet)==0 );
57807 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
57808 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
57809 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
57844 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
57845 assert( (pMem->flags & MEM_RowSet)==0 );
57860 assert( enc!=0 );
57931 assert( (combined_flags & MEM_RowSet)==0 );
57967 assert( f1&MEM_Int );
57968 assert( f2&MEM_Int );
57986 assert( pMem1->enc==pMem2->enc );
57987 assert( pMem1->enc==SQLITE_UTF8 ||
57994 assert( !pColl || pColl->xCmp );
58056 assert( sqlite3BtreeCursorIsValid(pCur) );
58060 assert( (pMem->flags & MEM_RowSet)==0 );
58066 assert( zData!=0 );
58105 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
58106 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
58107 assert( (pVal->flags & MEM_RowSet)==0 );
58112 assert( (MEM_Blob>>3) == MEM_Str );
58118 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
58125 assert( (pVal->flags&MEM_Blob)==0 );
58127 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
58129 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
58242 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
58243 assert( pExpr->u.zToken[1]=='\'' );
58248 assert( zVal[nVal]=='\'' );
58359 assert( isPrepareV2==1 || isPrepareV2==0 );
58364 assert( p->zSql==0 );
58448 assert( p->magic==VDBE_MAGIC_INIT );
58449 assert( op>0 && op<0xff );
58549 assert( p->magic==VDBE_MAGIC_INIT );
58569 assert( p->magic==VDBE_MAGIC_INIT );
58570 assert( j>=0 && j<p->nLabel );
58624 assert( p->iAddr<nOp );
58736 assert( p->nOp - i >= 3 );
58737 assert( pOp[-1].opcode==OP_Integer );
58750 assert( -1-pOp->p2<p->nLabel );
58764 assert( p->magic==VDBE_MAGIC_INIT );
58781 assert( aOp && !p->db->mallocFailed );
58784 assert( p->btreeMask==0 );
58798 assert( p->magic==VDBE_MAGIC_INIT );
58839 assert( p!=0 );
58850 assert( p!=0 );
58860 assert( p!=0 );
58871 assert( p!=0 );
58873 assert( p->nOp>0 );
58883 assert( addr>=0 );
58905 assert( db );
59018 assert( p!=0 );
59020 assert( p->magic==VDBE_MAGIC_INIT );
59027 assert( p->nOp>0 );
59028 assert( addr<p->nOp );
59071 assert( ((VTable *)zP4)->db==p->db );
59092 assert( p->nOp>0 || p->aOp==0 );
59093 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
59106 assert( p->nOp>0 || p->aOp==0 );
59107 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
59143 assert( p->magic==VDBE_MAGIC_INIT );
59150 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
59166 assert( nTemp>=20 );
59195 assert( i<nTemp );
59222 assert( (pMem->flags & MEM_Null)==0 );
59230 assert( pMem->flags & MEM_Blob );
59262 assert( zP4!=0 );
59275 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
59276 assert( i<(int)sizeof(p->btreeMask)*8 );
59382 assert( (&p[1])==pEnd || p[0].db==p[1].db );
59452 assert( p->explain );
59453 assert( p->magic==VDBE_MAGIC_RUN );
59454 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
59482 assert( p->nMem>9 );
59530 assert( pMem->z!=0 );
59572 assert( p->db->mallocFailed );
59580 assert( pMem->z!=0 );
59589 assert( p->db->mallocFailed );
59697 assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) );
59717 assert( p!=0 );
59718 assert( p->magic==VDBE_MAGIC_INIT );
59722 assert( p->nOp>0 );
59729 assert( p->aMem[i].db==p->db );
59781 assert( p!=0 );
59782 assert( p->nOp>0 );
59783 assert( pParse!=0 );
59784 assert( p->magic==VDBE_MAGIC_INIT );
59786 assert( db->mallocFailed==0 );
59816 assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
59965 for(i=0; i<p->nCursor; i++) assert( p->apCsr==0 || p->apCsr[i]==0 );
59966 for(i=1; i<=p->nMem; i++) assert( p->aMem==0 || p->aMem[i].flags==MEM_Null );
60017 assert( idx<p->nResColumn );
60018 assert( var<COLNAME_N );
60020 assert( !zName || xDel!=SQLITE_DYNAMIC );
60023 assert( p->aColName!=0 );
60026 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
60169 assert( zFile[0]!=0 );
60214 assert( rc!=SQLITE_BUSY );
60278 assert( cnt==db->activeVdbeCnt );
60279 assert( nWrite==db->writeVdbeCnt );
60334 assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
60335 assert( db->nStatement>0 );
60336 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
60451 assert( p->rc!=SQLITE_IOERR_BLOCKED ); /* This error no longer exists */
60588 assert( db->activeVdbeCnt>=db->writeVdbeCnt );
60604 assert( db->activeVdbeCnt>0 || db->autoCommit==0 || db->nStatement==0 );
60708 assert( (rc & p->db->errMask)==rc );
60742 assert( p->db==0 || p->db==db );
60770 assert( db->pVdbe==p );
60800 assert( p->isTable );
60900 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
60905 assert( n>=0 );
61001 assert( sizeof(v)==sizeof(pMem->r) );
61008 assert( len<=(u32)nBuf );
61018 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
61020 assert( pMem->n<=nBuf );
61025 assert( nBuf>=0 );
61096 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
61106 assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
61199 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
61215 assert( u<=pKeyInfo->nField + 1 );
61296 assert( mem1.zMalloc==0 ); /* See comment below */
61309 assert( idx1==szHdr1 && rc );
61310 assert( mem1.flags & MEM_Int );
61324 assert( mem1.zMalloc==0 );
61334 assert( rc==0 );
61369 assert( sqlite3BtreeCursorIsValid(pCur) );
61371 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
61372 assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
61444 assert( sqlite3BtreeCursorIsValid(pCur) );
61446 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
61458 assert( pUnpacked->flags & UNPACKED_IGNORE_ROWID );
61469 assert( sqlite3_mutex_held(db->mutex) );
61515 assert( iVar>0 );
61537 assert( iVar>0 );
61650 assert( (rc & (v->db->errMask))==rc );
61753 assert( n>=0 );
61754 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61758 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61762 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61768 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61774 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61778 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61782 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61791 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61801 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61810 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61819 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61824 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61828 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61841 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61849 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
61889 assert(p);
61939 assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
61973 assert( p->rc==SQLITE_OK );
61992 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
61995 assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
62035 assert( v->expired==0 );
62066 assert( p && p->pFunc );
62081 assert( p && p->pFunc );
62114 assert( p && p->pFunc && p->pFunc->xStep );
62115 assert( sqlite3_mutex_held(p->s.db->mutex) );
62142 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62165 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62205 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
62406 assert( db!=0 );
62411 assert( db->mallocFailed==0 );
62767 assert( pTo->db==pFrom->db );
62768 assert( pTo->nVar==pFrom->nVar );
62886 assert( n>0 && tokenType!=TK_ILLEGAL );
62944 assert( n>0 );
62947 assert( zRawSql[0] || nToken==0 );
62951 assert( sqlite3Isdigit(zRawSql[1]) );
62957 assert( zRawSql[0]==':' || zRawSql[0]=='$' || zRawSql[0]=='@' );
62962 assert( idx>0 );
62966 assert( idx>0 && idx<=p->nVar );
62993 assert( pVar->flags & MEM_Blob );
63235 assert( iCur<p->nCursor );
63313 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
63365 assert( (f & (MEM_Static|MEM_Ephem))==0 );
63368 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
63371 assert( (f & (MEM_Static|MEM_Dyn))==0 );
63402 assert( (f & (MEM_Static|MEM_Ephem))==0 );
63405 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
63408 assert( (f & (MEM_Static|MEM_Dyn))==0 );
63598 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
64095 assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
64102 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
64104 assert( p->explain==0 );
64125 assert( pc>=0 && pc<p->nOp );
64184 assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
64186 assert( pOp->p2>0 );
64187 assert( pOp->p2<=p->nMem );
64197 assert( pOp->p1>0 );
64198 assert( pOp->p1<=p->nMem );
64199 assert( memIsValid(&aMem[pOp->p1]) );
64203 assert( pOp->p2>0 );
64204 assert( pOp->p2<=p->nMem );
64205 assert( memIsValid(&aMem[pOp->p2]) );
64209 assert( pOp->p3>0 );
64210 assert( pOp->p3<=p->nMem );
64211 assert( memIsValid(&aMem[pOp->p3]) );
64215 assert( pOp->p2>0 );
64216 assert( pOp->p2<=p->nMem );
64220 assert( pOp->p3>0 );
64221 assert( pOp->p3<=p->nMem );
64283 assert( (pIn1->flags & MEM_Dyn)==0 );
64298 assert( pIn1->flags & MEM_Int );
64312 assert( (pIn1->flags & MEM_Dyn)==0 );
64378 assert( p->rc!=SQLITE_OK );
64387 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
64391 assert( rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT );
64392 assert( rc==SQLITE_OK || db->nDeferredCons>0 );
64413 assert( pOp->p4.pI64!=0 );
64426 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
64438 assert( pOp->p4.z!=0 );
64447 assert( pOut->zMalloc==pOut->z );
64448 assert( pOut->flags & MEM_Dyn );
64471 assert( pOp->p4.z!=0 );
64496 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
64515 assert( pOp->p1>0 && pOp->p1<=p->nVar );
64516 assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
64544 assert( u.ac.n>0 && u.ac.p1>0 && u.ac.p2>0 );
64545 assert( u.ac.p1+u.ac.n<=u.ac.p2 || u.ac.p2+u.ac.n<=u.ac.p1 );
64550 assert( pOut<=&aMem[p->nMem] );
64551 assert( pIn1<=&aMem[p->nMem] );
64552 assert( memIsValid(pIn1) );
64580 assert( pOut!=pIn1 );
64602 assert( pOut!=pIn1 );
64624 assert( p->nResColumn==pOp->p2 );
64625 assert( pOp->p1>0 );
64626 assert( pOp->p1+pOp->p2<=p->nMem+1 );
64632 assert( db->flags&SQLITE_CountRows );
64633 assert( p->usesStmtJournal );
64652 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
64667 assert( memIsValid(&u.ad.pMem[u.ad.i]) );
64669 assert( (u.ad.pMem[u.ad.i].flags & MEM_Ephem)==0
64704 assert( pIn1!=pOut );
64864 assert( pOp->p4type==P4_COLLSEQ );
64895 assert( u.ag.apVal || u.ag.n==0 );
64896 assert( pOp->p3>0 && pOp->p3<=p->nMem );
64900 assert( u.ag.n==0 || (pOp->p2>0 && pOp->p2+u.ag.n<=p->nMem+1) );
64901 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ag.n );
64904 assert( memIsValid(u.ag.pArg) );
64911 assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
64934 assert( pOp>aOp );
64935 assert( pOp[-1].p4type==P4_COLLSEQ );
64936 assert( pOp[-1].opcode==OP_CollSeq );
65040 assert( u.ah.op==OP_ShiftRight || u.ah.op==OP_ShiftLeft );
65044 assert( OP_ShiftRight==OP_ShiftLeft+1 );
65139 assert( MEM_Str==(MEM_Blob>>3) );
65143 assert( pIn1->flags & MEM_Str || db->mallocFailed );
65163 assert( pIn1->flags & MEM_Str || db->mallocFailed );
65322 assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
65347 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
65387 assert( pOp->p4type==P4_INTARRAY );
65388 assert( pOp->p4.ai );
65421 assert( u.aj.n>0 );
65422 assert( u.aj.pKeyInfo!=0 );
65429 assert( u.aj.p1>0 && u.aj.p1+mx<=p->nMem+1 );
65430 assert( u.aj.p2>0 && u.aj.p2+mx<=p->nMem+1 );
65432 assert( u.aj.p1>0 && u.aj.p1+u.aj.n<=p->nMem+1 );
65433 assert( u.aj.p2>0 && u.aj.p2+u.aj.n<=p->nMem+1 );
65438 assert( memIsValid(&aMem[u.aj.p1+u.aj.idx]) );
65439 assert( memIsValid(&aMem[u.aj.p2+u.aj.idx]) );
65442 assert( u.aj.i<u.aj.pKeyInfo->nField );
65602 assert( (pIn1->flags & (MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))==0 );
65686 assert( u.am.p1<p->nCursor );
65687 assert( pOp->p3>0 && pOp->p3<=p->nMem );
65705 assert( u.am.pC!=0 );
65707 assert( u.am.pC->pVtabCursor==0 );
65720 assert( sqlite3BtreeCursorIsValid(u.am.pCrsr) );
65722 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
65726 assert( (u.am.payloadSize64 & SQLITE_MAX_U32)==(u64)u.am.payloadSize64 );
65729 assert( sqlite3BtreeCursorIsValid(u.am.pCrsr) );
65731 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
65735 assert( u.am.pReg->flags & MEM_Blob );
65736 assert( memIsValid(u.am.pReg) );
65740 assert( u.am.payloadSize==0 || u.am.zRec!=0 );
65752 assert( db->aLimit[SQLITE_LIMIT_LENGTH]>=0 );
65758 assert( u.am.p2<u.am.nField );
65767 assert(u.am.aType);
65787 assert( u.am.avail>=0 );
65902 assert( rc==SQLITE_OK );
65931 assert( u.am.sMem.z==u.am.sMem.zMalloc );
65932 assert( !(u.am.pDest->flags & MEM_Dyn) );
65933 assert( !(u.am.pDest->flags & (MEM_Blob|MEM_Str)) || u.am.pDest->z==u.am.sMem.z );
65963 assert( u.an.zAffinity!=0 );
65964 assert( u.an.zAffinity[pOp->p2]==0 );
65967 assert( pIn1 <= &p->aMem[p->nMem] );
65968 assert( memIsValid(pIn1) );
66030 assert( u.ao.nField>0 && pOp->p2>0 && pOp->p2+u.ao.nField<=p->nMem+1 );
66037 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
66045 assert( memIsValid(u.ao.pRec) );
66094 assert( u.ao.i==u.ao.nByte );
66096 assert( pOp->p3>0 && pOp->p3<=p->nMem );
66157 assert( db->pSavepoint==0 || db->autoCommit==0 );
66158 assert( u.aq.p1==SAVEPOINT_BEGIN||u.aq.p1==SAVEPOINT_RELEASE||u.aq.p1==SAVEPOINT_ROLLBACK );
66159 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
66160 assert( checkSavepointCount(db) );
66178 assert( db->autoCommit==0 || db->nVTrans==0 );
66281 assert( u.aq.pSavepoint==db->pSavepoint );
66320 assert( u.ar.desiredAutoCommit==1 || u.ar.desiredAutoCommit==0 );
66321 assert( u.ar.desiredAutoCommit==1 || u.ar.iRollback==0 );
66322 assert( db->activeVdbeCnt>0 ); /* At least this one VM is active */
66341 assert( u.ar.desiredAutoCommit==1 );
66355 assert( db->nStatement==0 );
66410 assert( pOp->p1>=0 && pOp->p1<db->nDb );
66411 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
66428 assert( sqlite3BtreeIsInTrans(u.as.pBt) );
66430 assert( db->nStatement>=0 && db->nSavepoint>=0 );
66470 assert( pOp->p3<SQLITE_N_BTREE_META );
66471 assert( u.at.iDb>=0 && u.at.iDb<db->nDb );
66472 assert( db->aDb[u.at.iDb].pBt!=0 );
66473 assert( (p->btreeMask & (((yDbMask)1)<<u.at.iDb))!=0 );
66494 assert( pOp->p2<SQLITE_N_BTREE_META );
66495 assert( pOp->p1>=0 && pOp->p1<db->nDb );
66496 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
66498 assert( u.au.pDb->pBt!=0 );
66499 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
66546 assert( pOp->p1>=0 && pOp->p1<db->nDb );
66547 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
66548 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
66653 assert( u.aw.iDb>=0 && u.aw.iDb<db->nDb );
66654 assert( (p->btreeMask & (((yDbMask)1)<<u.aw.iDb))!=0 );
66657 assert( u.aw.pX!=0 );
66660 assert( sqlite3SchemaMutexHeld(db, u.aw.iDb, 0) );
66668 assert( u.aw.p2>0 );
66669 assert( u.aw.p2<=p->nMem );
66671 assert( memIsValid(pIn2) );
66672 assert( (pIn2->flags & MEM_Int)!=0 );
66691 assert( pOp->p1>=0 );
66701 assert( rc==SQLITE_OK );
66754 assert( pOp->p1>=0 );
66771 assert( pOp->p4type==P4_KEYINFO );
66774 assert( pgno==MASTER_ROOT+1 );
66835 assert( pOp->p1>=0 );
66851 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
66922 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
66923 assert( pOp->p2!=0 );
66925 assert( u.ba.pC!=0 );
66926 assert( u.ba.pC->pseudoTableReg==0 );
66927 assert( OP_SeekLe == OP_SeekLt+1 );
66928 assert( OP_SeekGe == OP_SeekLt+2 );
66929 assert( OP_SeekGt == OP_SeekLt+3 );
66930 assert( u.ba.pC->isOrdered );
66954 assert( (pIn3->flags & MEM_Real)!=0 );
66961 if( u.ba.oc>=OP_SeekGe ){ assert( u.ba.oc==OP_SeekGe || u.ba.oc==OP_SeekGt );
66966 if( u.ba.oc<=OP_SeekLe ){ assert( u.ba.oc==OP_SeekLt || u.ba.oc==OP_SeekLe );
66980 assert( u.ba.oc==OP_SeekLe || u.ba.oc==OP_SeekGt );
66994 assert( pOp->p4type==P4_INT32 );
66995 assert( u.ba.nField>0 );
67007 assert( u.ba.oc!=OP_SeekGt || u.ba.r.flags==UNPACKED_INCRKEY );
67008 assert( u.ba.oc!=OP_SeekLe || u.ba.r.flags==UNPACKED_INCRKEY );
67009 assert( u.ba.oc!=OP_SeekGe || u.ba.r.flags==0 );
67010 assert( u.ba.oc!=OP_SeekLt || u.ba.r.flags==0 );
67014 { int i; for(i=0; i<u.ba.r.nField; i++) assert( memIsValid(&u.ba.r.aMem[i]) ); }
67028 if( u.ba.oc>=OP_SeekGe ){ assert( u.ba.oc==OP_SeekGe || u.ba.oc==OP_SeekGt );
67037 assert( u.ba.oc==OP_SeekLt || u.ba.oc==OP_SeekLe );
67049 assert( pOp->p2>0 );
67077 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67079 assert( u.bb.pC!=0 );
67081 assert( u.bb.pC->isTable );
67133 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67134 assert( pOp->p4type==P4_INT32 );
67136 assert( u.bc.pC!=0 );
67140 assert( u.bc.pC->isTable==0 );
67146 { int i; for(i=0; i<u.bc.r.nField; i++) assert( memIsValid(&u.bc.r.aMem[i]) ); }
67155 assert( pIn3->flags & MEM_Blob );
67156 assert( (pIn3->flags & MEM_Zero)==0 ); /* zeroblobs already expanded */
67219 assert( pOp->p4type==P4_INT32 );
67220 assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
67221 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67225 assert( u.bd.pCx->deferredMoveto==0 );
67239 assert( (u.bd.aMx[u.bd.nField].flags & MEM_Null)==0 );
67248 { int i; for(i=0; i<u.bd.r.nField; i++) assert( memIsValid(&u.bd.r.aMem[i]) ); }
67291 assert( pIn3->flags & MEM_Int );
67292 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67294 assert( u.be.pC!=0 );
67295 assert( u.be.pC->isTable );
67296 assert( u.be.pC->pseudoTableReg==0 );
67309 assert( u.be.pC->rowidIsValid==0 );
67317 assert( u.be.pC->rowidIsValid==0 );
67331 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67332 assert( p->apCsr[pOp->p1]!=0 );
67364 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67366 assert( u.bf.pC!=0 );
67383 assert( u.bf.pC->isTable );
67405 assert( sqlite3BtreeCursorIsValid(u.bf.pC->pCursor) );
67407 assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
67419 assert( pOp->p3>0 );
67423 assert( pOp->p3<=u.bf.pFrame->nMem );
67427 assert( pOp->p3<=p->nMem );
67431 assert( memIsValid(u.bf.pMem) );
67435 assert( (u.bf.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
67454 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
67479 assert( u.bf.v>0 ); /* EV: R-40812-03570 */
67548 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67549 assert( memIsValid(u.bg.pData) );
67551 assert( u.bg.pC!=0 );
67552 assert( u.bg.pC->pCursor!=0 );
67553 assert( u.bg.pC->pseudoTableReg==0 );
67554 assert( u.bg.pC->isTable );
67559 assert( u.bg.pKey->flags & MEM_Int );
67560 assert( memIsValid(u.bg.pKey) );
67564 assert( pOp->opcode==OP_InsertInt );
67574 assert( u.bg.pData->flags & (MEM_Blob|MEM_Str) );
67596 assert( u.bg.pC->isTable );
67598 assert( u.bg.pC->iDb>=0 );
67630 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67632 assert( u.bh.pC!=0 );
67633 assert( u.bh.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
67639 assert( u.bh.pC->isTable );
67640 assert( u.bh.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
67651 assert( u.bh.pC->deferredMoveto==0 );
67664 assert( u.bh.pC->iDb>=0 );
67696 assert( isSorter(u.bi.pC) );
67716 assert( u.bj.pC->isSorter );
67758 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67760 assert( u.bk.pC->isSorter==0 );
67761 assert( u.bk.pC->isTable || pOp->opcode!=OP_RowData );
67762 assert( u.bk.pC->isIndex || pOp->opcode==OP_RowData );
67763 assert( u.bk.pC!=0 );
67764 assert( u.bk.pC->nullRow==0 );
67765 assert( u.bk.pC->pseudoTableReg==0 );
67766 assert( !u.bk.pC->isSorter );
67767 assert( u.bk.pC->pCursor!=0 );
67769 assert( sqlite3BtreeCursorIsValid(u.bk.pCrsr) );
67776 assert( u.bk.pC->deferredMoveto==0 );
67781 assert( !u.bk.pC->isTable );
67783 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
67790 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
67827 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67829 assert( u.bl.pC!=0 );
67830 assert( u.bl.pC->pseudoTableReg==0 );
67840 assert( u.bl.pModule->xRowid );
67845 assert( u.bl.pC->pCursor!=0 );
67852 assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
67870 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67872 assert( u.bm.pC!=0 );
67875 assert( u.bm.pC->pCursor || u.bm.pC->pVtabCursor );
67897 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67899 assert( u.bn.pC!=0 );
67956 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
67958 assert( u.bo.pC!=0 );
67959 assert( u.bo.pC->isSorter==(pOp->opcode==OP_SorterSort) );
67965 assert( u.bo.pCrsr );
67973 assert( pOp->p2>0 && pOp->p2<p->nOp );
68024 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68025 assert( pOp->p5<=ArraySize(p->aCounter) );
68030 assert( u.bp.pC->isSorter==(pOp->opcode==OP_SorterNext) );
68032 assert( pOp->opcode==OP_SorterNext );
68036 assert( u.bp.pC->deferredMoveto==0 );
68037 assert( u.bp.pC->pCursor );
68038 assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
68039 assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
68079 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68081 assert( u.bq.pC!=0 );
68082 assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
68084 assert( pIn2->flags & MEM_Blob );
68087 assert( u.bq.pC->isTable==0 );
68098 assert( u.bq.pC->deferredMoveto==0 );
68120 assert( pOp->p3>0 );
68121 assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
68122 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68124 assert( u.br.pC!=0 );
68132 { int i; for(i=0; i<u.br.r.nField; i++) assert( memIsValid(&u.br.r.aMem[i]) ); }
68138 assert( u.br.pC->deferredMoveto==0 );
68159 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68161 assert( u.bs.pC!=0 );
68167 assert( u.bs.pC->deferredMoveto==0 );
68168 assert( u.bs.pC->isTable==0 );
68215 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68217 assert( u.bt.pC!=0 );
68218 assert( u.bt.pC->isOrdered );
68220 assert( u.bt.pC->deferredMoveto==0 );
68221 assert( pOp->p5==0 || pOp->p5==1 );
68222 assert( pOp->p4type==P4_INT32 );
68232 { int i; for(i=0; i<u.bt.r.nField; i++) assert( memIsValid(&u.bt.r.aMem[i]) ); }
68238 assert( pOp->opcode==OP_IdxGE );
68291 assert( u.bu.iCnt==1 );
68292 assert( (p->btreeMask & (((yDbMask)1)<<u.bu.iDb))!=0 );
68300 assert( resetSchemaOnFault==0 || resetSchemaOnFault==u.bu.iDb+1 );
68332 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
68339 assert( memIsValid(&aMem[pOp->p3]) );
68378 assert( pOp->p1>=0 && pOp->p1<db->nDb );
68379 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
68381 assert( u.bw.pDb->pBt!=0 );
68415 assert( u.bx.iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[u.bx.iDb].pBt) );
68420 assert( u.bx.iDb>=0 && u.bx.iDb<db->nDb );
68421 assert( DbHasProperty(db, u.bx.iDb, DB_SchemaLoaded) );
68433 assert( db->init.busy==0 );
68436 assert( !db->mallocFailed );
68457 assert( pOp->p1>=0 && pOp->p1<db->nDb );
68532 assert( u.by.nRoot>0 );
68535 assert( pOp->p3>0 && pOp->p3<=p->nMem );
68537 assert( (u.by.pnErr->flags & MEM_Int)!=0 );
68538 assert( (u.by.pnErr->flags & (MEM_Str|MEM_Blob))==0 );
68544 assert( pOp->p5<db->nDb );
68545 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p5))!=0 );
68552 assert( u.by.z==0 );
68574 assert( (pIn2->flags & MEM_Int)!=0 );
68640 assert( pIn3->flags&MEM_Int );
68650 assert( pOp->p4type==P4_INT32 );
68651 assert( u.ca.iSet==-1 || u.ca.iSet>=0 );
68697 assert( memIsValid(u.cb.pRt) );
68698 assert( u.cb.pProgram->nOp>0 );
68764 assert( u.cb.pProgram->nMem+u.cb.pProgram->nCsr==u.cb.pFrame->nChildMem );
68765 assert( u.cb.pProgram->nCsr==u.cb.pFrame->nChildCsr );
68766 assert( pc==u.cb.pFrame->pc );
68871 assert( memIsValid(u.cd.pIn1) );
68891 assert( pIn1->flags&MEM_Int );
68907 assert( pIn1->flags&MEM_Int );
68924 assert( pIn1->flags&MEM_Int );
68953 assert( u.ce.n>=0 );
68956 assert( u.ce.apVal || u.ce.n==0 );
68958 assert( memIsValid(u.ce.pRec) );
68964 assert( pOp->p3>0 && pOp->p3<=p->nMem );
68975 assert( pOp>p->aOp );
68976 assert( pOp[-1].p4type==P4_COLLSEQ );
68977 assert( pOp[-1].opcode==OP_CollSeq );
69007 assert( pOp->p1>0 && pOp->p1<=p->nMem );
69009 assert( (u.cf.pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
69043 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
69081 assert( u.ch.eNew==PAGER_JOURNALMODE_DELETE
69089 assert( pOp->p1>=0 && pOp->p1<db->nDb );
69141 assert( sqlite3BtreeIsInTrans(u.ch.pBt)==0 );
69189 assert( pOp->p1>=0 && pOp->p1<db->nDb );
69190 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
69238 assert( p1>=0 && p1<db->nDb );
69239 assert( (p->btreeMask & (((yDbMask)1)<<p1))!=0 );
69240 assert( isWriteLock==0 || isWriteLock==1 );
69317 assert(u.ck.pVtab && u.ck.pModule);
69375 assert( memIsValid(u.cl.pQuery) );
69377 assert( u.cl.pCur->pVtabCursor );
69383 assert( (u.cl.pQuery->flags&MEM_Int)!=0 && u.cl.pArgc->flags==MEM_Int );
69430 assert( pCur->pVtabCursor );
69431 assert( pOp->p3>0 && pOp->p3<=p->nMem );
69440 assert( u.cm.pModule->xColumn );
69490 assert( u.cn.pCur->pVtabCursor );
69496 assert( u.cn.pModule->xNext );
69535 assert( u.co.pVtab->pModule->xRename );
69536 assert( memIsValid(u.co.pName) );
69538 assert( u.co.pName->flags & MEM_Str );
69582 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
69588 assert( pOp->p4type==P4_VTAB );
69594 assert( memIsValid(u.cp.pX) );
69605 assert( u.cp.nArg>1 && u.cp.apArg[0] && (u.cp.apArg[0]->flags&MEM_Null) );
69700 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
69730 assert( pc>=-1 && pc<p->nOp );
69750 assert( rc );
69790 assert( p->zErrMsg==0 );
69801 assert( db->u1.isInterrupted );
69869 assert( v->aVar[0].flags&MEM_Int );
69905 assert( rc!=SQLITE_OK || zErr==0 );
69906 assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
70061 assert( pBlob->pStmt || db->mallocFailed );
70194 assert( db == v->db );
70267 assert( rc!=SQLITE_SCHEMA );
70271 assert( rc==SQLITE_OK || p->pStmt==0 );
70440 assert( pIter->iEof>=pIter->iReadOff );
70472 assert( rc!=SQLITE_OK || nRec>0 );
70546 assert( pSorter->iWriteOff>iStart );
70547 assert( pIter->aAlloc==0 );
70600 assert( r2->nField>0 );
70626 assert( iOut<pSorter->nTree && iOut>0 );
70645 assert( pCsr->pSorter->pUnpacked!=0 ); /* allocated in vdbeSorterMerge() */
70669 assert( pCsr->pKeyInfo && pCsr->pBt==0 );
70677 assert( pSorter->pUnpacked==(UnpackedRecord *)d );
70830 assert( pSorter->pRecord==0 );
70839 assert( rc!=SQLITE_OK || pSorter->pTemp1 );
70840 assert( pSorter->iWriteOff==0 );
70841 assert( pSorter->nPMA==0 );
70867 assert( rc!=SQLITE_OK || pSorter->nInMemory==(
70895 assert( pSorter );
70947 assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
70973 assert( pSorter );
70980 assert( pSorter->aTree==0 );
70991 assert( nIter>0 );
71018 assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
71025 assert( iWrite2==0 );
71038 assert( pIter->pFile );
71220 assert(p->iSize<=p->nBuf);
71486 assert( iOfst+iAmt<=p->endpoint.iOffset );
71531 assert( iOfst==p->endpoint.iOffset );
71547 assert( p->pFirst );
71550 assert( !p->pFirst );
71571 assert(size==0);
71642 assert( EIGHT_BYTE_ALIGNMENT(p) );
71859 assert( iCol>=0 && iCol<pEList->nExpr );
71861 assert( pOrig!=0 );
71862 assert( pOrig->flags & EP_Resolved );
71877 assert( zToken!=0 );
71882 assert( (pDup->flags & (EP_Reduced|EP_TokenOnly))==0 );
71946 assert( pNC ); /* the name context cannot be NULL. */
71947 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
71948 assert( ~ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
71967 assert( pTab!=0 && pTab->zName!=0 );
71969 assert( pTab->nCol>0 );
72033 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
72105 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
72106 assert( pExpr->x.pList==0 );
72107 assert( pExpr->x.pSelect==0 );
72116 assert( zTab==0 && zDb==0 );
72176 assert( pMatch->iCursor==pExpr->iTable );
72189 assert( pNC!=0 );
72194 assert( pTopNC!=0 );
72244 assert( pNC!=0 );
72246 assert( pParse==pWalker->pParse );
72255 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
72269 assert( pSrcList && pSrcList->nSrc==1 );
72302 assert( pRight->op==TK_DOT );
72326 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
72392 assert( pNC->nRef>=nRef );
72474 assert( sqlite3ExprIsInteger(pE, &i)==0 );
72566 assert( pEList!=0 );
72582 assert(pDup);
72644 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
72738 assert( p!=0 );
72763 assert( (p->selFlags & SF_Expanded)!=0 );
72764 assert( (p->selFlags & SF_Resolved)==0 );
72786 assert( pEList!=0 );
72816 assert( pItem->isCorrelated==0 && nRef<=0 );
72824 assert( (p->selFlags & SF_Aggregate)==0 );
73012 assert( p!=0 );
73056 assert( pExpr->flags&EP_xIsSelect );
73061 assert( !ExprHasProperty(pExpr, EP_IntValue) );
73072 assert( pExpr->pTab && j<pExpr->pTab->nCol );
73169 assert( aff1==0 || aff2==0 );
73180 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
73183 assert( pExpr->pLeft );
73241 assert( pLeft );
73243 assert( pLeft->pColl );
73246 assert( pRight->pColl );
73412 assert( iValue>=0 );
73470 assert( db->mallocFailed );
73537 assert( pToken );
73544 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
73570 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
73572 assert( z!=0 );
73573 assert( z[0]!=0 );
73576 assert( z[0]=='?' );
73639 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
73704 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
73708 assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
73709 assert( !ExprHasProperty(p, EP_FromJoin) );
73710 assert( (p->flags2 & EP2_MallocedToken)==0 );
73711 assert( (p->flags2 & EP2_Irreducible)==0 );
73773 assert( pzBuffer==0 || isReduced );
73799 assert( ExprHasProperty(p, EP_Reduced)==0 );
73987 assert( p==0 );
74012 assert( pList->nAlloc==0 );
74024 assert( pList->a!=0 );
74053 assert( pList!=0 || pParse->db->mallocFailed!=0 );
74056 assert( pList->nExpr>0 );
74058 assert( pItem->zName==0 );
74078 assert( pList!=0 || db->mallocFailed!=0 );
74081 assert( pList->nExpr>0 );
74082 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
74113 assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
74114 assert( pList->nExpr<=pList->nAlloc );
74229 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
74332 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
74376 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
74378 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
74381 assert( pSrc!=0 );
74386 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
74456 assert( pX->op==TK_IN );
74480 assert(v);
74669 assert( !isRowid );
74672 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
74757 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
74759 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
74827 assert( v!=0 ); /* OOM detected prior to this routine */
74952 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
74971 assert( i>=0 );
74978 assert( z!=0 );
75018 assert( iReg>0 ); /* Register numbers are always positive */
75019 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
75043 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
75115 assert( N>0 );
75116 assert( pParse->iCacheLevel>=N );
75190 assert( v!=0 );
75287 assert( target>0 && target<=pParse->nMem );
75289 assert( pParse->db->mallocFailed );
75303 assert( pCol->iMem>0 );
75316 assert( pParse->ckBase>0 );
75330 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75336 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75349 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75350 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
75351 assert( pExpr->u.zToken[1]=='\'' );
75354 assert( z[n]=='\'' );
75361 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75362 assert( pExpr->u.zToken!=0 );
75363 assert( pExpr->u.zToken[0]!=0 );
75366 assert( pExpr->u.zToken[0]=='?'
75385 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75388 assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
75389 assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
75390 assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
75391 assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
75392 assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
75414 assert( TK_LT==OP_Lt );
75415 assert( TK_LE==OP_Le );
75416 assert( TK_GT==OP_Gt );
75417 assert( TK_GE==OP_Ge );
75418 assert( TK_EQ==OP_Eq );
75419 assert( TK_NE==OP_Ne );
75459 assert( TK_AND==OP_And );
75460 assert( TK_OR==OP_Or );
75461 assert( TK_PLUS==OP_Add );
75462 assert( TK_MINUS==OP_Subtract );
75463 assert( TK_REM==OP_Remainder );
75464 assert( TK_BITAND==OP_BitAnd );
75465 assert( TK_BITOR==OP_BitOr );
75466 assert( TK_SLASH==OP_Divide );
75467 assert( TK_LSHIFT==OP_ShiftLeft );
75468 assert( TK_RSHIFT==OP_ShiftRight );
75469 assert( TK_CONCAT==OP_Concat );
75490 assert( pLeft );
75495 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75510 assert( TK_BITNOT==OP_BitNot );
75511 assert( TK_NOT==OP_Not );
75523 assert( TK_ISNULL==OP_IsNull );
75524 assert( TK_NOTNULL==OP_NotNull );
75538 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75557 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
75566 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75581 assert( nFarg>=2 );
75733 assert( pExpr->iTable==0 || pExpr->iTable==1 );
75734 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
75735 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
75736 assert( p1>=0 && p1<(pTab->nCol*2+2) );
75779 default: assert( op==TK_CASE ); {
75792 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
75793 assert((pExpr->x.pList->nExpr % 2) == 0);
75794 assert(pExpr->x.pList->nExpr > 0);
75818 assert( pTest!=0 );
75840 assert( db->mallocFailed || pParse->nErr>0
75847 assert( pExpr->affinity==OE_Rollback
75860 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75906 assert( target>0 && target<=pParse->nMem );
75911 assert( pParse->pVdbe || pParse->db->mallocFailed );
75935 assert( target>0 );
76033 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76098 assert( pList!=0 );
76099 assert( target>0 );
76100 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
76138 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76190 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
76222 assert( TK_LT==OP_Lt );
76223 assert( TK_LE==OP_Le );
76224 assert( TK_GT==OP_Gt );
76225 assert( TK_GE==OP_Ge );
76226 assert( TK_EQ==OP_Eq );
76227 assert( TK_NE==OP_Ne );
76258 assert( TK_ISNULL==OP_IsNull );
76259 assert( TK_NOTNULL==OP_NotNull );
76310 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
76336 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
76337 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
76338 assert( pExpr->op!=TK_NE || op==OP_Eq );
76339 assert( pExpr->op!=TK_EQ || op==OP_Ne );
76340 assert( pExpr->op!=TK_LT || op==OP_Ge );
76341 assert( pExpr->op!=TK_LE || op==OP_Gt );
76342 assert( pExpr->op!=TK_GT || op==OP_Le );
76343 assert( pExpr->op!=TK_GE || op==OP_Lt );
76459 assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
76460 assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
76570 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
76648 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76652 assert( !ExprHasProperty(pExpr, EP_IntValue) );
76665 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
76700 assert( pNC->pSrcList!=0 );
76760 assert( !usedAsColumnCache(pParse, i, i+n-1) );
76854 assert( len>0 );
76976 assert( len>0 );
77119 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
77121 assert( iDb>=0 );
77127 assert( iTrigDb==iDb || iTrigDb==1 );
77191 assert( pSrc->nSrc==1 );
77192 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
77414 assert( pNew );
77416 assert( sqlite3BtreeHoldsAllMutexes(db) );
77423 assert( pTab );
77534 assert( pParse->pNewTable==0 );
77535 assert( sqlite3BtreeHoldsAllMutexes(db) );
77556 assert( pTab->addColOffset>0 );
77571 assert( pNew->nCol>0 );
77573 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
77663 assert( sqlite3BtreeHoldsAllMutexes(db) );
77664 assert( sqlite3VdbeDb(v)==db );
77754 assert( sqlite3BtreeHoldsAllMutexes(db) );
77756 assert( iDb>=0 );
77757 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
77782 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
77855 assert( regTabname+1==regIdxname
77884 assert( pIdx->azColl!=0 );
77885 assert( pIdx->azColl[i]!=0 );
77999 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
78016 assert( pTab!=0 );
78017 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
78054 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
78059 assert( pName2!=0 || pName1==0 );
78129 assert( argc==3 );
78212 assert( iDb>=0 && iDb<db->nDb );
78213 assert( db->aDb[iDb].pBt!=0 );
78216 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
78281 assert( pIdx->aSample );
78431 assert( z && zName );
78465 assert( pVfs );
78539 assert( iDb>=2 );
78677 assert( v || db->mallocFailed );
78680 assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
78760 assert( db->nDb>iDb );
79040 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
79044 assert( pTabList );
79056 assert( iCol<pTab->nCol );
79059 assert( pTab->iPKey<pTab->nCol );
79064 assert( iDb>=0 && iDb<db->nDb );
79117 assert( pParse );
79205 assert( iDb>=0 );
79239 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
79275 assert( !pParse->isMultiWrite
79295 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79335 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
79374 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
79407 assert( zName!=0 );
79410 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
79414 assert( sqlite3SchemaMutexHeld(db, j, 0) );
79475 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
79479 assert( pSchema );
79481 assert( sqlite3SchemaMutexHeld(db, j, 0) );
79510 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79545 assert( iDb<db->nDb );
79550 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79551 assert( pDb->pSchema!=0 );
79560 assert( pDb->pSchema!=0 );
79567 assert( iDb<0 );
79620 assert( pTable!=0 );
79645 assert( !pTable || pTable->nRef>0 );
79654 assert( pIndex->pSchema==pTable->pSchema );
79660 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
79661 assert( pOld==pIndex || pOld==0 );
79692 assert( db!=0 );
79693 assert( iDb>=0 && iDb<db->nDb );
79694 assert( zTabName );
79695 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79817 assert( db->init.iDb==0 || db->init.busy );
79908 assert( (isTemp & 1)==isTemp );
79951 assert( !db->init.busy );
79974 assert( pParse->pNewTable==0 );
79983 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80213 assert( pCol->zType==0 );
80311 assert( autoInc==0 || autoInc==1 );
80376 assert( pIdx->nColumn==1 );
80444 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80551 assert( pCol->affinity-SQLITE_AFF_TEXT >= 0 );
80552 assert( pCol->affinity-SQLITE_AFF_TEXT < ArraySize(azType) );
80561 assert( pCol->affinity==SQLITE_AFF_NONE
80565 assert( k<=n );
80607 assert( !db->init.busy || !pSelect );
80693 assert(pParse->nTab==1);
80703 assert( p->aCol==0 );
80747 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80768 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80772 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
80784 assert( !pSelect && pCons && pEnd );
80885 assert( pTable );
80919 assert( pTable->nCol>=0 );
80928 assert( pTable->pSelect );
80947 assert( pTable->aCol==0 );
80953 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
80974 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
81013 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81103 assert( pIdx->pSchema==pTab->pSchema );
81155 assert( pParse->nErr==0 );
81156 assert( pName->nSrc==1 );
81167 assert( iDb>=0 && iDb<db->nDb );
81251 assert( pTrigger->pSchema==pTab->pSchema ||
81334 assert( pTo!=0 );
81405 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
81414 assert( pNextTo->pPrevTo==0 );
81443 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
81609 assert( pStart==0 || pEnd!=0 ); /* pEnd must be non-NULL if pStart is */
81610 assert( pParse->nErr==0 ); /* Never called with prior errors */
81627 assert( pName1 && pName2 );
81649 assert(0);
81654 assert( db->aDb[iDb].pSchema==pTab->pSchema );
81656 assert( pName==0 );
81663 assert( pTab!=0 );
81664 assert( pParse->nErr==0 );
81712 assert( !db->init.busy );
81800 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81845 assert( nExtra>=nColl );
81890 assert( pIdx->onError!=OE_None );
81891 assert( pIdx->autoIndex );
81892 assert( pIndex->onError!=OE_None );
81930 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
81935 assert( p==pIndex ); /* Malloc must have failed */
81978 assert( pEnd!=0 );
82071 assert( a!=0 );
82094 assert( pParse->nErr==0 ); /* Never called with prior errors */
82098 assert( pName->nSrc==1 );
82280 assert( iStart>=0 );
82281 assert( nExtra>=1 );
82282 assert( pSrc!=0 );
82283 assert( iStart<=pSrc->nSrc );
82293 assert( db->mallocFailed );
82360 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
82391 assert(pList || pParse->db->mallocFailed );
82462 assert( pAlias!=0 );
82472 assert( p==0 );
82484 assert( pIndexedBy!=0 );
82487 assert( pItem->notIndexed==0 && pItem->zIndex==0 );
82516 assert( p->a || p->nSrc==0 );
82532 assert( pParse!=0 );
82534 assert( db!=0 );
82557 assert( pParse!=0 );
82559 assert( db!=0 );
82577 assert( pParse!=0 );
82579 assert( db!=0 );
82600 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
82634 assert( db->aDb[1].pSchema );
82677 assert( iDb<db->nDb );
82678 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
82679 assert( iDb<SQLITE_MAX_ATTACHED+2 );
82680 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82780 assert( zColl!=0 );
82783 assert( z!=0 );
82823 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
82825 assert( pDb!=0 );
82869 assert( pName1->z );
82922 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
82925 assert( zColl );
82963 assert( !db->xCollNeeded || !db->xCollNeeded16 );
83043 assert( !p || p->xCmp );
83068 assert( p==pColl );
83115 assert( pDel==0 || pDel==pColl );
83153 assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
83154 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
83232 assert( pOther!=pDef && pOther->pNext!=pDef );
83278 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
83432 assert( pItem && pSrc->nSrc==1 );
83504 assert( pFrom->nSrc==1 );
83507 assert( pFrom->a[0].pOn==0 );
83508 assert( pFrom->a[0].pUsing==0 );
83558 assert( pOffset == 0 );
83651 assert( pTabList->nSrc==1 );
83686 assert( iDb<db->nDb );
83689 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
83693 assert(!isView || pTrigger);
83697 assert( pTabList->nSrc==1 );
83752 assert( !isView );
83756 assert( pIdx->pSchema==pTab->pSchema );
83893 assert( v );
84095 assert( argc>1 );
84098 assert( pColl );
84099 assert( mask==-1 || mask==0 );
84143 assert( argc==1 );
84177 assert( argc==1 );
84238 assert( argc==3 || argc==2 );
84250 assert( len==sqlite3_value_bytes(argv[0]) );
84289 assert( p1>=0 && p2>=0 );
84316 assert( argc==1 || argc==2 );
84356 assert( nByte>0 );
84382 assert( z2==(char*)sqlite3_value_text(argv[0]) );
84402 assert( z2==(char*)sqlite3_value_text(argv[0]) );
84480 assert( argc==1 );
84633 assert( esc==0 ); /* This is GLOB, not LIKE */
84634 assert( matchSet<0x80 ); /* '[' is a single-byte character */
84663 assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
84755 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
84855 assert( argc==1 );
84879 assert( argc==1 );
84908 assert( argc==1 );
84920 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
84961 assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
84980 assert( argc==1 );
84984 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
85007 assert( argc==1 );
85041 assert( argc==3 );
85046 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
85049 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
85054 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
85059 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
85063 assert( zRep==sqlite3_value_text(argv[2]) );
85065 assert( nOut<SQLITE_MAX_LENGTH );
85097 assert( j+nStr-i+1==nOut );
85100 assert( j<=nOut );
85129 assert( zIn==sqlite3_value_text(argv[0]) );
85219 assert( argc==1 );
85299 assert( argc==1 );
85368 assert( argc==1 || p==0 || p->n>0x7fffffff
85438 assert( argc==1 || argc==2 );
85484 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
85538 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
85551 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
85552 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
85553 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
85854 assert( ppIdx && *ppIdx==0 );
85855 assert( !paiCol || *paiCol==0 );
85856 assert( pParse );
85879 assert( nCol>1 );
86061 assert( aiCol[i]!=pTab->iPKey );
86086 assert( nIncr==1 );
86147 assert( !pIdx || pIdx->pTable==pTab );
86186 assert( iCol>=0 );
86300 assert( v ); /* VDBE has already been allocated */
86368 assert( (regOld==0)!=(regNew==0) );
86397 assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
86417 assert( pFKey->nCol==1 || (aiFree && pIdx) );
86470 assert( regOld==0 && regNew!=0 );
86480 assert( aiCol || pFKey->nCol==1 );
86657 assert( aiCol || pFKey->nCol==1 );
86668 assert( iFromCol>=0 );
86846 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
86866 assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
86910 assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
87026 assert( pOp!=0 );
87041 assert( pOp->p4.pVtab!=0 );
87042 assert( pOp->p4type==P4_VTAB );
87113 assert( pParse->pTriggerTab==0 );
87114 assert( pParse==sqlite3ParseToplevel(pParse) );
87116 assert( v ); /* We failed long ago if this is not so */
87120 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
87163 assert( v );
87171 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
87367 assert( pTabList->nSrc==1 );
87375 assert( iDb<db->nDb );
87397 assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
87433 assert( !pTrigger );
87434 assert( pList==0 );
87485 assert( pParse->nErr==0 || rc );
87496 assert( pSelect->pEList );
87498 assert( dest.nMem==nColumn );
87552 assert( useTempTable==0 );
87705 assert( pSelect==0 ); /* Otherwise useTempTable is true */
87717 assert( !IsVirtual(pTab) );
87734 assert( pSelect==0 ); /* Otherwise useTempTable is true */
87822 assert( IsVirtual(pTab) );
88043 assert( v!=0 );
88044 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
88064 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
88084 assert( onError==OE_Replace );
88179 assert( seenReplace==0 );
88240 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
88268 assert( seenReplace==0 );
88274 assert( onError==OE_Replace );
88323 assert( v!=0 );
88324 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
88378 assert( v!=0 );
88382 assert( pIdx->pSchema==pTab->pSchema );
88432 assert( pDest && pSrc );
88433 assert( pDest->pTable!=pSrc->pTable );
88527 assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
88548 assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */
88556 assert( pEList!=0 );
88560 assert( pEList->a[0].pExpr );
88681 assert( (pDest->tabFlags & TF_Autoincrement)==0 );
88692 assert( pSrcIdx );
88780 assert( rc==SQLITE_OK || pStmt==0 );
88810 assert( azCols[i]!=0 );
88867 assert( (rc&db->errMask)==rc );
89796 assert( sqlite3_mutex_held(db->mutex) );
89895 assert( (rc&0xff)==rc );
90171 assert( v!=0 ); /* Already allocated by sqlite3Pragma() */
90216 assert( action==OE_None ); break;
90235 assert( PAGER_JOURNALMODE_DELETE==0 );
90236 assert( PAGER_JOURNALMODE_PERSIST==1 );
90237 assert( PAGER_JOURNALMODE_OFF==2 );
90238 assert( PAGER_JOURNALMODE_TRUNCATE==3 );
90239 assert( PAGER_JOURNALMODE_MEMORY==4 );
90240 assert( PAGER_JOURNALMODE_WAL==5 );
90241 assert( eMode>=0 && eMode<=ArraySize(azModeName) );
90302 assert( pId2 );
90352 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
90369 assert( pBt!=0 );
90395 assert( pBt!=0 );
90465 assert(pDb==&db->aDb[0]);
90476 assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
90563 assert( pBt!=0 );
90577 assert( eAuto>=0 && eAuto<=2 );
90655 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
90879 assert( pTab->nCol>cnum );
90923 assert( db->aDb[i].zName!=0 );
91076 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91227 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
91228 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
91229 assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
91544 assert( argc==3 );
91546 assert( sqlite3_mutex_held(db->mutex) );
91553 assert( iDb>=0 && iDb<db->nDb );
91567 assert( db->init.busy );
91573 assert( (rc&0xFF)==(rcp&0xFF) );
91577 assert( iDb==1 );
91660 assert( iDb>=0 && iDb<db->nDb );
91661 assert( db->aDb[iDb].pSchema );
91662 assert( sqlite3_mutex_held(db->mutex) );
91663 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
91801 assert( db->init.busy );
91874 assert( sqlite3_mutex_held(db->mutex) );
91914 assert( sqlite3_mutex_held(db->mutex) );
91937 assert( pParse->checkSchema );
91938 assert( sqlite3_mutex_held(db->mutex) );
91960 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91993 assert( sqlite3_mutex_held(db->mutex) );
92000 assert( i>=0 && i<db->nDb );
92029 assert( ppStmt && *ppStmt==0 );
92030 assert( !db->mallocFailed );
92031 assert( sqlite3_mutex_held(db->mutex) );
92059 assert( sqlite3BtreeHoldsMutex(pBt) );
92095 assert( 1==(int)pParse->nQueryLoop );
92135 assert( db->init.busy==0 || saveSqlFlag==0 );
92142 assert(!(*ppStmt));
92165 assert( (rc&db->errMask)==rc );
92178 assert( ppStmt!=0 );
92209 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
92211 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
92213 assert( sqlite3_mutex_held(db->mutex) );
92219 assert( pNew==0 );
92222 assert( pNew!=0 );
92249 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
92261 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
92286 assert( ppStmt );
92329 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
92341 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
92413 assert( db->mallocFailed || !pOffset || pLimit ); /* OFFSET implies LIMIT */
92431 assert( pOffset==0 || pLimit!=0 );
92440 assert( pNew->pSrc!=0 || pParse->nErr>0 );
92515 assert( pB!=0 );
92560 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
92600 assert( iLeft<iRight );
92601 assert( pSrc->nSrc>iRight );
92602 assert( pSrc->a[iLeft].pTab );
92603 assert( pSrc->a[iRight].pTab );
92611 assert( !ExprHasAnyProperty(pEq, EP_TokenOnly|EP_Reduced) );
92647 assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
92901 assert( v );
92903 assert( pEList!=0 );
92921 assert( pDest->nMem==nResultCol );
92942 assert( pEList!=0 );
92943 assert( pEList->nExpr==nColumn );
93001 assert( nColumn==1 );
93032 assert( nColumn==1 );
93072 assert( eDest==SRT_Discard );
93201 assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
93277 assert( nColumn==1 );
93284 assert( nColumn==1 );
93292 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
93296 assert( regRow!=pDest->iMem+i );
93404 assert( pTab && pExpr->pTab==pTab );
93424 assert( !pS );
93426 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
93451 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
93462 assert( pzOriginTab && pzOriginCol );
93550 assert( j<pTabList->nSrc );
93553 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
93612 assert( p->pRight==0 || ExprHasProperty(p->pRight, EP_IntValue)
93629 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
93695 assert( pSelect!=0 );
93696 assert( (pSelect->selFlags & SF_Resolved)!=0 );
93697 assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
93736 assert( db->lookaside.bEnabled==0 );
93800 assert( p->pOffset==0 || p->pLimit!=0 );
93853 assert( iCol>=0 );
93920 assert( p && p->pPrior ); /* Calling function guarantees this much */
93923 assert( pPrior->pRightmost!=pPrior );
93924 assert( pPrior->pRightmost==p->pRightmost );
93940 assert( v!=0 ); /* The VDBE already created by calling function */
93945 assert( p->pEList );
93954 assert( p->pEList && pPrior->pEList );
93974 assert( !pPrior->pLimit );
94024 assert( p->pRightmost!=p ); /* Can only happen for leftward elements
94026 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
94027 assert( p->pOffset==0 ); /* Not allowed on leftward elements */
94034 assert( p->pOrderBy==0 );
94036 assert( p->addrOpenEphm[0] == -1 );
94039 assert( p->pEList );
94044 assert( !pPrior->pOrderBy );
94057 assert( p->op==TK_UNION );
94085 assert( unionTab==dest.iParm || dest.eDest!=priorOp );
94088 assert( p->pEList );
94108 default: assert( p->op==TK_INTERSECT ); {
94122 assert( p->pOrderBy==0 );
94125 assert( p->addrOpenEphm[0] == -1 );
94128 assert( p->pEList );
94142 assert( p->addrOpenEphm[1] == -1 );
94163 assert( p->pEList );
94206 assert( p->pRightmost==p );
94231 assert( pLoop->addrOpenEphm[1]<0 );
94331 assert( pIn->nMem==1 );
94357 assert( pIn->nMem==1 );
94386 assert( pDest->eDest==SRT_Output );
94538 assert( p->pOrderBy!=0 );
94539 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
94542 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
94551 assert( pPrior->pOrderBy==0 );
94553 assert( pOrderBy );
94564 assert( pItem->iCol>0 );
94589 assert( pItem->iCol>0 && pItem->iCol<=p->pEList->nExpr );
94629 assert( nOrderBy>=nExpr || db->mallocFailed );
94873 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
94874 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
94922 assert( pSrc ); /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
95064 assert( p!=0 );
95065 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
95068 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
95072 assert( pSub!=0 );
95076 assert( pSubSrc );
95293 assert( pParent==p ); /* First time through the loop */
95296 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
95299 assert( db->mallocFailed );
95363 assert( pParent->pOrderBy==0 );
95375 assert( pParent->pHaving==0 );
95381 assert( pParent->pGroupBy==0 );
95436 assert( !ExprHasProperty(pExpr, EP_IntValue) );
95460 assert( !p->pGroupBy );
95469 assert( pTab && !pTab->pSelect && pExpr );
95561 assert( i==0 );
95568 assert( pSel!=0 );
95569 assert( pFrom->pTab==0 );
95583 assert( pFrom->pTab==0 );
95592 assert( pFrom->pSelect==0 );
95624 assert( pE->op!=TK_DOT || pE->pRight!=0 );
95625 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
95642 assert( pE->op!=TK_DOT || pE->pRight!=0 );
95660 assert( pE->pLeft!=0 );
95661 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
95689 assert(IsVirtual(pTab));
95804 assert( p->selFlags & SF_Resolved );
95814 assert( pSel );
95892 assert( !ExprHasProperty(pE, EP_xIsSelect) );
95916 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
95939 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
95950 assert( nArg==1 );
95957 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
96112 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
96128 assert( pEList!=0 );
96185 assert( pItem->addrFillSub==0 );
96353 assert( addrDistinctIndex>=0 );
96356 assert( isDistinct );
96357 assert( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED
96387 assert( sqlite3VdbeCurrentAddr(v)==iJump );
96454 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
96762 assert( !ExprHasProperty(p->pEList->a[0].pExpr, EP_xIsSelect) );
97081 assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
97125 assert( azResult!=0 );
97191 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
97235 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
97236 assert( pName2!=0 );
97237 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
97238 assert( op>0 && op<0xff );
97284 assert( pTableName->nSrc==1 );
97316 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97322 assert( !db->init.busy );
97386 assert( pParse->pNewTrigger==0 );
97397 assert( pParse->pNewTrigger==pTrigger );
97458 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97466 assert( pTab!=0 );
97474 assert( !pParse->pNewTrigger );
97538 assert(pEList == 0 || pSelect == 0);
97539 assert(pEList != 0 || pSelect != 0 || db->mallocFailed);
97636 assert( pName->nSrc==1 );
97640 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
97644 assert( sqlite3SchemaMutexHeld(db, j, 0) );
97683 assert( iDb>=0 && iDb<db->nDb );
97685 assert( pTable );
97686 assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
97702 assert( pTable!=0 );
97738 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97791 assert( pList==0 || IsVirtual(pTab)==0 );
97822 assert( pSrc->nSrc>0 );
97823 assert( pSrc->a!=0 );
97827 assert( iDb<pParse->db->nDb );
97847 assert( pParse->pTriggerTab && pParse->pToplevel );
97848 assert( pStepList );
97849 assert( v!=0 );
97893 default: assert( pStep->op==TK_SELECT ); {
97934 assert( pFrom->zErrMsg==0 || pFrom->nErr );
97935 assert( pTo->zErrMsg==0 || pTo->nErr );
97964 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
97965 assert( pTop->pVdbe );
98047 assert( !pSubParse->pAinc && !pSubParse->pZombieTab );
98048 assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
98069 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
98105 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
98179 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
98180 assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
98181 assert( (op==TK_UPDATE)==(pChanges!=0) );
98188 assert( p->pSchema!=0 );
98189 assert( p->pTabSchema!=0 );
98190 assert( p->pSchema==p->pTabSchema
98241 assert( isNew==1 || isNew==0 );
98321 assert( pTab!=0 );
98327 assert( i<pTab->nCol );
98397 assert( pTabList->nSrc==1 );
98411 assert( pTrigger || tmask==0 );
98622 assert( pParse->nTab>iCur+i+1 );
98645 assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
98885 assert( pTab->iPKey<0 );
98899 assert( v );
98978 assert( rc!=SQLITE_ROW );
99085 assert( strcmp(pDb->zName,"vacuum_db")==0 );
99221 assert( 1==sqlite3BtreeIsInTrans(pTemp) );
99222 assert( 1==sqlite3BtreeIsInTrans(pMain) );
99242 assert( rc==SQLITE_OK );
99395 assert( IsVirtual(pTab) );
99407 assert( db );
99408 assert( pVTab->nRef>0 );
99409 assert( sqlite3SafetyCheckOk(db) );
99439 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
99444 assert( db2 );
99456 assert( !db || pRet );
99485 assert( sqlite3BtreeHoldsAllMutexes(db) );
99486 assert( sqlite3_mutex_held(db->mutex) );
99567 assert( 0==pTable->pIndex );
99571 assert( iDb>=0 );
99678 assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
99682 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
99709 assert(pArg->z < p->z);
99747 assert( &db->pVtabCtx );
99748 assert( xConstruct );
99807 assert(zType[i-1]==' ');
99833 assert( pTab );
99904 assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
99951 assert( (pTab->tabFlags & TF_Virtual)!=0 );
99988 assert( (rc&0xff)==rc );
100009 assert( rc==SQLITE_OK );
100014 assert( pTab->pVTable==p && p->pNext==0 );
100164 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
100165 assert( iSavepoint>=0 );
100231 assert( pVtab!=0 );
100232 assert( pVtab->pModule!=0 );
100278 assert( IsVirtual(pTab) );
100303 assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
100304 assert( OE_Ignore==4 && OE_Replace==5 );
100305 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
100327 assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
100748 assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
100766 assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
100846 assert( TK_GT>TK_EQ && TK_GT<TK_GE );
100847 assert( TK_LT>TK_EQ && TK_LT<TK_GE );
100848 assert( TK_LE>TK_EQ && TK_LE<TK_GE );
100849 assert( TK_GE==TK_EQ+4 );
100873 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
100881 assert( TK_LT==TK_GT+2 );
100882 assert( TK_GE==TK_LE+2 );
100883 assert( TK_GT>TK_EQ );
100884 assert( TK_GT<TK_LE );
100885 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
100895 assert( allowedOp(op) );
100901 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
100904 assert( op!=TK_ISNULL || c==WO_ISNULL );
100905 assert( op!=TK_IN || c==WO_IN );
100906 assert( op!=TK_EQ || c==WO_EQ );
100907 assert( op!=TK_LT || c==WO_LT );
100908 assert( op!=TK_LE || c==WO_LE );
100909 assert( op!=TK_GT || c==WO_GT );
100910 assert( op!=TK_GE || c==WO_GE );
100930 assert( iCur>=0 );
100952 assert(pX->pLeft);
100954 assert(pColl || pParse->nErr);
101024 assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
101039 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
101219 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
101220 assert( pExpr->op==TK_OR );
101229 assert( pOrWc->nTerm>=2 );
101239 assert( pOrTerm->eOperator==0 );
101240 assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
101258 assert( pAndTerm->pExpr );
101328 assert( pOrTerm->eOperator==WO_EQ );
101333 assert( j==1 );
101343 assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
101353 assert( j==1 );
101354 assert( (chngToIN&(chngToIN-1))==0 );
101355 assert( chngToIN==getMask(pMaskSet, iCursor) );
101364 assert( pOrTerm->eOperator==WO_EQ );
101400 assert( pOrTerm->eOperator==WO_EQ );
101401 assert( pOrTerm->leftCursor==iCursor );
101402 assert( pOrTerm->u.leftColumn==iColumn );
101407 assert( pLeft!=0 );
101413 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
101476 assert( pExpr->pRight==0 );
101558 assert( pList!=0 );
101559 assert( pList->nExpr==2 );
101581 assert( pWC->op==TK_AND );
101951 assert( nTerm>0 );
101956 assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
102013 assert( pIdx->aSortOrder!=0 || iColumn==-1 );
102014 assert( pTerm->sortOrder==0 || pTerm->sortOrder==1 );
102015 assert( iSortOrder==0 || iSortOrder==1 );
102283 assert( pParse->nQueryLoop >= (double)1 );
102348 assert( v!=0 );
102370 assert( nColumn>0 );
102423 assert( (u32)n==pLevel->plan.nEq );
102441 assert( n==nColumn );
102445 assert( pLevel->iIdxCur>=0 );
102493 assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
102544 assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
102555 assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
102556 assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
102557 assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
102558 assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
102559 assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
102560 assert( WO_MATCH==SQLITE_INDEX_CONSTRAINT_MATCH );
102561 assert( pTerm->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) );
102684 assert( pTab->azModuleArg && pTab->azModuleArg[0] );
102685 assert( sqlite3GetVTable(pParse->db, pTab) );
102805 assert( roundUp==0 || roundUp==1 );
102834 assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
102839 assert( pColl->enc==SQLITE_UTF8 );
102851 assert( z && pColl && pColl->xCmp );
102867 assert( db->mallocFailed );
102881 assert( i>=0 && i<=SQLITE_INDEX_SAMPLES );
102989 assert( pLower->eOperator==WO_GT || pLower->eOperator==WO_GE );
102995 assert( pUpper->eOperator==WO_LT || pUpper->eOperator==WO_LE );
103019 assert( iEst<=SQLITE_INDEX_SAMPLES );
103035 assert( pLower || pUpper );
103072 assert( p->aSample!=0 );
103135 assert( p->aSample!=0 );
103154 assert( iLower>=0 && iUpper<=SQLITE_INDEX_SAMPLES );
103656 assert( pOrderBy || (pCost->plan.wsFlags&WHERE_ORDERBY)==0 );
103657 assert( pCost->plan.u.pIdx==0 || (pCost->plan.wsFlags&WHERE_ROWID_EQ)==0 );
103658 assert( pSrc->pIndex==0
103758 assert( pParse->db->mallocFailed );
103761 assert( v!=0 );
103805 assert( iTarget>0 );
103817 assert( pX->op==TK_IN );
103822 assert( pLevel->plan.wsFlags & WHERE_IN_ABLE );
103907 assert( pLevel->plan.wsFlags & WHERE_INDEXED );
103923 assert( pIdx->nColumn>=nEq );
104227 assert( pTerm!=0 );
104228 assert( pTerm->pExpr!=0 );
104229 assert( pTerm->leftCursor==iCur );
104230 assert( omitTable==0 );
104247 assert( omitTable==0 );
104268 assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */
104269 assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */
104270 assert( TK_GE==TK_GT+3 ); /* ... is correcct. */
104274 assert( pX!=0 );
104275 assert( pStart->leftCursor==iCur );
104288 assert( pX!=0 );
104289 assert( pEnd->leftCursor==iCur );
104307 assert( pLevel->p5==0 );
104469 assert( op!=0 );
104609 assert( pTerm!=0 );
104610 assert( pTerm->eOperator==WO_OR );
104611 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
104705 assert( bRev==0 || bRev==1 );
104706 assert( omitTable==0 );
104733 assert( pE!=0 );
104754 assert( pWInfo->untestedTerms );
104757 assert( pTerm->pExpr );
105004 assert( pWC->vmask==0 && pMaskSet->n==0 );
105018 assert( (m-1)==toTheLeft );
105142 assert( pTabItem->pTab );
105154 assert( isOptimal || (sCost.used¬Ready)==0 );
105158 assert( pTabItem->pIndex==0
105205 assert( bestJ>=0 );
105206 assert( notReady & getMask(pMaskSet, pTabList->a[bestJ].iCursor) );
105214 assert( pWInfo->eDistinct==0 );
105246 assert( bestPlan.plan.u.pIdx==pIdx );
105267 assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
105310 assert( n<=pTab->nCol );
105324 assert( pIx->pSchema==pTab->pSchema );
105325 assert( iIdxCur>=0 );
105448 assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
105472 assert( pWInfo->nLevel==1 || pWInfo->nLevel==pTabList->nSrc );
105476 assert( pTab!=0 );
105508 assert( pIdx!=0 );
105521 assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107078 assert( iLookAhead!=YYNOCODE );
107142 assert( stateno<=YY_REDUCE_COUNT );
107145 assert( i!=YY_REDUCE_USE_DFLT );
107146 assert( iLookAhead!=YYNOCODE );
107153 assert( i>=0 && i<YY_ACTTAB_COUNT );
107154 assert( yy_lookahead[i]==iLookAhead );
108535 assert( yymsp[-2].minor.yy203!=0 );
108543 assert( yymsp[-1].minor.yy203!=0 );
108738 assert( yyact == YYNSTATE + YYNRULE + 1 );
108775 assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */
108861 assert( !yyendofinput ); /* Impossible to shift the $ token */
108868 assert( yyact == YY_ERROR_ACTION );
109648 assert( pzErrMsg!=0 );
109654 assert( pParse->pNewTable==0 );
109655 assert( pParse->pNewTrigger==0 );
109656 assert( pParse->nVar==0 );
109657 assert( pParse->nzVar==0 );
109658 assert( pParse->azVar==0 );
109662 assert( i>=0 );
109721 assert( pzErrMsg!=0 );
110356 assert( sqlite3GlobalConfig.nRefInitMutex==0 );
110373 assert(sizeof(x)==8);
110374 assert(sizeof(x)==sizeof(y));
110376 assert( sqlite3IsNaN(y) );
110643 assert( sz > (int)sizeof(LookasideSlot*) );
110868 assert( sqlite3SafetyCheckSickOrOk(db) );
110900 assert( db->nDb<=2 );
110901 assert( db->aDb==db->aDbStatic );
110954 assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
110968 assert( sqlite3_mutex_held(db->mutex) );
111058 assert( count>=0 );
111188 assert( sqlite3_mutex_held(db->mutex) );
111235 assert( !db->mallocFailed );
111243 assert(p || db->mallocFailed);
111307 assert( rc!=SQLITE_OK );
111332 assert( !db->mallocFailed );
111558 assert( SQLITE_CHECKPOINT_FULL>SQLITE_CHECKPOINT_PASSIVE );
111559 assert( SQLITE_CHECKPOINT_FULL<SQLITE_CHECKPOINT_RESTART );
111560 assert( SQLITE_CHECKPOINT_PASSIVE+2==SQLITE_CHECKPOINT_RESTART );
111617 assert( sqlite3_mutex_held(db->mutex) );
111618 assert( !pnLog || *pnLog==-1 );
111619 assert( !pnCkpt || *pnCkpt==-1 );
111688 assert( !db->mallocFailed );
111784 assert( sqlite3_mutex_held(db->mutex) );
111919 assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
111920 assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
111921 assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
111922 assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
111923 assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
111924 assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
111925 assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
111926 assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
111927 assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
111929 assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
111930 assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
111931 assert( SQLITE_LIMIT_TRIGGER_DEPTH==(SQLITE_N_LIMIT-1) );
111986 assert( *pzErrMsg==0 );
112040 assert( octet>=0 && octet<256 );
112210 assert( SQLITE_OPEN_READONLY == 0x01 );
112211 assert( SQLITE_OPEN_READWRITE == 0x02 );
112212 assert( SQLITE_OPEN_CREATE == 0x04 );
112273 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
112313 assert( db->pDfltColl!=0 );
112425 assert( db->mutex!=0 || isThreadsafe==0 || sqlite3GlobalConfig.bFullMutex==0 );
112470 assert( zFilename );
112471 assert( ppDb );
112483 assert( *ppDb || rc==SQLITE_NOMEM );
112508 assert( !db->mallocFailed );
112528 assert( !db->mallocFailed );
112549 assert( !db->mallocFailed );
112825 assert( pPager!=0 );
112827 assert( fd!=0 );
112948 assert( (x = va_arg(ap,int))!=0 );
113130 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) )
113162 assert( p->pUnlockConnection || p->pBlockingConnection );
113167 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
113168 assert( db==0 || p->pUnlockConnection!=db );
113169 assert( db==0 || p->pBlockingConnection!=db );
113284 assert( !db->mallocFailed );
113346 assert( p->xUnlockNotify );
113353 assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
113354 assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
114550 assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
114678 assert( p->nPendingData==0 );
114679 assert( p->pSegments==0 );
114874 assert( p->nPgsz>0 || rc!=SQLITE_OK );
115171 assert( strlen(argv[0])==4 );
115172 assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4)
115287 assert( nString==0 );
115297 assert( pTokenizer );
115301 assert( zPrefix );
115357 assert( zCsr <= &((char *)p)[nByte] );
115397 assert( p->pSegments==0 );
115499 assert( p->pSegments==0 );
115529 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
115535 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
115718 assert( piLeaf || piLeaf2 );
115722 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
115759 assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) );
116014 assert( isSaveLeft==0 || isExact==0 );
116016 assert( *p1!=0 && *p2!=0 );
116038 assert( *p1!=POS_END && *p1!=POS_COLUMN );
116039 assert( *p2!=POS_END && *p2!=POS_COLUMN );
116069 assert( pp && p );
116075 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
116234 assert( *pbFirst || *piPrev==0 );
116235 assert( *pbFirst==0 || iWrite>0 );
116343 assert( *pnOut<=n1+n2+FTS3_VARINT_MAX-1 );
116376 assert( nDist>0 );
116496 assert( iOut>0 );
116637 assert( iIndex>=0 && iIndex<p->nIndex );
116638 assert( iLevel==FTS3_SEGCURSOR_ALL
116642 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
116643 assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
116644 assert( isPrefix==0 || isScan==0 );
116648 assert( isScan==0 || p->aIndex==0 );
116844 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
116879 assert( idxNum>=0 && idxNum<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
116880 assert( nVal==0 || nVal==1 );
116881 assert( (nVal==0)==(idxNum==FTS3_FULLSCAN_SEARCH) );
116882 assert( p->pSegments==0 );
116987 assert( iCol>=0 && iCol<=p->nColumn+1 );
117006 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
117040 assert( p->pSegments==0 );
117041 assert( p->nPendingData==0 );
117042 assert( p->inTransaction!=1 );
117056 assert( p->nPendingData==0 );
117057 assert( p->inTransaction!=0 );
117058 assert( p->pSegments==0 );
117071 assert( p->inTransaction!=0 );
117144 assert( nVal>=1 );
117179 assert( nVal==1 );
117181 assert( pCsr );
117207 assert( nVal==1 );
117210 assert( p );
117236 assert( nVal==1 || nVal==2 );
117333 assert( ((Fts3Table *)pVtab)->inTransaction );
117334 assert( ((Fts3Table *)pVtab)->mxSavepoint < iSavepoint );
117348 assert( p->inTransaction );
117349 assert( p->mxSavepoint >= iSavepoint );
117362 assert( p->inTransaction );
117363 assert( p->mxSavepoint >= iSavepoint );
117500 assert( rc!=SQLITE_OK );
117545 assert( pExpr->pPhrase->iDoclistToken==0 );
117570 assert( iToken!=p->iDoclistToken );
117633 assert( pToken->pDeferred==0 || pToken->pSegcsr==0 );
117643 assert( pToken->pSegcsr==0 );
117666 assert( pPhrase->doclist.bFreeList==0 );
117693 assert( iPrev>=0 );
117789 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
117814 assert( nDoclist>0 );
117815 assert( *pbEof==0 );
117816 assert( p || *piDocid==0 );
117817 assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
117875 assert( p->nToken==1 );
117876 assert( pDL->pNextDocid==0 );
117921 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
118070 assert( a );
118084 assert( pCsr->nRowAvg>0 );
118136 assert( rc!=SQLITE_OK || nDocSize>0 );
118173 assert( pTC );
118194 assert( rc==SQLITE_OK || pList==0 );
118316 assert( pPhrase->doclist.pList );
118324 assert( pPhrase->doclist.pList[nNew]=='\0' );
118325 assert( nNew<=pPhrase->doclist.nList && nNew>0 );
118383 assert( pExpr->bEof==0 );
118391 assert( !pLeft->bDeferred || !pRight->bDeferred );
118429 assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
118430 assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
118458 assert( *pRc!=SQLITE_OK || pRight->bStart );
118647 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
118721 assert( pCsr->isEof==0 );
118729 assert( sqlite3_data_count(pCsr->pStmt)==0 );
118760 assert( pPhrase->nToken==1 );
118761 assert( pPhrase->aToken[0].pSegcsr );
118794 assert( *p );
118836 assert( pExpr->eType==FTSQUERY_PHRASE );
118853 assert( pRoot->bStart );
118858 assert( pE->aMI==0 );
118871 assert( sqlite3_data_count(pCsr->pStmt)==0 );
118904 assert( pRoot->bEof==0 );
118952 assert( pCsr->nDoc>0 );
118960 assert( pExpr->aMI );
119000 assert( iCol>=0 && iCol<pTab->nColumn );
119009 assert( pPhrase->doclist.nList>0 );
119355 assert( iCol==0 );
119374 default: assert( eState==3 );
119409 assert( idxStr==0 );
119410 assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
119470 assert( p->isEof==0 );
119813 assert( nToken==ii );
119934 assert( nKey==4 );
120053 assert( p->eType!=FTSQUERY_PHRASE );
120061 assert( p->eType==FTSQUERY_AND );
120084 assert( pSplit->pParent->pRight==pSplit );
120160 assert( pRet && pPrev );
120192 assert( pPrev && pPrev->pLeft && pPrev->pRight==0 );
120203 assert( nByte>0 );
120205 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
120306 assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
120451 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
120563 assert( pNew!=0 );
120564 assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
120580 assert( pH!=0 );
120647 assert( keyClass==FTS3_HASH_BINARY );
120662 assert( keyClass==FTS3_HASH_BINARY );
120704 assert( (new_size & (new_size-1))==0 );
120779 assert( pH->first==0 );
120780 assert( pH->count==0 );
120795 assert( xHash!=0 );
120797 assert( (pH->htsize & (pH->htsize-1))==0 );
120840 assert( pH!=0 );
120842 assert( xHash!=0 );
120844 assert( (pH->htsize & (pH->htsize-1))==0 );
120863 assert( pH->htsize>0 );
120878 assert( pH->htsize>0 );
120879 assert( (pH->htsize & (pH->htsize-1))==0 );
121041 assert( x>='a' && x<='z' );
121050 assert( x>='a' && x<='z' );
121596 assert( argc==1 || argc==2 );
121724 assert( rc!=SQLITE_OK || *ppTok );
121796 assert( argc==2 || argc==3 );
121941 assert( rc==SQLITE_OK );
121942 assert( p1==p2 );
121944 assert( rc==SQLITE_ERROR );
121945 assert( p2==0 );
121946 assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
121950 assert( rc==SQLITE_OK );
121952 assert( rc==SQLITE_OK );
121953 assert( p2==p1 );
122551 assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
122552 assert( eStmt<SizeofArray(azSql) && eStmt>=0 );
122569 assert( rc==SQLITE_OK || pStmt==0 );
122593 assert( eStmt==SQL_SELECT_DOCSIZE || eStmt==SQL_SELECT_DOCTOTAL );
122711 assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 );
122712 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
122713 assert( iIndex>=0 && iIndex<p->nIndex );
122800 assert( !p || p->iLastDocid<=iDocid );
122805 assert( p->nData<p->nSpace );
122806 assert( p->aData[p->nData]==0 );
122826 assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
122872 assert( 0==fts3HashFind(pHash, zToken, nToken) );
122911 assert( pTokenizer && pModule );
123243 assert( pnBlob);
123318 assert( !pReader->pBlob
123363 assert( pReader->aNode );
123377 assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock );
123387 assert( pReader->pBlob==0 );
123395 assert( !fts3SegReaderIsPending(pReader) );
123448 assert( pReader->aDoclist );
123449 assert( !pReader->pOffsetList );
123488 assert( p );
123523 assert( *p==0 );
123577 assert( p->bHasStat );
123578 assert( pgsz>0 );
123631 assert( iStartLeaf<=iEndLeaf );
123811 assert( rc!=0 );
123835 assert( pLhs->aNode && pRhs->aNode );
123847 assert( pLhs->aNode && pRhs->aNode );
123892 assert( nSuspect<=nSegment );
123909 assert( xCmp(apSegment[i], apSegment[i+1])<0 );
124020 assert( pTree->aData==(char *)&pTree[1] );
124103 assert( iHeight>=1 && iHeight<128 );
124154 assert( iNextLeaf==iFree );
124176 assert( pRight==0 || p->zMalloc==0 );
124263 assert( nPrefix<nTerm );
124288 assert( nData+nReq<=pWriter->nSize );
124314 assert( pWriter->zTerm==pWriter->zMalloc );
124408 assert( iIndex>=0 && iIndex<p->nIndex );
124465 assert( iLevel>=0 || iLevel==FTS3_SEGCURSOR_ALL );
124507 assert( iCol>=0 );
124608 assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
124672 assert( pCsr->pFilter==0 );
124673 assert( zTerm && nTerm>0 );
124695 assert( iCol<0 || iCol<p->nColumn );
124716 assert( pCsr->zTerm==0 );
124717 assert( pCsr->nTerm==0 );
124718 assert( pCsr->aDoclist==0 );
124719 assert( pCsr->nDoclist==0 );
124769 assert( rc==SQLITE_OK );
124800 assert( isIgnoreEmpty || (isRequirePos && !isColFilter) );
124855 assert( iDelta>0 || (nDoclist==0 && iDelta==iDocid) );
124856 assert( nDoclist>0 || iDelta==iDocid );
124929 assert( iLevel==FTS3_SEGCURSOR_ALL
124933 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
124934 assert( iIndex>=0 && iIndex<p->nIndex );
124963 assert( csr.nSegment>0 );
124964 assert( iNewLevel>=(iIndex*FTS3_SEGDIR_MAXLEVEL) );
124965 assert( iNewLevel<((iIndex+1)*FTS3_SEGDIR_MAXLEVEL) );
124979 assert( pWriter );
125038 assert(j<=nBuf);
125251 assert( pCsr->isRequireSeek==0 );
125337 assert( pToken->pDeferred==0 );
125397 assert( p->pSegments==0 );
125471 assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER );
125677 assert( pExpr->pLeft && pExpr->pRight );
125859 assert( iCsr>=iStart );
125905 assert( pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 );
125989 assert( iScore>=0 );
126111 assert( nShift<=nDesired );
126353 assert( cArg==FTS3_MATCHINFO_HITS );
126376 assert( sqlite3_data_count(pStmt)==1 );
126606 assert( zArg[i]==FTS3_MATCHINFO_HITS );
126652 assert( pCsr->aMatchinfo );
126779 assert( (mCovered&mSeen)==mCovered );
126783 assert( nFToken>0 );
126834 assert( iPos>=0 );
126870 assert( pCsr->isRequireSeek==0 );
126943 assert( iCurrent<=iMinPos );
126973 assert( rc!=SQLITE_DONE );
127386 assert( sizeof(RtreeCoord)==4 );
127387 assert( sizeof(u32)==4 );
127450 assert( pNode->pNext==0 );
127463 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
127507 assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
127626 assert( nCell<=nMaxCell );
127669 assert( pNode->nRef>0 );
127698 assert( iCell<NCELL(pNode) );
127903 assert( pConstraint->op==RTREE_MATCH );
127904 assert( pConstraint->pGeom );
127933 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
127951 assert( p->op==RTREE_MATCH );
127985 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
127996 assert( p->op==RTREE_MATCH );
128035 assert( iHeight>=0 );
128064 assert( pCursor->pNode==pChild );
128122 assert( pCsr->pNode );
128162 assert(pCsr->pNode);
128184 assert( pRtree->eCoordType==RTREE_COORD_INT32 );
128286 assert( rc==SQLITE_OK );
128300 assert( (idxStr==0 && argc==0) || (int)strlen(idxStr)==argc*2 );
128330 assert( pCsr->pNode==pRoot );
128337 assert( pCsr->pNode==pRoot );
128341 assert( rc!=SQLITE_OK || !pCsr->pNode || pCsr->iCell<NCELL(pCsr->pNode) );
128392 assert( pIdxInfo->idxStr==0 );
128425 assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH );
128441 assert( iIdx>=0 );
128534 assert( iExclude==-1 );
128940 assert( left<=right );
129007 assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
129375 assert( pNode->nRef==1 );
129464 assert( pParent || pNode->iNode==1 );
129756 assert(nData>=1);
129773 assert( nData==(pRtree->nDim*2 + 3) );
130396 assert(uPattern!=0);
130580 assert(!pExpr);
130646 assert(nArg==1 || nArg==2);
130705 assert(!"Unexpected return value from ucol_strcoll()");
130734 assert(nArg==2);
130747 assert(p);
131018 assert(iStart<=iEnd);