Lines Matching defs:flags
888 ** Only those flags marked as "Ok for sqlite3_open_v2()" may be
890 ** The other flags have historically been ignored by sqlite3_open_v2(),
1009 ** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
1013 ** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how
1057 ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
1149 int (*xSync)(sqlite3_file*, int flags);
1159 int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
1659 ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
1661 ** The flags argument to xOpen() includes all bits set in
1662 ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]
1663 ** or [sqlite3_open16()] is used, then flags includes at least
1668 ** ^(SQLite will also add one of the following flags to the xOpen()
1682 ** The file I/O implementation can use the object type flags to
1691 ** SQLite might also add one of the following flags to the xOpen method:
1705 ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
1723 ** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
1782 int flags, int *pOutFlags);
1784 int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1842 ** following are the only legal combinations of flags to the
3728 ** over the new database connection. ^(The flags parameter to
3748 ** In addition to the required flags, the following optional flags are
3803 ** have silently ignored surplus bits in the flags parameter to
3884 ** the flags passed in the third parameter to sqlite3_open_v2().
3888 ** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to
3985 int flags, /* Flags */
4103 ** flags parameter to xOpen contains one of the bits
4371 ** These constants define various flags that can be passed into
4375 ** New flags may be added in future releases of SQLite.
4503 ** more of the [SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_*] flags. ^The
4525 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */
4547 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */
4629 ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and
5583 ** the database schema. This flags is especially recommended for SQL
5724 ** The SQLITE_DIRECTONLY flags is a security feature which is recommended
7506 ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
7560 int idxFlags; /* Mask of SQLITE_INDEX_SCAN_* flags */
7812 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
7813 ** and write access. ^If the flags parameter is zero, the BLOB is opened for
7882 int flags,
7994 ** writing (the flags parameter to [sqlite3_blob_open()] was zero),
10752 unsigned int mFlags /* Zero or more SQLITE_SERIALIZE_* flags */
10810 unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */
11504 ** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter.
11518 int flags /* SESSION_CHANGESETSTART_* flags */
11524 ** The following flags may passed via the 4th parameter to
12157 ** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter.
12192 int flags /* SESSION_CHANGESETAPPLY_* flags */
12198 ** The following flags may passed via the 9th parameter to
12590 int flags
12615 int flags
13198 int flags, /* Mask of FTS5_TOKENIZE_* flags */
13202 int tflags, /* Mask of FTS5_TOKEN_* flags */
15224 ** Allowed values for the flags parameter to sqlite3PagerOpen().
15472 int flags, /* Flags */
15476 /* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the
15509 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, Pgno*, int flags);
15534 /* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR
15535 ** of the flags shown below.
15685 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
15687 /* Allowed flags for sqlite3BtreeDelete() and sqlite3BtreeInsert() */
15737 int flags, int seekResult);
15740 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int flags);
15742 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int flags);
15917 ** with flags in the upper 8 bits */
15931 u8 *aOnce; /* Array of OP_Once flags */
16158 #define OP_CreateBtree 147 /* synopsis: r[P2]=root iDb=P1 flags=P3 */
16247 ** Additional non-public SQLITE_PREPARE_* flags
16250 #define SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */
16431 ** flags to indicate whether or not the branch was taken. The test application
16515 u16 flags; /* PGHDR flags defined below */
16529 /* Bit values for PgHdr.flags */
16596 /* Clear flags from pages of the page cache */
16829 ** Db.pSchema->flags field.
16837 ** Allowed values for the DB.pSchema->flags field.
16997 #define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */
17017 u32 mDbFlags; /* flags recording internal state */
17018 u64 flags; /* flags settable by pragmas. See below */
17038 u8 mTrace; /* zero or more SQLITE_TRACE flags */
17172 ** Possible values for the sqlite3.flags.
17344 ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
17416 ** optional SQLITE_FUNC_ flags for this function.
17422 ** optional SQLITE_FUNC_ flags for this function.
17436 ** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is
17452 ** LIKEFUNC(zName, nArg, pArg, flags)
17457 ** FuncDef.flags variable is set to the value passed as the flags
17501 #define LIKEFUNC(zName, nArg, arg, flags) \
17502 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
18159 ** Possible values to use within the flags argument to sqlite3GetToken().
18264 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
18297 ** If the EP_Reduced and EP_TokenOnly flags are set when
18312 u8 vvaFlags; /* Verification flags. */
18314 u32 flags; /* Various flags. EP_* See below */
18320 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
18332 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
18367 /* The following are the meanings of bits in the Expr.flags field.
18412 ** Expr.flags field.
18414 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
18415 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
18416 #define ExprSetProperty(E,P) (E)->flags|=(P)
18417 #define ExprClearProperty(E,P) (E)->flags&=~(P)
18418 #define ExprAlwaysTrue(E) (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue)
18419 #define ExprAlwaysFalse(E) (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse)
18424 #define ExprUseUToken(E) (((E)->flags&EP_IntValue)==0)
18425 #define ExprUseUValue(E) (((E)->flags&EP_IntValue)!=0)
18426 #define ExprUseXList(E) (((E)->flags&EP_xIsSelect)==0)
18427 #define ExprUseXSelect(E) (((E)->flags&EP_xIsSelect)!=0)
18428 #define ExprUseYTab(E) (((E)->flags&(EP_WinFunc|EP_Subrtn))==0)
18429 #define ExprUseYWin(E) (((E)->flags&EP_WinFunc)!=0)
18430 #define ExprUseYSub(E) (((E)->flags&EP_Subrtn)!=0)
18453 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
18507 u8 sortFlags; /* Mask of KEYINFO_ORDER_* flags */
18734 int ncFlags; /* Zero or more NC_* flags defined below */
19120 u8 prepFlags; /* SQLITE_PREPARE_* flags */
19262 ** Bitfield flags for P5 value in various opcodes.
19418 u8 printfFlags; /* SQLITE_PRINTF flags below */
20257 SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*);
20259 SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *);
20855 ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
22340 ** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
22618 double r; /* Real value used when MEM_Real is set in flags */
22619 i64 i; /* Integer value used when MEM_Int is set in flags */
22622 FuncDef *pDef; /* Used only when flags==MEM_Agg */
22626 u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
22637 u16 mScopyFlags; /* flags value immediately after the shallow copy */
22647 /* One or more of the following flags are set to indicate the
22684 ** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set.
22690 ** flags may coexist with the MEM_Str flag.
22723 (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)
22726 ** Clear any existing type flags from a Mem and replace them with f
22729 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
22735 (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \
22747 #define memIsValid(M) ((M)->flags & MEM_AffMask)!=0
22870 u8 prepFlags; /* SQLITE_PREPARE_* flags */
23110 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
24962 SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){
24964 return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK;
25033 SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
25034 return id->pMethods->xShmLock(id, offset, n, flags);
25082 int flags,
25087 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
25088 ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
25091 assert( zPath || (flags & SQLITE_OPEN_EXCLUSIVE) );
25092 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut);
25104 int flags,
25108 return pVfs->xAccess(pVfs, zPath, flags, pResOut);
25175 int flags,
25182 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
29992 etByte flags; /* One or more of FLAG_ constants below */
29999 ** Allowed values for et_info.flags
30217 /* Find out what flags are present */
30361 if( infop->flags & FLAG_SIGNED ){
30759 ** characters if the ! flags is present) to use from the input.
31459 if( flg ) printf(" flags=%04x", flg);
31821 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){
31825 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
31871 if( pExpr->flags & EP_IntValue ){
32043 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
32049 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags);
32056 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags);
33252 assert( pMem->flags&MEM_Str );
33406 c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype));
33408 pMem->flags = c;
33461 pMem->flags |= MEM_Term;
33540 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
33541 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
33868 p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
35749 /* 147 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"),
35862 static int kvvfsSyncDb(sqlite3_file*, int flags);
35863 static int kvvfsSyncJrnl(sqlite3_file*, int flags);
35879 static int kvvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
36479 static int kvvfsSyncJrnl(sqlite3_file *pProtoFile, int flags){
36503 static int kvvfsSyncDb(sqlite3_file *pProtoFile, int flags){
36592 ** Return the device characteristic flags supported by an kvvfs-file.
36607 int flags,
36661 int flags,
36980 int flags; /* Flags this file descriptor was opened with */
36995 unsigned short int ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
37012 int openFlags; /* The flags specified at open() */
37138 unsigned int flags = 0;
37139 int ret = ioctl(fd, HMFS_IOCTL_HW_GET_FLAGS, &flags);
37143 if (flags & HMFS_MONITOR_FL) {
37146 flags |= HMFS_MONITOR_FL;
37147 ret = ioctl(fd, HMFS_IOCTL_HW_SET_FLAGS, &flags);
37163 static int posixOpen(const char *zFile, int flags, int mode){
37164 int fd = open(zFile, flags, mode);
38677 /* Set up the transaction-counter change checking flags when
40589 static int unixSync(sqlite3_file *id, int flags){
40593 int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
40594 int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
40597 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
40598 || (flags&0x0F)==SQLITE_SYNC_FULL
41800 int flags /* What to do with the lock */
41812 sqlite3_log(SQLITE_IOERR_SHMLOCK, "unixShmLock-pShm, fd[%d], ofst[%d], n[%d], flags[%d]", ofst, n, flags);
41819 sqlite3_log(SQLITE_IOERR_SHMLOCK, "unixShmLock-pShmNode, fd[%d], ofst[%d], n[%d], flags[%d]", ofst, n, flags);
41829 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
41830 || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
41831 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
41832 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
41833 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
41851 assert( (flags & SQLITE_SHM_UNLOCK) || pDbFd->iBusyTimeout==0 || (
41863 if( flags & SQLITE_SHM_UNLOCK ){
41890 }else if( flags & SQLITE_SHM_SHARED ){
42054 int flags = PROT_READ; /* Flags to pass to mmap() */
42064 if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;
42085 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
42104 pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
42801 ** zPath with SQLITE_OPEN_XXX flags matching those passed as the second
42814 static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
42847 flags &= (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE);
42848 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
42905 int flags, /* Flags passed as 4th argument to xOpen() */
42914 if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
42946 }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
42948 }else if( flags & SQLITE_OPEN_URI ){
42971 ** These calls correspond to the following combinations of flags:
42987 int flags, /* Input flags to control the opening */
42988 int *pOutFlags /* Output flags returned to SQLite core */
42993 int eType = flags&0x0FFF00; /* Type of file to open */
42996 int ctrlFlags = 0; /* UNIXFILE_* flags */
42998 int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
42999 int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
43000 int isCreate = (flags & SQLITE_OPEN_CREATE);
43001 int isReadonly = (flags & SQLITE_OPEN_READONLY);
43002 int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
43004 int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY);
43028 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
43045 /* Assert that the upper layer has set one of the "file-type" flags. */
43070 pUnused = findReusableFd(zName, flags);
43084 assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
43100 /* Determine the value of the flags parameter passed to POSIX function
43114 rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
43130 flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
43132 flags |= SQLITE_OPEN_READONLY;
43156 if( openMode && (flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL))!=0 ){
43162 *pOutFlags = flags;
43167 p->pPreallocatedUnused->flags =
43168 flags & (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE);
43195 sqlite3_log(SQLITE_IOERR_ACCESS, "unixOpen, fd[%d], flags[%d], errno[%d]", fd, errno, flags);
43213 if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI;
43305 ** test performed depends on the value of flags:
43316 int flags, /* What do we want to learn about the zPath file? */
43323 /* The spec says there are three possible values for flags. But only
43325 assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE );
43327 if( flags==SQLITE_ACCESS_EXISTS ){
44058 pUnused->flags = openFlags;
44660 /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
45480 * The extra flags to use in calls to the Win32 heap APIs. This value may be
46665 "failed to HeapCreate (%lu), flags=%u, initSize=%lu, maxSize=%lu",
47589 DWORD flags,
47608 return osLockFileEx(*phFile, flags, 0, numBytesLow, numBytesHigh, &ovlp);
48071 static int winSync(sqlite3_file *id, int flags){
48091 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
48092 || (flags&0x0F)==SQLITE_SYNC_FULL
48100 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n",
48101 osGetCurrentProcessId(), pFile, pFile->h, flags,
48105 UNUSED_PARAMETER(flags);
48107 if( (flags&0x0F)==SQLITE_SYNC_FULL ){
48213 ** obtain an exclusive lock. These flags are used with the LockFileEx function
49148 int flags /* What to do with the lock */
49163 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
49164 || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
49165 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
49166 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
49167 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
49172 if( flags & SQLITE_SHM_UNLOCK ){
49194 }else if( flags & SQLITE_SHM_SHARED ){
49296 DWORD flags = FILE_MAP_WRITE | FILE_MAP_READ;
49361 flags = FILE_MAP_READ;
49388 pMap = osMapViewOfFileFromApp(hMap, flags,
49392 pMap = osMapViewOfFile(hMap, flags,
49517 DWORD flags = FILE_MAP_READ;
49523 flags |= FILE_MAP_WRITE;
49549 pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap);
49551 pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
50079 int flags, /* Type of test to make on this file */
50090 int flags, /* Open mode flags */
50091 int *pOutFlags /* Status return flags */
50115 int eType = flags&0xFFFFFF00; /* Type of file to open */
50118 int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
50119 int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
50120 int isCreate = (flags & SQLITE_OPEN_CREATE);
50121 int isReadonly = (flags & SQLITE_OPEN_READONLY);
50122 int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
50132 OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n",
50133 zUtf8Name, id, flags, pOutFlags));
50137 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
50154 /* Assert that the upper layer has set one of the "file-type" flags. */
50189 assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
50327 ((flags|SQLITE_OPEN_READONLY) &
50379 if( (flags & SQLITE_OPEN_MAIN_DB)
50520 int flags, /* Type of test to make on this file */
50530 OSTRACE(("ACCESS name=%s, flags=%x, pResOut=%p\n",
50531 zFilename, flags, pResOut));
50549 if( flags==SQLITE_ACCESS_EXISTS
50573 switch( flags ){
50583 assert(!"Invalid flags argument");
51380 static int memdbSync(sqlite3_file*, int flags);
51396 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
51619 static int memdbSync(sqlite3_file *pFile, int flags){
51621 UNUSED_PARAMETER(flags);
51770 ** Return the device characteristic flags supported by an memdb-file.
51817 int flags,
51885 *pOutFlags = flags | SQLITE_OPEN_MEMORY;
51913 int flags,
51918 UNUSED_PARAMETER(flags);
52108 unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */
52683 printf("%3d: nRef %2d flgs %02x data ", i, pPg->nRef, pPg->flags);
52742 if( pPg->flags & PGHDR_CLEAN ){
52743 assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */
52746 assert( (pPg->flags & PGHDR_DIRTY)!=0 );/* If not CLEAN must be DIRTY */
52753 if( pPg->flags & PGHDR_WRITEABLE ){
52754 assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */
52849 && 0==(pPage->flags&PGHDR_NEED_SYNC) /*OPTIMIZATION-IF-FALSE*/
53060 pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
53113 pPgHdr->flags = PGHDR_CLEAN;
53150 if( p->flags&PGHDR_CLEAN ){
53177 if( p->flags&PGHDR_DIRTY ){
53191 if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){ /*OPTIMIZATION-IF-FALSE*/
53192 p->flags &= ~PGHDR_DONT_WRITE;
53193 if( p->flags & PGHDR_CLEAN ){
53194 p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN);
53196 assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY );
53210 assert( (p->flags & PGHDR_DIRTY)!=0 );
53211 assert( (p->flags & PGHDR_CLEAN)==0 );
53213 p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
53214 p->flags |= PGHDR_CLEAN;
53240 p->flags &= ~(PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
53251 p->flags &= ~PGHDR_NEED_SYNC;
53276 if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
53304 assert( p->flags&PGHDR_DIRTY );
54933 u16 rsFlags; /* Various flags */
55041 /* Avoid unnecessary sorts by preserving the ROWSET_SORTED flags
55368 /* Macros for extracting appropriate sync flags for either transaction
56106 ** and contains the flags used to sync the checkpoint operations in the
56107 ** lower two bits, and sync flags used for transaction commits in the WAL
56108 ** file in bits 0x04 and 0x08. In other words, to get the correct sync flags
56110 ** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note
56774 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
57908 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
57915 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
58067 const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
58068 rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0);
58110 int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
58111 rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
59125 unsigned pgFlags /* Various flags */
59175 ** The flags passed to the VFS layer xOpen() call are those specified
59488 assert( pPg->flags&PGHDR_DIRTY );
59590 p->flags = PGHDR_MMAP;
59597 assert( p->flags==PGHDR_MMAP );
59687 if( db && 0==(db->flags & SQLITE_NoCkptOnClose)
59972 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
59976 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
60025 const int flags = SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE
60032 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
60122 assert( pPg->flags&PGHDR_DIRTY );
60146 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
60169 if( pPg->flags&PGHDR_NEED_SYNC
60177 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
60229 ** The flags argument is used to specify properties that affect the
60231 ** of the PAGER_* flags.
60233 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
60248 int flags, /* flags controlling this file */
60249 int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
60266 int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
60281 if( flags & PAGER_MEMORY ){
60459 int fout = 0; /* VFS flags returned by xOpen() */
61024 ** the flags parameter contains the PAGER_GET_NOCONTENT bit and the
61061 int flags /* PAGER_GET_XXX flags */
61089 noContent = (flags & PAGER_GET_NOCONTENT)!=0;
61163 int flags /* PAGER_GET_XXX flags */
61174 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
61226 return getPageNormal(pPager, pgno, ppPage, flags);
61235 int flags /* PAGER_GET_XXX flags */
61238 UNUSED_PARAMETER(flags);
61251 int flags /* PAGER_GET_XXX flags */
61254 return pPager->xGet(pPager, pgno, ppPage, flags);
61294 if( pPg->flags & PGHDR_MMAP ){
61310 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
61362 int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
61366 flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
61367 flags |= SQLITE_OPEN_EXCLUSIVE;
61370 flags |= SQLITE_OPEN_MAIN_JOURNAL;
61379 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
61521 pPg->flags |= PGHDR_NEED_SYNC;
61535 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
61607 pPg->flags |= PGHDR_NEED_SYNC;
61611 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
61620 pPg->flags |= PGHDR_WRITEABLE;
61691 if( pPage->flags&PGHDR_NEED_SYNC ){
61698 if( pPage->flags&PGHDR_NEED_SYNC ){
61716 pPage->flags |= PGHDR_NEED_SYNC;
61743 assert( (pPg->flags & PGHDR_MMAP)==0 );
61746 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
61766 return pPg->flags & PGHDR_WRITEABLE;
61792 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
61795 pPg->flags |= PGHDR_DONT_WRITE;
61796 pPg->flags &= ~PGHDR_WRITEABLE;
61797 testcase( pPg->flags & PGHDR_NEED_SYNC );
62735 if( (pPg->flags & PGHDR_DIRTY)!=0
62742 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
62752 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
62756 assert( pPg->flags&PGHDR_DIRTY );
62764 pPg->flags &= ~PGHDR_NEED_SYNC;
62772 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
62819 pPgHdr->flags |= PGHDR_NEED_SYNC;
62831 ** page number to iNew and sets the value of the PgHdr.flags field to
62834 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
62836 pPg->flags = flags;
64844 int flags; /* Flags passed to OsOpen() */
64912 flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
64913 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
64914 if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
67105 p->flags &= ~PGHDR_WAL_APPEND;
67117 p->flags |= PGHDR_WAL_APPEND;
67181 if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue;
67702 ** The flags define the format of this btree page. The leaf flag means that
67819 ** Page type flags. An ORed combination of these flags appear as the
68093 u8 curFlags; /* zero or more BTCF_* flags defined below */
68812 || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommit))
68891 && 0==(p->pBtree->db->flags & SQLITE_ReadUncommit)
68913 assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 );
68991 assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK );
70515 ** Decode the flags byte (the first byte of the header) for a page
70768 if( pBt->db->flags & SQLITE_CellSizeCk ){
70778 static void zeroPage(MemPage *pPage, int flags){
70792 data[hdr] = (char)flags;
70793 first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8);
70798 decodeFlags(pPage, flags);
70843 int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
70848 assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY );
70850 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
70991 int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
70993 int rc = btreeGetPage(pBt, pgno, ppPage, flags);
71061 ** The "flags" parameter is a bitmask that might contain bits like
71075 int flags, /* Options */
71102 assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
71105 assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
71108 assert( (flags & BTREE_SINGLE)==0 || isTempDb );
71111 flags |= BTREE_MEMORY;
71218 sizeof(MemPage), flags, vfsFlags, pageReinit);
71226 pBt->openFlags = (u8)flags;
71576 unsigned pgFlags /* Various PAGER_* flags */
71694 ** Change the values for the BTS_SECURE_DELETE and BTS_OVERWRITE flags:
71791 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK));
71833 if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){
72144 if( (p->db->flags & SQLITE_ResetDatabase)
73888 ** This function returns SQLITE_CORRUPT if the page-header flags field of
73889 ** the new child page does not match the flags field of the parent (i.e.
73975 ** page-header flags indicate that the [virtual] root-page is the expected
73977 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
73979 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
74752 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){
74754 UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */
74756 assert( flags==0 || flags==1 );
74841 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){
74843 assert( flags==0 || flags==1 );
74844 UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */
76962 assert( apNew[i]->pDbPage->flags & PGHDR_WRITEABLE );
76963 assert( apNew[i]->pDbPage->flags & PGHDR_DIRTY );
76980 u16 fgA = apNew[i]->pDbPage->flags;
76981 u16 fgB = apNew[iB]->pDbPage->flags;
77631 int flags, /* True if this is likely an append */
77644 assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND|BTREE_PREFORMAT))==flags );
77645 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
77692 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
77706 if( flags & BTREE_SAVEPOSITION ){
77734 (flags & BTREE_APPEND)!=0, &loc);
77743 assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 );
77750 if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){
77761 (flags & BTREE_APPEND)!=0, &loc);
77785 assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
77803 if( flags & BTREE_PREFORMAT ){
77906 if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){
78042 ** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then
78048 ** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes
78056 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
78073 assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
78112 bPreserve = (flags & BTREE_SAVEPOSITION)!=0;
78259 ** The type of type is determined by the flags parameter. Only the
78260 ** following values of flags are currently in use. Other values for
78261 ** flags might not work:
78411 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, Pgno *piTable, int flags){
78414 rc = btreeCreateTable(p, piTable, flags);
79317 u64 savedDbFlags = pBt->db->flags;
79398 testcase( pBt->db->flags & SQLITE_CellSizeCk );
79399 pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
79410 pBt->db->flags = savedDbFlags;
80585 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
80589 ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn.
80591 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
80594 assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) );
80596 if( p->flags & MEM_Null ){
80598 assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 );
80605 if( (p->flags & (MEM_Term|MEM_Subtype))==(MEM_Term|MEM_Subtype) ){
80608 assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
80609 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
80610 ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 );
80613 assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind
80616 /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn,
80621 assert( (p->flags & MEM_Cleared)==0 );
80626 || (p->flags==MEM_Undefined
80638 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
80641 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
80642 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
80643 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
80656 assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
80658 if( p->flags & MEM_Int ){
80663 assert( (p->flags&MEM_Int)*2==sizeof(x) );
80664 memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2);
80672 (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r);
80705 if( (p->flags & MEM_Str)==0 ) return 1;
80706 if( p->flags & MEM_Term ){
80717 if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1;
80755 if( !(pMem->flags&MEM_Str) ){
80793 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
80797 || (pMem->flags==MEM_Undefined
80826 if( (pMem->flags&MEM_Dyn)!=0 ){
80832 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
80851 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
80855 assert( (pMem->flags & MEM_Dyn)==0 );
80857 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
80877 pMem->flags |= MEM_Term;
80891 if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
80898 pMem->flags &= ~MEM_Ephem;
80914 assert( pMem->flags & MEM_Zero );
80915 assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
80923 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
80934 pMem->flags &= ~(MEM_Zero|MEM_Term);
80945 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
80946 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
80947 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
80973 assert( !(pMem->flags&MEM_Zero) );
80974 assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
80975 assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
80989 pMem->flags |= MEM_Str|MEM_Term;
80990 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
81010 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
81014 t.flags = MEM_Null;
81021 assert( (pMem->flags & MEM_Dyn)==0 );
81040 assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
81057 ** will free that value. It also sets Mem.flags to MEM_Null.
81066 if( p->flags&MEM_Agg ){
81068 assert( (p->flags & MEM_Agg)==0 );
81069 testcase( p->flags & MEM_Dyn );
81071 if( p->flags&MEM_Dyn ){
81075 p->flags = MEM_Null;
81169 int flags;
81173 flags = pMem->flags;
81174 if( flags & (MEM_Int|MEM_IntReal) ){
81175 testcase( flags & MEM_IntReal );
81177 }else if( flags & MEM_Real ){
81179 }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
81202 if( pMem->flags & MEM_Real ){
81204 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
81205 testcase( pMem->flags & MEM_IntReal );
81207 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
81220 testcase( pMem->flags & MEM_IntReal );
81221 if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0;
81222 if( pMem->flags & MEM_Null ) return ifNull;
81233 assert( pMem->flags & MEM_Real );
81320 testcase( pMem->flags & MEM_Int );
81321 testcase( pMem->flags & MEM_Real );
81322 testcase( pMem->flags & MEM_IntReal );
81323 testcase( pMem->flags & MEM_Null );
81324 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
81327 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
81339 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
81340 pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
81352 if( pMem->flags & MEM_Null ) return SQLITE_OK;
81355 if( (pMem->flags & MEM_Blob)==0 ){
81357 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
81358 if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
81360 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
81379 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
81381 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
81382 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero);
81395 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
81396 assert( (flags & ~MEM_TypeMask)==0 );
81397 pMem->flags = flags;
81419 pMem->flags = MEM_Null;
81433 pMem->flags = MEM_Blob|MEM_Zero;
81450 pMem->flags = MEM_Blob;
81464 pMem->flags = MEM_Int;
81476 pMem->flags = MEM_Int;
81493 assert( pMem->flags==MEM_Null );
81497 pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term;
81511 pMem->flags = MEM_Real;
81522 return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn)
81543 pMem->flags = MEM_Blob|MEM_Dyn;
81554 if( p->flags & (MEM_Str|MEM_Blob) ){
81556 if( p->flags & MEM_Zero ){
81579 if( pVdbe->db->flags & SQLITE_VdbeTrace ){
81589 mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
81594 pX->flags = MEM_Undefined;
81606 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
81618 if( (pFrom->flags&MEM_Static)==0 ){
81619 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
81621 pTo->flags |= srcType;
81635 pTo->flags &= ~MEM_Dyn;
81636 if( pTo->flags&(MEM_Str|MEM_Blob) ){
81637 if( 0==(pFrom->flags&MEM_Static) ){
81638 pTo->flags |= MEM_Ephem;
81659 pFrom->flags = MEM_Null;
81694 u16 flags; /* New value for pMem->flags */
81719 flags= MEM_Str|MEM_Term;
81721 flags = MEM_Blob;
81724 flags = MEM_Str;
81739 ** also sets a flag in local variable "flags" to indicate the memory
81744 if( flags&MEM_Term ){
81762 flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
81767 pMem->flags = flags;
81802 pMem->flags = MEM_Null;
81810 pMem->flags = MEM_Blob;
81836 pMem->flags = MEM_Blob|MEM_Ephem;
81855 assert( (pVal->flags & (MEM_Null))==0 );
81856 if( pVal->flags & (MEM_Blob|MEM_Str) ){
81858 pVal->flags |= MEM_Str;
81863 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
81898 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
81902 if( pVal->flags&MEM_Null ){
81914 p->flags = MEM_Null;
81962 pRec->aMem[i].flags = MEM_Null;
81988 ** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
82022 assert( (p->flags & EP_TokenOnly)==0 );
82125 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
82166 assert( (pVal->flags & MEM_IntReal)==0 );
82167 if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
82168 testcase( pVal->flags & MEM_Int );
82169 testcase( pVal->flags & MEM_Real );
82170 pVal->flags &= ~MEM_Str;
82181 if( pVal->flags & MEM_Real ){
82224 pVal->flags = MEM_Int;
82306 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
82515 assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
82516 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
82519 if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){
82522 if( (p->flags & MEM_Blob)!=0 ){
82523 if( p->flags & MEM_Zero ){
82529 if( p->flags & MEM_Null ) return 0;
82800 if( p->db->flags & SQLITE_VdbeAddopTrace ){
83117 if( p->db->flags & SQLITE_VdbeAddopTrace ){
83333 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
83541 ** pragmas comports with the flags specified in the mkpragmatab.tcl
83630 if( p->db->flags & SQLITE_VdbeAddopTrace ){
84344 if( pMem->flags & MEM_Str ){
84346 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
84348 }else if( pMem->flags & MEM_Real ){
84350 }else if( pMem->flags & MEM_Null ){
84353 assert( pMem->flags & MEM_Blob );
84517 ** Mem.flags = flags
84524 static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){
84527 p->flags = flags;
84572 testcase( p->flags & MEM_Agg );
84573 testcase( p->flags & MEM_Dyn );
84574 if( p->flags&(MEM_Agg|MEM_Dyn) ){
84575 testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel );
84577 p->flags = MEM_Undefined;
84581 p->flags = MEM_Undefined;
84585 p->flags = MEM_Undefined;
84653 if( pSub->flags&MEM_Blob ){
84780 int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0);
85285 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
85782 }else if( db->flags & SQLITE_CorruptRdOnly ){
85784 db->flags &= ~SQLITE_CorruptRdOnly;
85802 db->flags &= ~(u64)SQLITE_DeferFKs;
85987 for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
86269 int flags = pMem->flags;
86273 if( flags&MEM_Null ){
86277 if( flags&(MEM_Int|MEM_IntReal) ){
86282 testcase( flags & MEM_Int );
86283 testcase( flags & MEM_IntReal );
86303 if( flags&MEM_IntReal ){
86308 pMem->flags &= ~MEM_IntReal;
86309 pMem->flags |= MEM_Real;
86314 if( flags&MEM_Real ){
86318 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
86321 if( flags & MEM_Zero ){
86325 return ((n*2) + 12 + ((flags&MEM_Str)!=0));
86447 pMem->flags = MEM_Int;
86467 pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
86478 pMem->flags = MEM_Null|MEM_Zero;
86486 pMem->flags = MEM_Null;
86493 pMem->flags = MEM_Int;
86501 pMem->flags = MEM_Int;
86509 pMem->flags = MEM_Int;
86521 pMem->flags = MEM_Int;
86529 pMem->flags = MEM_Int;
86545 pMem->flags = MEM_Int;
86556 pMem->flags = aFlag[serial_type&1];
86620 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
86669 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
86718 && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null))
86852 assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
86853 assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
86855 if( (pB1->flags|pB2->flags) & MEM_Zero ){
86856 if( pB1->flags & pB2->flags & MEM_Zero ){
86858 }else if( pB1->flags & MEM_Zero ){
86913 f1 = pMem1->flags;
86914 f2 = pMem2->flags;
87116 if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
87117 testcase( pRhs->flags & MEM_Int );
87118 testcase( pRhs->flags & MEM_IntReal );
87140 else if( pRhs->flags & MEM_Real ){
87165 else if( pRhs->flags & MEM_Str ){
87184 mem1.flags = MEM_Str;
87198 else if( pRhs->flags & MEM_Blob ){
87199 assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
87211 }else if( pRhs->flags & MEM_Zero ){
87236 !=(serial_type==0 || (pRhs->flags&MEM_Null)))
87393 assert( pPKey2->aMem[0].flags & MEM_Str );
87470 int flags = p->aMem[0].flags;
87481 if( (flags & MEM_Int) ){
87485 testcase( flags & MEM_Real );
87486 testcase( flags & MEM_Null );
87487 testcase( flags & MEM_Blob );
87488 if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0
87491 assert( flags & MEM_Str );
87670 ** Return the SQLITE_PREPARE flags for a Vdbe.
87688 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
87689 if( 0==(pMem->flags & MEM_Null) ){
87708 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
88021 p->aVar[i].flags = MEM_Null;
88038 if( p->flags & (MEM_Blob|MEM_Str) ){
88040 assert( p->flags==MEM_Null && p->z==0 );
88043 p->flags |= MEM_Blob;
88066 return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
88070 if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
88169 if( pVal->flags & MEM_Null ){
88171 }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
88173 }else if( pVal->flags & MEM_Int ){
88175 }else if( pVal->flags & MEM_Str ){
88178 assert( eType == aType[pVal->flags&MEM_AffMask] );
88181 return aType[pVal->flags&MEM_AffMask];
88189 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
88194 return (pVal->flags&MEM_FromBind)!=0;
88206 pNew->flags &= ~MEM_Dyn;
88208 if( pNew->flags&(MEM_Str|MEM_Blob) ){
88209 pNew->flags &= ~(MEM_Static|MEM_Dyn);
88210 pNew->flags |= MEM_Ephem;
88215 }else if( pNew->flags & MEM_Null ){
88217 pNew->flags &= ~(MEM_Term|MEM_Subtype);
88343 pOut->flags = MEM_Null;
88350 pOut->flags |= MEM_Subtype;
88437 if( pCtx->pOut->flags & MEM_Null ){
88466 if( pCtx->pOut->flags & MEM_Int ){
88467 pCtx->pOut->flags &= ~MEM_Int;
88468 pCtx->pOut->flags |= MEM_IntReal;
88819 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
88875 assert( (pMem->flags & MEM_Agg)==0 );
88881 pMem->flags = MEM_Agg;
88899 if( (p->pMem->flags & MEM_Agg)==0 ){
89042 /* .flags = */ (u16)MEM_Null,
89161 if( pOut->flags&MEM_Static ){
89162 pOut->flags &= ~MEM_Static;
89163 pOut->flags |= MEM_Ephem;
89359 pVar->flags = MEM_Null;
89529 assert( pValue->flags & (MEM_Real|MEM_IntReal) );
89531 (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i
89536 if( pValue->flags & MEM_Zero ){
89876 if( pMem->flags & (MEM_Int|MEM_IntReal) ){
89877 testcase( pMem->flags & MEM_Int );
89878 testcase( pMem->flags & MEM_IntReal );
89988 if( pMem->flags==0 ){
90204 if( pVar->flags & MEM_Null ){
90206 }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){
90208 }else if( pVar->flags & MEM_Real ){
90210 }else if( pVar->flags & MEM_Str ){
90241 }else if( pVar->flags & MEM_Zero ){
90245 assert( pVar->flags & MEM_Blob );
90353 if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
90426 ** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5.
90433 ** 8 bytes are flags. The lower three bits of the flags indicate
90435 ** always taken, the flags should be 0x05 since the fall-through and
90437 ** flags should be 0x06 since only the fall-through approach is allowed.
90439 ** Bit 0x08 of the flags indicates an OP_Jump opcode that is only
90458 /* The upper 8 bits of iSrcLine are flags. The lower three bits of
90459 ** the flags indicate directions that the branch can never go. If
90467 ** flags removed.
90500 if( ((P)->flags&MEM_Ephem)!=0 \
90552 assert( pMem->flags==MEM_Undefined );
90553 assert( (pMem->flags & MEM_Dyn)==0 );
90615 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
90619 pRec->flags |= MEM_Int;
90622 pRec->flags |= MEM_Real;
90629 pRec->flags &= ~MEM_Str;
90659 if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
90660 if( (pRec->flags & MEM_Real)==0 ){
90661 if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
90672 if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
90673 if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
90674 testcase( pRec->flags & MEM_Int );
90675 testcase( pRec->flags & MEM_Real );
90676 testcase( pRec->flags & MEM_IntReal );
90680 pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal);
90721 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
90722 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
90746 ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
90750 assert( (pMem->flags & MEM_Null)==0
90752 if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){
90753 testcase( pMem->flags & MEM_Int );
90754 testcase( pMem->flags & MEM_Real );
90755 testcase( pMem->flags & MEM_IntReal );
90756 return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null);
90758 assert( pMem->flags & (MEM_Str|MEM_Blob) );
90759 testcase( pMem->flags & MEM_Str );
90760 testcase( pMem->flags & MEM_Blob );
90770 int f = pMem->flags;
90830 if( p->flags & MEM_Undefined ){
90832 }else if( p->flags & MEM_Null ){
90833 printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL");
90834 }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
90836 }else if( (p->flags & (MEM_IntReal))!=0 ){
90838 }else if( p->flags & MEM_Int ){
90841 }else if( p->flags & MEM_Real ){
90853 if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
90884 # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
90981 pOut->flags = MEM_Int;
90993 pOut->flags = MEM_Int;
91009 if( p->flags & (MEM_Int|MEM_IntReal) ){
91011 }else if( p->flags & MEM_Real ){
91013 }else if( p->flags & (MEM_Str|MEM_Blob) ){
91015 if( p->flags & MEM_Zero ) h += p->u.nZero;
91048 int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */
91098 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
91103 if( p->db->flags & SQLITE_VdbeListing ){
91109 if( p->db->flags & SQLITE_VdbeEQP ){
91118 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
91139 if( db->flags & SQLITE_VdbeTrace ){
91251 /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
91309 pIn1->flags = MEM_Int;
91339 if( pIn1->flags & MEM_Int ){
91366 pOut->flags = MEM_Int;
91389 assert( pIn1->flags==MEM_Int );
91395 pIn1->flags = MEM_Undefined;
91416 pIn1->flags = MEM_Int;
91437 if( (pIn3->flags & MEM_Null)==0 ) break;
91571 pOut->flags = MEM_Real;
91600 pOut->flags |= MEM_Static;
91633 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
91642 assert( pIn3->flags & MEM_Int );
91643 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
91690 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
91699 pOut->flags = nullFlag;
91717 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
91762 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
91763 pOut->flags |= MEM_Static|MEM_FromBind;
91838 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
91839 pOut->flags &= ~MEM_Subtype;
91872 pOut->mScopyFlags = pIn1->flags;
91887 assert( (pIn1->flags & MEM_Int)!=0 );
92005 u16 flags1; /* Initial flags for P1 */
92006 u16 flags2; /* Initial flags for P2 */
92013 flags1 = pIn1->flags;
92015 testcase( pIn2->flags & MEM_Null );
92016 if( (flags1 | pIn2->flags) & MEM_Null ){
92022 flags1 = pIn1->flags & ~MEM_Str;
92025 flags1 = pIn1->flags & ~MEM_Str;
92027 flags2 = pIn2->flags;
92030 flags2 = pIn2->flags & ~MEM_Str;
92033 flags2 = pIn2->flags & ~MEM_Str;
92045 assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
92046 pIn2->flags = flags2;
92049 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
92050 pIn1->flags = flags1;
92054 pOut->flags |= MEM_Term;
92112 type1 = pIn1->flags;
92114 type2 = pIn2->flags;
92250 if( (pIn1->flags | pIn2->flags) & MEM_Null ){
92315 if( (pIn1->flags & MEM_Int)==0 ){
92317 if( (pIn1->flags & MEM_Int)==0 ){
92344 if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
92345 testcase( pIn1->flags & MEM_Int );
92346 testcase( pIn1->flags & MEM_IntReal );
92489 u16 flags1; /* Copy of initial value of pIn1->flags */
92490 u16 flags3; /* Copy of initial value of pIn3->flags */
92494 flags1 = pIn1->flags;
92495 flags3 = pIn3->flags;
92558 testcase( flags3==pIn3->flags );
92559 flags3 = pIn3->flags;
92567 testcase( pIn1->flags & MEM_Int );
92568 testcase( pIn1->flags & MEM_Real );
92569 testcase( pIn1->flags & MEM_IntReal );
92571 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
92572 flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
92576 testcase( pIn3->flags & MEM_Int );
92577 testcase( pIn3->flags & MEM_Real );
92578 testcase( pIn3->flags & MEM_IntReal );
92580 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
92581 flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
92606 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
92607 pIn3->flags = flags3;
92608 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
92609 pIn1->flags = flags1;
92738 && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))
92864 if( (pIn1->flags & MEM_Null)==0 ){
92883 if( (pIn1->flags & MEM_Null)==0 ){
92884 pOut->flags = MEM_Int;
92963 VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
92964 if( (pIn1->flags & MEM_Null)!=0 ){
93065 if( (aMem[pOp->p1].flags & MEM_Null)!=0
93066 || (aMem[pOp->p3].flags & MEM_Null)!=0
93082 VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
93083 if( (pIn1->flags & MEM_Null)==0 ){
93207 assert( pReg->flags & MEM_Blob );
93403 pDest->flags = MEM_Null;
93411 pDest->flags = aFlag[t&1];
93439 pDest->flags &= ~MEM_Ephem;
93502 if( (pIn1->flags & MEM_Null)==0 ){
93505 if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error;
93510 if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error;
93514 if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error;
93518 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real );
93519 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_IntReal );
93520 if( pIn1->flags & MEM_Int ){
93530 pIn1->flags |= MEM_IntReal;
93531 pIn1->flags &= ~MEM_Int;
93534 pIn1->flags |= MEM_Real;
93535 pIn1->flags &= ~MEM_Int;
93537 }else if( (pIn1->flags & (MEM_Real|MEM_IntReal))==0 ){
93583 if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
93593 pIn1->flags |= MEM_IntReal;
93594 pIn1->flags &= ~MEM_Int;
93597 pIn1->flags |= MEM_Real;
93598 pIn1->flags &= ~MEM_Int;
93689 if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
93690 pRec->flags |= MEM_IntReal;
93691 pRec->flags &= ~(MEM_Int);
93707 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
93743 if( pRec->flags & MEM_Null ){
93744 if( pRec->flags & MEM_Zero ){
93759 }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){
93763 testcase( pRec->flags & MEM_Int );
93764 testcase( pRec->flags & MEM_IntReal );
93797 if( pRec->flags & MEM_IntReal ){
93802 pRec->flags &= ~MEM_IntReal;
93803 pRec->flags |= MEM_Real;
93809 }else if( pRec->flags & MEM_Real ){
93814 assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) );
93817 serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0);
93818 if( pRec->flags & MEM_Zero ){
93872 pOut->flags = MEM_Blob;
93875 pOut->flags |= MEM_Zero;
94270 if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){
94271 if( db->flags & SQLITE_QueryOnly ){
94581 assert( (pIn2->flags & MEM_Int)!=0 );
94613 ** SQLite used to check if the root-page flags were sane at this point
94682 ** The P5 parameter can be a mask of the BTREE_* flags defined
94683 ** in btree.h. These flags control aspects of the operation of
94684 ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
94717 assert( aMem[pOp->p3].flags & MEM_Null );
94903 ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
94970 ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
95016 flags3 = pIn3->flags;
95021 newType = pIn3->flags; /* Record the type after applying numeric affinity */
95022 pIn3->flags = flags3; /* But convert the type back to its original */
95279 if( db->flags&SQLITE_VdbeTrace ){
95308 if( db->flags&SQLITE_VdbeTrace ){
95319 if( db->flags&SQLITE_VdbeTrace ){
95329 if( db->flags&SQLITE_VdbeTrace ){
95374 if( db->flags&SQLITE_VdbeTrace ){
95381 if( db->flags&SQLITE_VdbeTrace ){
95504 if( db->flags&SQLITE_VdbeTrace ){
95544 assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
95551 assert( r.aMem->flags & MEM_Blob );
95583 if( r.aMem[ii].flags & MEM_Null ){
95651 testcase( pIn3->flags & MEM_Int );
95652 testcase( pIn3->flags & MEM_IntReal );
95653 testcase( pIn3->flags & MEM_Real );
95654 testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
95655 if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
95663 if( (x.flags & MEM_Int)==0 ) goto jump_to_p2;
95671 assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
95820 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
95920 assert( pKey->flags & MEM_Int );
95951 assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 );
95955 if( pData->flags & MEM_Zero ){
96095 || (aMem[pOp->p3].flags & MEM_Int)
96106 /* Only flags that can be set are SAVEPOISTION and AUXDELETE */
96207 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
96304 pOut->flags = MEM_Null;
96324 pOut->flags = MEM_Null;
96676 assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
96712 assert( pIn2->flags & MEM_Blob );
97026 pOut->flags = MEM_Null;
97036 pOut->flags = MEM_Int;
97114 ** Synopsis: r[P2]=root iDb=P1 flags=P3
97183 || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) );
97326 assert( (pnErr->flags & MEM_Int)!=0 );
97327 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
97359 assert( (pIn2->flags & MEM_Int)!=0 );
97360 if( (pIn1->flags & MEM_Blob)==0 ){
97380 assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
97381 if( (pIn1->flags & MEM_Blob)==0
97426 assert( pIn3->flags&MEM_Int );
97431 if( (pIn1->flags & MEM_Blob)==0 ){
97507 if( (pRt->flags&MEM_Blob)==0 ){
97525 pRt->flags = MEM_Blob|MEM_Dyn;
97550 pMem->flags = MEM_Undefined;
97632 if( db->flags & SQLITE_DeferFKs ){
97709 assert( pIn1->flags&MEM_Int );
97741 assert( pIn1->flags & MEM_Int );
97742 assert( pIn3->flags & MEM_Int );
97769 assert( pIn1->flags&MEM_Int );
97790 assert( pIn1->flags&MEM_Int );
97800 assert( pIn1->flags&MEM_Int );
97917 assert( pCtx->pOut->flags==MEM_Null );
97939 pCtx->pOut->flags = MEM_Null;
97943 assert( pCtx->pOut->flags==MEM_Null );
97980 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
98135 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
98263 if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
98315 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
98316 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
98410 pOut->flags = MEM_Null;
98462 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
98522 pDest->flags = MEM_Null|MEM_Zero;
98596 isLegacy = (db->flags & SQLITE_LegacyAlter);
98597 db->flags |= SQLITE_LegacyAlter;
98604 assert( pName->flags & MEM_Str );
98611 if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
98685 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
98830 assert( (pOut->flags&MEM_Str)==0
98847 pIn1->flags &= ~MEM_Subtype;
98862 assert( pIn1->flags & MEM_Blob );
98866 if( db->flags&SQLITE_VdbeTrace ){
98898 assert( (pIn1->flags & MEM_Blob)!=0 );
98902 if( db->flags&SQLITE_VdbeTrace ){
98999 if( (db->flags & SQLITE_SqlTrace)!=0
99149 if( db->flags & SQLITE_VdbeTrace ){
99180 if( db->flags & SQLITE_VdbeTrace ){
99202 db->flags |= SQLITE_CorruptRdOnly;
99319 v->aMem[1].flags = MEM_Int;
99468 if( db->flags&SQLITE_ForeignKeys ){
102534 if( r2->aMem[i].flags & MEM_Null ){
103049 int flags; /* xOpen flags */
103123 rc = sqlite3OsOpen(copy.pVfs, copy.zJournal, pReal, copy.flags, 0);
103274 static int memjrnlSync(sqlite3_file *pJfd, int flags){
103275 UNUSED_PARAMETER2(pJfd, flags);
103329 int flags, /* Opening flags */
103334 assert( zName || nSpill<0 || (flags & SQLITE_OPEN_EXCLUSIVE) );
103342 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
103354 p->flags = flags;
103388 || (p->flags & SQLITE_OPEN_MAIN_JOURNAL)
103821 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
103824 return (db->flags & SQLITE_DqsDDL)!=0;
103827 return (db->flags & SQLITE_DqsDML)!=0;
105178 pNew->flags |= EP_IntValue;
105413 /* If the SF_Converted flags is set, then this Select object was
105920 pNew->flags |= EP_Collate|EP_Skip;
106013 if( p->flags & EP_Collate ){
106014 if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
106136 int jumpIfNull /* Extra flags added to P5 */
106162 if( pLeft->flags & EP_Collate ){
106164 }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
106577 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
106589 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
106599 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
106600 ** Expr.flags.
106619 ** Propagate all EP_Propagate flags from the Expr.x.pList into
106620 ** Expr.flags.
106625 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
106676 pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
106731 pRoot->flags |= EP_Propagate & pRight->flags;
106740 pRoot->flags |= EP_Propagate & pLeft->flags;
106930 || (pParse->db->flags & SQLITE_TrustedSchema)==0
107137 ** (2) the EP_xxx flags that indicate what the structure size should be.
107145 ** of this routine with 0xfff. The flags can be found by masking the
107148 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
107158 static int dupedExprStructSize(const Expr *p, int flags){
107160 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
107163 if( 0==flags || p->op==TK_SELECT_COLUMN
107188 static int dupedExprNodeSize(const Expr *p, int flags){
107189 int nByte = dupedExprStructSize(p, flags) & 0xfff;
107199 ** mask containing EXPRDUP_XXX flags.
107209 static int dupedExprSize(const Expr *p, int flags){
107212 nByte = dupedExprNodeSize(p, flags);
107213 if( flags&EXPRDUP_REDUCE ){
107214 nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
107274 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
107275 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
107276 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
107277 pNew->flags |= staticFlag;
107289 if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){
107405 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
107410 SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, const Expr *p, int flags){
107411 assert( flags==0 || flags==EXPRDUP_REDUCE );
107412 return p ? exprDup(db, p, flags, 0) : 0;
107414 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int flags){
107432 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
107444 pPriorSelectColNew = sqlite3ExprDup(db, pPriorSelectColOld, flags);
107466 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int flags){
107497 sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
107503 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
107508 pNewItem->u3.pOn = sqlite3ExprDup(db, pOldItem->u3.pOn, flags);
107532 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int flags){
107542 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
107543 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
107544 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
107545 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
107546 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
107547 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
107551 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
107581 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *p, int flags){
107864 ** Return the bitwise-OR of all Expr.flags fields in the given
107874 m |= pExpr->flags;
108267 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
108270 if( p->flags & EP_IntValue ){
109506 if( pExpr->flags & EP_IntValue ){
110202 tempX.flags = EP_IntValue|EP_TokenOnly;
110863 u8 flags /* SQLITE_ECEL_* flags */
110867 u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy;
110873 if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
110882 if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){
110883 if( flags & SQLITE_ECEL_OMITREF ){
110889 }else if( (flags & SQLITE_ECEL_FACTOR)!=0
110970 ** for clarity, but we are out of bits in the Expr.flags field so we
110972 pDel->flags |= EP_OuterON;
111412 combinedFlags = pA->flags | pB->flags;
111414 if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
111463 if( (pA->flags & (EP_Distinct|EP_Commuted))
111464 != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2;
112178 if( pExpr->flags & EP_Distinct ){
112699 if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){
113157 ** here as the original will be expanded and resolved (flags SF_Expanded
114050 int isLegacy = (db->flags & SQLITE_LegacyAlter);
114073 if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys))
114165 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
114320 int isLegacy = (db->flags & SQLITE_LegacyAlter);
114334 int flags = db->flags;
114335 if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL);
114337 db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL));
116074 Index *pIndex /* Handle extra flags for this index, if not NULL */
116616 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
116632 unsigned int flags;
116703 flags = db->openFlags;
116704 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
116712 flags |= SQLITE_OPEN_MAIN_DB;
116713 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
116738 PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
117892 u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */
117924 if( flags & LOCATE_NOERR ) return 0;
117931 const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
117955 u32 flags,
117966 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
118494 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
118495 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118497 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118499 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
118501 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
118828 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
119235 x.flags = EP_Skip;
120898 if( (db->flags & SQLITE_Defensive)!=0
121041 ** of tables in the parent pTo table. flags contains all
121056 int flags /* Conflict resolution algorithms. */
121146 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
121147 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
122569 ** JT_LTORJ flags */
122667 static const int flags =
122674 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
123786 ((pParse->db->flags & SQLITE_TrustedSchema)!=0)
124136 if( (db->flags & SQLITE_CountRows)!=0
126069 int flags; /* 1: trimleft 2: trimright 3: trim */
126111 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
126112 if( flags & 1 ){
126124 if( flags & 2 ){
126236 if( (db->flags & SQLITE_LoadExtFunc)==0 ){
126419 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
126420 }else if( pBest->flags ){
126448 if( pRes->flags ){
126665 int flags;
126668 flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
126671 flags = SQLITE_FUNC_LIKE;
126675 sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags;
126676 sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags;
127462 && !(pParse->db->flags & SQLITE_DeferFKs)
127564 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
127861 if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){
127875 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
127895 if( (db->flags & SQLITE_DeferFKs)==0 ){
128029 if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
128149 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs)
128219 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
128272 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
128344 if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){
128541 if( pParse->db->flags&SQLITE_ForeignKeys ){
128861 /* This walker callback will compute the union of colFlags flags for all
129639 if( (db->flags & SQLITE_CountRows)!=0
129948 if( db->flags & SQLITE_ForeignKeys ){
130436 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
130586 if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){
130592 if( db->flags&SQLITE_RecTriggers ){
130873 && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */
130875 && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */
131589 if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){
131593 if( (db->flags & SQLITE_CountRows)!=0 ){
131835 && db->flags&SQLITE_NullCallback)) ){
133207 if( (db->flags & SQLITE_LoadExtension)==0 ){
133354 db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
133356 db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
133621 /* Property flags associated with various pragma. */
133669 /* 32 */ "flags",
134447 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
134464 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
134962 if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){
135021 ** incr-vacuum flags. This is required in case this connection
135129 (db->flags & SQLITE_CacheSpill)==0 ? 0 :
135137 db->flags |= SQLITE_CacheSpill;
135139 db->flags &= ~(u64)SQLITE_CacheSpill;
135364 returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
135380 db->flags |= mask;
135382 db->flags &= ~mask;
136188 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
136426 if( iCookie==BTREE_SCHEMA_VERSION && (db->flags & SQLITE_Defensive)!=0 ){
137187 }else if( db->flags & SQLITE_WriteSchema ){
137217 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
137432 if( (db->flags & SQLITE_ResetDatabase)!=0 ){
137498 db->flags &= ~(u64)SQLITE_LegacyFileFmt;
137535 if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){
137578 ** bit is set in the flags field of the Db structure.
137824 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
137885 testcase( db->flags & SQLITE_ReadUncommit );
137969 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
138085 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
138093 ** SQLITE_PREPARE_* flags.
138113 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
138195 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
140350 fullName = (db->flags & SQLITE_FullColNames)!=0;
140351 srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
140590 savedFlags = db->flags;
140591 db->flags &= ~(u64)SQLITE_FullColNames;
140592 db->flags |= SQLITE_ShortColNames;
140594 db->flags = savedFlags;
140749 if( pTerm->flags & EP_Collate ){
141720 pNew->flags |= EP_IntValue;
142063 ifNullRow.flags = EP_IfNullRow;
142077 pExpr->flags & (EP_OuterON|EP_InnerON));
143564 if( a[i].pExpr->flags & EP_Collate ) break;
144060 if( (db->flags & SQLITE_EnableView)==0
144072 && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
144119 elistFlags |= pE->flags;
144129 int flags = pParse->db->flags;
144130 int longNames = (flags & SQLITE_FullColNames)!=0
144131 && (flags & SQLITE_ShortColNames)==0;
144135 elistFlags |= pE->flags;
145604 ** So set the ASC/DESC flags in the GROUP BY to match those in the
147140 if( (pParse->db->flags & SQLITE_EnableTrigger)==0
147677 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
148164 int flags; /* Flags for sqlite3WhereBegin() */
148505 if( (db->flags&SQLITE_CountRows)!=0
148573 flags = WHERE_ONEPASS_DESIRED;
148575 flags |= WHERE_ONEPASS_MULTIROW;
148577 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur);
149663 u64 saved_flags; /* Saved value of db->flags */
149674 u32 pgflags = PAGER_SYNCHRONOUS_OFF; /* sync flags for output db */
149697 /* Save the current value of the database flags so that it can be
149700 saved_flags = db->flags;
149705 db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
149707 db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder
149747 /* For a VACUUM INTO, the pager-flags are set to the same values as
149750 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
149902 /* Restore the original value of db->flags */
149905 db->flags = saved_flags;
151463 u32 wsFlags; /* WHERE_* flags describing the plan */
151577 u16 wtFlags; /* TERM_xxx bit flags. See below */
151727 unsigned char bldFlags1; /* First set of SQLITE_BLDF_* flags */
151728 unsigned char bldFlags2; /* Second set of SQLITE_BLDF_* flags */
152063 u32 flags; /* Flags that describe this loop */
152069 flags = pLoop->wsFlags;
152070 if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_OR_SUBCLAUSE) ) return 0;
152072 isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0
152073 || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0))
152079 if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){
152085 assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) );
152090 }else if( flags & WHERE_PARTIALIDX ){
152092 }else if( flags & WHERE_AUTO_INDEX ){
152094 }else if( flags & WHERE_IDX_ONLY ){
152104 }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
152114 if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){
152116 }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){
152119 }else if( flags&WHERE_BTM_LIMIT ){
152122 assert( flags&WHERE_TOP_LIMIT);
152128 else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
152768 if( pTerm->pExpr->flags & EP_xIsSelect ){
154814 pExpr->flags ^= EP_Commuted;
154899 if( op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
155160 pDerived->flags |= pBase->flags & (EP_OuterON|EP_InnerON);
156098 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
156099 || (pExpr->pRight->flags & EP_xIsSelect)==0)
157937 ** the current configuration of "unusable" flags in sqlite3_index_info can
159771 u8 jointype, /* The JT_* flags on the join */
159785 if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
159988 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
160065 /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */
162178 u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */
162424 if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
162776 if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return;
163038 if( db->flags & SQLITE_VdbeAddopTrace ){
163107 if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n");
163933 int f = pExpr->flags & EP_Collate;
163944 pExpr->flags = f;
164039 pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
164442 if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){
166393 p->flags = EP_Leaf;
170641 yymsp[-4].minor.yy528->flags |= pList->a[0].pExpr->flags & EP_Propagate;
170672 if( yymsp[-2].minor.yy528 ) yymsp[-2].minor.yy528->flags |= EP_InfixFunc;
170685 if( yymsp[-4].minor.yy528 ) yymsp[-4].minor.yy528->flags |= EP_InfixFunc;
172753 if( db->flags & SQLITE_ParserTrace ){
174368 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
174394 u64 oldFlags = db->flags;
174396 db->flags |= aFlagOp[i].mask;
174398 db->flags &= ~(u64)aFlagOp[i].mask;
174400 if( oldFlags!=db->flags ){
174404 *pRes = (db->flags & aFlagOp[i].mask)!=0;
174893 db->flags &= ~(u64)(SQLITE_DeferFKs|SQLITE_CorruptRdOnly);
176320 ** the default flags to open the database handle with. The value stored in
176340 unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
176346 unsigned int flags = *pFlags;
176354 if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */
176366 flags |= SQLITE_OPEN_URI;
176468 ** correspond to flags that may be passed to the sqlite3_open_v2()
176511 limit = mask & flags;
176536 flags = (flags & ~mask) | mode;
176552 flags &= ~SQLITE_OPEN_URI;
176565 *pFlags = flags;
176630 unsigned int flags, /* Operational flags */
176651 }else if( flags & SQLITE_OPEN_NOMUTEX ){
176653 }else if( flags & SQLITE_OPEN_FULLMUTEX ){
176659 if( flags & SQLITE_OPEN_PRIVATECACHE ){
176660 flags &= ~SQLITE_OPEN_SHAREDCACHE;
176662 flags |= SQLITE_OPEN_SHAREDCACHE;
176665 /* Remove harmful bits from the flags parameter
176667 ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
176669 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
176672 ** bits. Silently mask off all other flags.
176674 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
176707 db->errMask = (flags & SQLITE_OPEN_EXRESCODE)!=0 ? 0xffffffff : 0xff;
176730 db->flags |= SQLITE_ShortColNames
176825 flags |= SQLITE_OPEN_URI;
176828 flags |= SQLITE_OPEN_URI;
176835 ** Only allow sensible combinations of bits in the flags argument.
176845 db->openFlags = flags;
176849 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
176850 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
176851 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
176852 if( ((1<<(flags&7)) & 0x46)==0 ){
176855 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
176872 flags | SQLITE_OPEN_MAIN_DB);
177000 int flags, /* Flags */
177003 return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
179826 int flags;
181232 ** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this
181234 ** support index-info flags. In that case this function is a no-op.
182819 filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS
186176 pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
186177 if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
192773 int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
192774 int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
192775 int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
192776 int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
192777 int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
192778 int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
193167 filter.flags = FTS3_SEGMENT_REQUIRE_POS;
193168 filter.flags |= (bIgnoreEmpty ? FTS3_SEGMENT_IGNORE_EMPTY : 0);
194889 pFilter->flags = FTS3_SEGMENT_REQUIRE_POS;
194898 pFilter->flags |= FTS3_SEGMENT_IGNORE_EMPTY;
195109 filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
195110 filter.flags |= FTS3_SEGMENT_SCAN;
198111 ** If the least significant bit in flags is clear, then the rule applies
198116 ** The 7 most significant bits in flags are an index into the aiOff[]
198118 ** case equivalent is ((C + aiOff[flags>>1]) & 0xFFFF).
198126 unsigned char flags;
198224 if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
198225 ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
198357 u8 jnFlags; /* JNODE flags */
199751 ** Bit values for the flags passed into jsonExtractFunc() or
199787 int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
199797 if( flags & JSON_ABPATH ){
199823 if( flags & JSON_JSON ){
209062 ** it points to an array of flags nTblCol elements in size. The flag is
209079 u8 *abTblPk; /* Array of flags, set on target PK columns */
209080 u8 *abNotNull; /* Array of flags, set on NOT NULL columns */
209081 u8 *abIndexed; /* Array of flags, set on indexed & PK cols */
209248 ** If this is a temporary file (pRbu!=0 && flags&DELETE_ON_CLOSE), variable
211469 const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI;
211470 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
213565 static int rbuVfsSync(sqlite3_file *pFile, int flags){
213573 return p->pReal->pMethods->xSync(p->pReal, flags);
213700 ** Return the device characteristic flags supported by an rbuVfs-file.
213710 static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
213734 if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
213735 rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
213837 int flags,
213865 int oflags = flags;
213870 pFd->openFlags = flags;
213872 if( flags & SQLITE_OPEN_MAIN_DB ){
213880 else if( flags & SQLITE_OPEN_WAL ){
213918 if( flags & SQLITE_OPEN_MAIN_DB ){
213943 int flags,
213950 rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
213966 if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
214293 u8 flags; /* Copy of flags byte */
214554 u8 flags, /* Page flags */
214561 if( flags==0x0D ){ /* Table leaf node */
214587 p->flags = aHdr[0];
214588 if( p->flags==0x0A || p->flags==0x0D ){
214591 }else if( p->flags==0x05 || p->flags==0x02 ){
214636 if( p->flags==0x05 ){
214642 if( p->flags==0x0D ){
214647 nLocal = getLocalPayload(nUsable, p->flags, nPayload);
214683 p->flags = 0;
214871 switch( p->flags ){
215410 if( pTab->db->flags & SQLITE_Defensive ){
215641 u8 *abPK; /* Array of primary key flags */
218376 int flags
218378 int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
218396 int flags
218398 int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
218524 u8 *abPK, /* Array of primary key flags, or NULL */
218593 ** + array of PK flags (1 byte per column),
218676 ** + array of PK flags (1 byte per column),
219713 u8 *abPK, /* Primary key flags array */
220177 int flags /* SESSION_APPLY_XXX flags */
220191 sApply.bInvertConstraints = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
220193 if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
220331 if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
220376 int flags
220379 int bInv = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
220383 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
220434 int flags
220437 int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
220441 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
221859 int flags, /* Mask of FTS5_TOKENIZE_* flags */
221863 int tflags, /* Mask of FTS5_TOKEN_* flags */
222172 int flags, /* FTS5_TOKENIZE_* flags */
222303 ** Values used as part of the flags argument passed to IndexQuery().
222311 ** defined here only to make it easier to avoid clashes with the flags
222352 int flags, /* Mask of FTS5INDEX_QUERY_X flags */
224433 int tflags, /* Mask of FTS5_TOKEN_* flags */
224569 int tflags, /* Mask of FTS5_TOKEN_* flags */
224672 unsigned char *aSeen; /* Array of "seen instance" flags */
226124 int flags, /* FTS5_TOKENIZE_* flags */
226131 pConfig->pTok, pCtx, flags, pText, nText, xToken
228034 int tflags, /* Mask of FTS5_TOKEN_* flags */
228155 int flags = FTS5_TOKENIZE_QUERY | (bPrefix ? FTS5_TOKENIZE_PREFIX : 0);
228159 rc = sqlite3Fts5Tokenize(pConfig, flags, z, n, &sCtx, fts5ParseTokenize);
229285 int tflags, /* Mask of FTS5_TOKEN_* flags */
230411 ** flags:
230435 int flags; /* Mask of configuration flags */
231742 if( pIter->flags & FTS5_SEGITER_REVERSE ){
231862 assert( pIter->flags & FTS5_SEGITER_REVERSE );
231863 assert( pIter->flags & FTS5_SEGITER_ONETERM );
231932 assert( pIter->flags & FTS5_SEGITER_REVERSE );
231969 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
231989 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
232075 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
232076 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
232130 if( pIter->flags & FTS5_SEGITER_ONETERM ){
232255 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
232258 assert( pIter->flags & FTS5_SEGITER_ONETERM );
232435 int flags, /* Mask of FTS5INDEX_XXX flags */
232440 int bGe = (flags & FTS5INDEX_QUERY_SCAN);
232444 assert( bGe==0 || (flags & FTS5INDEX_QUERY_DESC)==0 );
232476 pIter->flags |= FTS5_SEGITER_ONETERM;
232478 if( flags & FTS5INDEX_QUERY_DESC ){
232479 pIter->flags |= FTS5_SEGITER_REVERSE;
232484 if( flags & FTS5INDEX_QUERY_DESC ){
232518 int flags, /* Mask of FTS5INDEX_XXX flags */
232529 if( pTerm==0 || (flags & FTS5INDEX_QUERY_SCAN) ){
232550 pIter->flags |= FTS5_SEGITER_ONETERM;
232560 if( flags & FTS5INDEX_QUERY_DESC ){
232561 pIter->flags |= FTS5_SEGITER_REVERSE;
232775 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
232780 assert( pIter->flags & FTS5_SEGITER_ONETERM );
233140 if( (pSeg->flags & FTS5_SEGITER_REVERSE)==0 ){
233454 int flags, /* FTS5INDEX_QUERY_XXX flags */
233484 pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
233485 pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
233487 if( (flags & FTS5INDEX_QUERY_NOOUTPUT)==0 ){
233498 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
233507 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
233568 pIter->flags = FTS5_SEGITER_ONETERM;
233576 pIter->flags |= FTS5_SEGITER_REVERSE;
234309 const int flags = FTS5INDEX_QUERY_NOOUTPUT;
234355 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
235235 const int flags = FTS5INDEX_QUERY_SCAN
235267 fts5MultiIterNew(p, pStruct, flags, pColset, pToken, nToken, -1, 0, &p1);
235561 int flags, /* Mask of FTS5INDEX_QUERY_X flags */
235569 /* If the QUERY_SCAN flag is set, all other flags must be clear. */
235570 assert( (flags & FTS5INDEX_QUERY_SCAN)==0 || flags==FTS5INDEX_QUERY_SCAN );
235588 if( pConfig->bPrefixIndex==0 || (flags & FTS5INDEX_QUERY_TEST_NOIDX) ){
235589 assert( flags & FTS5INDEX_QUERY_PREFIX );
235593 if( flags & FTS5INDEX_QUERY_PREFIX ){
235607 fts5MultiIterNew(p, pStruct, flags | FTS5INDEX_QUERY_SKIPEMPTY,
235614 int bDesc = (flags & FTS5INDEX_QUERY_DESC)!=0;
235864 int flags, /* Flags for Fts5IndexQuery */
235870 int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
235950 int flags = (iIdx==0 ? 0 : FTS5INDEX_QUERY_PREFIX);
235956 rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, flags, &ck1);
235958 int f = flags|FTS5INDEX_QUERY_DESC;
235978 int f = flags|FTS5INDEX_QUERY_TEST_NOIDX;
235984 int f = flags|FTS5INDEX_QUERY_TEST_NOIDX|FTS5INDEX_QUERY_DESC;
236244 const int flags = FTS5INDEX_QUERY_NOOUTPUT;
236274 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
237009 int csrflags; /* Mask of cursor flags (see below) */
237061 ** Macros to Set(), Clear() and Test() cursor flags.
237282 ** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this
237284 ** support index-info flags. In that case this function is a no-op.
237332 ** flags used to encode the ORDER BY clause:
237478 /* Set idxFlags flags for the ORDER BY clause */
237494 /* Calculate the estimated cost based on the flags set in idxFlags. */
242171 int flags,
242181 p->pTokenizer, (void*)&sCtx, flags, pText, nText, fts5PorterCb
242462 ** If the least significant bit in flags is clear, then the rule applies
242467 ** The 7 most significant bits in flags are an index into the aiOff[]
242469 ** case equivalent is ((C + aiOff[flags>>1]) & 0xFFFF).
242477 unsigned char flags;
242575 if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
242576 ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
246109 u64 flagsBackup = db->flags;
246115 db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
246116 db->flags &= ~(SQLITE_ForeignKeys | SQLITE_ReverseOrder);
246203 db->flags = flagsBackup;