Lines Matching refs:all
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