Lines Matching defs:flag
554 ** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with
895 ** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into
952 ** flag indicates that a file cannot be deleted when open. The
953 ** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on
1002 ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
1004 ** information need not be flushed. If the lower four bits of the flag
1060 ** flag may be ORed in to indicate that only the data of the file
1698 ** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
1703 ** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
1704 ** with the [SQLITE_OPEN_CREATE] flag, which are both directly
1706 ** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
1727 ** flag is never actually used and is not implemented in the built-in
1852 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
2310 ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
2312 ** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
2621 ** option is used to set or clear (the default) a flag that governs this
2631 ** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run
2652 ** "defensive" flag for a database connection. When the defensive
2653 ** flag is enabled, language features that allow ordinary SQL to
2667 ** "writable_schema" flag. This has the same effect and is logically equivalent
2727 ** the legacy file format flag. When activated, this flag causes all newly
3730 ** three flag combinations:)^
3753 ** <dd>The filename can be interpreted as a URI if this flag is set.</dd>)^
3792 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
3806 ** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op
3809 ** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not
3833 ** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
3875 ** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
3893 ** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
4379 ** <dd>The SQLITE_PREPARE_PERSISTENT flag is a hint to the query planner
4381 ** probably reused many times.)^ ^Without this flag, [sqlite3_prepare_v3()]
4390 ** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
4395 ** flag.
4398 ** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler
5573 ** of the [SQLITE_DETERMINISTIC] flag is recommended where possible.
5576 ** flag, which if present prevents the function from being invoked from
5580 ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for
5585 ** Without this flag, an attacker might be able to modify the schema of
5709 ** The SQLITE_DETERMINISTIC flag means that the new function always gives
5720 ** The SQLITE_DIRECTONLY flag means that the function may only be invoked
5731 ** The SQLITE_INNOCUOUS flag means that the function is unlikely
5748 ** SQLITE_INNOCUOUS flag for application-defined functions unless the
5754 ** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
5756 ** Specifying this flag makes no difference for scalar or aggregate user
7020 ** with the [SQLITE_OPEN_SHAREDCACHE] flag.
7480 ** aConstraintUsage[].omit flag is an optimization hint. When the omit flag
7482 ** checked separately in byte code. If the omit flag is change to true, then
7484 ** when the omit flag is true there is no guarantee that the constraint will
7506 ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
7507 ** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite
7510 ** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then
8038 ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
8041 ** with the makeDflt flag set. If two different VFSes with the
8260 ** with the SQLITE_DEBUG flag. External mutex implementations
9084 ** false will always have the "discard" flag set to true.
9903 ** flag unless absolutely necessary.
10018 ** the "orderByConsumed" flag.
10026 ** the xBestIndex method to set the "orderByConsumed" flag, regardless of
10061 ** specified above, then it must not set the "orderByConsumed" flag in the
10065 ** it wants, as long as the "orderByConsumed" flag is not set. ^When the
10066 ** the "orderByConsumed" flag is unset, the query planner will add extra
10068 ** ordered correctly. The use of the "orderByConsumed" flag and the
10071 ** flag might help queries against a virtual table to run faster. Being
10072 ** overly aggressive and setting the "orderByConsumed" flag when it is not
10822 ** free it when it has finished using it. Without this flag, the caller
10825 ** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to
10827 ** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used.
10828 ** Without this flag, the deserialized database cannot increase in size beyond
10831 ** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database
11065 ** This option is used to set, clear or query the flag that enables
11112 ** <li> The session object "indirect" flag is set when the change is
11123 ** flag. If the second argument passed to this function is zero, then the
11124 ** indirect flag is cleared. If it is greater than zero, the indirect flag
11126 ** of the indirect flag, and may be used to query the current state of the
11127 ** indirect flag for the specified session object.
11129 ** The return value indicates the final state of the indirect flag: 0 if
11530 ** It is an error to specify this flag with a patchset.
12206 ** applied, or rolled back if an error occurs. Specifying this flag
12214 ** an error to specify this flag with a patchset.
13153 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
15566 ** the database file header. The incr-vacuum-flag field is located at
15618 ** The BTREE_BULKLOAD flag is set on index cursors when the index is going
15621 ** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or
15643 ** The BTREE_FORDELETE flag is an optimization hint. It is not used by
15648 ** the FORDELETE flag hint allows those alternative storage engines to
16839 ** The DB_SchemaLoaded flag is set after the database schema has been
16873 ** schema information, the Lookaside.bEnabled flag is cleared so that
16878 ** disables lookaside without adding a new test for the bDisable flag
17029 u8 autoCommit; /* The auto-commit flag. */
17403 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
17406 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
17409 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
17410 ** adds the SQLITE_DIRECTONLY flag.
17425 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
17426 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
17679 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
18310 ** TK_FUNCTION: NC_SelfRef flag if needs OP_PureFunc */
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
18453 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
18454 ** and an Expr struct with the EP_TokenOnly flag set.
19187 u8 explain; /* True if the EXPLAIN flag is found on the query */
19640 u8 eM10d; /* The MATERIALIZED flag */
19644 ** Allowed values for the materialized flag (eM10d):
19678 u8 eM10d; /* The MATERIALIZED flag */
19745 ** due to the SQLITE_SUBTYPE flag */
22653 ** UPDATE no-change flag set
22664 ** MEM_Term is set. This flag is
22682 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
22686 ** If the MEM_Str flag is set then Mem.z points at a string representation.
22688 ** database (see below for exceptions). If the MEM_Term flag is also
22690 ** flags may coexist with the MEM_Str flag.
29633 ** the mallocFailed flag in the connection pointer.
29659 ** If the allocation fails, set the mallocFailed flag in
29740 ** resize fails, set the mallocFailed flag in the connection object.
29786 ** and set the mallocFailed flag in the database connection.
29887 ** db->mallocFailed flag as necessary.
30163 etByte flag_leftjustify; /* True if "-" flag is present */
30165 etByte flag_alternateform; /* True if "#" flag is present */
30166 etByte flag_altform2; /* True if "!" flag is present */
30168 etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */
30169 etByte done; /* Loop termination flag */
30616 /* Special case: Add leading zeros if the flag_zeropad flag is
30847 ** at this point. If the "!" flag was present on string conversions
31355 ** Add a new subitem to the tree. The moreToFollow flag indicates that this
31981 /* COLLATE operators without the EP_Collate flag are intended to
33688 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
34524 ** A = 0xxxxxxx 7 bits of data and one flag bit
34525 ** B = 1xxxxxxx 7 bits of data and one flag bit
35217 ** db->mallocFailed flag is set.
40443 ** SQLite sets the dataOnly flag if the size of the file is unchanged.
40454 ** the value of the dataOnly flag.
40483 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
40615 /* Also fsync the directory containing the file if the DIRSYNC flag
41000 /* Set the POWERSAFE_OVERWRITE flag if requested. */
42980 ** interface, add the DELETEONCLOSE flag to those specified above for
47368 /* Set a flag that indicates we're the first to create the memory so it
48113 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
52646 ** clear PGHDR_NEED_SYNC flag or to a page that is older than this one
52843 /* If pSynced is NULL and this page has a clear NEED_SYNC flag, set
52844 ** pSynced to point to it. Checking the NEED_SYNC flag is an
52846 ** flag set sqlite3PcacheFetchStress() searches through all newer
53056 ** flag is currently referenced, then the following may leave pSynced
53234 ** Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages.
53246 ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
53711 ** flag (bPurgeable) and the pnPurgeable pointer are all set when the
54999 ** In an OOM situation, the RowSet.db->mallocFailed flag is set and this
55024 ** The mallocFailed flag of the database connection is set if a
55448 sqlite3 *db, /* Check this handle's interrupt flag */
55940 ** Bits of the Pager.doNotSpill flag. See further description below.
55980 ** The changeCountDone flag is inspected. If it is true, the work of
56007 ** The flag is cleared as soon as the journal file is finalized (either
56009 ** journal file from being successfully finalized, the setSuper flag
56028 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
56368 ** the change-counter field, so the changeCountDone flag is always set.
56373 /* If the useJournal flag is clear, the journal-mode must be "OFF".
56990 ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
57791 /* The jrnlEnc flag is true if Journal pages should be passed through
58472 ** in case this has happened, clear the changeCountDone flag now.
59757 ** If the Pager.noSync flag is set, then this function is a no-op.
59783 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
59889 ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
59919 ** * The PGHDR_DONT_WRITE flag is set on the page.
59969 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
60915 ** flush the cache. The hasHeldSharedLock flag prevents this from
61171 ** flag was specified by the caller. And so long as the db is not a
61515 ** page in the block above, set the need-sync flag for the page.
61705 /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
61808 ** But this only happens if the pPager->changeCountDone flag is false.
61813 ** If the isDirectMode flag is zero, then this is done by calling
61818 ** The isDirectMode flag may only be non-zero if the library was compiled
61902 ** or pages with the Pager.noSync flag set.
62011 /* Must have at least one page for the WAL commit flag.
62748 ** If the isCommit flag is set, there is no need to remember that
62760 ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
62799 ** "is journaled" bitvec flag has been set. This needs to be remedied by
62801 ** flag.
65605 sqlite3 *db, /* For interrupt flag */
66901 int nTruncate, /* The commit flag. Usually 0. >0 for commit */
67082 int nDbSize; /* 0 normally. Positive == commit flag */
67227 sqlite3 *db, /* Check this handle's interrupt flag */
67702 ** The flags define the format of this btree page. The leaf flag means that
67703 ** this page has no children. The zerodata flag means that this page carries
67704 ** only keys and no data. The intkey flag means that the key is an integer
67758 ** 4 Page number of the left child. Omitted if leaf flag is set.
67759 ** var Number of bytes of data. Omitted if the zerodata flag is set.
67760 ** var Number of bytes of key. Or the key itself if intkey flag is set.
68808 ** and has the read-uncommitted flag set, then no lock is required.
68878 ** read-uncommitted flag set, then it is OK for the other object to
68969 ** database (one with the BtShared.sharable flag set), and
68987 /* A connection with the read-uncommitted flag set will never try to
69039 ** transaction. If it does not, then the BTS_PENDING flag
69074 ** set the BTS_PENDING flag to 0.
69241 ** page from the pager layer with the 'no-content' flag set. True otherwise.
69364 ** cursors should have their BTCF_Multiple flag set. The btreeCursor()
69366 ** the uncommon case when pExpect has the BTCF_Multiple flag set.
69369 ** then the BTCF_Multiple flag on pExpect is cleared, to avoid another
69571 ** Provide flag hints to the cursor.
70739 /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
70832 ** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care
70985 ** * Make sure the isInit flag is clear
71604 ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
72099 ** exclusivity flag only works for a new transaction.
72411 ** The isCommit flag indicates that there is no need to remember that
72422 int isCommit /* isCommit flag passed to sqlite3PagerMovepage */
72920 ** references. Or if the writeOnly flag is set to 1, then only
72928 ** flag is true, then only write-cursors need be tripped - read-only
72936 ** If the writeOnly flag is true and an error is encountered while
73150 ** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE
73209 ** cursors *must* have the BTCF_Multiple flag set. */
75125 ** pager layer with the 'no-content' flag set. This prevents the pager
75130 ** not set the no-content flag. This causes the pager to load and journal
77664 ** Which can only happen if the SQLITE_NoSchemaError flag was set when
77666 ** set the flag, load the schema, and then unset the flag. */
77938 ** calling sqlite3BtreeInsert() with the BTREE_PREFORMAT flag specified.
78052 ** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag.
80040 ** Then clear the Btree layer MemPage.isInit flag. Both this module
80606 /* This is a pointer type. There may be a flag to indicate what to
80791 /* If the bPreserve flag is set to true, then the memory cell must already
81739 ** also sets a flag in local variable "flags" to indicate the memory
81989 ** * the SQLITE_FUNC_NEEDCOLL function flag is not set,
82973 ** If the bPush flag is true, then make this opcode the parent for
83694 ** into register iDest, then add the OPFLAG_TYPEOFARG flag to that
85479 ** flag is set this is not required.
85764 /* If the auto-commit flag is set and this is the only active writer
85786 /* The auto-commit flag is true, the vdbe program was successful
85873 /* If the auto-commit flag is set to true, then any locks that were held
86477 ** UPDATE no-change flag set */
87061 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
87630 ** Set a flag in the vdbe to update the change counter when it is finalised
87651 ** Internally, this function just sets the Vdbe.expired flag on all
87652 ** prepared statements. The flag is set to 1 for an immediate expiration
88532 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
89085 ** malloc() has failed, the threads mallocFailed flag is cleared and the result
89231 ** is the case, clear the mallocFailed flag and return NULL.
90431 ** generated the VDBE instruction combined with flag bits. The source
90473 ** measurement logic does not flag those impossible cases
90489 ** An ephemeral string value (signified by the MEM_Ephem flag) contains
90602 ** If the bTryForInt flag is true, then extra effort is made to give
91679 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
91819 ** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the
92417 ** the SQLITE_NULLEQ flag were omitted from P5.
94163 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
94238 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
94239 ** true (this flag is set if the Vdbe may modify more than one row and may
94741 ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
94897 ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
94964 ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
95008 /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
95209 ** The This.P5 parameter is a flag that indicates what to do if the
95456 ** A value of N in the seekHit flag of cursor P1 means that there exists
95869 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
95870 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
95874 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
95876 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
95879 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
95880 ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
95901 int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */
95989 ** with the OPFLAG_PREFORMAT flag set to complete the insert operation.
96023 ** marked with the AUXDELETE flag.
96025 ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
96036 ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
96038 ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
96657 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
96659 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
97480 /* If the p5 flag is clear, then recursive invocation of triggers is
97482 ** is really a trigger, not a foreign key action, and the flag set
98640 ** P1 is a boolean flag. If it is set to true and the xUpdate call
99247 ** flag.
101483 /* Set the flag to indicate that at least one PMA has been written.
101793 ** Set the "use-threads" flag on object pIncr.
104726 /* For the purposes of the EP_ConstFunc flag, date and time
105603 ** checking on function usage and set a flag if any aggregate functions
105640 ** If the function is an aggregate function, then the NC_HasAgg flag is
105763 ** "type" flag
106179 ** However, if the OP_Commuted flag is set, then the order of the operands
106643 ** then the EP_DblQuoted flag is set on the expression node.
106648 ** into u.iValue and the EP_IntValue flag is set. No extra storage
106649 ** is allocated to hold the integer text and the dequote flag is ignored.
107160 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
107204 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
107335 ** and the db->mallocFailed flag set.
107406 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
107771 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
107806 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
108005 ** SQLITE_FUNC_CONST flag. */
108266 ** integer, then the EP_IntValue flag will have already been set */
108500 ** ephmeral table might be put inside of a subroutine, the EP_Subrtn flag
109725 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
110846 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
110852 ** The SQLITE_ECEL_REF flag means that expressions in the list with
110901 && pOp->p5==0 /* The do-not-merge flag must be clear */
110997 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
118673 ** flag is true if the table should be stored in the auxiliary database
118909 ** The trigger has the Trigger.bReturning flag and an opcode of
119077 ** been seen on a column. This routine sets the notNull flag on
119089 /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
119989 ** any shadow tables seen using the TF_Shadow flag.
120458 ** on a view, even though views do not have rowids. The following flag
122767 ** Technically, we only need to set the mayAbort flag if the
122768 ** isMultiWrite flag was previously set. There is a time dependency
123050 u8 eM10d /* The MATERIALIZED flag */
123533 ** Locate a user function given a name, a number of arguments and a flag
123548 ** number of arguments may be returned even if the eTextRep flag does not
123582 ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in
126234 ** flag is set. See the sqlite3_enable_load_extension() API.
127305 ** pParse->db->mallocFailed flag is set.
127891 ** If the SQLITE_DeferFKs flag is set, then this is not required, as
128183 ** So do not set the "may-abort" flag in this case.
128186 ** may-abort flag will eventually be set on this statement anyway
129952 /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
129955 ** flag in the second case as if any REPLACE constraint is hit, an
129998 ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
130688 ** recursive-triggers flag is set, call GenerateRowDelete() to
130693 ** flag is not set, but the table has one or more indexes, call
131163 int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
131167 u8 pik_flags; /* flag values passed to the btree insert */
131622 ** DBFLAG_Vacuum flag is set, this block generates code to make
134830 ** secure_delete flag. The second form changes the secure_delete
134831 ** flag setting and reports the new value.
135194 ** Return or set the local value of the temp_store flag. Changing
135214 ** Return or set the local value of the temp_store_directory flag. Changing
135258 ** Return or set the local value of the data_store_directory flag. Changing
135300 ** Return or set the value of the lock_proxy_file flag. Changing
135336 ** Return or set the local value of the synchronous flag. Changing
135394 /* Many of the flag-pragmas modify the code generated by the SQL
136818 ** PragFlg_NoColumns1 flag is set and the caller specified an argument
137493 ** clear the legacy_file_format pragma flag so that a VACUUM will
137536 /* Hack: If the SQLITE_NoSchemaError flag is set, then consider
137754 ** pParse->earlyCleanup flag is set in that case. Calling code show verify
139221 ** The ExprList_item.fg.bSorterRef flag is set for each expression in pEList
140777 ** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
141430 ** records the previous output. mem[regPrev] is a flag that is false
141981 ** has the nullRow flag set, because the expression is an integer constant,
141983 ** that checks to see if the nullRow flag is set on the table. If the nullRow
141984 ** flag is set, then the value in the register is set to NULL and the original
141985 ** expression is bypassed. If the nullRow flag is not set, then the original
142606 /* Without this restriction, the JT_LTORJ flag would end up being
143142 ** type conversions to occur. See logic associated with the bHasAffBlob flag
144975 /* If the SF_UFSrcCheck flag is set, then this function is being called
144994 /* Clear the SF_UFSrcCheck flag. The check has already been performed,
144995 ** and leaving this flag set can cause errors if a compound sub-query
145409 ** original setting of the SF_Distinct flag, not the current setting */
145566 int iUseFlag; /* Mem address holding flag indicating that at least
145715 int addrSetAbort; /* Set the abort flag and return */
145762 VdbeComment((v, "clear abort flag"));
145845 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
145890 VdbeComment((v, "check abort flag"));
145932 VdbeComment((v, "set abort flag"));
146022 int regAcc = 0; /* "populate accumulators" flag */
147687 ** not a foreign key action, and (b) the flag to enable recursive triggers
149698 ** restored before returning. Then set the writable-schema flag, and
149914 ** by manually setting the autoCommit flag to true and detaching the
150580 ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
151059 ** SQLITE_FUNC_EPHEM flag.
151389 int regBignull; /* big-null flag reg. True if a NULL-scan is needed */
153314 VdbeComment((v, "init LEFT JOIN no-match flag"));
153661 int regBignull = 0; /* big-null flag register */
153708 /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses
154275 /* The pSubWInfo->untestedTerms flag means that this OR term
154426 /* If the TERM_LIKECOND flag is set, that means that the range search
154744 ** the db->mallocFailed flag so that higher-level functions can detect it.
156053 ** LIKE on all candidate expressions by clearing the isComplete flag
157235 pOp->p5 = 2; /* Cause the MEM_Subtype flag to be cleared */
157589 ** flag set, initialize a Bloomfilter for them as well. Except don't do
157593 ** When the Bloom filter is initialized, the WHERE_BLOOMFILTER flag is cleared
157745 ** Mark each term with the TERM_OK flag. Set nTerm to the number of
158657 /* The 0x10000 .wheretrace flag causes extra information to be
159617 ** higher selectivity, then set the flag to rerun the
160247 /* Set the usable flag on the subset of constraints identified by
160380 /* Set the WHERE_ONEROW flag if the xBestIndex() method indicated
160432 ** or clear (if bHandle==0) the flag to handle it using an iterator.
160843 ** The JT_LTORJ case and the hasRightJoin flag work together to
161231 ** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(),
161239 ** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then
161966 ** by the WHERE_SELFCULL flag on the term.)
161972 ** appropriate, and if so sets the WHERE_BLOOMFILTER flag on the
162144 ** flag = 0
162148 ** flag = 1
162150 ** if flag==0 then
162159 ** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement
162223 ** pTabList. But if the WHERE_OR_SUBCLAUSE flag is set, then we should
162304 ** WHERE_OR_SUBCLAUSE flag is set.
165259 /* If the BIGNULL flag is set for the ORDER BY, then it is required to
165263 ** instead if the BIGNULL flag is set then cases where either reg1 or
165327 ** control skips over this test if the BIGNULL flag is set and either
165554 ** flag and returns zero.
172869 /* If the pParse->declareVtab flag is set, do not delete any table
175241 ** is returned and the mallocFailed flag cleared.
175277 /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But
175896 /* If there are no active statements, clear the interrupt flag at this
176075 ** above. If this is the case, then the db->mallocFailed flag needs to
176364 /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
177726 ** Set or clear a flag that indicates that the database file is always well-
177727 ** formed and never corrupt. This flag is clear by default, indicating that
177728 ** database files might have arbitrary corruption. Setting the flag during
177739 ** Set or clear a flag that causes SQLite to verify that type, name,
178742 ** A = 0xxxxxxx 7 bits of data and one flag bit
178743 ** B = 1xxxxxxx 7 bits of data and one flag bit
181232 ** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this
181338 /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */
182881 ** this routine simply sets the EOF flag.
184127 u8 *pbEof /* OUT: End-of-file flag */
184182 u8 *pbEof /* OUT: End-of-file flag */
184340 ** one incremental token. In which case the bIncr flag is set. */
185315 ** by Fts3Cursor.iMinDocid/iMaxDocid. If so, set the EOF flag. */
187930 ** flag is set. NULL is returned.
189226 char delim[128]; /* flag ASCII delimiters */
195801 char flag;
196578 assert( p->flag==FTS3_MATCHINFO_LHITS_BM || p->flag==FTS3_MATCHINFO_LHITS );
196579 if( p->flag==FTS3_MATCHINFO_LHITS ){
196588 if( p->flag==FTS3_MATCHINFO_LHITS ){
196836 ** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag.
196946 pInfo->flag = zArg[i];
199497 int *pApnd, /* Set this flag to 1 */
199769 ** then always return an SQL representation of the result. If neither flag
201167 ** Set the Rtree.bCorrupt flag
208547 ** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget
209062 ** it points to an array of flags nTblCol elements in size. The flag is
212814 ** flag it set, this means that the db was not opened because it seemed
214447 ** If this will satisfy the client, set the orderByConsumed flag so that
215705 ** 1 byte: The "indirect-change" flag.
215747 ** 1 byte: The "indirect-change" flag.
220063 /* If the bRetry flag is set, the change has not been applied due to an
220075 /* If the bReplace flag is set, the change is an INSERT that has not
221814 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
227511 /* Set the EOF flag if either all synonym iterators are at EOF or an
227795 ** match. If there are no matches, set the Node.bEof flag to indicate EOF.
227943 ** Set the "bFirst" flag on the first token of the phrase passed as the
229511 u8 bDel; /* Set delete-flag @ iSzPoslist */
229512 u8 bContent; /* Set content-flag (detail=none mode) */
229823 /* This is a delete. Set the delete flag. */
230135 ** this field. Plus 1 if this entry carries the "delete" flag.
230233 #define FTS5_DATA_DLI_B 1 /* Doclist-index flag (1 bit) */
230419 ** This flag is only ever set if FTS5_SEGITER_ONETERM is also set. If
230424 ** These are used if the FTS5_SEGITER_REVERSE flag is set.
230452 /* The following are only used if the FTS5_SEGITER_REVERSE flag is set. */
230463 u8 bDel; /* True if the delete flag is set */
231623 ** list, and *pbDel to true if the delete flag is set, or false otherwise.
231795 ** Fts5IndexQuery() with the FTS5INDEX_QUERY_DESC flag set.
232497 ** 4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points
235569 /* If the QUERY_SCAN flag is set, all other flags must be clear. */
235582 ** If the QUERY_TEST_NOIDX flag was specified, then this must be a
236330 int *pbDlidx, /* OUT: Dlidx flag */
237063 #define CsrFlagSet(pCsr, flag) ((pCsr)->csrflags |= (flag))
237064 #define CsrFlagClear(pCsr, flag) ((pCsr)->csrflags &= ~(flag))
237065 #define CsrFlagTest(pCsr, flag) ((pCsr)->csrflags & (flag))
237282 ** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this
237668 ** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors
237683 ** If the REQUIRE_RESEEK flag is set on the cursor passed as the first
238147 ** sqlite3_index_constraint.omit flag clear for range constraints
238277 ** If the cursor requires seeking (bSeekRequired flag is set), seek it.
240239 ** argument bCache is true, set the p->bTotalsValid flag to indicate
243384 ** A = 0xxxxxxx 7 bits of data and one flag bit
243385 ** B = 1xxxxxxx 7 bits of data and one flag bit
243774 ** sqlite3_index_info.orderByConsumed flag to tell the core the results