3 ** version 3.14.1.  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 ** In all cases, the special comment must be enclosed in the usual
182 ** code in all source files.
193 ** on 2008-11-28.) These days, all Linux kernels support large files, so
340 ** that we have taken it all out and gone back to using simple
547 ** the [sqlite3] object is successfully destroyed and all associated
561 ** Applications should [sqlite3_finalize | finalize] all [prepared statements],
562 ** [sqlite3_blob_close | close] all [BLOB handles], and 
563 ** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated
568 ** of resources is deferred until all [prepared statements], [BLOB handles],
819 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
883 ** xSync VFS method occur and applies uniformly across all platforms.
957 ** core reserves all opcodes less than 100 for its own use.
985 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1109 ** to be adjusted.  The values are changed for all database connections
1150 ** all [VFSes] in the VFS stack.  The names are of all VFS shims and the
1155 ** all file-control actions, there is no guarantee that this will actually
1351 ** be unique across all VFS modules.
1370 ** The flags argument to xOpen() includes all bits set in
1471 ** or all of these interfaces to be NULL or for their behavior to change
1602 ** single thread.  All open [database connections] must be closed and all
1723 ** memory allocation subsystem for SQLite to use for all of its
1762 ** not need to be threadsafe either.  For all other methods, SQLite
1803 ** all mutexing and puts SQLite into a mode where it can only be used
1828 ** all mutexes including the recursive
1917 ** a page cache line is larger than sz bytes or if all of the pMem buffer
1929 ** that SQLite will use for all of its dynamic memory allocation needs
1942 ** allocator is engaged to handle all of SQLites memory allocation needs.
2018 ** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()],
2361 ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
2404 ** ^The sqlite3_interrupt(D) call is in effect until all currently running
2529 ** turns off all busy handlers.
2559 ** The remaining entries all point to query results.  NULL values result
2661 ** These routines all implement some additional formatting
2735 ** The SQLite core uses these three routines for all of its own
2918 ** [truncate optimization] is disabled and all rows are deleted individually.
3361 **     privilege, and so the database is opened read-only and all locking
3407 ** URI filename are interpreted, they are encoded using UTF-8 and all 
3518 ** all calls to the interfaces listed here are completed.
3711 ** recommended for all new programs. The two older interfaces are retained
3857 ** to locate all prepared statements associated with a database 
3868 ** SQLite uses the sqlite3_value object to represent all values
4052 ** parameter. For all forms except ?NNN, this will correspond to the
4113 ** ^Use this routine to reset all host parameters to NULL.
4185 ** subquery and is not a column value, then all of these functions return
4190 ** ^As with all other SQLite APIs, those whose names end with "16" return
4299 ** For all versions of SQLite up to and including 3.6.23.1, a call to
4317 ** with the "v2" interface.  If you prepare all of your SQL statements
4665 ** SQL function or aggregate, pass NULL pointers for all three function
5031 ** a BLOB containing all zero bytes and N bytes in size.
5046 ** message all text up through the first zero character.
5199 ** deleted.  ^When all collating functions having the same name are deleted,
5209 ** to the same collation name (using different eTextRep values) then all
5211 ** The collating function must obey the following properties for all
5270 ** ^To avoid having to register all collation sequences before a database
5373 ** all, then the behavior of sqlite3_sleep() may deviate from the description
5382 ** the name of a folder (a.k.a. directory), then all temporary files
5390 ** But for all other platforms, it is highly recommended that applications
5416 ** so itself, taking care to only do so after all [database connection]
5440 ** the name of a folder (a.k.a. directory), then all database files
5444 ** pointer, then SQLite assumes that all database files specified
5670 ** ^(The cache sharing mode set by this interface effects all subsequent
5807 ** table or NULL.)^ ^If it is NULL, then all attached databases are searched
5851 ** ^This function causes all database schemas to be read from disk and
5885 ** X is consists of the lower-case equivalent of all ASCII alphabetic
5951 ** that is to be automatically loaded into all new database connections.
5998 ** ^This interface disables all automatic extensions previously
6269 ** common to all module implementations.
6300 ** are common to all implementations.
6720 ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
6754 ** implementation of this method is expected to release all outstanding
6923 ** the number, meaning, and operation of all subsequent parameters.
6930 ** they take, and what they do are all subject to change without notice.
7159 ** been satisfied using lookaside memory but failed due to all lookaside
7166 ** memory used by all pager caches associated with the database connection.)^
7183 ** memory used to store the schema for all databases associated
7192 ** and lookaside memory used by all prepared statements associated with
7222 ** all foreign key constraints (deferred or immediate) have been
7479 ** When SQLite calls the xTruncate() method, the cache must discard all
7572 **     <li><b>sqlite3_backup_finish()</b> is called to release all resources 
7613 ** ^If N is negative, all remaining source pages are copied. 
7616 ** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
7671 ** ^The sqlite3_backup_finish() interfaces releases all
8047 **   readers or writers to finish, then sync the database file if all frames 
8056 **   database writer and all readers are reading from the most recent database
8057 **   snapshot. ^It then checkpoints all frames in the log file and syncs the
8065 **   until all readers are reading from the database file only. ^This ensures 
8103 ** specified operation is attempted on all WAL databases [attached] to 
8139 ** These constants define all valid values for the "checkpoint mode" passed
8255 ** to the total number of rows examined by all iterations of the X-th loop.</dd>
8262 ** product of this value for all prior loops with the same SELECTID will
8314 ** ^Statistics might not be available for all loops in all statements. ^In cases
8332 ** ^Zero all [sqlite3_stmt_scanstatus()] related event counters.
8348 ** interface flushes caches for all schemas - "main", "temp", and
8850 ** then the change is considered indirect if all operations meet the criteria
8873 ** Or, if argument zTab is NULL, then changes are recorded for all tables
8940 ** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL,
8951 ** Within a changeset generated by this function, all changes related to a
8953 ** a changeset or when applying a changeset to a database, all changes related
8966 ** records the primary key values of all new rows inserted into the table.
8998 **        primary key in the database, but all fields contain their original
9101 ** A patchset blob may be used with up to date versions of all 
9113 ** generated by the sqlite3session_changeset() function (i.e. all changes for
9165 ** [sqlite3changeset_invert()] functions, all changes within the changeset 
9168 ** this function, all changes that relate to a single table are visted 
9195 ** Otherwise, if all changes in the changeset have already been visited,
9367 ** In all other cases this function returns SQLITE_MISUSE.
9498 **   <li> The result of combining all input changesets together is obtained 
9514 ** Add all changes within the changeset (or patchset) in buffer pData (size
9517 ** If the buffer contains a patchset, then all prior calls to this function
9581 ** function returns SQLITE_NOMEM. In all cases, if an error occurs the
9595 ** sqlite3session_patchset() functions, all changes related to a single
9635 ** argument to this function is NULL, all changes related to the table are
9640 ** considered compatible if all of the following are true:
9684 **   stored in all non-primary key columns also match the values stored in 
9723 **   stored in all non-primary key columns also match the values stored in 
9896 ** required. In all cases, a pair of API function parameters such as
9917 ** error code should be returned. In all cases, if an xInput callback returns
9918 ** an error, all processing is abandoned and the streaming API function
9924 ** an error state, whereby all subsequent calls to iterator functions 
10086 **   the total number of tokens in column iCol, considering all rows in 
10127 **   Set *pnInst to the total number of occurrences of all phrases within
10194 **   more than once for a single FTS query, then all invocations share a 
10230 **   method, to iterate through all instances of a single query phrase within
10254 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
10262 **   of iterating through all instances of a phrase in the current row, these
10278 **   then this API always iterates through an empty set (all calls to 
10424 **   all instances of "first place" or "1st place" regardless of which form
10429 **   <ol><li> By mapping all synonyms to a single token. In this case, the 
10683 ** at all times.
10822 ** fire any triggers. A value of 0 means that no trigger programs at all 
10858 ** Unfortunately, that typedef is not available on all compilers, or
11034 ** can insure that all cases are evaluated.
11235 ** Macros for looping over all elements of a hash table.  The idiom is
11425 /* The token codes above must all fit in 8 bits */
11754 ** all alignment restrictions correct.
11795 ** The default MMAP_SIZE is zero on all platforms.  Or, even if a larger
11850 ** is a special table that holds the names and attributes of all
11922 ** When a function parameter is not used at all within the body of a function,
12180 ** selected will all have the same key.  In other words, the cursor will
12206 ** skip a lot of work.  Namely:  FORDELETE cursors may treat all SEEK
12727 ** generated this include file strives to group all JUMP opcodes
13220 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*);    /* Mark all dirty list pages as clean */
13226 /* Remove all pages with pgno>x.  Reset the cache if x==0 */
13229 /* Get a list of all dirty pages in the cache, sorted by page number */
13253 /* Iterate through all dirty pages currently stored in the cache. This
13360 ** After the following block of preprocess macros, all of SQLITE_OS_UNIX,
13448 ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
13473 ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
13484 ** But a single Win95 reader will lock out all WinNT readers and a single
13485 ** WinNT reader will lock out all other Win95 readers.
13494 ** clients on win95, winNT, and unix all talking to the same shared file
13495 ** and all locking correctly.  To do so would require that samba (or whatever
13503 ** that all locks will fit on a single page even at the minimum page size.
13598 ** This file contains the common header for all mutex implementations.
13600 ** to all source files.  We break it out in an effort to keep the code
13681 ** In other words, the zero-based numbers are used for all external interfaces
13968   /* The following variables are all protected by the STATIC_MASTER
13982   sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
14031 #define SQLITE_DeferFKs       0x02000000  /* Defer all FK constraints */
14401   FKey *pFKey;         /* Linked list of all foreign keys in this table */
14504 ** The list of all parents for child Table X is held at X.pFKey.
14506 ** A list of all children for a table named Z (which might not even exist)
14554 #define OE_Fail     3   /* Stop the operation but leave all prior changes */
14685   unsigned uniqNotNull:1;  /* True if UNIQUE and NOT NULL for all columns */
14836 ** it can be accessed after all aggregates are computed.
14861 ** an Expr object is truncated.  When EP_Reduced is set, then all
15186 ** or all contexts are check.  When a match is found, the nRef member of
15208 ** Value constraints (all checked via assert()):
15223 ** An instance of the following structure contains all information
15268 ** Value constraints (all checked via assert())
15346 **                     a record of all prior results and ignore any duplicate
15350 **                     an index).  Append a sequence number so that all entries
15355 **                     index at pDest->iSDParm+1 hold all prior stores.
15366 /* The ORDER BY clause is ignored for all of the above */
15399   AutoincInfo *pNext;   /* Next info block in a list of them all */
15439 ** The yDbMask datatype for the bitmask of all attached databases.
15459 ** the parser and down into all the parser action routine in order to
15731   const char *zDb;    /* Make sure all objects are contained in this database */
16883 /* An array to map all upper-case characters into their corresponding
17098 ** Hash table for global functions - functions common to all
17172 ** An array of names of all compile-time options.  This array should 
17635 ** VDBE.  This information used to all be at the top of the single
17746   const u8 *aRow;       /* Data for the current row, if all on one page */
17748   u32 aType[1];         /* Type values for all entries in the record */
17806 ** Internally, the vdbe manipulates nearly all SQL values as Mem
17924 ** There is a typedef for this structure in sqlite.h.  So all routines,
18034   SubProgram *pProgram;   /* Linked list of all sub-programs used by VM */
18388     ** by all pagers associated with the given database connection.  The
18415     ** to store the schema for all databases (main, temp, and any ATTACHed
18458     ** to store all prepared statements.
18479     ** Set *pCurrent to the total cache hits or misses encountered by all
18505     ** key constraints.  Set *pCurrent to zero if all foreign key constraints
18542 ** SQLite processes all times and dates as julian day numbers.  The
18555 ** The Gregorian calendar system is used for all dates and times,
19306 ** argv[1] and following are modifiers.  Parse them all and write
19665 ** This function registered all of the above C functions as SQL
19703 ** This file contains OS interface code that is common to all
20014 ** The list of all registered VFS implementations.
20227 ** No-op versions of all memory allocation routines
20616   struct MemBlockHdr *pNext, *pPrev;  /* Linked list of all unfreed memory */
20649   ** Head and tail of a linked list of all outstanding allocations
21032 ** Open the file indicated and write a log of all unfreed memory 
21105 ** This version of the memory allocation subsystem omits all
21394 ** This routine examines all entries on the given list and tries
21676 ** Open the file indicated and write a log of all unfreed memory 
21795 ** This version of the memory allocation subsystem omits all
21820 ** allocation size (after rounding all sizes up to a power of 2.)  Let M
21890   u64 totalAlloc;     /* Total of all malloc calls - includes internal frag */
22296 ** Open the file indicated and write a log of all unfreed memory 
22373 ** This file contains code that is common across all mutex implementations.
22565 ** Stub routines for all mutex methods.
23157 ** Include code that is common to all os_*.c files
23174 ** all of the platform-specific files (os_*.c) and is #included into those
23478 ** on Win32.  It should be noted that all mutexes require initialization
24308       /* Trash all content in the buffer being freed */
24448 ** that all prior mallocs (ex: "a") worked too.
25541 ** Reset an StrAccum string.  Reclaim all malloced memory.
25805 ** all the appropriate tree lines
26895   ** all that is required is to swap the byte order. This case is handled
27979 ** for all bytes that have the 8th bit set and one byte with the 8th
28707 /* Remove all entries from a hash table.  Reclaim all memory.
28712   HashElem *elem;         /* For looping over all elements of the table */
29147 ** skip locking all together.
29158 **   *  Various locking primitive implementations (all except proxy locking):
29166 **   *  Definitions of sqlite3_io_methods objects for all locking
29170 **   *  Definitions of sqlite3_vfs objects for all locking methods
29408 ** Include code that is common to all os_*.c files
29425 ** all of the platform-specific files (os_*.c) and is #included into those
29676 ** to all overrideable system calls.
29845 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
29860     /* If no zName is given, restore all system calls to their default
29993 ** vxworksFileId objects used by this file, all of which may be 
30037 ** Print out information about all locking operations.
30170   struct vxworksFileId *pNext;  /* Next in a list of them all */
30349 ** all locks on that file that are owned by the current process are
30354 ** to close() the file descriptor is deferred until all of the locks clear.
30411   unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
30423 ** A lists of all unixInodeInfo objects.
30525 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
30765 ** within this process, but all of that is handled in memory and the
30861   ** range'. Since all other locks require a read-lock on one of the bytes
31192     ** OS call only when all threads in this same process have released
31248 ** common to all locking schemes. It closes the directory and file
31249 ** handles, if they are valid, and sets all fields of the unixFile
31367 **    (1)  There is zero concurrency.  A single reader blocks all other
31651 ** lock states in the sqlite3_file structure, but all locks SHARED or
31652 ** above are really EXCLUSIVE locks and exclude all other processes from
31825 ** lock states in the sqlite3_file structure, but all locks SHARED or
31826 ** above are really EXCLUSIVE locks and exclude all other processes from
31935 ** The afpLockingContext structure contains all afp lock specific state
32328     ** OS call only when all threads in this same process have released
32420 ** The next division contains implementations for all methods of the 
32423 ** division).  Those methods that are common to all locking modes
32485 ** Read data from a file into a buffer.  Return SQLITE_OK if all
32719 ** The SQLITE_NO_SYNC macro disables all fsync()s.  This is useful
32857 ** Make sure all writes to a particular file are committed to disk.
33327 ** When multiple threads all reference the same wal-index, each thread
33328 ** has its own unixShm object, but they all point to a single instance
33400 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
33493 ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
33766         ** last page in order to extend the file. But writing to all new
33853   unixShm *pX;                          /* For looping over all siblings */
34121     /* If the mmap() above failed, assume that all subsequent mmap() calls
34243 ** Here ends the implementation of all sqlite3_file methods.
34312 ** Here are all of the sqlite3_io_methods objects for each of the
35028   ** here such that two or more threads all trying to open databases at
35029   ** the same instant might all reset the PRNG.  But multiple resets
35188           ** and clear all the structure's references.  Specifically, 
35482   ** When testing, initializing zBuf[] to zero is all we do.  That means
35626 ** until late in the file (here) after all of the other I/O methods have
35650 ** cache exposes a cache coherency problem that is present on all OS X
35720 ** The proxy file - a single-byte file used for all advisory file locks
35723 ** host (the conch ensures that they all use the same local lock file).
35764 ** will force automatic proxy locking to be disabled for all database
35843   /* try to create all the intermediate directories */
36493     /* all other styles use the locking context to store the db file path */
36501 ** Takes an already filled in unix file and alters it so all file locking 
36569     /* all memory is allocated, proxys are created and assigned, 
36657 ** above this point are all utilities.  The lock-related methods of the
36802 ** This routine registers all VFS implementations for unix-like operating
36897   /* Register all VFSes defined in the aVfs[] array */
36937 ** Include code that is common to all os_*.c files
36954 ** all of the platform-specific files (os_*.c) and is #included into those
37410 ** The winVfsAppData structure is used for the pAppData member for all of the
37460  * and an isolated heap will be created to store all allocated data.
37465  *          function), all data that was allocated using the isolated heap will
37598 ** to all overrideable system calls.
38256 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
38271     /* If no zName is given, restore all system calls to their default
38434   if( nMin<-1 ) nMin = -1; /* all negative values become -1. */
39771 ** Read data from a file into a buffer.  Return SQLITE_OK if all
40019 ** Make sure all writes to a particular file are committed to disk.
40262 ** erases all locks at once and returns us immediately to locking level 0.
40688 ** this file, all of which may be shared by multiple threads.
40712 ** shared memory.  When multiple threads all reference the same
40713 ** log-summary, each thread has its own winFile object, but they all
40748   winShmNode *pNext;         /* Next in list of all winShmNode objects */
40755 ** A global array of all winShmNode objects.
40792 ** Apply advisory locks for all n bytes beginning at ofst.
40840 ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
41056   winShm *pX;                           /* For looping over all siblings */
41549 ** Here ends the implementation of all sqlite3_file methods.
41555 ** This vector defines all the methods that can operate on an
41581 ** This vector defines all the methods that can operate on an
43096 ** or all of the pages in a database can get journalled.  In those cases, 
43351 ** Destroy a bitmap object.  Reclaim all memory used.
43534   int nRefSum;                        /* Sum of ref counts over all pages */
43552 ** When sqlite3PcacheTrace is 2, a dump of the pcache showing all cache entries
43624   ** disk sector size.  When any page of a sector is journalled, all pages
43626   ** in case they are later modified, since all pages in the same sector
43706     ** flag set sqlite3PcacheFetchStress() searches through all newer 
44085 ** Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages.
44097 ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
44252 ** Return a list of all dirty pages in the cache, sorted by page number.
44263 ** Return the total number of references to all pages held by the cache.
44266 ** reference count for all pages.
44353 ** For all dirty pages currently in the cache, invoke the specified
44484 **   (2)  There is a single global PGroup that all PCaches are a member
44529   /* Hash table of all pages. The following variables may only be accessed
44555   ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
44857 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
44860 ** for all page cache needs and we should not need to spill the
44863 ** Or, the heap is used for all page cache memory but the heap is
44991 ** Discard all pages from cache pCache with a page number (key value) 
45057   ** PGroup in pcache1.grp is used for all page caches (mode-2).
45317 **           the sum of nMax for all purgeable caches, less the sum of 
45318 **           nMin for all other purgeable caches, or
45326 **       (b) The number of pages allocated for all purgeable caches is
45327 **           already equal to or greater than the sum of nMax for all
45492 ** Discard all unpinned pages in the cache with a page number equal to
45646 ** After all inserts are finished, it is possible to extract the
45674 ** a non-zero batch number, it will see all prior INSERTs.
45725   struct RowSetChunk *pNextChunk;        /* Next chunk on list of them all */
45735   struct RowSetChunk *pChunk;    /* List of all chunk allocations */
45781 ** Deallocate all chunks from a RowSet.  This frees all memory that
45895 ** Sort all elements on the list of RowSetEntry objects into order of
46329 **     (a) The page and all other pages on the same sector are overwriteable.
46350 ** (6) If a master journal file is used, then all writes to the database file
46355 ** all queries.  Note in particular the content of freelist leaf
46456 **    * Any lock, or no lock at all, may be held on the database file.
46461 **    In this state all the requirements for reading the database in 
46486 **    is first opened on the database. In WRITER_LOCKED state, all locks 
46494 **    in WRITER_LOCKED state, all that is required is to unlock the database 
46507 **    * The dbSize, dbOrigSize and dbFileSize variables are all valid.
46553 **      If no error occurred, all that remains is to finalize the journal to
46577 **    to read or write data returns an error. Eventually, once all 
46758 **   logic into thinking that it already has all the locks it will ever
46839 **   It is valid in PAGER_READER and higher states (all states except for
46893 **   is set to zero in all other states. In PAGER_ERROR state, Pager.errCode 
46911   u8 memDb;                   /* True to inhibit all file I/O */
47144   ** this means an in-memory pager performs no IO at all, it cannot encounter 
47986 ** Free all structures in the Pager.aSavepoint[] array and set both
48006 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
48129 ** all major API calls on the Pager will immediately return Pager.errCode.
48159 ** Return TRUE if and only if all dirty pages should be flushed to disk.
48366 ** call to pager_unlock() will discard all in-memory pages, unlock
48699 ** of all of its child journals, one after another, formatted as utf-8 
48706 ** A master journal file may only be deleted once all of its child 
48970 ** journal file then all pages up to the first corrupted page are rolled
49141   ** update the change-counter at all. This may lead to cache inconsistency
49223       ** pPager->dbFileVers[] with all 0xff bytes should suffice.
49325   /* For all pages in the cache that are currently dirty or have already
49782 ** the xSync primitive is called and is relevant to all platforms.
49914 ** Otherwise, if all of the following are true:
49929 ** In all other cases, SQLITE_OK is returned.
50024 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
50127 ** following is true for all dirty pages currently in the page-cache:
50176   ** ensure that all pages being truncated away by this operation are,
50275 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
50288 ** Shutdown the page cache.  Free all memory and close all files.
50371 ** Sync the journal. In other words, make sure all the pages that have
50433         ** hot-journal rollback following recovery. It may roll back all
50465         ** all data has really hit the disk before nRec is updated to mark
50508   ** all pages.
50659 ** for all open savepoints before returning.
50742   ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling
50797 ** Flush all unreferenced dirty pages to disk.
50825 ** all information is held in cache. It is never written to disk. 
51558 ** page is initialized to all zeros. 
51577 ** The acquisition might fail for several reasons.  In all cases,
51786 ** page is added to the LRU list.  When all references to all pages
51879       /* TODO: Check if all of these are really required. */
52126 ** all bytes of a sector are written together by hardware.  Hence, all bytes of
52193   ** starting at pg1, then it needs to be set for all of them. Because
52195   ** journal file must contain sync()ed copies of all of them
52222 ** fit on a single disk sector. In this case all co-resident pages
52264 ** The overlying software layer calls this routine when all of the data
52446 **   * all dirty pages are written to the database file, 
52574       /* Sync the journal file and write all dirty pages to the database.
52680 ** If a write transaction is open, then all changes made within the 
52690 **   1) It rolls back the journal file, restoring all database file and 
52700 ** In WAL mode, all cache-entries containing data modified within the
52760 ** Return the sum of the reference counts for all pages held by pPager.
52912 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
52927 ** In any case, all savepoints with an index greater than iSavepoint 
53729 **        after the commit. For all other records, zero.
53743 **        WAL header and the first 8 bytes and the content of all frames
53762 ** of the sequence being summed.)  The s1 value spans all 32-bit 
53767 ** The VFS.xSync operations serve as write barriers - all writes launched
53788 ** for all subsequent read operations.  New transactions can be appended
53816 ** Hence, unlike the database and WAL file formats which store all values
53835 ** first index block are the same size as all other index blocks in the
53973 ** For all versions of SQLite through 3.10.0 and probably beyond,
53992   u32 aCksum[2];                  /* Checksum over all prior fields */
54011 ** nBackfill is only set after all backfilling completes.  So if a checkpoint
54024 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
54041 ** get all their all content directly from the database file and ignore 
54045 ** if nBackfill equals mxFrame (meaning that all WAL content has been
54084 ** file are calculated by treating all data as an array of 32-bit 
54086 ** all data as 32-bit little-endian words.
54157 ** all frames in the WAL in database page order. Where two or more frames
54360 **        after the commit. For all other records, zero.
54424   ** all prior frams, the first 16 bytes of this frame-header, 
54474 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
54633   /* Zero all hash-table entries that correspond to frame numbers greater
54768   /* Obtain an exclusive lock on all byte in the locking range not already
54857     /* Read all frames from the log file. */
54896     ** currently holding locks that exclude all other readers, writers and
55034 ** Find the smallest page number out of all pages held in the WAL that
55078 ** is guaranteed for all J<K:
55088 ** The aContent[aLeft[X]] values will be unique for all X.  And the
55142 ** aList[] are to be sorted so that for all J<K:
55221 ** Construct a WalInterator object that can be used to loop over all 
55537   ** until all readers have finished using the wal file. This ensures that 
55557           ** wal-index header in shared memory, as all subsequent reader or
55704     return 1;   /* Malformed header - probably all zeros */
55839 ** completely and get all content directly from the database file.
56473         /* If all readers are using WAL_READ_LOCK(0) (in other words if no
56574 ** all frames written to the wal file by the current transaction starting
56705     ** all syncing is turned off by PRAGMA synchronous=OFF).  Otherwise
56727   /* Write all frames into the log file exactly once */
57300 ** a fragment.  The total number of bytes in all fragments is recorded.
57314 ** byte are used.  The integer consists of all bytes that have bit 8 set and
57317 ** As a special case, all 8 bytes of the 9th byte are used as data.  This
57413 ** Access to all fields of this structure is controlled by the mutex
57483 ** schema associated with the database file are all contained within
57558   BtCursor *pCursor;    /* A list of all open cursors */
57621 ** root-node and 3 for all other internal nodes.
57650   BtCursor *pNext;          /* Forms a linked list of all cursors */
57804 ** This structure is passed around through all the sanity checking routines
57900 ** by all database connections.  The p->pNext is a list of other
57903 ** p, then first unlock all of the others on p->pNext, then wait
57904 ** for the lock to become available on p, then relock all of the
57954   /* To avoid deadlock, first release all locks with a larger
58012 ** against all schemas and we do not want those schemas being
58015 ** There is a corresponding leave-all procedures.
58019 ** two or more btrees in common both try to lock all their btrees
58044 ** mutex and all required BtShared mutexes.
58094 ** these two routines, all mutex operations are no-ops in that case and
58097 ** If shared cache is disabled, then all btree mutex routines, including
58512 ** Release all the table locks (locks obtained via calls to
58561 ** This function changes all write-locks held by Btree p into read-locks.
58611 ** Invalidate the overflow page-list cache for all cursors opened
58629 ** table is about to be deleted. In this case invalidate all incrblob
58639   int isClearTable        /* True if all rows are being deleted */
58669 **   1) When all data is deleted from a page and the page becomes
58677 **      be, if it is not at all meaningful?).
58732 ** Release all of the apPage[] pages for a cursor.
58819 ** Save the positions of all cursors (except pExcept) that are open on
58826 ** If there are two or more cursors on the same btree, then all such 
58858   Pgno iRoot,          /* Only save cursor with this iRoot. Save all if zero */
59215 ** all MemPage types and that references the cell by index rather than
59358 ** cellSizePtr()             =>   all index nodes & table leaf nodes
59460 ** end of the page and all free space is collected into one
59465 ** b-tree page so that there are no freeblocks or fragment bytes, all
59466 ** unused bytes are contained in the unallocated space region, and all
59617 ** all the space together, however.  This routine will avoid using
60390       /* In debug mode, we mark all persistent databases as sharable
60497   ** Btree into the list of all sharable Btrees for the same connection.
60636 ** Close an open database and invalidate all cursors.
60642   /* Close all cursors opened via this handle.  */
61138 ** false then all cursors are counted.
61411 ** Set the pointer-map entries for all children of page pPage. Also, if
61555   ** that point to overflow pages. The pointer map entries for all these
61846 ** disk and we are still holding all locks, so the transaction has not
61932 ** routine did all the work of writing information out to disk and flushing the
62008 ** following the rollback. Or, if writeOnly is false, all cursors are 
62015 ** saving the current position of a read-only cursor, all cursors, 
62016 ** including all read-cursors are tripped.
62057 ** Only write cursors are tripped if writeOnly is true but all cursors are
62143   ** an index greater than all savepoints created explicitly using
62220 ** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE
62221 ** operations on this cursor can be no-ops and all READ operations can 
62239   BtCursor *pX;                          /* Looping over other all cursors */
62278   /* If there are two or more cursors on the same btree, then all such
62718         /* If all the following are true:
62725         **   6) all data from the page is being read.
63422   /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
64531   u16 *szCell;            /* Local size of all cells in apCell[] */
64646 ** all cells - not just those inserted by the current call). If the content
64647 ** area must be extended to before this point in order to accomodate all
64715       /* No need to use cachedCellSize() here.  The sizes of all cells that
64742 ** apCell[] and szCell[] contains pointers to and sizes of all cells in the
65074 ** (hereafter "the page") and up to 2 siblings so that all pages have about the
65079 ** is a root page or a child of a root page) then all available siblings
65087 ** if the page is overfull. This routine ensures that all cells allocated
65107 ** enough for all overflow cells.
65175   ** has NB or fewer children then all children of pParent are taken.  
65276   ** Load pointers to all cells on sibling pages and the divider cells
65283   ** into aSpace1[].  In this way, all cells in b.apCell[] are without
65284   ** child pointers.  If siblings are not leaves, then all cell in
65285   ** b.apCell[] include child pointers.  Either way, all cells in b.apCell[]
65302     /* Verify that all sibling pages are of the same "type" (table-leaf,
65310     /* Load b.apCell[] with pointers to all cells in pOld.  If pOld
65385   ** Figure out the number of pages needed to hold all b.nCell cells.
65387   ** size of all cells on the i-th page and cntNew[] which is the index
65793     ** sets all pointer-map entries corresponding to database image pages 
65798     ** by smaller than the child due to the database header, and so all the
65833     ** all pointer map pages are set correctly. This is helpful while 
65866 ** Before returning, all pointer-map entries corresponding to pages 
66075 ** point to any entry or to no entry at all and so this function has to seek
66433     ** out to be an overflow page, delete all overflow page-map caches
66562 ** Erase the given database page and all its children.  Return
66620 ** Delete all information from a single table in the database.  iTable is
66641     /* Invalidate all incrblob cursors open on table iTable (assuming iTable
66652 ** Delete all information from the single table that pCur is open on.
66661 ** Erase all information in a table and add the root of the table to
66672 ** is added to the freelist instead of iTable.  In this say, all
66907     ** If all pages in the tree have been visited, return SQLITE_OK to the
67186 **      4.  Recursively call checkTreePage on all children.
67187 **      5.  Verify that the depth of all children is the same.
67417     /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
67509   /* Check all the tables.
67736   /* Save the positions of all other cursors open on this table. This is
68363           /* This block ensures that all data required to recreate the original
68448 ** Release all resources associated with an sqlite3_backup* handle.
69295 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
69315 ** n containing all zeros.
69801 **   * all function arguments are SQL literals,
69910 ** in all cases.
70426 ** Swap all content between two VDBE structures.
70650 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
70698 ** through its operation list and change all values of P2 which match
70755 ** The following type and function are used to iterate through all opcodes
70874   ** through all opcodes and hasAbort may be set incorrectly. Return
70883 ** This routine is called after all opcodes have been inserted.  It loops
70884 ** through all the opcodes and fixes up some details.
70915     ** all these opcodes together near the front of the opcode list.  Skip
71229 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
71404   /* C89 specifies that the constant "dummy" will be initialized to all
71731 ** of all of BtShared structures accessible via the database handle 
71737 ** The p->btreeMask field is a bitmask of all btrees that the prepared 
71762 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
71921   ** the sum of the number of rows in all trigger subprograms encountered
72270   ** end of the opcode array.  If we are unable to satisfy all memory
72318 ** Close a VDBE cursor and release all the resources that cursor 
72356 ** Close all cursors in the current frame.
72400 ** Close all cursors.
72575   /* If there are any write-transactions at all, invoke the commit hook */
72602     /* Do the commit only if all databases successfully complete phase 1. 
72707     /* Sync all the db files involved in the transaction. The same call
72938     /* Lock all btrees used by the statement */
73195   /* Reclaim all memory used by the VDBE
73256 ** all auxiliary data pointers currently cached by the VM passed as
73289 ** Free all memory associated with the Vdbe passed as the second argument,
73446 ** the blob of data that it corresponds to. In a table record, all serial
73980   ** all the fields up to that point were equal. Return the default_rc
74198 ** corresponds to an integer - all values between 1 and 9 inclusive 
74249 ** Key1 and Key2 do not have to contain the same number of fields. If all 
74428   ** all the fields up to that point were equal. Return the default_rc
75087 ** Set all the parameters in the compiled SQL statement to NULL.
75858   ** instead of an 8-byte one. This all works fine, except that when
76447 ** Transfer all bindings from the first statement over to the second.
76833 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
77170 ** generated the VDBE instruction.  This instrumentation assumes that all
77873 ** for lines of that contain "Opcode:".  That line and all subsequent
77901   ** OP_VNext, OP_RowSetNext, or OP_SorterNext) all jump here upon
78059 ** then back out all changes that have occurred during this execution of the
78496   /* Invalidate all ephemeral cursor row caches */
79412 ** In other words, this opcode causes all following opcodes up through P2
79514 ** skipped for length() and all content loading can be skipped for typeof().
79657       ** (2) the entire header was used but not all data was used
79693   ** all valid.
79797 ** If P4 is NULL then all index fields have the affinity BLOB.
79848   /* Apply the requested affinity to all inputs
80105       /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all 
80388     /* Invalidate all prepared statements whenever the TEMP database
80405 ** values need not be contiguous but all P1 values should be small integers.
80416 ** released when all cursors are closed.  If this instruction attempts
81048 ** contains any NULL value, jump immediately to P2.  If all terms of the
81310     ** to provide the constant while making all compilers happy.
81540 ** delete one of several associated with deleting a table row and all its
81542 ** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
82375 ** might be moved into the newly deleted root page in order to keep all
82419 ** Delete all contents of the database table or index whose root page
82458 ** Delete all contents from the ephemeral table or sorter
82532 ** Read and parse all entries from the SQLITE_MASTER table of database P1
82593 ** the analysis to be used when preparing all subsequent queries.
82655 ** The root page numbers of all tables in the database are integers
82840   ** single trigger all have the same value for the SubProgram.token 
83439 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
84004 ** The cases of the switch statement above this line should all be indented
84576 ** database handle error code and message set. If this happens, then all 
84647 **    sqlite3VdbeSorterRewind()     Sort all content previously added.
84665 **                                  all resources.
84704 ** If the sorter is running in single-threaded mode, then all PMAs generated
84795 ** are connected using SorterRecord.u.pNext.  If aMemory!=0 then all objects
84807 ** one big PMA using a merge operation.  Separate PMAs all need to be
84885 ** Essentially, this structure contains all those fields of the VdbeSorter
85079 ** Free all memory belonging to the PmaReader object passed as the
85117   ** than p->nBuffer bytes remaining in the PMA, read all remaining data.  */
85145     /* The requested data is not all available in the in-memory buffer.
85567   /* Do not allow the total number of threads (main thread + all workers)
85654 ** Free all resources owned by the object indicated by argument pTask. All 
85753 ** Join all outstanding threads launched by SorterWrite() to create 
85820 ** Free all resources associated with the IncrMerger object indicated by
86226 ** the MergeEngine has reached the end of all its inputs.
86333   ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
86558 ** For multi-threaded objects, all that is required is to wait until the 
86714 ** set the PmaReader objects up to read from it. In this case all that is
86768 ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders
86775 ** background thread. In this case all PmaReaders in the sub-tree are 
86788 ** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all
86790 ** In this case vdbePmaReaderNext() is called on all child PmaReaders and
87019 ** can be used to incrementally merge all PMAs on disk.
87101 ** all records stored in the sorter.
87215   /* Join all threads */
87221   ** incrementally read and merge all remaining PMAs.  */
87712 ** all content is always stored in main-memory. Finally, if nSpill is a
87868 ** Walk all expressions associated with SELECT statement p.  Do
87885 ** Walk the parse trees associated with all subqueries in the
87970 ** resolve all identifiers by associating them with a particular
88440     /* Increment the nRef value on all name contexts from TopNC up to
88805   /* Resolve all names in the ORDER BY term expression
89068 ** Resolve names in the SELECT statement p and all of its descendants.
89094   ** sqlite3SelectPrep() do all of the processing for this SELECT.
89135     /* Recursively resolve names in all subqueries
89144         /* Count the total number of references to pOuterNC and all of its
89232     ** below, after all of the result-sets for all of the elements of
89280   /* Resolve the ORDER BY on a compound SELECT after all terms of
89379 ** Resolve all names for all expression in an expression list.  This is
89397 ** Resolve all names in all expressions of a SELECT and in all
89485 ** i.e. the WHERE clause expressions in the following statements all
89855 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
89875 ** Propagate all EP_Propagate flags from the Expr.x.pList into
90312 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft 
90500 ** If cursors, triggers, views and subqueries are all omitted from
90756 ** Return the bitwise-OR of all Expr.flags fields in the given
90785 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
90808     /* Consider functions to be constant if all their arguments are constant
91144 ** all members of the RHS set, skipping duplicates.
91173 ** IN index will be used to loop over all values of the RHS of the
91382   ** If all of the above are false, then we can run this code just once
91954 ** get them all.
92066 ** Clear all column cache entries.
93807 ** Mark all temporary registers as being unavailable for reuse.
94111 ** Generate the text of a WHERE expression which can be used to select all
94127 ** Generate the text of a WHERE expression which can be used to select all
94339     ** statements corresponding to all child tables of foreign key constraints
94687 ** For most applications, sqlite_stat1 provides all the statistics required
94788 ** all contain just a single integer which is the same as the first
94817 ** or it may be a NULL pointer. If it is not NULL, then all entries in
94819 ** If zWhere==0, then code is generated to delete all stat table entries.
94875       /* The table already exists. If zWhere is not NULL, delete all entries 
94887         /* The sqlite_stat[134] table already exists.  Delete all rows. */
95007 ** Reclaim all memory of a Stat4Accum structure.
95595 ** Generate code to do an analysis of all indices associated with
95781         ** row, we know that all the rest will be distinct, so skip 
95988 ** Form 1 causes all indices in all attached databases to be analyzed.
95989 ** Form 2 analyzes all indices the single database named.
95990 ** Form 3 analyzes all indices associated with the named table.
96228       /* If this is stat4 data, then calculate aAvgEq[] values for all
96230       ** once the trailing PK fields are considered all index keys are
96428 ** the Index.aSample[] arrays of all indices.
96508   /* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
96908     ** statement only). For DETACH, set it to false (expire all existing
96984 ** a specific database to all table references where the database name
97584       /* Once all the cookies have been verified and transactions opened, 
97686 ** If zDatabase is 0, all databases are searched for the table and the
97798 ** If zDatabase is 0, all databases are searched for the
97841 ** the index hash table and free all memory structures associated
97926 ** Erase all schema information from all attached databases (including
97994   /* Delete all indices associated with this table. */
98038 ** table structure with all its indices and foreign keys.
99045 **     (1)  Set all columns of the PRIMARY KEY schema object to be NOT NULL.
99054 **     (5)  Add all table columns to the PRIMARY KEY Index object
99058 **     (6)  Replace the rowid tail on all automatically generated UNIQUE
99124     ** Remove all redundant columns from the PRIMARY KEY.  For example, change
99145   /* Update the in-memory representation of all UNIQUE indices by converting
99171   /* Add all table columns to the PRIMARY KEY index
99263   /* Resolve names in all CHECK constraint expressions.
99270   /* Estimate the average row size for the table and for all implied indices */
99319     ** a schema-lock excludes all other database users, the write-lock would
99378     ** SQLITE_MASTER table.  We just need to update that slot with all
99484   ** This will force all the Expr.token.z values to be dynamically
99667 ** We must continue looping until all tables and indices with
99726 ** Write VDBE code to erase table pTab and all associated indices on disk.
99828   /* Drop all triggers associated with the table being dropped. Code
99854   /* Drop all SQLITE_MASTER table and index entries that refer to the
99989 ** of tables in the parent pTo table.  flags contains all
100181   /* Open the table. Loop through all rows of the table, inserting index
100764     ** to invalidate all pre-compiled statements.
100778   ** sure all indices labeled OE_Replace come after all those labeled
101150 ** Assign VdbeCursor index numbers to all tables in a SrcList
101168 ** Delete an entire SrcList including all its substructure.
101287 ** Shifts all join operators from left to right for an entire FROM
101467 ** rollback the whole transaction.  For operations where all constraints
101608 ** Recompute all indices of pTab that use the collating sequence pColl.
101609 ** If pColl==0 then recompute all indices of pTab.
101626 ** Recompute all indices of all tables in all databases where the
101628 ** all indices everywhere.
101657 ** Form 1 causes all indices in all attached databases to be rebuilt.
101658 ** Form 2 rebuilds all indices in all databases that use the named
101659 ** collating function.  Forms 3 and 4 rebuild the named index or all
102249 ** Free all resources held by the schema structure. The void* argument points
102545   int iEphCur = 0;       /* Ephemeral table holding all primary key values */
102608   /* Assign cursor numbers to the table and all its indices.
102695       ** hold all primary keys for rows to be deleted. */
102778     ** deleting from and all its indices. If this is a view, then the
102839     /* End of the loop over all rowids/primary-keys. */
102898 ** all indices are removed.
102907 **   2.  Read/write cursors for all indices of pTab must be open as
103061 ** This routine generates VDBE code that causes the deletion of all
103071 **   2.  Read/write cursors for all indices of pTab must be open as
104357 ** The replace() function.  Three arguments are all strings: call
104937   ** The following array holds FuncDef structures for all of the functions
105132 **   An UPDATE command requires that all 4 steps above are taken, but only
105385   int isIgnore          /* If true, pretend pTab contains all NULL values */
105709 ** FKey.pNextTo) holding all children of table pTab.  For example,
105728 ** and all of its sub-components.
105934   /* Loop through all the foreign key constraints for which pTab is the
106026       ** foreign key, then omit this scan altogether. As all child key
106035   /* Loop through all the foreign key constraints that refer to this table.
106088         ** all OP_FkCounter related scans when either CASCADE or SET NULL
106405   /* If foreign-key support is enabled, iterate through all FKs that 
106425 ** Free all memory associated with foreign key definitions attached to
106686 ** The 2nd register is the one that is returned.  That is all the
106718 ** This routine generates code that will initialize all of the
106830 ** above are all no-ops
106854 ** then a list of all (non-hidden) columns for the table is substituted.
106879 ** in other words if the SELECT pulls all columns from a single table
106882 ** schemas, including all the same indices, then a special optimization
106889 **         transfer all records in <table2> over to <table>
106894 **           transfer all records from the read to the write cursors
107096   ** all elements of the IDLIST really are columns of the table and 
107254   /* If this is not a view, open the table and and all indices */
107412     /* Compute data for all columns of the new entry, beginning
107501     /* Close all tables opened */
107638 ** table and all applicable indices (that is to say, all indices for which
107646 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
107739   /* Test all NOT NULL constraints.
107791   /* Test all CHECK constraints
107936   /* Test all UNIQUE constraints by creating entries for each UNIQUE
107997     ** logic below can all be skipped. */
108190 ** Allocate cursors for the pTab table and all its indices and generate
108283 **    *   The same DESC and ASC markings occurs on all columns
108471       return 0;    /* Affinity must be the same on all columns */
108474       return 0;    /* Collating sequence must be the same on all columns */
108487         return 0;    /* Default values must be the same for all columns */
108610       ** that the destination table is empty. If all indexed columns use
108849 ** The following structure holds pointers to all of the SQLite API
109114 ** This is the function signature used for all extension entry points.  It
109488 ** The following structure contains pointers to all SQLite API routines.
110129 ** Load all automatic extensions.
110846 ** set these values for all pagers.
111201         ** set on all attached databases, as well as the main db file.
111408   ** The cache_spill=BOOLEAN setting applies to all attached schemas,
111436   ** used to limit the aggregate size of all memory mapped regions of the
111438   ** is not used at all.  If N is negative, then the default memory map
111666       ** compiler (eg. count_changes). So add an opcode to expire all
112051     ** of all attached databases.  */
112091       ** for all tables and indices in the database.
112129       /* Make sure all the indices are constructed correctly.
112156         /* Verify that all NOT NULL columns really are NOT NULL */
112280   ** In all cases new databases created using the ATTACH command are
112413   ** Return the names of all compile-time options used in this build,
112547   ** Report the current state of file logs for all databases
112973 ** Initialize all database files - the main database file, the file
113000   /* Once all the other databases have been initialized, load the schema
113042 ** Check schema cookies in all databases.  If any cookie is out
113043 ** of date set pParse->rc to SQLITE_SCHEMA.  If all schema cookies
113121 ** Free all memory allocations in the pParse object
113164   /* Check to verify that it is possible to get a read lock on all
113176   ** This thread is currently holding mutexes on all Btrees (because
113184   ** but it does *not* override schema lock detection, so this all still
113552 ** Delete all the content of a Select structure.  Deallocate the structure
113658 ** Delete the given Select structure and all of its substructures.
113836 ** Set the EP_FromJoin property on all terms of the given expression.
114271         ** row is all NULLs.
114446     ** pSO->nExpr columns, then make sure all keys are unique by adding a
114463         ** on a second ephemeral index that holds all values every previously
114828 ** result-set expression in all of the following SELECT statements is 
115214 ** This routine requires that all identifiers in the SELECT
115349   ** "LIMIT -1" always shows all rows.  There is some
115473 ** inserted into the Queue table.  The iDistinct table keeps a copy of all rows
115483 ** negative LIMIT means to output all rows.  If there is also an OFFSET clause
115755   /* Make sure all SELECTs in the statement have the same number of elements
116003   ** Attach the KeyInfo structure to all temporary tables.
116063     sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
116297 ** until all data is exhausted then jump to the "end" labe.  AltB, AeqB,
116727 ** Flattening is only attempted if all of the following are true:
116743 **        (4) has since been expanded to exclude all DISTINCT subqueries.
116791 **        operator other than UNION ALL because all the other compound
116797 **        SELECT statement, but all the code here does is make sure that no
116801 **  (18)  If the sub-query is a compound select, then all terms of the
116930   ** which is not at all the same thing.
117105   ** This loop moves all of the FROM elements of the subquery into the
117134     ** then expand the outer query to make space for it to hold all elements
117337 ** If all of the above are true, then WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX
117755   /* Make sure cursor numbers have been assigned to all entries in
117833   ** all columns in all tables.  And for every TABLE.* insert the names
117834   ** of all columns in TABLE.  The parser inserted a special expression
117837   ** expressions and expand each one to the list of all columns in
117838   ** all tables.
118017 ** This routine "expands" a SELECT statement and all of its subqueries.
118089 ** the Table structures of all FROM-clause subqueries in a
118110 **     *  VDBE Cursor numbers are assigned to all FROM-clause terms.
118111 **     *  Ephemeral Table objects are created for all FROM-clause subqueries.
118116 ** This routine acts recursively on all subqueries within the SELECT.
118140 ** routine generates code that stores NULLs in all of those memory
118150   /* Verify that all AggInfo registers are within the range specified by
118453   /* Generate code for all sub-queries in the FROM clause
118500     ** The subquery is implemented as a co-routine if all of these are true:
118582     SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
118727     /* Remove any and all aliases between the result set and the
118763     ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
118804       ** that we do not need it after all, the OP_SorterOpen instruction
118831       /* Begin a loop that will extract all source rows in GROUP BY order.
119264   ** the names of all columns.
119434 ** Given table pTab, return a list of all the triggers attached to 
119439 ** triggers on pTab in the TEMP schema.  This routine prepends all
119443 ** To state it another way:  This routine returns a list of all triggers
119560       ** Normally, whenever a table is dropped, all associated triggers are
119666 ** This routine is called after all of the trigger actions have been parsed
120011 ** Return a list of all triggers on table pTab if there exists at least
120544 ** If the former, then all row-records are guaranteed to include a value
120633   int iEph = 0;          /* Ephemeral table holding all primary key values */
120683   /* Allocate a cursors for the main database table and for all indices.
120715   /* Resolve the column names in all the expressions of the
120770   ** case, set all bits of the colUsed mask (to ensure that the virtual
120771   ** table implementation makes all columns available).
120836   /* Resolve the column names in all the expressions in the
120920     ** action, then we need to open all indices because we might need
121061     ** all columns not modified by the update statement into their 
121150   ** all record selected by the WHERE clause have been updated.
121162   /* Close all tables */
121415 **   (2)  Copy all content from the database being vacuumed into
121620   ** associated storage, so all we have to do is copy their entries
121828 ** the disconnect is deferred until all locks have been removed.
121869 ** Table p is a virtual table. This function moves all elements in the
121911 ** used when closing database connection db to free all of its VTable
121934 ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
121936 ** This function may only be called when the mutexes associated with all
121941 **   1) By this function. In this case, all BtShared mutexes and the mutex
121971 ** Clear any and all virtual-table information from the Table record.
122112     ** SQLITE_MASTER table.  We just need to update that slot with all
122578 ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
122580 ** SQLITE_OK if all xSync operations are successful.
122603 ** Invoke the xRollback method of all virtual tables in the 
122612 ** Invoke the xCommit method of all virtual tables in the 
122674 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
122685 ** function immediately. If all calls to virtual table methods are successful,
123072 ** one WhereLoop object per FROM clause term, that satisfy all dependencies
123132 ** that implement some or all of a query plan.
123140 ** or all of the WhereLoop objects once.
123149   Bitmask maskLoop;     /* Bitmask of all WhereLoop objects in this path */
123267 ** An instance of the following structure holds all information about a
123298   Bitmask indexable;       /* Bitmask of all indexable tables in the clause */
123332 ** numbers all get mapped into bit numbers that begin with 0 and contain
123346 ** This object is a convenience wrapper holding all information needed
123375   ExprList *pDistinctSet;   /* DISTINCT over all these values */
123376   WhereLoop *pLoops;        /* List of all WhereLoop objects */
123384   u8 untestedTerms;         /* Not all WHERE terms resolved by outer loop */
123459 ** Bitmasks for the operators on WhereTerm objects.  These are all
123486 #define WO_ALL    0x1fff       /* Mask of all possible WO_* values */
123487 #define WO_SINGLE 0x01ff       /* Mask of all non-compound WO_* values */
123752 ** If all the children of a term are disabled, then that term is also
123796 ** beginning and end of zAff are ignored.  If all entries in zAff are
123839 ** this routine sets up a loop that will iterate over all values of X.
123915 ** Generate code that will evaluate all == and IN constraints for an
123931 ** The nExtraReg parameter is 0 or 1.  It is 0 if all WHERE clause constraints
124295     /* If we survive all prior tests, that means this term is worth hinting */
124326 ** does not appear in the index at all, the array entry is set to 0.
124643     **         index is on (x,y,z), then the following clauses are all 
124773     /* Generate code to evaluate all constraint terms using == or IN
124998     ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
125170           /* If all of the OR-connected terms are optimized using the same
125177           ** processed or the index is the same as that used by all previous
125368 ** Deallocate all memory associated with a WhereOrInfo object.
125376 ** Deallocate all memory associated with a WhereAndInfo object.
125790 ** If all subterms are of the form T.C=expr for some single column of C and
125813 ** If all subterms are indexable by a single table T, then set
125842 ** the union of all rowids using a RowSet object.  This is similar
125974   ** sure the same column is used on all terms.  The 2-bit case is when
125975   ** the all terms are of the form "table1.column=table2.column".  It
125986     int iCursor = -1;         /* Table cursor common to all terms */
126210 ** subexpression and populate all the other fields of the WhereTerm
126386   ** for LIKE) then the lower-bound is made all uppercase and the upper-
126387   ** bound is made all lowercase so that the bounds also work when comparing
126428         ** LIKE on all candidate expressions by clearing the isComplete flag
126561 ** all terms of the WHERE clause.
126648 ** Call exprAnalyze on all terms in a WHERE clause.  
127044 ** aiCur[]/iaColumn[] arrays hold X and all its equivalents. There are 11
127169   /* Loop through all indices on the table, checking each to see if it makes
127407   ** covering index.  A "covering index" is an index that contains all
127695 ** Estimate the location of a particular key among all keys in an
127734   ** than one fields, all fields following the first are ignored.
127826       ** all samples in the aSample[] array, pRec must be smaller than the
127834       /* if i==0 and iCol==0, then record pRec is smaller than all samples
127860     ** is larger than all samples in the array. */
127941 ** It does this by scanning through all stat4 samples, comparing values
128269   /* If values are not available for all fields of the index to the left
128547 ** Return TRUE if all of the following are true:
129068     ** values of nIn and nInMul. In other words, assuming that all 
129280 ** Add all WhereLoop objects for a single table of the join where the table
129351     ** fake index the first in a chain of Index objects with all of the real
129425   /* Loop over all indices
129538 ** Argument pIdxInfo is already populated with all constraints that may
129685 ** Add all WhereLoop objects for a table of the join identified by
129689 ** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause
129692 ** mUnusable mask contains all FROM clause entries that occur after the
129703 ** table. So any terms for which all prerequisites are satisfied by 
129704 ** mPrereq may be specified as "usable" in all calls to xBestIndex. 
129705 ** Conversely, all tables in mUnusable must be scanned after the current
129744   /* First call xBestIndex() with all constraints usable. */
129745   WHERETRACE(0x40, ("  VirtualOne: all usable\n"));
129748   /* If the call to xBestIndex() with all terms enabled produced a plan
129751   ** since they will all return the same result (if the xBestIndex()
129762       WHERETRACE(0x40, ("  VirtualOne: all usable w/o IN\n"));
129797     ** that requires no source tables at all (i.e. one guaranteed to be
129798     ** usable), make a call here with all source tables disabled */
129800       WHERETRACE(0x40, ("  VirtualOne: all disabled\n"));
129806     ** that requires no source tables at all and does not use an IN(...)
129809       WHERETRACE(0x40, ("  VirtualOne: all disabled and w/o IN\n"));
129922         ** of all sub-scans required by the OR-scan. However, due to rounding
129945 ** Add all WhereLoop objects for all tables 
130045   Bitmask obDone;       /* Mask of all ORDER BY terms */
130046   Bitmask orderDistinctMask;  /* Mask of all well-ordered loops */
130051   ** row of output.  A WhereLoop is one-row if all of the following are true:
130140       /* Loop through all columns of the index and deal with the ones
130238       } /* end Loop over all index columns */
130260   } /* End the loop over all WhereLoops from outer-most down to inner-most */
130833 ** scanning through all values on the right-hand side of the IN.
130855 ** loops are evaluated and if false a jump is made around all subsequent
130887 ** the first cursor in an array of cursors for all indices.  iIdxCur should
130893   SrcList *pTabList,      /* FROM clause: A list of all tables to be scanned */
130948   /* This function normally generates a nested loop for all tables in 
130998   ** expression and either jump over all of the code or fall thru.
131022   ** a table T, then X-1 is the bitmask for all other tables to the left of T.
131023   ** Knowing the bitmask for all tables to the left of a left join is
131026   ** Note that bitmasks are created for all pTabList->nSrc tables in
131042   /* Analyze all of the subexpressions. */
131066   if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */
131076     if( sqlite3WhereTrace ){    /* Display all of the WhereLoop objects */
131184   /* Open all tables in the pTabList and any indices selected for
131439     /* For a co-routine, change all OP_Column references to the table of
131449     /* Close all of the cursors that were opened by sqlite3WhereBegin.
131477     ** directly.  This loop scans all that code looking for opcodes
131547 ** The following is the concatenation of all %include directives from the
131556 ** Disable all error recovery processing in the parser push-down
131624   ** all elements in the list.  And make sure list length does not exceed
131773 **                       Terminal symbols all have the same minor type, though.
131776 **    YYMINORTYPE        is the data type used for all minor types.
131899 **  yy_action[]        A single table containing all actions.
132548 /* For tracing shifts, the names of all terminals and nonterminals
132618 /* For tracing reduce actions, the names of all rules are required.
133159 ** all stack elements before shutting the parser down.
134704   Token all;
134705   all.z = yymsp[-3].minor.yy0.z;
134706   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
134707   sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy145, &all);
135243 ** a lookup table is used, all of the classes need to be small integers and
135244 ** all of them need to be used within the switch.
136209 ** This means that a SQL string of all whitespace is invalid.
136211 ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
136593 ** all database files specified with a relative pathname.
136711   ** methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
137019         ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
137025         ** alternative memory allocator is engaged to handle all of SQLites
137335 ** Return true if the buffer z[0..n-1] contains all spaces.
137440 ** Close all open savepoints. This function only manipulates fields of the
137473 ** Disconnect all sqlite3_vtab objects that belong to database connection
137535   /* Force xDisconnect calls on all virtual tables */
137590 ** finished, then free all resources.
137606   ** closed all sqlite3_stmt and sqlite3_backup objects and has been
137608   ** go ahead and free all resources.
137620   /* Close all database connections */
137709 ** Rollback all database files.  If tripCode is not SQLITE_OK, then
137722   /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). 
138134   ** operation to continue but invalidate all precompiled statements.
138605 ** to contains a zero-length string, all attached databases are 
138628 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
139100           ** case we ignore all text in the remainder of the path, name or
139305   ** off all other flags.
139395   /* EVIDENCE-OF: R-08308-17224 The default collating function for all
139440   /* Register all built-in functions, but do not attempt to read the
139511   ** mode.  Doing nothing at all also makes NORMAL the default.
139803 ** This is a convenience routine that makes sure that all thread-specific
139911   ** this has the effect of zeroing all output parameters.
140250     ** If parameter onoff is non-zero, configure the wrappers so that all
140316     ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
140318     ** effect of erasing all imposter tables.
140551 ** Head of a linked list of all sqlite3 objects created by this process
141038 ** is encoded.  The subtree at iBlockid will contain all terms less
141039 ** than the first term encoded (or all terms if no term is encoded).
141078 ** leaves_end_block, and end_block are all 0.
141088 ** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
141094 ** A segment merge traverses all segments at a given level in
141098 ** After the merge, all segment blocks from the merged level are
141172 ** SQLITE_ENABLE_FTS3 macro.  But to avoid confusion we also all
141445 ** Macros for looping over all elements of a hash table.  The idiom is
141523 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
141529 ** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
141530 ** level values between 0 and 1023 (inclusive) belong to index 0, all levels
141678   ** there is an entry in the aIndex[] array. Index 0 is an index of all the
141684   ** malloc overhead.  When nPendingData exceeds nMaxPendingData, all hash
141761 ** indicating that all columns should be searched,
142541 ** with all double quote characters escaped. For example:
142633 ** If argument zFunc is not NULL, then all but the first question mark
142813     int nStr = 0;                 /* Size of all column names (incl. 0x00) */
142877   int nString = 0;                /* Bytes required to hold all column names */
142922   /* Loop through all of the arguments passed by the user to the FTS3/4
142923   ** module (i.e. all the column names and special arguments). This loop
143049   **      TABLE statement, use all columns from the content table.
143598     ** to the term from the interior node, then all terms on the sub-tree 
143847 ** into *pp contains all positions of both *pp1 and *pp2 in sorted
144191 ** This function does an "OR" merge of two doclists (output contains all
144237   ** the input list). The same argument applies to all but the first docid
144238   ** read from the 'other' list. And to the contents of all position lists
144411 ** Merge all doclists in the TermSelect.aaOutput[] array into a single
144412 ** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
144424   /* Loop through the doclists in the aaOutput[] array. Merge them all
144465 ** a queried prefix. It merges all these doclists into one, the doclist
144690 ** if isPrefix is true, to scan the doclist for all terms for which 
144770   int iColumn,                    /* Column to query (or -ve for all columns) */
144991   ** statement loops through all rows of the %_content table. For a
145366 ** function merges all segments in the database to a single segment.
145727 ** within the union of all segments of a b-tree. Hence the name.
146283       sqlite3_int64 iMax = 0;     /* Largest docid for all iterators */
146297       /* Keep advancing iterators until they all point to the same document */
146380 ** Otherwise, fts3EvalPhraseStart() is called on all phrases within the
146382 ** expressions for which all descendent tokens are deferred.
146510     ** data stored in all rows of each column of the table, from left
146602   /* Iterate through all tokens in this AND/NEAR cluster, in ascending order 
146639       /* The number of overflow pages to load for this (and therefore all
146641       ** that will be loaded if all subsequent tokens are deferred.
146833 **      the db. In this case the position-list is not populated at all. 
146985 ** phrase instances sufficiently close to their peers to satisfy all NEAR
147093         ** all phrases involved in the NEAR. This is because the snippet(),
147295 ** expression rooted at pExpr, the cursor iterates through all rows matched
147339 ** for all other phrases that are part of the NEAR expression.
147430 **      the FTS table (considering all rows), and
147443 **   * If a phrase consists entirely of deferred tokens, then all output 
147631 ** Free all components of the Fts3Phrase structure that were allocated by
147733 ** This function does all the work for both the xConnect and xCreate methods.
148525   ** Fts3PhraseToken structures token buffers are all stored as a single 
148537   **   Buffer zTemp: Contains copies of all tokens.
148708       /* Turns out that wasn't a keyword after all. This happens if the
149615 /* Remove all entries from a hash table.  Reclaim all memory.
149620   Fts3HashElem *elem;         /* For looping over all elements of the table */
150313     /* Do nothing.  The work was all in the test */
150321        /* Do nothing.  The work was all in the test */
150508 ** part of a token.  In other words, delimiters all must have
151501 ** This function does all the work for both the xConnect and xCreate methods.
151853 ** memory incrementally instead of all at once. This can be a big performance
151855 ** method before retrieving all query results (as may happen, for example,
152021 ** the tree is assembled in memory and written out only once all leaves have
152387 ** all rows in the %_segdir table, from oldest to newest. If successful,
152587 ** Tokenize the nul-terminated string zText and add all tokens to the
152831 ** Remove all data from the FTS3 table. Clear the hash table containing
152866 ** (an integer) of a row about to be deleted. Remove all terms from the
152959     ** full, merge all segments in level iLevel into a single iLevel+1
153298       ** normally all that is required to move pointer p to the desired 
153383 ** Free all allocations associated with the iterator passed as the 
153671 ** the array around until all entries are in sorted order.
153928 ** Write the buffer for the segment node pTree and all of its peers to the
153982 ** Free all memory allocations associated with the tree pTree.
154146 ** Flush all data associated with the SegmentWriter object pWriter to the
154147 ** database. This function must be called after all terms have been added
154184 ** Release all memory held by the SegmentWriter object passed as the 
154293 ** Delete all entries in the %_segments table associated with the segment
154320 **   1) Deletes all %_segments entries for the segments associated with 
154324 **   2) deletes all %_segdir entries with level iLevel, or all %_segdir
154673     /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
154681     ** to does not share a suffix with pFilter->zTerm/nTerm, then all 
154885     /* Loop through all entries in the %_segdir table corresponding to 
154887     ** at least one such segment, and it is possible to determine that all 
154922         /* Loop through all %_segdir entries for segments in this index with
154927         ** In other words, move all segments being promoted to level -1,
154962 ** Merge all level iLevel segments in the database into a single 
154963 ** iLevel+1 segment. Or, if iLevel<0, merge all segments into a
155003     /* This call is to merge all segments in the database to a single
155015     /* This call is to merge all segments at level iLevel. find the next
155180 **                   the column for all rows of the table.
155182 **   Varint 1+nCol:  The total size, in bytes, of all text values in all
155183 **                   columns of all rows of the table.
155557 ** Release all dynamic resources held by node-reader object *p.
155820 ** This function is called to release all dynamic resources held by the
155822 ** all outstanding node buffers held by pWriter to disk.
155886   /* Flush all currently outstanding nodes to disk. */
155972 **   * It was initially created as an appendable segment (with all required
156105 ** one before returning SQLITE_OK. Or, if there are no segments at all 
156317 ** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes)
156324   const char *zTerm,              /* Omit all terms smaller than this */
156367 ** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute 
156455 ** Each input segment is either removed from the db completely (if all of
156463   Fts3MultiSegReader *pCsr,       /* Chomp all segments opened by this cursor */
156490       /* The incremental merge did not copy all the data from this 
156879 ** Return a checksum of all entries in the FTS index that correspond to
156965   sqlite3_stmt *pAllLangid = 0;   /* Statement to return all language-ids */
157064 ** The checksums for all entries in the index are XORed together to create
157130 ** Delete all cached deferred doclists. Deferred doclists are cached
157142 ** Free all entries in the pCsr->pDeffered list. Entries are added to 
157157 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
157162 ** table, not for all rows.
157291         ** delete the contents of all three tables and throw away any
157467 ** merge all segments in the database (including the new segment, if 
157757 ** Iterate through all phrase nodes in an FTS3 query, except those that
157764 ** all eligible phrase nodes.
157799 ** phrases in the expression (all phrases except those directly or 
157801 ** pnToken is not NULL, then it is set to the number of tokens in all
158051     /* Loop through all candidate snippets. Store the best snippet in 
158402 ** of the matchinfo array that are constant for all rows returned by the 
158413 ** where X is the number of matches for phrase iPhrase is column iCol of all
158417 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
158558 ** finished iterating through all offsets for all columns.
158680 ** If bGlobal is true, then populate all fields of the matchinfo() output.
158903   ** size that contains at least one instance of all phrases in the query
158936       /* Loop through all columns of the table being considered for snippets.
158937       ** If the iCol argument to this function was negative, this means all
158959     /* If all query phrases seen by fts3BestSnippet() are present in at least
159315 ** all characters in string zIn/nIn to be separators (if bAlnum==0) or
159322 ** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all
159528   ** Return SQLITE_DONE early if this takes us all the way to the end of 
159832   ** to all nRange codepoints (i.e. all nRange codepoints are upper case and
160168 ** Therefore all non-root nodes must contain at least 3 entries. Since 
160399 ** Clear the content of node p (set all bytes to 0x00).
160519   ** of the r-tree structure. A height of zero means all data is stored on
161067 ** iLevel values coming first.  In this way, if rScore is the same for all
161878 ** all ancestor elements.
161930 ** Arguments aIdx, aDistance and aSpare all point to arrays of size
162002 ** Arguments aIdx, aCell and aSpare all point to arrays of size
162209   ** all cells from node pLeft. Then zero the original node.
162254   ** In this case avoid the all to nodeWrite().
162326 ** still NULL, load all ancestor nodes of pLeaf into memory and populate
162327 ** the pLeaf->pParent chain all the way up to the root node.
163287 ** deserialize all nodes, a statement like:
163346 ** The depth value is 0 for all nodes other than the root node, and the root
163649     **     1. uPattern is an unescaped match-all character "%",
164382 **     b-tree are completed before moving on to the next, and all
164422 **  collected in the rbu_xyz table. And for both UPDATEs and DELETEs all
164472 ** and all but guarantees each modified leaf page is loaded and stored 
164526 ** The "rbu_control" column should have no type at all. For example, if
164563 ** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
164598 ** the new values of all columns being update. The text value in the 
164686 ** To remove all RBU extension state information, returning an RBU database 
164687 ** to its original contents, it is sufficient to drop all tables that begin
164743 ** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of
164828 ** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
164991 ** file-system via "rbu" all the time, even if it only uses RBU functionality 
165001 ** before all database handles that use it have been closed, the results
165140 ** An iterator of this type is used to iterate through all objects in
165243 **   for all source tables in the RBU database, where nRow is the number
165278   int nProgress;                  /* Rows processed for all objects */
165682 ** Finalize all statements and free all allocations that are specific to
166237     /* Check that all non-HIDDEN columns in the destination table are also
166742 ** An imposter table is required in all cases except RBU_PK_VTAB. Only
168208 ** considered equal, and NULL is considered distinct from all other values.
168351 ** for all rows in the rbu_count table, where nIndex is the number of 
168574 ** then edit any error message string so as to remove all occurrences of
168754 **    to point to the new file. A mutex protected linked list of all main 
168785 **     mode except RBU_STAGE_DONE (all work completed and checkpointed), it 
168790 ** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
168791 **     all xWrite() calls on the target database file perform no IO. 
169385     ** mutex protected linked list of all such files.  */
169707   "  mx_payload INTEGER,          /* Largest payload size of all cells */"  \
170388   int bIndirect;                  /* True if all changes are indirect */
170448 ** The keys of the SessionTable.aChange[] hash table are all rows that have
170512 ** but may occur in any order (i.e. deletes, updates and inserts are all
170542 ** Within the old.* record associated with an UPDATE change, all fields
170576 ** For a DELETE change, all fields within the record except those associated
170580 ** For an UPDATE change, all fields except those associated with PRIMARY KEY
171267 ** pointer *pazCol should be freed to release all memory. Otherwise, pointer
171439       /* Create a new change object containing all the old values (if
171478       ** preupdate_new() or SerializeValue() calls below may fail as all
171977   /* Delete all attached table objects. And the contents of their 
172272 ** If all of the old.* values are equal to their corresponding new.* value
172273 ** (i.e. nothing has changed), then no data at all is appended to the buffer.
172275 ** Otherwise, the old.* record contains all primary key values and the 
172473 ** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
172690 ** Obtain a changeset object containing all changes recorded by the 
172727 ** Obtain a patchset object containing all changes recorded by the 
172861 ** if there are not nByte bytes remaining in the input, that all available
172955 ** It is the responsibility of the caller to free all sqlite_value structures
173021 ** This function ensures that all of the above is present in the input 
173169   /* Make sure the buffer contains at least 10 bytes of input data, or all
173229       /* If this is an UPDATE that is part of a patchset, then all PK and
173353 ** they omit all error checking and return a pointer to the requested value.
173390 ** In all other cases this function returns SQLITE_MISUSE.
173532         /* Write the new new.* record. Consists of a copy of all values
173886 ** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
174114     ** bind values for all columns and set bound variable (nCol+1) to true.
174121     **   * all columns of the table are PK columns (in this case there is
174668 ** Add all changes in the changeset traversed by the iterator passed as
174777 ** Serialize a changeset (or patchset) based on all changesets (or patchsets)
174877 ** of all changesets added to the group so far.
175006 ** For the time being, all JSON is stored as pure text.  (We might add
175180 /* Free all allocated memory and reset the JsonString object back to its
175377 ** Reclaim all memory allocated by a JsonParse object.  But do not
175476 ** Return a JsonNode and all its descendents as a JSON string.
175837 ** are any errors.  If an error occurs, free all memory associated with
175872 ** to fill in all the descendants of node i.
175899 ** Compute the parentage of all nodes in a completed parse.
176224 ** array that contains all values given in arguments.  Or if any argument
176333 ** object that contains all name/value given in arguments.  Or if any name
176559 ** Return a JSON array composed of all values in the aggregate.
176603 ** Return a JSON object composed of all names and values in the aggregate.
177280 **   the total number of tokens in column iCol, considering all rows in 
177321 **   Set *pnInst to the total number of occurrences of all phrases within
177388 **   more than once for a single FTS query, then all invocations share a 
177424 **   method, to iterate through all instances of a single query phrase within
177448 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
177456 **   of iterating through all instances of a phrase in the current row, these
177472 **   then this API always iterates through an empty set (all calls to 
177618 **   all instances of "first place" or "1st place" regardless of which form
177623 **   <ol><li> By mapping all synonyms to a single token. In this case, the 
177917 ** An instance of the following structure encodes all information that can
177920 ** And all information loaded from the %_config table.
178183 ** Open a new iterator to iterate though all rowids that match the 
178620 ** The following is the concatenation of all %include directives from the
178630 ** Disable all error recovery processing in the parser push-down
178681 **                       Terminal symbols all have the same minor type, though.
178684 **    fts5YYMINORTYPE        is the data type used for all minor types.
178797 **  fts5yy_action[]        A single table containing all actions.
178950 /* For tracing shifts, the names of all terminals and nonterminals
178964 /* For tracing reduce actions, the names of all rules are required.
179157 ** all stack elements before shutting the parser down.
179859 ** Object used to iterate through all "coalesced phrase instances" in 
181871   Fts5Colset *pColset;            /* Columns to search (NULL -> all columns) */
181885   Fts5ExprPhrase **apPhrase;      /* Array of all phrases */
182503 ** Initialize all term iterators in the pNear object. If any term is found
182504 ** to match no documents at all, return immediately without initializing any
182609 ** considered to be larger. Nodes at EOF are the largest of all.
182627 ** this function is called. This function checks if all term iterators
182645   int bMatch;                     /* True if all terms are at the same rowid */
182745     /* Set the EOF flag if either all synonym iterators are at EOF or an
183029     /* Initialize all term iterators in the NEAR object. */
183328 ** phrase object consisting of all tokens returned.
183376       ** no token characters at all. (e.g ... MATCH '""'). */
184833 ** Extract all tokens from hash table iHash and link them into a list
184958 ** routines in this file file implement all read and write access to the
184969 ** The %_data table contains all the FTS indexes for an FTS5 virtual table.
184973 **   * all segment b-tree leaf data is stored in fixed size page records 
185018 **   there are one or more prefix indexes), it is guaranteed that all share
185025 **     + total number of segments on all levels,
185041 **   from left to right, the total number of tokens in the column for all
185446 ** considered to be greater than all other iterators.
185730 ** Remove all records associated with segment iSegid.
186632     ** merge and all data has already been "trimmed". See function
188162 ** The last point is to ensure all column numbers are stored as 
188268 ** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
188281   int iLevel,                     /* Level to iterate (-1 for all) */
188524 ** Discard all data currently cached in the hash-tables.
188647 ** is larger than all terms written to earlier leaves, and equal to or
188665 ** terms at all to disk.
189151     /* Read input from all segments in the input level */
189350 ** Buffer aBuf[] contains a list of varints, all small enough to fit
189549   **  + all segments are on the same level, or
189550   **  + all segments except one are currently inputs to a merge operation.
189579       /* Iterate through all segments, from oldest to newest. Add them to
190021 ** Indicate that all subsequent calls to sqlite3Fts5IndexWrite() pertain
190229 ** Open a new iterator to iterate though all rowid that match the 
190243   /* If the QUERY_SCAN flag is set, all other flags must be clear. */
190421 ** Set the 32-bit cookie value stored at the start of all structure 
190856 ** checksum does not match. Return SQLITE_OK if all checks pass without
190889   ** based on all expected entries in the FTS index (including prefix index
191480 ** all registered FTS5 extensions - tokenizers and auxiliary functions.
191486   Fts5Auxiliary *pAux;            /* First in list of all aux. functions */
191487   Fts5TokenizerModule *pTok;      /* First in list of all tokenizer modules */
191489   Fts5Cursor *pCsr;               /* First in list of all open cursors */
191943   /* Set idxFlags flags for all WHERE clause terms that will be used. */
192052 ** is moved to point at a different row. It clears all cached data 
192163 ** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors 
192179 ** argument, close and reopen all Fts5IndexIter iterators that the cursor 
192772   if( 0==sqlite3_stricmp("delete-all", zCmd) ){
192775           "'delete-all' may only be used with a "
193165     /* Initialize all iterators */
194316 ** Drop all shadow tables. Return SQLITE_OK if successful or an SQLite error
194483     /* Finalize all SQL statements */
194695 ** Delete all entries in the FTS5 index.
196488 ** Register all built-in tokenizers with FTS5.
196751   ** to all nRange codepoints (i.e. all nRange codepoints are upper case and
197169 ** for all bytes that have the 8th bit set and one byte with the 8th

Indexes created Sat Sep 07 21:54:46 MDT 2024