3 ** version 3.35.5.  By combining all the individual C code files into this
10 ** This file is all you need to compile SQLite.  To use SQLite in other
65 ** An array of names of all compile-time options.  This array should
833 ** In all cases, the special comment must be enclosed in the usual
947 ** code in all source files.
958 ** on 2008-11-28.) These days, all Linux kernels support large files, so
976 ** optimizations, and hence set all compiler macros to 0
980 ** and unreliable.  Fortunately, all versions of clang also recognize the
1143 ** that we have taken it all out and gone back to using simple
1362 ** the [sqlite3] object is successfully destroyed and all associated
1365 ** Ideally, applications should [sqlite3_finalize | finalize] all
1366 ** [prepared statements], [sqlite3_blob_close | close] all [BLOB handles], and
1367 ** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated
1377 ** connection after all prepared statements are finalized, all BLOB handles
1378 ** are closed, and all backups have finished. The sqlite3_close_v2() interface
1653 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1723 ** xSync VFS method occur and applies uniformly across all platforms.
1797 ** core reserves all opcodes less than 100 for its own use.
1829 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1962 ** to be adjusted.  The values are changed for all database connections
2004 ** all [VFSes] in the VFS stack.  The names are of all VFS shims and the
2009 ** all file-control actions, there is no guarantee that this will actually
2124 ** means all subsequent write operations will be deferred and done
2135 ** The [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] opcode causes all write
2139 ** all performed successfully and have been committed to persistent storage.
2141 ** the file descriptor out of batch write mode so that all subsequent
2147 ** The [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE] opcode causes all write
2151 ** so that all subsequent write operations are independent.
2301 ** be unique across all VFS modules.
2320 ** The flags argument to xOpen() includes all bits set in
2427 ** or all of these interfaces to be NULL or for their behavior to change
2558 ** single thread.  All open [database connections] must be closed and all
2679 ** memory allocation subsystem for SQLite to use for all of its
2718 ** not need to be threadsafe either.  For all other methods, SQLite
2759 ** all mutexing and puts SQLite into a mode where it can only be used
2784 ** all mutexes including the recursive
2866 ** a page cache line is larger than sz bytes or if all of the pMem buffer
2878 ** that SQLite will use for all of its dynamic memory allocation needs
2890 ** allocator is engaged to handle all of SQLites memory allocation needs.
2966 ** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()],
3071 ** to an ORDER BY clause, all fields required by the caller are present in the
3183 ** <p>Originally this option disabled all triggers.  ^(However, since
3200 ** <p>Originally this option disabled all views.  ^(However, since
3251 ** connections at all to the database. If so, it performs a checkpoint
3378 ** all applications are advised to turn it off if possible. This setting
3385 ** the legacy file format flag.  When activated, this flag causes all newly
3393 ** all the way back to version 3.0.0, and so this setting is of little
3570 ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
3626 ** ^The sqlite3_interrupt(D) call is in effect until all currently running
3748 ** turns off all busy handlers.
3778 ** The remaining entries all point to query results.  NULL values result
3890 ** The SQLite core uses these three routines for all of its own
4068 ** [truncate optimization] is disabled and all rows are deleted individually.
4537 **     privilege, and so the database is opened read-only and all locking
4584 ** URI filename are interpreted, they are encoded using UTF-8 and all
4677 ** it has access to all the same query parameters as were found on the
4709 ** In all of the above, if F is not the name of a database, journal or WAL
4837 ** all calls to the interfaces listed here are completed.
5011 ** [sqlite3_normalized_sql()] interface is now available to all
5041 ** does all parsing using UTF-8.  The UTF-16 interfaces are provided
5081 ** and sqlite3_prepare16_v3() interfaces are recommended for all new programs.
5274 ** to locate all prepared statements associated with a database
5285 ** SQLite uses the sqlite3_value object to represent all values
5500 ** parameter. For all forms except ?NNN, this will correspond to the
5562 ** ^Use this routine to reset all host parameters to NULL.
5638 ** subquery and is not a column value, then all of these functions return
5643 ** ^As with all other SQLite APIs, those whose names end with "16" return
5750 ** For all versions of SQLite up to and including 3.6.23.1, a call to
5769 ** with the "v2" interface.  If you prepare all of your SQL statements
6169 ** all application-defined SQL functions that do not need to be
6189 ** SQL function or aggregate, pass NULL pointers for all three function
6314 ** for all [application-defined SQL functions], and especially for functions
6465 ** sqlite3_value_nochange(X) is true will in all other respects appear
6722 ** a BLOB containing all zero bytes and N bytes in size.
6738 ** message all text up through the first zero character.
6922 ** deleted.  ^When all collating functions having the same name are deleted,
6933 ** to the same collation name (using different eTextRep values) then all
6935 ** The collating function must obey the following properties for all
6994 ** ^To avoid having to register all collation sequences before a database
7052 ** all, then the behavior of sqlite3_sleep() may deviate from the description
7061 ** the name of a folder (a.k.a. directory), then all temporary files
7069 ** But for all other platforms, it is highly recommended that applications
7095 ** so itself, taking care to only do so after all [database connection]
7119 ** the name of a folder (a.k.a. directory), then all database files
7123 ** pointer, then SQLite assumes that all database files specified
7451 ** ^(The cache sharing mode set by this interface effects all subsequent
7513 ** by all database connections within a single process.
7609 ** table or NULL.)^ ^If it is NULL, then all attached databases are searched
7653 ** ^This function causes all database schemas to be read from disk and
7687 ** X is consists of the lower-case equivalent of all ASCII alphabetic
7753 ** that is to be automatically loaded into all new database connections.
7800 ** ^This interface disables all automatic extensions previously
8093 ** ^The sqlite3_drop_modules(D,L) interface removes all virtual
8097 ** ^If the L parameter is NULL, then all virtual table modules are removed.
8115 ** common to all module implementations.
8146 ** are common to all implementations.
8576 ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
8610 ** implementation of this method is expected to release all outstanding
8791 ** the number, meaning, and operation of all subsequent parameters.
8798 ** they take, and what they do are all subject to change without notice.
8879 ** <li> Put all identifier names inside double-quotes.  This is the official
9202 ** been satisfied using lookaside memory but failed due to all lookaside
9209 ** memory used by all pager caches associated with the database connection.)^
9226 ** memory used to store the schema for all databases associated
9235 ** and lookaside memory used by all prepared statements associated with
9267 ** to disk all at once. When pages spill mid-transaction, that introduces
9274 ** all foreign key constraints (deferred or immediate) have been
9553 ** When SQLite calls the xTruncate() method, the cache must discard all
9646 **     <li><b>sqlite3_backup_finish()</b> is called to release all resources
9687 ** ^If N is negative, all remaining source pages are copied.
9690 ** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
9745 ** ^The sqlite3_backup_finish() interfaces releases all
10121 **   readers or writers to finish, then sync the database file if all frames
10130 **   database writer and all readers are reading from the most recent database
10131 **   snapshot. ^It then checkpoints all frames in the log file and syncs the
10139 **   until all readers are reading from the database file only. ^This ensures
10177 ** specified operation is attempted on all WAL databases [attached] to
10213 ** These constants define all valid values for the "checkpoint mode" passed
10399 ** to the total number of rows examined by all iterations of the X-th loop.</dd>
10406 ** product of this value for all prior loops with the same SELECTID will
10458 ** ^Statistics might not be available for all loops in all statements. ^In cases
10476 ** ^Zero all [sqlite3_stmt_scanstatus()] related event counters.
10493 ** interface flushes caches for all schemas - "main", "temp", and
10801 ** If a [WAL file] remains on disk after all database connections close
10810 ** of database handle db and make all valid snapshots available to
11193 ** then the change is considered indirect if all operations meet the criteria
11217 ** Or, if argument zTab is NULL, then changes are recorded for all tables
11315 ** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL,
11326 ** Within a changeset generated by this function, all changes related to a
11328 ** a changeset or when applying a changeset to a database, all changes related
11341 ** records the primary key values of all new rows inserted into the table.
11373 **        primary key in the database, but all fields contain their original
11479 ** A patchset blob may be used with up to date versions of all
11491 ** generated by the sqlite3session_changeset() function (i.e. all changes for
11552 ** [sqlite3changeset_invert()] functions, all changes within the changeset
11555 ** this function, all changes that relate to a single table are visited
11609 ** Otherwise, if all changes in the changeset have already been visited,
11792 ** In all other cases this function returns SQLITE_MISUSE.
11932 **   <li> The result of combining all input changesets together is obtained
11951 ** Add all changes within the changeset (or patchset) in buffer pData (size
11954 ** If the buffer contains a patchset, then all prior calls to this function
12018 ** function returns SQLITE_NOMEM. In all cases, if an error occurs the state
12035 ** sqlite3session_patchset() functions, all changes related to a single
12076 ** is NULL, all changes related to the table are attempted.
12080 ** considered compatible if all of the following are true:
12124 **   stored in all non-primary key columns also match the values stored in
12169 **   stored in all modified non-primary key columns also match the values
12261 **   Usually, the sessions module encloses all operations performed by
12522 ** Delete the changeset rebaser object and all associated resources. There
12556 ** required. In all cases, a pair of API function parameters such as
12577 ** error code should be returned. In all cases, if an xInput callback returns
12578 ** an error, all processing is abandoned and the streaming API function
12584 ** an error state, whereby all subsequent calls to iterator functions
12815 **   the total number of tokens in column iCol, considering all rows in
12856 **   Set *pnInst to the total number of occurrences of all phrases within
12919 **   more than once for a single FTS query, then all invocations share a
12955 **   method, to iterate through all instances of a single query phrase within
12979 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
12987 **   of iterating through all instances of a phrase in the current row, these
13003 **   then this API always iterates through an empty set (all calls to
13149 **   all instances of "first place" or "1st place" regardless of which form
13154 **   <ol><li> By mapping all synonyms to a single token. In this case, using
13163 **       <li> By querying the index for all synonyms of each query term
13547 ** fire any triggers. A value of 0 means that no trigger programs at all
13599 ** Unfortunately, that typedef is not available on all compilers, or
13781 ** can insure that all cases are evaluated.
14017 ** Macros for looping over all elements of a hash table.  The idiom is
14586 ** all alignment restrictions correct.
14626 ** The default MMAP_SIZE is zero on all platforms.  Or, even if a larger
14762 ** When a function parameter is not used at all within the body of a function,
15320 ** selected will all have the same key.  In other words, the cursor will
15346 ** skip a lot of work.  Namely:  FORDELETE cursors may treat all SEEK
15923 ** generated this include file strives to group all JUMP opcodes
16263 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*);    /* Mark all dirty list pages as clean */
16269 /* Remove all pages with pgno>x.  Reset the cache if x==0 */
16272 /* Get a list of all dirty pages in the cache, sorted by page number */
16296 /* Iterate through all dirty pages currently stored in the cache. This
16407 ** After the following block of preprocess macros, all of SQLITE_OS_UNIX,
16495 ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
16520 ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
16531 ** But a single Win95 reader will lock out all WinNT readers and a single
16532 ** WinNT reader will lock out all other Win95 readers.
16541 ** clients on win95, winNT, and unix all talking to the same shared file
16542 ** and all locking correctly.  To do so would require that samba (or whatever
16550 ** that all locks will fit on a single page even at the minimum page size.
16647 ** This file contains the common header for all mutex implementations.
16649 ** to all source files.  We break it out in an effort to keep the code
16731 ** In other words, the zero-based numbers are used for all external interfaces
17087   /* The following variables are all protected by the STATIC_MAIN
17101   sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
17115 ** A u64 constant where the lower 32 bits are all zeros.  Only the
17150 #define SQLITE_DeferFKs       0x00080000  /* Defer all FK constraints */
17658   FKey *pFKey;         /* Linked list of all foreign keys in this table */
17778 ** The list of all parents for child Table X is held at X.pFKey.
17780 ** A list of all children for a table named Z (which might not even exist)
17834 #define OE_Fail     3   /* Stop the operation but leave all prior changes */
17970   unsigned uniqNotNull:1;  /* True if UNIQUE and NOT NULL for all columns */
18136 ** it can be accessed after all aggregates are computed.
18161 ** an Expr object is truncated.  When EP_Reduced is set, then all
18257 #define EP_Leaf       0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
18526 ** or all contexts are check.  When a match is found, the nRef member of
18553 ** Value constraints (all checked via assert()):
18616 ** An instance of the following structure contains all information
18659 ** Value constraints (all checked via assert())
18741 **                     a record of all prior results and ignore any duplicate
18745 **                     an index).  Append a sequence number so that all entries
18750 **                     index at pDest->iSDParm+1 hold all prior stores.
18767 /* The DISTINCT clause is ignored for all of the above.  Not that
18774 /* The ORDER BY clause is ignored for all of the above */
18809   AutoincInfo *pNext;   /* Next info block in a list of them all */
18842 ** The yDbMask datatype for the bitmask of all attached databases.
18873 ** the parser and down into all the parser action routine in order to
18901   u8 disableVtab;      /* Disable all virtual tables for this parse */
19343   const char *zDb;    /* Make sure all objects are contained in this database */
19434 ** This object is used in various ways, most (but not all) related to window
20661 /* An array to map all upper-case characters into their corresponding
20911 ** Hash table for global functions - functions common to all
20999 ** VDBE.  This information used to all be at the top of the single
21108   const u8 *aRow;         /* Data for the current row, if all on one page */
21183 ** Internally, the vdbe manipulates nearly all SQL values as Mem
21308 ** There is a typedef for this structure in sqlite.h.  So all routines,
21388   /* When allocating a new Vdbe object, all of the fields below should be
21430   SubProgram *pProgram;   /* Linked list of all sub-programs used by VM */
21854     ** by all pagers associated with the given database connection.  The
21881     ** to store the schema for all databases (main, temp, and any ATTACHed
21924     ** to store all prepared statements.
21945     ** Set *pCurrent to the total cache hits or misses encountered by all
21974     ** key constraints.  Set *pCurrent to zero if all foreign key constraints
22011 ** SQLite processes all times and dates as julian day numbers.  The
22024 ** The Gregorian calendar system is used for all dates and times,
22858 ** argv[1] and following are modifiers.  Parse them all and write
23220 ** This function registered all of the above C functions as SQL
23258 ** This file contains OS interface code that is common to all
23589 ** The list of all registered VFS implementations.
23805 ** No-op versions of all memory allocation routines
24189   struct MemBlockHdr *pNext, *pPrev;  /* Linked list of all unfreed memory */
24222   ** Head and tail of a linked list of all outstanding allocations
24605 ** Open the file indicated and write a log of all unfreed memory
24678 ** This version of the memory allocation subsystem omits all
24967 ** This routine examines all entries on the given list and tries
25249 ** Open the file indicated and write a log of all unfreed memory
25368 ** This version of the memory allocation subsystem omits all
25393 ** allocation size (after rounding all sizes up to a power of 2.)  Let M
25463   u64 totalAlloc;     /* Total of all malloc calls - includes internal frag */
25869 ** Open the file indicated and write a log of all unfreed memory
25946 ** This file contains code that is common across all mutex implementations.
25978 ** Type for all mutexes used when SQLITE_ENABLE_MULTITHREADED_CHECKS
26330 ** Stub routines for all mutex methods.
26929 ** Include code that is common to all os_*.c files
26946 ** all of the platform-specific files (os_*.c) and is #included into those
27250 ** on Win32.  It should be noted that all mutexes require initialization
28184 ** that all prior mallocs (ex: "a") worked too.
29513 ** Reset an StrAccum string.  Reclaim all malloced memory.
29798 ** all the appropriate tree lines
31154   ** all that is required is to swap the byte order. This case is handled
32405 ** for all bytes that have the 8th bit set and one byte with the 8th
33224 /* Remove all entries from a hash table.  Reclaim all memory.
33229   HashElem *elem;         /* For looping over all elements of the table */
33683 ** skip locking all together.
33694 **   *  Various locking primitive implementations (all except proxy locking):
33702 **   *  Definitions of sqlite3_io_methods objects for all locking
33706 **   *  Definitions of sqlite3_vfs objects for all locking methods
33961 ** Include code that is common to all os_*.c files
33978 ** all of the platform-specific files (os_*.c) and is #included into those
34243 ** to all overrideable system calls.
34428 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
34443     /* If no zName is given, restore all system calls to their default
34576 ** vxworksFileId objects used by this file, all of which may be
34634 ** Print out information about all locking operations.
34767   struct vxworksFileId *pNext;  /* Next in a list of them all */
34946 ** all locks on that file that are owned by the current process are
34951 ** to close() the file descriptor is deferred until all of the locks clear.
35015 **  (3) With the exceptions above, all the fields may only be read
35032   unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
35044 ** A lists of all unixInodeInfo objects.
35164 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
35459 ** within this process, but all of that is handled in memory and the
35555   ** range'. Since all other locks require a read-lock on one of the bytes
35887     ** OS call only when all threads in this same process have released
35943 ** common to all locking schemes. It closes the directory and file
35944 ** handles, if they are valid, and sets all fields of the unixFile
36069 **    (1)  There is zero concurrency.  A single reader blocks all other
36353 ** lock states in the sqlite3_file structure, but all locks SHARED or
36354 ** above are really EXCLUSIVE locks and exclude all other processes from
36527 ** lock states in the sqlite3_file structure, but all locks SHARED or
36528 ** above are really EXCLUSIVE locks and exclude all other processes from
36638 ** The afpLockingContext structure contains all afp lock specific state
37030     ** OS call only when all threads in this same process have released
37128 ** The next division contains implementations for all methods of the
37131 ** division).  Those methods that are common to all locking modes
37193 ** Read data from a file into a buffer.  Return SQLITE_OK if all
37444 ** The SQLITE_NO_SYNC macro disables all fsync()s.  This is useful
37582 ** Make sure all writes to a particular file are committed to disk.
37941 ** There are two versions of this function. One for QNX and one for all
38102 ** When multiple threads all reference the same wal-index, each thread
38103 ** has its own unixShm object, but they all point to a single instance
38177 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
38276 ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
38610         ** last page in order to extend the file. But writing to all new
39021     /* If the mmap() above failed, assume that all subsequent mmap() calls
39143 ** Here ends the implementation of all sqlite3_file methods.
39212 ** Here are all of the sqlite3_io_methods objects for each of the
39940   ** here such that two or more threads all trying to open databases at
39941   ** the same instant might all reset the PRNG.  But multiple resets
40115           ** and clear all the structure's references.  Specifically,
40236 **    Remove all instances of /./
40237 **    Remove all isntances of /X/../ for any X
40471   ** When testing, initializing zBuf[] to zero is all we do.  That means
40616 ** until late in the file (here) after all of the other I/O methods have
40640 ** cache exposes a cache coherency problem that is present on all OS X
40710 ** The proxy file - a single-byte file used for all advisory file locks
40713 ** host (the conch ensures that they all use the same local lock file).
40754 ** will force automatic proxy locking to be disabled for all database
40833   /* try to create all the intermediate directories */
41483     /* all other styles use the locking context to store the db file path */
41491 ** Takes an already filled in unix file and alters it so all file locking
41559     /* all memory is allocated, proxys are created and assigned,
41647 ** above this point are all utilities.  The lock-related methods of the
41792 ** This routine registers all VFS implementations for unix-like operating
41887   /* Register all VFSes defined in the aVfs[] array */
41929 ** Include code that is common to all os_*.c files
41946 ** all of the platform-specific files (os_*.c) and is #included into those
42401 ** The winVfsAppData structure is used for the pAppData member for all of the
42435  * and an isolated heap will be created to store all allocated data.
42440  *          function), all data that was allocated using the isolated heap will
42611 ** to all overrideable system calls.
43269 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
43284     /* If no zName is given, restore all system calls to their default
43447   if( nMin<-1 ) nMin = -1; /* all negative values become -1. */
44817 ** Read data from a file into a buffer.  Return SQLITE_OK if all
45028     ** all references to memory-mapped content are closed.  That is doable,
45097 ** Make sure all writes to a particular file are committed to disk.
45340 ** erases all locks at once and returns us immediately to locking level 0.
45781 ** this file, all of which may be shared by multiple threads.
45806 ** shared memory.  When multiple threads all reference the same
45807 ** log-summary, each thread has its own winFile object, but they all
45845   winShmNode *pNext;         /* Next in list of all winShmNode objects */
45852 ** A global array of all winShmNode objects.
45889 ** Apply advisory locks for all n bytes beginning at ofst.
45937 ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
46180   winShm *pX;                           /* For looping over all siblings */
46686 ** Here ends the implementation of all sqlite3_file methods.
46692 ** This vector defines all the methods that can operate on an
46718 ** This vector defines all the methods that can operate on an
48923 ** or all of the pages in a database can get journalled.  In those cases,
49178 ** Destroy a bitmap object.  Reclaim all memory used.
49361   int nRefSum;                        /* Sum of ref counts over all pages */
49379 ** When sqlite3PcacheTrace is 2, a dump of the pcache showing all cache entries
49451   ** disk sector size.  When any page of a sector is journalled, all pages
49453   ** in case they are later modified, since all pages in the same sector
49530     ** flag set sqlite3PcacheFetchStress() searches through all newer
49912 ** Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages.
49924 ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
50079 ** Return a list of all dirty pages in the cache, sorted by page number.
50090 ** Return the total number of references to all pages held by the cache.
50093 ** reference count for all pages.
50189 ** For all dirty pages currently in the cache, invoke the specified
50337 **   (2)  There is a single global PGroup that all PCaches are a member
50368   ** flag (bPurgeable) and the pnPurgeable pointer are all set when the
50385   /* Hash table of all pages. The following variables may only be accessed
50411   ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
50715 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
50718 ** for all page cache needs and we should not need to spill the
50721 ** Or, the heap is used for all page cache memory but the heap is
50846 ** Discard all pages from cache pCache with a page number (key value)
50912   ** PGroup in pcache1.grp is used for all page caches (mode-2).
51175 **           the sum of nMax for all purgeable caches, less the sum of
51176 **           nMin for all other purgeable caches, or
51184 **       (b) The number of pages allocated for all purgeable caches is
51185 **           already equal to or greater than the sum of nMax for all
51349 ** Discard all unpinned pages in the cache with a page number equal to
51503 ** After all inserts are finished, it is possible to extract the
51531 ** a non-zero batch number, it will see all prior INSERTs.
51582   struct RowSetChunk *pNextChunk;        /* Next chunk on list of them all */
51592   struct RowSetChunk *pChunk;    /* List of all chunk allocations */
51631 ** Deallocate all chunks from a RowSet.  This frees all memory that
51651 ** Deallocate all chunks from a RowSet.  This frees all memory that
51756 ** Sort all elements on the list of RowSetEntry objects into order of
52199 **     (a) The page and all other pages on the same sector are overwriteable.
52220 ** (6) If a super-journal file is used, then all writes to the database file
52225 ** all queries.  Note in particular the content of freelist leaf
52326 **    * Any lock, or no lock at all, may be held on the database file.
52331 **    In this state all the requirements for reading the database in
52356 **    is first opened on the database. In WRITER_LOCKED state, all locks
52364 **    in WRITER_LOCKED state, all that is required is to unlock the database
52377 **    * The dbSize, dbOrigSize and dbFileSize variables are all valid.
52423 **      If no error occurred, all that remains is to finalize the journal to
52447 **    to read or write data returns an error. Eventually, once all
52615 **   logic into thinking that it already has all the locks it will ever
52696 **   It is valid in PAGER_READER and higher states (all states except for
52750 **   is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
52779   u8 memDb;                   /* True to inhibit all file I/O */
53021   ** this means an in-memory pager performs no IO at all, it cannot encounter
53910 ** Free all structures in the Pager.aSavepoint[] array and set both
53930 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
54053 ** all major API calls on the Pager will immediately return Pager.errCode.
54084 ** Return TRUE if and only if all dirty pages should be flushed to disk.
54292 ** call to pager_unlock() will discard all in-memory pages, unlock
54598 ** of all of its child journals, one after another, formatted as utf-8
54605 ** A super-journal file may only be deleted once all of its child
54877 ** journal file then all pages up to the first corrupted page are rolled
55050   ** update the change-counter at all. This may lead to cache inconsistency
55142       ** pPager->dbFileVers[] with all 0xff bytes should suffice.
55238   /* For all pages in the cache that are currently dirty or have already
55694 ** the xSync primitive is called and is relevant to all platforms.
55821 ** Otherwise, if all of the following are true:
55836 ** In all other cases, SQLITE_OK is returned.
55939 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
56042 ** following is true for all dirty pages currently in the page-cache:
56091   ** ensure that all pages being truncated away by this operation are,
56193 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
56230 ** Shutdown the page cache.  Free all memory and close all files.
56317 ** Sync the journal. In other words, make sure all the pages that have
56379         ** hot-journal rollback following recovery. It may roll back all
56411         ** all data has really hit the disk before nRec is updated to mark
56454   ** all pages.
56604 ** for all open savepoints before returning.
56686   ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
56749 ** Flush all unreferenced dirty pages to disk.
56777 ** all information is held in cache. It is never written to disk.
57583 ** page is initialized to all zeros.
57602 ** The acquisition might fail for several reasons.  In all cases,
57798 /* Dispatch all page fetch requests to the appropriate getter method.
57942       /* TODO: Check if all of these are really required. */
58189 ** all bytes of a sector are written together by hardware.  Hence, all bytes of
58256   ** starting at pg1, then it needs to be set for all of them. Because
58258   ** journal file must contain sync()ed copies of all of them
58285 ** fit on a single disk sector. In this case all co-resident pages
58327 ** The overlying software layer calls this routine when all of the data
58506 **   * all dirty pages are written to the database file,
58658       /* Sync the journal file and write all dirty pages to the database.
58793 ** If a write transaction is open, then all changes made within the
58803 **   1) It rolls back the journal file, restoring all database file and
58813 ** In WAL mode, all cache-entries containing data modified within the
58874 ** Return the sum of the reference counts for all pages held by pPager.
59034 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
59049 ** In any case, all savepoints with an index greater than iSavepoint
59911 **        after the commit. For all other records, zero.
59925 **        WAL header and the first 8 bytes and the content of all frames
59944 ** of the sequence being summed.)  The s1 value spans all 32-bit
59949 ** The VFS.xSync operations serve as write barriers - all writes launched
59970 ** for all subsequent read operations.  New transactions can be appended
60002 ** Hence, unlike the database and WAL file formats which store all values
60021 ** first index block are the same size as all other index blocks in the
60144 ** WalCkptInfo.aLock[] array in the wal-index header.  In other words, all
60168 ** For all versions of SQLite through 3.10.0 and probably beyond,
60187   u32 aCksum[2];                  /* Checksum over all prior fields */
60206 ** nBackfill is only set after all backfilling completes.  So if a checkpoint
60219 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
60236 ** get all their all content directly from the database file and ignore
60240 ** if nBackfill equals mxFrame (meaning that all WAL content has been
60278 ** file are calculated by treating all data as an array of 32-bit
60280 ** all data as 32-bit little-endian words.
60355 ** all frames in the WAL in database page order. Where two or more frames
60601 **        after the commit. For all other records, zero.
60665   ** all prior frams, the first 16 bytes of this frame-header,
60715 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
60878   /* Zero all hash-table entries that correspond to frame numbers greater
61013   /* Obtain an exclusive lock on all byte in the locking range not already
61104     /* Read all frames from the log file. */
61144       /* Memcpy() should work fine here, on all reasonable implementations.
61186     ** currently holding locks that exclude all other writers and
61336 ** Find the smallest page number out of all pages held in the WAL that
61380 ** is guaranteed for all J<K:
61390 ** The aContent[aLeft[X]] values will be unique for all X.  And the
61444 ** aList[] are to be sorted so that for all J<K:
61523 ** Construct a WalInterator object that can be used to loop over all
61933   ** until all readers have finished using the wal file. This ensures that
61953           ** wal-index header in shared memory, as all subsequent reader or
62096   ** shared among multiple processes and not all mutex implementions work
62108     return 1;   /* Malformed header - probably all zeros */
62311   ** or SQLITE_READONLY_CANTINIT or some error for all subsequent invocations,
62451 ** completely and get all content directly from the database file.
62678 ** through all wal frames from nBackfillAttempted to (nBackfill+1),
62692 ** decreased at all.
63206         /* If all readers are using WAL_READ_LOCK(0) (in other words if no
63303 ** all frames written to the wal file by the current transaction starting
63434     ** all syncing is turned off by PRAGMA synchronous=OFF).  Otherwise
63456   /* Write all frames into the log file exactly once */
64088 ** a fragment.  The total number of bytes in all fragments is recorded.
64102 ** byte are used.  The integer consists of all bytes that have bit 8 set and
64105 ** As a special case, all 8 bytes of the 9th byte are used as data.  This
64200 ** Access to all fields of this structure is controlled by the mutex
64265 ** schema associated with the database file are all contained within
64357   BtCursor *pCursor;    /* A list of all open cursors */
64421 ** root-node and 3 for all other internal nodes.
64469   BtCursor *pNext;          /* Forms a linked list of all cursors */
64613 ** This structure is passed around through all the sanity checking routines
64709 ** by all database connections.  The p->pNext is a list of other
64712 ** p, then first unlock all of the others on p->pNext, then wait
64713 ** for the lock to become available on p, then relock all of the
64763   /* To avoid deadlock, first release all locks with a larger
64821 ** against all schemas and we do not want those schemas being
64824 ** There is a corresponding leave-all procedures.
64828 ** two or more btrees in common both try to lock all their btrees
64864 ** mutex and all required BtShared mutexes.
64914 ** these two routines, all mutex operations are no-ops in that case and
64917 ** If shared cache is disabled, then all btree mutex routines, including
65373 ** Release all the table locks (locks obtained via calls to
65422 ** This function changes all write-locks held by Btree p into read-locks.
65474 ** Invalidate the overflow page-list cache for all cursors opened
65492 ** table is about to be deleted. In this case invalidate all incrblob
65503   int isClearTable        /* True if all rows are being deleted */
65533 **   1) When all data is deleted from a page and the page becomes
65541 **      be, if it is not at all meaningful?).
65596 ** Release all of the apPage[] pages for a cursor.
65694 ** Save the positions of all cursors (except pExcept) that are open on
65701 ** If there are two or more cursors on the same btree, then all such
65733   Pgno iRoot,          /* Only save cursor with this iRoot. Save all if zero */
66131 ** all MemPage types and that references the cell by index rather than
66274 ** cellSizePtr()             =>   all index nodes & table leaf nodes
66389 ** b-tree page so that there are no freeblocks or fragment bytes, all
66390 ** unused bytes are contained in the unallocated space region, and all
66592 ** all the space together, however.  This routine will avoid using
67437       /* In debug mode, we mark all persistent databases as sharable
67546   ** Btree into the list of all sharable Btrees for the same connection.
67692 ** Close an open database and invalidate all cursors.
67697   /* Close all cursors opened via this handle.  */
68233 ** false then all cursors are counted.
68539 ** Set the pointer-map entries for all children of page pPage. Also, if
68678   ** that point to overflow pages. The pointer map entries for all these
68969 ** disk and we are still holding all locks, so the transaction has not
69055 ** routine did all the work of writing information out to disk and flushing the
69131 ** following the rollback. Or, if writeOnly is false, all cursors are
69138 ** saving the current position of a read-only cursor, all cursors,
69139 ** including all read-cursors are tripped.
69188 ** Only write cursors are tripped if writeOnly is true but all cursors are
69270   ** an index greater than all savepoints created explicitly using
69351 ** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE
69352 ** operations on this cursor can be no-ops and all READ operations can
69370   BtCursor *pX;                          /* Looping over other all cursors */
69414   /* If there are two or more cursors on the same btree, then all such
69905         /* If all the following are true:
70664   /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
71813 ** tunable - as if you could change them and recompile and it would all work.
71829 ** which should be common to all pages that contribute cells to this array.
71863 ** each of these 5 stages, and all stages to the left.  Hence:
71888   u16 *szCell;            /* Local size of all cells in apCell[] */
72027 ** all cells - not just those inserted by the current call). If the content
72028 ** area must be extended to before this point in order to accomodate all
72115       /* No need to use cachedCellSize() here.  The sizes of all cells that
72142 ** pCArray contains pointers to and sizes of all cells in the page being
72480 ** (hereafter "the page") and up to 2 siblings so that all pages have about the
72485 ** is a root page or a child of a root page) then all available siblings
72493 ** if the page is overfull. This routine ensures that all cells allocated
72513 ** enough for all overflow cells.
72578   ** has NB or fewer children then all children of pParent are taken.
72684   ** Load pointers to all cells on sibling pages and the divider cells
72691   ** into aSpace1[].  In this way, all cells in b.apCell[] are without
72692   ** child pointers.  If siblings are not leaves, then all cell in
72693   ** b.apCell[] include child pointers.  Either way, all cells in b.apCell[]
72711     /* Verify that all sibling pages are of the same "type" (table-leaf,
72719     /* Load b.apCell[] with pointers to all cells in pOld.  If pOld
72799   ** Figure out the number of pages needed to hold all b.nCell cells.
72801   ** size of all cells on the i-th page and cntNew[] which is the index
73223     ** sets all pointer-map entries corresponding to database image pages
73228     ** by smaller than the child due to the database header, and so all the
73264     ** all pointer map pages are set correctly. This is helpful while
73297 ** Before returning, all pointer-map entries corresponding to pages
74251     ** out to be an overflow page, delete all overflow page-map caches
74382 ** Erase the given database page and all its children.  Return
74440 ** Delete all information from a single table in the database.  iTable is
74461     /* Invalidate all incrblob cursors open on table iTable (assuming iTable
74472 ** Delete all information from the single table that pCur is open on.
74481 ** Erase all information in a table and add the root of the table to
74492 ** is added to the freelist instead of iTable.  In this say, all
74709     ** If all pages in the tree have been visited, return SQLITE_OK to the
74984 **      4.  Recursively call checkTreePage on all children.
74985 **      5.  Verify that the depth of all children is the same.
75221     /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
75279   int bPartial = 0;            /* True if not checking all btrees */
75336   /* Check all the tables.
75580   /* Save the positions of all other cursors open on this table. This is
76183           /* This block ensures that all data required to recreate the original
76268 ** Release all resources associated with an sqlite3_backup* handle.
77284 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
77304 ** n containing all zeros.
77837 **   * all function arguments are SQL literals,
77946 ** in all cases.
78495 ** Swap all content between two VDBE structures.
78845 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
78899 ** through its operation list and change all values of P2 which match
78979 ** The following type and function are used to iterate through all opcodes
79112   ** through all opcodes and hasAbort may be set incorrectly. Return
79148 ** This routine is called after all opcodes have been inserted.  It loops
79149 ** through all the opcodes and fixes up some details.
79180     ** all these opcodes together near the front of the opcode list.  Skip
79562 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
79806   /* C89 specifies that the constant "dummy" will be initialized to all
80156 ** of all of BtShared structures accessible via the database handle
80162 ** The p->btreeMask field is a bitmask of all btrees that the prepared
80187 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
80356   ** the sum of the number of rows in all trigger subprograms encountered
80795   ** end of the opcode array.  If we are unable to satisfy all memory
80844 ** Close a VDBE cursor and release all the resources that cursor
80877 ** Close all cursors in the current frame.
80919 ** Close all cursors.
81071   /* If there are any write-transactions at all, invoke the commit hook */
81098     /* Do the commit only if all databases successfully complete phase 1.
81204     /* Sync all the db files involved in the transaction. The same call
81433     /* Lock all btrees used by the statement */
81768 ** all auxiliary data pointers currently cached by the VM passed as
81803 ** Free all memory associated with the Vdbe passed as the second argument,
81973 ** the blob of data that it corresponds to. In a table record, all serial
82530   ** all the fields up to that point were equal. Return the default_rc
82796 ** corresponds to an integer - all values between 1 and 9 inclusive
82847 ** Key1 and Key2 do not have to contain the same number of fields. If all
83044   ** all the fields up to that point were equal. Return the default_rc
83421 ** Internally, this function just sets the Vdbe.expired flag on all
83772 ** Set all the parameters in the compiled SQL statement to NULL.
84531 ** auxiliary data pointers that is available to all functions within a
84559 ** to all functions within the current prepared statement using iArg as an
84646   ** instead of an 8-byte one. This all works fine, except that when
85239 ** Transfer all bindings from the first statement over to the second.
85672 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
86456 ** Show the values of all registers in the virtual machine.  Used for
86806 ** for lines of that contain "Opcode:".  That line and all subsequent
86848   ** OP_VNext, or OP_SorterNext) all jump here upon
87011 ** then back out all changes that have occurred during this execution of the
87446   /* Invalidate all ephemeral cursor row caches */
88393 ** on the second and all subsequent encounters during the same invocation.
88549 ** skipped for length() and all content loading can be skipped for typeof().
88701       ** (2) the entire header was used but not all data was used
88741   ** all valid.
88880 ** If P4 is NULL then all index fields have the affinity BLOB.
88941   /* Apply the requested affinity to all inputs
89338       /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
89627     /* Invalidate all prepared statements whenever the TEMP database
89644 ** values need not be contiguous but all P1 values should be small integers.
89870 ** is cleared (all content is erased).
89919     ** OP_OpenDup, then erase all existing content so that the table is
90621 ** contains any NULL value, jump immediately to P2.  If all terms of the
90909     ** to provide the constant while making all compilers happy.
91151 ** delete one of several associated with deleting a table row and all its
91153 ** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
91574 ** After all records have been inserted into the Sorter object
92116 ** might be moved into the newly deleted root page in order to keep all
92168 ** Delete all contents of the database table or index whose root page
92208 ** Delete all contents from the ephemeral table or sorter
92274 ** Read and parse all entries from the schema table of database P1
92355 ** the analysis to be used when preparing all subsequent queries.
92420 ** The root page numbers of all tables in the database are integers
92524 ** must have P4==0, the final set must have P4==-1, and for all other sets
92605   ** single trigger all have the same value for the SubProgram.token
93299 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
94068 ** If P5 is set, then all released registers have their type set
94119 ** The cases of the switch statement above this line should all be indented
94710 ** database handle error code and message set. If this happens, then all
94781 **    sqlite3VdbeSorterRewind()     Sort all content previously added.
94799 **                                  all resources.
94838 ** If the sorter is running in single-threaded mode, then all PMAs generated
94929 ** are connected using SorterRecord.u.pNext.  If aMemory!=0 then all objects
94941 ** one big PMA using a merge operation.  Separate PMAs all need to be
95019 ** Essentially, this structure contains all those fields of the VdbeSorter
95213 ** Free all memory belonging to the PmaReader object passed as the
95251   ** than p->nBuffer bytes remaining in the PMA, read all remaining data.  */
95279     /* The requested data is not all available in the in-memory buffer.
95702   /* Do not allow the total number of threads (main thread + all workers)
95790 ** Free all resources owned by the object indicated by argument pTask. All
95889 ** Join all outstanding threads launched by SorterWrite() to create
95956 ** Free all resources associated with the IncrMerger object indicated by
96353 ** the MergeEngine has reached the end of all its inputs.
96460   ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
96692 ** For multi-threaded objects, all that is required is to wait until the
96848 ** set the PmaReader objects up to read from it. In this case all that is
96907 ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders
96914 ** background thread. In this case all PmaReaders in the sub-tree are
96927 ** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all
96929 ** In this case vdbePmaReaderNext() is called on all child PmaReaders and
97158 ** can be used to incrementally merge all PMAs on disk.
97240 ** all records stored in the sorter.
97354   /* Join all threads */
97360   ** incrementally read and merge all remaining PMAs.  */
97635 ** Clear all internal content from a bytecodevtab cursor.
97823 **    idxNum==0     means show all subprograms
97896 ** This following structure defines all the methods for the
98283 ** all content is always stored in main-memory. Finally, if nSpill is a
98399 ** Walk all expressions linked into the list of Window objects passed
98498 ** Walk all expressions associated with SELECT statement p.  Do
98525 ** Walk the parse trees associated with all subqueries in the
98641 ** resolve all identifiers by associating them with a particular
99203       ** programmers. To all those frustrated programmers, my apologies.
99284     /* Increment the nRef value on all name contexts from TopNC up to
99591           ** in a CHECK constraint.  SQLServer, MySQL, and PostgreSQL all
99592           ** all this. */
99887   /* Resolve all names in the ORDER BY term expression
100191         ** to an identical expression in the result set, remove all Window
100202 ** Resolve names in the SELECT statement p and all of its descendants.
100228   ** sqlite3SelectPrep() do all of the processing for this SELECT.
100269     /* Recursively resolve names in all subqueries
100286         ** the refcount on all contexts between the current one and the
100368     ** below, after all of the result-sets for all of the elements of
100430   /* Resolve the ORDER BY on a compound SELECT after all terms of
100523 ** Resolve all names for all expression in an expression list.  This is
100571 ** Resolve all names in all expressions of a SELECT and in all
100600 ** or which cannot reference any tables at all.  Examples:
100610 ** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
100689 ** i.e. the WHERE clause expressions in the following statements all
101125 ** sqlite3ExprCode() will generate all necessary code to compute
101412 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
101432 ** Propagate all EP_Propagate flags from the Expr.x.pList into
101932 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
102088 ** gatherSelectWindowsCallback() are used to scan all the expressions
102089 ** an a newly duplicated SELECT statement and gather all of the Window
102183 ** If cursors, triggers, views and subqueries are all omitted from
102560 ** Return the bitwise-OR of all Expr.flags fields in the given
102674 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
102698     /* Consider functions to be constant if all their arguments are constant
102847 ** the value of the HAVING clause term must be the same for all members of
103132 ** all members of the RHS set, skipping duplicates.
103161 ** be used to loop over all values of the RHS of the IN operator.
103493 ** Generate code that will construct an ephemeral table containing all terms
103536   ** If all of the above are false, then we can compute the RHS just once
103725   ** If all of the above are false, then we can run this code just once
103748   /* For a SELECT, generate code to put the values for all columns of
104054   ** If any comparison is NULL, then the result is NULL.  If all
106734 ** Mark all temporary registers as being unavailable for reuse.
106962   /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
107427   RenameToken *pNext;    /* Next is a list of all RenameToken objects */
107558 ** Unmap all tokens in the IdList object passed as the second argument.
107602 ** Remove all nodes that are part of expression pExpr from the rename list.
107617 ** Remove all nodes that are part of expression-list pEList from the
107721 ** return all column name tokens in the order that they are encountered
107853   /* Ensure that all mappings in the Parse.pRename list really do map to
107896   ** point to zQuot so that all substitutions are made using the
107910   ** corresponding to all tokens in the input SQL that must be replaced
107955 ** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming
108050 ** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr
108805 ** For most applications, sqlite_stat1 provides all the statistics required
108906 ** all contain just a single integer which is the same as the first
108929 ** or it may be a NULL pointer. If it is not NULL, then all entries in
108931 ** If zWhere==0, then code is generated to delete all stat table entries.
108989       /* The table already exists. If zWhere is not NULL, delete all entries
109004         /* The sqlite_stat[134] table already exists.  Delete all rows. */
109130 ** Reclaim all memory of a StatAccum structure.
109746 ** Generate code to do an analysis of all indices associated with
109952         ** row, we know that all the rest will be distinct, so skip
110175 ** Form 1 causes all indices in all attached databases to be analyzed.
110176 ** Form 2 analyzes all indices the single database named.
110177 ** Form 3 analyzes all indices associated with the named table.
110410       /* If this is stat4 data, then calculate aAvgEq[] values for all
110412       ** once the trailing PK fields are considered all index keys are
110606 ** the Index.aSample[] arrays of all indices.
110682   /* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
111096     ** statement only). For DETACH, set it to false (expire all existing
111235 ** a specific database to all table references where the database name
111804       /* Once all the cookies have been verified and transactions opened,
111912 ** If zDatabase is 0, all databases are searched for the table and the
112079 ** If zDatabase is 0, all databases are searched for the
112122 ** the index hash table and free all memory structures associated
112206 ** Erase all schema information from all attached databases (including
112288   /* Delete all indices associated with this table. */
112332 ** table structure with all its indices and foreign keys.
112589 ** input column is a VIRTUAL table, put it after all the other columns.
112602 ** So, in other words, this routine shifts all the virtual columns to
113686 ** able to find all instances of a reference to the indexed table column
113717 **     (1)  Set all columns of the PRIMARY KEY schema object to be NOT NULL.
113725 **     (5)  Add all table columns to the PRIMARY KEY Index object
113729 **     (6)  Replace the rowid tail on all automatically generated UNIQUE
113789     ** Remove all redundant columns from the PRIMARY KEY.  For example, change
113822   /* Update the in-memory representation of all UNIQUE indices by converting
113856   /* Add all table columns to the PRIMARY KEY index
113926 ** Mark all nodes of an expression as EP_Immutable, indicating that
114033   /* Resolve names in all CHECK constraint expressions.
114079   /* Estimate the average row size for the table and for all implied indices */
114128     ** a schema-lock excludes all other database users, the write-lock would
114188     ** schema table.  We just need to update that slot with all
114290   ** This will force all the Expr.token.z values to be dynamically
114501 ** We must continue looping until all tables and indices with
114561 ** Write VDBE code to erase table pTab and all associated indices on disk.
114654   /* Drop all triggers associated with the table being dropped. Code
114680   /* Drop all entries in the schema table that refer to the
114849 ** of tables in the parent pTo table.  flags contains all
115050   /* Open the table. Loop through all rows of the table, inserting index
115083     ** sqlite3MayAbort() for all CREATE INDEX statements.  */
115704       ** to invalidate all pre-compiled statements.
115732     /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
115750     /* Verify that all REPLACE indexes really are now at the end
116154 ** Assign VdbeCursor index numbers to all tables in a SrcList
116172 ** Delete an entire SrcList including all its substructure.
116281 ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
116320 ** Shifts all join operators from left to right for an entire FROM
116498 ** rollback the whole transaction.  For operations where all constraints
116644 ** Recompute all indices of pTab that use the collating sequence pColl.
116645 ** If pColl==0 then recompute all indices of pTab.
116664 ** Recompute all indices of all tables in all databases where the
116666 ** all indices everywhere.
116695 ** Form 1 causes all indices in all attached databases to be rebuilt.
116696 ** Form 2 rebuilds all indices in all databases that use the named
116697 ** collating function.  Forms 3 and 4 rebuild the named index or all
117099   /* EVIDENCE-OF: R-08308-17224 The default collating function for all
117395 ** Free all resources held by the schema structure. The void* argument points
117724   int iEphCur = 0;       /* Ephemeral table holding all primary key values */
117798   /* Assign cursor numbers to the table and all its indices.
117865   ** the truncate optimization is disabled and all rows are deleted
117900       ** hold all primary keys for rows to be deleted. */
117980     ** deleting from and all its indices. If this is a view, then the
118046     /* End of the loop over all rowids/primary-keys. */
118101 ** all indices are removed.
118110 **   2.  Read/write cursors for all indices of pTab must be open as
118274 ** This routine generates VDBE code that causes the deletion of all
118284 **   2.  Read/write cursors for all indices of pTab must be open as
119637 ** The replace() function.  Three arguments are all strings: call
120539   ** The following array holds FuncDef structures for all of the functions
120787 **   An UPDATE command requires that all 4 steps above are taken, but only
121040   int isIgnore          /* If true, pretend pTab contains all NULL values */
121380 ** FKey.pNextTo) holding all children of table pTab.  For example,
121399 ** and all of its sub-components.
121607   /* Loop through all the foreign key constraints for which pTab is the
121701       ** foreign key, then omit this scan altogether. As all child key
121710   /* Loop through all the foreign key constraints that refer to this table.
121763         ** all OP_FkCounter related scans when either CASCADE or SET NULL
121829 **     and any FK processing at all is required (even of a different FK), or
122104   /* If foreign-key support is enabled, iterate through all FKs that
122124 ** Free all memory associated with foreign key definitions attached to
122373 /* This walker callback will compute the union of colFlags flags for all
122414     /* Change the OP_Affinity argument to '@' (NONE) for all stored
122433   ** this is a two-pass algorithm.  On the first pass, mark all generated
122507 ** The 2nd register is the one that is returned.  That is all the
122558 ** This routine generates code that will initialize all of the
122678 ** above are all no-ops
122702 ** then a list of all (non-hidden) columns for the table is substituted.
122727 ** in other words if the SELECT pulls all columns from a single table
122730 ** schemas, including all the same indices, then a special optimization
122737 **         transfer all records in <table2> over to <table>
122742 **           transfer all records from the read to the write cursors
122929   ** for all columns of the new row.
122940   ** all elements of the IDLIST really are columns of the table and
123136   /* If this is not a view, open the table and and all indices */
123326     /* Compute the new value for generated columns after all other
123397     /* Compute the new value for generated columns after all other
123589 ** The IndexIterator object is used to walk through all of the indexes
123690 ** table and all applicable indices (that is to say, all indices for which
123698 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
123772   int addrRecheck = 0;  /* Jump here to recheck all uniqueness constraints */
123801   /* Test all NOT NULL constraints.
123892         ** first pass, recomputed values for all generated columns, as
123901   /* Test all CHECK constraints
123971   ** list of indexes attached to a table puts all OE_Replace indexes last
123984         ** Make all unique constraint resolution be OE_Ignore */
123988         /* A single ON CONFLICT DO UPDATE.  Make all resolutions OE_Update */
123993       ** iterator to ensure that all of the ON CONFLICT conditions are
124038   ** recheck all of the uniqueness constraints after they have all run.
124046   **   (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
124221   /* Test all UNIQUE constraints by creating entries for each UNIQUE
124298     ** logic below can all be skipped. */
124325     /* Collision detection may be omitted if all of the following are true:
124463           /* Here we insert code that will be invoked after all constraint
124527   /* Recheck all uniqueness constraints after replace triggers have run */
124687 ** Allocate cursors for the pTab table and all its indices and generate
124780 **    *   The same DESC and ASC markings occurs on all columns
124978     ** to do a bulk transfer all of the content from t1 over to t2.
125001       return 0;    /* Affinity must be the same on all columns */
125004       return 0;    /* Collating sequence must be the same on all columns */
125017         return 0;    /* Default values must be the same for all columns */
125169       ** that the destination table is empty. If all indexed columns use
125413 ** The following structure holds pointers to all of the SQLite API
125733 ** This is the function signature used for all extension entry points.  It
126156 ** The following structure contains pointers to all SQLite API routines.
126850 ** Load all automatic extensions.
127052 /* Definitions of all built-in pragmas */
127756 ** set these values for all pagers.
128199         ** set on all attached databases, as well as the main db file.
128410   ** The cache_spill=BOOLEAN setting applies to all attached schemas,
128438   ** used to limit the aggregate size of all memory mapped regions of the
128440   ** is not used at all.  If N is negative, then the default memory map
128669       ** compiler (eg. count_changes). So add an opcode to expire all
129104     ** of all attached databases.  */
129129       Hash *pTbls;     /* Set of all tables in the schema */
129130       int *aRoot;      /* Array of root page numbers of all btrees */
129142       ** for all tables and indices in the database.
129187       /* Make sure all the indices are constructed correctly.
129218         /* Verify that all NOT NULL columns really are NOT NULL */
129365   ** In all cases new databases created using the ATTACH command are
129495   ** Return the names of all compile-time options used in this build,
129596   ** The default MASK is and always shall be 0xfffe.  0xfffe means perform all
129604   ** In the current implementation, a table is analyzed if only if all of
129778   ** Report the current state of file logs for all databases
129974 /* Clear all content from pragma virtual table cursor. */
130561 ** Initialize all database files - the main database file, the file
130619 ** Check schema cookies in all databases.  If any cookie is out
130620 ** of date set pParse->rc to SQLITE_SCHEMA.  If all schema cookies
130700 ** Free all memory allocations in the pParse object
130804   /* Check to verify that it is possible to get a read lock on all
130816   ** This thread is currently holding mutexes on all Btrees (because
130824   ** but it does *not* override schema lock detection, so this all still
131230 ** Delete all the content of a Select structure.  Deallocate the structure
131335 ** Delete the given Select structure and all of its substructures.
131518 ** Set the EP_FromJoin property on all terms of the given expression.
131949 ** for all cursors required to evaluate all selected expressions. Finally.
131951 ** expressions for all extra PK values that should be stored in the
132188         ** row is all NULLs.
132390     ** pSO->nExpr columns, then make sure all keys are unique by adding a
132407         ** on a second ephemeral index that holds all values every previously
132806 ** result-set expression in all of the following SELECT statements is
133017 ** deprecated.  The default setting is short=ON, full=OFF.  99.9% of all
133227 ** This routine requires that all identifiers in the SELECT
133360   ** "LIMIT -1" always shows all rows.  There is some
133484 ** inserted into the Queue table.  The iDistinct table keeps a copy of all rows
133494 ** negative LIMIT means to output all rows.  If there is also an OFFSET clause
133792   /* Make sure all SELECTs in the statement have the same number of elements
134036   ** Attach the KeyInfo structure to all temporary tables.
134096     sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
134328 ** until all data is exhausted then jump to the "end" labe.  AltB, AeqB,
134821 ** The array is guaranteed by the caller to be large enough for all
134867 ** the FROM clause of (*p). Update all expressions and other references
134876 **   * the array entries for all cursor numbers that do *not* appear in
134947 **        (4) has since been expanded to exclude all DISTINCT subqueries.
134984 **        (17a) all compound operators must be a UNION ALL, and
134997 **        operator other than UNION ALL because all the other compound
135003 **        SELECT statement, but all the code here does is make sure that no
135007 **  (18)  If the sub-query is a compound select, then all terms of the
135129   ** which is not at all the same thing.
135134   ** the LEFT JOIN table should be all-NULL.
135322   ** This loop moves all of the FROM elements of the subquery into the
135345     ** then expand the outer query to make space for it to hold all elements
135471 ** A structure to keep track of all of the column values that are fixed to
135530 ** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
135595 ** replace all other occurrences of COLUMN with CONSTANT.
135665 ** BY clause of all window function used by the sub-query. It is safe
135741 **          all window-functions used by the sub-query. It is safe to
136375   /* Make sure cursor numbers have been assigned to all entries in
136466   ** all columns in all tables.  And for every TABLE.* insert the names
136467   ** of all columns in TABLE.  The parser inserted a special expression
136470   ** expressions and expand each one to the list of all columns in
136471   ** all tables.
136651 ** This routine "expands" a SELECT statement and all of its subqueries.
136723 ** the Table structures of all FROM-clause subqueries in a
136744 **     *  VDBE Cursor numbers are assigned to all FROM-clause terms.
136745 **     *  Ephemeral Table objects are created for all FROM-clause subqueries.
136750 ** This routine acts recursively on all subqueries within the SELECT.
136772 ** routine generates code that stores NULLs in all of those memory
136783   /* Verify that all AggInfo registers are within the range specified by
137072 ** The transformation only works if all of the following are true:
137411   ** (2) Generate code for all sub-queries
137443     /* Generate code for all sub-queries in the FROM clause
137600     SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
137785     /* Remove any and all aliases between the result set and the
137833     ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
137926       ** that we do not need it after all, the OP_SorterOpen instruction
137952       /* Begin a loop that will extract all source rows in GROUP BY order.
138386   ** the names of all columns.
138559 ** Given table pTab, return a list of all the triggers attached to
138564 ** triggers on pTab in the TEMP schema.  This routine prepends all
138568 ** To state it another way:  This routine returns a list of all triggers
138805     ** Normally, whenever a table is dropped, all associated triggers are
138820 ** This routine is called after all of the trigger actions have been parsed
138908 ** Duplicate a range of text from an SQL statement, then convert all
139243 ** Return a list of all triggers on table pTab if there exists at least
139967 ** If the former, then all row-records are guaranteed to include a value
140098 ** If the table is actually a view, then <other-columns> are all columns of
140250   int iEph = 0;          /* Ephemeral table holding all primary key values */
140322   /* Allocate a cursors for the main database table and for all indices.
140367   /* Resolve the column names in all the expressions of the
140463   ** case, set all bits of the colUsed mask (to ensure that the virtual
140464   ** table implementation makes all columns available).
140500     /* If REPLACE conflict resolution might be invoked, open cursors on all
140547   /* Resolve the column names in all the expressions in the
140619       /* If this is an UPSERT, then all cursors have already been opened by
140893       ** all columns not modified by the update statement into their registers
141009   ** all record selected by the WHERE clause have been updated.
141333 ** Analyze the ON CONFLICT clause described by pUpsert.  Resolve all
141359   /* Resolve all symbolic names in the conflict-target clause, which
141648 **   (2)  Copy all content from the database being vacuumed into
141873   ** associated storage, so all we have to do is copy their entries
142007 ** routine is called, it is guaranteed that all appropriate locks are held
142111 ** External API to drop all virtual-table modules, except those named
142154 ** the disconnect is deferred until all locks have been removed.
142196 ** Table p is a virtual table. This function moves all elements in the
142238 ** used when closing database connection db to free all of its VTable
142261 ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
142263 ** This function may only be called when the mutexes associated with all
142268 **   1) By this function. In this case, all BtShared mutexes and the mutex
142298 ** Clear any and all virtual-table information from the Table record.
142443     ** schema table.  We just need to update that slot with all
142918 ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
142920 ** SQLITE_OK if all xSync operations are successful.
142943 ** Invoke the xRollback method of all virtual tables in the
142952 ** Invoke the xCommit method of all virtual tables in the
143014 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
143025 ** function immediately. If all calls to virtual table methods are successful,
143106   ** with an all lower-case function name.  Continue in this tradition to
143419 ** one WhereLoop object per FROM clause term, that satisfy all dependencies
143482 ** that implement some or all of a query plan.
143490 ** or all of the WhereLoop objects once.
143499   Bitmask maskLoop;     /* Bitmask of all WhereLoop objects in this path */
143623 ** An instance of the following structure holds all information about a
143655   Bitmask indexable;       /* Bitmask of all indexable tables in the clause */
143689 ** numbers all get mapped into bit numbers that begin with 0 and contain
143704 ** This object is a convenience wrapper holding all information needed
143757   WhereExprMod *pNext;  /* Next translation on a list of them all */
143789   unsigned untestedTerms :1;   /* Not all WHERE terms resolved by outer loop */
143795   WhereLoop *pLoops;        /* List of all WhereLoop objects */
143868 ** Bitmasks for the operators on WhereTerm objects.  These are all
143894 #define WO_ALL    0x1fff       /* Mask of all possible WO_* values */
143895 #define WO_SINGLE 0x01ff       /* Mask of all non-compound WO_* values */
144184 ** If all the children of a term are disabled, then that term is also
144229 ** are no-ops) at the beginning and end of zAff are ignored.  If all entries
144292 ** LHS.  But not all terms in the vector are indexable and the terms might
144398 ** this routine sets up a loop that will iterate over all values of X.
144537 ** Generate code that will evaluate all == and IN constraints for an
144553 ** The nExtraReg parameter is 0 or 1.  It is 0 if all WHERE clause constraints
144920     /* If we survive all prior tests, that means this term is worth hinting */
144951 ** does not appear in the index at all, the array entry is set to 0.
145161 ** a partial index that is driving a query loop.  Look through all of the
145516     **         index is on (x,y,z), then the following clauses are all
145659     /* Generate code to evaluate all constraint terms using == or IN
145865       ** all the expressions in pWInfo and try to transform matching expressions
145873       ** as the result of the expression may not be NULL, even if all table
145990     ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
146171           /* If all of the OR-connected terms are optimized using the same
146178           ** processed or the index is the same as that used by all previous
146256   ** iLoop==3: Code all remaining expressions.
146430 ** Deallocate all memory associated with a WhereOrInfo object.
146438 ** Deallocate all memory associated with a WhereAndInfo object.
146634     ** consists of at least one character after all escapes have been
146642       /* Get the pattern prefix.  Remove all escapes from the prefix. */
146973 ** If all subterms are of the form T.C=expr for some single column of C and
146996 ** If all subterms are indexable by a single table T, then set
147025 ** the union of all rowids using a RowSet object.  This is similar
147162   ** sure the same column is used on all terms.  The 2-bit case is when
147163   ** the all terms are of the form "table1.column=table2.column".  It
147174     int iCursor = -1;         /* Table cursor common to all terms */
147458 **   bUses==1   false      pExpr contains no sub-selects and all TK_COLUMN
147464 **   bUses==0   false      pExpr contains no sub-selects and all TK_COLUMN
147490 ** Iterate through all AND connected nodes in the expression tree
147689 ** subexpression and populate all the other fields of the WhereTerm
147933   ** for LIKE) then the lower-bound is made all uppercase and the upper-
147934   ** bound is made all lowercase so that the bounds also work when comparing
147976         ** LIKE on all candidate expressions by clearing the isComplete flag
148141 ** all terms of the WHERE clause.
148245 ** Call exprAnalyze on all terms in a WHERE clause.
148337 ** agree on the structure, all will be well.
148367 ** terms means that no sorting is needed at all.  A return that
148378 ** inner-most loop did not fit within the sorter, then we can skip all
148744 ** aiCur[]/iaColumn[] arrays hold X and all its equivalents. There are 11
148871   /* Loop through all indices on the table, checking each to see if it makes
149118   ** covering index.  A "covering index" is an index that contains all
149423 ** Estimate the location of a particular key among all keys in an
149462   ** than one fields, all fields following the first are ignored.
149554       ** all samples in the aSample[] array, pRec must be smaller than the
149562       /* if i==0 and iCol==0, then record pRec is smaller than all samples
149588     ** is larger than all samples in the array. */
149670 ** It does this by scanning through all stat4 samples, comparing values
150003   /* If values are not available for all fields of the index to the left
150293 ** Return TRUE if all of the following are true:
150968     ** values of nIn and nInMul. In other words, assuming that all
151202 ** Add all WhereLoop objects for a single table of the join where the table
151273     ** fake index the first in a chain of Index objects with all of the real
151350   /* Loop over all indices. If there was an INDEXED BY clause, then only
151492 ** Argument pIdxInfo is already populated with all constraints that may
151687 ** Add all WhereLoop objects for a table of the join identified by
151691 ** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause
151694 ** mUnusable mask contains all FROM clause entries that occur after the
151705 ** table. So any terms for which all prerequisites are satisfied by
151706 ** mPrereq may be specified as "usable" in all calls to xBestIndex.
151707 ** Conversely, all tables in mUnusable must be scanned after the current
151748   /* First call xBestIndex() with all constraints usable. */
151750   WHERETRACE(0x40, ("  VirtualOne: all usable\n"));
151753   /* If the call to xBestIndex() with all terms enabled produced a plan
151756   ** any further calls to xBestIndex() since they will all return the same
151767       WHERETRACE(0x40, ("  VirtualOne: all usable w/o IN\n"));
151804     ** that requires no source tables at all (i.e. one guaranteed to be
151805     ** usable), make a call here with all source tables disabled */
151807       WHERETRACE(0x40, ("  VirtualOne: all disabled\n"));
151814     ** that requires no source tables at all and does not use an IN(...)
151817       WHERETRACE(0x40, ("  VirtualOne: all disabled and w/o IN\n"));
151933         ** of all sub-scans required by the OR-scan. However, due to rounding
151956 ** Add all WhereLoop objects for all tables
152066   Bitmask obDone;       /* Mask of all ORDER BY terms */
152067   Bitmask orderDistinctMask;  /* Mask of all well-ordered loops */
152072   ** row of output.  A WhereLoop is one-row if all of the following are true:
152177       /* Loop through all columns of the index and deal with the ones
152315       } /* end Loop over all index columns */
152337   } /* End the loop over all WhereLoops from outer-most down to inner-most */
152949 ** Display all WhereLoops in pWInfo
152952   if( sqlite3WhereTrace ){    /* Display all of the WhereLoop objects */
152998 ** scanning through all values on the right-hand side of the IN.
153020 ** loops are evaluated and if false a jump is made around all subsequent
153052 ** the first cursor in an array of cursors for all indices.  iIdxCur should
153058   SrcList *pTabList,      /* FROM clause: A list of all tables to be scanned */
153113   /* This function normally generates a nested loop for all tables in
153180     ** a table T, then X-1 is the bitmask for all other tables to the left of T.
153181     ** Knowing the bitmask for all tables to the left of a left join is
153184     ** Note that bitmasks are created for all pTabList->nSrc tables in
153206   /* Analyze all of the subexpressions. */
153211   ** (constant expressions). Evaluate each such term, and jump over all the
153260   if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */
153274     ** then we need to rerun the whole loop building process so that all
153279            ("**** Redo all loop computations due to"
153410   if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */
153457   /* Open all tables in the pTabList and any indices selected for
153805     /* For a co-routine, change all OP_Column references to the table of
153817     /* Close all of the cursors that were opened by sqlite3WhereBegin.
153846     ** directly.  This loop scans all that code looking for opcodes
153921   /* Undo all Expr node modifications */
153980 **     * FROM, WHERE, GROUP BY and HAVING clauses are all moved to
154027 **     * The results of all window-functions for the row are stored
154518 /* Window functions that use all window interfaces: xStep, xFinal,
154534 /* Window functions that use all window interfaces: xStep, the
154694   ** not process aggregates or window functions at all, as they belong
155492 **   Depending on the window-frame in question, all three cursors may not
155546 ** already populated with all columns from the current row of the sub-query.
155699 ** Generate code to calculate the current values of all window functions in the
155799 ** return the current row of Window.iEphCsr. If all window functions are
155801 ** OP_Gosub instruction is all that this routine generates. Extra VM code
156037   ** Since all strings and blobs are greater-than-or-equal-to an empty string,
156048   ** consider NULL values to be larger than all other values, instead of
156348 **         // Rewind three cursors, all open on the eph table.
156357 **         // rows. The first row in the partition, which all three cursors
156386 **               current row of csrCurrent and the current state of all
156551 **      all subsequent rows belonging to the same group.
157017 ** Disable all error recovery processing in the parser push-down
157099   ** all elements in the list.  And make sure list length does not exceed
157429 **                       Terminal symbols all have the same minor type, though.
157432 **    YYMINORTYPE        is the data type used for all minor types.
157569 **  yy_action[]        A single table containing all actions.
158460 /* For tracing shifts, the names of all terminals and nonterminals
158783 /* For tracing reduce actions, the names of all rules are required.
159431 ** Clear all secondary memory allocations from the parser
159444 ** all stack elements before shutting the parser down.
161562   Token all;
161563   all.z = yymsp[-3].minor.yy0.z;
161564   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
161565   sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy483, &all);
162347 ** a lookup table is used, all of the classes need to be small integers and
162348 ** all of them need to be used within the switch.
163764 ** This means that a SQL string of all whitespace is invalid.
163766 ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
164219 ** all database files specified with a relative pathname.
164340   ** methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
164648         ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
164654         ** alternative memory allocator is engaged to handle all of SQLites
165166 ** Close all open savepoints. This function only manipulates fields of the
165199 ** Disconnect all sqlite3_vtab objects that belong to database connection
165261   /* Force xDisconnect calls on all virtual tables */
165299 ** transaction state over all attached databases if zSchema is null.
165346 ** finished, then free all resources.
165362   ** closed all sqlite3_stmt and sqlite3_backup objects and has been
165364   ** go ahead and free all resources.
165376   /* Close all database connections */
165462 ** Rollback all database files.  If tripCode is not SQLITE_OK, then
165475   /* Obtain all b-tree mutexes before making any calls to BtreeRollback().
165928   ** operation to continue but invalidate all precompiled statements.
166454     iDb = SQLITE_MAX_DB;   /* This means process all schemas */
166480 ** to contains a zero-length string, all attached databases are
166503 ** If iDb is passed SQLITE_MAX_DB then all attached databases are
166981           ** case we ignore all text in the remainder of the path, name or
167192   ** off all other flags.
167394   /* Register all built-in functions, but do not attempt to read the
167428   ** mode.  Doing nothing at all also makes NORMAL the default.
167714 ** This is a convenience routine that makes sure that all thread-specific
167822   ** this has the effect of zeroing all output parameters.
168249     ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
168251     ** effect of erasing all imposter tables.
168270     ** -DYYCOVERAGE) writes a report onto "out" that shows all
168767 ** Head of a linked list of all sqlite3 objects created by this process
169254 ** is encoded.  The subtree at iBlockid will contain all terms less
169255 ** than the first term encoded (or all terms if no term is encoded).
169294 ** leaves_end_block, and end_block are all 0.
169304 ** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
169310 ** A segment merge traverses all segments at a given level in
169314 ** After the merge, all segment blocks from the merged level are
169388 ** SQLITE_ENABLE_FTS3 macro.  But to avoid confusion we also all
169661 ** Macros for looping over all elements of a hash table.  The idiom is
169741 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
169747 ** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
169748 ** level values between 0 and 1023 (inclusive) belong to index 0, all levels
169915   ** there is an entry in the aIndex[] array. Index 0 is an index of all the
169921   ** malloc overhead.  When nPendingData exceeds nMaxPendingData, all hash
170009 ** indicating that all columns should be searched,
170840 ** with all double quote characters escaped. For example:
170932 ** If argument zFunc is not NULL, then all but the first question mark
171126     sqlite3_int64 nStr = 0;       /* Size of all column names (incl. 0x00) */
171190   int nString = 0;                /* Bytes required to hold all column names */
171235   /* Loop through all of the arguments passed by the user to the FTS3/4
171236   ** module (i.e. all the column names and special arguments). This loop
171363   **      TABLE statement, use all columns from the content table.
171781 ** Free all resources currently held by the cursor passed as the only
171965     ** to the term from the interior node, then all terms on the sub-tree
172223 ** into *pp contains all positions of both *pp1 and *pp2 in sorted
172579 ** This function does an "OR" merge of two doclists (output contains all
172626   ** the input list). The same argument applies to all but the first docid
172627   ** read from the 'other' list. And to the contents of all position lists
172809 ** Merge all doclists in the TermSelect.aaOutput[] array into a single
172810 ** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
172822   /* Loop through the doclists in the aaOutput[] array. Merge them all
172863 ** a queried prefix. It merges all these doclists into one, the doclist
173089 ** if isPrefix is true, to scan the doclist for all terms for which
173169   int iColumn,                    /* Column to query (or -ve for all columns) */
173381   ** statement loops through all rows of the %_content table. For a
173769 ** function merges all segments in the database to a single segment.
174145 ** within the union of all segments of a b-tree. Hence the name.
174704       sqlite3_int64 iMax = 0;     /* Largest docid for all iterators */
174718       /* Keep advancing iterators until they all point to the same document */
174802 ** Otherwise, fts3EvalPhraseStart() is called on all phrases within the
174804 ** expressions for which all descendent tokens are deferred.
174933     ** data stored in all rows of each column of the table, from left
175024   /* Iterate through all tokens in this AND/NEAR cluster, in ascending order
175061       /* The number of overflow pages to load for this (and therefore all
175063       ** that will be loaded if all subsequent tokens are deferred.
175257 **      the db. In this case the position-list is not populated at all.
175411 ** phrase instances sufficiently close to their peers to satisfy all NEAR
175515         ** all phrases involved in the NEAR. This is because the snippet(),
175720 ** expression rooted at pExpr, the cursor iterates through all rows matched
175763 ** for all other phrases that are part of the NEAR expression.
175855 **      the FTS table (considering all rows), and
175868 **   * If a phrase consists entirely of deferred tokens, then all output
176056 ** Free all components of the Fts3Phrase structure that were allocated by
176158 ** This function does all the work for both the xConnect and xCreate methods.
176951   ** Fts3PhraseToken structures token buffers are all stored as a single
176963   **   Buffer zTemp: Contains copies of all tokens.
177131       /* Turns out that wasn't a keyword after all. This happens if the
178025 /* Remove all entries from a hash table.  Reclaim all memory.
178030   Fts3HashElem *elem;         /* For looping over all elements of the table */
178723     /* Do nothing.  The work was all in the test */
178731        /* Do nothing.  The work was all in the test */
178918 ** part of a token.  In other words, delimiters all must have
179915 ** This function does all the work for both the xConnect and xCreate methods.
180269 ** memory incrementally instead of all at once. This can be a big performance
180271 ** method before retrieving all query results (as may happen, for example,
180437 ** the tree is assembled in memory and written out only once all leaves have
180807 ** all rows in the %_segdir table, from oldest to newest. If successful,
181007 ** Tokenize the nul-terminated string zText and add all tokens to the
181251 ** Remove all data from the FTS3 table. Clear the hash table containing
181286 ** (an integer) of a row about to be deleted. Remove all terms from the
181379     ** full, merge all segments in level iLevel into a single iLevel+1
181727       ** normally all that is required to move pointer p to the desired
181812 ** Free all allocations associated with the iterator passed as the
182106 ** the array around until all entries are in sorted order.
182370 ** Write the buffer for the segment node pTree and all of its peers to the
182424 ** Free all memory allocations associated with the tree pTree.
182597 ** Flush all data associated with the SegmentWriter object pWriter to the
182598 ** database. This function must be called after all terms have been added
182635 ** Release all memory held by the SegmentWriter object passed as the
182744 ** Delete all entries in the %_segments table associated with the segment
182771 **   1) Deletes all %_segments entries for the segments associated with
182775 **   2) deletes all %_segdir entries with level iLevel, or all %_segdir
183138     /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
183146     ** to does not share a suffix with pFilter->zTerm/nTerm, then all
183347     /* Loop through all entries in the %_segdir table corresponding to
183349     ** at least one such segment, and it is possible to determine that all
183384         /* Loop through all %_segdir entries for segments in this index with
183389         ** In other words, move all segments being promoted to level -1,
183424 ** Merge all level iLevel segments in the database into a single
183425 ** iLevel+1 segment. Or, if iLevel<0, merge all segments into a
183465     /* This call is to merge all segments in the database to a single
183477     /* This call is to merge all segments at level iLevel. find the next
183646 **                   the column for all rows of the table.
183648 **   Varint 1+nCol:  The total size, in bytes, of all text values in all
183649 **                   columns of all rows of the table.
184031 ** Release all dynamic resources held by node-reader object *p.
184296 ** This function is called to release all dynamic resources held by the
184298 ** all outstanding node buffers held by pWriter to disk.
184362   /* Flush all currently outstanding nodes to disk. */
184448 **   * It was initially created as an appendable segment (with all required
184600 ** one before returning SQLITE_OK. Or, if there are no segments at all
184812 ** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes)
184819   const char *zTerm,              /* Omit all terms smaller than this */
184865 ** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute
184954 ** Each input segment is either removed from the db completely (if all of
184962   Fts3MultiSegReader *pCsr,       /* Chomp all segments opened by this cursor */
184989       /* The incremental merge did not copy all the data from this
185407 ** Return a checksum of all entries in the FTS index that correspond to
185497   sqlite3_stmt *pAllLangid = 0;   /* Statement to return all language-ids */
185595 ** The checksums for all entries in the index are XORed together to create
185667 ** Delete all cached deferred doclists. Deferred doclists are cached
185679 ** Free all entries in the pCsr->pDeffered list. Entries are added to
185694 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
185699 ** table, not for all rows.
185828         ** delete the contents of all three tables and throw away any
186002 ** merge all segments in the database (including the new segment, if
186294 ** Iterate through all phrase nodes in an FTS3 query, except those that
186301 ** all eligible phrase nodes.
186336 ** phrases in the expression (all phrases except those directly or
186338 ** pnToken is not NULL, then it is set to the number of tokens in all
186592     /* Loop through all candidate snippets. Store the best snippet in
186948 ** of the matchinfo array that are constant for all rows returned by the
186959 ** where X is the number of matches for phrase iPhrase is column iCol of all
186963 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
187116 ** finished iterating through all offsets for all columns.
187243 ** If bGlobal is true, then populate all fields of the matchinfo() output.
187476   ** size that contains at least one instance of all phrases in the query
187513       /* Loop through all columns of the table being considered for snippets.
187514       ** If the iCol argument to this function was negative, this means all
187536     /* If all query phrases seen by fts3BestSnippet() are present in at least
187892 ** all characters in string zIn/nIn to be separators (if bAlnum==0) or
187899 ** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all
188109   ** Return SQLITE_DONE early if this takes us all the way to the end of
188430   ** to all nRange codepoints (i.e. all nRange codepoints are upper case and
188580 ** For the time being, all JSON is stored as pure text.  (We might add
188775 /* Free all allocated memory and reset the JsonString object back to its
188973 ** Reclaim all memory allocated by a JsonParse object.  But do not
189078 ** Return a JsonNode and all its descendents as a JSON string.
189507 ** are any errors.  If an error occurs, free all memory associated with
189543 ** to fill in all the descendants of node i.
189570 ** Compute the parentage of all nodes in a completed parse.
189915 ** Mark all NULL entries in the Object passed in as JNODE_REMOVE.
190018 ** array that contains all values given in arguments.  Or if any argument
190227 ** object that contains all name/value given in arguments.  Or if any name
190447 ** Return a JSON array composed of all values in the aggregate.
190501 ** to the first comma (",") that is not within a string and deleting all
190549 ** Return a JSON object composed of all names and values in the aggregate.
191439 ** Therefore all non-root nodes must contain at least 3 entries. Since
191784 ** Clear the content of node p (set all bytes to 0x00).
191953   ** of the r-tree structure. A height of zero means all data is stored on
192577 ** iLevel values coming first.  In this way, if rScore is the same for all
193432 ** all ancestor elements.
193486 ** Arguments aIdx, aDistance and aSpare all point to arrays of size
193558 ** Arguments aIdx, aCell and aSpare all point to arrays of size
193765   ** all cells from node pLeft. Then zero the original node.
193810   ** In this case avoid the all to nodeWrite().
193882 ** still NULL, load all ancestor nodes of pLeaf into memory and populate
193883 ** the pLeaf->pParent chain all the way up to the root node.
195025 ** deserialize all nodes, a statement like:
195081 ** The depth value is 0 for all nodes other than the root node, and the root
195583 ** access to all of the R-Tree internals.
196452   GeoEvent *aEvent;          /* Array of all events */
196453   GeoSegment *aSegment;      /* Array of all segments */
196503 ** Insert all segments and events for polygon pPoly.
196507   GeoPoly *pPoly,         /* Take all segments from this polygon */
197699     **     1. uPattern is an unescaped match-all character "%",
198416 **     b-tree are completed before moving on to the next, and all
198456 **  collected in the rbu_xyz table. And for both UPDATEs and DELETEs all
198506 ** and all but guarantees each modified leaf page is loaded and stored
198560 ** The "rbu_control" column should have no type at all. For example, if
198597 ** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
198632 ** the new values of all columns being update. The text value in the
198720 ** To remove all RBU extension state information, returning an RBU database
198721 ** to its original contents, it is sufficient to drop all tables that begin
198777 ** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of
198838 ** In all cases the returned value is the current limit in bytes (zero
198894 ** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
199057 ** file-system via "rbu" all the time, even if it only uses RBU functionality
199067 ** before all database handles that use it have been closed, the results
199225 ** An iterator of this type is used to iterate through all objects in
199239 **   If there are one or more partial indexes on the table, all fields of
199336 **   for all source tables in the RBU database, where nRow is the number
199371   int nProgress;                  /* Rows processed for all objects */
199390   i64 szTemp;                     /* Current size of all temp files in use */
199793 ** Finalize all statements and free all allocations that are specific to
200362     /* Check that all non-HIDDEN columns in the destination table are also
201083 ** An imposter table is required in all cases except RBU_PK_VTAB. Only
202744 ** considered equal, and NULL is considered distinct from all other values.
202890 ** for all rows in the rbu_count table, where nIndex is the number of
203087 ** Allocate and return an RBU handle with all fields zeroed except for the
203145 ** then edit any error message string so as to remove all occurrences of
203346 **    to point to the new file. A mutex protected linked list of all main
203377 **     mode except RBU_STAGE_DONE (all work completed and checkpointed), it
203382 ** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
203383 **     all xWrite() calls on the target database file perform no IO.
203422 ** There are two main-db lists. One for all file descriptors, and one
203423 ** for all file descriptors with rbu_file.pDb!=0. If the argument has
204030     ** mutex protected linked list of all such files.  */
204366   " mx_payload INTEGER,"       /*  7 Largest payload size of all cells */
204673 /* Populate the StatPage object with information about the all
205522 ** on them all.
205619   int bIndirect;                  /* True if all changes are indirect */
205683 ** The keys of the SessionTable.aChange[] hash table are all rows that have
205748 ** but may occur in any order (i.e. deletes, updates and inserts are all
205778 ** Within the old.* record associated with an UPDATE change, all fields
205812 ** For a DELETE change, all fields within the record except those associated
205816 ** For an UPDATE change, all fields except those associated with PRIMARY KEY
206812       /* Create a new change object containing all the old values (if
206851       ** preupdate_new() or SerializeValue() calls below may fail as all
207355   /* Delete all attached table objects. And the contents of their
207359   /* Assert that all allocations have been freed and then free the
207653 ** If all of the old.* values are equal to their corresponding new.* value
207654 ** (i.e. nothing has changed), then no data at all is appended to the buffer.
207656 ** Otherwise, the old.* record contains all primary key values and the
207868 ** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
208085 ** Obtain a changeset object containing all changes recorded by the
208122 ** Obtain a patchset object containing all changes recorded by the
208285 ** if there are not nByte bytes remaining in the input, that all available
208379 ** It is the responsibility of the caller to free all sqlite_value structures
208456 ** This function ensures that all of the above is present in the input
208621   /* Make sure the buffer contains at least 10 bytes of input data, or all
208692       /* If this is an UPDATE that is part of a patchset, then all PK and
208851 ** they omit all error checking and return a pointer to the requested value.
208888 ** In all other cases this function returns SQLITE_MISUSE.
209030         /* Write the new new.* record. Consists of a copy of all values
209294 ** Free all cached UPDATE statements.
209497 ** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
209783     ** bind values for all columns and set bound variable (nCol+1) to true.
209790     **   * all columns of the table are PK columns (in this case there is
210503 ** Add all changes in the changeset traversed by the iterator passed as
210612 ** Serialize a changeset (or patchset) based on all changesets (or patchsets)
210711 ** of all changesets added to the group so far.
211262 **   the total number of tokens in column iCol, considering all rows in
211303 **   Set *pnInst to the total number of occurrences of all phrases within
211366 **   more than once for a single FTS query, then all invocations share a
211402 **   method, to iterate through all instances of a single query phrase within
211426 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
211434 **   of iterating through all instances of a phrase in the current row, these
211450 **   then this API always iterates through an empty set (all calls to
211596 **   all instances of "first place" or "1st place" regardless of which form
211601 **   <ol><li> By mapping all synonyms to a single token. In this case, using
211610 **       <li> By querying the index for all synonyms of each query term
211908 ** An instance of the following structure encodes all information that can
211911 ** And all information loaded from the %_config table.
212178 ** Open a new iterator to iterate though all rowids that match the
212656 ** The following is the concatenation of all %include directives from the
212665 ** Disable all error recovery processing in the parser push-down
212731 **                       Terminal symbols all have the same minor type, though.
212734 **    fts5YYMINORTYPE        is the data type used for all minor types.
212858 **  fts5yy_action[]        A single table containing all actions.
213022 /* For tracing shifts, the names of all terminals and nonterminals
213056 /* For tracing reduce actions, the names of all rules are required.
213268 ** Clear all secondary memory allocations from the parser
213281 ** all stack elements before shutting the parser down.
214131 ** Object used to iterate through all "coalesced phrase instances" in
216307   Fts5Colset *pColset;            /* Columns to search (NULL -> all columns) */
216321   Fts5ExprPhrase **apPhrase;      /* Array of all phrases */
217074 ** Initialize all term iterators in the pNear object. If any term is found
217075 ** to match no documents at all, return immediately without initializing any
217192 ** considered to be larger. Nodes at EOF are the largest of all.
217210 ** this function is called. This function checks if all term iterators
217228   int bMatch;                     /* True if all terms are at the same rowid */
217329     /* Set the EOF flag if either all synonym iterators are at EOF or an
217624     /* Initialize all term iterators in the NEAR object. */
217952 ** phrase object consisting of all tokens returned.
217993       ** no token characters at all. (e.g ... MATCH '""'). */
218064     ** no token characters at all. (e.g ... MATCH '""'). */
218289 ** Recursively apply colset pColset to expression node pNode and all of
218330 ** Apply colset pColset to expression node pExpr and all of its descendents.
219682 ** Extract all tokens from hash table iHash and link them into a list
219822 ** routines in this file file implement all read and write access to the
219833 ** The %_data table contains all the FTS indexes for an FTS5 virtual table.
219837 **   * all segment b-tree leaf data is stored in fixed size page records
219882 **   there are one or more prefix indexes), it is guaranteed that all share
219889 **     + total number of segments on all levels,
219905 **   from left to right, the total number of tokens in the column for all
220305 ** considered to be greater than all other iterators.
220593 ** Remove all records associated with segment iSegid.
221511     ** merge and all data has already been "trimmed". See function
223047 ** against no columns at all).
223074 ** The last point is to ensure all column numbers are stored as
223178 ** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
223191   int iLevel,                     /* Level to iterate (-1 for all) */
223433 ** Discard all data currently cached in the hash-tables.
223557 ** is larger than all terms written to earlier leaves, and equal to or
223577 ** terms at all to disk.
224073     /* Read input from all segments in the input level */
224276 ** Buffer aBuf[] contains a list of varints, all small enough to fit
224477   **  + all segments are on the same level, or
224478   **  + all segments except one are currently inputs to a merge operation.
224507       /* Iterate through all segments, from oldest to newest. Add them to
224781 ** Array aBuf[] contains nBuf doclists. These are all merged in with the
224803   ** linking any iterators already at EOF into the linked list at all. */
225061 ** Indicate that all subsequent calls to sqlite3Fts5IndexWrite() pertain
225277 ** Open a new iterator to iterate though all rowid that match the
225291   /* If the QUERY_SCAN flag is set, all other flags must be clear. */
225472 ** Set the 32-bit cookie value stored at the start of all structure
225945 ** checksum does not match. Return SQLITE_OK if all checks pass without
225978   ** based on all expected entries in the FTS index (including prefix index
226592 ** all registered FTS5 extensions - tokenizers and auxiliary functions.
226598   Fts5Auxiliary *pAux;            /* First in list of all aux. functions */
226599   Fts5TokenizerModule *pTok;      /* First in list of all tokenizer modules */
226601   Fts5Cursor *pCsr;               /* First in list of all open cursors */
227244 ** is moved to point at a different row. It clears all cached data
227356 ** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors
227372 ** argument, close and reopen all Fts5IndexIter iterators that the cursor
228041   if( 0==sqlite3_stricmp("delete-all", zCmd) ){
228044           "'delete-all' may only be used with a "
228443     /* Initialize all iterators */
229622 ** Drop all shadow tables. Return SQLITE_OK if successful or an SQLite error
229789     /* Finalize all SQL statements */
230004 ** Delete all entries in the FTS5 index.
231977 **     all other tokenizers - FTS5_PATTERN_NONE
231991 ** Register all built-in tokenizers with FTS5.
232141   ** to all nRange codepoints (i.e. all nRange codepoints are upper case and
233089 ** for all bytes that have the 8th bit set and one byte with the 8th
233176 **     CREATE TABLE vocab(term, doc, col, offset, PRIMARY KEY(<all-fields>));
233214   /* Output values used by all tables. */
233946 ** about all prepared statements for the database connection.
233994 **    (1) Allocate the stmt_vtab object and initialize all fields.
234175 ** This following structure defines all the methods for the

Indexes created Thu May 30 22:23:56 MDT 2024