Lines Matching refs:flags
944 int (*xSync)(sqlite3_file*, int flags);
954 int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
1384 int flags, int *pOutFlags);
1386 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
3183 int flags, /* Flags */
6055 int flags,
9391 int flags, /* Flags */
9428 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags);
10367 u16 flags; /* PGHDR flags defined below */ member
11024 int flags; /* Miscellaneous flags. See below */ member
11319 #define LIKEFUNC(zName, nArg, arg, flags) \ argument
11320 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
11928 u32 flags; /* Various flags. EP_* See below */ member
12004 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
12005 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
12006 #define ExprSetProperty(E,P) (E)->flags|=(P)
12007 #define ExprClearProperty(E,P) (E)->flags&=~(P)
12014 # define ExprSetVVAProperty(E,P) (E)->flags|=(P)
14674 u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ member
14735 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
14742 #define memIsValid(M) ((M)->flags & MEM_Undefined)==0
14943 (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
14990 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
16546 SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){ in sqlite3OsSync() argument
16548 return id->pMethods->xSync(id, flags); in sqlite3OsSync()
16603 SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){ in sqlite3OsShmLock() argument
16604 return id->pMethods->xShmLock(id, offset, n, flags); in sqlite3OsShmLock()
16651 int flags, in sqlite3OsOpen() argument
16660 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut); in sqlite3OsOpen()
16672 int flags, in sqlite3OsAccess() argument
16676 return pVfs->xAccess(pVfs, zPath, flags, pResOut); in sqlite3OsAccess()
16730 int flags, in sqlite3OsOpenMalloc() argument
16737 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); in sqlite3OsOpenMalloc()
21397 etByte flags; /* One or more of FLAG_ constants below */
21663 if( useIntern || (infop->flags & FLAG_INTERN)==0 ){
21700 if( infop->flags & FLAG_SIGNED ){
23105 assert( pMem->flags&MEM_Str );
23211 c = pMem->flags;
23213 pMem->flags = MEM_Str|MEM_Term|(c&MEM_AffMask);
23262 pMem->flags |= MEM_Term;
23341 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
23342 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
25422 int flags; /* Flags this file descriptor was opened with */
25767 static int posixOpen(const char *zFile, int flags, int mode){
25768 return open(zFile, flags, mode);
29011 static int unixSync(sqlite3_file *id, int flags){
29015 int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
29016 int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
29019 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
29020 || (flags&0x0F)==SQLITE_SYNC_FULL
29996 int flags /* What to do with the lock */
30009 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
30010 || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
30011 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
30012 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
30013 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
30020 if( flags & SQLITE_SHM_UNLOCK ){
30042 }else if( flags & SQLITE_SHM_SHARED ){
30209 int flags = PROT_READ; /* Flags to pass to mmap() */
30218 if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;
30238 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
30257 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
30975 static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
31005 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
31040 int flags, /* Flags passed as 4th argument to xOpen() */
31049 if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
31087 }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
31119 int flags, /* Input flags to control the opening */
31125 int eType = flags&0xFFFFFF00; /* Type of file to open */
31130 int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
31131 int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
31132 int isCreate = (flags & SQLITE_OPEN_CREATE);
31133 int isReadonly = (flags & SQLITE_OPEN_READONLY);
31134 int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
31136 int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY);
31198 pUnused = findReusableFd(zName, flags);
31212 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
31242 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
31252 flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
31254 flags |= SQLITE_OPEN_READONLY;
31268 if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
31274 *pOutFlags = flags;
31279 p->pUnused->flags = flags;
31323 if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI;
31427 int flags, /* What do we want to learn about the zPath file? */
31433 switch( flags ){
31448 if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){
32038 pUnused->flags = openFlags;
35515 DWORD flags,
35534 return osLockFileEx(*phFile, flags, 0, numBytesLow, numBytesHigh, &ovlp);
35960 static int winSync(sqlite3_file *id, int flags){
35980 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
35981 || (flags&0x0F)==SQLITE_SYNC_FULL
35990 osGetCurrentProcessId(), pFile, pFile->h, flags,
35994 UNUSED_PARAMETER(flags);
35996 if( (flags&0x0F)==SQLITE_SYNC_FULL ){
36946 int flags /* What to do with the lock */
36957 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
36958 || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
36959 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
36960 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
36961 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
36966 if( flags & SQLITE_SHM_UNLOCK ){
36988 }else if( flags & SQLITE_SHM_SHARED ){
37298 DWORD flags = FILE_MAP_READ;
37303 flags |= FILE_MAP_WRITE;
37328 pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap);
37330 pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
37807 int flags, /* Open mode flags */
37831 int eType = flags&0xFFFFFF00; /* Type of file to open */
37834 int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
37835 int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
37836 int isCreate = (flags & SQLITE_OPEN_CREATE);
37837 int isReadonly = (flags & SQLITE_OPEN_READONLY);
37838 int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
37849 zUtf8Name, id, flags, pOutFlags));
37905 assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
38020 ((flags|SQLITE_OPEN_READONLY) &
38205 int flags, /* Type of test to make on this file */
38216 zFilename, flags, pResOut));
38234 if( flags==SQLITE_ACCESS_EXISTS
38258 switch( flags ){
39310 while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
39350 if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
39539 pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
39630 if( (p->flags&PGHDR_DIRTY)==0 ){
39654 if( p->flags&PGHDR_DIRTY ){
39669 p->flags &= ~PGHDR_DONT_WRITE;
39671 if( 0==(p->flags & PGHDR_DIRTY) ){
39672 p->flags |= PGHDR_DIRTY;
39682 if( (p->flags & PGHDR_DIRTY) ){
39684 p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC);
39707 p->flags &= ~PGHDR_NEED_SYNC;
39721 if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
39747 assert( p->flags&PGHDR_DIRTY );
42834 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
43911 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
43918 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
43953 pPg->flags &= ~PGHDR_NEED_READ;
44067 const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
44068 rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
44103 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
44104 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
45447 assert( pPg->flags&PGHDR_DIRTY );
45540 p->flags = PGHDR_MMAP;
45547 assert( p->flags==PGHDR_MMAP );
45887 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
45891 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
46024 assert( pPg->flags&PGHDR_DIRTY );
46048 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
46065 if( pPg->flags&PGHDR_NEED_SYNC
46106 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
46156 int flags, /* flags controlling this file */
46169 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
46193 if( flags & PAGER_MEMORY ){
46903 int flags /* PAGER_GET_XXX flags */
46908 const int noContent = (flags & PAGER_GET_NOCONTENT);
46915 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
47094 if( pPg->flags & PGHDR_MMAP ){
47151 const int flags = /* VFS flags to open journal file */
47164 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
47167 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
47360 pPg->flags |= PGHDR_NEED_SYNC;
47374 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
47389 pPg->flags |= PGHDR_NEED_SYNC;
47393 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
47470 if( pPage->flags&PGHDR_NEED_SYNC ){
47477 if( pPage->flags&PGHDR_NEED_SYNC ){
47495 pPage->flags |= PGHDR_NEED_SYNC;
47521 assert( (pPg->flags & PGHDR_MMAP)==0 );
47539 return pPg->flags&PGHDR_DIRTY;
47559 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
47562 pPg->flags |= PGHDR_DONT_WRITE;
48395 if( pPg->flags&PGHDR_DIRTY
48403 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
48413 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
48417 assert( pPg->flags&PGHDR_DIRTY );
48425 pPg->flags &= ~PGHDR_NEED_SYNC;
48429 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
48477 pPgHdr->flags |= PGHDR_NEED_SYNC;
48492 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
48494 pPg->flags = flags;
50166 int flags; /* Flags passed to OsOpen() */
50201 flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
50202 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
50203 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
53206 || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted))
53283 && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted)
53305 assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
53383 assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
54738 static void zeroPage(MemPage *pPage, int flags){
54752 data[hdr] = (char)flags;
54753 first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8);
54758 decodeFlags(pPage, flags);
54799 int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
54804 assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY );
54806 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
54954 int flags, /* Options */
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 );
54990 flags |= BTREE_MEMORY;
55093 EXTRA_SIZE, flags, vfsFlags, pageReinit);
55101 pBt->openFlags = (u8)flags;
55742 if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
60083 aPgFlags[i] = apNew[i]->pDbPage->flags;
61014 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
61017 rc = btreeCreateTable(p, piTable, flags);
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) );
63141 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
63144 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
63145 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
63146 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
63171 assert( (pMem->flags&MEM_RowSet)==0 );
63174 if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
63204 assert( (pMem->flags&MEM_RowSet)==0 );
63208 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
63235 if( (pMem->flags&MEM_Dyn)!=0 ){
63241 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
63260 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
63264 assert( (pMem->flags & MEM_Dyn)==0 );
63266 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real);
63279 assert( (pMem->flags&MEM_RowSet)==0 );
63281 f = pMem->flags;
63288 pMem->flags |= MEM_Term;
63290 pMem->flags &= ~MEM_Ephem;
63304 if( pMem->flags & MEM_Zero ){
63306 assert( pMem->flags&MEM_Blob );
63307 assert( (pMem->flags&MEM_RowSet)==0 );
63321 pMem->flags &= ~(MEM_Zero|MEM_Term);
63337 pMem->flags |= MEM_Term;
63346 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
63347 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
63348 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
63370 int fg = pMem->flags;
63377 assert( (pMem->flags&MEM_RowSet)==0 );
63399 pMem->flags |= MEM_Str|MEM_Term;
63400 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real);
63418 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
63422 t.flags = MEM_Null;
63428 assert( (pMem->flags & MEM_Dyn)==0 );
63448 if( p->flags&MEM_Agg ){
63450 assert( (p->flags & MEM_Agg)==0 );
63451 testcase( p->flags & MEM_Dyn );
63453 if( p->flags&MEM_Dyn ){
63454 assert( (p->flags&MEM_RowSet)==0 );
63457 }else if( p->flags&MEM_RowSet ){
63459 }else if( p->flags&MEM_Frame ){
63464 p->flags = MEM_Null;
63545 int flags;
63548 flags = pMem->flags;
63549 if( flags & MEM_Int ){
63551 }else if( flags & MEM_Real ){
63553 }else if( flags & (MEM_Str|MEM_Blob) ){
63572 if( pMem->flags & MEM_Real ){
63574 }else if( pMem->flags & MEM_Int ){
63576 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
63593 assert( pMem->flags & MEM_Real );
63594 assert( (pMem->flags & MEM_RowSet)==0 );
63621 assert( (pMem->flags & MEM_RowSet)==0 );
63651 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
63652 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
63662 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
63663 pMem->flags &= ~(MEM_Str|MEM_Blob);
63675 if( pMem->flags & MEM_Null ) return;
63678 if( (pMem->flags & MEM_Blob)==0 ){
63680 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63683 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
63702 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
63704 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63705 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
63716 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
63717 assert( (flags & ~MEM_TypeMask)==0 );
63718 pMem->flags = flags;
63740 pMem->flags = MEM_Null;
63753 pMem->flags = MEM_Blob|MEM_Zero;
63769 pMem->flags = MEM_Int;
63781 pMem->flags = MEM_Int;
63794 pMem->flags = MEM_Real;
63806 assert( (pMem->flags & MEM_RowSet)==0 );
63810 pMem->flags = MEM_Null;
63817 pMem->flags = MEM_RowSet;
63827 if( p->flags & (MEM_Str|MEM_Blob) ){
63829 if( p->flags & MEM_Zero ){
63851 pX->flags |= MEM_Undefined;
63871 assert( (pFrom->flags & MEM_RowSet)==0 );
63875 if( (pFrom->flags&MEM_Static)==0 ){
63876 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
63878 pTo->flags |= srcType;
63890 assert( (pFrom->flags & MEM_RowSet)==0 );
63893 pTo->flags &= ~MEM_Dyn;
63894 if( pTo->flags&(MEM_Str|MEM_Blob) ){
63895 if( 0==(pFrom->flags&MEM_Static) ){
63896 pTo->flags |= MEM_Ephem;
63917 pFrom->flags = MEM_Null;
63945 u16 flags = 0; /* New value for pMem->flags */
63948 assert( (pMem->flags & MEM_RowSet)==0 );
63961 flags = (enc==0?MEM_Blob:MEM_Str);
63970 flags |= MEM_Term;
63979 if( flags&MEM_Term ){
64000 flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
64004 pMem->flags = flags;
64052 assert( (pMem->flags & MEM_RowSet)==0 );
64062 pMem->flags = MEM_Blob|MEM_Ephem;
64065 pMem->flags = MEM_Null;
64075 pMem->flags = MEM_Blob|MEM_Term;
64095 assert( (pVal->flags & MEM_RowSet)==0 );
64096 assert( (pVal->flags & (MEM_Null))==0 );
64097 if( pVal->flags & (MEM_Blob|MEM_Str) ){
64098 pVal->flags |= MEM_Str;
64099 if( pVal->flags & MEM_Zero ){
64106 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
64139 assert( (pVal->flags & MEM_RowSet)==0 );
64140 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
64143 if( pVal->flags&MEM_Null ){
64155 p->flags = MEM_Null;
64203 pRec->aMem[i].flags = MEM_Null;
64264 assert( (p->flags & EP_TokenOnly)==0 );
64367 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
64406 if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
64416 if( pVal->flags & MEM_Real ){
64773 if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
64774 if( p->flags & MEM_Zero ){
64956 if( p->db->flags & SQLITE_VdbeAddopTrace ){
65375 if( p->db->flags & SQLITE_VdbeAddopTrace ){
65886 if( pMem->flags & MEM_Str ){
65888 }else if( pMem->flags & MEM_Int ){
65890 }else if( pMem->flags & MEM_Real ){
65892 }else if( pMem->flags & MEM_Null ){
65895 assert( pMem->flags & MEM_Blob );
66066 testcase( p->flags & MEM_Agg );
66067 testcase( p->flags & MEM_Dyn );
66068 testcase( p->flags & MEM_Frame );
66069 testcase( p->flags & MEM_RowSet );
66070 if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
66077 p->flags = MEM_Undefined;
66159 if( pSub->flags&MEM_Blob ){
66198 pMem->flags = MEM_Int;
66202 pMem->flags = MEM_Static|MEM_Str|MEM_Term;
66223 pSub->flags |= MEM_Blob;
66229 pMem->flags = MEM_Int;
66233 pMem->flags = MEM_Int;
66237 pMem->flags = MEM_Int;
66245 pMem->flags = MEM_Str|MEM_Term;
66261 pMem->flags = MEM_Str|MEM_Term;
66272 pMem->flags = MEM_Str|MEM_Term;
66276 pMem->flags = MEM_Null; /* Comment */
66526 p->aVar[n].flags = MEM_Null;
66539 p->aMem[n].flags = MEM_Undefined;
66659 for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
66686 pColName->flags = MEM_Null;
66720 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
67214 db->flags &= ~SQLITE_DeferFKs;
67666 int flags = pMem->flags;
67669 if( flags&MEM_Null ){
67672 if( flags&MEM_Int ){
67691 if( flags&MEM_Real ){
67694 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
67697 if( flags & MEM_Zero ){
67700 return ((n*2) + 12 + ((flags&MEM_Str)!=0));
67806 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
67847 pMem->flags = MEM_Int;
67867 pMem->flags = sqlite3IsNaN(pMem->u.r) ? MEM_Null : MEM_Real;
67881 pMem->flags = MEM_Null;
67888 pMem->flags = MEM_Int;
67896 pMem->flags = MEM_Int;
67904 pMem->flags = MEM_Int;
67912 pMem->flags = MEM_Int;
67920 pMem->flags = MEM_Int;
67935 pMem->flags = MEM_Int;
67946 pMem->flags = aFlag[serial_type&1];
68240 f1 = pMem1->flags;
68241 f2 = pMem2->flags;
68422 if( pRhs->flags & MEM_Int ){
68449 else if( pRhs->flags & MEM_Real ){
68473 else if( pRhs->flags & MEM_Str ){
68490 mem1.flags = MEM_Str;
68504 else if( pRhs->flags & MEM_Blob ){
68742 int flags = p->aMem[0].flags;
68750 if( (flags & MEM_Int) ){
68753 testcase( flags & MEM_Real );
68754 testcase( flags & MEM_Null );
68755 testcase( flags & MEM_Blob );
68756 if( (flags & (MEM_Real|MEM_Null|MEM_Blob))==0 && p->pKeyInfo->aColl[0]==0 ){
68757 assert( flags & MEM_Str );
68935 if( 0==(pMem->flags & MEM_Null) ){
69095 p->aVar[i].flags = MEM_Null;
69111 if( p->flags & (MEM_Blob|MEM_Str) ){
69113 p->flags |= MEM_Blob;
69187 return aType[pVal->flags&MEM_AffMask];
69350 if( pCtx->pOut->flags & MEM_Null ){
69661 assert( (pMem->flags & MEM_Agg)==0 );
69667 pMem->flags = MEM_Agg;
69685 if( (p->pMem->flags & MEM_Agg)==0 ){
69934 if( pOut->flags&MEM_Static ){
69935 pOut->flags &= ~MEM_Static;
69936 pOut->flags |= MEM_Ephem;
70136 pVar->flags = MEM_Null;
70296 if( pValue->flags & MEM_Zero ){
70682 if( pVar->flags & MEM_Null ){
70684 }else if( pVar->flags & MEM_Int ){
70686 }else if( pVar->flags & MEM_Real ){
70688 }else if( pVar->flags & MEM_Str ){
70717 }else if( pVar->flags & MEM_Zero ){
70721 assert( pVar->flags & MEM_Blob );
70826 if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
70892 if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \
70907 if( ((P)->flags&MEM_Ephem)!=0 \
70989 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
70993 pRec->flags |= MEM_Int;
70996 pRec->flags |= MEM_Real;
71027 if( (pRec->flags & MEM_Int)==0 ){
71028 if( (pRec->flags & MEM_Real)==0 ){
71029 if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
71039 if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
71042 pRec->flags &= ~(MEM_Real|MEM_Int);
71081 assert( (pMem->flags & (MEM_Int|MEM_Real))==0 );
71082 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
71100 if( pMem->flags & (MEM_Int|MEM_Real) ){
71101 return pMem->flags & (MEM_Int|MEM_Real);
71103 if( pMem->flags & (MEM_Str|MEM_Blob) ){
71116 int f = pMem->flags;
71197 if( p->flags & MEM_Undefined ){
71199 }else if( p->flags & MEM_Null ){
71201 }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
71203 }else if( p->flags & MEM_Int ){
71206 }else if( p->flags & MEM_Real ){
71209 }else if( p->flags & MEM_RowSet ){
71225 # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
71361 pOut->flags = MEM_Int;
71429 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
71434 if( p->db->flags & SQLITE_VdbeListing ){
71440 if( p->db->flags & SQLITE_VdbeEQP ){
71449 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
71467 if( db->flags & SQLITE_VdbeTrace ){
71619 pIn1->flags = MEM_Int;
71637 assert( pIn1->flags==MEM_Int );
71639 pIn1->flags = MEM_Undefined;
71661 pOut->flags = MEM_Int;
71677 assert( pIn1->flags==MEM_Int );
71683 pIn1->flags = MEM_Undefined;
71704 pIn1->flags = MEM_Int;
71722 if( (pIn3->flags & MEM_Null)==0 ) break;
71857 pOut->flags = MEM_Real;
71886 pOut->flags |= MEM_Static;
71914 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
71923 assert( pIn3->flags & MEM_Int );
71924 if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
71947 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
71952 pOut->flags = nullFlag;
71969 pOut->flags = (pOut->flags|MEM_Null)&~MEM_Undefined;
72137 assert( db->flags&SQLITE_CountRows );
72157 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
72174 assert( (pMem[i].flags & MEM_Ephem)==0
72175 || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
72208 if( (pIn1->flags | pIn2->flags) & MEM_Null ){
72229 pOut->flags |= MEM_Term;
72280 u16 flags; /* Combined MEM_* flags from both inputs */
72293 flags = pIn1->flags | pIn2->flags;
72294 if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
72499 if( (pIn1->flags | pIn2->flags) & MEM_Null ){
72564 if( (pIn1->flags & MEM_Int)==0 ){
72566 VdbeBranchTaken((pIn1->flags&MEM_Int)==0, 2);
72567 if( (pIn1->flags & MEM_Int)==0 ){
72592 if( pIn1->flags & MEM_Int ){
72726 flags1 = pIn1->flags;
72727 flags3 = pIn3->flags;
72767 if( (pIn1->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
72770 if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
72774 if( (pIn1->flags & MEM_Str)==0 && (pIn1->flags & (MEM_Int|MEM_Real))!=0 ){
72775 testcase( pIn1->flags & MEM_Int );
72776 testcase( pIn1->flags & MEM_Real );
72778 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
72779 flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
72781 if( (pIn3->flags & MEM_Str)==0 && (pIn3->flags & (MEM_Int|MEM_Real))!=0 ){
72782 testcase( pIn3->flags & MEM_Int );
72783 testcase( pIn3->flags & MEM_Real );
72785 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
72786 flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
72790 if( pIn1->flags & MEM_Zero ){
72794 if( pIn3->flags & MEM_Zero ){
72811 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
72812 pIn1->flags = flags1;
72813 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
72814 pIn3->flags = flags3;
72957 if( pIn1->flags & MEM_Null ){
72963 if( pIn2->flags & MEM_Null ){
72996 if( (pIn1->flags & MEM_Null)==0 ){
72997 pOut->flags = MEM_Int;
73014 if( (pIn1->flags & MEM_Null)==0 ){
73015 pOut->flags = MEM_Int;
73059 if( pIn1->flags & MEM_Null ){
73083 VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
73084 if( (pIn1->flags & MEM_Null)!=0 ){
73097 VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
73098 if( (pIn1->flags & MEM_Null)==0 ){
73173 assert( pReg->flags & MEM_Blob );
73294 sMem.flags = MEM_Null;
73362 pDest->flags &= ~MEM_Ephem;
73372 if( (pDest->flags & MEM_Ephem)!=0 && pDest->z ){
73373 fx = pDest->flags & (MEM_Str|MEM_Blob);
73381 pDest->flags = fx|MEM_Term;
73499 if( pRec->flags & MEM_Zero ){
73562 pOut->flags = MEM_Blob;
73565 pOut->flags |= MEM_Zero;
73713 isSchemaChange = (db->flags & SQLITE_InternChanges)!=0;
73732 db->flags = (db->flags | SQLITE_InternChanges);
73889 if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
74022 db->flags |= SQLITE_InternChanges;
74157 assert( (pIn2->flags & MEM_Int)!=0 );
74479 if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
74486 if( (pIn3->flags & MEM_Int)==0 ){
74487 if( (pIn3->flags & MEM_Real)==0 ){
74716 assert( pIn3->flags & MEM_Blob );
74727 if( pIdxKey->aMem[ii].flags & MEM_Null ){
74778 assert( pIn3->flags & MEM_Int );
74914 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
75023 assert( pKey->flags & MEM_Int );
75034 if( pData->flags & MEM_Null ){
75038 assert( pData->flags & (MEM_Blob|MEM_Str) );
75041 if( pData->flags & MEM_Zero ){
75181 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
75299 pOut->flags = MEM_Null;
75316 pOut->flags = MEM_Null;
75598 assert( pIn2->flags & MEM_Blob );
75677 pOut->flags = MEM_Null;
75695 pOut->flags = MEM_Int;
75814 pOut->flags = MEM_Null;
75823 pOut->flags = MEM_Int;
75925 int flags;
75937 flags = BTREE_INTKEY;
75939 flags = BTREE_BLOBKEY;
75941 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
76091 assert( (pnErr->flags & MEM_Int)!=0 );
76092 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
76129 assert( (pIn2->flags & MEM_Int)!=0 );
76130 if( (pIn1->flags & MEM_RowSet)==0 ){
76132 if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
76149 if( (pIn1->flags & MEM_RowSet)==0
76195 assert( pIn3->flags&MEM_Int );
76200 if( (pIn1->flags & MEM_RowSet)==0 ){
76202 if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
76277 if( (pRt->flags&MEM_Frame)==0 ){
76293 pRt->flags = MEM_Frame;
76315 pMem->flags = MEM_Undefined;
76383 if( db->flags & SQLITE_DeferFKs ){
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 );
76601 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
76748 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
76832 if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommitted) ){
76880 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
76881 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
76995 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
77122 assert( pName->flags & MEM_Str );
77200 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
77292 if( (db->flags & SQLITE_SqlTrace)!=0
77345 if( db->flags & SQLITE_VdbeTrace ){
77448 int flags; /* Copy of "flags" passed to sqlite3_blob_open() */
77484 assert( v->aVar[0].flags&MEM_Int );
77535 int flags, /* True -> read/write access, false -> read-only */
77589 flags = !!flags; /* flags = (flags ? 1 : 0); */
77649 if( flags ){
77653 if( db->flags&SQLITE_ForeignKeys ){
77693 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags,
77708 sqlite3VdbeChangeP3(v, 1, flags);
77714 sqlite3VdbeChangeToNoop(v, 3 - flags);
77715 sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
77716 sqlite3VdbeChangeP3(v, 2 + flags, iDb);
77725 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
77735 pBlob->flags = flags;
80615 if( r2->aMem[i].flags & MEM_Null ){
80665 int flags; /* xOpen flags */
80680 rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
80777 static int jrnlSync(sqlite3_file *pJfd, int flags){
80781 rc = sqlite3OsSync(p->pReal, flags);
80832 int flags, /* Opening flags */
80843 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
80847 p->flags = flags;
81426 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
81428 pExpr->flags |= EP_MemToken;
82286 pNew->flags |= EP_IntValue;
82839 if( pExpr->flags & EP_Generic ) return 0;
82842 assert( pExpr->flags&EP_xIsSelect );
82882 pNew->flags |= EP_Collate|EP_Skip;
82930 if( p->flags & EP_Generic ) break;
82952 if( p->flags & EP_Collate ){
82953 if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
83079 if( pLeft->flags & EP_Collate ){
83081 }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
83189 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
83224 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
83273 pNew->flags |= EP_IntValue;
83284 if( c=='"' ) pNew->flags |= EP_DblQuoted;
83329 pRoot->flags |= EP_Propagate & pRight->flags;
83333 pRoot->flags |= EP_Propagate & pLeft->flags;
83590 static int dupedExprStructSize(Expr *p, int flags){
83592 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
83595 if( 0==(flags&EXPRDUP_REDUCE) ){
83617 static int dupedExprNodeSize(Expr *p, int flags){
83618 int nByte = dupedExprStructSize(p, flags) & 0xfff;
83638 static int dupedExprSize(Expr *p, int flags){
83641 nByte = dupedExprNodeSize(p, flags);
83642 if( flags&EXPRDUP_REDUCE ){
83643 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
83657 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
83660 const int isReduced = (flags&EXPRDUP_REDUCE);
83671 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
83681 const unsigned nStructSize = dupedExprStructSize(p, flags);
83699 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static|EP_MemToken);
83700 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
83701 pNew->flags |= staticFlag;
83709 if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
83720 zAlloc += dupedExprNodeSize(p, flags);
83784 SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
83785 return exprDup(db, p, flags, 0);
83787 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
83795 if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; i<p->nExpr; i+=i){}
83804 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
83823 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
83854 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
83855 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
83884 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
83889 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
83890 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
83891 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
83892 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
83893 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
83894 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
83896 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
83899 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
83900 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
83912 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
84058 if( ALWAYS(pExpr) ) m |= pExpr->flags;
84216 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
84219 if( p->flags & EP_IntValue ){
85056 if( pExpr->flags & EP_IntValue ){
85192 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85209 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85308 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85579 tempX.flags = EP_IntValue|EP_TokenOnly;
85736 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
86147 if( pExpr->flags & EP_IntValue ){
86395 u8 flags /* SQLITE_ECEL_* flags */
86399 u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy;
86404 if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
86407 if( (flags & SQLITE_ECEL_FACTOR)!=0 && sqlite3ExprIsConstant(pExpr) ){
86797 combinedFlags = pA->flags | pB->flags;
86799 if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
86818 if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
87100 if( pExpr->flags & EP_Distinct ){
87641 savedDbFlags = db->flags;
87650 db->flags |= SQLITE_PreferBuiltin;
87732 if( db->flags&SQLITE_ForeignKeys ){
87798 if( db->flags&SQLITE_ForeignKeys ){
87815 db->flags = savedDbFlags;
87905 if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
87939 int savedDbFlags = db->flags;
87943 db->flags |= SQLITE_PreferBuiltin;
87952 db->flags = savedDbFlags;
90026 unsigned int flags;
90082 flags = db->openFlags;
90083 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
90091 flags |= SQLITE_OPEN_MAIN_DB;
90092 rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
90114 sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));
91276 db->flags |= SQLITE_InternChanges;
91349 db->flags &= ~SQLITE_InternChanges;
91359 db->flags &= ~SQLITE_InternChanges;
91465 db->flags |= SQLITE_InternChanges;
91594 && (pParse->db->flags & SQLITE_WriteSchema)==0
91799 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
92807 db->flags |= SQLITE_InternChanges;
93366 int flags /* Conflict resolution algorithms. */
93446 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
93447 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
94010 db->flags |= SQLITE_InternChanges;
94680 static const int flags =
94687 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
95491 if( !createFlag && (pBest==0 || (db->flags & SQLITE_PreferBuiltin)!=0) ){
95650 && (pParse->db->flags & SQLITE_WriteSchema)==0
95775 pInClause->flags |= EP_xIsSelect;
95936 if( db->flags & SQLITE_CountRows ){
95991 if( db->flags & SQLITE_CountRows ){
96130 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
97663 int flags; /* 1: trimleft 2: trimright 3: trim */
97704 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
97705 if( flags & 1 ){
97717 if( flags & 2 ){
97940 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
97941 }else if( pBest->flags ){
97969 if( pRes->flags ){
98654 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
98930 if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
98943 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
98963 if( (db->flags & SQLITE_DeferFKs)==0 ){
99096 if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
99212 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs)
99282 if( pParse->db->flags&SQLITE_ForeignKeys ){
99320 if( pParse->db->flags&SQLITE_ForeignKeys ){
99572 if( pParse->db->flags&SQLITE_ForeignKeys ){
100375 if( db->flags & SQLITE_CountRows ){
100604 if( (db->flags & SQLITE_CountRows)!=0 ){
100649 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
100862 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
100962 if( db->flags&SQLITE_RecTriggers ){
101138 if( db->flags&SQLITE_RecTriggers ){
101550 if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
101554 if( (db->flags & SQLITE_CountRows)!=0 ){
101575 if( (db->flags & SQLITE_Vacuum)==0 && (
101643 if( db->flags & SQLITE_Vacuum ){
101763 && db->flags&SQLITE_NullCallback)) ){
102811 if( (db->flags & SQLITE_LoadExtension)==0 ){
102948 db->flags |= SQLITE_LoadExtension;
102950 db->flags &= ~SQLITE_LoadExtension;
103787 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
104552 returnSingleInt(pParse, pPragma->zName, (db->flags & pPragma->iArg)!=0 );
104568 db->flags |= mask;
104570 db->flags &= ~mask;
105600 if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
105890 db->flags &= ~SQLITE_LegacyFileFmt;
105924 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
105966 int commit_internal = !(db->flags&SQLITE_InternChanges);
106172 testcase( db->flags & SQLITE_ReadUncommitted );
107986 fullNames = (db->flags & SQLITE_FullColNames)!=0;
107987 shortNames = (db->flags & SQLITE_ShortColNames)!=0;
108193 savedFlags = db->flags;
108194 db->flags &= ~SQLITE_FullColNames;
108195 db->flags |= SQLITE_ShortColNames;
108199 db->flags = savedFlags;
108358 if( pTerm->flags & EP_Collate ){
109311 pNew->flags |= EP_IntValue;
110265 if( pExpr->flags&EP_Distinct ) return 0;
110332 if( a[i].pExpr->flags & EP_Collate ) break;
110709 int flags = pParse->db->flags;
110710 int longNames = (flags & SQLITE_FullColNames)!=0
110711 && (flags & SQLITE_ShortColNames)==0;
110717 || ((flags & SQLITE_FullColNames)==0 &&
110718 (flags & SQLITE_ShortColNames)!=0) );
112885 db->flags |= SQLITE_InternChanges;
112924 if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
113249 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
113799 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
114012 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
114054 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
114221 assert( rc!=SQLITE_ROW || (db->flags&SQLITE_CountRows) );
114315 saved_flags = db->flags;
114319 db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks | SQLITE_PreferBuiltin;
114320 db->flags &= ~(SQLITE_ForeignKeys | SQLITE_ReverseOrder);
114426 assert( (db->flags & SQLITE_Vacuum)==0 );
114427 db->flags |= SQLITE_Vacuum;
114435 assert( (db->flags & SQLITE_Vacuum)!=0 );
114436 db->flags &= ~SQLITE_Vacuum;
114518 db->flags = saved_flags;
116556 u16 expRight = (pExpr->pRight->flags & EP_Collate);
116557 u16 expLeft = (pExpr->pLeft->flags & EP_Collate);
116564 pExpr->pRight->flags &= ~EP_Collate;
116569 pExpr->pLeft->flags |= EP_Collate;
116934 pDerived->flags |= pBase->flags & EP_FromJoin;
119267 u32 flags; /* Flags that describe this loop */
119273 flags = pLoop->wsFlags;
119274 if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return 0;
119276 isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0
119277 || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0))
119291 if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){
119297 assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
119302 }else if( flags & WHERE_PARTIALIDX ){
119304 }else if( flags & WHERE_AUTO_INDEX ){
119306 }else if( flags & WHERE_IDX_ONLY ){
119316 }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
119318 if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){
119320 }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){
119322 }else if( flags&WHERE_BTM_LIMIT ){
119325 assert( flags&WHERE_TOP_LIMIT);
119332 else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
121301 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
122822 if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
126019 yygotominor.yy346.pExpr->flags |= EP_Distinct;
126060 if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc;
126073 if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc;
126155 pRHS->flags &= ~EP_Collate;
126156 pRHS->flags |= EP_Generic;
128755 int oldFlags = db->flags;
128757 db->flags |= aFlagOp[i].mask;
128759 db->flags &= ~aFlagOp[i].mask;
128761 if( oldFlags!=db->flags ){
128765 *pRes = (db->flags & aFlagOp[i].mask)!=0;
129165 schemaChange = (db->flags & SQLITE_InternChanges)!=0 && db->init.busy==0;
129179 if( (db->flags&SQLITE_InternChanges)!=0 && db->init.busy==0 ){
129188 db->flags &= ~SQLITE_DeferFKs;
130409 unsigned int flags = *pFlags;
130417 if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */
130429 flags |= SQLITE_OPEN_URI;
130565 limit = mask & flags;
130590 flags = (flags & ~mask) | mode;
130603 flags &= ~SQLITE_OPEN_URI;
130616 *pFlags = flags;
130630 unsigned int flags, /* Operational flags */
130661 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
130662 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
130663 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
130664 if( ((1<<(flags&7)) & 0x46)==0 ){
130670 }else if( flags & SQLITE_OPEN_NOMUTEX ){
130672 }else if( flags & SQLITE_OPEN_FULLMUTEX ){
130677 if( flags & SQLITE_OPEN_PRIVATECACHE ){
130678 flags &= ~SQLITE_OPEN_SHAREDCACHE;
130680 flags |= SQLITE_OPEN_SHAREDCACHE;
130692 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
130731 db->flags |= SQLITE_ShortColNames | SQLITE_EnableTrigger | SQLITE_CacheSpill
130781 db->openFlags = flags;
130782 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
130792 flags | SQLITE_OPEN_MAIN_DB);
130934 int flags, /* Flags */
130937 return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
133186 int flags;
136006 filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS
139299 pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
139300 if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
145775 int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
145776 int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
145777 int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
145778 int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
145779 int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
145780 int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
146168 filter.flags = FTS3_SEGMENT_REQUIRE_POS;
146169 filter.flags |= (bIgnoreEmpty ? FTS3_SEGMENT_IGNORE_EMPTY : 0);
147830 pFilter->flags = FTS3_SEGMENT_REQUIRE_POS;
147839 pFilter->flags |= FTS3_SEGMENT_IGNORE_EMPTY;
148038 filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
148039 filter.flags |= FTS3_SEGMENT_SCAN;
150855 unsigned char flags;
150953 if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
150954 ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
155308 u8 flags; /* Copy of flags byte */
155498 u8 flags, /* Page flags */
155506 if( flags==0x0D ){ /* Table leaf node */
155529 p->flags = aHdr[0];
155533 isLeaf = (p->flags==0x0A || p->flags==0x0D);
155566 if( p->flags==0x05 ){
155572 if( p->flags==0x0D ){
155577 getLocalPayload(nUsable, p->flags, nPayload, &nLocal);
155743 switch( p->flags ){
