225 ** with a page-size of 65536 bytes crashes, then an instance of SQLite 
389 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
401 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
501 ** be true and false so that the unreachable code then specify will
551 ** or constant definition does not appear in this file, then it is
738 ** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
814 ** outstanding [prepared statements] or [BLOB handles], then it returns
848 ** sqlite3_exec() is not NULL, then it is invoked for each result row
852 ** is NULL, then no callback is ever invoked and result rows are
856 ** sqlite3_exec(), then execution of the current statement stops and
858 ** is not NULL then any error message is written into memory obtained
864 ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
875 ** result row is NULL then the corresponding string pointer for the
883 ** SQL comments, then no SQL statements are evaluated and the database
1038 ** first then the size of the file is extended, never the other
1113 ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
1179 ** first then the size of the file is extended, never the other
1304 ** If the zFilename parameter is xOpen is a NULL pointer then xOpen
1311 ** or [sqlite3_open16()] is used, then flags includes at least
1313 ** If xOpen() opens a file read-only then it sets *pOutFlags to
1537 ** compile-time option, then the automatic calls to sqlite3_initialize()
1589 ** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
1601 ** then this routine returns a non-zero [error code].
1690 ** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
1728 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1743 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1759 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1810 ** what is provided by this configuration option, then 
1828 ** page cache memory is needed beyond what is provided by this option, then
1841 ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
1845 ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
1857 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1870 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1984 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
1992 ** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted
2016 ** then the value returned by [sqlite3_last_insert_rowid()] is
2071 ** while [sqlite3_changes()] is running then the value returned
2097 ** while [sqlite3_total_changes()] is running then the value
2117 ** sqlite3_interrupt() is called, then it might not have an opportunity
2122 ** that is inside an explicit transaction, then the entire transaction
2137 ** is running then bad things will likely happen.
2157 ** memory allocation fails, then SQLITE_NOMEM is returned.
2163 ** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
2165 ** then the return value from sqlite3_complete16() will be non-zero
2184 ** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
2186 ** is not NULL, then the callback might be invoked with two arguments.
2192 ** busy callback returns 0, then no additional attempts are made to
2194 ** ^If the callback returns non-zero, then another attempt
2220 ** readers.  ^If it is unable to promote the lock, then the in-memory
2450 ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
2468 ** is a NULL pointer then its behavior is identical to calling
2471 ** negative then the behavior is exactly the same as calling
2475 ** ^If M is the size of the prior allocation, then min(N,M) bytes
2478 ** ^If sqlite3_realloc() returns NULL, then the prior allocation
2572 ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
2589 ** and the callback returns [SQLITE_IGNORE] then the
2596 ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
2606 ** database.  An authorizer could then be put in place while the
2768 ** object.)^ ^(If the database is opened (and/or created) successfully, then
2810 ** then the behavior is undefined.
2812 ** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
2815 ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
2824 ** ^If the filename is ":memory:", then a private, temporary in-memory database
2832 ** ^If the filename is an empty string, then a private, temporary
2839 ** a NULL pointer then the default [sqlite3_vfs] object is used.
2916 ** <li> Reset the statement using [sqlite3_reset()] then go back
3039 ** ^If the nByte argument is less than zero, then zSql is read up to the
3040 ** first zero terminator. ^If nByte is non-negative, then it is the maximum
3044 ** that the supplied string is nul-terminated, then there is a small
3049 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3057 ** string or a comment) then *ppStmt is set to NULL.
3096 ** change the query plan for a statement, then the statement may be
3163 ** then there is no distinction between protected and unprotected
3241 ** the special value [SQLITE_STATIC], then SQLite assumes that the
3243 ** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
3258 ** then the call will return [SQLITE_MISUSE].  If any sqlite3_bind_()
3319 ** nameless, then NULL is returned.  ^The returned string is
3380 ** (for example during a conversion from UTF-8 to UTF-16) then a
3385 ** then the name of the column is unspecified and may change from
3414 ** subquery and is not a column value, then all of these functions return
3426 ** prepared statement and column at the same time then the results are
3432 ** at the same time then the results are undefined.
3447 ** expression or subquery) then the declared type of the table
3449 ** expression or subquery, then a NULL pointer is returned.
3495 ** or occurs outside of an explicit transaction, then you can retry the
3497 ** explicit transaction then you should rollback the transaction before
3505 ** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
3543 ** then the more specific [error codes] are returned directly
3613 ** are pending, then the results are undefined.
3625 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
3627 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
3628 ** the string to UTF-8 and then returns the number of bytes.
3629 ** ^If the result is a numeric value then sqlite3_column_bytes() uses
3651 ** or [sqlite3_value_bytes()], then the behavior is undefined.
3676 ** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
3677 ** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
3723 ** into the desired format, then invoke sqlite3_column_bytes() or
3757 ** ^If the statement was executed successfully or not executed at all, then
3758 ** SQLITE_OK is returned. ^If execution of the statement failed then an
3786 ** then [sqlite3_reset(S)] returns [SQLITE_OK].
3789 ** [prepared statement] S indicated an error, then
3812 ** connection then application-defined SQL functions must be added
3823 ** aggregate takes. ^If this parameter is -1, then the SQL function or
3826 ** parameter is less than -1 or greater than 127 then the behavior is
3839 ** encoding is used, then the fourth argument should be [SQLITE_ANY].
3963 ** then the conversion is performed.  Otherwise no conversion occurs.
4000 ** called once for each invocation of the xStep callback and then one
4073 ** then sqlite3_get_auxdata() returns a NULL pointer.
4151 ** or sqlite3_result_error16() is negative then SQLite takes as the error
4154 ** sqlite3_result_error16() is non-negative then SQLite takes that many
4189 ** is negative, then SQLite takes result text from the 2nd parameter
4192 ** is non-negative, then as many bytes (not characters) of the text
4196 ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
4200 ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
4206 ** then SQLite makes a copy of the result into space obtained from
4318 ** then it is passed the names of undefined collation sequences as strings
4398 ** millisecond time resolution, then the time will be rounded up to
4411 ** the name of a folder (a.k.a. directory), then all temporary files
4414 ** is a NULL pointer, then SQLite performs a search for an appropriate
4450 ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
4456 ** connection while this routine is running, then the return value
4478 ** then this interface returns a pointer to the first prepared statement
4501 ** then the commit is converted into a rollback.
4520 ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
4670 ** table or NULL. ^If it is NULL, then all attached databases are searched
4701 ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
4703 ** explicitly declared [INTEGER PRIMARY KEY] column, then the output
4747 ** ^If an error occurs and pzErrMsg is not 0, then the
4909 ** about what parameters to pass to xFilter.  ^If argvIndex>0 then
4912 ** is true, then the constraint is assumed to be fully handled by the
5117 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
5140 ** then the BLOB handle is marked as "expired".
5291 ** ^If zVfsName is NULL then the default VFS is returned.
5300 ** then the behavior is undefined.
5337 ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
5382 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
5419 ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
5528 ** ^If the argument to sqlite3_mutex_held() is a NULL pointer then
5568 ** ^If the [threading mode] is Single-thread or Multi-thread then this
5590 ** open database file, then SQLITE_ERROR is returned.  ^This error
5657 ** resetFlag is true, then the highest record value is reset after
5783 ** the resetFlg is true, then the highest instantaneous value is
5854 ** ^If the resetFlg is true, then the counter is reset to zero after this
5981 ** ^If the requested page is already in the page cache, then the page cache
5983 ** intact.  ^(If the requested page is not already in the cache, then the
5997 ** a call to xFetch() with createFlag==1 returns NULL, then SQLite will
6005 ** then the page should be evicted from the cache. In this case SQLite 
6008 ** zero, then the page is considered to be unpinned. ^The cache implementation
6103 ** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
6121 ** are still more pages to be copied, then the function resturns [SQLITE_OK].
6123 ** from source to destination, then it returns [SQLITE_DONE].
6125 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
6139 ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
6142 ** busy-handler returns non-zero before the lock is available, then 
6147 ** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
6150 ** [SQLITE_READONLY] is returned, then 
6166 ** used by the backup operation, then the backup will be automatically
6169 ** by the backup operation, then the backup database is automatically
6179 ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
6188 ** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
6205 ** operation, then the values are not updated to account for any extra
6214 ** connections, then the source database connection may be used concurrently
6282 ** If this happens, then the specified callback is invoked immediately,
6287 ** a read-lock on the same table, then SQLite arbitrarily selects one of 
6293 ** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
6294 ** called with a NULL pointer as its second argument, then any existing
6318 ** same callback function, then instead of invoking the callback function
6328 ** action (a reasonable assumption), then using this API may cause the
6331 ** Y is waiting on connection X's transaction, then neither connection
6336 ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
6356 ** invoked immediately. If the application then re-attempts the "DROP TABLE"
6360 ** by an sqlite3_step() call. ^(If there is a blocking connection, then the
6477 ** empty string, then a checkpoint is run on all databases of
6479 ** [WAL | write-ahead log mode] then this interface is a harmless no-op.
6954 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
7316 ** If we are not using shared cache, then there is no need to
8101 ** If no global maximum is configured, then the system attempts to limit
8230 /* If the SET_FULLSYNC macro is not defined above, then make it
8253 ** 2006-10-31:  The default prefix used to be "sqlite_".  But then
8256 ** This annoyed many windows users.  Those users would then do a 
8606 ** length of a statement and is then updated by OP_SetCounts.  It keeps a
8822 **     argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
8985 ** If the database schema is shared, then there is one instance of this
8994 ** then used by the virtual table implementation to access real tables 
9012 ** corresponding sqlite3 structure. They are then deleted/xDisconnected 
9042 ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
9046 ** the table.  If a table has no INTEGER PRIMARY KEY, then a random rowid
9054 ** then the table is stored in a file that is automatically deleted
9181 #define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */
9296 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
9309 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
9376 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
9377 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the 
9379 ** then Expr.token contains the name of the function.
9388 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is 
9395 ** expression is used as a result in an aggregate SELECT, then the
9400 ** character '?' in the original SQL) then the Expr.iTable holds the index 
9403 ** If the expression is a subquery then Expr.iColumn holds an integer
9405 ** subquery gives a constant result, then iTable is -1.  If the subquery
9407 ** then iTable is the address of a subroutine that computes the subquery.
9410 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
9422 ** an Expr object is truncated.  When EP_Reduced is set, then all
9437   /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
9450   /* If the EP_Reduced flag is set in the Expr.flags mask, then no
9580 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
9614 ** now be identified by a database name, a dot, then the table name: ID.ID.
10109  * pSelect   -> If this is an INSERT INTO ... SELECT ... statement, then
10112  * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
10115  *              statement, then this stores the column-names to be
10938 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
11072 ** If x is a lower-case ASCII character, then its upper-case equivalent
11785 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
11788 ** If the MEM_Str flag is set then Mem.z points at a string representation.
11791 ** set, then the string is nul terminated. The MEM_Int and MEM_Real 
12111 ** then this routine is not threadsafe.
12951 ** then assume a default value of "now" for argv[0].
14157     /* If memory status is enabled, then the malloc.c wrapper will already
14555 ** freelist. If the previous chunk is checked out, then
14806 ** chunk before invoking this routine, then must unlink the (possibly
14920   /* If none of the above worked, then we fail. */
15215 **       then the two blocks are coalesed into the single larger block.
15450   ** block.  If not, then split a block of the next larger power of
15800     /* If the xMutexAlloc method has not been set, then the user did not
15945 ** If compiled with SQLITE_DEBUG, then additional logic is inserted
16118 ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
16208 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
16462 ** not an atomic operation, then these routines might delivery
16465 ** told that HPUX is not such a platform.  If so, then these routines
16525 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
16613   /* If recursive mutexes are not available, then we have to grow
16621   ** are not met, then the mutexes will fail and problems will result.
16656   /* If recursive mutexes are not available, then we have to grow
16664   ** are not met, then the mutexes will fail and problems will result.
16935 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
17372 ** First make sure the memory subsystem is initialized, then do the
17658 ** failure on the same database connection) then always return 0.
17743 ** Attempt to reallocate p.  If the reallocation fails, then free p
17817 ** then the connection error-code (the value returned by sqlite3_errcode())
17821   /* If the db handle is not NULL, then we must hold the connection handle
17979 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
17985 ** Return the ascii code for the leading digit of *val, then
18346         ** If the field type is etGENERIC, then convert to either etEXP
19143 **     0xd800 and 0xe000 then it is rendered as 0xfffd.
19225   /* If the translation is between UTF-16 little and big endian, then 
19730 ** input does not begin with a quote character, then this routine
20005 ** then return false.
20094 ** If zNum represents an integer that will fit in 32-bits, then set
20394 ** integer, then set *v to 0xffffffff.
20711 /* Link pNew element into the hash table pH.  If pEntry!=0 then also
20867 ** If no element exists with a matching key, then a new
20870 ** If another element already exists with the same key, then the
20872 ** The key is not copied in this instance.  If a malloc fails, then
20875 ** If the "data" parameter to this function is NULL, then the
21113 ** wrappers then we will get simulated malloc() failures within this
21290 ** If we compile with the SQLITE_TEST macro set, then the following block
21483   /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
21678   /* If we are holding a PENDING lock that ought to be released, then
21691   /* Update the state of the lock has held in the file descriptor then
21754 ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
21878 ** into UCS-2 and then from UCS-2 to the current codepage.
21904 ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
22820 ** If we compile with the SQLITE_TEST macro set, then the following block
23237 ** one is a hard or symbolic link to the other) then if you set
23238 ** an exclusive lock on fd1, then try to get an exclusive lock
23364 ** Otherwise, if an error occurs, then successfully closed file descriptor
23667   ** has a SHARED or RESERVED lock, then increment reference counts and
23705   /* If control gets to this point, then actually go ahead and make
23828 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
23829 ** the byte range is divided into 2 parts and the first part is unlocked then
23830 ** set to a read lock, then the other part is simply unlocked.  This works 
24224   /* If we have any lock, then the lock file already exists.  All we have
24821       /* if we failed to get the lock then someone else must have it */
24906   ** has a SHARED or RESERVED lock, then increment reference counts and
24935   /* If control gets to this point, then actually go ahead and make
25171 ** is available.  If you don't compile for a mac, then the "unix-afp"
25212 ** Seek to the offset passed as the second argument, then read cnt 
25215 ** NB:  If you define USE_PREAD or USE_PREAD64, then it might also
25296 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
25361   ** normal database file) then record the fact that the database
25414 ** then simply compile with -Dfdatasync=fdatasync
25483   /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
25527 ** If dataOnly==0 then both the file itself and its metadata (file
25528 ** size, access time, etc) are synced.  If dataOnly!=0 then only the
25571     ** then the directory sync is superfluous.
25693       ** ftruncate() to set the file size, then write a single byte to
25965 ** is "/home/user1/config.db" then the file that is created and mmapped
25970 ** from the database file is used, then differing access permissions
25984 ** file are currently open, in this process or in other processes, then
26109 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If 
26114 ** this call as described above, then it is mapped into this processes 
26333 ** If there is no shared memory associated with the connection then this
26364   /* If pShmNode->nRef has reached 0, then close the underlying
26563 ** for the database file "filePath".  It then returns the sqlite3_io_methods
26629 ** for the database file "filePath".  It then returns the sqlite3_io_methods
26744       ** descriptors on this file, then no malloc would be required by
26749       ** If scenario (a) caused the error then things are not so safe. The
26970 ** If a suitable file descriptor is found, then it is returned. If no
27017 ** to create new files with. If no error occurs, then SQLITE_OK is returned
27027 ** Finally, if the file being opened is a WAL or regular journal file, then 
27125   **   (b) if CREATE is set, then READWRITE must also be set, and
27126   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
27127   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
27279         ** then the call to close() will cancel those locks. In practice,
27484   ** you really cannot cast a function pointer into void*.  But then, on the
27744 ** host ID and/or proxy path, then the lock is escalated to an exclusive
27922   ** the parent directories and then try again.
28030 ** Takes an open conch file, copies the contents to a new path and then moves 
28394 ** If pFile holds a lock on a conch file, then release that lock.
28559       ** (c) the file system is read-only, then enable no-locking access.
28591     ** switch the locking context and pMethod then return.
28796     /* restore the original locking context and pMethod then close it */
28956 ** wrappers then we will get simulated malloc() failures within this
29139 ** If we compile with the SQLITE_TEST macro set, then the following block
29543   /* If shared memory could not be created, then close the mutex and fail */
29637     /* If no pending lock has been acquired, then acquire it */
29985   /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
30201   /* If we are holding a PENDING lock that ought to be released, then
30208   /* Update the state of the lock has held in the file descriptor then
30258 ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
30545 ** file are currently open, in this process or in other processes, then
30684   /* If pShmNode->nRef has reached 0, then close the underlying
30828 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If 
30833 ** this call as described above, then it is mapped into this processes 
31761 ** then it is not necessary to include the nul-terminator character
31898 ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
31901 ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
31946 ** i is out of range, then return false.
32005   /* completely fill the hash, then just add it without */
32518 ** reference count drops to 0, then it is made elible for recycling.
32632 ** function is 0, then the data area associated with page 1 is zeroed, but
32831 ** If the default page cache implementation is overriden, then neither of
33141 ** LRU list, then this function is a no-op.
33352 **      then attempt to recycle a page from the LRU list. If it is the right
33664 ** two TESTs where the TESTs have the same batch nubmer, then the
33921 ** list contains too few elements, then construct an incomplete tree
33977 ** sorted already.  If there is a binary tree on p->pTree, then
34161 ** the last call, then return 0.
34224 ** (6) If a master journal file is used, then all writes to the database file
34353 **    * If the database is a WAL database, then the WAL connection is open.
34473 **    layer then attempts a rollback operation. If the error condition 
34576 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
34590 ** the savepoint is active, then iHdrOffset is set to the byte offset 
34693 **   This is a boolean variable. If true, then any required sub-journal
34694 **   is opened as an in-memory journal file. If false, then in-memory
34736 **   to measure the database file on disk, and then truncates it if required.
34865 ** file after power is restored.  If an attempt is then made
35256 ** then the value returned is the size of the journal file when it
35284 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
35337 ** nul-terminator), then this is handled as if no master journal name
35341 ** file, then it is copied into the buffer pointed to by zMaster. A
35377     /* If the checksum doesn't add up, then one or more of the disk sectors
35423 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
35430 ** journal file in bytes is larger than this value, then truncate the
35682       ** invalid, then the process that wrote the journal-header must have 
35698     ** created by a process other than this one, then this routine
35776   /* If the pager is in peristent-journal mode, then the physical 
35892     /* If the operating system support deletion of open files, then
35961 ** the persistent error occurred, then the rollback journal may need
35993 ** If the journal file is open, then it is "finalized". Once a journal 
36026 ** database then the IO error code is returned to the user. If the 
36027 ** operation to finalize the journal file fails, then the code still
36029 ** unlock operation fails as well, then the first error code related
36046   **      lock switches back to locking_mode=normal and then executes a
36144 ** malloc error occurs during a rollback, then this will itself cause 
36217 ** is greater than the current value of Pager.dbSize, then playback is
36220 ** If pDone is not NULL, then it is a record of pages that have already
36222 ** (if the corresponding pDone bit is set) then skip the playback.
36227 ** and played back, then SQLITE_OK is returned. If an IO error occurs
36229 ** to the database file, then the IO error code is returned. If data
36240 ** If this is a savepoint rollback, then memory may have to be dynamically
36310   ** rollback, then don't bother to play it back again.
36323   /* If the pager is in CACHEMOD state, then there must be a copy of this
36328   ** and a page is moved during an incremental vacuum then the page may
36330   ** during a Movepage() call, then the page may not be in the cache
36334   ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
36335   ** pager cache if it exists and the main file. The page is then marked 
36343   ** then changed again within the statement.  When rolling back such a
36399     ** if the page is on the free-list at the start of the transaction, then
36400     ** populated, then moved using sqlite3PagerMovepage().
36404     ** and if the pager requires a journal-sync, then mark the page as 
36430       ** journal file, then its content must be as they were when the 
36437       ** unsynced portion of the main journal file, then it is not safe
36443       ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
36453     /* If this was page 1, then restore the value of Pager.dbFileVers.
36607 ** If the file on disk is currently larger than nPage pages, then use the VFS
36687 **       in the journal.  If this value is 0xffffffff, then compute the
36721 ** journal file then all pages up to the first corrupted page are rolled
36723 ** is then deleted and SQLITE_OK returned, just as if no corruption had
36758   ** present on disk, then the journal is not hot and does not need to be
36786     ** it is corrupted, then a process must have failed while writing it.
36797     /* If nRec is 0xffffffff, then this journal was created by a process
36808     ** process and if this is the final header in the journal, then it means
36886   ** before the transaction was committed, then the change-counter 
36888   ** mode, then subsequent transactions performed by the connection will not
36931 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
36934 ** If an IO error occurs, then the IO error is returned to the caller.
37239 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
37245 ** being rolled back), then the rollback consists of up to three stages,
37253 **   * If PagerSavepoint.iHdrOffset is not zero, then pages are played
37257 **   * Pages are then played back from the sub-journal file, starting
37266 ** If pSavepoint is NULL, then pages are only played back from the main
37408 **              single disk sector is atomic, then this mode provides
37483 ** retried. If it returns zero, then the SQLITE_BUSY error is
37513 ** then the pager object page size is set to *pPageSize.
37515 ** If the page size is changed, then this function uses sqlite3PagerMalloc() 
37523 ** then *pPageSize is set to the old, retained page size before returning.
37667 ** However, if the file is between 1 and <page-size> bytes in size, then 
37760 ** syncs the journal file to disk, then sets pPager->journalHdr to the
37816     ** If this is not done, then an unsynced portion of the open journal 
37872 ** If the Pager.noSync flag is set, then this function is a no-op.
37880 **     then the nRec field of the most recently written journal header
37883 **     mode, then the journal file is synced before this field is updated.
37885 **   * If the device does not support the SEQUENTIAL property, then 
37900 ** error is encountered, then the IO error code is returned to the caller.
37923         ** mode, then the journal file may at this point actually be larger
37929         ** transaction), then SQLite may become confused when doing the 
37931         ** of this connections data, then proceed to rolling back the old,
37935         ** a valid header following Pager.journalOff, then write a 0x00
38037 ** is updated accordingly. If page 1 is written out, then the value cached
38211 ** made clean for some other reason, but no error occurs, then SQLITE_OK
38275     ** If (X>Y), then when pagerStress is called page X will not be written
38316 ** If zFilename is NULL then a randomly-named temporary file is created
38318 ** automatically when they are closed. If zFilename is ":memory:" then 
38626 ** does not exist, then the journal file is not really hot. In this
38660     ** call above, but then delete the journal and drop the lock before
38671       ** then delete the journal file. See the header comment above for 
38689           ** If there is, then we consider this journal to be hot. If not, 
38711             ** This might be a false positive.  But if it is, then the
38736 **      on the database file), then an attempt is made to obtain a
38746 **      then an attempt is made to clear the error state by discarding
38782     ** database file, then it either needs to be played back or deleted.
38865         ** the file. If the unlock attempt fails, then Pager.eLock must be
38982 ** already in the cache when this function is called, then the extra
38987 ** requested page is not already stored in the cache, then no 
39000 ** If noContent is true, then the data returned is zeroed instead of
39145 ** If the number of references to the page drop to zero, then the
39170 ** then this function just writes a journal header to the start of the
39250 ** If the exFlag argument is false, then acquire at least a RESERVED
39251 ** lock on the database file. If exFlag is true, then acquire at least
39255 ** If the subjInMemory argument is non-zero, then any sub-journal opened
39259 ** sub-journal. If the subjInMemory argument is zero, then any required
39293       ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
39362   ** to the journal then we can return right away.
39410         ** then corruption may follow.
39450     ** then write the current page to the statement journal.  Note that
39548     ** starting at pg1, then it needs to be set for all of them. Because
39612 ** If the isDirectMode flag is zero, then this is done by calling 
39613 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
39619 ** if isDirect is non-zero, then the database file is updated directly
39632   ** atomic-write optimization is enabled in this build, then isDirect
39765 ** If the final parameter - noSync - is true, then the database file itself
39821       ** If the optimization was not enabled at compile time, then the
39825       ** to make sure the journal file has actually been created, then call
39830       ** then call pager_incr_changecounter() to update the change-counter
39847         ** to include the updated change counter and then write page 1 
39863       /* If this transaction has made the database smaller, then all pages
39897       ** or if zMaster is NULL (no master journal), then this call is a no-op.
39924       ** then use pager_truncate to grow or shrink the file here.
39980   ** using persistent journals, then this function is a no-op.
40004 ** If a write transaction is open, then all changes made within the 
40027 ** WAL files. The WAL transaction is then closed.
40125 ** currently less than nSavepoints open, then open one or more savepoints
40127 ** equal to nSavepoint, then this function is a no-op.
40130 ** occurs while opening the sub-journal file, then an IO error code is
40188 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
40189 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
40196 ** (Pager.nSavepoint-1), then this function is a no-op.
40198 ** If a negative value is passed to this function, then the current
40206 ** then savepoint iSavepoint is also destroyed.
40338 ** If the fourth argument, isCommit, is non-zero, then this page is being
40367   ** savepoint, then save the current contents of the page into the 
40371   **     <journal page X, then modify it in memory>
40442     /* If needSyncPgno is non-zero, then the journal file needs to be 
40493 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
40587       ** not possible, then that is not a problem. Deleting the journal file
40845 ** WAL can fill up with frames and then be checkpointed and then new
40906 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
40907 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
40920 ** first checks the WAL to see if it contains page P.  If so, then the
40924 ** frame or are followed by a commit frame, then page P is read from
41026 ** no hash slot such that aHash[i]==p) then page P is not in the
41082 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
41144 ** holds read-lock K, then the value in aReadMark[K] is no greater than
41164 ** in the WAL has been backfilled into the database) then new readers
41172 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
41206 ** If the LSB is set, then the checksums for each frame within the WAL
41311 ** then an SQLite error code is returned and *ppPage is set to 0.
41778     /* If the entry in aPgno[] is already set, then the previous writer
42086 ** number larger than *piPage, then return 1.
42522 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
42542   ** When reading, read [0] first then [1].  Writes are in the reverse order.
42657 ** checkpointed.  If useWal==0 then this routine calls walIndexReadHdr() 
42682 ** Or if pWal->readLock==0, then the reader will ignore the WAL
42684 ** If the useWal parameter is 1 then the WAL will never be ignored and
42715       ** then convert BUSY errors to WAL_RETRY.  If recovery is known to
42793     ** be mxFrame, then retry.
42833     ** happened, then reading the database with the current value of
42867 ** transaction, then *pChanged is set to 1 before returning.  The
42915   /* If the "last page" field of the wal-index header snapshot is 0, then
42918   ** then the WAL is ignored by the reader so return early, as if the 
42993   /* If iRead is non-zero, then it is the log frame number that contains the
43032 ** the read transaction was started, then it is not possible for this
43059   ** time the read transaction on this connection was started, then
43112       ** (b) has an outstanding reference, then xUndo is either a no-op
43198         ** readers are currently using the WAL), then the transactions
43404 ** Obtain a CHECKPOINT lock and then backfill as much information as
43435     ** performed, then the pager-cache associated with pWal is now
43453 ** the last call, then return 0.
43468 ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE
43471 ** or if the acquisition of the lock fails, then return 0.  If the
43476 ** If op is one, then change from locking_mode=NORMAL into 
43483 ** If op is negative, then do a dry-run of the op==1 case but do
43585 ** page.  If the payload is larger than the preset amount then surplus
43641 ** If the payload for a cell is larger than the max payload, then extra
43787 ** the header, then your custom library will not be able to read 
44098 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
44226 ** If the object is not sharable, then no mutex is ever required
44235 ** p, then first unlock all of the others on p->pNext, then wait
44236 ** for the lock to become available on p, then relock all of the
44259   /* Unless the database is sharable and unlocked, then BtShared.db
44616   ** shared-cache feature disabled, then there is only ever one user
44664   ** and has the read-uncommitted flag set, then no lock is required. 
44674   ** not loaded, then it is too difficult to actually check to see if
44726 ** read-uncommitted flag set, then it is OK for the other object to
44763   /* If requesting a write-lock, then the Btree must have an open write
44789     ** since we know that if eLock==WRITE_LOCK, then no other connection
44887 ** transaction. If it does not, then the BtShared.isPending variable
44921     ** that writer, then the number of locks held by connections other
44925     ** If there is not currently a writer, then BtShared.isPending must
44992 ** If argument isClearTable is true, then the entire contents of the
44996 ** Otherwise, if argument isClearTable is false, then the row with
45043 ** a page is moved to the free-list and then reused within the same
45046 ** is extracted from the free-list and reused, then the original data
45110   /* If this is an intKey table, then the above call to BtreeKeySize()
45113   ** table, then malloc space for and store the pCur->nKey bytes of key 
45179 ** record and then call BtreeMovetoUnpacked() to do the work.
45290 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
45804   ** situations arise, then subsequent insert operations might corrupt
45903 ** not contain a well-formed database page, then return 
46001     ** of the page, then the page must be corrupted. This check also
46123 ** If an error occurs, then the value *ppPage is set to is undefined. It
46209 ** If zFilename is ":memory:" then an in-memory database is created
46213 ** and we are in shared cache mode, then the open will fail with an
46356       /* If the magic name ":memory:" will create an in-memory database, then
46359       ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
46405   /* If the new Btree uses a sharable pBtShared, then link the new
46634 ** size supplied does not meet this constraint then the page size is not
46642 ** If parameter nReserve is less than zero, then the number of reserved
46645 ** If the iFix!=0 then the pageSizeFixed flag is set so that the page size
46710 ** then make no changes.  Always return the value of the secureDelete
46728 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
46778 ** well-formed database file, then SQLITE_CORRUPT is returned.
46926 ** of a transaction but there is a read lock on the database, then
46945 ** If pBt points to an empty file then convert that empty file
47010 ** and the database was previously unlocked, then invoke the busy handler
47146     ** the sub-journal is not already open, then it will be opened here.
47299   /* If pDbPage was a btree-page, then it may have child pages and/or cells
47303   ** If pDbPage is an overflow page, then the first 4 bytes may store a
47304   ** pointer to a subsequent overflow page. If this is the case, then
47418       ** On the other hand, if nFin is greater than zero, then keep
47499 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
47777     ** the result of a constraint, malloc() failure or IO error) then 
47860 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the 
47892 ** on the database already. If a write-cursor is requested, then
47895 ** If wrFlag==0, then the cursor can only be used for reading.
47896 ** If wrFlag==1, then the cursor can be used for reading or for
47914 ** root page of a b-tree.  If it is not, then the cursor acquired
48029 ** ignored.  If the rowid cache has never before been set, then a
48183 ** to page number pOvfl was obtained, then *ppPage is set to point to that
48186 ** the pointer-map was used to obtain the value for *pPgnoNext), then
48250 ** If argument eOp is false, then nByte bytes of data are copied
48252 ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
48399         ** page-list cache, if any, then fall back to the getOverflowPage()
48492 ** into *pAmt.  If *pAmt==0, then the value returned will not be
48499 ** onto overflow pages, then accessPayload() must be used to reassemble
48638 ** right-most child page then pCur->idx is set to one more than
48660 ** If the table has a virtual root page, then the cursor is moved to point
48710     /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
48869 ** If an exact match is not found, then the cursor is always
48905   ** to move to, then just return without doing any work */
48940     ** not run. If this is not the root-page, then the moveToChild() routine
49084 ** successful then set *pRes=0.  If the cursor
49086 ** this routine was called, then set *pRes=1.
49153 ** successful then set *pRes=0.  If the cursor
49155 ** this routine was called, then set *pRes=1.
49223 ** If the "nearby" parameter is not 0, then a (feeble) effort is made to 
49229 ** anywhere on the free-list, then it is guarenteed to be returned. This
49261     ** shows that the page 'nearby' is somewhere on the free-list, then
49541     /* If the secure_delete option is enabled, then
49562   ** trunk page in the free-list is full, then this page will become a
49611   /* If control flows to this point, then it was not possible to add the
49683       ** So if there exists more than one reference to this page, then it 
49714 ** be constructed in this temporary area then copied into pPage->aData
49798       ** If this is the first overflow page, then write a partial entry 
49800       ** then the optimistic overflow chain processing in clearCell()
49821       /* If pPrior is part of the data area of pPage, then make sure pPage
49841     /* If pPayload is part of the data area of pPage, then make sure pPage
49917 ** If the cell content will fit on the page, then put it there.  If it
49918 ** will not fit, then make a copy of the cell content into pTemp if
49925 ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
49927 ** nSkip is non-zero, then pCell may not point to an invalid memory location 
49957   ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
50218 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
50221 ** any cells with overflow page pointers, then the corresponding pointer
50281 ** is a root page or a child of a root page) then all available siblings
50372   ** has NB or fewer children then all children of pParent are taken.  
50474   ** If the siblings are on leaf pages, then the child pointers of the
50477   ** child pointers.  If siblings are not leaves, then all cell in
50729         ** then there is no divider cell in apCell[]. Instead, the divider 
50743         ** bytes, then it may actually be smaller than this 
50813     **   3) If the sibling pages are not leaves, then the child pages of
50816     **   4) If the sibling pages are not internal intkey nodes, then any
50820     **   5) If the sibling pages are not leaves, then the pointer-map
50841         ** intkey b-tree, then cell i was a divider cell. */
50864         ** intkey b-tree, then cell i is a divider cell.  */
50873       ** page before the balancing, then the pointer map entries associated
50928 ** page is then overwritten to make it an empty page with the right-child 
51117 ** If the seekResult parameter is non-zero, then a successful call to
51124 ** If the seekResult parameter is non-zero, then the caller guarantees that
51126 ** overwritten.  If the seekResult parameter is 0, then cursor pCur may
51158   ** expecting an index b-tree, then the caller should be inserting blob
51176   ** integer key to use. It then calls this function to actually insert the 
51331   /* If the cell deleted was not located on a leaf page, then the cursor
51356   ** then the cursor still points to that page. In this case the first
51360   ** Otherwise, if the entry deleted was on an internal node page, then
51589 ** If pnChange is not NULL, then table iTable must be an intkey table. The
51621 ** root page in the database file, then the last root page 
51826     /* If this is a leaf page or the tree is not an int-key tree, then 
52277 ** malloc is returned if *pnErr is non-zero.  If *pnErr==0 then NULL is
52891 ** If pFile is currently larger than iSize bytes, then truncate it to
52892 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
52961     ** one now. If a transaction is opened here, then it will be closed
53095     /* If bCloseTrans is true, then this function opened a read transaction
53187 ** copied into the destination database, then the data written to the
53311 ** representation is already stored using the requested encoding, then this
53332   ** then the encoding of the value may not have changed.
53627 ** If pMem is an integer, then the value is exact.  If pMem is
53628 ** a floating-point then the value returned is the integer part.
53629 ** If pMem is a string or blob, then we make an attempt to convert
53882 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
53941 ** parameter. If the value passed is SQLITE_TRANSIENT, then the 
53947 ** size limit) then no memory allocation occurs.  If the string can be
53948 ** stored without allocating memory, then it is.  If a memory allocation
53949 ** is required to store the string, then value of pMem is unchanged.  In
54162 ** to read from the disk) then the pMem is left in an inconsistent state.
54218 ** If that is the case, then the result must be aligned on an even byte
54275 ** be converted directly into a value, then the value is allocated and
54278 ** cannot be converted to a value, then *ppVal is set to NULL.
54777   ** If malloc failed, then the while() loop above may not have iterated
54966 ** If the input FuncDef structure is ephemeral, then free it.  If
54967 ** the FuncDef is not ephermal, then do nothing.
55076 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
55079 ** first null byte.  If n>0 then copy n+1 bytes of zP4.
55093 ** If addr<0 then change P4 on the most recently inserted instruction.
55199 ** Return the opcode for a given address.  If the address is -1, then
55203 ** routine, then a pointer to a dummy VdbeOp will be returned.  That opcode
55455 ** When p->explain==1, first the main program is listed, then each of
55708 ** request, then increment *pnByte by the amount of the request.
55801     ** requirements by reusing the opcode array tail, then the second
55997 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
56082   ** simple case then too.
56192     ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
56304 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
56305 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the 
56315   /* If p->iStatement is greater than zero, then this Vdbe opened a 
56363 ** If SQLite is not threadsafe but does support shared-cache mode, then
56408 ** has made changes and is in autocommit mode, then commit those
56409 ** changes.  If a rollback is needed, then do the rollback.
56496     ** VM, then we do either a commit or rollback of the current transaction. 
56542     /* If eStatementOp is non-zero, then a statement transaction needs to
56545     ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
56549     ** is SAVEPOINT_ROLLBACK.  But if p->rc==SQLITE_OK then eStatementOp
56605   /* If the auto-commit flag is set to true, then any locks that were held
56642   ** error, then it might not have been halted properly.  So halt
56647   /* If the VDBE has be run even partially, then transfer the error code
56793 ** If a MoveTo operation is pending on the given cursor, then do that
56799 ** not been deleted out from under the cursor, then this routine is a no-op.
56924 ** points (ex: ARM7) then swap the lower 4 bytes with the 
56982 ** a blob with a zero-filled tail, then buf[] might be just the right
56984 ** is only big enough to hold the non-zero prefix, then only write that
56986 ** prefix and the tail then write the prefix and set the tail to all
57242 ** and the common prefixes are equal, then key1 is less than key2.
57244 ** equal, then the keys are considered to be equal and
57247 ** If the UNPACKED_IGNORE_ROWID flag is set, then the last byte of
57315       ** rowid field were equal, then clear the PREFIX_SEARCH flag and set 
57339   ** flag is set, then break the tie by treating key2 as larger.
57340   ** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes
57743 ** then sets the error code to SQLITE_TOOBIG
57921     /* If there are no other statements currently running, then
57986     ** error has occured, then return the error code in p->rc to the
58268   ** sqlite3_column_XXX API, then set the return code of the statement to
58354 ** xFunc() then return that string.  If N is out of range, return 0.
58366 ** or a constant) then useTypes 2, 3, and 4 return NULL.
58414 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
58497 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
58529   /* If the bit corresponding to this variable in Vdbe.expmask is set, then 
58779 ** If the two statements contain a different number of bindings, then
59002 ** The SQL parser generates a program which is then executed by
59540 ** sqlite3_interrupt() routine has been called.  If it has been, then
59587 ** Execute as much of a VDBE program as we can then return.
59597 ** If an attempt is made to open a locked database, then this routine
59605 ** If the callback ever returns non-zero, then the program exits
60221 ** and then jump to address P2.
60264 ** Check the value in register P3.  If is is NULL then Halt using
60266 ** value in register P3 is not NULL, then this routine is a no-op.
60281 ** For errors, it can be some other value.  If P1!=0 then P2 will determine
60284 ** then back out all changes that have occurred during this execution of the
60287 ** If P4 is not null then it is an error message string.
60304       ** instruction is set to OE_Ignore, then the sub-program is throwing
60451 ** If the parameter is named, then its name appears in P4 and P3==1.
60528 ** is a string or blob, then the copy is only a pointer to the
60570   /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
60578   ** If the open statement-transaction is not closed here, then the user
60617 ** If either the P1 or P2 text are NULL then store NULL in P3.
60685 ** register P1 is zero, then the result is NULL. If either input is 
60812 ** argument was constant then bit 0 of P1 is set. This is used to determine
60982 ** without data loss, then jump immediately to P2, or if P2==0
61123 ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
61127 ** reg(P3) is NULL then take the jump.  If the SQLITE_JUMPIFNULL 
61128 ** bit is clear then fall thru if either operand is NULL.
61133 ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
61139 ** the values are compared. If both values are blobs then memcmp() is
61141 ** are text, then the appropriate collating function specified in
61142 ** P4 is  used to do the comparison.  If P4 is not specified then
61144 ** numeric, then a numeric comparison is used. If the two values
61145 ** are of different types, then numbers are considered less than
61148 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump.  Instead,
61157 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
61158 ** true or false and is never NULL.  If both operands are NULL then the result
61159 ** of comparison is false.  If either operand is NULL then the result is true.
61169 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
61170 ** true or false and is never NULL.  If both operands are NULL then the result
61171 ** of comparison is true.  If either operand is NULL then the result is false.
61214       ** OP_Eq or OP_Ne) then take the jump or not depending on whether
61221       ** then the result is always NULL.
61369 ** If either P1 or P2 is 0 (false) then the result is 0 even if
61378 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
61422 ** NULL, then a NULL is stored in P2.
61439 ** a NULL then store a NULL in P2.
61456 ** in P1 is NULL then take the jump if P3 is true.
61462 ** in P1 is NULL then take the jump if P3 is true.
61520 ** If the column contains fewer than P2 fields, then extract a NULL.  Or,
61525 ** then the cache of the cursor is reset prior to extracting the column.
61619   /* If u.am.payloadSize is 0, then just store a NULL */
61736         /* If u.am.i is less that u.am.nField, then there are less fields in this
61751     ** of the record (when all fields present), then we must be dealing
61761   /* Get the column information. If u.am.aOffset[u.am.p2] is non-zero, then
61763   ** then there are not enough fields in the record to satisfy the
61792   ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
61857 ** If P4 is NULL then all index fields have the affinity NONE.
62020   ** transaction, then there cannot be any savepoints.
62044         /* If there is no open transaction, then mark this as a special
62062     /* Find the named savepoint. If there is no such savepoint, then an
62089       ** and this is a RELEASE command, then the current transaction
62129       /* If it is a RELEASE, then destroy the savepoint being operated on
62130       ** too. If it is a ROLLBACK TO, then set the number of deferred
62153 ** VMs (apart from this one), then a ROLLBACK fails.  A COMMIT fails if
62233 ** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is
62238 ** database.  If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
62251 ** If P2 is zero, then a read-lock is obtained on the database file.
62429 ** If P5!=0 then use the content of register P2 as the root page, not
62434 ** then a read lock is acquired as part of this instruction.  A read
62443 ** structure, then said structure defines the content and collating 
62457 ** structure, then said structure defines the content and collating 
62670 ** to an SQL index, then P3 is the first in an array of P4 registers 
62675 ** greater than or equal to the key and P2 is not zero, then jump to P2.
62683 ** to an SQL index, then P3 is the first in an array of P4 registers 
62688 ** the key and P2 is not zero, then jump to P2.
62696 ** to an SQL index, then P3 is the first in an array of P4 registers 
62701 ** the key and P2 is not zero, then jump to P2.
62709 ** to an SQL index, then P3 is the first in an array of P4 registers 
62714 ** less than or equal to the key and P2 is not zero, then jump to P2.
62752       ** loss of information, then special processing is required... */
62756           ** then the seek is not possible, so jump to P2 */
62760         /* If we reach this point, then the P3 value must be a floating
62899 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
62900 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
62904 ** is a prefix of any entry in P1 then a jump is made to P2 and
62909 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
62910 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
62914 ** is not the prefix of any entry in P1 then a jump is made to P2.  If P1 
62915 ** does contain an entry whose prefix matches the P3/P4 record then control
63069 ** with that key does not exist in table of P1, then jump to P2. 
63070 ** If the record does exist, then fall thru.  The cursor is left 
63143 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds 
63248       ** largest possible integer (9223372036854775807) then the database
63287 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
63289 ** then rowid is stored for subsequent return by the
63293 ** the last seek operation (OP_NotExists) was a success, then this
63300 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
63301 ** UPDATE operation.  Otherwise (if the flag is clear) then this opcode
63306 ** may be NULL. If it is not NULL, then the update-hook 
63310 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
63312 ** value of register P2 will then change.  Make sure this does not
63396 ** record in the table. If it is left pointing at the next record, then
63400 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
63406 ** If P4 is not NULL, then it is the name of the table that P1 is
63408 ** If P4 is not NULL then the P1 cursor must have been positioned
63627 ** If the table or index is empty and P2>0, then jump immediately to P2.
63664 ** then rewinding that index and playing it back from beginning to
63682 ** If the table or index is empty and P2>0, then jump immediately to P2.
63715 ** table or index.  If there are no more key/value pairs then fall through
63721 ** If P5 is positive and the jump is taken, then event counter
63729 ** table or index.  If there is no previous key/value pairs then fall through
63735 ** If P5 is positive and the jump is taken, then event counter
63896 ** then jump to P2.  Otherwise fall through to the next instruction.
63898 ** If P5 is non-zero then the key value is increased by an epsilon 
63909 ** If the P1 index entry is less than the key value then jump to P2.
63912 ** If P5 is non-zero then the key value is increased by an epsilon prior 
63958 ** P3==1 then the table to be clear is in the auxiliary database file
63961 ** If AUTOVACUUM is enabled then it is possible that another root page
63967 ** the last one in the database) then a zero is stored in register P2.
63968 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
64017 ** P2==1 then the table to be clear is in the auxiliary database file
64020 ** If the P3 value is non-zero, then the table referred to must be an
64023 ** If P3 is greater than zero, then the value stored in register P3 is
64097 ** the parsing if P2 is true.  If P2 is false, then this routine is a
64103 ** then runs the new virtual machine.  It is thus a re-entrant opcode.
64116   /* If pOp->p2 is 0, then this opcode is being executed to read a
64131   ** this happens, then some other thread may delete the in-memory
64417   /* If the p5 flag is clear, then recursive invocation of triggers is
64442   ** the trigger program. If this trigger has been fired before, then u.by.pRt
64551 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
64913 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
64914 ** then only the currently executing statement is affected. 
65182 ** the end of its result set, then fall through to the next instruction.
65260 ** is the rowid of a row to delete.  If argv[0] is NULL then no 
65266 ** If P2==1 then no insert is performed.  argv[0] is the rowid of
65270 ** is successful, then the value returned by sqlite3_last_insert_rowid() 
65322 ** If tracing is enabled (by the sqlite3_trace()) interface, then
65520   ** Code external to the Vdbe then "borrows" the b-tree cursor and
65799     /* If there is no statement handle, then the blob-handle has
66472 ** If the Walker does not have an xSelectCallback() then this routine
66512 ** If the result set column is a simple column reference, then this routine
66516 ** evaluated just once and then reused for each alias.
66533 ** then again, we might not...
66690                 ** then skip the right table to avoid a duplicate match */
66714     /* If we have not already resolved the name, then maybe 
66776     ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
66819   ** supplied) and the value of Z is enclosed in double-quotes, then
66851   /* If a column from a table in pSrcList is referenced, then record
66855   ** then set the high-order bit of the bitmask.
67105 ** no match, or if pE is not a simple identifier, then this routine
67306 ** then convert that term into a copy of the corresponding result set
67351 ** number of columns in the result set of the SELECT) then the expression
67354 ** a result-set expression, then the term resolves to a copy of the
67358 ** This routine returns the number of errors.  If errors occur, then
67505     /* If a HAVING clause is present, then there must be a GROUP BY clause.
67517     ** Minor point: If this is the case, then the expression will be
67619 ** If the function is an aggregate function, then the pNC->hasAgg is
67621 ** If an expression contains aggregate functions then the EP_Agg
67714 ** or a sub-select with a column as the return value, then the 
67900 ** If the left hand expression has a collating sequence type, then it is
67978 ** to by pnHeight, the second parameter, then set *pnHeight to that
68059 ** If dequote is true, then the token (if it exists) is dequoted.
68063 ** then the EP_DblQuoted flag is set on the expression node.
68066 ** can be translated into a 32-bit integer, then the token is not
68185 ** NULL, then just return the other expression.
68409 ** If the EXPRDUP_REDUCE flag is set, then the return value includes 
68427 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough 
68530 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
68567 ** the build, then none of the following routines, except for 
68660 ** initially NULL, then create a new expression list.
68663 ** NULL is returned.  If non-NULL is returned, then it is guaranteed
68804   /* If pWalker->u.i is 3 then any term of the expression that comes from
68959 ** determine that it can never generate a NULL, then the OP_IsNull operation
69086 ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
69092 ** If the prNotFound parameter is not 0, then the b-tree will be used 
69101 ** runtime, then a register is allocated and the register number written
69103 ** NULL value, then *prNotFound is left unchanged.
69105 ** If a register is allocated and its location stored in *prNotFound, then
69108 ** is a correlated subquery) then the value of the allocated register is
69242 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
69283   ** If all of the above are false, then we can run this code just once
69312       ** statement returns a column value, then the affinity of that
69314       ** SELECT... statement are columns, then numeric affinity is used
69316       ** 'x' nor the SELECT... statement are columns, then numeric affinity
69349         ** store it in the temporary table. If <expr> is a column, then use
69371           /* If the expression is not constant then we will need to
69470 ** is contained in the RHS then jump to destIfNull.  If the LHS is contained
69471 ** within the RHS then fall through.
69505   /* If the LHS is NULL, then the result is either false or NULL depending
69529     /* If the set membership test fails, then the result of the 
69531     ** contains no NULL values, then the result is 0. If the set 
69532     ** contains one or more NULL values, then the result of the
69553       ** then the presence of NULLs in the RHS does not matter, so jump
69560       ** tests the RHS for NULLs.  If the RHS contains a NULL then
69561       ** jump to destIfNull.  If there are no NULLs in the RHS then
69832 ** is called.  If iColumn<0 then code is generated that extracts the rowid.
69931 ** the registers in the nReg registers beginning with iReg, then
70432       /* If the opcode is TK_TRIGGER, then the expression is a reference
70498     ** ELSE clause and no other term matches, then the result of the
70605 ** then write its number into *pReg.  If the result register is not
70606 ** a temporary, then set *pReg to zero.
70683 ** We could factor them out, but then we would end up adding an
70732 ** factoring out of a loop, then evaluate the expression
70884 ** If the expression evaluates to NULL (neither true nor false), then
71007 ** If the expression evaluates to NULL (neither true nor false) then
71154 ** returns 2, then you do not really know for certain if the two
71155 ** expressions are the same.  But if you get a 0 or 1 return, then you
71440 ** If a register is currently being used by the column cache, then
71736 ** If argument zWhere is NULL, then a pointer string containing the text 
71742 ** If argument zWhere is not NULL, then the string returned is 
72008   /* If the sqlite_sequence table exists in this database, then update 
72121   ** literal NULL, then set pDflt to 0. This simplifies checking
72129   ** If there is a NOT NULL constraint, then the default value for the
72187   /* If the default value of the new column is NULL, then set the file
72310 ** SQLITE_ENABLE_STAT2 macro defined, then the sqlite_stat2 table is
72318 ** or it may be a NULL pointer. If it is not NULL, then all entries in
72320 ** with the named table are deleted. If zWhere==0, then code is generated
72466     ** first index in the pTab->pIndex list, then register regLast has
72559       /* If a malloc failure has occurred, then the result of the expression 
72586     ** values and K is the total number of rows, then the integer is computed
72591     ** If K==0 then no entry is made into the sqlite_stat1 table.  
72592     ** If K>0 then it is always the case the D>0 so division by zero
73125   ** If this fails, or if opening the file failed, then close the file and 
73575 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
73576 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
73610 ** then generate an error.
73666 ** is returned, then the error count and error message in pParse are
73990 ** names is done.)  The search order is TEMP first, then MAIN, then any
74056 ** TEMP first, then MAIN, then any auxiliary databases added
74087 ** unlike that index from its Table then remove the index from
74123 ** If iDb==0 then reset the internal schema tables for all database
74124 ** files.  If iDb>=1 then reset the internal schema for only the
74148   ** then remove them from the auxiliary database list.  We take the
74538   ** then record a pointer to this table in the main database structure
74675   ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
74814 ** of columns that form the primary key.  If pList is NULL, then the
74818 ** a primary key (and this is the second primary key) then create an
74822 ** then we will try to use that column as the rowid.  Set the Table.iPKey
74827 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
74931     ** then an index may have been created on this column before the
74952 ** and the sequence is available in another text encoding, then that is
75034 ** then it is copied to the output buffer exactly as it is. Otherwise,
75201   /* If not initializing, then create a record for the new table
75384   assert( pParse->nErr==0 ); /* If sqlite3StartTable return non-NULL then
75598   ** is non-zero, then it is the root page number of a table moved to
75629   ** is not defined), then it is important to call OP_Destroy on the
75640   ** database, then root page 5 would be moved to page 4 by the 
75840 ** in the current table point to the foreign key.  If pFromCol==0 then
75990 ** root page number of the index.  If memRootPage is negative, then
76189   ** index, then we will continue to process this index.
76333     ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
76379     ** the constraint occur in different orders, then the constraints are
76439   /* If the db->init.busy is 0 then create the index on disk.  This
76761 ** If the iStart argument had been 1 instead of 2, then the result
76763 ** the iStart value would be 0.  The result then would
76823 ** a new one.  If an OOM error does occurs, then the prior value of pList
76844 ** then so is B.  In other words, we never have a case where:
76928 ** usual case.  If the term has a alias, then pAlias points to the
76929 ** alias token.  If the term is a subquery, then pSubquery is the
77158 ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
77193 ** a transaction.  If we are already within a transaction, then a checkpoint
77210 ** more than one entry (example: deleting one row then inserting another,
77212 ** If an abort occurs after some of these writes have completed, then it will
77275 ** If pColl==0 then recompute all indices of pTab.
77293 ** indices use the collating sequence pColl.  If pColl==0 then recompute
77492 ** If it is not NULL, then pColl must point to the database native encoding 
77558 ** true, then create a new entry. Otherwise return NULL.
77611 ** If the entry specified is not found and 'create' is true, then create a
77730 ** If the createFlag argument is true, then a new (blank) FuncDef
77733 ** and the nArg parameter is -1, then only a function that accepts
77736 ** If createFlag is false and nArg is -1, then the first valid
77740 ** If createFlag is false, then a function with the required name and
77775   ** If the SQLITE_PreferBuiltin flag is set, then search the built-in
77800   ** exact match for the name, number of arguments and encoding, then add a
78255     ** deleting from and all its indices. If this is a view, then the
78641           /* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
78676 ** of x.  If x is text, then we actually count UTF-8 characters.
78677 ** If x is a blob, then we count bytes.
78679 ** If p1 is negative, then we begin abs(p1) from the end of x[].
78807 ** If nByte is larger than the maximum string or blob length, then
79027 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
79694 ** A function that loads a shared-library extension then returns NULL.
79973 ** then set aWc[0] through aWc[2] to the wildcard characters and
79974 ** return TRUE.  If the function is not a LIKE-style function then
80254 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx 
80283 ** then non-zero is returned, and a "foreign key mismatch" error loaded
80335       ** column of pFKey, then this index is a winner.  */
80338         /* If zKey is NULL, then this foreign key is implicitly mapped to 
80349         /* If zKey is non-NULL, then this foreign key was declared to
80398 ** affected - once to "delete" the old row, and then again to "insert" the
80436   /* If nIncr is less than zero, then check at runtime if there are any
80441   ** any are, then the constraint is considered satisfied. No need to 
80453       /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
80459       ** apply the affinity of the parent key). If this fails, then there
80468       ** then check if the row being inserted matches itself. If so, do not
80494       ** then check if the row being inserted matches itself. If so, do not
80724 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
80738       ** generating any VDBE code. If one can be found, then jump over
80917         ** on the parent table of this FK, then throw an exception 
80961 ** row contained in table pTab. If the operation is a DELETE, then
80964 ** If the i'th column is not modified by the UPDATE, then the corresponding 
81022 ** If the current operation is an UPDATE, then the pChanges parameter is
81028 ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
81038 ** then the returned trigger structure is equivalent to:
81358     ** required, it is allocated and populated here. It is then stored as
81399   ** is required, it is allocated and populated here. It is then 
81559 ** larger than the maximum rowid in the memId memory cell, then the
81610 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
81634 ** then a list of all columns for the table is substituted.  The IDLIST
81660 ** schemas, including all the same indices, then a special optimization
81826   *  (b) that if it is a view then ON INSERT triggers exist
81862   ** is coming from a SELECT statement, then generate a co-routine that
81997   /* If the INSERT statement included an IDLIST term, then make sure
82002   ** is named in the IDLIST, then record in the keyColumn variable
82201       /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
82375 ** If isUpdate is true and rowidChng is non-zero, then rowidChng contains
82378 ** is false, indicating an INSERT statement, then a non-zero rowidChng 
82392 ** then the appropriate action is performed.  There are five possible
82402 **                                only (do not do a complete rollback) then
82425 ** Or if overrideError==OE_Default, then the pParse->onError parameter
82426 ** is used.  Or if pParse->onError==OE_Default then the onError value
82432 ** Except, if there is no possibility of a REPLACE action then
82869   /* If no test above fails then the indices must be compatible */
82902 ** be attempted, then this routine returns FALSE.
83155 ** If the SQL is a query, then for each row in the query result
83157 ** argument to xCallback().  If xCallback=NULL then no callback
83327 ** interfaces in the middle of this structure, then older different
83997 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with 
84557 ** identifier, or a number.  If minusFlag is true, then the value is
84560 ** If the left side is "database.id" then pId1 is the database name
84561 ** and pId2 is the id.  If the left side is just "id" then pId1 is the
84826         ** then do a query */
85001   ** If temporary directory is changed, then invalidateTempStorage.
85503   ** is created. If an existing main database file is opened, then the
86125     /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
86162 ** file was of zero-length, then the DB_Empty flag is also set.
86275   /* If pSchema is NULL, then return -1000000. This happens when code in 
86333   ** back and different changes are made in their place, then when this
86574   ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
86595     ** characters between zSql8 and zTail8, and then returning a pointer
86762 ** If an illegal or unsupported join type is seen, then still return
87020     ** A and B and the USING clause names X, Y, and Z, then add this
87161 ** If srcTab and nColumn are both zero, then the pEList expressions
87163 ** then data is pulled from srcTab and pEList is used only to get the
87223   ** and this row has been seen before, then do not make this row
87286     ** then there should be a single item on the stack.  Write this
87316     /* If this is a scalar select that is part of an expression, then
87380 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
87383 ** then the KeyInfo structure is appropriate for initializing a virtual
87421 ** then the results were placed in a sorter.  After the loop is terminated
87577         ** cause this condition to run.  Since then, we have restructured how
87603           /* If iCol is less than zero, then the expression requests the
87981 ** the limit and offset.  If there is no limit and/or offset, then 
88100 ** So if this routine is called with p equal to the t3 query, then
88411           /* If [0] is unused then [1] is also unused.  So we can
88443 ** If regPrev>0 then it is the first register in a vector that
88445 ** if there has been no previous output.  If regPrev>0 then code is
88508     ** then there should be a single item on the stack.  Write this
88534     /* If this is a scalar select that is part of an expression, then
88559     /* If none of the above, then the result destination must be
88648 ** subroutines first, then put the control logic at the bottom.  Like this:
88671 ** until all data is exhausted then jump to the "end" labe.  AltB, AeqB,
89117 ** subquery first and store the results in a temporary table, then
89190 **  (18)  If the sub-query is a compound select, then all terms of the
89197 **  (20)  If the sub-query is a compound select, then it must not use
89302   ** subquery is the right term of a LEFT JOIN, then do not flatten.
89308   /* Restriction 17: If the sub-query is a compound SELECT, then it must
89347   /* If the sub-query is a compound SELECT statement, then (by restrictions
89443   ** then this loop only runs once.
89474     ** then expand the outer query to make space for it to hold all elements
89621 ** does match this pattern, then a pointer to the Table object representing
89649 ** INDEXED BY clause, then try to locate the specified index. If there
89722   ** then create a transient table structure to describe the subquery.
89918 ** When this routine is the Walker.xExprCallback then expression trees
89920 ** when this routine is used for Walker.xExprCallback then 
90176 **                     in register pDest->iParm then abandon the rest
90210 ** encountered, then an appropriate error message is left in
90249     /* If ORDER BY makes no difference in the output then neither does
90364   ** identical, then disable the ORDER BY clause since the GROUP BY
90375   /* If there is an ORDER BY clause, then this sorting
90377   ** extracted in pre-sorted order.  If that is the case, then the
90427     ** instruction ended up not being needed, then change the OP_OpenEphemeral
90557         ** then loop over the sorting index in order to get the output
90631       ** over to a0,a1,a2.  It then calls the output subroutine
90705         /* If isSimpleCount() returns a pointer to a Table structure, then
90730         ** does, then we can assume that it consumes less space on disk and
90764         ** If it is, then ask the code in where.c to attempt to sort results
90766         ** If where.c is able to produce results sorted in this order, then
90775         **   + If the query is a "SELECT min(x)", then the loop coded by
90826   /* If there is an ORDER BY clause, then we need to sort the results
91018   /* If this is the first row, then generate an extra row containing
91256     /* If TEMP was specified, then the trigger name may not be qualified. */
91272   ** then set iDb to 1 to create the trigger in the temporary database.
91750 ** then return TRUE.  If pIdList==NULL, then it is considered a
91751 ** wildcard that matches anything.  Likewise if pEList==NULL then
91842     ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
92061   ** process of being coded). If this is the case, then an entry with
92119 ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
92128 ** (a copy of pTab->nCol), then registers are populated as follows:
92208 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
92286 ** command. If the latter, then the row-records in the table btree on disk
92289 ** If the former, then all row-records are guaranteed to include a value
92590     ** action, then we need to open all indices because we might need
92626   ** for example, then jump to the next iteration of the RowSet loop.  */
92631   ** then regNewRowid is the same register as regOldRowid, which is
92663   ** If there are one or more BEFORE triggers, then do not populate the
92840 ** as (B) we only store (A), then duplicate (A) when pulling
93181   ** transaction is then committed, so the SQL level never knows it was
93391 ** Except, if argument db is not NULL, then the entry associated with
93442 **      or, if the virtual table is stored in a non-sharable database, then
93589   ** created now instead of just being read out of sqlite_master) then
94065   ** than zero, then this function is being called from within a
94100 ** If pExpr is a column in a virtual table, then let the virtual
94254 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
94269 ** categories, then eOperator==0.  The WhereTerm.pExpr field is still set
94423 ** is set to WO_IN|WO_EQ.  The WhereLevel.wsFlags field can then be used as
94425 ** ISNULL constraints will then not be used on the right table of a left
94515 ** If the wtFlags argument includes TERM_DYNAMIC, then responsibility
94895           ** function, then no OP_Variable will be added to the program.
94922 ** If it is then return TRUE.  If not, return FALSE.
94948 ** a join, then transfer the appropriate markings over to derived.
94983 ** a single table T (as shown in example B above) then create a new virtual
94989 ** then create a new virtual term like this:
94995 ** If all subterms are indexable by a single table T, then set
95029 ** If neither case 1 nor case 2 apply, then leave the eOperator set to
95206           /* If the right-hand side is also a column, then the affinities
95276 ** columns, then the original expression is unchanged and a new virtual
95642         ** then the index cannot satisfy the ORDER BY constraint.
95665       ** tables in the join, then we are assured that the index can be used 
95683     ** clause reference other tables in a join.  If this is all true then
95710 ** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines
95873 ** is taken into account, then alter the query plan to use the
96122   ** virtual table then allocate space for the aOrderBy part of
96281   ** allocated and initialized, then allocate and initialize it now.
96314   ** and we are evaluating a join, then the constraint on column is 
96368   ** inital value of lowestCost in this loop. If it is, then the
96535 ** If either of the upper or lower bound is not present, then NULL is passed in
96545 ** then nEq should be passed the value 1 (as the range restricted column,
96550 ** then nEq should be passed 0.
96656 ** the SQL statement, then this function only considers plans using the 
96657 ** named index. If no such plan is found, then the returned cost is
96659 ** then the cost is calculated in the usual way.
96662 ** in the SELECT statement, then no indexes are considered. However, the 
96688   /* If the pSrc table is the right table of a LEFT JOIN then we may not
96748     ** scan being evaluated. They are then used to determine the expected
96770     **    If there exists a WHERE term of the form "x IN (SELECT ...)", then 
96997     /* If this index is the best we have seen so far, then record this
97011     /* If there was an INDEXED BY clause, then only that one index is
97021   ** is set, then reverse the order that the index will be scanned
97122 ** SQLITE_AFF_NONE, then no code gets generated.
97241 ** key value of the loop.  If one or more IN operators appear, then
97282   /* Figure out how many memory cells we will need then allocate them.
97543     **         index is on (x,y,z), then the following clauses are all 
97558     **         If there are no inequality constraints, then N is at
97603     ** query, then the caller will only allow the loop to run for
98084 **      if flag==0 then
98094 ** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL.
98097 ** scan is correct for the ORDER BY clause, then that index is used and
98103 ** output order, then the *ppOrderBy is unchanged.
98136   ** pTabList.  But if the WHERE_ONETABLE_ONLY flag is set, then we should
98189   ** the case that if X is the bitmask for the N-th FROM clause term then
98283     ** its query plan, then checking to see if that query plan uses any
98285     ** used then the "optimal" query plan works.
98339         /* If an INDEXED BY clause is present, then the plan must use that
98407     ** used for the scan. If not, then query compilation has failed.
98428   /* If the total query only selects a single row, then the ORDER BY
98918 **                       defined, then do no error processing.
99005 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
99494 ** appears in the grammar, then ID becomes a fallback token for X, Y,
99624 **      If NULL, then tracing is turned off.
99626 **      line of trace output.  If NULL, then tracing is
100196 ** is popped from the stack, then call it.
100261 ** If the look-ahead token is YYNOCODE, then check to see if the action is
100326 ** If the look-ahead token is YYNOCODE, then check to see if the action is
101921     ** one element off the stack, then we can push the new element back
102085       **    it is legal to shift the error symbol, then shift
102131       /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
102147       **  * If the input token is $, then fail the parse.
102228 ** named keywordhash.h and then included into this source file by
102509 ** If X is a character that can be used in an identifier then
102824 ** then an and attempt is made to write an error message into 
103094   /* If triggers are not supported by this compile then the statement machine
103385 ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
103394 ** name of a directory, then that directory will be used to store
103415 ** thread has finished the initialization process, then the subsequent
103443   /* If SQLite is already completely initialized, then this call
103488   /* If rc is not SQLITE_OK at this point, then either the malloc
103563 ** when this routine is invoked, then this routine is a harmless no-op.
103696         /* If the heap pointer is NULL, then restore the malloc implementation
103703         /* The heap pointer is not NULL, then install one of the
103756 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
103856 ** If the padFlag argument is not NULL then space padding at the end
104329   ** and there are active VMs, then return SQLITE_BUSY. If a function
104408 ** If the function already exists as a regular global function, then
104409 ** this routine is a no-op.  If the function does not exist, then create
104478 ** If the invoked function returns non-zero, then the commit becomes a
104641 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
104697 ** driver.  If zFilename is the name of a file, then that file is
104698 ** opened and used.  If zFilename is the magic name ":memory:" then
104700 ** the connection is closed.)  If zFilename is NULL then the database
104711   int omitJournal,          /* if TRUE then do not journal this file */
104811     ** above. If this is the case, then the db->mallocFailed flag needs to
104893     ** then any copies made by synthCollSeq() need to be invalidated.
105658     ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
105735     ** is enabled, then the return value is true.  If X is true and
105736     ** assert() is disabled, then the return value is zero.  If X is
105737     ** false and assert() is enabled, then the assertion fires and the
105738     ** process aborts.  If X is false and assert() is disabled, then the
105759     ** default setting.  If the return value is 1, then ALWAYS() is either
105815     ** If zWord is a keyword recognized by the parser, then return the
105897 **   3) If the argument db is not NULL, then none of the entries in the
105982 ** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
105989 ** on the same "db".  If xNotify==0 then any prior callbacks are immediately
106060 **      set to db, then set pBlockingConnection=0.
106063 **      set to db, then invoke the configured unlock-notify callback and
106125           ** array already accumulated. We can then clear the array and
106283 ** 234 at I is the next docid.  It has one position 72 (72-2) and then
106405 ** If the root node is a leaf node, then start_block,
106528 ** If tokenizers are to be allowed to call sqlite3_*() functions, then
106570   ** then argc is set to 2, and the argv[] array contains pointers
106574   ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
106925 ** FTS3_FULLTEXT_SEARCH.  If so, then Fts3Cursor.eSearch - 2 is the index
106935 ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
106962 ** is true, then aDoclist points to a malloced buffer, size nDoclist bytes, 
107146 ** input does not begin with a quote character, then this routine
107165     /* If the first byte was a '[', then the close-quote character is a ']' */
107193 ** As long as *pp has not reached its end (pEnd), then do the same
107234 ** and then evaluate those statements.  The success code is writting
107237 ** If *pRc is initially non-zero then this routine is a no-op.
107321 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
107686         /* If no row was found and no error has occured, then the %_content
107802       ** to the term from the interior node, then all terms on the sub-tree 
107806       ** If the interior node term is larger than the specified term, then
107855 ** If pp is not NULL, then the contents of the position list are copied
107865   ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
107901 ** If pp is not NULL, then the contents of the column-list are copied
108525 ** value of parameter isReqPos. If isReqPos is zero, then the doclist is
108527 ** is non-zero, then the returned list is in the same format as is stored 
108591       ** not reset here, then it may remain classified as an active statement 
108895 ** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against
108898 ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
108901 ** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index.  The
109162 ** sizeof(Fts3Cursor*), then the blob contents are copied to the 
109436 ** of the sqlite library, then this function is called directly by
109548 ** is defined, then it uses the new syntax. The differences between
109562 ** If compiled with SQLITE_TEST defined, then this module exports the
109703 ** then free the old allocation.
109937   /* See if we are dealing with a quoted phrase. If this is the case, then
110202 ** If parameter n is a negative number, then z is assumed to point to a
110755 ** If no element exists with a matching key, then a new
110759 ** If another element already exists with the same key, then the
110761 ** The key is not copied in this instance.  If a malloc fails, then
110764 ** If the "data" parameter to this function is NULL, then the
111082 ** of the word that preceeds the zFrom ending, then change the 
111114 ** it contains digits) then word is truncated to 20 or 6 bytes
111157 ** in [a-zA-Z] then no stemming is attempted and this routine just 
111516 ** to the string <key-name>. If <pointer> is not specified, then
112034   ** track such information in the database, then we'd only want this
112362 ** If argument apVal is not NULL, then it must point to an array with
113037 ** If arguments ppOffsetList and pnOffsetList are not NULL, then 
113834   ** If the isCopyTerm parameter is true, then the buffer pointed to by
114028 ** If there are no entries in the input position list for column iCol, then
114146   ** for, then advance each segment iterator until it points to a term of
114169     ** to does not share a suffix with pFilter->zTerm/nTerm, then all 
114952 ** NEAR operators (and is not the left-most of said series), then elements are
115036 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable 
115039 ** pnToken is not NULL, then it is set to the number of tokens in all
115304 ** If nAppend is negative, then the length of the string zAppend is
115638     /* If Fts3Cursor.aMatchinfo[] is NULL, then this is the first time the
116185 **   1. If the node is the root node (node 1), then the first 2 bytes
116550 ** an internal node, then the 64-bit integer is a child page number.
116797 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
117067 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
117113       ** and then a linear search of an R-Tree node. This should be 
118639 ** If this function is being called as part of an xConnect(), then the rtree
119106 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
119128   ** then the result is also NULL. 

Indexes created Thu Aug 15 21:26:39 MDT 2024