13 ** the "sqlite3.h" header file at hand, you will find a copy embedded within
188 ** defined; otherwise, detection of conditions specific to MinGW will be
311 ** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
312 ** be larger than the release from which it is derived.  Either Y will
313 ** be held constant and Z will be incremented or else Y will be incremented
314 ** and Z will be reset to zero.
497 ** will leave the database connection open and return [SQLITE_BUSY].
500 ** an unusable "zombie" which will automatically be deallocated when the
843 ** implementations will
941 ** failure to zero-fill short reads will eventually lead to
991 ** layer a hint of how large the database file will grow to be during the
1041 ** anti-virus programs.  By default, the windows VFS will retry file read,
1082 ** reason, the entire database file will be overwritten by the current 
1092 ** all file-control actions, there is no guarantee that this will actually
1107 ** or the equivalent and that string will become the result of the pragma or
1139 ** argument should be a char** which will be filled with the filename
1145 ** maximum number of bytes that will be used for memory-mapped I/O.
1261 ** structure that SQLite will ever modify.  SQLite will only access
1273 ** ^If a suffix is added to the zFilename parameter, it will
1277 ** the string will be valid and unchanged until xClose() is
1283 ** xFilename parameter is NULL it will also be the case that the
1284 ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
1293 ** ^(SQLite will also add one of the following flags to the xOpen()
1313 ** file will be doing page-aligned sector reads and writes in a random
1325 ** will be set for TEMP databases and their journals, transient
1344 ** element will be valid after xOpen returns regardless of the success
1354 ** ^SQLite will always allocate at least mxPathname+1 bytes for the
1374 ** ^SQLite will use the xCurrentTimeInt64() method to get the current
1376 ** greater and the function pointer is not NULL) and will fall back
1428   ** value will increment whenever this happens. 
1488 ** The SQLite core will never attempt to acquire or release a
1522 ** Among other things, ^sqlite3_initialize() will invoke
1524 ** will invoke sqlite3_os_end().
1534 ** calls sqlite3_initialize() so the SQLite library will be automatically
1589 ** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
1684 ** SQLite will never invoke xInit() more than once without an intervening
1709 ** the call worked.  The [sqlite3_config()] interface will return a
1721 ** value of Single-thread and so [sqlite3_config()] will return 
1731 ** are enabled so that SQLite will be safe to use in a multi-threaded
1736 ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1745 ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
1752 ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1793 ** aligned memory buffer from which the scratch allocations will be
1798 ** ^SQLite will not use more than one scratch buffers per thread.
1799 ** ^SQLite will never request a scratch buffer that is more than 6
1803 ** [sqlite3_malloc()] will be used to obtain the memory needed.<p>
1831 ** ^SQLite will use the memory provided by the first argument to satisfy its
1838 ** that SQLite will use for all of its dynamic memory allocation needs
1853 ** boundary or subsequent behavior of SQLite will be undefined.
1866 ** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
1879 ** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
1981 ** will be silently truncated if necessary so that it does not exceed the
2049 ** the call worked.  ^The [sqlite3_db_config()] interface will return a
2060 ** may be NULL in which case SQLite will allocate the
2134 ** method, then this routine will return the [rowid] of the inserted
2147 ** the constraint problem so INSERT OR REPLACE will always change
2197 **        upon completion as normal. Of course, this value will not include 
2199 **        value will be saved and restored after each sub-trigger has run.)^
2261 ** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
2264 ** will be rolled back automatically.
2278 ** is running then bad things will likely happen.
2301 ** will not detect syntactically incorrect SQL.
2306 ** then the return value from sqlite3_complete16() will be non-zero
2345 ** The presence of a busy handler does not guarantee that it will be invoked
2347 ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
2356 ** invoke the busy handlers, neither will make any progress.  Therefore,
2358 ** will induce the first process to release its read lock and allow
2366 ** or evaluating [PRAGMA busy_timeout=N] will change the
2385 ** will sleep multiple times until at least "ms" milliseconds of sleeping
2519 ** written will be n-1 characters.
2576 ** The code above will render a correct SQL statement in the zSQL
2756 ** the authorizer will fail with an error message.
2761 ** authorizer will fail with an error message explaining that
2803 ** The authorizer callback must not do anything that will modify
2851 ** callback function will be parameters or NULL depending on which of these
2954 ** The progress handler callback must not do anything that will modify
2972 ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
2979 ** ^The default encoding will be UTF-8 for databases created using
2981 ** created using sqlite3_open16() will be UTF-16 in the native byte order.
3034 ** is created for the connection.  ^This in-memory database will vanish when
3042 ** on-disk database will be created.  ^This private database will be
3278 ** When that happens, the second error will be reported since these
3486 ** always used to do, [sqlite3_step()] will automatically recompile the SQL
3488 ** retries will occur before sqlite3_step() gives up and returns an error.
3492 ** ^When an error occurs, [sqlite3_step()] will return one of the detailed
3503 ** then the statement will be automatically recompiled, as if there had been 
3615 ** will accept either a protected or an unprotected sqlite3_value.
3651 ** The application-defined SQL function implementation will pass this
3714 ** the value of the fourth parameter then the resulting string value will
3748 ** then the call will return [SQLITE_MISUSE].  If any sqlite3_bind_()
3792 ** parameter. For all forms except ?NNN, this will correspond to the
3999 ** interface will continue to be supported.
4001 ** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
4077 ** will return non-zero if previous call to [sqlite3_step](P) returned
4240 ** that the prior pointer references will have been modified.  Other kinds
4271 ** pointer.  Subsequent calls to [sqlite3_errcode()] will return
4365 ** will result in [SQLITE_MISUSE] being returned.
4386 ** will pick the one that involves the least amount of data conversion.
4389 ** to signal that the function will always return the same result given
4420 ** arguments or differing preferred text encodings.  ^SQLite will use
4501 ** these functions, we will not explain what they do.
4616 ** the same aggregate function instance will not resize the memory
4688 ** SQLite will invoke the destructor function X with parameter P exactly
4722 ** and will never change.  It does not need to be destroyed.  ^The
4723 ** SQLITE_TRANSIENT value means that the content will likely change in
4819 ** parameter, then the resulting string will contain embedded NULs and the
4904 ** with different eTextRep parameters and SQLite will use whichever
5032 ** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
5050 ** activated, none of the SEE routines will work.
5060 ** activated, none of the CEROD routines will work.
5074 ** millisecond time resolution, then the time will be rounded up to
5092 ** will be placed in that directory.)^  ^If this variable
5150 ** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
5230 ** will be an absolute pathname, even if the filename used
5283 ** The callback implementation must not do anything that will modify
5289 ** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
5345 ** The update hook implementation must not do anything that will modify
5391 ** and will always return SQLITE_MISUSE. On those systems, 
5441 ** below the limit, it will exceed the limit rather than generate
5476 ** applications will achieve adequate soft heap limit enforcement without
5479 ** The circumstances under which SQLite will enforce the soft heap limit may
5590 ** ^(zProc may be 0, in which case SQLite will try to come up with an
5606 ** otherwise an error will be returned.
5657 ** is NULL before calling the xEntryPoint().  ^SQLite will invoke
5660 ** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail.
5664 ** will be called more than once for each database connection that is opened.
5696 ** When the virtual-table mechanism stabilizes, we will declare the
5803 ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
5814 ** will be returned by the strategy.
5885 ** is a pointer to a destructor for the pClientData.  ^SQLite will
5887 ** no longer needs the pClientData pointer.  ^The destructor will also
5913 ** of the [virtual table].  Each subclass will
5922 ** is delivered up to the client application, the string will be automatically
5923 ** freed by sqlite3_free() and the zErrMsg field will be zeroed.
5929   /* Virtual table implementations will typically add additional fields */
5943 ** of the module.  Each module implementation will define
5951   /* Virtual table implementations will typically add additional fields */
5989 ** When the virtual-table mechanism stabilizes, we will declare the
6065 ** rolled back by the expiration of the BLOB.  Such changes will eventually
6317 ** not want to.  SQLite will only request a recursive mutex in
6343 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
6354 ** will always return SQLITE_BUSY. The SQLite core only ever uses
6435 ** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
6551 ** code is not remembered and will not be recalled by [sqlite3_errcode()]
6778 ** The [sqlite3_db_status()] interface will return a non-zero error code
6957 ** page cache.  The page cache will allocate instances of this
7017 ** ^SQLite will never invoke xInit() more than once without an intervening
7022 ** SQLite will typically create one cache instance for each open database file,
7025 ** be allocated by the cache.  ^szPage will always a power of two.  ^The
7027 ** associated with each page cache entry.  ^The szExtra parameter will
7028 ** a number less than 250.  SQLite will use the
7033 ** created will be used to cache database pages of a file stored on disk, or
7036 ** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
7039 ** false will always have the "discard" flag set to true.  
7040 ** ^Hence, a cache created with bPurgeable false will
7058 ** The pBuf element of the returned sqlite3_pcache_page object will be a
7060 ** single database page.  The pExtra element of sqlite3_pcache_page will be
7083 ** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  SQLite
7084 ** will only use a createFlag of 2 after a prior call with a createFlag of 1
7119 ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
7220 ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
7223 ** ^A call to sqlite3_backup_init() will fail, returning SQLITE_ERROR, if 
7241 ** ^Function sqlite3_backup_step(B,N) will copy up to N pages between 
7290 ** used by the backup operation, then the backup will be automatically
7384 ** ^This API may be used to register a callback that SQLite will invoke 
7400 ** the first argument to register for a callback that will be invoked
7406 ** there is a chance that the blocking connection will have already
7458 ** will proceed and the system may remain deadlocked indefinitely.
7540 ** will not use dynamically allocated memory.  The log message is stored in
7542 ** a few hundred characters, it will be truncated to the length of the
7567 ** code is returned, that error will propagate back up through the
7569 ** to report an error, though the commit will have still occurred. If the
7578 ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
7671 **   that the next writer will restart the log file from the beginning.
7688 ** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been
7689 ** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero.
7694 ** busy-handler configured, it will not be invoked in this case.
7790 ** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before
7850 ** managed by the prepared statement S and will be automatically freed when
7855 ** <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be
7859 ** <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be set
7863 ** <dd>^The "double" variable pointed to by the T parameter will be set to the
7866 ** then this value will approximate the quotient NVISIT/NLOOP and the
7867 ** product of this value for all prior loops with the same SELECTID will
7871 ** <dd>^The "const char *" variable pointed to by the T parameter will be set
7876 ** <dd>^The "const char *" variable pointed to by the T parameter will be set
7881 ** <dd>^The "int" variable pointed to by the T parameter will be set to the
8126 ** The hard upper limit here is 32676.  Most database people will
8220 ** The maximum value of a ?nnn wildcard that the parser will accept.
8234 ** compiled with the default page-size limit will not be able to rollback 
8259 ** SQLite will choose on its own.
8292 ** A value of 1 means that a trigger program will not be able to itself
8425 ** will cause HeapValidate to be called.  If heap validation should fail, an
8426 ** assertion will be triggered.
8528 ** code within VVA_ONLY() will only run during verification processes.
8548 ** be true and false so that the unreachable code they specify will
8959 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
9239 ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
9298 ** pointer will work here as long as it is distinct from SQLITE_STATIC
9563 ** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or
9565 ** selected will all have the same key.  In other words, the cursor will
10154 ** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch()
10591 ** the SQLite library will work on both POSIX and windows systems.
10628 ** SQLITE_OS_WIN, and SQLITE_OS_OTHER will defined to either 1 or 0.  One of
10629 ** the three will be 1.  The other two will be 0.
10698 ** enough to know that calling the developer will not help get rid
10750 ** will support two or more Win95 readers or two or more WinNT readers.
10751 ** But a single Win95 reader will lock out all WinNT readers and a single
10752 ** WinNT reader will lock out all other Win95 readers.
10770 ** that all locks will fit on a single page even at the minimum page size.
10989 ** changes and so the view will need to be reset.
11488 ** used as the P4 operand, they will be more readable.
11632 ** done as a macro so that it will be optimized out when virtual
11995 ** help reduce memory requirements, sometimes an Expr object will be
11997 ** two or more Expr objects will be stored in a single memory allocation,
12018   ** access them will result in a segfault or malfunction. 
12030   ** access them will result in a segfault or malfunction.
12828 ** do not necessarily know how big the string will be in the end.
13096 ** The alloca() routine never returns NULL.  This will cause code paths
14129 ** Changing the pending byte during operation will result in undefined
14619 ** The maximum number of times that a statement will try to reparse
14689   ** Vdbe.cacheCtr.  Vdbe.cacheCtr will never take on the value of
15141 /* The "wsdStat" macro will resolve to the status information
15862 ** routine will always fail.
16820   /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
16823   ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
16995 ** hash table will continue to function normally.  So a malloc failure 
17012 /* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks
17077 ** here always fail.  SQLite will not operate with these drivers.  These
17079 ** sqlite3_config() before SQLite will operate.
17138 ** SQLite will use the standard C-library malloc/realloc/free interface
17247 ** cases of nByte<=0 will be intercepted and dealt with by higher level
17279 ** cases where pPrior==0 will have been intecepted and dealt with
17316 ** cases where nByte<=0 will have been intercepted by higher-level
17436 ** SQLite will use the standard C-library malloc/realloc/free interface
17614     /* If memory status is enabled, then the malloc.c wrapper will already
17984 ** mean that the library will use a memory-pool by default, just that
18172 ** will already be held (obtained by code in malloc.c) if
18686 ** proved that this memory allocator will never breakdown due to 
18830 ** will already be held (obtained by code in malloc.c) if
19539 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
19563 ** is not currently allocated.  SQLite will never do either.
19669 ** will not always work correctly on HPUX.
19695 ** will unwind its stack and return an error.  The argument
19720 ** not want to.  But SQLite will only request a recursive mutex in
19760         /* If recursive mutexes are not available, we will have to
19823 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
19843   ** are not met, then the mutexes will fail and problems will result.
19886   ** are not met, then the mutexes will fail and problems will result.
19928 ** is not currently allocated.  SQLite will never do either.
20118   ** stub function.  You will lose timing support for many
20144 ** of code will give us the ability to simulate a disk I/O error.  This
20418 ** will unwind its stack and return an error.  The argument
20443 ** not want to.  But SQLite will only request a recursive mutex in
20526 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
20572   ** For that reason, we will omit this optimization for now.  See
20605 ** is not currently allocated.  SQLite will never do either.
20702   ** The alarm callback and its arguments.  The mem0.mutex lock will
20704   ** the memory subsystem are allowed, but no new callbacks will be
20960     ** 255 bytes of overhead.  SQLite itself will never use anything near
21037   /* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch
21572 ** conversions will work.
22355 **        allocations will ever occur.
23013   /* The "wsdPrng" macro will resolve to the pseudo-random number generator
23995   **      The compiler [with /fp:precise] will properly handle comparisons 
24000 # error SQLite will not work correctly with the -ffast-math option of GCC.
24017 ** The value returned will never be negative.  Nor will it ever be greater
24156 ** there is no consistency, we will define our own.
24390 ** will return -8.
24532 ** If zNum represents an integer that will fit in 32-bits, then set
24626 ** The length of data write will be between 1 and 9 bytes.  The number
24978 ** Return the number of bytes that will be needed to store the given
25179     /* If both iA1 and iB1 are non-zero, overflow will result */
25431   ** only zeroes the requested number of bytes whereas this module will
25982   ** whenever any part of the database changes.  An assertion fault will
26003 ** indicating that a fork() has occurred, the PRNG will be reset.
26149   ** stub function.  You will lose timing support for many
26175 ** of code will give us the ability to simulate a disk I/O error.  This
26287 ** On some systems, calls to fchown() will trigger a message in a security
26531 ** The m parameter will be non-zero only when creating -wal, -journal,
26536 ** process that is able to write to the database will also be able to
26725   ** will be handled by the "default:" case below.
26888   /* No match was found.  We will make a new file ID */
26942 ** among competing threads of the same process.  POSIX locks will work fine
26965 ** a reference count (so we will know when to delete it) and a "cnt"
27003 ** was dropped beginning with version 3.7.0.  SQLite will still work with
27067 ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). 
27099   ** available, the error message will often be an empty string. Not a
27457 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
27562   ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
27743     ** the lock in 2 blocks, so that part of the range will be covered by a 
27891 ** even on VxWorks.  A mutex will be acquired on VxWorks by the
27943     ** descriptor to pInode->pUnused list.  It will be automatically closed 
28081 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
28310 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
28487 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
28732 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
28796   ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
29029       ** descriptor to pInode->aPending.  It will be automatically closed when
29093 ** in any form by default, we will not attempt to define _XOPEN_SOURCE.
29358 ** Others do no.  To be safe, we will stick with the (slightly slower)
29387 ** or power failure will likely corrupt the database file.
29393 ** Ted Ts'o tells us that fdatasync() will also write the inode if the
29395 ** and fsync(), Ted tells us, is that fdatasync() will not flush the
29522 ** SQLite to access the file will not know that the journal exists (because
29524 ** will not roll back - possibly leading to database corruption.
29610     ** mapped region, reduce the effective mapping size as well. SQLite will
29848 ** a database and its journal file) that the sector size will be the
30196 ** for shared memory will be called "/home/user1/config.db-shm".  
30209 ** same database file at the same time, database corruption will likely
30221 ** file is created.  The shared memory will be simulated with heap memory.
30250     ** a new *-shm file is created, an attempt will be made to create it
30301       ** the original owner will not be able to connect.
30420         ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
30586     /* Make sure no sibling connections hold locks that will block this
30781     ** will probably fail too. Fall back to using xRead/xWrite exclusively
31291       ** handle h - as it is guaranteed that no posix locks will be released
31502   ** almost certain that an open() call on the same path will also fail.
31504   ** ignored and -1 is returned. The caller will try to open a new file
31539 ** In most cases, this routine sets *pMode to 0, which will become
31657   /* If creating a master or main-file journal, this function will open
31659   ** is called the directory file descriptor will be fsync()ed and close()d.
31862           ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op 
32057   ** other hand, dlsym() will not work on such a system either, so we have
32290 ** host ID in it, the proxy path in the conch file will be used, otherwise
32292 ** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
32297 **       The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
32327 ** will fail and SQLITE_BUSY is returned.
32371 ** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will
32373 ** will force automatic proxy locking to be disabled for all database
32489     int islockfile           /* if non zero missing dirs will be created */
32757 ** lockPath means that the lockPath in the conch file will be used if the 
32758 ** host IDs match, or a new lock path will be generated automatically 
32856       /* update conch with host and path (this will fail if other process
33111 ** will be performed on the local proxy lock file.  The following fields
33149       ** that openFlags will have only one of O_RDONLY or O_RDWR.
33228           ** switching proxy locking mode off then it will need to fail if
33313 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
33669   ** stub function.  You will lose timing support for many
33695 ** of code will give us the ability to simulate a disk I/O error.  This
34032  * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the
34038  * If this is non-zero, an isolated heap will be created by the native Win32
34039  * allocator subsystem; otherwise, the default process heap will be used.  This
34041  * and an isolated heap will be created to store all allocated data.
34046  *          function), all data that was allocated using the isolated heap will
34048  *          data will almost certainly result in an immediate access violation.
34909 ** If a Win32 native heap has been configured, this function will attempt to
34910 ** compact it.  Upon success, SQLITE_OK will be returned.  Upon failure, one
34911 ** of SQLITE_NOMEM, SQLITE_ERROR, or SQLITE_NOTFOUND will be returned.  The
34912 ** "pnLargest" argument, if non-zero, will be used to return the size of the
34950 ** If a Win32 native heap has been configured, this function will attempt to
34952 ** the sqlite3_memory_used() function does not return zero, SQLITE_BUSY will
34953 ** be returned and no changes will be made to the Win32 native heap.
35071 ** WinNT/2K/XP so that we will know whether or not we can safely call
35477 ** argument is the name of the directory to use.  The return value will be
35601 ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
35632 ** will be retried following a locking error - probably caused by
35654 ** is defined, it will be consulted only when the macro "winIoerrCanRetry1"
36452   ** mapped region, reduce the effective mapping size as well. SQLite will
36717 ** This routine will only increase a lock.  The winUnlock() routine
37077 ** a database and its journal file) that the sector size will be the
37095 ** Windows will only let you create file view mappings
37540     /* Make sure no sibling connections hold locks that will block this
37644       ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
38018   /* caller will handle out of memory */
38039   /* caller will handle out of memory */
38610 ** will open a journal file shortly after it is created in order to do
38612 ** file open, we will be unable to delete it.  To work around this
38823   ** so that callers of this function will simply use it verbatim.
38848 ** pathname into zOut[].  zOut[] will be at least pVfs->mxPathname
39259 ** Not supplying an error message will have no adverse effect
39268 ** However if an error message is supplied, it will be incorporated
39411 ** it will be aligned within the Bitvec struct. */
39451 ** a hash table that will hold up to BITVEC_MXHASH distinct values.
40041 ** callback to spill dirty pages to the journal.  It will then try to
40042 ** allocate the new page and will only fail to allocate a new page on
41181   PGroup *pGroup;       /* The group the new page cache will belong to */
41359 ** the calling function (pcache.c) will never have a createFlag of 1 on
41730 ** will only see elements that were inserted before the last change
41733 ** value added by the INSERT will not be visible to the second TEST.
41735 ** a non-zero batch number, it will see all prior INSERTs.
41737 ** No INSERTs may occurs after a SMALLEST.  An assertion will fail if
42423 **     journal is rolled back, the resulting database file will be logically
42429 **     method is a no-op, but that does not change the fact the SQLite will
42433 **     of bytes from 24 through 39 inclusive will be changed prior to releasing
42616 **      commit the transaction. If an error did occur, the caller will need
42819 **   logic into thinking that it already has all the locks it will ever
42866 **   is cleared anyway (and the pager will move to ERROR state).
43114 ** the value of MEMDB will be a constant and the compiler will optimize
43794   ** that will be implicitly filled in by the OS).
43799   ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
44010   ** will not be able to find the master-journal name to determine 
44093 ** or not, any journal file left in the file-system will be treated
44181 ** all major API calls on the Pager will immediately return Pager.errCode.
44222 ** transaction. Nor will it be considered to be a hot-journal by this
44316       ** the database file, it will do so using an in-memory journal. 
44388 ** call to pager_unlock() will discard all in-memory pages, unlock
44392 ** will roll it back.
44395 ** malloc error occurs during a rollback, then this will itself cause 
44396 ** the pager to enter the ERROR state. Which will be cleared by the
44428 ** scenario is that one end or the other of the record will be changed. 
44429 ** It is much less likely that the two ends of the journal record will be
44645     ** will be read from the database file, which may or may not be 
44683       ** as clean, since there will be no need to write it out to the
44690       ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is
44693       ** again within this transaction, it will be marked as dirty but
44694       ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
44920 ** of the open database file. The sector size will be used 
44949     ** call will segfault. */
44994 ** in this case.  But for things like temporary table (which will be
45140           ** code.  This will cause the pager to enter the error state
45141           ** so that no further harm will be done.  Perhaps the next
45142           ** process to come along will be able to rollback the database.
45168   ** mode, then subsequent transactions performed by the connection will not
45190     /* If there was a master journal and this routine will return success,
45247       ** that will never be a valid file version.  dbFileVers[] is a copy
45379 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
45404     ** They will never be read by any client. So remove them from the pDirty
45650   ** will be skipped automatically.  Pages are added to pDone as they
45695   ** will be skipped.  Out-of-range pages are also skipped.
45779 **              assurance that the journal will not be corrupted to the
45849 ** or some other error code if we fail. The OS will automatically 
46004 ** during rollback and will be overwritten whenever a rollback
46172 ** truncation will be done when the current transaction is committed.
46223 ** The new object will use the pointer pData, obtained from xFetch().
46302 ** with this page cache after this function returns will likely
46335     ** back or finalize it. The next database user will have to do hot-journal
46451         ** problematic header will occur, if it exists. aMagic is used 
46575   ** file size will be.
46908       ** the database being opened will be more than pVfs->mxPathname
46910       ** as it will not be possible to open the journal file or even
47121   /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
47174 ** case this routine will return a false-positive. The pager_playback()
47175 ** routine will discover that the journal file is not really hot and 
47176 ** will not roll it back. 
47210     ** in fact there is none.  This results in a false-positive which will
47261             ** automatic journal playback and recovery mechanism will deal
47350       ** other process attempting to access the database file will get to 
47364       ** in exclusive-access mode the file descriptor will be kept open 
47415         ** pager_unlock() routine will be called before returning to unlock
47423         ** since we know that the same call to pager_unlock() will very
47452       ** There is a vanishingly small chance that a change will not be 
47567 ** will not be journaled. This saves IO.
47753 ** and sqlite3PagerGet() is that _get() will go to the disk and read
47896 ** within this transaction will be opened as an in-memory file. This
47928       ** holds the write-lock. If possible, the upper layer will call it.
47991   ** playback_one_page() will think that the page needs to be restored
48280 ** page data. In this case the file will be updated when the current
48348           ** next time a read transaction is opened the cache will be
48349           ** flushed (as the change-counter values will not match).  */
48506       ** in 'direct' mode. In this case the journal file will never be
48521         ** following call will modify the in-memory representation of page 1 
48546       ** If the atomic-update optimization is being used, this sync will not 
48554       ** xSync() call will be changed to a no-op by the OS anyhow. 
48599 ** though, and if a failure occurs at this point it will eventually
48630   ** a hot-journal during hot-journal rollback, 0 changes will be made
48699       ** Any active readers will get SQLITE_ABORT.
48916     /* Figure out how many savepoints will still be active after this
49062 ** pPg refers to will not be written to again within this transaction.
49285   ** the logic there will never allow a temporary file to be changed
49477   /* If the pager is already in exclusive-mode, the WAL module will use 
49578   ** the database file, the log and log-summary files will be deleted.
49726 ** and ignores the newly appended content, it will see a consistent snapshot
49804 ** the mapping section.  (For index blocks other than the last, K will
49806 ** K will be (mxFrame%HASHTABLE_NPAGE).)  Unused slots of the hash table
49844 ** K>K0 but to the first reader, those entries will appear to be unused
49845 ** slots in the hash table and so the first reader will get an answer as
49848 ** second reader using K1 will see additional values that were inserted
49952 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
49958 ** largest value and will increase an unused aReadMark[] to mxFrame if there
49962 ** will choose aReadMark[0] which has value 0 and hence such reader will
49970 ** the writer will first "reset" the WAL back to the beginning and start
50102 ** Changing any of these constants will alter the wal-index format and
50518 ** updated.  Any later hash tables will be automatically cleared when
50581 ** Set an entry in the wal-index that will map database page number
50669 ** WAL_RECOVER_LOCK is also held so that other threads will know
50995 ** The aContent[aLeft[X]] values will be unique for all X.  And the
50996 ** aContent[aRight[X]] values will be unique too.  But there might be
51167   ** of memory will be freed before this function returns.
51280 ** by active readers.  This routine will never overwrite a database page
51286 ** process, foreground threads will never block on a lengthy fsync call.
51294 ** it safe to delete the WAL since the new content will persist in the
51298 ** This is the only routine that will increase the value of nBackfill.  
51299 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
51726 ** This routine will start taking more aggressive measures to clear the
51728 ** number of errors will ultimately return SQLITE_PROTOCOL.  The
51740 ** including frame number aReadMark[pWal->readLock].  The reader will
51742 ** Or if pWal->readLock==0, then the reader will ignore the WAL
51744 ** If the useWal parameter is 1 then the WAL will never be ignored and
51745 ** this routine will always set pWal->readLock>0 on success.
51800       ** WAL_RETRY this routine will be called again and will probably be
51856   /* If we get this far, it means that the reader will want to use
51936 ** instant in time.  The current thread will continue to use this snapshot.
51942 ** Pager layer will use this to know that is cache is stale and
51992   ** no data will be read from the wal under any circumstances. Return early
52282         ** frames will overwrite the start of the existing log. Update the
52609     ** it will not be invoked in this case.
52889 ** is to limit the maximum cell size so that at least 4 cells will fit
53023 ** small cells will be rare, but they are possible.
53040 ** the header, then your custom library will not be able to read 
53042 ** will not be able to read databases created by your custom library.
53275 ** this will be declared corrupt. This value is calculated based on a
53680 ** a statement since we will be comparing table and column names
53987   ** read-lock on iTab will suffice. Return 1 if any of these are found.  */
54122   /* A connection with the read-uncommitted flag set will never try to
54317 **      such a page is not even journalled (as it will not be modified,
54784   /* If the payload will not fit completely on the local page, we have
54791   ** way will result in an incompatible file format.
55171 ** will be ignored if adding the extra space to the fragmentation count
55232 ** all the space together, however.  This routine will avoid using
55234 ** allocation is being made in order to insert a new cell, so we will
55322 ** that routine will not detect overlap between cells or freeblocks.  Nor
55537     ** offset to the cell content area will equal the page size minus the
55580         /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
55848       ** call to btreeInitPage() will likely return SQLITE_CORRUPT.
55873 ** Either way, the ephemeral database will be automatically deleted 
55883 ** and we are in shared cache mode, then the open will fail with an
55885 ** objects in the same database connection since doing so will lead
56059       /* If the magic name ":memory:" will create an in-memory database, then
56311 ** value of mxPage.  If mxPage is negative, the pager will
56312 ** operate asynchronously - it will not stop to do fsync()s
56558 ** Get a reference to pPage1 of the database file.  This will
56670       ** zero and return SQLITE_OK. The caller will call this function
56701   ** cells can will fit on one page.  We assume a 10-byte page header.
56845 ** will work unless a transaction is started first:
56930     ** file is not pBt->pageSize. In this case lockBtree() will update
56997     ** the sub-journal is not already open, then it will be opened here.
57215 ** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE 
57246         ** if bCommit is non-zero. In that case, the free-list will be
57507     ** call below will unlock the pager.  */
57539 ** the upper layer will attempt a rollback. However, if the second argument
57542 ** (by deleting a master journal file) and the caller will ignore this 
57545 ** transaction has been closed. This is quite safe, as the pager will have
57548 ** This will release the write lock on the database file.  If there
57655 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
57658 ** a tripped cursor will result in an error.
57660 ** This will release the write lock on the database file.  If there
57815 ** will not work correctly.
57909 ** Initialize memory that will be converted into a BtCursor object.
58370 ** "amt" bytes will be transferred into pBuf[].  The transfer
58390 ** "amt" bytes will be transfered into pBuf[].  The transfer
58423 ** returned will not be a valid pointer.
59010 ** TRUE will be returned after a call to sqlite3BtreeNext() moves
59016   ** have been deleted? This API will need to change to return an error code
59034 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
59035 ** will be 1 if the cursor being stepped corresponds to an SQL index and
59037 ** a unique index.  Otherwise the caller will have set *pRes to zero.
59144 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
59145 ** will be 1 if the cursor being stepped corresponds to an SQL index and
59147 ** a unique index.  Otherwise the caller will have set *pRes to zero.
59248 ** eMode is BTALLOC_LT then the page returned will be less than or equal
59286     ** the entire-list will be searched for that page.
59506     ** Note that the pager will not actually attempt to load or journal 
59622   ** trunk page in the free-list is full, then this page will become a
59623   ** new free-list trunk page. Otherwise, it will become a leaf of the
59650       ** usableSize/4 - 8 entries will be reported as corrupt.  In order
59652       ** we will continue to restrict the number of entries to usableSize/4 - 8
59680   ** will become the new first trunk page in the free-list.
59790 ** area.  pCell might point to some temporary storage.  The cell will
60029 ** If the cell content will fit on the page, then put it there.  If it
60030 ** will not fit, then make a copy of the cell content into pTemp if
60216   /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
60231 ** the page needs to be defragmented before the cells will fit), non-zero
60463 ** tree, in other words, when the new entry will become the largest
60469 ** unbalanced.  But odds are that we will be inserting new entries
60470 ** at the end soon afterwards so the nearly empty page will quickly
60478 ** cell that will be inserted into pParent. Such a cell consists of a 4
60496   /* Allocate a new page. This page will become the right-sibling of 
60522     ** be marked as dirty. Returning an error code will cause a
60776   ** overflow cells in the parent page, since if any existed they will
60827       ** the dropCell() routine will overwrite the entire cell with zeroes.
60829       ** buffer. It will be copied out again as soon as the aSpace[] buffer
60860   /* EVIDENCE-OF: R-28375-38319 SQLite will never request a scratch buffer
60920     ** offset section of the btree page will be overwritten and we will no
61336   ** needs to be tested because (2) will always be true from the previous
61396     ** copied into the parent, because if the parent is page 1 then it will
61488   ** page that will become the new right-child of pPage. Copy the contents
61553         ** next iteration of the do-loop will balance the child page.
61584           ** happens, the next iteration of the do-loop will balance pParent 
61603           ** will balance the parent page to correct this.
61607           ** A subsequent iteration of the do-loop will deal with this by
61612           ** the previous call, as the overflow cell data will have been 
61627           /* The pSpace buffer will be freed after the next call to
61810     ** fails. Internal data structure corruption will result otherwise. 
61852   ** the entry being deleted. This cell will replace the cell being deleted
61993     /* Allocate a page. The page that currently resides at pgnoRoot will
62003       /* pgnoRoot is the page that will be used for the root-page of
62162 ** This routine will fail with SQLITE_LOCKED if there are any open
62203 ** This routine will fail with SQLITE_LOCKED if there are any open
62813     /* For leaf pages, the coverage check will occur in the same loop
63434 **       associated with the source database BtShared structure will always 
63773     ** one now. If a transaction is opened here, then it will be closed
63846         ** round up. In this case the call to sqlite3OsTruncate() below will
63894           ** occurs, the original database will be reconstructed from the 
64451 ** A MEM_Null value will never be passed to this function. This function is
64527 ** will free that value.  It also sets Mem.flags to MEM_Null.
65119 ** The pMem object must have been initialized.  This routine will use
65121 ** pMem->zMalloc space will be allocated if necessary.  The calling routine
65283 ** that function will return to its caller here. Then return a pointer to
65441 ** NULL, it is assumed that the caller will free any allocated object
66030 /* This routine is just a convenient place to set a breakpoint that will
66155 ** This routine will take ownership of the allocated memory.
66184 ** the label is resolved to a specific address, the VDBE will scan
66854 ** routine, then a pointer to a dummy VdbeOp will be returned.  That opcode
66859 ** dummy will never be written to.  This is verified by code inspection and
66863   /* C89 specifies that the constant "dummy" will be initialized to all
67090 ** attached databases that will be use.  A mask of these databases
67092 ** p->btreeMask of databases that will require a lock.
67120 ** statement p will ever use.  Let N be the number of bits in p->btreeMask
67305   ** so far.  The nRow value will increase as new trigger subprograms are
67306   ** encountered, but p->pc will eventually catch up to nRow.
67310     /* The first 8 memory cells are used for the result set.  So we will
67317       /* On the first call to sqlite3_step(), pSub will hold a NULL.  It is
67499 ** The pBuf parameter is the initial value of a pointer which will
67517   void *pBuf,          /* Where return pointer will be stored */
67623   ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
67653   ** pass will fill in the rest using a fresh allocation.  
67715     /* The pCx->pCursor will be close automatically, if it exists, by
67826 ** Set the number of result columns that will be returned by this SQL
67857 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
68027     ** still have 'null' as the master journal pointer, so they will roll
68071     ** master journal file will be orphaned. But we cannot delete it,
68264   ** transaction will be committed or rolled back as a result of the
68467 ** as the first argument to its database handle (so that they will be 
68816 ** of SQLite will not understand those serial types.
68896 ** enabled, some asserts below will ensure that the byte order of
69190     /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
69235   ** But in fact, mem1.u.i will never actually be used uninitialized, and doing 
69256     ** a buffer overread.  The "d1+serial_type1+2" subexpression will
69312 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
70033   /* nCellKey will always be between 0 and 0xffffffff because of the way
70875 ** SQL function that use this routine so that the functions will exist
71116   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
71117   ** and _finalize() will return NOMEM.
71382   ** for a statement, then the statement will be automatically recompiled,
71649 ** will not bother to check for that condition.
72180   /* Find the memory cell that will be used to store the blob of memory
72235 ** will have a MEM_Int representation when bTryForInt is true.
72571   ** stub function.  You will lose timing support for many
72783 ** the switch statement will break with convention and be flush-left. Another
72784 ** big comment (similar to this one) will mark the point in the code where
72790 ** will be filled with #defines that give unique integer values to each
72816 ** The next instruction executed will be 
72897 ** Set up register P1 so that it will Yield to the coroutine
72985 ** For errors, it can be some other value.  If P1!=0 then P2 will determine
73189 ** NULL values will not compare equal even if SQLITE_NULLEQ is set on
73215 ** previously copied using OP_SCopy, the copies will continue to be valid.
73339 ** original and hence if the original changes so will the copy.
73341 ** Thus the program must guarantee that the original will not change
73617 ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
73622 ** max() aggregate will set to 1 if the current row is not the minimum or
74023       /* If SQLITE_NULLEQ is set (which will only happen if the operator is
74530     ** everything will still work.  But OP_Column is measurably faster
74607     ** columns.  So the result will be either the default value or a NULL.
74643       ** content from disk.  NULL will work for the value for strings
74645       ** will work for everything else. */
74783   /* Loop through the elements that will make up the record to figure
75146 ** will automatically commit when the VDBE halts.
75329 ** There will be a read lock on the database whenever there is an
75440     ** that opcode will always set the p2 value to 2 or more or else fail.
75503 ** by this opcode will be used for automatically created transient
75610 ** P3 is the number of fields in the records that will be stored by
75923 ** advanced in the forward direction.  The Next instruction will work,
76023     ** input fields are NULL, since any key with a NULL will not
76065 ** in either direction.  In other words, the Next and Prev opcodes will
76267 ** operation will not attempt to find the appropriate row before doing
76268 ** the insert but will instead overwrite the row that the cursor is
76285 ** value of register P2 will then change.  Make sure this does not
76367 ** The cursor will be left pointing at either the next or the previous
76369 ** the next Next instruction will be a no-op.  Hence it is OK to delete
76379 ** pointing to.  The update hook will be invoked, if it exists.
76393   /* The seek operation that positioned the cursor prior to OP_Delete will
76627 ** that occur while the cursor is on the null row will always
76647 ** will refer to the last entry in the database table or index.
76691 ** rewinding so that the global variable will be incremented and
76707 ** will refer to the first entry in the database table or index.
76757 ** been opened prior to this opcode or the program will segfault.
76978   ** out from under the cursor.  That will never happend for an IdxRowid
77256   /* Any prepared statement that invokes this opcode will hold mutexes
77301 ** of that table into the internal index hash table.  This will cause
77359 ** At most reg(P3) errors will be reported.
77478 ** (b) when P4==-1 there is no need to insert the value, as it will
78100 ** Vacuum the entire database.  This opcode will cause other virtual
78138 ** is executed using sqlite3_step() it will either automatically
78140 ** or it will fail with SQLITE_SCHEMA.
78195 ** code will be set to SQLITE_LOCKED.
78486 ** The xUpdate method will do a DELETE or an INSERT or both.
78814 ** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will 
78886   ** vdbe program will take advantage of the various transaction,
78998         ** key columns must be indexed. The check below will pick up this 
79062       ** does. An OP_Column to retrieve this imaginary column will
79479 ** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will
80364   SortSubtask *pTask,             /* Thread will use this task object */
80937   ** Or will be, anyhow.  */
81022   ** already in memory and (b) the new value will not fit in memory.
81215   SortSubtask *pTask,     /* The thread that will be using the new IncrMerger */
81216   MergeEngine *pMerger,   /* The MergeEngine that the IncrMerger will control */
81334   SortSubtask *pTask,             /* Thread that will run pMerger */
81354       ** in use it will block the vdbePmaReaderNext() call while it uses
81393 ** this entire function is being run by thread (pTask->thread), that will
81645   ** MergeEngine here. This MergeEngine will read data from exactly 
81759             **      root merge (INCRINIT_ROOT) will be using the same task
81803   ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly
82257 ** the FileChunk object will have a size that almost exactly fills
82699 ** column reference is so that the column reference will be recognized as
82766   ** The pExpr->u.zToken might point into memory that will be freed by the
82802 ** and zCol.  If any of zDb, zTab, and zCol are NULL then those fields will
82886   ** schema.  If not found, pSchema will remain NULL and nothing will match
83084     /* Advance to the next name context.  The loop will exit when either
83748         ** sqlite3ResolveOrderGroupBy() will convert the expression to a
83756       ** number so that sqlite3ResolveOrderGroupBy() will convert the
83804   /* Normally sqlite3SelectExpand() will be called first and will have
83806   ** an expression, sqlite3ResolveExprNames() will be called without a
83809   ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
83839     ** moves the pOrderBy down to the sub-query. It will be moved back
83917     ** Minor point: If this is the case, then the expression will be
83933     ** These integers will be replaced by copies of the corresponding result
85137 ** truncated version of the usual Expr structure that will be stored as
85494       testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
85495       testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
85571   ** integer, then the EP_IntValue flag will have already been set */
85609 ** will likely result in an incorrect answer.  So when in doubt, return
85802 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a
85804 ** IN index will be used to loop over all values of the RHS of the
85807 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
85813 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used 
85834 ** the value in that register will be NULL if the b-tree contains one or more
85835 ** NULL values, and it will be some non-NULL value if the b-tree contains no
85895       /* Check that the affinity that will be used to perform the 
85941     ** We will have to generate an ephemeral table to do the job.
85984 ** to NULL.  Calling routines will take care of changing this register
86075         assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
86110           /* If the expression is not constant then we will need to
86233   ** pExpr->iTable will contains the values that make up the RHS.
86372 ** Generate an instruction that will put the floating point
86375 ** The z[] string will probably not be zero-terminated.  But the 
86392 ** Generate an instruction that will put the integer describe by
86466   ** that the object will never already be in cache.  Verify this guarantee.
86604 ** Generate code that will extract the iColumn-th column from
86713 ** With this routine, there is no guarantee that results will
87204       ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
87401 ** Generate code that will evaluate expression pExpr and store the
87421 ** Generate code that will evaluate expression pExpr and store the
87876 ** Sometimes this routine will return 2 even if the two expressions
87935 ** only consequence will be disabled optimizations.  But this routine
87937 ** a malfunction will result.
87957 ** Return true if we can prove the pE2 will always be true if pE1 is
87974 ** it will always give the correct answer and is hence always safe.
88015   ** NEVER() will need to be removed. */
88809   ** one is defined. The xRename() callback will modify the names
88916 ** The generated code will increase the file format number if necessary.
89072 ** Routine sqlite3AlterFinishAddColumn() will be called to complete
89113   ** prefix, we insure that the name will not collide with an existing
89202 ** which the index belongs.  In each such row, the stat column will be
89211 ** a K-column index, there will be K+1 integers in the stat column.  If
89212 ** the index is unique, then the last integer will be 1.
89218 ** the index is unordered and will not use the index for a range query.
89253 ** sqlite_stat4 format will be described first.  Further information
89284 ** The ANALYZE command will typically generate sqlite_stat4 tables
89375         ** because the OpenWrite opcode below will be needing it. */
89860 ** index being analyzed.  The stat_get() SQL function will later be used to
90295         ** row, we know that all the rest will be distinct, so skip 
90391       ** the previous loop.  Thus the not-found jump of seekOp will never
90436 ** Generate code that will cause the most recent index analysis to
90447 ** Generate code that will do an analysis of an entire database
90472 ** Generate code that will do an analysis of a single table in
91085 ** will fail because neither abc or def can be resolved.
91481   Parse *pParse,      /* Error messages will be written here */
91701 ** means that the SQL statement will never-run - the sqlite3_exec() call
91702 ** will return with an error.  SQLITE_IGNORE means that the SQL statement
91703 ** should run but attempts to read the specified column will return NULL
91704 ** and attempts to write the column will be ignored.
91874 ** zArg3 argument to authorization callbacks will be zContext until
92734 ** routines will be called to add more information to this record.
92819   ** and types will be used, so there is no need to test for namespace
92869   /* Begin generating the code that will insert the table record into
92872   ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
92907     ** The record created does not contain anything yet.  It will be replaced
92913     ** sqlite3EndTable will generate.
92997   ** 'BLOB'. If there is a type specified, then sqlite3AddColumnType() will
93172 ** then we will try to use that column as the rowid.  Set the Table.iPKey
93340 ** Generate code that will increment the schema cookie.
93580   ** created will become the PRIMARY KEY index.
93707 ** the new table will match the result set of the SELECT.
93951   Select *pSelect,   /* A SELECT statement that will become the new view */
93984   ** This will force all the Expr.token.z values to be dynamically
93986   ** they will persist after the current sqlite3_exec() call returns.
94068   ** Note that the call to sqlite3ResultSetOfSelect() will expand any
94069   ** "*" elements in the results set of the view and will assign cursors
94611 ** Generate code that will erase and refill index *pIdx.  This is
94738 ** and pTblList is the name of the table that is to be indexed.  Both will 
94744 ** pList is a list of columns to be indexed.  pList will be NULL if this
94873   ** index, then we will continue to process this index.
94992   ** the column will ever be used by the optimizer.  Note that using the
95161     ** that case the convertToWithoutRowidTable() routine will replace
95283 ** This routine will drop an existing named index.  This routine
95462 ** db->mallocFailed flag will be set to true.
95830 ** Record the fact that the schema cookie will need to be verified
95832 ** will occur at the end of the top-level VDBE and will be generated
95875 ** the way through and which will need to undo some writes without having to
95891 ** If an abort occurs after some of these writes have completed, then it will
96405       /* If a malloc() failure occurred in sqlite3HashInsert(), it will 
96612   ** install a new function.  Whatever FuncDef structure is returned it will
96863     /* if pLimit is null, pOffset will always be null as well. */
96934   Table *pTab;           /* The table from which records will be deleted */
96978   ** will be calling are designed to work with multiple tables and expect
97140       nKey = nPk; /* OP_Found will use an unpacked key */
97192       assert( nKey==nPk );  /* OP_Found will use an unpacked key */
97202       assert( nKey==0 );  /* OP_Found will use a composite key */
97288 **       store for the table.  (This will be either the table itself,
97349     /* Populate the OLD.* pseudo-table register array. These values will be 
97418 **       btree for the table pTab.  (This will be either the table itself
97461 ** Generate code that will assemble an index key and stores it in register
97477 ** will be set to zero which is an empty label that is ignored by
97922   /* If Y==0 and X will fit in a 64-bit int,
98015 ** noopFunc will never be called so it doesn't matter what the implementation
99713       ** will have INTEGER affinity applied to it, which may not be correct.  */
99783     /* Special case: If this is an INSERT statement that will insert exactly
99786     ** generated for will not open a statement transaction.  */
100085     ** the statement transaction will not be rolled back even if FK
100370         ** removing the parent key will be rectified by the action trigger.
100374         ** may-abort flag will eventually be set on this statement anyway
100435 ** If any foreign key processing will be required, this function returns
100560       ** The final WHEN clause will be like this:
100774 ** Generate code that will 
100825 ** is managed along with the rest of the Index structure. It will be
100834     ** The column affinity string will eventually be deleted by
100861 ** if iReg>0 then code an OP_Affinity opcode that will set the affinities
100995 ** This routine generates code that will initialize all of the
101259   /* Locate the table into which we will be inserting new information.
101553     ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
101555     ** we do not know what the unique ID will be (because the insert has
101621       /* The row that the VUpdate opcode will delete: none */
101672         ** Whenever this column is read, the rowid will be substituted
101674         ** taking up data space with information that will never be used.
101807 ** the data to be inserted or the data after the update.  There will be
101809 ** that regNewData points to) will contain the new rowid, or NULL in the
101810 ** case of a WITHOUT ROWID table.  The second register in the range will
101811 ** contain the content of the first table column.  The third register will
101828 ** pkChng will only be true if the INSERT statement provides an integer
101831 ** The code generated by this routine will store new index entries into
102067         ** remove the conflicting row from the table. This will fire
102073         ** only. The table b-tree entry will be replaced by the new entry 
102188     /* Check to see if the new index entry will be unique */
102371 ** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
102372 ** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
102510 ** Sometimes the xfer optimization will only work if the destination table
102515 ** returns FALSE so that the caller will know to go ahead and generate
102579   ** there is no ORDER BY, we will get an error. */
102773       ** index will be populated by inserting keys in strictly sorted 
102919           ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
103017 ** versions of SQLite will not be able to load each other's shared
104129 /* The "wsdAutoext" macro will resolve to the autoextension
105489   ** upper layers will never invoke the xFetch interfaces to the VFS.
105527   ** value will be restored the next time the database is opened.
105596   ** a relative path will probably be based on the current directory for the
105682   ** default value will be restored the next time the database is
106122   ** used will be case sensitive or not depending on the RHS.
106373   ** encoding that will be used for the main database file if a new file
106415       ** will be overwritten when the schema is next loaded. If it does not
106416       ** already exists, it will be created to use the new encoding value.
106949   ** will be closed before this function returns.  */
107040   ** clear the legacy_file_format pragma flag so that a VACUUM will
107082     ** current sqlite3_prepare() operation will fail, but the following one
107083     ** will attempt to compile the supplied statement against whatever subset
107198     ** will be closed immediately after reading the meta-value. */
107981 ** NULL t2 row will be inserted whenever t1.x!=5.  If we do not
107982 ** defer the handling of t1.x=5, it will be processed immediately
107983 ** after the t1 loop and rows with t1.x!=5 will never appear in
108114 ** Generate code that will push the record in registers regData
108227 ** Add code that will check to make sure the N registers starting at iMem
108330     ** there are columns in the table on the left.  The error will be caught
108372         ** previous value.  This will cause the OP_Ne below to always
108509       /* The LIMIT clause will terminate the loop for us */
108523         /* The LIMIT clause will jump out of the loop for us */
108884       /* The LIMIT clause will terminate the loop for us */
109021           ** The ALWAYS() is because iCol>=pS->pEList->nExpr will have been
109093 ** Generate code that will tell the VDBE the declaration types of columns
109132 ** Generate code that will tell the VDBE the names of columns
109205 ** All column names will be unique.
109773 ** in which case this routine will be called recursively. 
109792 ** pPrior will be the t2 query.  p->op will be TK_UNION in this case.
109933         /* We will need to create our own temporary table to hold the
110021       ** by allocating the tables we will need.
110259       /* The LIMIT clause will jump out of the loop for us */
110688   /* Reassembly the compound query so that it will be freed correctly
110886 **        such (illegal) sub-query is flattened. The caller will detect the
111031   ** But the t2.x>0 test will always fail on a NULL row of t2, which
111196   ** iParent.  The iParent cursor will never be used.  Subsequent code
111197   ** will scan expressions looking for iParent references and replace
111231     ** block of code will expand the out query to 4 slots.  The middle
111365 ** The hope is that the terms added to the inner query will make it more
111626 ** WITH clause will never be popped from the stack. In this case it
111628 ** bFree==0, the With object will be freed along with the SELECT 
112523     /* Sometimes the code for a subquery will be generated more than
112565       /* Implement a co-routine that will return a single row of the result
112583       /* Generate a subroutine that will fill an ephemeral table with
112584       ** the content of this subquery.  pItem->addrFillSub will point
112663   ** If that is the case, then the OP_OpenEphemeral instruction will be
112784     ** on the grounds that the GROUP BY will cause elements to come out 
112840       ** will be converted into a Noop.  
112866       /* Begin a loop that will extract all source rows in GROUP BY order.
112878         ** we do not have to sort.  The OP_OpenEphemeral table will be
112942       ** will naturally deliver rows in the order required by the ORDER BY
113048       /* Generate a subroutine that will reset the group-by accumulator
113089         ** In practice the KeyInfo structure will not be used. It is only 
113252 ** These routines are in a separate files so that they will not be linked
113483 ** that fire off of pTab.  The list will include any TEMP triggers on
113553     /* Figure out the db that the trigger will be created in */
114149     /* Figure out the ON CONFLICT policy that will be used for this step
114374   ** a matching TriggerPrg.pTrigger field will be present somewhere
114453 ** For ON DELETE triggers, the registers containing the NEW.* values will
114835   ** being updated.  Fill in aRegIdx[] with a register number that will hold
115018   /* If the record number will change, set register regNewRowid to
115076         /* This branch loads the value of a column that will not be changed 
115283   /* Construct the SELECT statement that will find the new values for
115302   /* Create the ephemeral table into which the update results will
115434 ** and renaming the transient database as the original.  But that will
115645     ** connections to the same database will know to reread the schema.
115823 ** If an unlock is omitted, resources leaks will occur.  
115996 ** string will be freed automatically when the table is
116784 ** array so that an OP_VBegin will get generated for it.  Add pTab to the
116985 ** term of a join.  Every term of the FROM clause will have at least
116988 ** FROM clause will have multiple WhereLoop objects, each describing a
117119 ** bits that will fit in a Bitmask.  The VDBE cursor numbers might be
117742 ** this routine sets up a loop that will iterate over all values of X.
117818 ** Generate code that will evaluate all == and IN constraints for an
117825 ** constraints are coded.  This routine will generate code to evaluate
117826 ** a==5 and b IN (1,2,3).  The current values for a and b will be stored
117841 ** calls this routine will use that memory range to store keys for
117888   /* Figure out how many memory cells we will need then allocate them.
118278     Index *pIdx;                 /* The index we will be using */
118293     ** query, then the caller will only allow the loop to run for
118618     ** That way, terms in y that are factored into the disjunction will
118680           ** row will be skipped in subsequent sub-WHERE clauses.
118714               ** need to insert the key into the temp table, as it will never 
118740           ** terms from the notReady table could not be tested and will
118754           ** pCov to NULL to indicate that no candidate covering index will 
118881   /* For a LEFT OUTER JOIN, generate code that will record the fact that
118953 ** allocation error.  The memory allocation failure will be recorded in
118956 ** This routine will increase the size of the pWC->a[] array as necessary.
119162           ** function, then no OP_Variable will be added to the program.
119377 ** also satisfies case 1 (such as B) we know that the optimizer will
119508   ** chngToIN will hold either 0, 1, or 2 bits.  The 0-bit case means
119514   ** will correspond to the common table.  We still need to check to make
119532     ** will be recorded in iCursor and iColumn.  There might not be any
119550           ** chngToIN set but t1 is not.  This term will be either preceded
119920         ** wildcard.  But if we increment '@', that will push it into the
119921         ** alphabetic range where case conversions will mess up the 
120240 ** Any cursors returned will have been opened for writing.
120319 ** array will never overflow.
120410 ** The scanner will be searching the WHERE clause pWC.  It will look
120461 ** the WHERE clause that specifies that X=Y.  Any such constraints will be
120467 ** Hence a search for X will return <expr> if X=A1 and A1=A2 and A2=A3
120556   ** this query, then it will not be possible to show that the DISTINCT 
120752   /* Count the number of columns that will be added to the index
120800   ** be a covering index because the index will not be updated if the
121269 ** that the scan will visit nNew rows. This function returns the number
121300 ** on the stat4 data for the index. this scan will be peformed multiple 
121399 ** This function is used to estimate the number of rows that will be visited
121459       /* Variable iLower will be set to the estimate of the number of rows in 
121600 ** Estimate the number of rows that will be returned based on
121666 ** Estimate the number of rows that will be returned based on
122047 ** is better and has fewer dependencies.  Or the template will be ignored
122048 ** and no insert will occur if an existing WhereLoop is faster and has
122131     /* We will be overwriting WhereLoop p[].  But before we do, first
122184 ** of rows in the table.  In other words, assume that x==EXPR will filter
122719         ** will be more aggressive about generating automatic indexes for
122729         ** of knowing how selective the index will ultimately be.  It would
122986           ** (2) Multiple outputs from a single IN value will not merge
123252   ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags.
123465 ** true if the rows really will be sorted in the specified order, or false
123512   ** terms are out of order, then block-sorting will reduce the 
123539 ** Assume that the total number of output rows that will need to be sorted
123540 ** will be nRowEst (in the 10*log2 representation).  Or, ignore sorting
123581   ** will invoke this function a second time, passing the estimate as the
123821   /* Find the lowest cost path.  pFrom will be left pointing to that path */
124014 ** code will run much faster.  Most of the work of this routine is checking
124110   /* Allocate and initialize the WhereInfo structure that will become the
124594     ** Except, do not close cursors that will be reused by the OR optimization
124620     ** sqlite3WhereEnd will have created code that references the table
124822 ** This section will be null unless lemon is run with the -m switch.
124848 **                       original value of the token will not parse.
126320    /* Here code is inserted which will execute if the parser
128032   /* Here code is inserted which will be executed whenever the
128068   /* Here code is inserted which will be executed whenever the
128170       **    processing will occur until three tokens have been
128595 ** IdChar(X) will be true.  Otherwise it is false.
128606 ** SQLite will allow '$' in identifiers for compatibility.
129032     ** will take responsibility for freeing the Table structure.
129072 ** separating it out, the code will be automatically omitted from
129500 ** this variable being set to non-zero will cause OSTRACE macros to emit
129522 ** name of a directory, then that directory will be used to store
129531 ** name of a directory, then that directory will be used to store
129544 ** this routine will be called automatically by key routines such as
129641   ** that we will be able to handle recursive calls into
129868       ** which the scratch allocations will be drawn, the size of each scratch
129952         ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
130034       ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
130263       ** words, strings will compare equal to one another as long as they
130426   ** will not have called the xDisconnect() method on any virtual
130428   ** call will do so. We need to do this before the check for active
130895 ** given callback function with the given argument. The progress callback will
132685   /* The following block stores the meta information that will be returned
132830     ** to sqlite3_randomness() will reseed the PRNG using a single call
133105     ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
133425 ** associated with connection db. The operation will return SQLITE_LOCKED
133426 ** to the user because it requires a lock that will not be available
133505           ** is returned the transaction on connection db will still be
133507           ** will go unissued. This might cause the application to wait
133508           ** indefinitely for an unlock-notify callback that will never 
133516           ** context pointers the application will receive two or more
133517           ** callbacks with smaller arrays of context pointers, which will
133596 ** are built from the bottom up, things will be described from the
133753 ** is encoded.  The subtree at iBlockid will contain all terms less
133756 ** than pTerm[i+1], the subtree for that term will be rooted at
133840 ** optimizations to things like doclist merging will swing the sweet
133852 ** will eventually overtake the earlier data and knock it out.  The
133923 ** we will need a way to register the API consistently.
133972   ** this callback. The caller will do so.
134047   /* Tokenizer implementations will typically add additional fields */
134052   /* Tokenizer implementations will typically add additional fields */
134183 ** that the library will create and use. FTS uses recursion to perform 
134467 ** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1.  (+0 for a,
134501 ** nToken will be the number of tokens in the string.
134786 ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
135634   **   + Figures out the number of columns the FTSX table will have, and
136012         ** of the overall query plan the user will see an "unable to use
136491 ** (in which case **pp will be a terminator bytes POS_END (0) or
136519 ** the value of iCol encoded as a varint to *pp.   This will start a new
136931   ** that will be copied and merged from the input to the output.
137533 ** matches the search criteria.  For a MATCH search, this will be
137534 ** the next row that matches. For a full-table scan, this will be
137539 ** even if we reach end-of-file.  The fts3EofMethod() will be called
137823   ** is only attempted if it will write at least 64 leaf blocks. Hence
138687   ** possible if the bOptOk argument is true, the FTS doclists will be
139188 ** of data that will fit on a single leaf page of an intkey table in
139240 ** This function is called to select the tokens (if any) that will be 
139267   int nLoad4 = 1;                 /* (Phrases that will be loaded)^4. */
139295   ** of the number of overflow pages that will be loaded by the pager layer 
139309   ** one or more tokens will not be deferred.
139333       ** that will be loaded if all subsequent tokens are deferred.
139347         ** part of a multi-token phrase. Either way, the entire doclist will
140686         ** that the following integer will be a column number, or the
140702           if( v==0 ){       /* 0x00. Next integer will be a docid. */
140704           }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
140806     ** instead. This works, as the "languageid=?" constraint will also
140807     ** be tested by the VDBE layer. The test will always be false (since
140808     ** this module will not return a row with a negative languageid), and
140809     ** so the overall query will return zero rows.  */
141794         /* Link pParent into the free node list. It will be used as an
142266 ** determines what kind of key the hash table will use.  "copyKey" is
143497 ** will return the string:
143655 ** function with no arguments. An assert() will fail if a problem is
144969 ** committing a transaction, the whole transaction will be rolled back. 
145237   Fts3Table *p,                   /* Table into which text will be inserted */
146635 ** be passed NULL. This function will allocate a new SegmentWriter object
147519     ** such segments are smaller than nLimit bytes in size, they will be 
147561         ** transiently here), will be moved back to level iAbsLevel below.  */
147648     ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to 
148221 ** than or equal to the first key that will be written to the next leaf
148245     /* Figure out how much space the key will consume if it is written to
148256       ** the key to it will not cause it to grow to larger than nNodeSize 
148283       ** Then allocate a new, empty sibling node. The key will be written
148475   ** will be set to 0. If the root node is the parent of the leaves, iRoot
148476   ** will be 1. And so on.  */
148791   Fts3MultiSegReader *pCsr,       /* Cursor that data will be read from */
149292     ** iteration of the loop will work on merging at the hinted level.
149414 ** before it will be selected for a merge, respectively.
150027       /* The new rowid is not NULL (in this case the rowid will be
150040       ** function) will return SQLITE_MISMATCH. If fts3DeleteByRowid is 
150041       ** invoked, it will delete zero rows (since no row will have
152751 ** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will
152753 ** will be done.
153512 ** implementation will only be used if this module is compiled as part
154474     /* Select the child node which will be enlarged the least if pCell
155035   ** the Rtree.pDeleted list. Its contents will be re-inserted later on.
156004 ** The R-Tree MATCH operator will read the returned BLOB, deserialize
156944 **  wrong moment they might get out of sync. As the main database will be
156945 **  committed before the RBU update database this will likely either just
156950 **  other error occurs, the RBU extension will keep throwing errors. It's
157018 ** guarantee that a single update process will run for long enough to apply 
157046 **   * No triggers will be fired.
157236 ** or zRbu begin with "file:", it will be interpreted as an SQLite 
158203     /* Figure out the type of table this step will deal with. */
159282   **     no-ops. These locks will not be released until the connection
159939 ** argument. This VFS will be used unless the call to sqlite3rbu_open()
160436     ** one is found, this vfs will operate in pass-through mode. The lower
160437     ** level vfs will do the special RBU handling.  */
160663       ** the name of the *-wal file this db connection will use. SQLite
160765   **      causing SQLite to call xOpen() to open it. This call will also
161021 **   the overflow pages associated with a cell will appear earlier in the
161157   ** If this will satisfy the client, set the orderByConsumed flag so that 

Indexes created Fri Jul 05 22:58:02 MDT 2024