Lines Matching refs:assert
8505 # define ALWAYS(X) ((X)?1:(assert(0),0))
8506 # define NEVER(X) ((X)?(assert(0),1):0)
15053 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusValue()
15054 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusValue()
15055 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusValue()
15073 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusUp()
15074 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusUp()
15075 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusUp()
15084 assert( N>=0 ); in sqlite3StatusDown()
15085 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusDown()
15086 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusDown()
15088 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusDown()
15098 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusSet()
15099 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusSet()
15100 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusSet()
15183 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); in sqlite3_db_status()
15184 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); in sqlite3_db_status()
15290 assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 ); in sqlite3_db_status()
15291 assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 ); in sqlite3_db_status()
16661 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
16666 assert( dirSync==0 || dirSync==1 ); in sqlite3OsDelete()
16748 assert( pFile ); in sqlite3OsCloseFree()
16802 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ); in vfsUnlink()
16843 assert(vfsList); in sqlite3_vfs_register()
17147 assert( nByte>0 ); in sqlite3MemMalloc()
17174 assert( pPrior!=0 ); in sqlite3MemFree()
17218 assert( pPrior!=0 && nByte>0 ); in sqlite3MemRealloc()
17219 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
17450 assert( mem.nCurrent[i]>=0 ); in adjustStats()
17468 assert( p->iForeGuard==(int)FOREGUARD ); in sqlite3MemsysGetHeader()
17472 assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); in sqlite3MemsysGetHeader()
17477 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); in sqlite3MemsysGetHeader()
17498 assert( (sizeof(struct MemBlockHdr)&7) == 0 ); in sqlite3MemInit()
17559 assert( mem.disallow==0 ); in sqlite3MemMalloc()
17584 assert(pBt[0]); in sqlite3MemMalloc()
17613 assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 in sqlite3MemFree()
17620 assert( pHdr->pPrev->pNext==pHdr ); in sqlite3MemFree()
17623 assert( mem.pFirst==pHdr ); in sqlite3MemFree()
17627 assert( pHdr->pNext->pPrev==pHdr ); in sqlite3MemFree()
17630 assert( mem.pLast==pHdr ); in sqlite3MemFree()
17654 assert( mem.disallow==0 ); in sqlite3MemRealloc()
17655 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
17693 assert( pHdr->iForeGuard==FOREGUARD ); in sqlite3MemdebugSetType()
17712 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugHasType()
17734 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugNoType()
17988 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3UnlinkFromList()
18007 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Unlink()
18008 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Unlink()
18009 assert( i>=1 ); in memsys3Unlink()
18011 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Unlink()
18012 assert( size>=2 ); in memsys3Unlink()
18026 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3LinkIntoList()
18041 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Link()
18042 assert( i>=1 ); in memsys3Link()
18043 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Link()
18045 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Link()
18046 assert( size>=2 ); in memsys3Link()
18076 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3OutOfMemory()
18092 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Checkout()
18093 assert( i>=1 ); in memsys3Checkout()
18094 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); in memsys3Checkout()
18095 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); in memsys3Checkout()
18109 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FromMaster()
18110 assert( mem3.szMaster>=nBlock ); in memsys3FromMaster()
18122 assert( newi > mem3.iMaster+1 ); in memsys3FromMaster()
18156 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3Merge()
18160 assert( (size&1)==0 ); in memsys3Merge()
18163 assert( i > mem3.aPool[i-1].u.hdr.prevSize ); in memsys3Merge()
18197 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3MallocUnsafe()
18198 assert( sizeof(Mem3Block)==8 ); in memsys3MallocUnsafe()
18204 assert( nBlock>=2 ); in memsys3MallocUnsafe()
18278 assert( sqlite3_mutex_held(mem3.mutex) ); in memsys3FreeUnsafe()
18279 assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); in memsys3FreeUnsafe()
18281 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); in memsys3FreeUnsafe()
18283 assert( i+size<=mem3.nPool+1 ); in memsys3FreeUnsafe()
18319 assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); in memsys3Size()
18339 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ in memsys3Malloc()
18350 assert( pPrior ); in memsys3Free()
18397 assert( sizeof(Mem3Block)==8 ); in memsys3Init()
18448 assert( 0 ); in sqlite3Memsys3Dump()
18453 assert( 0 ); in sqlite3Memsys3Dump()
18458 assert( 0 ); in sqlite3Memsys3Dump()
18676 assert( i>=0 && i<mem5.nBlock ); in memsys5Unlink()
18677 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Unlink()
18678 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Unlink()
18698 assert( sqlite3_mutex_held(mem5.mutex) ); in memsys5Link()
18699 assert( i>=0 && i<mem5.nBlock ); in memsys5Link()
18700 assert( iLogsize>=0 && iLogsize<=LOGMAX ); in memsys5Link()
18701 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); in memsys5Link()
18706 assert( x<mem5.nBlock ); in memsys5Link()
18733 assert( i>=0 && i<mem5.nBlock ); in memsys5Size()
18756 assert( nByte>0 ); in memsys5MallocUnsafe()
18828 assert( iBlock>=0 && iBlock<mem5.nBlock ); in memsys5FreeUnsafe()
18829 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 ); in memsys5FreeUnsafe()
18830 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 ); in memsys5FreeUnsafe()
18834 assert( iBlock+size-1<(u32)mem5.nBlock ); in memsys5FreeUnsafe()
18838 assert( mem5.currentCount>0 ); in memsys5FreeUnsafe()
18839 assert( mem5.currentOut>=(size*mem5.szAtom) ); in memsys5FreeUnsafe()
18842 assert( mem5.currentOut>0 || mem5.currentCount==0 ); in memsys5FreeUnsafe()
18843 assert( mem5.currentCount>0 || mem5.currentOut==0 ); in memsys5FreeUnsafe()
18853 assert( iBuddy>=0 ); in memsys5FreeUnsafe()
18898 assert( pPrior!=0 ); in memsys5Free()
18919 assert( pPrior!=0 ); in memsys5Realloc()
18920 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ in memsys5Realloc()
18921 assert( nBytes>=0 ); in memsys5Realloc()
18992 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 ); in memsys5Init()
18996 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */ in memsys5Init()
19021 assert((iOffset+nAlloc)>mem5.nBlock); in memsys5Init()
19199 assert( GLOBAL(int, mutexIsInit) ); in sqlite3MutexAlloc()
19403 assert( p->cnt==0 ); in debugMutexFree()
19426 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexEnter()
19431 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexTry()
19444 assert( debugMutexHeld(pX) ); in debugMutexLeave()
19446 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexLeave()
19675 assert( p->nRef==0 ); in pthreadMutexFree()
19702 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexEnter()
19721 assert( p->nRef==0 ); in pthreadMutexEnter()
19731 assert( p->nRef>0 || p->owner==0 ); in pthreadMutexEnter()
19745 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexTry()
19764 assert( p->nRef==0 ); in pthreadMutexTry()
19801 assert( pthreadMutexHeld(p) ); in pthreadMutexLeave()
19806 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexLeave()
20374 assert( p );
20375 assert( p->nRef==0 && p->owner==0 );
20402 assert( p );
20403 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20405 assert( p );
20407 assert( winMutex_isInit==1 );
20410 assert( p->nRef>0 || p->owner==0 );
20425 assert( p );
20426 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20439 assert( winMutex_isInit==1 );
20440 assert( winMutex_isNt>=-1 && winMutex_isNt<=1 );
20444 assert( winMutex_isNt==0 || winMutex_isNt==1 );
20474 assert( p );
20476 assert( p->nRef>0 );
20477 assert( p->owner==tid );
20480 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
20482 assert( winMutex_isInit==1 );
20789 assert( sqlite3_mutex_held(mem0.mutex) );
20837 assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */
20880 assert( n>0 );
20900 assert( sqlite3_mutex_notheld(mem0.mutex) );
20909 assert( scratchAllocOut==0 );
20923 assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
20935 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
20940 assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
20941 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) );
20974 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
20979 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
20980 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
20983 assert( sqlite3_mutex_held(db->mutex) );
20987 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
20988 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
20994 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
20995 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
21004 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
21005 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
21030 assert( db==0 || sqlite3_mutex_held(db->mutex) );
21049 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21050 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21051 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
21062 assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
21063 assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
21103 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
21169 assert( db==0 || sqlite3_mutex_held(db->mutex) );
21170 assert( db==0 || db->pnBytesFreed==0 );
21213 assert( db!=0 );
21214 assert( sqlite3_mutex_held(db->mutex) );
21229 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21230 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
21270 assert( (n&0x7fffffff)==n );
21282 assert( (n&0x7fffffff)==n );
21334 assert( !db || sqlite3_mutex_held(db->mutex) );
21483 assert( eError==STRACCUM_NOMEM || eError==STRACCUM_TOOBIG );
21889 assert( precision>0 );
21899 assert( bufpt>zOut );
22041 assert( bArgList==0 );
22052 assert( bArgList==0 );
22053 assert( k>=0 && k<pSrc->nSrc );
22063 assert( xtype==etINVALID );
22093 assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
22125 assert( p->zText!=0 || p->nChar==0 );
22170 assert( z!=0 || N==0 );
22171 assert( p->zText!=0 || p->nChar==0 || p->accError );
22172 assert( N>=0 );
22173 assert( p->accError==0 || p->nAlloc==0 );
22177 assert( p->zText );
22252 assert( db!=0 );
22444 assert( moreToFollow==0 || moreToFollow==1 );
22589 assert( N>0 );
22687 assert( ppThread!=0 );
22688 assert( xTask!=0 );
22690 assert( sqlite3GlobalConfig.bCoreMutex!=0 );
22715 assert( ppOut!=0 );
22752 assert( p!=0 );
22760 assert( p->id==GetCurrentThreadId() );
22762 assert( p->xTask!=0 );
22777 assert( ppThread!=0 );
22778 assert( xTask!=0 );
22807 assert( ppOut!=0 );
22810 assert( p->id==GetCurrentThreadId() );
22812 assert( p->tid==0 );
22814 assert( p->id!=0 && p->id!=GetCurrentThreadId() );
22816 assert( rc!=WAIT_IO_COMPLETION );
22818 assert( bRc );
22852 assert( ppThread!=0 );
22853 assert( xTask!=0 );
22871 assert( ppOut!=0 );
23104 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
23105 assert( pMem->flags&MEM_Str );
23106 assert( pMem->enc!=desiredEnc );
23107 assert( pMem->enc!=0 );
23108 assert( pMem->n>=0 );
23127 assert( rc==SQLITE_NOMEM );
23182 assert( desiredEnc==SQLITE_UTF16BE );
23192 assert( desiredEnc==SQLITE_UTF8 );
23209 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
23243 assert( pMem->n>=0 );
23286 assert( z<=zTerm );
23341 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
23342 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
23343 assert( m.z || db->mallocFailed );
23388 assert( n>0 && n<=4 );
23395 assert( c==t );
23396 assert( (z-zBuf)==n );
23403 assert( n>0 && n<=4 );
23407 assert( c==i );
23408 assert( (z-zBuf)==n );
23415 assert( n>0 && n<=4 );
23419 assert( c==i );
23420 assert( (z-zBuf)==n );
23544 assert( db!=0 );
23571 assert( db!=0 );
23649 assert( z[i] );
23740 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
23748 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
23951 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
23956 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
23992 assert( u<=LARGEST_INT64 );
23999 assert( u<=LARGEST_INT64 );
24007 assert( u-1==LARGEST_INT64 );
24166 assert( n<=9 );
24226 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
24227 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
24432 assert( n>3 && n<=9 );
24484 assert( n>5 && n<=9 );
24527 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
24778 assert( sizeof(x)==8 && sizeof(a)==8 );
24827 assert( pNew!=0 );
24841 assert( pH!=0 );
24967 assert( elem!=0 );
24999 assert( pEntry->count>=0 );
25004 assert( pH->first==0 );
25005 assert( pH->count==0 );
25018 assert( pH!=0 );
25019 assert( pKey!=0 );
25043 assert( pH!=0 );
25044 assert( pKey!=0 );
25064 assert( pH->htsize>0 );
26135 assert( 0 );
26137 assert( p->l_whence==SEEK_SET );
26154 assert( 0 );
26349 assert( zAbsoluteName[0]=='/' );
26388 assert( pId->nRef>0 );
26393 assert( *pp==pId );
26661 assert( unixMutexHeld() );
26665 assert( pInode->pShmNode==0 );
26668 assert( pInode->pPrev->pNext==pInode );
26671 assert( inodeList==pInode );
26675 assert( pInode->pNext->pPrev==pInode );
26703 assert( unixMutexHeld() );
26841 assert( pFile );
26896 assert( unixMutexHeld() );
26897 assert( pInode!=0 );
26903 assert( pInode->nLock==0 );
26990 assert( pFile );
27011 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
27012 assert( eFileLock!=PENDING_LOCK );
27013 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
27036 assert( eFileLock==SHARED_LOCK );
27037 assert( pFile->eFileLock==0 );
27038 assert( pInode->nShared>0 );
27072 assert( pInode->nShared==0 );
27073 assert( pInode->eFileLock==0 );
27074 assert( rc==SQLITE_OK );
27113 assert( 0!=pFile->eFileLock );
27116 assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
27199 assert( pFile );
27204 assert( eFileLock<=SHARED_LOCK );
27210 assert( pInode->nShared!=0 );
27212 assert( pInode->eFileLock==pFile->eFileLock );
27238 assert( handleNFSUnlock==0 );
27304 lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
27338 assert( pInode->nLock>=0 );
27359 assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
27424 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
27528 assert( pFile );
27627 assert( pFile );
27630 assert( eFileLock<=SHARED_LOCK );
27646 assert( eFileLock==NO_LOCK );
27723 assert( pFile );
27802 assert( pFile );
27845 assert( pFile );
27848 assert( eFileLock<=SHARED_LOCK );
27915 assert( pFile );
28012 assert( pFile );
28013 assert( pSem );
28016 assert( eFileLock<=SHARED_LOCK );
28049 assert( pFile );
28158 assert( pFile );
28226 assert( pFile );
28246 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
28247 assert( eFileLock!=PENDING_LOCK );
28248 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
28271 assert( eFileLock==SHARED_LOCK );
28272 assert( pFile->eFileLock==0 );
28273 assert( pInode->nShared>0 );
28302 assert( pInode->nShared==0 );
28303 assert( pInode->eFileLock==0 );
28342 assert( 0!=pFile->eFileLock );
28412 assert( pFile );
28417 assert( eFileLock<=SHARED_LOCK );
28423 assert( pInode->nShared!=0 );
28425 assert( pInode->eFileLock==pFile->eFileLock );
28439 assert( pFile->inNormalWrite==0
28490 assert( pInode->nLock>=0 );
28591 assert( cnt==(cnt&0x1ffff) );
28592 assert( id->h>2 );
28646 assert( id );
28647 assert( offset>=0 );
28648 assert( amt>0 );
28653 assert( pFile->pUnused==0
28706 assert( nBuf==(nBuf&0x1ffff) );
28707 assert( fd>2 );
28760 assert( id );
28761 assert( amt>0 );
28766 assert( pFile->pUnused==0
29019 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
29028 assert( pFile );
29063 assert( pFile );
29113 assert( id );
29182 assert( iWrite>=buf.st_size );
29183 assert( (iWrite/nBlk)==((buf.st_size+nBlk-1)/nBlk) );
29184 assert( ((iWrite+1)%nBlk)==0 );
29564 assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
29567 assert( n==1 || lockType!=F_RDLCK );
29570 assert( n>=1 && n<SQLITE_SHM_NLOCK );
29602 assert( lockType==F_WRLCK );
29613 assert( lockType==F_WRLCK );
29637 assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */
29650 assert( unixMutexHeld() );
29654 assert( p->pInode==pFd->pInode );
29720 assert( pDbFd->pShm==0 );
29878 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
29879 assert( pShmNode->pInode==pDbFd->pInode );
29880 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
29881 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
29923 assert( (nByte % pgsz)==0 );
30005 assert( pShmNode==pDbFd->pInode->pShmNode );
30006 assert( pShmNode->pInode==pDbFd->pInode );
30007 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
30008 assert( n>=1 );
30009 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
30013 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
30014 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
30015 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
30018 assert( n>1 || mask==(1<<ofst) );
30026 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
30087 assert( (p->sharedMask & mask)==0 );
30133 assert( pShmNode==pDbFd->pInode->pShmNode );
30134 assert( pShmNode->pInode==pDbFd->pInode );
30150 assert( pShmNode->nRef>0 );
30176 assert( pFd->nFetchOut==0 );
30211 assert( pFd->nFetchOut==0 );
30212 assert( nNew>pFd->mmapSize );
30213 assert( nNew<=pFd->mmapSizeMax );
30214 assert( nNew>0 );
30215 assert( pFd->mmapSizeActual>=pFd->mmapSize );
30216 assert( MAP_FAILED!=0 );
30294 assert( nMap>=0 || pFd->nFetchOut==0 );
30372 assert( (p==0)==(pFd->nFetchOut==0) );
30375 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
30383 assert( pFd->nFetchOut>=0 );
30705 assert( pNew->pInode==NULL );
30712 assert( zFilename==0 || zFilename[0]=='/'
30715 assert( zFilename==0 || zFilename[0]=='/' );
30719 assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
30823 assert( zFilename!=0 );
31072 assert( nDb>0 );
31073 assert( zPath[nDb]!='\n' );
31165 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
31166 assert(isCreate==0 || isReadWrite);
31167 assert(isExclusive==0 || isCreate);
31168 assert(isDelete==0 || isCreate);
31172 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
31173 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
31174 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
31175 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
31178 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
31212 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
31216 assert(isDelete && !syncDir);
31225 assert( zName[strlen(zName)+1]==0 );
31244 assert( !p->pUnused );
31245 assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
31272 assert( fd>=0 );
31445 assert(!"Invalid flags argument");
31481 assert( pVfs->mxPathname==MAX_PATHNAME );
31566 assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
31591 assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
31936 assert(lockPath!=NULL);
32069 assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
32198 assert( nTries>1 );
32224 assert( nTries==3 );
32526 assert( (int)strlen(conchPath) == len+7 );
32576 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
32588 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
32742 assert( 0 ); /* The call assures that only valid opcodes are sent */
32989 assert( ArraySize(aSyscall)==25 );
33594 #define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 )
33595 #define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 )
34405 assert( hHeap!=0 );
34406 assert( hHeap!=INVALID_HANDLE_VALUE );
34408 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
34455 assert( winMemGetHeap()!=NULL );
34456 assert( winMemGetOwned() );
34457 assert( sqlite3_memory_used()==0 );
34459 assert( winMemGetHeap()==NULL );
34460 assert( !winMemGetOwned() );
34461 assert( sqlite3_memory_used()==0 );
34463 assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
34464 assert( rc!=SQLITE_OK || winMemGetOwned() );
34465 assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
34487 assert( nMin==-1 || nMin==0 || nMin<SQLITE_WIN32_DBG_BUF_SIZE );
34529 assert( sleepObj!=NULL );
34617 assert( hHeap!=0 );
34618 assert( hHeap!=INVALID_HANDLE_VALUE );
34620 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
34622 assert( nBytes>=0 );
34639 assert( hHeap!=0 );
34640 assert( hHeap!=INVALID_HANDLE_VALUE );
34642 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
34660 assert( hHeap!=0 );
34661 assert( hHeap!=INVALID_HANDLE_VALUE );
34663 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
34665 assert( nBytes>=0 );
34688 assert( hHeap!=0 );
34689 assert( hHeap!=INVALID_HANDLE_VALUE );
34691 assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) );
34717 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
34718 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
34739 assert( pWinMemData->bOwned );
34749 assert( !pWinMemData->bOwned );
34751 assert( pWinMemData->hHeap!=0 );
34752 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
34754 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
34766 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
34767 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
34770 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
34772 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
34974 assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE
34977 assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) );
35101 assert( errcode!=SQLITE_OK );
35464 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
35472 assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE
35667 assert( id!=0 );
35669 assert( pFile->pShm==0 );
35671 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
35727 assert( id!=0 );
35728 assert( amt>0 );
35729 assert( offset>=0 );
35804 assert( amt>0 );
35805 assert( pFile );
35861 assert( nWrite==0 || nWrite<=(DWORD)nRem );
35908 assert( pFile );
35978 assert( pFile );
35980 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
36049 assert( id!=0 );
36050 assert( pSize!=0 );
36213 assert( id!=0 );
36228 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
36229 assert( locktype!=PENDING_LOCK );
36230 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
36271 assert( pFile->locktype==NO_LOCK );
36283 assert( pFile->locktype==SHARED_LOCK );
36302 assert( pFile->locktype>=SHARED_LOCK );
36350 assert( id!=0 );
36383 assert( pFile!=0 );
36384 assert( locktype<=SHARED_LOCK );
36702 assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
36744 assert( winShmMutexHeld() );
36797 assert( pDbFd->pShm==0 ); /* Not previously opened */
36929 assert( pShmNode->nRef>0 );
36955 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
36956 assert( n>=1 );
36957 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
36961 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
36964 assert( n>1 || mask==(1<<ofst) );
36972 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
37033 assert( (p->sharedMask & mask)==0 );
37099 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
37220 assert( pFile!=0 );
37273 assert( nMap>=0 || pFd->nFetchOut==0 );
37325 assert( (nMap % winSysInfo.dwPageSize)==0 );
37326 assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff );
37414 assert( (p==0)==(pFd->nFetchOut==0) );
37417 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
37432 assert( pFd->nFetchOut>=0 );
37576 assert( nDir>0 );
37858 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
37859 assert(isCreate==0 || isReadWrite);
37860 assert(isExclusive==0 || isCreate);
37861 assert(isDelete==0 || isCreate);
37865 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
37866 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
37867 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
37868 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
37871 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
37877 assert( pFile!=0 );
37892 assert( isDelete && !isOpenJournal );
37905 assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
38268 assert(!"Invalid flags argument");
38338 assert( nFull>=pVfs->mxPathname );
38811 assert( ArraySize(aSyscall)==80 );
38820 assert( winSysInfo.dwAllocationGranularity>0 );
38821 assert( winSysInfo.dwPageSize>0 );
38960 assert( sizeof(*p)==BITVEC_SZ );
39012 assert( i>0 );
39013 assert( i<=p->iSize );
39082 assert( i>0 );
39304 assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
39305 assert( pPage->pDirtyPrev || pPage==p->pDirty );
39319 assert( pPage==p->pDirtyTail );
39325 assert( pPage==p->pDirty );
39328 assert( p->eCreate==1 );
39336 assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
39340 assert( pPage->pDirtyNext->pDirtyPrev==0 );
39345 assert( p->eCreate==2 );
39444 assert( pCache->nRef==0 && pCache->pDirty==0 );
39494 assert( pCache!=0 );
39495 assert( pCache->pCache!=0 );
39496 assert( createFlag==3 || createFlag==0 );
39497 assert( pgno>0 );
39507 assert( eCreate==0 || eCreate==1 || eCreate==2 );
39508 assert( createFlag==0 || pCache->eCreate==eCreate );
39509 assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) );
39579 assert( pPage!=0 );
39581 assert( pPgHdr->pPage==0 );
39626 assert( p->nRef>0 );
39643 assert(p->nRef>0);
39653 assert( p->nRef==1 );
39670 assert( p->nRef>0 );
39717 assert( p->nRef>0 );
39718 assert( newPgno>0 );
39745 assert( p->pgno>0 );
39747 assert( p->flags&PGHDR_DIRTY );
39763 assert( pCache->pCache!=0 );
39873 assert( pCache->pCache!=0 );
39890 assert( pCache->pCache!=0 );
39900 assert( pCache->pCache!=0 );
40122 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
40130 assert( pcache1.nFreeSlot>=0 );
40170 assert( pcache1.nFreeSlot<=pcache1.nSlot );
40173 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
40195 assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
40214 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
40251 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
40317 assert( sqlite3_mutex_held(p->pGroup->mutex) );
40357 assert( pPage!=0 );
40358 assert( pPage->isPinned==0 );
40361 assert( pPage->pLruNext || pPage==pGroup->pLruTail );
40362 assert( pPage->pLruPrev || pPage==pGroup->pLruHead );
40363 assert( sqlite3_mutex_held(pGroup->mutex) );
40392 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
40405 assert( sqlite3_mutex_held(pGroup->mutex) );
40408 assert( p->pCache->pGroup==pGroup );
40409 assert( p->isPinned==0 );
40429 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
40445 assert( pCache->nPage==nPage );
40456 assert( pcache1.isInit==0 );
40474 assert( pcache1.isInit!=0 );
40509 assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
40510 assert( szExtra < 300 );
40610 assert( pCache->nPage >= pCache->nRecyclable );
40612 assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
40613 assert( pCache->n90pct == pCache->nMax*9/10 );
40623 assert( pCache->nHash>0 && pCache->apHash );
40633 assert( pPage->isPinned==0 );
40640 assert( (pCache->szPage & (pCache->szPage-1))==0 && pCache->szPage>=512 );
40641 assert( pCache->szExtra<512 );
40642 assert( (pOther->szPage & (pOther->szPage-1))==0 && pOther->szPage>=512 );
40643 assert( pOther->szExtra<512 );
40742 assert( offsetof(PgHdr1,page)==0 );
40743 assert( pCache->bPurgeable || createFlag!=1 );
40744 assert( pCache->bPurgeable || pCache->nMin==0 );
40745 assert( pCache->bPurgeable==0 || pCache->nMin==10 );
40746 assert( pCache->nMin==0 || pCache->bPurgeable );
40747 assert( pCache->nHash>0 );
40761 assert( pPage==0 || pCache->iMaxKey>=iKey );
40781 assert( pPage->pCache==pCache );
40787 assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
40788 assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
40789 assert( pPage->isPinned==1 );
40824 assert( pPage->iKey==iOld );
40825 assert( pPage->pCache==pCache );
40872 assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
40875 assert( pGroup->nMaxPage >= pCache->nMax );
40877 assert( pGroup->nMinPage >= pCache->nMin );
40935 assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
40936 assert( sqlite3_mutex_notheld(pcache1.mutex) );
40945 assert( p->isPinned==0 );
40970 assert( p->isPinned==0 );
41119 assert( N >= ROUND8(sizeof(*p)) );
41161 assert( p!=0 );
41188 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
41221 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
41222 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
41236 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
41239 assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v );
41282 assert( pIn!=0 );
41295 assert( (*ppLast)->pRight==0 );
41347 assert( pList!=0 );
41370 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
41380 assert( p->pForest==0 );
41404 assert( p!=0 );
41434 assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 );
42472 assert( p->eState==PAGER_OPEN
42485 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
42486 assert( p->tempFile==0 || pPager->changeCountDone );
42491 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
42492 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
42503 assert( p->noSync );
42504 assert( p->journalMode==PAGER_JOURNALMODE_OFF
42507 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
42508 assert( pagerUseWal(p)==0 );
42514 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
42515 assert( p->eLock!=PENDING_LOCK );
42519 assert( !MEMDB );
42520 assert( pPager->errCode==SQLITE_OK );
42521 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
42525 assert( pPager->errCode==SQLITE_OK );
42526 assert( p->eLock!=UNKNOWN_LOCK );
42527 assert( p->eLock>=SHARED_LOCK );
42531 assert( p->eLock!=UNKNOWN_LOCK );
42532 assert( pPager->errCode==SQLITE_OK );
42534 assert( p->eLock>=RESERVED_LOCK );
42536 assert( pPager->dbSize==pPager->dbOrigSize );
42537 assert( pPager->dbOrigSize==pPager->dbFileSize );
42538 assert( pPager->dbOrigSize==pPager->dbHintSize );
42539 assert( pPager->setMaster==0 );
42543 assert( p->eLock!=UNKNOWN_LOCK );
42544 assert( pPager->errCode==SQLITE_OK );
42551 assert( p->eLock>=RESERVED_LOCK );
42552 assert( isOpen(p->jfd)
42557 assert( pPager->dbOrigSize==pPager->dbFileSize );
42558 assert( pPager->dbOrigSize==pPager->dbHintSize );
42562 assert( p->eLock==EXCLUSIVE_LOCK );
42563 assert( pPager->errCode==SQLITE_OK );
42564 assert( !pagerUseWal(pPager) );
42565 assert( p->eLock>=EXCLUSIVE_LOCK );
42566 assert( isOpen(p->jfd)
42570 assert( pPager->dbOrigSize<=pPager->dbHintSize );
42574 assert( p->eLock==EXCLUSIVE_LOCK );
42575 assert( pPager->errCode==SQLITE_OK );
42576 assert( !pagerUseWal(pPager) );
42577 assert( isOpen(p->jfd)
42588 assert( pPager->errCode!=SQLITE_OK );
42589 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
42722 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
42723 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
42724 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
42726 assert( pPager->eLock>=eLock );
42749 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
42779 assert( !MEMDB );
42785 assert( isOpen(pPager->fd) );
42790 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
42791 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
42833 assert( pPager->eState!=PAGER_ERROR );
42834 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
42929 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
42930 assert( offset>=c );
42931 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
42958 assert( isOpen(pPager->jfd) );
43012 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
43050 assert( isOpen(pPager->fd) || pPager->noSync );
43099 assert( pPager->journalHdr <= pPager->journalOff );
43134 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
43255 assert( pPager->setMaster==0 );
43256 assert( !pagerUseWal(pPager) );
43265 assert( pPager->journalHdr <= pPager->journalOff );
43325 assert( pPager->eState>PAGER_OPEN );
43362 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
43387 assert( pPager->eState==PAGER_READER
43397 assert( !isOpen(pPager->jfd) );
43409 assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
43410 assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
43411 assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
43412 assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
43413 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
43414 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
43435 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
43446 assert( !MEMDB );
43480 assert( rc==SQLITE_OK || !MEMDB );
43481 assert(
43565 assert( assert_pager_state(pPager) );
43566 assert( pPager->eState!=PAGER_ERROR );
43572 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
43574 assert( !pagerUseWal(pPager) );
43578 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
43607 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
43641 assert( rc2==SQLITE_OK );
43649 assert( pPager->eLock==EXCLUSIVE_LOCK );
43689 assert( assert_pager_state(pPager) );
43695 assert( pPager->eState==PAGER_READER );
43798 assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
43799 assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
43800 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
43801 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
43804 assert( aData ); /* Temp storage must have already been allocated */
43805 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
43813 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
43816 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
43834 assert( !isSavepnt );
43902 assert( pPg || !MEMDB );
43903 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
43919 assert( !pagerUseWal(pPager) );
43946 assert( isSavepnt );
43947 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
43950 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
43987 assert( !pagerUseWal(pPager) );
44131 assert( !isOpen(pJournal) );
44160 assert( pPager->eState!=PAGER_ERROR );
44161 assert( pPager->eState!=PAGER_READER );
44168 assert( pPager->eLock==EXCLUSIVE_LOCK );
44199 assert( MAX_SECTOR_SIZE>=512 );
44229 assert( isOpen(pPager->fd) || pPager->tempFile );
44316 assert( isOpen(pPager->jfd) );
44369 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
44438 assert( 0 );
44515 assert( pPager->eState>=PAGER_READER && !MEMDB );
44516 assert( isOpen(pPager->fd) );
44603 assert( pagerUseWal(pPager) );
44679 assert( pPager->pWal );
44680 assert( pList );
44684 assert( p->pgno < p->pDirty->pgno );
44688 assert( pList->pDirty==0 || isCommit );
44702 assert( pList );
44740 assert( pagerUseWal(pPager) );
44741 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
44778 assert( pPager->eState==PAGER_OPEN );
44779 assert( pPager->eLock>=SHARED_LOCK );
44790 assert( isOpen(pPager->fd) || pPager->tempFile );
44833 assert( pPager->eState==PAGER_OPEN );
44834 assert( pPager->eLock>=SHARED_LOCK );
44906 assert( pPager->eState!=PAGER_ERROR );
44907 assert( pPager->eState>=PAGER_WRITER_LOCKED );
44933 assert( pagerUseWal(pPager)==0 || szJ==0 );
44948 assert( rc!=SQLITE_DONE );
44963 assert( rc!=SQLITE_DONE );
44978 assert( rc!=SQLITE_DONE );
44980 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
44994 assert( offset==(i64)ii*(4+pPager->pageSize) );
44997 assert( rc!=SQLITE_DONE );
45097 assert( level>=1 && level<=3 );
45163 assert( rc!=SQLITE_OK || isOpen(pFile) );
45198 assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
45199 assert( ap[1]==pBusyHandlerArg );
45248 assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
45281 assert( nReserve>=0 && nReserve<1000 );
45312 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
45313 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
45358 assert( isOpen(pPager->fd) || pPager->tempFile );
45364 assert( !pagerUseWal(pPager) );
45384 assert( pPager->eState>=PAGER_READER );
45385 assert( pPager->eState!=PAGER_WRITER_FINISHED );
45412 assert( (pPager->eLock>=locktype)
45447 assert( pPg->flags&PGHDR_DIRTY );
45448 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
45469 assert( pPager->dbSize>=nPage );
45470 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
45545 assert( p->pExtra==(void *)&p[1] );
45546 assert( p->pPage==0 );
45547 assert( p->flags==PGHDR_MMAP );
45548 assert( p->pPager==pPager );
45549 assert( p->nRef==1 );
45568 assert( pPager->fd->pMethods->iVersion>=3 );
45602 assert( assert_pager_state(pPager) );
45645 assert( !pPager->aSavepoint && !pPager->pInJournal );
45646 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
45706 assert( pPager->eState==PAGER_WRITER_CACHEMOD
45709 assert( assert_pager_state(pPager) );
45710 assert( !pagerUseWal(pPager) );
45716 assert( !pPager->tempFile );
45719 assert( isOpen(pPager->jfd) );
45810 assert( assert_pager_state(pPager) );
45850 assert( !pagerUseWal(pPager) );
45851 assert( pPager->eState==PAGER_WRITER_DBMOD );
45852 assert( pPager->eLock==EXCLUSIVE_LOCK );
45859 assert( pPager->tempFile && rc==SQLITE_OK );
45866 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
45891 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
45968 assert( pPager->useJournal );
45969 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
45970 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
45971 assert( pagerUseWal(pPager)
45994 assert( pPager->nSavepoint>0 );
46023 assert( pPg->pPager==pPager );
46024 assert( pPg->flags&PGHDR_DIRTY );
46106 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
46224 assert( nUri>=0 );
46263 assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
46274 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
46278 assert( nPathname>0 );
46301 assert( !memDb );
46316 assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
46327 assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
46328 assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
46329 assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
46368 assert( pPager->memDb==0 );
46375 assert( nExtra<1000 );
46404 assert( tempFile==PAGER_LOCKINGMODE_NORMAL
46406 assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
46411 assert( useJournal || pPager->tempFile );
46414 assert( pPager->fullSync==0 );
46415 assert( pPager->syncFlags==0 );
46416 assert( pPager->walSyncFlags==0 );
46417 assert( pPager->ckptSyncFlags==0 );
46429 assert( isOpen(pPager->fd) || tempFile );
46458 assert( pPager->zFilename && pPager->zFilename[0] );
46509 assert( pPager->useJournal );
46510 assert( isOpen(pPager->fd) );
46511 assert( pPager->eState==PAGER_OPEN );
46513 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
46630 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
46631 assert( assert_pager_state(pPager) );
46632 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
46638 assert( !MEMDB );
46642 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
46702 assert( !pPager->tempFile );
46704 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
46721 assert( rc==SQLITE_OK );
46752 assert( pPager->eState==PAGER_OPEN );
46753 assert( (pPager->eLock==SHARED_LOCK)
46811 assert( pPager->pWal==0 || rc==SQLITE_OK );
46816 assert( rc==SQLITE_OK );
46826 assert( !MEMDB );
46828 assert( pPager->eState==PAGER_OPEN );
46921 assert( pPager->eState>=PAGER_READER );
46922 assert( assert_pager_state(pPager) );
46923 assert( noContent==0 || bMmapOk==0 );
46957 assert( rc==SQLITE_OK );
46986 assert( (*ppPage)->pgno==pgno );
46987 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
46992 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
47038 assert( pPg->pPager==pPager );
47051 assert( rc!=SQLITE_OK );
47074 assert( pPager!=0 );
47075 assert( pgno!=0 );
47076 assert( pPager->pPCache!=0 );
47078 assert( pPage==0 || pPager->hasBeenUsed );
47092 assert( pPg!=0 );
47131 assert( pPager->eState==PAGER_WRITER_LOCKED );
47132 assert( assert_pager_state(pPager) );
47133 assert( pPager->pInJournal==0 );
47171 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
47192 assert( pPager->eState==PAGER_WRITER_LOCKED );
47220 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
47224 assert( pPager->pInJournal==0 );
47273 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
47274 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
47275 assert( assert_pager_state(pPager) );
47298 assert( pPager->eState==PAGER_WRITER_LOCKED
47302 assert( assert_pager_state(pPager) );
47303 assert( pPager->errCode==0 );
47304 assert( pPager->readOnly==0 );
47321 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
47322 assert( assert_pager_state(pPager) );
47330 assert( !pagerUseWal(pPager) );
47338 assert( pagerUseWal(pPager)==0 );
47347 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
47349 assert( pPager->journalHdr<=pPager->journalOff );
47378 assert( pPager->pInJournal!=0 );
47381 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
47384 assert( rc==SQLITE_NOMEM );
47440 assert( !MEMDB );
47441 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
47458 assert(nPage>0);
47459 assert(pg1<=pPg->pgno);
47460 assert((pg1+nPage)>pPg->pgno);
47491 assert( !MEMDB );
47501 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
47521 assert( (pPg->flags & PGHDR_MMAP)==0 );
47522 assert( pPg->pPager->eState>=PAGER_WRITER_LOCKED );
47523 assert( pPg->pPager->eState!=PAGER_ERROR );
47524 assert( assert_pager_state(pPg->pPager) );
47592 assert( pPager->eState==PAGER_WRITER_CACHEMOD
47595 assert( assert_pager_state(pPager) );
47609 assert( isDirectMode==0 );
47618 assert( !pPager->tempFile && isOpen(pPager->fd) );
47622 assert( pPgHdr==0 || rc==SQLITE_OK );
47640 assert( pPager->dbFileSize>0 );
47681 assert( !MEMDB );
47700 assert( pPager->eState==PAGER_WRITER_CACHEMOD
47704 assert( assert_pager_state(pPager) );
47744 assert( pPager->eState==PAGER_WRITER_LOCKED
47749 assert( assert_pager_state(pPager) );
47777 assert( rc==SQLITE_OK );
47811 assert( isOpen(pPager->jfd)
47861 assert( rc!=SQLITE_IOERR_BLOCKED );
47874 assert( pPager->eState==PAGER_WRITER_DBMOD );
47918 assert( pPager->eState==PAGER_WRITER_LOCKED
47922 assert( assert_pager_state(pPager) );
47939 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
47984 assert( assert_pager_state(pPager) );
48009 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
48010 assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
48085 assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
48090 assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
48091 assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
48092 assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 && PAGER_STAT_WRITE==2 );
48121 assert( pPager->eState>=PAGER_WRITER_LOCKED );
48122 assert( assert_pager_state(pPager) );
48159 assert( pPager->nSavepoint==nSavepoint );
48199 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
48200 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
48223 assert( rc==SQLITE_OK );
48236 assert(rc!=SQLITE_DONE);
48363 assert( pPg->nRef>0 );
48364 assert( pPager->eState==PAGER_WRITER_CACHEMOD
48367 assert( assert_pager_state(pPager) );
48415 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
48417 assert( pPg->flags&PGHDR_DIRTY );
48427 assert( !pPgOld || pPgOld->nRef==1 );
48448 assert( pPgOld );
48472 assert( pPager->pTmpSpace!=0 );
48493 assert( pPg->pgno!=iNew );
48502 assert( pPg->nRef>0 || pPg->pPager->memDb );
48525 assert( eMode==PAGER_LOCKINGMODE_QUERY
48528 assert( PAGER_LOCKINGMODE_QUERY<0 );
48529 assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
48530 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
48568 assert( eMode==PAGER_JOURNALMODE_DELETE
48579 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
48585 assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
48594 assert( pPager->eState!=PAGER_ERROR );
48601 assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
48602 assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
48603 assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
48604 assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
48605 assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
48606 assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
48608 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
48625 assert( state==PAGER_OPEN || state==PAGER_READER );
48630 assert( rc==SQLITE_OK );
48641 assert( state==pPager->eState );
48665 assert( assert_pager_state(pPager) );
48745 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
48765 assert( pPager->pWal==0 && pPager->tempFile==0 );
48766 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
48813 assert( assert_pager_state(pPager) );
48814 assert( pPager->eState==PAGER_OPEN || pbOpen );
48815 assert( pPager->eState==PAGER_READER || !pbOpen );
48816 assert( pbOpen==0 || *pbOpen==0 );
48817 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
48849 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
48894 assert( pPager->eState>=PAGER_READER );
49455 assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
49463 assert( pWal->nWiData>0 && pWal->apWiData[0] );
49471 assert( pWal->nWiData>0 && pWal->apWiData[0] );
49514 assert( nByte>=8 );
49515 assert( (nByte&0x00000007)==0 );
49549 assert( pWal->writeLock );
49580 assert( WAL_FRAME_HDRSIZE==24 );
49608 assert( WAL_FRAME_HDRSIZE==24 );
49718 assert( iPage>0 );
49719 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
49751 assert( rc==SQLITE_OK || iHash>0 );
49780 assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
49820 assert( pWal->writeLock );
49831 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
49832 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
49839 assert( iLimit>0 );
49863 assert( aHash[iKey]==i );
49891 assert( idx <= HASHTABLE_NSLOT/2 + 1 );
49909 assert( !aPgno[idx] );
49928 assert( nEntry==idx );
49942 assert( aHash[iKey]==i );
49976 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
49977 assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
49978 assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
49979 assert( pWal->writeLock );
50168 assert( zWalName && zWalName[0] );
50169 assert( pDbFd );
50176 assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
50179 assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
50250 assert( iMin<0xffffffff );
50307 assert( nLeft>0 && nRight>0 );
50324 assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
50325 assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );
50369 assert( nList<=HASHTABLE_NPAGE && nList>0 );
50370 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
50377 assert( p->aList && p->nList<=(1<<iSub) );
50378 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
50388 assert( p->nList<=(1<<iSub) );
50389 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
50393 assert( aMerge==aList );
50400 assert( aContent[aList[i]] > aContent[aList[i-1]] );
50437 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
50558 assert( pInfo->aReadMark[0]==0 );
50621 assert( pIter );
50625 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
50645 assert( y<=pWal->hdr.mxFrame );
50685 assert( walFramePgno(pWal, iFrame)==iDbpage );
50731 assert( pWal->writeLock );
50737 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
50873 assert( pWal->nWiData>0 && pWal->apWiData[0] );
50933 assert( pChanged );
50938 assert( page0 || pWal->writeLock==0 );
50950 assert( badHdr==0 || pWal->writeLock==0 );
51049 assert( pWal->readLock<0 ); /* Not currently locked */
51152 assert( thisMark!=READMARK_NOT_USED );
51175 assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
51210 assert( mxReadMark<=pWal->hdr.mxFrame );
51275 assert( pWal->readLock>=0 || pWal->lockError );
51329 assert( iFrame>iRead || CORRUPT_DB );
51351 assert( iRead==iRead2 );
51410 assert( pWal->readLock>=0 );
51489 assert( walFramePgno(pWal, iFrame)!=1 );
51504 assert( pWal->writeLock );
51520 assert( pWal->writeLock );
51521 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
51560 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
51588 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
51631 assert( p->syncFlags & (SQLITE_SYNC_NORMAL|SQLITE_SYNC_FULL) );
51685 assert( pList );
51686 assert( pWal->writeLock );
51690 assert( (isCommit!=0)==(nTruncate!=0) );
51749 assert( (int)pWal->szPage==szPage );
51764 assert( iOffset==walFrameOffset(iFrame, szPage) );
51877 assert( pWal->ckptLock==0 );
51878 assert( pWal->writeLock==0 );
51882 assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
52004 assert( pWal->writeLock==0 );
52005 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
52013 assert( pWal->readLock>=0 || pWal->lockError );
52014 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
52028 assert( pWal->exclusiveMode==0 );
52029 assert( pWal->readLock>=0 );
52055 assert( pWal==0 || pWal->readLock>=0 );
52715 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
52716 assert( p->pBt->inTransaction>=p->inTrans );
52776 assert( p->locked==0 );
52777 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
52778 assert( sqlite3_mutex_held(p->db->mutex) );
52791 assert( p->locked==1 );
52792 assert( sqlite3_mutex_held(pBt->mutex) );
52793 assert( sqlite3_mutex_held(p->db->mutex) );
52794 assert( p->db==pBt->db );
52824 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
52825 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
52826 assert( p->pNext==0 || p->pNext->db==p->db );
52827 assert( p->pPrev==0 || p->pPrev->db==p->db );
52828 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
52831 assert( !p->locked || p->wantToLock>0 );
52832 assert( p->sharable || p->wantToLock==0 );
52835 assert( sqlite3_mutex_held(p->db->mutex) );
52839 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
52872 assert( pLater->sharable );
52873 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
52874 assert( !pLater->locked || pLater->wantToLock>0 );
52892 assert( sqlite3_mutex_held(p->db->mutex) );
52894 assert( p->wantToLock>0 );
52910 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
52911 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
52912 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
52913 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
52952 assert( sqlite3_mutex_held(db->mutex) );
52961 assert( sqlite3_mutex_held(db->mutex) );
53014 assert( db!=0 );
53016 assert( iDb>=0 && iDb<db->nDb );
53020 assert( p!=0 );
53302 assert( sqlite3BtreeHoldsMutex(p) );
53303 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
53304 assert( p->db!=0 );
53305 assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
53311 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
53312 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
53337 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
53338 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
53342 assert( p==pBt->pWriter );
53375 assert( sqlite3BtreeHoldsMutex(p) );
53376 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
53377 assert( p->db!=0 );
53383 assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
53387 assert( p->sharable );
53388 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
53416 assert( WRITE_LOCK>READ_LOCK );
53438 assert( sqlite3BtreeHoldsMutex(p) );
53439 assert( p->sharable || 0==*ppIter );
53440 assert( p->inTrans>0 );
53444 assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
53445 assert( pLock->pBtree->inTrans>=pLock->eLock );
53448 assert( pLock->iTable!=1 || pLock==&p->lock );
53457 assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
53485 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
53518 assert( sqlite3_mutex_held(pBt->mutex) );
53545 assert( sqlite3BtreeHoldsMutex(pBtree) );
53598 assert( pgno<=pBt->nPage );
53654 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
53655 assert( 0==pCur->pKey );
53656 assert( cursorHoldsMutex(pCur) );
53664 assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
53685 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
53713 assert( sqlite3_mutex_held(pBt->mutex) );
53714 assert( pExcept==0 || pExcept->pBt==pBt );
53752 assert( cursorHoldsMutex(pCur) );
53776 assert( nKey==(i64)(int)nKey );
53806 assert( cursorHoldsMutex(pCur) );
53807 assert( pCur->eState>=CURSOR_REQUIRESEEK );
53816 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
53862 assert( pCur!=0 );
53863 assert( pCur->eState!=CURSOR_VALID );
53872 assert( pCur->skipNext==0 );
53891 assert( sqlite3_mutex_held(pBt->mutex) );
53921 assert( sqlite3_mutex_held(pBt->mutex) );
53923 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
53925 assert( pBt->autoVacuum );
53941 assert( offset <= (int)pBt->usableSize-5 );
53971 assert( sqlite3_mutex_held(pBt->mutex) );
53985 assert( offset <= (int)pBt->usableSize-5 );
53986 assert( pEType!=0 );
54019 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54047 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54048 assert( pPage->leaf==0 || pPage->leaf==1 );
54050 assert( pPage->childPtrSize==0 );
54054 assert( pPage->childPtrSize==4 );
54137 assert( pPage->childPtrSize==4 );
54171 assert( nSize==debuginfo.nSize || CORRUPT_DB );
54192 assert( pCell!=0 );
54229 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54230 assert( pPage->pBt!=0 );
54231 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
54232 assert( pPage->nOverflow==0 );
54233 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54239 assert( nCell==get2byte(&data[hdr+3]) );
54258 assert( pc>=iCellFirst && pc<=iCellLast );
54270 assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
54284 assert( cbrk>=iCellFirst );
54290 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54380 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54381 assert( pPage->pBt );
54382 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54383 assert( nByte>=0 ); /* Minimum cell size is 4 */
54384 assert( pPage->nFree>=nByte );
54385 assert( pPage->nOverflow==0 );
54386 assert( nByte < (int)(pPage->pBt->usableSize-8) );
54388 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
54390 assert( gap<=65536 );
54412 assert( pSpace>=data && (pSpace - data)<65536 );
54424 assert( pPage->nCell>0 || CORRUPT_DB );
54428 assert( gap+nByte<=top );
54440 assert( top+nByte <= (int)pPage->pBt->usableSize );
54468 assert( pPage->pBt!=0 );
54469 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54470 assert( iStart>=pPage->hdrOffset+6+pPage->childPtrSize );
54471 assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize );
54472 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54473 assert( iSize>=4 ); /* Minimum cell size is 4 */
54474 assert( iStart<=iLast );
54495 assert( iFreeBlk>iPtr || iFreeBlk==0 );
54559 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
54560 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54561 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
54568 assert( (PTF_LEAFDATA|PTF_INTKEY)==5 );
54571 assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 );
54580 assert( (PTF_ZERODATA)==2 );
54583 assert( (PTF_ZERODATA|PTF_LEAF)==10 );
54609 assert( pPage->pBt!=0 );
54610 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54611 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
54612 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
54613 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
54634 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
54657 assert( pPage->nCell>0 || top==usableSize || CORRUPT_DB );
54744 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
54745 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
54746 assert( sqlite3PagerGetData(pPage->pDbPage) == data );
54747 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54748 assert( sqlite3_mutex_held(pBt->mutex) );
54763 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
54804 assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY );
54805 assert( sqlite3_mutex_held(pBt->mutex) );
54819 assert( sqlite3_mutex_held(pBt->mutex) );
54835 assert( sqlite3BtreeHoldsMutex(p) );
54836 assert( ((p->pBt->nPage)&0x8000000)==0 );
54855 assert( sqlite3_mutex_held(pBt->mutex) );
54856 assert( bReadonly==PAGER_GET_READONLY || bReadonly==0 );
54871 assert( pgno!=0 || rc==SQLITE_CORRUPT );
54881 assert( pPage->aData );
54882 assert( pPage->pBt );
54883 assert( pPage->pDbPage!=0 );
54884 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
54885 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
54886 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54902 assert( sqlite3PagerPageRefcount(pData)>0 );
54904 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54923 assert( pBt->db );
54924 assert( sqlite3_mutex_held(pBt->db->mutex) );
54978 assert( db!=0 );
54979 assert( pVfs!=0 );
54980 assert( sqlite3_mutex_held(db->mutex) );
54981 assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
54984 assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
54987 assert( (flags & BTREE_SINGLE)==0 || isTempDb );
55041 assert( pBt->nRef>0 );
55081 assert( sizeof(i64)==8 );
55082 assert( sizeof(u64)==8 );
55083 assert( sizeof(u32)==4 );
55084 assert( sizeof(u16)==2 );
55085 assert( sizeof(Pgno)==4 );
55146 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
55222 assert( sqlite3_mutex_held(mutexOpen) );
55240 assert( sqlite3_mutex_notheld(pBt->mutex) );
55318 assert( sqlite3_mutex_held(p->db->mutex) );
55340 assert( p->wantToLock==0 && p->locked==0 );
55347 assert( !pBt->pCursor );
55358 assert( p->wantToLock==0 );
55359 assert( p->locked==0 );
55385 assert( sqlite3_mutex_held(p->db->mutex) );
55399 assert( sqlite3_mutex_held(p->db->mutex) );
55421 assert( sqlite3_mutex_held(p->db->mutex) );
55436 assert( sqlite3_mutex_held(p->db->mutex) );
55438 assert( pBt && pBt->pPager );
55467 assert( nReserve>=-1 && nReserve<=255 );
55479 assert( nReserve>=0 && nReserve<=255 );
55482 assert( (pageSize & 7)==0 );
55483 assert( !pBt->pCursor );
55514 assert( sqlite3_mutex_held(p->pBt->mutex) );
55634 assert( sqlite3_mutex_held(pBt->mutex) );
55635 assert( pBt->pPage1==0 );
55718 assert( (pageSize & 7)==0 );
55782 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
55826 assert( sqlite3_mutex_held(pBt->mutex) );
55827 assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
55830 assert( pPage1->aData );
55831 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
55847 assert( sqlite3_mutex_held(pBt->mutex) );
55852 assert( pP1!=0 );
55857 assert( sizeof(zMagicHeader)==16 );
55862 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
55871 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
55872 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
55945 assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
56018 assert( p->lock.pBtree==p && p->lock.iTable==1 );
56032 assert( !pBt->pWriter );
56083 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
56126 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
56127 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
56198 assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
56200 assert( sqlite3_mutex_held(pBt->mutex) );
56201 assert( pDbPage->pBt==pBt );
56282 assert( sqlite3_mutex_held(pBt->mutex) );
56283 assert( iLastPg>nFin );
56315 assert( iFreePg==iLastPg );
56349 assert( iFreePg<iLastPg );
56405 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
56447 assert( sqlite3_mutex_held(pBt->mutex) );
56449 assert(pBt->autoVacuum);
56487 assert( nRef>=sqlite3PagerRefcount(pPager) );
56551 assert( sqlite3BtreeHoldsMutex(p) );
56622 assert( pBt->inTransaction==TRANS_WRITE );
56623 assert( pBt->nTransaction>0 );
56683 assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
56727 assert( writeOnly==1 || writeOnly==0 );
56728 assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
56738 assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
56746 assert( TRANS_WRITE==pBt->inTransaction );
56763 assert( countValidCursors(pBt, 1)==0 );
56795 assert( p->inTrans==TRANS_WRITE );
56796 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
56797 assert( iStatement>0 );
56798 assert( iStatement>p->db->nSavepoint );
56799 assert( pBt->inTransaction==TRANS_WRITE );
56826 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
56827 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
56840 assert( pBt->nPage>0 );
56888 assert( sqlite3BtreeHoldsMutex(p) );
56889 assert( wrFlag==0 || wrFlag==1 );
56895 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
56896 assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
56899 assert( p->inTrans>TRANS_NONE );
56900 assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
56901 assert( pBt->pPage1 && pBt->pPage1->aData );
56911 assert( wrFlag==0 );
56922 assert( wrFlag==0 || wrFlag==BTCF_WriteFlag );
57021 assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 );
57073 assert( cursorHoldsMutex(pCur) );
57074 assert( pCur->eState==CURSOR_VALID );
57093 assert( cursorHoldsMutex(pCur) );
57094 assert( pCur->eState==CURSOR_VALID );
57095 assert( pCur->iPage>=0 );
57096 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
57097 assert( pCur->apPage[pCur->iPage]->intKeyLeaf==1 );
57132 assert( sqlite3_mutex_held(pBt->mutex) );
57133 assert(pPgnoNext);
57161 assert( next==0 || rc==SQLITE_DONE );
57164 assert( rc==SQLITE_OK || pPage==0 );
57258 assert( pPage );
57259 assert( pCur->eState==CURSOR_VALID );
57260 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
57261 assert( cursorHoldsMutex(pCur) );
57262 assert( eOp!=2 || offset==0 ); /* Always start from beginning for eOp==2 */
57269 assert( offset+amt <= pCur->info.nPayload );
57340 assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
57354 assert( eOp!=2 );
57355 assert( pCur->curFlags & BTCF_ValidOvfl );
57356 assert( pCur->pBtree->db==pBt->db );
57400 assert( aWrite>=pBufStart ); /* hence (7) */
57446 assert( cursorHoldsMutex(pCur) );
57447 assert( pCur->eState==CURSOR_VALID );
57448 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
57449 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
57471 assert( cursorHoldsMutex(pCur) );
57474 assert( pCur->eState==CURSOR_VALID );
57475 assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
57476 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
57506 assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
57507 assert( pCur->eState==CURSOR_VALID );
57508 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57509 assert( cursorHoldsMutex(pCur) );
57510 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
57511 assert( pCur->info.nSize>0 );
57512 assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB );
57513 assert( pCur->info.pPayload<pCur->apPage[pCur->iPage]->aDataEnd ||CORRUPT_DB);
57558 assert( cursorHoldsMutex(pCur) );
57559 assert( pCur->eState==CURSOR_VALID );
57560 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
57561 assert( pCur->iPage>=0 );
57591 assert( iIdx<=pParent->nCell );
57593 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
57595 assert( get4byte(findCell(pParent, iIdx))==iChild );
57611 assert( cursorHoldsMutex(pCur) );
57612 assert( pCur->eState==CURSOR_VALID );
57613 assert( pCur->iPage>0 );
57614 assert( pCur->apPage[pCur->iPage] );
57653 assert( cursorHoldsMutex(pCur) );
57654 assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
57655 assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
57656 assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
57659 assert( pCur->skipNext!=SQLITE_OK );
57680 assert( pRoot->pgno==pCur->pgnoRoot );
57692 assert( pRoot->intKey==1 || pRoot->intKey==0 );
57727 assert( cursorHoldsMutex(pCur) );
57728 assert( pCur->eState==CURSOR_VALID );
57730 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
57752 assert( cursorHoldsMutex(pCur) );
57753 assert( pCur->eState==CURSOR_VALID );
57761 assert( pCur->info.nSize==0 );
57762 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
57773 assert( cursorHoldsMutex(pCur) );
57774 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57778 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
57781 assert( pCur->apPage[pCur->iPage]->nCell>0 );
57796 assert( cursorHoldsMutex(pCur) );
57797 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57806 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
57808 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
57809 assert( pCur->apPage[pCur->iPage]->leaf );
57817 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
57820 assert( pCur->eState==CURSOR_VALID );
57872 assert( cursorHoldsMutex(pCur) );
57873 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57874 assert( pRes );
57875 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
57895 assert( pIdxKey->default_rc==1
57907 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
57908 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
57909 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
57912 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
57915 assert( pCur->apPage[0]->intKey || pIdxKey );
57928 assert( pPage->nCell>0 );
57929 assert( pPage->intKey==(pIdxKey==0) );
57932 assert( biasRight==0 || biasRight==1 );
57952 assert( nCellKey==intKey );
57965 assert( lwr+upr>=0 );
58018 assert(
58027 assert( c==0 );
58035 assert( lwr+upr>=0 );
58039 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
58040 assert( pPage->isInit );
58042 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
58106 assert( cursorHoldsMutex(pCur) );
58107 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
58108 assert( *pRes==0 );
58110 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
58120 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
58132 assert( pPage->isInit );
58170 assert( cursorHoldsMutex(pCur) );
58171 assert( pRes!=0 );
58172 assert( *pRes==0 || *pRes==1 );
58173 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
58215 assert( cursorHoldsMutex(pCur) );
58216 assert( pRes!=0 );
58217 assert( *pRes==0 );
58218 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
58219 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
58220 assert( pCur->info.nSize==0 );
58231 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
58242 assert( pPage->isInit );
58257 assert( pCur->info.nSize==0 );
58258 assert( (pCur->curFlags & (BTCF_ValidNKey|BTCF_ValidOvfl))==0 );
58271 assert( cursorHoldsMutex(pCur) );
58272 assert( pRes!=0 );
58273 assert( *pRes==0 || *pRes==1 );
58274 assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
58326 assert( sqlite3_mutex_held(pBt->mutex) );
58327 assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
58350 assert( nearby>0 );
58351 assert( pBt->autoVacuum );
58398 assert( pTrunk!=0 );
58399 assert( pTrunk->aData!=0 );
58407 assert( pPrevTrunk==0 );
58471 assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
58584 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
58598 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
58608 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
58623 assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
58647 assert( sqlite3_mutex_held(pBt->mutex) );
58648 assert( iPage>1 );
58649 assert( !pMemPage || pMemPage->pgno==iPage );
58701 assert( pBt->usableSize>32 );
58789 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
58799 assert( pBt->usableSize > 4 );
58802 assert( ovflPgno==0 || nOvfl>0 );
58876 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
58880 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
58889 assert( nData==0 );
58890 assert( nZero==0 );
58943 assert( nHeader=(int)(info.pPayload - pCell) );
58944 assert( info.nKey==nKey );
58945 assert( *pnSize == info.nSize );
58946 assert( spaceLeft == info.nLocal );
58947 assert( pPrior == &pCell[info.iOverflow] );
58991 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
58995 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
59011 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
59015 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
59020 assert( pSrc );
59056 assert( idx>=0 && idx<pPage->nCell );
59057 assert( sz==cellSize(pPage, idx) );
59058 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
59059 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
59119 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
59120 assert( MX_CELL(pPage->pBt)<=10921 );
59121 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
59122 assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) );
59123 assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
59124 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
59130 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
59140 assert( j<(int)(sizeof(pPage->apOvfl)/sizeof(pPage->apOvfl[0])) );
59149 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
59158 assert( idx >= end+2 );
59159 assert( idx+sz <= (int)pPage->pBt->usableSize );
59221 assert( szCell[i]==cellSizePtr(pPg, pCell) );
59272 assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */
59319 assert( pFree>aData && (pFree - aData)<65536 );
59333 assert( pFree>aData && (pFree - aData)<65536 );
59394 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
59438 assert( 0==memcmp(pCell, &aData[iOff], szCell[i+iNew]) );
59494 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
59495 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
59496 assert( pPage->nOverflow==1 );
59514 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
59515 assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
59583 assert( pPage->isInit );
59594 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
59599 assert( n==pPage->pgno && e==PTRMAP_BTREE );
59605 assert( n==pPage->pgno && e==PTRMAP_BTREE );
59640 assert( pFrom->isInit );
59641 assert( pFrom->nFree>=iToHdr );
59642 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
59754 assert( sqlite3_mutex_held(pBt->mutex) );
59755 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
59766 assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
59767 assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx );
59788 assert( bBulk==0 || bBulk==1 );
59867 assert( szScratch<=6*(int)pBt->pageSize );
59875 assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
59902 assert( nCell<nMaxCells );
59912 assert( nCell<nMaxCells );
59922 assert( nCell<nMaxCells );
59926 assert( sz<=pBt->maxLocal+23 );
59927 assert( iSpace1 <= (int)pBt->pageSize );
59930 assert( leafCorrection==0 || leafCorrection==4 );
59933 assert( leafCorrection==0 );
59934 assert( pOld->hdrOffset==0 );
59939 assert( leafCorrection==4 );
59943 assert( szCell[nCell]==3 );
59944 assert( apCell[nCell]==&aSpace1[iSpace1-3] );
59971 assert( i<nMaxCells );
60005 assert( d<nMaxCells );
60006 assert( r<nMaxCells );
60027 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
60051 assert( i>0 );
60092 assert( CORRUPT_DB );
60127 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
60203 assert( j<nMaxCells );
60235 assert(leafCorrection==4);
60240 assert( sz<=pBt->maxLocal+23 );
60241 assert( iOvflSpace <= (int)pBt->pageSize );
60244 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
60271 assert( iPg>=0 && iPg<nNew );
60282 assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] );
60286 assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] );
60300 assert( apNew[iPg]->nOverflow==0 );
60301 assert( apNew[iPg]->nCell==nNewCell );
60306 assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 );
60308 assert( nOld>0 );
60309 assert( nNew>0 );
60327 assert( nNew==1 );
60330 assert( apNew[0]->nFree ==
60346 assert( pParent->isInit );
60411 assert( pRoot->nOverflow>0 );
60412 assert( sqlite3_mutex_held(pBt->mutex) );
60431 assert( sqlite3PagerIswriteable(pChild->pDbPage) );
60432 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
60433 assert( pChild->nCell==pRoot->nCell );
60482 assert( (balance_deeper_called++)==0 );
60488 assert( pCur->apPage[1]->nOverflow );
60521 assert( (balance_quick_called++)==0 );
60566 assert( pCur->iPage>=0 );
60618 assert( pCur->skipNext!=SQLITE_OK );
60622 assert( cursorHoldsMutex(pCur) );
60623 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
60626 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
60633 assert( (pKey==0)==(pCur->pKeyInfo==0) );
60667 assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
60670 assert( pPage->intKey || nKey>=0 );
60671 assert( pPage->leaf || !pPage->intKey );
60676 assert( pPage->isInit );
60678 assert( newCell!=0 );
60681 assert( szNew==cellSizePtr(pPage, newCell) );
60682 assert( szNew <= MX_CELL_SIZE(pBt) );
60686 assert( idx<pPage->nCell );
60699 assert( pPage->leaf );
60702 assert( pPage->leaf );
60705 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
60739 assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
60759 assert( cursorHoldsMutex(pCur) );
60760 assert( pBt->inTransaction==TRANS_WRITE );
60761 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
60762 assert( pCur->curFlags & BTCF_WriteFlag );
60763 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
60764 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
60823 assert( MX_CELL_SIZE(pBt) >= nCell );
60825 assert( pTmp!=0 );
60879 assert( sqlite3BtreeHoldsMutex(p) );
60880 assert( pBt->inTransaction==TRANS_WRITE );
60881 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
60914 assert( pgnoRoot>=3 );
60957 assert( eType!=PTRMAP_ROOTPAGE );
60958 assert( eType!=PTRMAP_FREEPAGE );
60990 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
61002 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
61010 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
61039 assert( sqlite3_mutex_held(pBt->mutex) );
61064 assert( pPage->intKey );
61096 assert( p->inTrans==TRANS_WRITE );
61145 assert( sqlite3BtreeHoldsMutex(p) );
61146 assert( p->inTrans==TRANS_WRITE );
61225 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
61276 assert( p->inTrans>TRANS_NONE );
61277 assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
61278 assert( pBt->pPage1 );
61279 assert( idx>=0 && idx<=15 );
61306 assert( idx>=1 && idx<=15 );
61308 assert( p->inTrans==TRANS_WRITE );
61309 assert( pBt->pPage1!=0 );
61316 assert( pBt->autoVacuum || iMeta==0 );
61317 assert( iMeta==0 || iMeta==1 );
61446 assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 );
61454 assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 );
61692 assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */
61817 assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */
61848 assert( i<=usableSize-4 ); /* Enforced by btreeInitPage() */
61850 assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */
61859 assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */
61860 assert( j<=usableSize-4 ); /* Enforced by btreeInitPage() */
61864 assert( heap[0]>0 );
61865 assert( (heap[1]>>16)==0 );
61928 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
62032 assert( p->pBt->pPager!=0 );
62045 assert( p->pBt->pPager!=0 );
62053 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
62086 assert( p );
62087 assert( sqlite3_mutex_held(p->db->mutex) );
62092 assert( p );
62093 assert( sqlite3_mutex_held(p->db->mutex) );
62135 assert( sqlite3_mutex_held(p->db->mutex) );
62138 assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
62152 assert( p->inTrans!=TRANS_NONE );
62155 assert( READ_LOCK+1==WRITE_LOCK );
62156 assert( isWriteLock==0 || isWriteLock==1 );
62182 assert( cursorHoldsMutex(pCsr) );
62183 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
62184 assert( pCsr->curFlags & BTCF_Incrblob );
62190 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
62204 assert( rc==SQLITE_OK );
62216 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
62218 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
62219 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
62220 assert( pCsr->apPage[pCsr->iPage]->intKey );
62242 assert( iVersion==1 || iVersion==2 );
62273 assert( mask==BTREE_BULKLOAD || mask==BTREE_SEEK_EQ || mask==0 );
62553 assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 );
62554 assert( p->bDestLocked );
62555 assert( !isFatalError(p->rc) );
62556 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
62557 assert( zSrcData );
62643 assert( sqlite3BtreeHoldsMutex(p->pSrc) );
62715 assert( nSrcPage>=0 );
62774 assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
62775 assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
62785 assert( nDestTruncate>0 );
62804 assert( pFile );
62805 assert( nDestTruncate==0
62879 assert( rc2==SQLITE_OK );
62989 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
62996 assert( p->pDestDb );
63000 assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
63022 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
63043 assert( sqlite3BtreeIsInTrans(pTo) );
63071 assert( b.rc!=SQLITE_OK );
63079 assert( sqlite3BtreeIsInTrans(pTo)==0 );
63118 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
63124 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
63127 assert( (p->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) );
63130 assert( p->szMalloc==0
63142 assert(
63171 assert( (pMem->flags&MEM_RowSet)==0 );
63172 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
63177 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63186 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
63187 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
63188 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
63203 assert( sqlite3VdbeCheckMemInvariants(pMem) );
63204 assert( (pMem->flags&MEM_RowSet)==0 );
63208 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
63211 assert( pMem->szMalloc==0
63236 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
63259 assert( szNew>0 );
63260 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
63264 assert( (pMem->flags & MEM_Dyn)==0 );
63278 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63279 assert( (pMem->flags&MEM_RowSet)==0 );
63306 assert( pMem->flags&MEM_Blob );
63307 assert( (pMem->flags&MEM_RowSet)==0 );
63308 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63345 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63373 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63374 assert( !(fg&MEM_Zero) );
63375 assert( !(fg&(MEM_Str|MEM_Blob)) );
63376 assert( fg&(MEM_Int|MEM_Real) );
63377 assert( (pMem->flags&MEM_RowSet)==0 );
63378 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63394 assert( fg & MEM_Real );
63418 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
63419 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63428 assert( (pMem->flags & MEM_Dyn)==0 );
63446 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
63447 assert( VdbeMemDynamic(p) );
63450 assert( (p->flags & MEM_Agg)==0 );
63454 assert( (p->flags&MEM_RowSet)==0 );
63455 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
63497 assert( sqlite3VdbeCheckMemInvariants(p) );
63546 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63547 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63555 assert( pMem->z || pMem->n==0 );
63570 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63571 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63593 assert( pMem->flags & MEM_Real );
63594 assert( (pMem->flags & MEM_RowSet)==0 );
63595 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63596 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63620 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63621 assert( (pMem->flags & MEM_RowSet)==0 );
63622 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63634 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63635 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
63652 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
63653 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63662 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
63680 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63700 assert( aff==SQLITE_AFF_TEXT );
63701 assert( MEM_Str==(MEM_Blob>>3) );
63704 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63717 assert( (flags & ~MEM_TypeMask)==0 );
63805 assert( db!=0 );
63806 assert( (pMem->flags & MEM_RowSet)==0 );
63813 assert( pMem->zMalloc );
63816 assert( pMem->u.pRowSet!=0 );
63826 assert( p->db!=0 );
63871 assert( (pFrom->flags & MEM_RowSet)==0 );
63872 assert( pTo->db==pFrom->db );
63877 assert( srcType==MEM_Ephem || srcType==MEM_Static );
63889 assert( pTo->db==pFrom->db );
63890 assert( (pFrom->flags & MEM_RowSet)==0 );
63911 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
63912 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
63913 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
63947 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63948 assert( (pMem->flags & MEM_RowSet)==0 );
63963 assert( enc!=0 );
64047 assert( sqlite3BtreeCursorIsValid(pCur) );
64048 assert( !VdbeMemDynamic(pMem) );
64052 assert( (pMem->flags & MEM_RowSet)==0 );
64058 assert( zData!=0 );
64092 assert( pVal!=0 );
64093 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
64094 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
64095 assert( (pVal->flags & MEM_RowSet)==0 );
64096 assert( (pVal->flags & (MEM_Null))==0 );
64106 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
64114 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
64116 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
64137 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
64138 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
64139 assert( (pVal->flags & MEM_RowSet)==0 );
64199 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
64200 assert( pRec->pKeyInfo->enc==ENC(db) );
64263 assert( pCtx!=0 );
64264 assert( (p->flags & EP_TokenOnly)==0 );
64269 assert( pFunc );
64294 assert( pCtx->pParse->rc==SQLITE_OK );
64304 assert( rc==SQLITE_OK );
64367 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
64433 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
64434 assert( pExpr->u.zToken[1]=='\'' );
64439 assert( zVal[nVal]=='\'' );
64457 assert( *ppVal==0 );
64461 assert( pCtx==0 ); sqlite3ValueFree(pVal);
64599 assert( pVal==0 || pVal->db==db );
64653 assert( pVal==0 || pVal->db==pParse->db );
64701 assert( iCol>0 );
64817 assert( pParse->aLabel==0 );
64818 assert( pParse->nLabel==0 );
64819 assert( pParse->nOpAlloc==0 );
64827 assert( isPrepareV2==1 || isPrepareV2==0 );
64832 assert( p->zSql==0 );
64894 assert( nOp<=(1024/sizeof(Op)) );
64895 assert( nNew>=(p->nOpAlloc+nOp) );
64936 assert( p->magic==VDBE_MAGIC_INIT );
64937 assert( op>0 && op<0xff );
65055 assert( v->magic==VDBE_MAGIC_INIT );
65074 assert( v->magic==VDBE_MAGIC_INIT );
65075 assert( j<p->nLabel );
65130 assert( p->iAddr<nOp );
65270 assert( p->nOp - i >= 3 );
65271 assert( pOp[-1].opcode==OP_Integer );
65294 assert( -1-pOp->p2<pParse->nLabel );
65302 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
65309 assert( p->magic==VDBE_MAGIC_INIT );
65326 assert( aOp && !p->db->mallocFailed );
65329 assert( DbMaskAllZero(p->btreeMask) );
65343 assert( p->magic==VDBE_MAGIC_INIT );
65357 assert( sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP );
65420 assert( p!=0 );
65431 assert( p!=0 );
65441 assert( p!=0 );
65452 assert( p!=0 );
65454 assert( p->nOp>0 );
65486 assert( db );
65600 assert( p!=0 );
65602 assert( p->magic==VDBE_MAGIC_INIT );
65609 assert( p->nOp>0 );
65610 assert( addr<p->nOp );
65615 assert( pOp->p4type==P4_NOTUSED
65635 assert( ((VTable *)zP4)->db==p->db );
65652 assert( v!=0 );
65653 assert( pIdx!=0 );
65666 assert( p->nOp>0 || p->aOp==0 );
65667 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
65669 assert( p->aOp );
65719 assert( p->magic==VDBE_MAGIC_INIT );
65723 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
65830 assert( nTemp>=20 );
65835 assert( pKeyInfo->aSortOrder!=0 );
65859 assert( i<nTemp );
65895 assert( pMem->flags & MEM_Blob );
65927 assert( zP4!=0 );
65941 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
65942 assert( i<(int)sizeof(p->btreeMask)*8 );
66051 assert( (&p[1])==pEnd || p[0].db==p[1].db );
66052 assert( sqlite3VdbeCheckMemInvariants(p) );
66126 assert( p->explain );
66127 assert( p->magic==VDBE_MAGIC_RUN );
66128 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
66157 assert( p->nMem>9 );
66204 assert( pMem->z!=0 );
66242 assert( p->db->mallocFailed );
66250 assert( pMem->z!=0 );
66258 assert( p->db->mallocFailed );
66269 assert( p->db->mallocFailed );
66366 assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) );
66386 assert( p!=0 );
66387 assert( p->magic==VDBE_MAGIC_INIT );
66391 assert( p->nOp>0 );
66398 assert( p->aMem[i].db==p->db );
66451 assert( p!=0 );
66452 assert( p->nOp>0 );
66453 assert( pParse!=0 );
66454 assert( p->magic==VDBE_MAGIC_INIT );
66455 assert( pParse==p->pParse );
66457 assert( db->mallocFailed==0 );
66489 assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
66567 assert( pVtabCursor->pVtab->nRef>0 );
66631 assert( p->nFrame==0 );
66644 assert( p->pAuxData==0 );
66657 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
66659 for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
66711 assert( idx<p->nResColumn );
66712 assert( var<COLNAME_N );
66714 assert( !zName || xDel!=SQLITE_DYNAMIC );
66717 assert( p->aColName!=0 );
66720 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
66851 assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
66880 assert( zFile[0]!=0 );
66925 assert( rc!=SQLITE_BUSY );
66991 assert( cnt==db->nVdbeActive );
66992 assert( nWrite==db->nVdbeWrite );
66993 assert( nRead==db->nVdbeRead );
67022 assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
67023 assert( db->nStatement>0 );
67024 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
67277 assert( db->nVdbeActive>=db->nVdbeRead );
67278 assert( db->nVdbeRead>=db->nVdbeWrite );
67279 assert( db->nVdbeWrite>=0 );
67295 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
67341 assert( v->db->init.busy==0 );
67449 assert( (rc & p->db->errMask)==rc );
67501 assert( p->db==0 || p->db==db );
67530 assert( sqlite3_mutex_held(db->mutex) );
67535 assert( db->pVdbe==p );
67556 assert( p->deferredMoveto );
67557 assert( p->isTable );
67578 assert( p->pCursor!=0 );
67579 assert( sqlite3BtreeCursorHasMoved(p->pCursor) );
67694 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
67695 assert( pMem->n>=0 );
67789 assert( sizeof(v)==sizeof(pMem->u.r) );
67796 assert( i>0 );
67806 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
67862 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
67864 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
67992 assert( pKeyInfo->aSortOrder!=0 );
68017 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
68033 assert( u<=pKeyInfo->nField + 1 );
68081 assert( pKeyInfo->nField+pKeyInfo->nXField>=pPKey2->nField || CORRUPT_DB );
68082 assert( pKeyInfo->aSortOrder!=0 );
68083 assert( pKeyInfo->nField>0 );
68084 assert( idx1<=szHdr1 || CORRUPT_DB );
68111 assert( mem1.szMalloc==0 ); /* See comment below */
68124 assert( mem1.szMalloc==0 );
68165 assert( nKey>=0 );
68166 assert( szHdr<=(u32)nKey );
68171 assert( nField <= pKeyInfo->nField+pKeyInfo->nXField );
68243 assert( (combined_flags & MEM_RowSet)==0 );
68293 assert( pMem1->enc==pMem2->enc );
68294 assert( pMem1->enc==SQLITE_UTF8 ||
68301 assert( !pColl || pColl->xCmp );
68324 assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
68413 assert( pPKey2->pKeyInfo->nField+pPKey2->pKeyInfo->nXField>=pPKey2->nField
68415 assert( pPKey2->pKeyInfo->aSortOrder!=0 );
68416 assert( pPKey2->pKeyInfo->nField>0 );
68417 assert( idx1<=szHdr1 || CORRUPT_DB );
68534 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
68535 assert( mem1.szMalloc==0 ); /* See comment below */
68548 assert( mem1.szMalloc==0 );
68553 assert( CORRUPT_DB
68589 assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB );
68658 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) );
68715 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res)
68757 assert( flags & MEM_Str );
68786 assert( sqlite3BtreeCursorIsValid(pCur) );
68788 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
68789 assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
68862 assert( sqlite3BtreeCursorIsValid(pCur) );
68864 assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
68886 assert( sqlite3_mutex_held(db->mutex) );
68932 assert( iVar>0 );
68953 assert( iVar>0 );
69075 assert( (rc & (v->db->errMask))==rc );
69217 assert( xDel!=SQLITE_DYNAMIC );
69234 assert( n>=0 );
69235 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69244 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69245 assert( xDel!=SQLITE_DYNAMIC );
69253 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69257 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69264 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69271 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69275 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69279 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69288 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69298 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69299 assert( xDel!=SQLITE_DYNAMIC );
69314 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69323 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69332 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69337 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69341 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69358 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69367 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69411 assert(p);
69461 assert( db->nVdbeWrite>0 || db->autoCommit==0
69501 assert( p->rc==SQLITE_OK );
69520 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
69523 assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
69559 assert( v->expired==0 );
69591 assert( p && p->pFunc );
69606 assert( p && p->pFunc );
69621 assert( p->pVdbe!=0 );
69661 assert( (pMem->flags & MEM_Agg)==0 );
69682 assert( p && p->pFunc && p->pFunc->xStep );
69683 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
69699 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69703 assert( pCtx->pVdbe!=0 );
69726 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69731 assert( pVdbe!=0 );
69773 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
69989 assert( db!=0 );
69994 assert( db->mallocFailed==0 );
70209 assert( xDel!=SQLITE_DYNAMIC );
70265 assert( xDel!=SQLITE_DYNAMIC );
70380 assert( pTo->db==pFrom->db );
70381 assert( pTo->nVar==pFrom->nVar );
70591 assert( n>0 && tokenType!=TK_ILLEGAL );
70648 assert( (zRawSql - zStart) > 0 );
70656 assert( n>0 );
70659 assert( zRawSql[0] || nToken==0 );
70663 assert( sqlite3Isdigit(zRawSql[1]) );
70669 assert( zRawSql[0]==':' || zRawSql[0]=='$' ||
70676 assert( idx>0 );
70680 assert( idx>0 && idx<=p->nVar );
70721 assert( pVar->flags & MEM_Blob );
70878 assert( (M & I)==I );
70950 assert( iCur<p->nCursor );
70989 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
71025 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
71081 assert( (pMem->flags & (MEM_Int|MEM_Real))==0 );
71082 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
71125 assert( (f & (MEM_Static|MEM_Ephem))==0 );
71128 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
71131 assert( (f & (MEM_Static|MEM_Dyn))==0 );
71162 assert( (f & (MEM_Static|MEM_Ephem))==0 );
71165 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
71168 assert( (f & (MEM_Static|MEM_Dyn))==0 );
71345 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
71356 assert( pOp->p2>0 );
71357 assert( pOp->p2<=(p->nMem-p->nCursor) );
71399 assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
71406 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
71407 assert( p->bIsReader || p->readOnly!=0 );
71410 assert( p->explain==0 );
71417 assert( 0 < db->nProgressOps );
71454 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
71487 assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
71489 assert( pOp->p1>0 );
71490 assert( pOp->p1<=(p->nMem-p->nCursor) );
71491 assert( memIsValid(&aMem[pOp->p1]) );
71492 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
71496 assert( pOp->p2>0 );
71497 assert( pOp->p2<=(p->nMem-p->nCursor) );
71498 assert( memIsValid(&aMem[pOp->p2]) );
71499 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
71503 assert( pOp->p3>0 );
71504 assert( pOp->p3<=(p->nMem-p->nCursor) );
71505 assert( memIsValid(&aMem[pOp->p3]) );
71506 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
71510 assert( pOp->p2>0 );
71511 assert( pOp->p2<=(p->nMem-p->nCursor) );
71515 assert( pOp->p3>0 );
71516 assert( pOp->p3<=(p->nMem-p->nCursor) );
71597 assert( db->nProgressOps!=0 );
71615 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71617 assert( VdbeMemDynamic(pIn1)==0 );
71637 assert( pIn1->flags==MEM_Int );
71655 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71656 assert( pOp->p2>=0 && pOp->p2<p->nOp );
71657 assert( pOp->p3>=0 && pOp->p3<p->nOp );
71659 assert( !VdbeMemDynamic(pOut) );
71677 assert( pIn1->flags==MEM_Int );
71678 assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
71680 assert( pCaller->opcode==OP_Yield );
71681 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
71703 assert( VdbeMemDynamic(pIn1)==0 );
71791 assert( pOp->p5>=1 && pOp->p5<=4 );
71800 assert( zType!=0 || pOp->p4.z!=0 );
71813 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
71817 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
71818 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
71843 assert( pOp->p4.pI64!=0 );
71858 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
71873 assert( pOp->p4.z!=0 );
71883 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
71884 assert( VdbeMemDynamic(pOut)==0 );
71912 assert( pOp->p4.z!=0 );
71920 assert( pOp->p3>0 );
71921 assert( pOp->p3<=(p->nMem-p->nCursor) );
71923 assert( pIn3->flags & MEM_Int );
71946 assert( pOp->p3<=(p->nMem-p->nCursor) );
71967 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
71980 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
71999 assert( pOp->p1>0 && pOp->p1<=p->nVar );
72000 assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
72028 assert( n>0 && p1>0 && p2>0 );
72029 assert( p1+n<=p2 || p2+n<=p1 );
72034 assert( pOut<=&aMem[(p->nMem-p->nCursor)] );
72035 assert( pIn1<=&aMem[(p->nMem-p->nCursor)] );
72036 assert( memIsValid(pIn1) );
72066 assert( pOut!=pIn1 );
72097 assert( pOut!=pIn1 );
72117 assert( p->nResColumn==pOp->p2 );
72118 assert( pOp->p1>0 );
72119 assert( pOp->p1+pOp->p2<=(p->nMem-p->nCursor)+1 );
72137 assert( db->flags&SQLITE_CountRows );
72138 assert( p->usesStmtJournal );
72157 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
72172 assert( memIsValid(&pMem[i]) );
72174 assert( (pMem[i].flags & MEM_Ephem)==0
72207 assert( pIn1!=pOut );
72379 assert( pOp->p4type==P4_COLLSEQ );
72412 assert( apVal || n==0 );
72413 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
72417 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
72418 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
72421 assert( memIsValid(pArg) );
72427 assert( pOp->p4type==P4_FUNCDEF );
72511 assert( op==OP_ShiftRight || op==OP_ShiftLeft );
72515 assert( OP_ShiftRight==OP_ShiftLeft+1 );
72616 assert( pOp->p2>=SQLITE_AFF_NONE && pOp->p2<=SQLITE_AFF_REAL );
72735 assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
72736 assert( (flags1 & MEM_Cleared)==0 );
72737 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 );
72789 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
72811 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
72813 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
72841 assert( pOp->p4type==P4_INTARRAY );
72842 assert( pOp->p4.ai );
72880 assert( n>0 );
72881 assert( pKeyInfo!=0 );
72888 assert( p1>0 && p1+mx<=(p->nMem-p->nCursor)+1 );
72889 assert( p2>0 && p2+mx<=(p->nMem-p->nCursor)+1 );
72891 assert( p1>0 && p1+n<=(p->nMem-p->nCursor)+1 );
72892 assert( p2>0 && p2+n<=(p->nMem-p->nCursor)+1 );
72897 assert( memIsValid(&aMem[p1+idx]) );
72898 assert( memIsValid(&aMem[p2+idx]) );
72901 assert( i<pKeyInfo->nField );
73033 assert( pOp->p1<p->nOnceFlag );
73150 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
73153 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
73155 assert( pC!=0 );
73156 assert( p2<pC->nField );
73159 assert( pC->pVtabCursor==0 ); /* OP_Column never called on virtual table */
73162 assert( pCrsr!=0 || pC->pseudoTableReg>0 ); /* pCrsr NULL on PseudoTables */
73163 assert( pCrsr!=0 || pC->nullRow ); /* pC->nullRow on PseudoTables */
73171 assert( pC->pseudoTableReg>0 );
73173 assert( pReg->flags & MEM_Blob );
73174 assert( memIsValid(pReg) );
73182 assert( pCrsr );
73184 assert( sqlite3BtreeCursorIsValid(pCrsr) );
73186 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
73190 assert( (payloadSize64 & SQLITE_MAX_U32)==(u64)payloadSize64 );
73194 assert( sqlite3BtreeCursorIsValid(pCrsr) );
73196 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
73199 assert( avail<=65536 ); /* Maximum page size is 64KiB */
73241 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
73272 assert( i<=p2 && zHdr<zEndHdr );
73331 assert( p2<pC->nHdrParsed );
73332 assert( rc==SQLITE_OK );
73333 assert( sqlite3VdbeCheckMemInvariants(pDest) );
73374 assert( fx!=0 );
73403 assert( zAffinity!=0 );
73404 assert( zAffinity[pOp->p2]==0 );
73407 assert( pIn1 <= &p->aMem[(p->nMem-p->nCursor)] );
73408 assert( memIsValid(pIn1) );
73469 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem-p->nCursor)+1 );
73476 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
73482 assert( pData0<=pLast );
73487 assert( zAffinity[0]==0 || pRec<=pLast );
73496 assert( memIsValid(pRec) );
73546 assert( pData0<=pLast );
73557 assert( i==nHdr );
73558 assert( j==nByte );
73560 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
73585 assert( pCrsr );
73616 assert( db->pSavepoint==0 || db->autoCommit==0 );
73617 assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
73618 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
73619 assert( checkSavepointCount(db) );
73620 assert( p->bIsReader );
73638 assert( db->autoCommit==0 || db->nVTrans==0 );
73750 assert( pSavepoint==db->pSavepoint );
73788 assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
73789 assert( desiredAutoCommit==1 || iRollback==0 );
73790 assert( db->nVdbeActive>0 ); /* At least this one VM is active */
73791 assert( p->bIsReader );
73813 assert( desiredAutoCommit==1 );
73827 assert( db->nStatement==0 );
73885 assert( p->bIsReader );
73886 assert( p->readOnly==0 || pOp->p2==0 );
73887 assert( pOp->p1>=0 && pOp->p1<db->nDb );
73888 assert( DbMaskTest(p->btreeMask, pOp->p1) );
73909 assert( sqlite3BtreeIsInTrans(pBt) );
73911 assert( db->nStatement>=0 && db->nSavepoint>=0 );
73939 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
73982 assert( p->bIsReader );
73985 assert( pOp->p3<SQLITE_N_BTREE_META );
73986 assert( iDb>=0 && iDb<db->nDb );
73987 assert( db->aDb[iDb].pBt!=0 );
73988 assert( DbMaskTest(p->btreeMask, iDb) );
74008 assert( pOp->p2<SQLITE_N_BTREE_META );
74009 assert( pOp->p1>=0 && pOp->p1<db->nDb );
74010 assert( DbMaskTest(p->btreeMask, pOp->p1) );
74011 assert( p->readOnly==0 );
74013 assert( pDb->pBt!=0 );
74014 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
74111 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
74112 assert( pOp->p4type==P4_KEYINFO );
74115 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
74123 assert( (pOp->p5&(OPFLAG_P2ISREG|OPFLAG_BULKCSR|OPFLAG_SEEKEQ))==pOp->p5 );
74124 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
74125 assert( p->bIsReader );
74126 assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
74138 assert( iDb>=0 && iDb<db->nDb );
74139 assert( DbMaskTest(p->btreeMask, iDb) );
74142 assert( pX!=0 );
74145 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
74153 assert( p2>0 );
74154 assert( p2<=(p->nMem-p->nCursor) );
74156 assert( memIsValid(pIn2) );
74157 assert( (pIn2->flags & MEM_Int)!=0 );
74171 assert( pKeyInfo->enc==ENC(db) );
74172 assert( pKeyInfo->db==db );
74177 assert( pOp->p1>=0 );
74178 assert( nField>=0 );
74194 assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
74195 assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
74238 assert( pOp->p1>=0 );
74239 assert( pOp->p2>=0 );
74257 assert( pOp->p4type==P4_KEYINFO );
74260 assert( pgno==MASTER_ROOT+1 );
74261 assert( pKeyInfo->db==db );
74262 assert( pKeyInfo->enc==ENC(db) );
74289 assert( pOp->p1>=0 );
74290 assert( pOp->p2>=0 );
74294 assert( pCx->pKeyInfo->db==db );
74295 assert( pCx->pKeyInfo->enc==ENC(db) );
74309 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74311 assert( pC->pSorter );
74337 assert( pOp->p1>=0 );
74338 assert( pOp->p3>=0 );
74344 assert( pOp->p5==0 );
74354 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74443 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74444 assert( pOp->p2!=0 );
74446 assert( pC!=0 );
74447 assert( pC->pseudoTableReg==0 );
74448 assert( OP_SeekLE == OP_SeekLT+1 );
74449 assert( OP_SeekGE == OP_SeekLT+2 );
74450 assert( OP_SeekGT == OP_SeekLT+3 );
74451 assert( pC->isOrdered );
74452 assert( pC->pCursor!=0 );
74465 assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
74466 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
74467 assert( pOp[1].p1==pOp[0].p1 );
74468 assert( pOp[1].p2==pOp[0].p2 );
74469 assert( pOp[1].p3==pOp[0].p3 );
74470 assert( pOp[1].p4.i==pOp[0].p4.i );
74502 assert( OP_SeekGE==(OP_SeekGT-1) );
74503 assert( OP_SeekLT==(OP_SeekLE-1) );
74504 assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
74511 assert( OP_SeekLE==(OP_SeekLT+1) );
74512 assert( OP_SeekGT==(OP_SeekGE+1) );
74513 assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
74524 assert( pOp->p4type==P4_INT32 );
74525 assert( nField>0 );
74537 assert( oc!=OP_SeekGT || r.default_rc==-1 );
74538 assert( oc!=OP_SeekLE || r.default_rc==-1 );
74539 assert( oc!=OP_SeekGE || r.default_rc==+1 );
74540 assert( oc!=OP_SeekLT || r.default_rc==+1 );
74544 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
74557 if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT );
74566 assert( oc==OP_SeekLT || oc==OP_SeekLE );
74578 assert( pOp->p2>0 );
74599 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74601 assert( pC!=0 );
74602 assert( pC->pCursor!=0 );
74603 assert( pC->isTable );
74688 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74689 assert( pOp->p4type==P4_INT32 );
74691 assert( pC!=0 );
74696 assert( pC->pCursor!=0 );
74697 assert( pC->isTable==0 );
74704 assert( memIsValid(&r.aMem[ii]) );
74716 assert( pIn3->flags & MEM_Blob );
74778 assert( pIn3->flags & MEM_Int );
74779 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74781 assert( pC!=0 );
74785 assert( pC->isTable );
74786 assert( pC->pseudoTableReg==0 );
74788 assert( pCrsr!=0 );
74811 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74812 assert( p->apCsr[pOp->p1]!=0 );
74845 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
74847 assert( pC!=0 );
74864 assert( pC->isTable );
74884 assert( sqlite3BtreeCursorIsValid(pC->pCursor) );
74886 assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
74898 assert( pOp->p3>0 );
74902 assert( pOp->p3<=pFrame->nMem );
74906 assert( pOp->p3<=(p->nMem-p->nCursor) );
74910 assert( memIsValid(pMem) );
74914 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
74930 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
74944 assert( v>0 ); /* EV: R-40812-03570 */
75012 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75013 assert( memIsValid(pData) );
75015 assert( pC!=0 );
75016 assert( pC->pCursor!=0 );
75017 assert( pC->pseudoTableReg==0 );
75018 assert( pC->isTable );
75023 assert( pKey->flags & MEM_Int );
75024 assert( memIsValid(pKey) );
75028 assert( pOp->opcode==OP_InsertInt );
75038 assert( pData->flags & (MEM_Blob|MEM_Str) );
75058 assert( pC->isTable );
75060 assert( pC->iDb>=0 );
75088 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75090 assert( pC!=0 );
75091 assert( pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
75092 assert( pC->deferredMoveto==0 );
75101 assert( pC->movetoTarget==iKey );
75112 assert( pC->iDb>=0 );
75151 assert( isSorter(pC) );
75152 assert( pOp->p4type==P4_INT32 );
75179 assert( isSorter(pC) );
75181 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
75182 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75220 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75222 assert( isSorter(pC)==0 );
75223 assert( pC->isTable || pOp->opcode!=OP_RowData );
75224 assert( pC->isTable==0 || pOp->opcode==OP_RowData );
75225 assert( pC!=0 );
75226 assert( pC->nullRow==0 );
75227 assert( pC->pseudoTableReg==0 );
75228 assert( pC->pCursor!=0 );
75238 assert( pC->deferredMoveto==0 );
75239 assert( sqlite3BtreeCursorIsValid(pCrsr) );
75246 assert( !pC->isTable );
75248 assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
75255 assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
75294 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75296 assert( pC!=0 );
75297 assert( pC->pseudoTableReg==0 || pC->nullRow );
75307 assert( pModule->xRowid );
75312 assert( pC->pCursor!=0 );
75320 assert( rc==SQLITE_OK ); /* Always so because of CursorRestore() above */
75335 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75337 assert( pC!=0 );
75363 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75365 assert( pC!=0 );
75368 assert( pCrsr!=0 );
75423 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75425 assert( pC!=0 );
75426 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
75435 assert( pCrsr );
75441 assert( pOp->p2>0 && pOp->p2<p->nOp );
75515 assert( isSorter(pC) );
75525 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75526 assert( pOp->p5<ArraySize(p->aCounter) );
75529 assert( pC!=0 );
75530 assert( pC->deferredMoveto==0 );
75531 assert( pC->pCursor );
75532 assert( res==0 || (res==1 && pC->isTable==0) );
75534 assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
75535 assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
75536 assert( pOp->opcode!=OP_NextIfOpen || pOp->p4.xAdvance==sqlite3BtreeNext );
75537 assert( pOp->opcode!=OP_PrevIfOpen || pOp->p4.xAdvance==sqlite3BtreePrevious);
75541 assert( pOp->opcode!=OP_Next || pOp->opcode!=OP_NextIfOpen
75544 assert( pOp->opcode!=OP_Prev || pOp->opcode!=OP_PrevIfOpen
75593 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75595 assert( pC!=0 );
75596 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
75598 assert( pIn2->flags & MEM_Blob );
75601 assert( pCrsr!=0 );
75602 assert( pC->isTable==0 );
75613 assert( pC->deferredMoveto==0 );
75633 assert( pOp->p3>0 );
75634 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem-p->nCursor)+1 );
75635 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75637 assert( pC!=0 );
75639 assert( pCrsr!=0 );
75640 assert( pOp->p5==0 );
75646 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
75652 assert( pC->deferredMoveto==0 );
75672 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75674 assert( pC!=0 );
75676 assert( pCrsr!=0 );
75678 assert( pC->isTable==0 );
75679 assert( pC->deferredMoveto==0 );
75752 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75754 assert( pC!=0 );
75755 assert( pC->isOrdered );
75756 assert( pC->pCursor!=0);
75757 assert( pC->deferredMoveto==0 );
75758 assert( pOp->p5==0 || pOp->p5==1 );
75759 assert( pOp->p4type==P4_INT32 );
75763 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
75766 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
75771 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
75775 assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
75777 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
75780 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
75812 assert( p->readOnly==0 );
75820 assert( DbMaskTest(p->btreeMask, iDb) );
75829 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
75859 assert( p->readOnly==0 );
75860 assert( DbMaskTest(p->btreeMask, pOp->p2) );
75867 assert( memIsValid(&aMem[pOp->p3]) );
75886 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
75888 assert( pC!=0 );
75892 assert( pC->isEphemeral );
75930 assert( pOp->p1>=0 && pOp->p1<db->nDb );
75931 assert( DbMaskTest(p->btreeMask, pOp->p1) );
75932 assert( p->readOnly==0 );
75934 assert( pDb->pBt!=0 );
75966 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
75971 assert( iDb>=0 && iDb<db->nDb );
75972 assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
75984 assert( db->init.busy==0 );
75987 assert( !db->mallocFailed );
76009 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76084 assert( p->bIsReader );
76086 assert( nRoot>0 );
76089 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
76091 assert( (pnErr->flags & MEM_Int)!=0 );
76092 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
76098 assert( pOp->p5<db->nDb );
76099 assert( DbMaskTest(p->btreeMask, pOp->p5) );
76106 assert( z==0 );
76129 assert( (pIn2->flags & MEM_Int)!=0 );
76195 assert( pIn3->flags&MEM_Int );
76205 assert( pOp->p4type==P4_INT32 );
76206 assert( iSet==-1 || iSet>=0 );
76248 assert( pProgram->nOp>0 );
76320 assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem );
76321 assert( pProgram->nCsr==pFrame->nChildCsr );
76322 assert( (int)(pOp - aOp)==pFrame->pc );
76437 assert( memIsValid(pIn1) );
76460 assert( pIn1->flags&MEM_Int );
76474 assert( pIn1->flags&MEM_Int );
76490 assert( pIn1->flags&MEM_Int );
76507 assert( pIn1->flags&MEM_Int );
76524 assert( pIn1->flags&MEM_Int );
76551 assert( n>=0 );
76554 assert( apVal || n==0 );
76556 assert( memIsValid(pRec) );
76561 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
76576 assert( pOp[-1].opcode==OP_CollSeq );
76599 assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
76601 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
76631 assert( p->readOnly==0 );
76634 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
76674 assert( eNew==PAGER_JOURNALMODE_DELETE
76682 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76683 assert( p->readOnly==0 );
76735 assert( sqlite3BtreeIsInTrans(pBt)==0 );
76765 assert( p->readOnly==0 );
76781 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76782 assert( DbMaskTest(p->btreeMask, pOp->p1) );
76783 assert( p->readOnly==0 );
76834 assert( p1>=0 && p1<db->nDb );
76835 assert( DbMaskTest(p->btreeMask, p1) );
76836 assert( isWriteLock==0 || isWriteLock==1 );
76880 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
76881 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
76883 assert( rc==SQLITE_OK );
76885 assert( zTab || db->mallocFailed );
76921 assert( p->bIsReader );
76942 assert( db->mallocFailed );
76987 assert( memIsValid(pQuery) );
76989 assert( pCur->pVtabCursor );
76995 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
77032 assert( pCur->pVtabCursor );
77033 assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
77042 assert( pModule->xColumn );
77077 assert( pCur->pVtabCursor );
77083 assert( pModule->xNext );
77118 assert( pVtab->pModule->xRename );
77119 assert( memIsValid(pName) );
77120 assert( p->readOnly==0 );
77122 assert( pName->flags & MEM_Str );
77173 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
77176 assert( p->readOnly==0 );
77184 assert( pOp->p4type==P4_VTAB );
77190 assert( memIsValid(pX) );
77200 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
77316 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
77342 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
77362 assert( rc );
77404 assert( p->zErrMsg==0 );
77415 assert( db->u1.isInterrupted );
77484 assert( v->aVar[0].flags&MEM_Int );
77519 assert( rc!=SQLITE_OK || zErr==0 );
77520 assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
77687 assert( pBlob->pStmt || db->mallocFailed );
77815 assert( db == v->db );
77888 assert( rc!=SQLITE_SCHEMA );
77892 assert( rc==SQLITE_OK || p->pStmt==0 );
78398 assert( p->aBuffer );
78414 assert( nRead>0 );
78418 assert( rc!=SQLITE_IOERR_SHORT_READ );
78463 assert( aNext!=p->aAlloc );
78536 assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 );
78631 assert( pFile->iEof>iStart );
78632 assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 );
78633 assert( pReadr->aBuffer==0 );
78634 assert( pReadr->aMap==0 );
78756 assert( (s1>0 && s1<7) || s1==8 || s1==9 );
78757 assert( (s2>0 && s2<7) || s2==8 || s2==9 );
78783 assert( res!=0 );
78861 assert( pCsr->pKeyInfo && pCsr->pBt==0 );
78899 assert( pSorter->iMemory==0 );
78943 assert( pTask->list.aMemory==0 );
79009 assert( pTask->bDone==1 );
79024 assert( pTask->pThread==0 && pTask->bDone==0 );
79067 assert( nReader<=SORTER_MAX_MERGE_COUNT );
79119 assert( pSorter->bUseThreads || pSorter->pReader==0 );
79221 assert( pTask->pUnpacked==(UnpackedRecord*)pFree );
79306 assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
79329 assert( pTask->pUnpacked->errCode==SQLITE_OK
79378 assert( p->iBufEnd<p->nBuffer );
79446 assert( pList->szPMA>0 );
79451 assert( rc!=SQLITE_OK || pTask->file.pFd );
79452 assert( pTask->file.iEof==0 );
79453 assert( pTask->nPMA==0 );
79485 assert( rc!=SQLITE_OK || pList->pList==0 );
79486 assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
79571 assert( pTask->bDone==0 );
79622 assert( pTask->pThread==0 && pTask->bDone==0 );
79623 assert( pTask->list.pList==0 );
79624 assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
79671 assert( pSorter );
79704 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
79763 assert( pIncr->bEof==0 );
79782 assert( pIncr->pMerger->pTask==pTask );
79809 assert( pIncr->bUseThread );
79917 assert( iOut<pMerger->nTree && iOut>0 );
79938 assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */
79999 assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
80002 assert( pMerger->pTask==0 );
80067 assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
80086 assert( pTask->file2.iEof>0 );
80110 assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK );
80153 assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK );
80303 assert( pSorter->bUseThreads || pSorter->nTask==1 );
80312 assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 );
80344 assert( pMain==0 );
80386 assert( pSorter->bUseThreads==0 || pSorter->nTask>1 );
80405 assert( pIncr->pTask!=pLast );
80419 assert( p->pIncr==0 || (
80456 assert( pSorter );
80475 assert( pSorter->list.pList );
80485 assert( pSorter->pReader==0 );
80502 assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
80504 assert( pSorter->pReader==0 || pSorter->pMerger==0 );
80505 assert( pSorter->bUseThreads==0 || pSorter->pReader );
80506 assert( pSorter->bUseThreads==1 || pSorter->pMerger );
80514 assert( pSorter->pMerger!=0 );
80515 assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
80606 assert( pSorter->pUnpacked==(UnpackedRecord*)p );
80610 assert( r2->nField==nKeyCol );
80684 assert(p->iSize<=p->nBuf);
80962 assert( iOfst+iAmt<=p->endpoint.iOffset );
81007 assert( iOfst==p->endpoint.iOffset );
81023 assert( p->pFirst );
81026 assert( !p->pFirst );
81047 assert(size==0);
81120 assert( EIGHT_BYTE_ALIGNMENT(p) );
81395 assert( iCol>=0 && iCol<pEList->nExpr );
81397 assert( pOrig!=0 );
81426 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
81528 assert( pNC ); /* the name context cannot be NULL. */
81529 assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
81530 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
81552 assert( db->aDb[i].zName );
81569 assert( pTab!=0 && pTab->zName!=0 );
81570 assert( pTab->nCol>0 );
81590 assert( zTabName!=0 );
81620 assert( (pMatch->jointype & JT_RIGHT)==0 );
81634 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
81719 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
81720 assert( pExpr->x.pList==0 );
81721 assert( pExpr->x.pSelect==0 );
81730 assert( zTab==0 && zDb==0 );
81791 assert( pMatch->iCursor==pExpr->iTable );
81804 assert( pNC!=0 );
81811 assert( pTopNC!=0 );
81886 assert( r>=0.0 );
81907 assert( pNC!=0 );
81909 assert( pParse==pWalker->pParse );
81918 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
81932 assert( pSrcList && pSrcList->nSrc==1 );
81966 assert( pRight->op==TK_DOT );
81988 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
82063 assert( pDef!=0 );
82065 assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
82088 assert( pNC->nRef>=nRef );
82167 assert( sqlite3ExprIsInteger(pE, &i)==0 );
82259 assert( pEList!=0 );
82275 assert(pDup);
82292 assert( pParent->op==TK_COLLATE );
82294 assert( pParent->pLeft==pE );
82345 assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
82448 assert( p!=0 );
82473 assert( (p->selFlags & SF_Expanded)!=0 );
82474 assert( (p->selFlags & SF_Resolved)==0 );
82495 assert( p->pSrc->nSrc==1 && p->pOrderBy );
82496 assert( pSub->pPrior && pSub->pOrderBy==0 );
82523 assert( pItem->isCorrelated==0 && nRef<=0 );
82537 assert( pEList!=0 );
82548 assert( (p->selFlags & SF_Aggregate)==0 );
82551 assert( NC_MinMaxAgg==SF_MinMaxAgg );
82752 assert( p!=0 );
82783 assert( type==NC_IsCheck || type==NC_PartIdx );
82842 assert( pExpr->flags&EP_xIsSelect );
82847 assert( !ExprHasProperty(pExpr, EP_IntValue) );
82858 assert( pExpr->pTab && j<pExpr->pTab->nCol );
82890 assert( zC!=0 );
82903 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
82904 assert( pExpr->x.pList->nExpr>0 );
82905 assert( pExpr->op==TK_FUNCTION );
82908 assert( pExpr->op==TK_COLLATE || pExpr->op==TK_AS );
82958 assert( p->x.pList==0 || p->pRight==0 );
83006 assert( aff1==0 || aff2==0 );
83017 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
83020 assert( pExpr->pLeft );
83078 assert( pLeft );
83264 assert( iValue>=0 );
83278 assert( pToken->z!=0 || pToken->n==0 );
83323 assert( db->mallocFailed );
83425 assert( pToken );
83432 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
83458 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
83460 assert( z!=0 );
83461 assert( z[0]!=0 );
83464 assert( z[0]=='?' );
83527 assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
83530 assert( p->x.pList==0 || p->pRight==0 );
83592 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
83593 assert( EXPR_FULLSIZE<=0xfff );
83594 assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 );
83598 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
83599 assert( !ExprHasProperty(p, EP_FromJoin) );
83600 assert( !ExprHasProperty(p, EP_MemToken) );
83601 assert( !ExprHasProperty(p, EP_NoReduce) );
83605 assert( p->pRight==0 );
83664 assert( pzBuffer==0 || isReduced );
83690 assert( ExprHasProperty(p, EP_Reduced)==0 );
83913 assert( p==0 );
83942 assert( pList->nExpr>0 );
83949 assert( pList->a!=0 );
83978 assert( pList!=0 || pParse->db->mallocFailed!=0 );
83981 assert( pList->nExpr>0 );
83983 assert( pItem->zName==0 );
84003 assert( pList!=0 || db->mallocFailed!=0 );
84006 assert( pList->nExpr>0 );
84007 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
84038 assert( pList->a!=0 || pList->nExpr==0 );
84201 assert( isInit==0 || isInit==1 );
84216 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
84231 assert( v!=(-2147483647-1) );
84268 assert( p->pTab!=0 );
84306 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
84350 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
84352 assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
84355 assert( pSrc!=0 );
84360 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
84403 assert( !ExprHasProperty(pIn, EP_xIsSelect) );
84490 assert( pX->op==TK_IN );
84505 assert( p ); /* Because of isCandidateForInOpt(p) */
84506 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
84507 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
84508 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
84522 assert(v);
84554 assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 );
84707 assert( !isRowid );
84710 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
84719 assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
84720 assert( pEList!=0 );
84721 assert( pEList->nExpr>0 );
84722 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
84742 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
84804 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
84806 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
84880 assert( v!=0 ); /* OOM detected prior to this routine */
84909 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
84926 assert( destIfNull==destIfFalse );
84975 assert( destIfFalse!=destIfNull || rRhsHasNull==0 );
85039 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
85058 assert( i>=0 );
85065 assert( z!=0 );
85113 assert( iReg>0 || pParse->nErr || pParse->db->mallocFailed );
85114 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
85129 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
85206 assert( pParse->iCacheLevel>=1 );
85290 assert( v!=0 );
85333 assert( iFrom>=iTo+nReg || iFrom+nReg<=iTo );
85388 assert( target>0 && target<=pParse->nMem );
85390 assert( pParse->db->mallocFailed );
85404 assert( pCol->iMem>0 );
85437 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85443 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85456 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85457 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
85458 assert( pExpr->u.zToken[1]=='\'' );
85461 assert( z[n]=='\'' );
85468 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85469 assert( pExpr->u.zToken!=0 );
85470 assert( pExpr->u.zToken[0]!=0 );
85473 assert( pExpr->u.zToken[0]=='?'
85512 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
85513 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
85514 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
85515 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
85516 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
85517 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
85549 assert( TK_AND==OP_And ); testcase( op==TK_AND );
85550 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
85551 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
85552 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
85553 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
85554 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
85555 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
85556 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
85557 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
85558 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
85559 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
85569 assert( pLeft );
85574 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85591 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
85592 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
85602 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
85603 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
85617 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85635 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
85642 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85657 assert( nFarg>=2 );
85675 assert( nFarg>=1 );
85704 assert( nFarg==1 );
85705 assert( pFarg->a[0].pExpr!=0 );
85708 assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
85709 assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
85847 assert( pExpr->iTable==0 || pExpr->iTable==1 );
85848 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
85849 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
85850 assert( p1>=0 && p1<(pTab->nCol*2+2) );
85896 default: assert( op==TK_CASE ); {
85908 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
85909 assert(pExpr->x.pList->nExpr > 0);
85931 assert( pTest!=0 );
85952 assert( db->mallocFailed || pParse->nErr>0
85959 assert( pExpr->affinity==OE_Rollback
85972 assert( !ExprHasProperty(pExpr, EP_IntValue) );
86001 assert( ConstFactorOk(pParse) );
86067 assert( target>0 && target<=pParse->nMem );
86072 assert( pParse->pVdbe || pParse->db->mallocFailed );
86109 assert( target>0 );
86110 assert( pExpr->op!=TK_REGISTER );
86400 assert( pList!=0 );
86401 assert( target>0 );
86402 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
86454 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
86505 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
86544 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86545 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86546 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86547 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86548 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86549 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86571 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
86572 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
86630 assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
86656 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
86657 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
86658 assert( pExpr->op!=TK_NE || op==OP_Eq );
86659 assert( pExpr->op!=TK_EQ || op==OP_Ne );
86660 assert( pExpr->op!=TK_LT || op==OP_Ge );
86661 assert( pExpr->op!=TK_LE || op==OP_Gt );
86662 assert( pExpr->op!=TK_GT || op==OP_Le );
86663 assert( pExpr->op!=TK_GE || op==OP_Lt );
86700 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86701 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86702 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86703 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86704 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86705 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86948 assert( pExpr->op==TK_AGG_FUNCTION );
87014 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
87092 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
87096 assert( !ExprHasProperty(pExpr, EP_IntValue) );
87109 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
87142 assert( pNC->pSrcList!=0 );
87202 assert( !usedAsColumnCache(pParse, i, i+n-1) );
87304 assert( len>0 );
87428 assert( len>0 );
87571 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
87573 assert( iDb>=0 );
87579 assert( iTrigDb==iDb || iTrigDb==1 );
87643 assert( pSrc->nSrc==1 );
87644 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
87867 assert( pNew );
87869 assert( sqlite3BtreeHoldsAllMutexes(db) );
87876 assert( pTab );
87923 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
87990 assert( pParse->pNewTable==0 );
87991 assert( sqlite3BtreeHoldsAllMutexes(db) );
88012 assert( pTab->addColOffset>0 );
88027 assert( pNew->nCol>0 );
88029 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
88264 assert( sqlite3BtreeHoldsAllMutexes(db) );
88265 assert( sqlite3VdbeDb(v)==db );
88307 assert( i<ArraySize(aTable) );
88363 assert( db!=0 );
88375 assert( db!=0 );
88391 assert( db!=0 );
88473 assert( nCol>0 );
88476 assert( nKeyCol<=nCol );
88477 assert( nKeyCol>0 );
88523 assert( (pSpace - (u8*)p)==n );
88569 assert( pNew->iCol==pOld->iCol );
88594 assert( pOld->isPSample==0 && pNew->isPSample==0 );
88595 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
88617 assert( IsStat4 || nEqZero==0 );
88622 assert( pNew->anEq[pNew->iCol]>0 );
88633 assert( pOld->iCol>pNew->iCol );
88634 assert( sampleIsBetter(p, pNew, pOld) );
88668 assert( p->nSample==0
88691 assert( iMin>=0 );
88782 assert( p->nCol>0 );
88783 assert( iChng<p->nCol );
88879 assert( argc==2 );
88880 assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ
88886 assert( argc==1 );
88926 assert( p->current.anEq[i] );
88928 assert( z[0]=='\0' && z>zRet );
88950 assert( p->iGet<p->nSample );
88974 assert( z[0]=='\0' && z>zRet );
88999 assert( regOut!=regStat4 && regOut!=regStat4+1 );
89003 assert( iParam==STAT_GET_STAT1 );
89058 assert( sqlite3BtreeHoldsAllMutexes(db) );
89060 assert( iDb>=0 );
89061 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
89142 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
89241 assert( regRowid==(regStat4+2) );
89257 assert( regChng==(regStat4+1) );
89265 assert( "BBB"[0]==SQLITE_AFF_TEXT );
89329 assert( "BBB"[0]==SQLITE_AFF_TEXT );
89367 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
89384 assert( pTab!=0 );
89385 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
89423 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
89428 assert( pName2!=0 || pName1==0 );
89501 assert( z!=0 );
89513 assert( aOut==0 );
89515 assert( aLog!=0 );
89521 assert( pIndex!=0 ); {
89563 assert( argc==3 );
89738 assert( db->lookaside.bEnabled==0 );
89761 assert( pIdx==0 || bStat3 || pIdx->nSample==0 );
89766 assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 );
89790 assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) );
89852 assert( db->lookaside.bEnabled==0 );
89899 assert( iDb>=0 && iDb<db->nDb );
89900 assert( db->aDb[iDb].pBt!=0 );
89903 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
90056 assert( z && zName );
90090 assert( pVfs );
90178 assert( iDb>=2 );
90315 assert( v || db->mallocFailed );
90318 assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
90392 assert( db->nDb>iDb );
90703 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
90707 assert( pTabList );
90719 assert( iCol<pTab->nCol );
90722 assert( pTab->iPKey<pTab->nCol );
90727 assert( iDb>=0 && iDb<db->nDb );
90784 assert( pParse );
90872 assert( iDb>=0 );
90906 assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
90946 assert( pParse->pToplevel==0 );
90958 assert( !pParse->isMultiWrite
90985 assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
91035 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
91073 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
91117 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
91128 assert( sqlite3SchemaMutexHeld(db, j, 0) );
91193 assert( p->pSchema==0 || p->zDatabase==0 );
91219 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
91223 assert( pSchema );
91225 assert( sqlite3SchemaMutexHeld(db, j, 0) );
91258 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91316 assert( iDb<db->nDb );
91320 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91321 assert( pDb->pSchema!=0 );
91330 assert( pDb->pSchema!=0 );
91369 assert( pTable!=0 );
91401 assert( !pTable || pTable->nRef>0 );
91416 assert( pIndex->pSchema==pTable->pSchema );
91422 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
91423 assert( pOld==pIndex || pOld==0 );
91446 assert( nLookaside==0 || nLookaside==db->lookaside.nOut );
91457 assert( db!=0 );
91458 assert( iDb>=0 && iDb<db->nDb );
91459 assert( zTabName );
91460 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91578 assert( db->init.iDb==0 || db->init.busy );
91690 assert( (isTemp & 1)==isTemp );
91733 assert( !db->init.busy || CORRUPT_DB );
91755 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
91756 assert( pParse->pNewTable==0 );
91765 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92022 assert( pCol->zType==0 || CORRUPT_DB );
92122 assert( autoInc==0 || autoInc==1 );
92198 assert( pIdx->nKeyCol==1 );
92263 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92370 assert( pCol->affinity-SQLITE_AFF_NONE >= 0 );
92371 assert( pCol->affinity-SQLITE_AFF_NONE < ArraySize(azType) );
92380 assert( pCol->affinity==SQLITE_AFF_NONE
92384 assert( k<=n );
92398 assert( pIdx->isResized==0 );
92438 assert( x<pIdx->pTable->nCol );
92487 assert( v );
92495 assert( v );
92509 assert( pParse->pNewTable==pTab );
92531 assert( pPk!=0 );
92568 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
92569 assert( pIdx->nColumn>=j );
92578 assert( j<pPk->nColumn );
92584 assert( pPk->nColumn==j );
92585 assert( pTab->nCol==j );
92629 assert( !db->init.busy || !pSelect );
92722 assert(pParse->nTab==1);
92732 assert( p->aCol==0 );
92778 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92799 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92802 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
92813 assert( !pSelect && pCons && pEnd );
92913 assert( pTable );
92947 assert( pTable->nCol>=0 );
92956 assert( pTable->pSelect );
92975 assert( pTable->aCol==0 );
92981 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
93002 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
93041 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93131 assert( pIdx->pSchema==pTab->pSchema );
93140 assert( iDb>=0 && iDb<pParse->db->nDb );
93182 assert( v!=0 );
93197 assert( pTrigger->pSchema==pTab->pSchema ||
93255 assert( pParse->nErr==0 );
93256 assert( pName->nSrc==1 );
93267 assert( iDb>=0 && iDb<db->nDb );
93378 assert( pTo!=0 );
93449 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
93458 assert( pNextTo->pPrevTo==0 );
93487 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
93559 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
93681 assert( pName1 && pName2 );
93684 assert( pName && pName->z );
93703 assert(0);
93706 assert( db->mallocFailed==0 || pTab==0 );
93716 assert( pName==0 );
93717 assert( pStart==0 );
93724 assert( pTab!=0 );
93725 assert( pParse->nErr==0 );
93764 assert( pName->z!=0 );
93778 assert( !db->init.busy );
93827 assert( pExpr->op==TK_COLLATE );
93842 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
93843 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
93858 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93892 assert( j<=0x7fff );
93896 assert( pListItem->pExpr->op==TK_COLLATE );
93899 assert( nExtra>=nColl );
93928 assert( i==pIndex->nColumn );
93961 assert( IsUniqueIndex(pIdx) );
93962 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
93963 assert( IsUniqueIndex(pIndex) );
94002 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
94006 assert( p==pIndex ); /* Malloc must have failed */
94144 if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) );
94150 a[i] = 23; assert( 23==sqlite3LogEst(5) );
94153 assert( 0==sqlite3LogEst(1) );
94167 assert( pParse->nErr==0 ); /* Never called with prior errors */
94171 assert( pName->nSrc==1 );
94348 assert( iStart>=0 );
94349 assert( nExtra>=1 );
94350 assert( pSrc!=0 );
94351 assert( iStart<=pSrc->nSrc );
94361 assert( db->mallocFailed );
94428 assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
94459 assert(pList || pParse->db->mallocFailed );
94530 assert( pAlias!=0 );
94540 assert( p==0 );
94552 assert( pIndexedBy!=0 );
94555 assert( pItem->notIndexed==0 && pItem->zIndex==0 );
94599 assert( pParse!=0 );
94601 assert( db!=0 );
94623 assert( pParse!=0 );
94624 assert( pParse->db!=0 );
94640 assert( pParse!=0 );
94641 assert( pParse->db!=0 );
94661 assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
94695 assert( db->aDb[1].pSchema );
94714 assert( iDb>=0 && iDb<db->nDb );
94715 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
94716 assert( iDb<SQLITE_MAX_ATTACHED+2 );
94717 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
94809 assert( (errCode&0xff)==SQLITE_CONSTRAINT );
94875 assert( zColl!=0 );
94878 assert( z!=0 || pIndex->aiColumn[i]<0 );
94918 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
94920 assert( pDb!=0 );
94964 assert( pName1->z );
95019 assert( sqlite3KeyInfoIsWriteable(pKey) );
95022 assert( zColl!=0 );
95069 assert( zName!=0 || pNew==0 );
95070 assert( db->mallocFailed==0 || pNew==0 );
95129 assert( !db->xCollNeeded || !db->xCollNeeded16 );
95210 assert( !p || p->xCmp );
95236 assert( p==pColl );
95283 assert( pDel==0 || pDel==pColl );
95321 assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
95322 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
95419 assert( pOther!=pDef && pOther->pNext!=pDef );
95463 assert( nArg>=(-2) );
95464 assert( nArg>=(-1) || createFlag==0 );
95618 assert( pItem && pSrc->nSrc==1 );
95687 assert( pFrom->nSrc==1 );
95690 assert( pFrom->a[0].pOn==0 );
95691 assert( pFrom->a[0].pUsing==0 );
95737 assert( pOffset == 0 );
95847 assert( pTabList->nSrc==1 );
95882 assert( iDb<db->nDb );
95885 assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
95889 assert(!isView || pTrigger);
95893 assert( pTabList->nSrc==1 );
95949 assert( !isView );
95956 assert( pIdx->pSchema==pTab->pSchema );
95972 assert( pPk!=0 );
96056 assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
96057 assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
96065 assert( nKey==nPk ); /* OP_Found will use an unpacked key */
96066 assert( !IsVirtual(pTab) );
96068 assert( pPk!=0 || pTab->pSelect!=0 );
96075 assert( nKey==0 ); /* OP_Found will use a composite key */
96079 assert( nKey==1 );
96191 assert( v );
96320 assert( iIdxCur+i!=iDataCur || pPk==pIdx );
96450 assert( context->pVdbe!=0 );
96452 assert( pOp->opcode==OP_CollSeq );
96453 assert( pOp->p4type==P4_COLLSEQ );
96478 assert( argc>1 );
96481 assert( pColl );
96482 assert( mask==-1 || mask==0 );
96526 assert( argc==1 );
96560 assert( argc==1 );
96697 assert( argc==3 || argc==2 );
96709 assert( len==sqlite3_value_bytes(argv[0]) );
96756 assert( p1>=0 && p2>=0 );
96784 assert( argc==1 || argc==2 );
96824 assert( nByte>0 );
96850 assert( z2==(char*)sqlite3_value_text(argv[0]) );
96869 assert( z2==(char*)sqlite3_value_text(argv[0]) );
96927 assert( argc==1 );
97098 assert( matchOther<0x80 ); /* '[' is a single-byte character */
97238 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
97338 assert( argc==1 );
97362 assert( argc==1 );
97387 assert( argc==1 );
97410 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
97451 assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
97526 assert( argc==1 );
97530 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
97553 assert( argc==1 );
97587 assert( argc==3 );
97592 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
97595 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
97600 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
97605 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
97609 assert( zRep==sqlite3_value_text(argv[2]) );
97611 assert( nOut<SQLITE_MAX_LENGTH );
97643 assert( j+nStr-i+1==nOut );
97646 assert( j<=nOut );
97675 assert( zIn==sqlite3_value_text(argv[0]) );
97765 assert( argc==1 );
97845 assert( argc==1 );
97914 assert( argc==1 || p==0 || p->n>0x7fffffff
97988 assert( argc==1 || argc==2 );
98033 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
98092 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
98105 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
98106 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
98107 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
98423 assert( ppIdx && *ppIdx==0 );
98424 assert( !paiCol || *paiCol==0 );
98425 assert( pParse );
98448 assert( nCol>1 );
98634 assert( aiCol[i]!=pTab->iPKey );
98662 assert( nIncr==1 );
98782 assert( pIdx==0 || pIdx->pTable==pTab );
98783 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
98784 assert( pIdx!=0 || pFKey->nCol==1 );
98785 assert( pIdx!=0 || HasRowid(pTab) );
98810 assert( iCol>=0 );
98839 assert( pIdx!=0 );
98934 assert( v ); /* VDBE has already been allocated */
99093 assert( (regOld==0)!=(regNew==0) );
99129 assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
99149 assert( pFKey->nCol==1 || (aiFree && pIdx) );
99215 assert( regOld==0 && regNew!=0 );
99225 assert( aiCol || pFKey->nCol==1 );
99402 assert( aiCol || pFKey->nCol==1 );
99413 assert( iFromCol>=0 );
99414 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
99532 assert( pStep!=0 );
99596 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
99616 assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
99664 assert( !IsVirtual(pTab) );
99666 assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
99674 assert( pPk!=0 );
99675 assert( pPk->tnum=pTab->tnum );
99795 assert( pOp!=0 );
99810 assert( pOp->p4.pVtab!=0 );
99811 assert( pOp->p4type==P4_VTAB );
99882 assert( pParse->pTriggerTab==0 );
99883 assert( pParse==sqlite3ParseToplevel(pParse) );
99885 assert( v ); /* We failed long ago if this is not so */
99889 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
99933 assert( v );
99941 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
100135 assert( pTabList->nSrc==1 );
100143 assert( iDb<db->nDb );
100166 assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
100199 assert( !pTrigger );
100200 assert( pList==0 );
100243 ipkColumn = i; assert( !withoutRowid );
100285 assert( pSelect->pEList );
100337 assert( useTempTable==0 );
100436 assert( !withoutRowid );
100440 assert( pSelect==0 ); /* Otherwise useTempTable is true */
100452 assert( !IsVirtual(pTab) );
100469 assert( pSelect==0 ); /* Otherwise useTempTable is true */
100555 assert( IsVirtual(pTab) );
100792 assert( v!=0 );
100793 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
100828 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
100850 assert( onError==OE_Replace );
101121 assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
101136 assert( onError==OE_Replace );
101189 assert( v!=0 );
101190 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
101202 assert( pParse->nested==0 );
101268 assert( op==OP_OpenRead || op==OP_OpenWrite );
101277 assert( v!=0 );
101289 assert( pIdx->pSchema==pTab->pSchema );
101343 assert( pDest && pSrc );
101344 assert( pDest->pTable!=pSrc->pTable );
101439 assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
101460 assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */
101468 assert( pEList!=0 );
101472 assert( pEList->a[0].pExpr );
101574 assert( HasRowid(pDest) || destHasUniqueIdx );
101615 assert( (pDest->tabFlags & TF_Autoincrement)==0 );
101633 assert( pSrcIdx );
101660 assert( zColl!=0 );
101743 assert( rc==SQLITE_OK || pStmt==0 );
101773 assert( azCols[i]!=0 );
101830 assert( (rc&db->errMask)==rc );
102934 assert( sqlite3_mutex_held(db->mutex) );
103033 assert( (rc&0xff)==rc );
103778 assert( SQLITE_FullFSync==PAGER_FULLFSYNC );
103779 assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC );
103780 assert( SQLITE_CacheSpill==PAGER_CACHESPILL );
103781 assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)
103783 assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
103810 assert( action==OE_None ); break;
103829 assert( PAGER_JOURNALMODE_DELETE==0 );
103830 assert( PAGER_JOURNALMODE_PERSIST==1 );
103831 assert( PAGER_JOURNALMODE_OFF==2 );
103832 assert( PAGER_JOURNALMODE_TRUNCATE==3 );
103833 assert( PAGER_JOURNALMODE_MEMORY==4 );
103834 assert( PAGER_JOURNALMODE_WAL==5 );
103835 assert( eMode>=0 && eMode<=ArraySize(azModeName) );
103901 assert( pId2 );
104018 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104038 assert( pBt!=0 );
104065 assert( pBt!=0 );
104139 assert(pDb==&db->aDb[0]);
104150 assert( eMode==PAGER_LOCKINGMODE_NORMAL
104235 assert( pBt!=0 );
104240 assert( eAuto>=0 && eAuto<=2 );
104312 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104340 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104761 assert( db->aDb[i].zName!=0 );
104897 assert( pParse->nErr>0 || pFK==0 );
104907 assert( x==0 );
104912 assert( iKey>=0 && iKey<pTab->nCol );
105011 assert( iDb>=0 );
105012 assert( iDb==0 || pId2->z );
105050 assert( sqlite3SchemaMutexHeld(db, i, 0) );
105161 assert( iCol>=0 && iCol<pTab->nCol );
105253 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
105254 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
105255 assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
105439 assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT );
105629 assert( argc==3 );
105631 assert( sqlite3_mutex_held(db->mutex) );
105638 assert( iDb>=0 && iDb<db->nDb );
105652 assert( db->init.busy );
105658 assert( (rc&0xFF)==(rcp&0xFF) );
105662 assert( iDb==1 );
105747 assert( iDb>=0 && iDb<db->nDb );
105748 assert( db->aDb[iDb].pSchema );
105749 assert( sqlite3_mutex_held(db->mutex) );
105750 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
105895 assert( db->init.busy );
105968 assert( sqlite3_mutex_held(db->mutex) );
105969 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
105970 assert( db->init.busy==0 );
105987 assert( db->nDb>1 );
106011 assert( sqlite3_mutex_held(db->mutex) );
106034 assert( pParse->checkSchema );
106035 assert( sqlite3_mutex_held(db->mutex) );
106057 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
106090 assert( sqlite3_mutex_held(db->mutex) );
106097 assert( i>=0 && i<db->nDb );
106137 assert( ppStmt && *ppStmt==0 );
106138 assert( !db->mallocFailed );
106139 assert( sqlite3_mutex_held(db->mutex) );
106167 assert( sqlite3BtreeHoldsMutex(pBt) );
106203 assert( 0==pParse->nQueryLoop );
106249 assert(!(*ppStmt));
106273 assert( (rc&db->errMask)==rc );
106303 assert( rc==SQLITE_OK || *ppStmt==0 );
106321 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
106323 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
106325 assert( sqlite3_mutex_held(db->mutex) );
106331 assert( pNew==0 );
106334 assert( pNew!=0 );
106361 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
106373 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
106449 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
106461 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
106582 assert( db->mallocFailed );
106600 assert( pOffset==0 || pLimit!=0 || pParse->nErr>0 || db->mallocFailed!=0 );
106607 assert( pNew->pSrc!=0 || pParse->nErr>0 );
106609 assert( pNew!=&standin );
106700 assert( pB!=0 );
106745 assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
106785 assert( iLeft<iRight );
106786 assert( pSrc->nSrc>iRight );
106787 assert( pSrc->a[iLeft].pTab );
106788 assert( pSrc->a[iRight].pTab );
106796 assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
106832 assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
106971 assert( bSeq==0 || bSeq==1 );
106973 assert( nPrefixReg==nExpr+bSeq );
107143 assert( v );
107144 assert( pEList!=0 );
107148 assert( iContinue!=0 );
107227 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
107238 assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
107292 assert( pSort==0 );
107314 assert( nResultCol==1 );
107346 assert( nResultCol==1 );
107350 assert( regResult==iParm );
107386 assert( pSO );
107428 assert( eDest==SRT_Discard );
107468 assert( p->nRef>0 );
107479 assert( p->nRef>0 );
107524 assert( sqlite3KeyInfoIsWriteable(pInfo) );
107608 assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
107707 assert( nColumn==1 );
107715 assert( nColumn==1 );
107722 assert( eDest==SRT_Output || eDest==SRT_Coroutine );
107844 assert( pTab && pExpr->pTab==pTab );
107864 assert( !pS );
107866 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
107901 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
107913 assert( pzOrigTab && pzOrigCol );
108003 assert( j<pTabList->nSrc );
108006 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
108082 assert( pColExpr!=0 );
108092 assert( !ExprHasProperty(pColExpr, EP_IntValue) );
108161 assert( pSelect!=0 );
108162 assert( (pSelect->selFlags & SF_Resolved)!=0 );
108163 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
108206 assert( db->lookaside.bEnabled==0 );
108209 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
108277 assert( p->pOffset==0 || p->pLimit!=0 );
108281 assert( v!=0 );
108330 assert( iCol>=0 );
108366 assert( sqlite3KeyInfoIsWriteable(pRet) );
108523 assert( p->pPrior==0 );
108579 assert( p->selFlags & SF_MultiValue );
108581 assert( p->selFlags & SF_Values );
108582 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
108583 assert( p->pLimit==0 );
108584 assert( p->pOffset==0 );
108590 assert( p->pPrior->pNext==p );
108656 assert( p && p->pPrior ); /* Calling function guarantees this much */
108657 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
108675 assert( v!=0 ); /* The VDBE already created by calling function */
108680 assert( p->pEList );
108696 assert( p->pEList && pPrior->pEList );
108721 assert( !pPrior->pLimit );
108773 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
108774 assert( p->pOffset==0 ); /* Not allowed on leftward elements */
108781 assert( p->pOrderBy==0 );
108783 assert( p->addrOpenEphm[0] == -1 );
108786 assert( p->pEList );
108791 assert( !pPrior->pOrderBy );
108804 assert( p->op==TK_UNION );
108832 assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
108835 assert( p->pEList );
108855 default: assert( p->op==TK_INTERSECT ); {
108869 assert( p->pOrderBy==0 );
108872 assert( p->addrOpenEphm[0] == -1 );
108875 assert( p->pEList );
108889 assert( p->addrOpenEphm[1] == -1 );
108910 assert( p->pEList );
108953 assert( p->pNext==0 );
108973 assert( pLoop->addrOpenEphm[1]<0 );
109073 assert( pIn->nSdst==1 || pParse->nErr>0 );
109099 assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 );
109128 assert( pDest->eDest==SRT_Output );
109279 assert( p->pOrderBy!=0 );
109280 assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
109283 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
109292 assert( pPrior->pOrderBy==0 );
109294 assert( pOrderBy );
109305 assert( pItem->u.x.iOrderByCol>0 );
109330 assert( pItem->u.x.iOrderByCol>0 );
109354 assert( nOrderBy>=nExpr || db->mallocFailed );
109360 assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
109577 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
109578 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
109623 assert( pSrc ); /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
109794 assert( p!=0 );
109795 assert( p->pPrior==0 ); /* Unable to flatten compound queries */
109798 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
109802 assert( pSub!=0 );
109815 assert( pSubSrc );
109902 assert( pSub->pSrc!=0 );
110053 assert( pParent==p ); /* First time through the loop */
110056 assert( pParent!=p ); /* 2nd and subsequent times through the loop */
110059 assert( db->mallocFailed );
110136 assert( pParent->pOrderBy==0 );
110137 assert( pSub->pPrior==0 );
110149 assert( pParent->pHaving==0 );
110155 assert( pParent->pGroupBy==0 );
110218 assert( pExpr->op==TK_AGG_FUNCTION );
110231 assert( *ppMinMax==0 || (*ppMinMax)->nExpr==1 );
110250 assert( !p->pGroupBy );
110259 assert( pTab && !pTab->pSelect && pExpr );
110357 assert( (p->selFlags & SF_Converted)==0 );
110359 assert( pNew->pPrior!=0 );
110409 assert( bFree==0 || pParse->pWith==0 );
110441 assert( pFrom->pTab==0 );
110461 assert( pFrom->pTab==0 );
110467 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
110471 assert( pFrom->pSelect );
110500 assert( pTab->nRef==1 || ((pSel->selFlags&SF_Recursive) && pTab->nRef==2 ));
110550 assert( pParse->pWith==pWith );
110616 assert( pFrom->isRecursive==0 || pFrom->pTab );
110621 assert( i==0 );
110635 assert( pSel!=0 );
110636 assert( pFrom->pTab==0 );
110645 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
110650 assert( pFrom->pTab==0 );
110664 assert( pFrom->pSelect==0 );
110697 assert( pE->op!=TK_DOT || pE->pRight!=0 );
110698 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
110716 assert( (p->selFlags & SF_NestedFrom)==0
110723 assert( pE->op!=TK_DOT || pRight!=0 );
110741 assert( pE->pLeft!=0 );
110742 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
110769 assert( zName );
110781 assert(IsVirtual(pTab));
110921 assert( p->selFlags & SF_Resolved );
111007 assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
111009 assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
111013 assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
111021 assert( !ExprHasProperty(pE, EP_xIsSelect) );
111045 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
111069 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
111088 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
111212 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
111213 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
111214 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
111215 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
111217 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
111236 assert( pEList!=0 );
111329 assert( pItem->addrFillSub==0 );
111406 assert( sDistinct.isTnct );
111564 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
111893 assert( p->pGroupBy==0 );
111894 assert( flag==0 );
111898 assert( flag==0 || (pMinMax!=0 && pMinMax->nExpr==1) );
111920 assert( pMinMax==0 || pMinMax->nExpr==1 );
112224 assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
112268 assert( azResult!=0 );
112334 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
112378 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
112379 assert( pName2!=0 );
112380 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
112381 assert( op>0 && op<0xff );
112427 assert( pTableName->nSrc==1 );
112459 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112464 assert( !db->init.busy );
112527 assert( pParse->pNewTrigger==0 );
112538 assert( pParse->pNewTrigger==pTrigger );
112601 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112608 assert( pTab!=0 );
112616 assert( !pParse->pNewTrigger );
112679 assert(pSelect != 0 || db->mallocFailed);
112773 assert( pName->nSrc==1 );
112776 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
112780 assert( sqlite3SchemaMutexHeld(db, j, 0) );
112818 assert( iDb>=0 && iDb<db->nDb );
112820 assert( pTable );
112821 assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
112837 assert( pTable!=0 );
112874 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112927 assert( pList==0 || IsVirtual(pTab)==0 );
112959 assert( pSrc->nSrc>0 );
112963 assert( iDb<db->nDb );
112983 assert( pParse->pTriggerTab && pParse->pToplevel );
112984 assert( pStepList );
112985 assert( v!=0 );
113001 assert( pParse->okConstFactor==0 );
113029 default: assert( pStep->op==TK_SELECT ); {
113070 assert( pFrom->zErrMsg==0 || pFrom->nErr );
113071 assert( pTo->zErrMsg==0 || pTo->nErr );
113101 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
113102 assert( pTop->pVdbe );
113185 assert( !pSubParse->pAinc && !pSubParse->pZombieTab );
113186 assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
113208 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
113244 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
113318 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
113319 assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
113320 assert( (op==TK_UPDATE)==(pChanges!=0) );
113327 assert( p->pSchema!=0 );
113328 assert( p->pTabSchema!=0 );
113329 assert( p->pSchema==p->pTabSchema
113380 assert( isNew==1 || isNew==0 );
113460 assert( pTab!=0 );
113466 assert( i<pTab->nCol );
113547 assert( pTabList->nSrc==1 );
113561 assert( pTrigger || tmask==0 );
113659 assert( (chngRowid & chngPk)==0 );
113660 assert( chngRowid==0 || chngRowid==1 );
113661 assert( chngPk==0 || chngPk==1 );
113768 assert( pPk!=0 );
113833 assert( pPk );
113859 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
113966 assert( regOldRowid>0 );
114034 assert( aRegIdx );
114128 assert( pTab->iPKey<0 );
114142 assert( v );
114221 assert( rc!=SQLITE_ROW || (db->flags&SQLITE_CountRows) );
114349 assert( strcmp(pDb->zName,"vacuum_db")==0 );
114426 assert( (db->flags & SQLITE_Vacuum)==0 );
114435 assert( (db->flags & SQLITE_Vacuum)!=0 );
114492 assert( 1==sqlite3BtreeIsInTrans(pTemp) );
114493 assert( 1==sqlite3BtreeIsInTrans(pMain) );
114513 assert( rc==SQLITE_OK );
114610 assert( pDel==0 || pDel==pMod );
114676 assert( IsVirtual(pTab) );
114688 assert( db );
114689 assert( pVTab->nRef>0 );
114690 assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
114720 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
114725 assert( db2 );
114737 assert( !db || pRet );
114752 assert( IsVirtual(p) );
114753 assert( sqlite3BtreeHoldsAllMutexes(db) );
114754 assert( sqlite3_mutex_held(db->mutex) );
114791 assert( sqlite3BtreeHoldsAllMutexes(db) );
114792 assert( sqlite3_mutex_held(db->mutex) );
114874 assert( 0==pTable->pIndex );
114878 assert( iDb>=0 );
114885 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
114992 assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
114996 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
115023 assert(pArg->z <= p->z);
115077 assert( &db->pVtabCtx );
115078 assert( xConstruct );
115087 assert( sCtx.pTab==pTab );
115145 assert(zType[i-1]==' ');
115174 assert( pTab );
115245 assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
115299 assert( (pTab->tabFlags & TF_Virtual)!=0 );
115337 assert( (rc&0xff)==rc );
115358 assert( p->pVtab );
115367 assert( pTab->pVTable==p && p->pNext==0 );
115514 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
115515 assert( iSavepoint>=-1 );
115581 assert( pVtab!=0 );
115582 assert( pVtab->pModule!=0 );
115628 assert( IsVirtual(pTab) );
115656 assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
115657 assert( OE_Ignore==4 && OE_Replace==5 );
115658 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
115682 assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
116224 assert( pWInfo->iContinue!=0 );
116454 assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
116472 assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
116536 assert( TK_GT>TK_EQ && TK_GT<TK_GE );
116537 assert( TK_LT>TK_EQ && TK_LT<TK_GE );
116538 assert( TK_LE>TK_EQ && TK_LE<TK_GE );
116539 assert( TK_GE==TK_EQ+4 );
116558 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
116574 assert( TK_LT==TK_GT+2 );
116575 assert( TK_GE==TK_LE+2 );
116576 assert( TK_GT>TK_EQ );
116577 assert( TK_GT<TK_LE );
116578 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
116588 assert( allowedOp(op) );
116594 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
116597 assert( op!=TK_ISNULL || c==WO_ISNULL );
116598 assert( op!=TK_IN || c==WO_IN );
116599 assert( op!=TK_EQ || c==WO_EQ );
116600 assert( op!=TK_LT || c==WO_LT );
116601 assert( op!=TK_LE || c==WO_LE );
116602 assert( op!=TK_GT || c==WO_GT );
116603 assert( op!=TK_GE || c==WO_GE );
116634 assert( pX->op==TK_COLUMN );
116656 assert(pX->pLeft);
116844 assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
116856 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
116999 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
117000 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
117008 assert( eOp & (WO_GT|WO_GE) );
117015 for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
117131 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
117132 assert( pExpr->op==TK_OR );
117141 assert( pOrWc->nTerm>=2 );
117151 assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
117170 assert( pAndTerm->pExpr );
117254 assert( pOrTerm->eOperator & WO_EQ );
117259 assert( j==1 );
117269 assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
117279 assert( j==1 );
117280 assert( IsPowerOfTwo(chngToIN) );
117281 assert( chngToIN==getMask(&pWInfo->sMaskSet, iCursor) );
117290 assert( pOrTerm->eOperator & WO_EQ );
117324 assert( pOrTerm->eOperator & WO_EQ );
117325 assert( pOrTerm->leftCursor==iCursor );
117326 assert( pOrTerm->u.leftColumn==iColumn );
117331 assert( pLeft!=0 );
117337 assert( !ExprHasProperty(pNew, EP_xIsSelect) );
117396 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
117400 assert( pExpr->pRight==0 );
117490 assert( pList!=0 );
117491 assert( pList->nExpr==2 );
117513 assert( pWC->op==TK_AND );
117899 assert( v!=0 );
117911 assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */
117941 assert( nKeyCol>0 );
117989 assert( (u32)n==pLoop->u.btree.nEq );
118007 assert( n==nKeyCol );
118012 assert( pLevel->iIdxCur>=0 );
118070 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
118123 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
118137 assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
118138 assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
118139 assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
118140 assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
118141 assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
118142 assert( WO_MATCH==SQLITE_INDEX_CONSTRAINT_MATCH );
118143 assert( pTerm->eOperator & (WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) );
118235 assert( pRec!=0 );
118236 assert( pIdx->nSample>0 );
118237 assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol );
118326 assert( i<pIdx->nSample );
118327 assert( iCol==nField-1 );
118329 assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
118336 assert( i<=pIdx->nSample && i>=0 );
118338 assert( i==pIdx->nSample
118348 assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0
118353 assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
118362 assert( iCol==nField-1 );
118413 nRet -= 20; assert( 20==sqlite3LogEst(4) );
118517 assert( *pbDone==0 );
118634 assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 );
118635 assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 );
118636 assert( p->aSortOrder!=0 );
118680 if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) );
118682 nNew = 10; assert( 10==sqlite3LogEst(2) );
118699 assert( pLower || pUpper );
118701 assert( pUpper==0 || (pUpper->wtFlags & TERM_VNULL)==0 );
118760 assert( nEq>=1 );
118761 assert( nEq<=p->nColumn );
118762 assert( p->aSample!=0 );
118763 assert( p->nSample>0 );
118764 assert( pBuilder->nRecValid<nEq );
118825 assert( p->aSample!=0 );
118838 assert( pBuilder->nRecValid==nRecValid );
118919 assert( pParse->db->mallocFailed );
118922 assert( v!=0 );
118968 assert( iTarget>0 );
118989 assert( pX->op==TK_IN );
119000 assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
119094 assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 );
119098 assert( pIdx!=0 );
119125 assert( pIdx->aiColumn[j]>=0 );
119132 assert( zAff==0 || (int)strlen(zAff)>=nEq );
119136 assert( pTerm!=0 );
119295 assert( pLoop->u.btree.pIndex!=0 );
119297 assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
119325 assert( flags&WHERE_TOP_LIMIT);
119403 assert( pLevel->iLikeRepCntr>0 );
119405 assert( pOp!=0 );
119406 assert( pOp->opcode==OP_String8
119538 assert( pLoop->u.btree.nEq==1 );
119540 assert( pTerm!=0 );
119541 assert( pTerm->pExpr!=0 );
119542 assert( omitTable==0 );
119565 assert( omitTable==0 );
119570 assert( pStart!=0 || pEnd!=0 );
119589 assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */
119590 assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */
119591 assert( TK_GE==TK_GT+3 ); /* ... is correcct. */
119593 assert( (pStart->wtFlags & TERM_VNULL)==0 );
119596 assert( pX!=0 );
119616 assert( pX!=0 );
119617 assert( (pEnd->wtFlags & TERM_VNULL)==0 );
119633 assert( pLevel->p5==0 );
119712 assert( nEq>=pLoop->nSkip );
119722 assert( pWInfo->pOrderBy==0
119729 assert( pLoop->nSkip==0 );
119742 assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
119749 assert( pRangeStart!=0 ); /* LIKE opt constraints */
119750 assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */
119767 assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 );
119774 assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq );
119830 assert( op!=0 );
119918 assert( pLevel->p5==0 );
119984 assert( pTerm!=0 );
119985 assert( pTerm->eOperator & WO_OR );
119986 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
120092 assert( pSubWInfo || pParse->nErr || db->mallocFailed );
120177 assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
120182 assert( pSubWInfo->a[0].iIdxCur==iCovCur );
120215 assert( bRev==0 || bRev==1 );
120250 assert( pE!=0 );
120255 assert( pLevel->iLikeRepCntr>0 );
120280 assert( !ExprHasProperty(pE, EP_FromJoin) );
120281 assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
120310 assert( pWInfo->untestedTerms );
120313 assert( pTerm->pExpr );
120601 assert( p->rSetup==0 || pTemplate->rSetup==0
120607 assert( p->rSetup>=pTemplate->rSetup );
120643 assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */
120807 assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
120892 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
120893 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
120903 assert( pNew->u.btree.nEq<pProbe->nColumn );
120943 assert( nInMul==0
120954 nIn = 46; assert( 46==sqlite3LogEst(25) );
120959 assert( nIn>0 ); /* RHS always has 2 or more terms... The parser
120983 assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
120984 assert( pTop->wtFlags & TERM_LIKEOPT );
120985 assert( pTop->eOperator==WO_LT );
120991 assert( eOp & (WO_LT|WO_LE) );
121005 assert( pNew->nOut==saved_nOut );
121012 assert( eOp & (WO_ISNULL|WO_EQ|WO_IN) );
121014 assert( pNew->nOut==saved_nOut );
121016 assert( (eOp & WO_IN) || nIn==0 );
121108 assert( 42==sqlite3LogEst(18) );
121263 assert( !IsVirtual(pSrc->pTab) );
121337 pNew->nOut = 43; assert( 43==sqlite3LogEst(20) );
121366 assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 );
121468 assert( IsVirtual(pTab) );
121506 assert( seenIn );
121510 assert( seenVar );
121514 assert( seenVar && seenIn );
121532 assert( pNew->nLSlot>=nConstraint );
121552 assert( iTerm<pNew->nLSlot );
121577 assert( pNew->nLTerm<=pNew->nLSlot );
121674 assert( rc==SQLITE_OK || sCur.n==0 );
121837 assert( pOrderBy!=0 );
121892 assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
121893 assert( pIndex->aiColumn[nColumn-1]==(-1) || !HasRowid(pIndex->pTable));
122046 assert( pWInfo->wctrlFlags & WHERE_GROUPBY );
122047 assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP );
122088 assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
122143 assert( nLoop<=pWInfo->pTabList->nSrc );
122179 assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] );
122180 assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX );
122187 aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) );
122189 assert( aFrom[0].isOrdered==0 );
122394 assert( pWInfo->nLevel==nLoop );
122431 assert( pWInfo->sorted==0 );
122471 assert( pWInfo->pTabList->nSrc>=1 );
122491 assert( pLoop->aLTermSpace==pLoop->aLTerm );
122701 assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) );
122758 assert( (m-1)==toTheLeft );
122893 assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
122935 assert( pTabItem->iCursor==pLevel->iTabCur );
122944 assert( n<=pTab->nCol );
122954 assert( iIdxCur!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 );
122965 assert( wctrlFlags & WHERE_ONEPASS_DESIRED );
122979 assert( pIx->pSchema==pTab->pSchema );
122980 assert( iIndexCur>=0 );
123102 assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
123126 assert( pWInfo->nLevel<=pTabList->nSrc );
123133 assert( pTab!=0 );
123205 assert( pIdx->pTable==pTab );
123215 assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 );
124793 assert( iLookAhead!=YYNOCODE );
124857 assert( stateno<=YY_REDUCE_COUNT );
124860 assert( i!=YY_REDUCE_USE_DFLT );
124861 assert( iLookAhead!=YYNOCODE );
124868 assert( i>=0 && i<YY_ACTTAB_COUNT );
124869 assert( yy_lookahead[i]==iLookAhead );
126362 assert( yymsp[-2].minor.yy473!=0 );
126370 assert( yymsp[-1].minor.yy473!=0 );
126552 assert( yyruleno>=0 && yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
126575 assert( yyact == YYNSTATE + YYNRULE + 1 );
126612 assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */
126707 assert( yyact == YY_ERROR_ACTION );
127479 assert( zSql!=0 );
127487 assert( pzErrMsg!=0 );
127493 assert( pParse->pNewTable==0 );
127494 assert( pParse->pNewTrigger==0 );
127495 assert( pParse->nVar==0 );
127496 assert( pParse->nzVar==0 );
127497 assert( pParse->azVar==0 );
127501 assert( i>=0 );
127538 assert( nErr==0 );
127563 assert( pzErrMsg!=0 );
127607 assert( nErr==0 || pParse->rc!=SQLITE_OK );
128137 assert( SQLITE_PTRSIZE==sizeof(char*) );
128235 assert( sqlite3GlobalConfig.nRefInitMutex==0 );
128252 assert(sizeof(x)==8);
128253 assert(sizeof(x)==sizeof(y));
128255 assert( sqlite3IsNaN(y) );
128670 assert( sz > (int)sizeof(LookasideSlot*) );
128948 assert( sqlite3_mutex_held(db->mutex) );
129075 assert( db->nDb<=2 );
129076 assert( db->aDb==db->aDbStatic );
129137 assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
129155 assert( sqlite3_mutex_held(db->mutex) );
129376 assert( count>=0 );
129526 assert( sqlite3_mutex_held(db->mutex) );
129536 assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
129577 assert( !db->mallocFailed );
129585 assert(p || db->mallocFailed);
129656 assert( rc!=SQLITE_OK );
129685 assert( !db->mallocFailed );
129964 assert( SQLITE_CHECKPOINT_PASSIVE==0 );
129965 assert( SQLITE_CHECKPOINT_FULL==1 );
129966 assert( SQLITE_CHECKPOINT_RESTART==2 );
129967 assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
130029 assert( sqlite3_mutex_held(db->mutex) );
130030 assert( !pnLog || *pnLog==-1 );
130031 assert( !pnCkpt || *pnCkpt==-1 );
130101 assert( !db->mallocFailed );
130203 assert( sqlite3_mutex_held(db->mutex) );
130347 assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
130348 assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
130349 assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
130350 assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
130351 assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
130352 assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
130353 assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
130354 assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
130355 assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
130357 assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
130358 assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
130359 assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
130360 assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
130415 assert( *pzErrMsg==0 );
130482 assert( octet>=0 && octet<256 );
130658 assert( SQLITE_OPEN_READONLY == 0x01 );
130659 assert( SQLITE_OPEN_READWRITE == 0x02 );
130660 assert( SQLITE_OPEN_CREATE == 0x04 );
130723 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
130778 assert( db->pDfltColl!=0 );
130898 assert( db->mutex!=0 || isThreadsafe==0
130903 assert( db!=0 || rc==SQLITE_NOMEM );
130967 assert( *ppDb || rc==SQLITE_NOMEM );
131010 assert( !db->mallocFailed );
131035 assert( !db->mallocFailed );
131326 assert( pPager!=0 );
131328 assert( fd!=0 );
131470 assert( (x = va_arg(ap,int))!=0 );
131804 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) )
131836 assert( p->pUnlockConnection || p->pBlockingConnection );
131841 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
131842 assert( db==0 || p->pUnlockConnection!=db );
131843 assert( db==0 || p->pBlockingConnection!=db );
131958 assert( !db->mallocFailed );
132020 assert( p->xUnlockNotify );
132027 assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
132028 assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
133311 SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; }
133312 SQLITE_PRIVATE int sqlite3Fts3Never(int b) { assert( !b ); return b; }
133329 assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
133377 assert( a & 0x80 );
133484 assert( p->nPendingData==0 );
133485 assert( p->pSegments==0 );
133683 assert( p->bHasStat==p->bFts4 );
133717 assert( p->nPgsz>0 || rc!=SQLITE_OK );
133987 assert( nPrefix>=0 );
134140 assert( strlen(argv[0])==4 );
134141 assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4)
134261 assert( iOpt==6 );
134319 assert( nString==0 );
134329 assert( pTokenizer );
134333 assert( zPrefix );
134397 assert( zCsr <= &((char *)p)[nByte] );
134469 assert( p->pSegments==0 );
134636 assert( p->pSegments==0 );
134666 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
134672 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
134815 assert( zBuffer );
134885 assert( piLeaf || piLeaf2 );
134889 assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
134926 assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) );
135181 assert( isSaveLeft==0 || isExact==0 );
135183 assert( p!=0 && *p1!=0 && *p2!=0 );
135205 assert( *p1!=POS_END && *p1!=POS_COLUMN );
135206 assert( *p2!=POS_END && *p2!=POS_COLUMN );
135218 assert( p );
135230 assert( pp && p );
135236 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
135395 assert( *pbFirst || *piPrev==0 );
135396 assert( *pbFirst==0 || iWrite>0 );
135504 assert( *pnOut<=n1+n2+FTS3_VARINT_MAX-1 );
135538 assert( nDist>0 );
135734 assert( iOut>0 );
135879 assert( iIndex>=0 && iIndex<p->nIndex );
135880 assert( iLevel==FTS3_SEGCURSOR_ALL
135884 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
135885 assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
135886 assert( isPrefix==0 || isScan==0 );
136088 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
136158 assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
136159 assert( p->pSegments==0 );
136167 assert( iIdx==nVal );
136198 assert( p->base.zErrMsg==0 );
136289 assert( iCol>=0 && iCol<=p->nColumn+2 );
136320 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
136376 assert( rc==SQLITE_OK || mxLevel==0 );
136418 assert( p->pSegments==0 );
136419 assert( p->nPendingData==0 );
136420 assert( p->inTransaction!=1 );
136435 assert( p->nPendingData==0 );
136436 assert( p->inTransaction!=0 );
136437 assert( p->pSegments==0 );
136450 assert( p->inTransaction!=0 );
136475 assert( p==pStart || c==0 );
136543 assert( nVal>=1 );
136580 assert( nVal==1 );
136582 assert( pCsr );
136608 assert( nVal==1 );
136611 assert( p );
136637 assert( nVal==1 || nVal==2 );
136705 assert( p->nPendingData==0 );
136748 assert( ((Fts3Table *)pVtab)->inTransaction );
136749 assert( ((Fts3Table *)pVtab)->mxSavepoint < iSavepoint );
136766 assert( p->inTransaction );
136767 assert( p->mxSavepoint >= iSavepoint );
136780 assert( p->inTransaction );
136781 assert( p->mxSavepoint >= iSavepoint );
136936 assert( rc!=SQLITE_OK );
136981 assert( pExpr->pPhrase->iDoclistToken==0 );
137009 assert( iToken!=p->iDoclistToken );
137075 assert( pToken->pDeferred==0 || pToken->pSegcsr==0 );
137085 assert( pToken->pSegcsr==0 );
137107 assert( pPhrase->doclist.bFreeList==0 );
137134 assert( iPrev>=0 );
137257 assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
137282 assert( nDoclist>0 );
137283 assert( *pbEof==0 );
137284 assert( p || *piDocid==0 );
137285 assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
137337 assert( nDoclist>0 );
137338 assert( *pbEof==0 );
137339 assert( p || *piDocid==0 );
137340 assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) );
137401 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
137436 assert( p->bIgnore==0 );
137437 assert( pPhrase->aToken[iToken].pSegcsr==0 );
137444 assert( pToken->pDeferred==0 );
137445 assert( pToken->pSegcsr || pPhrase->iDoclistToken>=0 );
137447 assert( p->bIgnore==0 );
137490 assert( p->bIncr==1 );
137502 assert( p->nToken<=MAX_INCR_PHRASE_TOKENS );
137503 assert( p->iDoclistToken<MAX_INCR_PHRASE_TOKENS );
137518 assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) );
137519 assert( rc!=SQLITE_OK || bMaxSet );
137692 assert( pExpr->eType==FTSQUERY_OR
137696 assert( pExpr->pLeft && pExpr->pRight );
137748 assert( a );
137762 assert( pCsr->nRowAvg>0 );
137823 assert( rc!=SQLITE_OK || nDocSize>0 );
137860 assert( pTC );
137885 assert( rc==SQLITE_OK || pList==0 );
138013 assert( pPhrase->doclist.pList );
138021 assert( pPhrase->doclist.pList[nNew]=='\0' );
138022 assert( nNew<=pPhrase->doclist.nList && nNew>0 );
138080 assert( pExpr->bEof==0 );
138088 assert( !pLeft->bDeferred || !pRight->bDeferred );
138142 assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
138143 assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
138171 assert( *pRc!=SQLITE_OK || pRight->bStart );
138273 assert( p->pParent && p->pParent->pLeft==p );
138368 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
138444 assert( pCsr->isEof==0 );
138452 assert( sqlite3_data_count(pCsr->pStmt)==0 );
138496 assert( pToken->pDeferred==0 );
138532 assert( *p );
138574 assert( pExpr->eType==FTSQUERY_PHRASE );
138591 assert( pRoot->bStart );
138596 assert( pE->aMI==0 );
138609 assert( sqlite3_data_count(pCsr->pStmt)==0 );
138642 assert( pRoot->bEof==0 );
138690 assert( pCsr->nDoc>0 );
138698 assert( pExpr->aMI );
138743 assert( iCol>=0 && iCol<pTab->nColumn );
138782 assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
139210 assert( iCol==0 );
139229 default: assert( eState==3 );
139271 assert( idxStr==0 );
139272 assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
139304 assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) );
139359 assert( p->isEof==0 );
139382 assert( iCol==4 );
139583 assert( rc==SQLITE_OK || pCsr==0 );
139767 assert( nToken==ii );
139802 assert( nTemp==0 );
139887 assert( nKey==4 );
140000 assert( p->eType!=FTSQUERY_PHRASE );
140008 assert( p->eType==FTSQUERY_AND );
140031 assert( pSplit->pParent->pRight==pSplit );
140070 assert( nByte>0 || (rc!=SQLITE_OK && p==0) );
140112 assert( pRet && pPrev );
140144 assert( pPrev && pPrev->pLeft && pPrev->pRight==0 );
140157 assert( nByte>0 );
140159 assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
140251 assert( p->pParent==0 || p->pParent->pLeft==p );
140252 assert( p->pLeft && p->pRight );
140260 assert( pParent==0 || pParent->pLeft==p );
140275 assert( pFree );
140300 assert( pParent->pParent==0 || pParent->pParent->pLeft==pParent );
140305 assert( pParent==pRoot );
140323 assert( pFree!=0 );
140350 assert( pFree==0 );
140403 assert( rc==SQLITE_OK || *ppExpr==0 );
140482 assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
140497 assert( pDel==0 || pDel->pParent==0 );
140499 assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft );
140507 assert( p==p->pParent->pRight || p==p->pParent->pLeft );
140655 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
140679 assert( rc==SQLITE_OK || pExpr==0 );
140784 assert( pNew!=0 );
140785 assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
140801 assert( pH!=0 );
140868 assert( keyClass==FTS3_HASH_BINARY );
140883 assert( keyClass==FTS3_HASH_BINARY );
140925 assert( (new_size & (new_size-1))==0 );
141000 assert( pH->first==0 );
141001 assert( pH->count==0 );
141016 assert( xHash!=0 );
141018 assert( (pH->htsize & (pH->htsize-1))==0 );
141061 assert( pH!=0 );
141063 assert( xHash!=0 );
141065 assert( (pH->htsize & (pH->htsize-1))==0 );
141084 assert( pH->htsize>0 );
141099 assert( pH->htsize>0 );
141100 assert( (pH->htsize & (pH->htsize-1))==0 );
141262 assert( x>='a' && x<='z' );
141271 assert( x>='a' && x<='z' );
141834 assert( argc==1 || argc==2 );
141939 assert( n==0 );
141968 assert( rc!=SQLITE_OK || *ppTok );
142187 assert( rc==SQLITE_OK );
142188 assert( p1==p2 );
142190 assert( rc==SQLITE_ERROR );
142191 assert( p2==0 );
142192 assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
142196 assert( rc==SQLITE_OK );
142198 assert( rc==SQLITE_OK );
142199 assert( p2==p1 );
142692 assert( (rc==SQLITE_OK)==(pMod!=0) );
142757 assert( pInfo->estimatedCost>1000000.0 );
142902 assert( iCol==4 );
143352 assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
143353 assert( eStmt<SizeofArray(azSql) && eStmt>=0 );
143370 assert( rc==SQLITE_OK || pStmt==0 );
143526 assert( iLangid>=0 );
143527 assert( p->nIndex>0 );
143528 assert( iIndex>=0 && iIndex<p->nIndex );
143561 assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 );
143562 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
143563 assert( iIndex>=0 && iIndex<p->nIndex );
143652 assert( !p || p->iLastDocid<=iDocid );
143657 assert( p->nData<p->nSpace );
143658 assert( p->aData[p->nData]==0 );
143678 assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
143724 assert( 0==fts3HashFind(pHash, zToken, nToken) );
143764 assert( pTokenizer && pModule );
143825 assert( iLangid>=0 );
143987 assert( p->zContentTbl==0 || bContent==0 );
144024 assert( *pbFound==0 );
144086 assert( iLangid>=0 );
144087 assert( p->nIndex>=1 );
144156 assert( pnBlob );
144231 assert( !pReader->pBlob
144288 assert( pReader->aNode );
144297 assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock );
144307 assert( pReader->pBlob==0 );
144315 assert( !fts3SegReaderIsPending(pReader) );
144368 assert( pReader->aDoclist );
144369 assert( !pReader->pOffsetList );
144408 assert( p );
144443 assert( *p==0 );
144498 assert( p->bFts4 );
144499 assert( pgsz>0 );
144552 assert( iStartLeaf<=iEndLeaf );
144737 assert( rc!=0 );
144761 assert( pLhs->aNode && pRhs->aNode );
144773 assert( pLhs->aNode && pRhs->aNode );
144818 assert( nSuspect<=nSegment );
144835 assert( xCmp(apSegment[i], apSegment[i+1])<0 );
144974 assert( pTree->aData==(char *)&pTree[1] );
145057 assert( iHeight>=1 && iHeight<128 );
145108 assert( iNextLeaf==iFree );
145130 assert( pRight==0 || p->zMalloc==0 );
145218 assert( nPrefix<nTerm );
145246 assert( nData+nReq<=pWriter->nSize );
145272 assert( pWriter->zTerm==pWriter->zMalloc );
145378 assert( iIndex>=0 && iIndex<p->nIndex );
145485 assert( iLevel>=0 || iLevel==FTS3_SEGCURSOR_ALL );
145535 assert( iCol>=0 );
145633 assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
145708 assert( pCsr->pFilter==0 );
145709 assert( zTerm && nTerm>0 );
145731 assert( iCol<0 || iCol<p->nColumn );
145752 assert( pCsr->zTerm==0 );
145753 assert( pCsr->nTerm==0 );
145754 assert( pCsr->aDoclist==0 );
145755 assert( pCsr->nDoclist==0 );
145811 assert( rc==SQLITE_OK );
145842 assert( isIgnoreEmpty || (isRequirePos && !isColFilter) );
145898 assert( iDelta>0 || (nDoclist==0 && iDelta==iDocid) );
145899 assert( nDoclist>0 || iDelta==iDocid );
146124 assert( iLevel==FTS3_SEGCURSOR_ALL
146128 assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
146129 assert( iIndex>=0 && iIndex<p->nIndex );
146156 assert( FTS3_SEGCURSOR_PENDING==-1 );
146163 assert( csr.nSegment>0 );
146164 assert( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) );
146165 assert( iNewLevel<getAbsoluteLevel(p, iLangid, iIndex,FTS3_SEGDIR_MAXLEVEL) );
146179 assert( pWriter || bIgnoreEmpty );
146269 assert(j<=nBuf);
146544 assert( pCsr->nSegment==0 );
146664 assert( p->aNode );
146688 assert( p->iOff<=p->nNode );
146742 assert( nTerm>0 );
146793 assert( pNode->block.nAlloc>=p->nNodeSize );
146806 assert( 0 );
146849 assert( pNode->n>0 );
146850 assert( (pNode->a[0]=='\0')==(aDoclist!=0) );
146873 assert( pNode->n<=pNode->nAlloc );
146986 assert( *pRc || pNode->block.nAlloc==0 );
146987 assert( *pRc || pNode->key.nAlloc==0 );
147169 assert( reader.aNode );
147422 assert( p->bIgnoreSavepoint==0 );
147441 assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) );
147444 assert( pNode->nAlloc>=1 );
147496 assert( pNew->n<=pNew->nAlloc );
147617 assert( j<pCsr->nSegment && pSeg->iIdx==i );
147834 assert( bUseHint==1 || bUseHint==0 );
147946 assert( p->bFts4==0 );
147976 assert( p->bFts4==0 );
148034 assert( *pRc==SQLITE_OK );
148311 assert( pCsr->isRequireSeek==0 );
148399 assert( pToken->pDeferred==0 );
148476 assert( p->bHasStat==0 || p->bHasStat==1 );
148478 assert( p->pSegments==0 );
148479 assert(
148564 assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER );
148582 assert( p->iPrevDocid==*pRowid );
148774 assert( pExpr->pLeft && pExpr->pRight );
148956 assert( iCsr>=iStart );
148993 assert( rc==SQLITE_OK || pCsr==0 );
148998 assert( iFirst>=0 );
149004 assert( rc!=SQLITE_OK || (
149091 assert( iScore>=0 );
149135 assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) );
149215 assert( nShift<=nDesired );
149454 assert( pExpr->pPhrase );
149473 assert( *pIter==0x00 || *pIter==0x01 );
149524 assert( cArg==FTS3_MATCHINFO_HITS );
149547 assert( sqlite3_data_count(pStmt)==1 );
149783 assert( zArg[i]==FTS3_MATCHINFO_HITS );
149829 assert( pCsr->aMatchinfo );
149956 assert( (mCovered&mSeen)==mCovered );
149960 assert( nFToken>0 );
150012 assert( iPos>=0 );
150046 assert( pCsr->isRequireSeek==0 );
150122 assert( iCurrent<=iMinPos );
150152 assert( rc!=SQLITE_DONE );
150350 assert( bAlnum==0 || bAlnum==1 );
150354 assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 );
150419 assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 );
150750 assert( aEntry[0]<key );
150751 assert( key>=aEntry[iRes] );
150807 assert( key>=aDia[iRes] );
150929 assert( c>=0 );
150930 assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 );
150949 assert( iRes<0 || c>=aEntry[iRes].iCode );
150955 assert( ret>0 );
151374 assert( sizeof(RtreeCoord)==4 );
151375 assert( sizeof(u32)==4 );
151435 assert( pNode->pNext==0 );
151448 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
151491 assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
151609 assert( nCell<=nMaxCell );
151650 assert( pNode->nRef>0 );
151679 assert( iCell<NCELL(pNode) );
151932 assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY );
151933 assert( nCoord==2 || nCoord==4 || nCoord==6 || nCoord==8 || nCoord==10 );
151979 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
152018 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
152044 assert( nCell<200 );
152093 assert( i<j );
152122 assert( ii==0 || ii==1 );
152123 assert( pCur->bPoint || pCur->nPoint );
152125 assert( pRC!=0 );
152153 assert( iLevel<=RTREE_MAX_DEPTH );
152188 assert( pCur->aNode[ii]==0 );
152240 assert( i==0 || i==1 );
152302 assert( nCell<200 );
152404 assert( pRtree->eCoordType==RTREE_COORD_INT32 );
152520 assert( p!=0 ); /* Always returns pCsr->sPoint */
152543 assert( (idxStr==0 && argc==0)
152578 assert( pCsr->bPoint==1 );
152648 assert( pIdxInfo->idxStr==0 );
152683 assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH );
152987 assert( left<=right );
153054 assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
153366 assert( pNode->nRef==1 );
153455 assert( pParent || pNode->iNode==1 );
153775 assert(nData>=1);
153801 assert( nData<=(pRtree->nDim*2 + 3) );
154213 assert( *ppVtab==0 );
154214 assert( pRtree->nBusy==1 );
154533 assert(uPattern!=0);
154717 assert(!pExpr);
154783 assert(nArg==1 || nArg==2);
154842 assert(!"Unexpected return value from ucol_strcoll()");
154871 assert(nArg==2);
154884 assert(p);
155161 assert(iStart<=iEnd);
155376 assert( rc==SQLITE_OK || pTab==0 );
155579 assert( nLocal>=0 );
155580 assert( nPayload>=(u32)nLocal );
155581 assert( nLocal<=(nUsable-35) );
155596 assert( pPg==0 );
155715 assert( p==&pCsr->aPage[pCsr->iPage-1] );
155823 assert( i==9 );
