Lines Matching defs:all
3 ** version 3.7.8. 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
53 ** code in all source files.
149 ** at all times.
285 ** fire any triggers. A value of 0 means that no trigger programs at all
333 ** Unfortunately, that typedef is not available on all compilers, or
427 ** implemented on some systems. So we avoid defining it at all
470 ** can insure that all cases are evaluated.
620 ** that we have taken it all out and gone back to using simple
824 ** successfully destroyed and all associated resources are deallocated.
826 ** Applications must [sqlite3_finalize | finalize] all [prepared statements]
827 ** and [sqlite3_blob_close | close] all [BLOB handles] associated with
1056 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1110 ** xSync VFS method occur and applies uniformly across all platforms.
1184 ** core reserves all opcodes less than 100 for its own use.
1212 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1289 ** SQLite and sent to all VFSes in place of a call to the xSync method
1306 ** to be adjusted. The values are changed for all database connections
1385 ** be unique across all VFS modules.
1404 ** The flags argument to xOpen() includes all bits set in
1505 ** or all of these interfaces to be NULL or for their behavior to change
1636 ** single thread. All open [database connections] must be closed and all
1754 ** memory allocation subsystem for SQLite to use for all of its
1793 ** not need to be threadsafe either. For all other methods, SQLite
1834 ** all mutexing and puts SQLite into a mode where it can only be used
1859 ** all mutexes including the recursive
1943 ** for all of its dynamic memory allocation needs beyond those provided
1952 ** allocator is engaged to handle all of SQLites memory allocation needs.
2025 ** is globally disabled. If URI handling is globally enabled, all filenames
2234 ** ^(The count returned by sqlite3_total_changes() includes all changes
2235 ** from all [CREATE TRIGGER | trigger] contexts and changes made by
2278 ** ^The sqlite3_interrupt(D) call is in effect until all currently running
2368 ** when SQLite is in the middle of a large transaction where all the
2407 ** turns off all busy handlers.
2434 ** The remaining entries all point to query results. NULL values result
2532 ** These routines all implement some additional formatting
2600 ** The SQLite core uses these three routines for all of its own
2711 ** ^On all subsequent invocations, the pseudo-randomness is generated
2758 ** [truncate optimization] is disabled and all rows are deleted individually.
3116 ** URI filename are interpreted, they are encoded using UTF-8 and all
3189 ** all calls to the interfaces listed here are completed.
3374 ** recommended for all new programs. The two older interfaces are retained
3484 ** SQLite uses the sqlite3_value object to represent all values
3635 ** parameter. For all forms except ?NNN, this will correspond to the
3693 ** ^Use this routine to reset all host parameters to NULL.
3762 ** subquery and is not a column value, then all of these functions return
3767 ** ^As with all other SQLite APIs, those whose names end with "16" return
3874 ** For all versions of SQLite up to and including 3.6.23.1, a call to
3892 ** with the "v2" interface. If you prepare all of your SQL statements
4227 ** SQL function or aggregate, pass NULL pointers for all three function
4530 ** the application-defined function to be a BLOB containing all zero
4546 ** message all text up through the first zero character.
4669 ** deleted. ^When all collating functions having the same name are deleted,
4679 ** to the same collation name (using different eTextRep values) then all
4681 ** The collating function must obey the following properties for all
4739 ** ^To avoid having to register all collation sequences before a database
4832 ** all, then the behavior of sqlite3_sleep() may deviate from the description
4841 ** the name of a folder (a.k.a. directory), then all temporary files
5030 ** ^(The cache sharing mode set by this interface effects all subsequent
5133 ** table or NULL. ^If it is NULL, then all attached databases are searched
5250 ** that is to be automatically loaded into all new database connections.
5284 ** ^This interface disables all automatic extensions previously
5499 ** common to all module implementations.
5530 ** are common to all implementations.
5926 ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
5960 ** implementation of this method is expected to release all outstanding
6121 ** the number, meaning, and operation of all subsequent parameters.
6128 ** they take, and what they do are all subject to change without notice.
6346 ** been satisfied using lookaside memory but failed due to all lookaside
6353 ** memory used by all pager caches associated with the database connection.)^
6358 ** memory used to store the schema for all databases associated
6367 ** and lookaside memory used by all prepared statements associated with
6591 ** When SQLite calls the xTruncate() method, the cache must discard all
6654 ** <li><b>sqlite3_backup_finish()</b> is called to release all resources
6691 ** ^If N is negative, all remaining source pages are copied.
6694 ** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
6749 ** ^The sqlite3_backup_finish() interfaces releases all
7051 ** empty string, then a checkpoint is run on all databases of
7074 ** readers or writers to finish. Sync the db file if all frames in the log
7080 ** database writer and all readers are reading from the most recent database
7081 ** snapshot. It then checkpoints all frames in the log file and syncs the
7088 ** until all readers are reading from the database file only. This ensures
7119 ** specified operation is attempted on all WAL databases. In this case the
7389 ** Macros for looping over all elements of a hash table. The idiom is
7762 ** all alignment restrictions correct.
7793 ** is a special table that holds the names and attributes of all
7856 ** When a function parameter is not used at all within the body of a function,
8873 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
8878 /* Remove all pages with pgno>x. Reset the cache if x==0 */
8881 /* Get a list of all dirty pages in the cache, sorted by page number */
8905 /* Iterate through all dirty pages currently stored in the cache. This
8966 ** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER
9092 ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
9117 ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
9128 ** But a single Win95 reader will lock out all WinNT readers and a single
9129 ** WinNT reader will lock out all other Win95 readers.
9138 ** clients on win95, winNT, and unix all talking to the same shared file
9139 ** and all locking correctly. To do so would require that samba (or whatever
9147 ** that all locks will fit on a single page even at the minimum page size.
9237 ** This file contains the common header for all mutex implementations.
9239 ** to all source files. We break it out in an effort to keep the code
9538 /* The following variables are all protected by the STATIC_MASTER
9552 sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
9606 #define SQLITE_OptMask 0xff /* Mask of all disablable opts */
9932 FKey *pFKey; /* Linked list of all foreign keys in this table */
9935 Expr *pCheck; /* The AND of all CHECK constraints */
9943 char **azModuleArg; /* Text of all module args. [0] is module name */
10039 #define OE_Fail 3 /* Stop the operation but leave all prior changes */
10090 #define UNPACKED_NEED_DESTROY 0x0002 /* apMem[]s should all be destroyed */
10259 ** it can be accessed after all aggregates are computed.
10284 ** an Expr object is truncated. When EP_Reduced is set, then all
10618 u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */
10647 ** or all contexts are check. When a match is found, the nRef member of
10670 ** An instance of the following structure contains all information
10731 /* The ORDER BY clause is ignored for all of the above */
10764 AutoincInfo *pNext; /* Next info block in a list of them all */
10804 ** The yDbMask datatype for the bitmask of all attached databases.
10814 ** the parser and down into all the parser action routine in order to
11041 const char *zDb; /* Make sure all objects are contained in this database */
11169 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all
11917 /* An array to map all upper-case characters into their corresponding
12077 ** Hash table for global functions - functions common to all
12144 ** An array of names of all compile-time options. This array should
12557 ** VDBE. This information used to all be at the top of the single
12583 ** loop over all entries of the Btree. You can also insert new BTree
12629 u32 *aType; /* Type values for all entries in the record */
12631 u8 *aRow; /* Data for the current row, if all on one page */
12682 ** Internally, the vdbe manipulates nearly all SQL values as Mem
12785 ** There is a typedef for this structure in sqlite.h. So all routines,
12811 ** set to 2 for xDestroy method calls and 1 for all other methods. This
12872 SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
13115 ** by all pagers associated with the given database connection. The
13137 ** to store the schema for all databases (main, temp, and any ATTACHed
13180 ** to store all prepared statements.
13227 ** SQLite processes all times and dates as Julian Day numbers. The
13240 ** The Gregorian calendar system is used for all dates and times,
13944 ** argv[1] and following are modifiers. Parse them all and write
14304 ** This function registered all of the above C functions as SQL
14348 ** This file contains OS interface code that is common to all
14578 ** The list of all registered VFS implementations.
14785 ** No-op versions of all memory allocation routines
15026 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
15059 ** Head and tail of a linked list of all outstanding allocations
15442 ** Open the file indicated and write a log of all unfreed memory
15515 ** This version of the memory allocation subsystem omits all
15803 ** This routine examines all entries on the given list and tries
16085 ** Open the file indicated and write a log of all unfreed memory
16204 ** This version of the memory allocation subsystem omits all
16229 ** allocation size (after rounding all sizes up to a power of 2.) Let M
16297 u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
16709 ** Open the file indicated and write a log of all unfreed memory
16786 ** This file contains code that is common across all mutex implementations.
16960 ** Stub routines for all mutex methods.
18705 ** that all prior mallocs (ex: "a") worked too.
19700 ** Reset an StrAccum string. Reclaim all malloced memory.
19951 ** randomness any more. But we will leave this code in all the same.
20280 ** all that is required is to swap the byte order. This case is handled
21214 ** for all bytes that have the 8th bit set and one byte with the 8th
21828 /* Remove all entries from a hash table. Reclaim all memory.
21833 HashElem *elem; /* For looping over all elements of the table */
22271 ** driver. And that causes all kinds of problems for our tests. We
22292 ** Include code that is common to all os_*.c files
22309 ** all of the platform-specific files (os_*.c) and is #included into those
22564 ** Read data from a file into a buffer. Return SQLITE_OK if all
22661 ** Make sure all writes to a particular file are committed to disk.
22759 ** erases all locks at once and returns us immediately to locking level 0.
23189 ** When multiple threads all reference the same log-summary, each thread has
23190 ** its own os2File object, but they all point to a single instance of this
23212 os2ShmNode *pNext; /* Next in list of all os2ShmNode objects */
23252 ** A global list of all os2ShmNode objects.
23270 ** Apply advisory locks for all n bytes beginning at ofst.
23427 ** Purge the os2ShmNodeList list of all entries with nRef==0.
23662 os2ShmLink *pX; /* For looping over all siblings */
23787 ** This vector defines all the methods that can operate on an
24393 ** skip locking all together.
24404 ** * Various locking primitive implementations (all except proxy locking):
24412 ** * Definitions of sqlite3_io_methods objects for all locking
24416 ** * Definitions of sqlite3_vfs objects for all locking methods
24472 ** on 2008-11-28.) These days, all Linux kernels support large files, so
24634 ** Include code that is common to all os_*.c files
24651 ** all of the platform-specific files (os_*.c) and is #included into those
24892 ** to all overrideable system calls.
24993 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
25008 /* If no zName is given, restore all system calls to their default
25087 ** vxworksFileId objects used by this file, all of which may be
25131 ** Print out information about all locking operations.
25305 struct vxworksFileId *pNext; /* Next in a list of them all */
25484 ** all locks on that file that are owned by the current process are
25489 ** to close() the file descriptor is deferred until all of the locks clear.
25546 unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
25558 ** A lists of all unixInodeInfo objects.
25653 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
25843 ** within this process, but all of that is handled in memory and the
25935 ** range'. Since all other locks require a read-lock on one of the bytes
26285 ** OS call only when all threads in this same process have released
26336 ** common to all locking schemes. It closes the directory and file
26337 ** handles, if they are valid, and sets all fields of the unixFile
26444 ** (1) There is zero concurrency. A single reader blocks all other
26745 ** lock states in the sqlite3_file structure, but all locks SHARED or
26746 ** above are really EXCLUSIVE locks and exclude all other processes from
26921 ** lock states in the sqlite3_file structure, but all locks SHARED or
26922 ** above are really EXCLUSIVE locks and exclude all other processes from
27032 ** The afpLockingContext structure contains all afp lock specific state
27425 ** OS call only when all threads in this same process have released
27518 ** The next division contains implementations for all methods of the
27521 ** division). Those methods that are common to all locking modes
27572 ** Read data from a file into a buffer. Return SQLITE_OK if all
27754 ** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
27886 ** Make sure all writes to a particular file are committed to disk.
28162 ** When multiple threads all reference the same wal-index, each thread
28163 ** has its own unixShm object, but they all point to a single instance
28235 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
28310 ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
28637 unixShm *pX; /* For looping over all siblings */
28807 ** Here ends the implementation of all sqlite3_file methods.
28874 ** Here are all of the sqlite3_io_methods objects for each of the
29711 ** and clear all the structure's references. Specifically,
29932 ** When testing, initializing zBuf[] to zero is all we do. That means
30070 ** until late in the file (here) after all of the other I/O methods have
30094 ** cache exposes a cache coherency problem that is present on all OS X
30163 ** The proxy file - a single-byte file used for all advisory file locks
30166 ** host (the conch ensures that they all use the same local lock file).
30207 ** will force automatic proxy locking to be disabled for all database
30285 /* try to create all the intermediate directories */
30933 /* all other styles use the locking context to store the db file path */
30941 ** Takes an already filled in unix file and alters it so all file locking
31009 /* all memory is allocated, proxys are created and assigned,
31094 ** above this point are all utilities. The lock-related methods of the
31239 ** This routine registers all VFS implementations for unix-like operating
31332 /* Register all VFSes defined in the aVfs[] array */
31384 ** driver. And that causes all kinds of problems for our tests. We
31411 ** Include code that is common to all os_*.c files
31428 ** all of the platform-specific files (os_*.c) and is #included into those
32672 ** Read data from a file into a buffer. Return SQLITE_OK if all
32805 ** Make sure all writes to a particular file are committed to disk.
32967 ** erases all locks at once and returns us immediately to locking level 0.
33257 ** this file, all of which may be shared by multiple threads.
33281 ** shared memory. When multiple threads all reference the same
33282 ** log-summary, each thread has its own winFile object, but they all
33317 winShmNode *pNext; /* Next in list of all winShmNode objects */
33324 ** A global array of all winShmNode objects.
33361 ** Apply advisory locks for all n bytes beginning at ofst.
33414 ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
33627 winShm *pX; /* For looping over all siblings */
33874 ** Here ends the implementation of all sqlite3_file methods.
33880 ** This vector defines all the methods that can operate on an
34786 ** or all of the pages in a database can get journalled. In those cases,
35036 ** Destroy a bitmap object. Reclaim all memory used.
35558 ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
35703 ** Return a list of all dirty pages in the cache, sorted by page number.
35759 ** For all dirty pages currently in the cache, invoke the specified
35811 ** (2) There is a single global PGroup that all PCaches are a member
35869 ** then it is guaranteed that all blocks are full.
35911 /* Hash table of all pages. The following variables may only be accessed
35951 ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
36362 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
36365 ** for all page cache needs and we should not need to spill the
36368 ** Or, the heap is used for all page cache memory put the heap is
36499 ** Discard all pages from cache pCache with a page number (key value)
36675 ** the sum of nMax for all purgeable caches, less the sum of
36676 ** nMin for all other purgeable caches, or
36684 ** (b) The number of pages allocated for all purgeable caches is
36685 ** already equal to or greater than the sum of nMax for all
36876 ** Discard all unpinned pages in the cache with a page number equal to
37008 ** After all inserts are finished, it is possible to extract the
37036 ** a non-zero batch number, it will see all prior INSERTs.
37080 struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */
37090 struct RowSetChunk *pChunk; /* List of all chunk allocations */
37130 ** Deallocate all chunks from a RowSet. This frees all memory that
37226 ** Sort all elements on the pEntry list of the RowSet into ascending order.
37588 ** (a) The page and all other pages on the same sector are overwriteable.
37609 ** (6) If a master journal file is used, then all writes to the database file
37614 ** all queries. Note in particular the the content of freelist leaf
37715 ** * Any lock, or no lock at all, may be held on the database file.
37720 ** In this state all the requirements for reading the database in
37745 ** is first opened on the database. In WRITER_LOCKED state, all locks
37753 ** in WRITER_LOCKED state, all that is required is to unlock the database
37766 ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
37812 ** If no error occured, all that remains is to finalize the journal to
37836 ** to read or write data returns an error. Eventually, once all
38009 ** logic into thinking that it already has all the locks it will ever
38088 ** It is valid in PAGER_READER and higher states (all states except for
38142 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
38158 u8 memDb; /* True to inhibit all file I/O */
38366 ** this means an in-memory pager performs no IO at all, it cannot encounter
39206 ** Free all structures in the Pager.aSavepoint[] array and set both
39226 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
39344 ** all major API calls on the Pager will immediately return Pager.errCode.
39525 ** call to pager_unlock() will discard all in-memory pages, unlock
39864 ** of all of its child journals, one after another, formatted as utf-8
39871 ** A master journal file may only be deleted once all of its child
40115 ** journal file then all pages up to the first corrupted page are rolled
40283 ** update the change-counter at all. This may lead to cache inconsistency
40366 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
40463 /* For all pages in the cache that are currently dirty or have already
40871 ** the xSync primitive is called and is relevant to all platforms.
40982 ** Otherwise, if all of the following are true:
40997 ** In all other cases, SQLITE_OK is returned.
41087 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
41190 ** following is true for all dirty pages currently in the page-cache:
41262 ** Shutdown the page cache. Free all memory and close all files.
41344 ** Sync the journal. In other words, make sure all the pages that have
41406 ** hot-journal rollback following recovery. It may roll back all
41438 ** all data has really hit the disk before nRec is updated to mark
41481 ** all pages.
41627 ** for all open savepoints before returning.
41703 ** The doNotSpill flag inhibits all cache spilling regardless of whether
41796 ** all information is held in cache. It is never written to disk.
42476 ** page is initialized to all zeros.
42495 ** The acquisition might fail for several reasons. In all cases,
42633 ** page is added to the LRU list. When all references to all pages
42713 /* TODO: Check if all of these are really required. */
42962 ** fit on a single disk sector. In this case all co-resident pages
43035 ** starting at pg1, then it needs to be set for all of them. Because
43037 ** journal file must contain sync()ed copies of all of them
43077 ** The overlying software layer calls this routine when all of the data
43239 ** * all dirty pages are written to the database file,
43358 /* If this transaction has made the database smaller, then all pages
43397 /* Sync the journal file and write all dirty pages to the database.
43499 ** If a write transaction is open, then all changes made within the
43509 ** 1) It rolls back the journal file, restoring all database file and
43519 ** In WAL mode, all cache-entries containing data modified within the
43694 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
43709 ** In any case, all savepoints with an index greater than iSavepoint
44423 ** after the commit. For all other records, zero.
44437 ** WAL header and the first 8 bytes and the content of all frames
44456 ** of the sequence being summed.) The s1 value spans all 32-bit
44461 ** The VFS.xSync operations serve as write barriers - all writes launched
44482 ** for all subsequent read operations. New transactions can be appended
44510 ** Hence, unlike the database and WAL file formats which store all values
44528 ** first index block are the same size as all other index blocks in the
44680 u32 aCksum[2]; /* Checksum over all prior fields */
44702 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
44719 ** get all their all content directly from the database file and ignore
44723 ** if nBackfill equals mxFrame (meaning that all WAL content has been
44760 ** file are calculated by treating all data as an array of 32-bit
44762 ** all data as 32-bit little-endian words.
44823 ** all frames in the WAL in database page order. Where two or more frames
45026 ** after the commit. For all other records, zero.
45086 ** all prior frams, the first 16 bytes of this frame-header,
45136 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
45295 /* Zero all hash-table entries that correspond to frame numbers greater
45430 /* Obtain an exclusive lock on all byte in the locking range not already
45518 /* Read all frames from the log file. */
45557 ** currently holding locks that exclude all other readers, writers and
45681 ** Find the smallest page number out of all pages held in the WAL that
45725 ** is guaranteed for all J<K:
45735 ** The aContent[aLeft[X]] values will be unique for all X. And the
45789 ** aList[] are to be sorted so that for all J<K:
45864 ** Construct a WalInterator object that can be used to loop over all
46131 ** file has been copied into the database file, then block until all
46245 return 1; /* Malformed header - probably all zeros */
46380 ** completely and get all content directly from the database file.
46914 /* If all readers are using WAL_READ_LOCK(0) (in other words if no
47500 ** a fragment. The total number of bytes in all fragments is recorded.
47514 ** byte are used. The integer consists of all bytes that have bit 8 set and
47517 ** As a special case, all 8 bytes of the 9th byte are used as data. This
47611 ** Access to all fields of this structure is controlled by the mutex
47675 ** schema associated with the database file are all contained within
47748 BtCursor *pCursor; /* A list of all open cursors */
47805 ** root-node and 3 for all other internal nodes.
47829 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
47964 ** This structure is passed around through all the sanity checking routines
48031 ** by all database connections. The p->pNext is a list of other
48034 ** p, then first unlock all of the others on p->pNext, then wait
48035 ** for the lock to become available on p, then relock all of the
48076 /* To avoid deadlock, first release all locks with a larger
48147 ** against all schemas and we do not want those schemas being
48150 ** There is a corresponding leave-all procedures.
48154 ** two or more btrees in common both try to lock all their btrees
48187 ** mutex and all required BtShared mutexes.
48237 ** these two routines, all mutex operations are no-ops in that case and
48240 ** If shared cache is disabled, then all btree mutex routines, including
48610 ** Release all the table locks (locks obtained via calls to
48660 ** This function changes all write-locks held by Btree p into read-locks.
48703 ** Invalidate the overflow page-list cache for all cursors opened
48720 ** table is about to be deleted. In this case invalidate all incrblob
48730 int isClearTable /* True if all rows are being deleted */
48758 ** 1) When all data is deleted from a page and the page becomes
48766 ** be, if it is not at all meaningful?).
48839 ** all that is required. Otherwise, if pCur is not open on an intKey
48873 ** Save the positions of all cursors (except pExcept) that are open on
49321 ** end of the page and all free space is collected into one
49410 ** all the space together, however. This routine will avoid using
50064 /* In debug mode, we mark all persistent databases as sharable
50165 ** Btree into the list of all sharable Btrees for the same connection.
50279 ** Close an open database and invalidate all cursors.
50285 /* Close all cursors opened via this handle. */
50932 ** Set the pointer-map entries for all children of page pPage. Also, if
51074 ** that point to overflow pages. The pointer map entries for all these
51348 ** disk and we are still holding all locks, so the transaction has not
51428 ** routine did all the work of writing information out to disk and flushing the
51566 ** all queries that may be using any of the cursors that failed to save.
51630 ** an index greater than all savepoints created explicitly using
51891 /* Use a macro in all other compilers so that the function is inlined */
52865 /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
54073 ** (hereafter "the page") and up to 2 siblings so that all pages have about the
54078 ** is a root page or a child of a root page) then all available siblings
54086 ** if the page is overfull. This routine ensures that all cells allocated
54106 ** enough for all overflow cells.
54141 u16 *szCell; /* Local size of all cells in apCell[] */
54169 ** has NB or fewer children then all children of pParent are taken.
54266 ** Load pointers to all cells on sibling pages and the divider cells
54273 ** into aSpace1[]. In this way, all cells in apCell[] are without
54274 ** child pointers. If siblings are not leaves, then all cell in
54275 ** apCell[] include child pointers. Either way, all cells in apCell[]
54345 ** Figure out the number of pages needed to hold all nCell cells.
54347 ** size of all cells on the i-th page and cntNew[] which is the index
54555 ** Note that this can never happen in an SQLite data file, as all
54591 ** sets all pointer-map entries corresponding to database image pages
54605 /* Fix the pointer-map entries for all the cells that were shifted around.
54701 ** all pointer map pages are set correctly. This is helpful while
54738 ** Before returning, all pointer-map entries corresponding to pages
54934 ** point to any entry or to no entry at all and so this function has to seek
55225 ** out to be an overflow page, delete all overflow page-map caches
55346 ** Erase the given database page and all its children. Return
55395 ** Delete all information from a single table in the database. iTable is
55413 /* Invalidate all incrblob cursors open on table iTable (assuming iTable
55427 ** Erase all information in a table and add the root of the table to
55438 ** is added to the freelist instead of iTable. In this say, all
55661 ** If all pages in the tree have been visited, return SQLITE_OK to the
55870 ** 6. Recursively call checkTreePage on all children.
55871 ** 7. Verify that the depth of all children is the same.
55919 /* Check out all the cells.
56145 /* Check all the tables.
56916 /* This call ensures that all data required to recreate the original
56987 ** Release all resources associated with an sqlite3_backup* handle.
57648 ** n containing all zeros.
58321 ** to version 2.8.7, all this code was combined into the vdbe.c source file.
58329 ** set the sqlite3VdbeAddopTrace to 1 and all opcodes will be printed
58378 ** Swap all content between two VDBE structures.
58504 ** sqlite3VdbeAddOp4() since it needs to also local all btrees.
58537 ** through its operation list and change all values of P2 which match
58586 ** The following type and function are used to iterate through all opcodes
58697 ** through all opcodes and hasAbort may be set incorrectly. Return
58709 ** This routine is called once after all opcodes have been inserted.
58715 ** The Op.opflags field is set on all opcodes.
58969 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
59140 /* C89 specifies that the constant "dummy" will be initialized to all
59293 ** of all of BtShared structures accessible via the database handle
59299 ** The p->btreeMask field is a bitmask of all btrees that the prepared
59325 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
59472 ** the sum of the number of rows in all trigger subprograms encountered
59821 ** end of the opcode array. If we are unable to satisfy all memory
59870 ** Close a VDBE cursor and release all the resources that cursor
59915 ** Close all cursors.
60075 /* If there are any write-transactions at all, invoke the commit hook */
60102 /* Do the commit only if all databases successfully complete phase 1.
60197 /* Sync all the db files involved in the transaction. The same call
60290 *** occurs. We have to trip all the other cursors, even
60446 /* Lock all btrees used by the statement */
60668 /* Reclaim all memory used by the VDBE
60717 ** are always destroyed. To destroy all auxdata entries, call this
60734 ** Free all memory associated with the Vdbe passed as the second argument.
60838 ** the blob of data that it corresponds to. In a table record, all serial
60985 ** prefix and the tail then write the prefix and set the tail to all
61303 /* If the PREFIX_SEARCH flag is set and all fields except the final
61327 ** all the fields up to that point were equal. If the UNPACKED_INCRKEY
61658 ** Set all the parameters in the compiled SQL statement to NULL.
62249 ** instead of an 8-byte one. This all works fine, except that when
62761 ** Transfer all bindings from the first statement over to the second.
63035 ** Few opcodes use all 5 operands.
64252 ** for lines of that contain "Opcode:". That line and all subsequent
64343 ** then back out all changes that have occurred during this execution of the
64658 /* Invalidate all ephemeral cursor row caches */
65567 ** once and jumps on all subsequent invocations. It is the equivalent
65795 /* The following assert is true in all cases accept when
65885 ** of the record (when all fields present), then we must be dealing
65989 ** If P4 is NULL then all index fields have the affinity NONE.
66225 ** if there are any active statements at all.
66267 /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
66513 /* Invalidate all prepared statements whenever the TEMP database
66589 ** values need not be contiguous but all P1 values should be small integers.
66600 ** released when all cursors are closed. If this instruction attempts
67368 /* The zero initialization above is all that is needed */
67390 ** to provide the constant while making all compilers happy.
68258 ** might be moved into the newly deleted root page in order to keep all
68310 ** Delete all contents of the database table or index whose root page
68395 ** Read and parse all entries from the SQLITE_MASTER table of database P1
68454 ** the analysis to be used when preparing all subsequent queries.
68512 ** The root page numbers of all tables in the database are integer
68709 ** single trigger all have the same value for the SubProgram.token
69207 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
69705 ** The cases of the switch statement above this line should all be indented
70242 ** database handle error code and message set. If this happens, then all
70310 ** all PMAs currently stored on disk must be merged together. This comment
70419 ** Free all memory belonging to the VdbeSorterIter object passed as the second
70935 i64 *pnByte /* Sum of bytes in all opened PMAs */
70940 i64 nByte = 0; /* Total bytes in all opened PMAs */
71736 ** Walk all expressions associated with SELECT statement p. Do
71753 ** Walk the parse trees associated with all subqueries in the
71815 ** resolve all identifiers by associating them with a particular
72191 /* Increment the nRef value on all name contexts from TopNC up to
72477 /* Resolve all names in the ORDER BY term expression
72723 ** Resolve names in the SELECT statement p and all of its descendents.
72750 ** sqlite3SelectPrep() do all of the processing for this SELECT.
72794 /* Recursively resolve names in all subqueries
72803 /* Count the total number of references to pOuterNC and all of its
72862 ** below, after all of the result-sets for all of the elements of
72896 /* Resolve the ORDER BY on a compound SELECT after all terms of
72994 ** Resolve all names in all expressions of a SELECT and in all
73045 ** i.e. the WHERE clause expresssions in the following statements all
73743 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
73899 ** If cursors, triggers, views and subqueries are all omitted from
74148 /* Consider functions to be constant if all their arguments are constant
74579 ** all corresponding LHS elements. All this routine does is initialize
74610 ** If all of the above are false, then we can run this code just once
74892 ** over all of the code that follows.
75130 ** get them all.
75197 ** Clear all column cache entries.
77054 ** Generate the text of a WHERE expression which can be used to select all
77070 ** Generate the text of a WHERE expression which can be used to select all
77282 ** statements corresponding to all child tables of foreign key constraints
77633 ** or it may be a NULL pointer. If it is not NULL, then all entries in
77636 ** to delete all stat table entries.
77681 /* The table already exists. If zWhere is not NULL, delete all entries
77691 /* The sqlite_stat[12] table already exists. Delete all rows. */
77706 ** Generate code to do an analysis of all indices associated with
77839 /* Start the analysis loop. This loop runs through all the entries in
78039 ** Form 1 causes all indices in all attached databases to be analyzed.
78040 ** Form 2 analyzes all indices the single database named.
78041 ** Form 3 analyzes all indices associated with the named table.
78685 ** statement only). For DETACH, set it to false (expire all existing
78770 ** a specific database to all table references where the database name
79312 /* Once all the cookies have been verified and transactions opened,
79396 ** If zDatabase is 0, all databases are searched for the table and the
79464 ** If zDatabase is 0, all databases are searched for the
79502 ** the index hash table and free all memory structures associated
79533 ** Erase all schema information from the in-memory hash tables of
79539 ** If iDb<0 then reset the internal schema tables for all database
79565 /* Case 2 (from here to the end): Reset all schemas for all attached
79581 ** opportunity to do this here since we have just deleted all of the
79651 /* Delete all indices associated with this table. */
79686 ** table structure with all its indices and foreign keys.
80612 /* Resolve names in all CHECK constraint expressions.
80686 ** a schema-lock excludes all other database users, the write-lock would
80723 ** SQLITE_MASTER table. We just need to update that slot with all
80838 ** This will force all the Expr.token.z values to be dynamically
81003 ** We must continue looping until all tables and indices with
81061 ** Write VDBE code to erase table pTab and all associated indices on disk.
81245 /* Drop all triggers associated with the table being dropped. Code
81271 /* Drop all SQLITE_MASTER table and index entries that refer to the
81307 ** pTo table that the foreign key points to. flags contains all
81505 /* Open the table. Loop through all rows of the table, inserting index
82003 ** to invalidate all pre-compiled statements.
82015 ** sure all indices labeled OE_Replace come after all those labeled
82386 ** Assign VdbeCursor index numbers to all tables in a SrcList
82404 ** Delete an entire SrcList including all its substructure.
82502 ** Shifts all join operators from left to right for an entire FROM
82645 ** a read-transaction for all named database files.
82647 ** It is important that all schema cookies be verified and all
82655 ** pParse->cookieMask field. Later, after all other code has been
82716 ** rollback the whole transaction. For operations where all constraints
82793 ** Recompute all indices of pTab that use the collating sequence pColl.
82794 ** If pColl==0 then recompute all indices of pTab.
82811 ** Recompute all indices of all tables in all databases where the
82813 ** all indices everywhere.
82842 ** Form 1 causes all indices in all attached databases to be rebuilt.
82843 ** Form 2 rebuilds all indices in all databases that use the named
82844 ** collating function. Forms 3 and 4 rebuild the named index or all
83340 ** Free all resources held by the schema structure. The void* argument points
83695 /* Assign cursor number to the table and all its indices.
83789 ** deleting from and all its indices. If this is a view, then the
83870 ** 2. Read/write cursors for all indices of pTab must be open as
83876 ** This routine generates code to remove both the table record and all
83970 ** This routine generates VDBE code that causes the deletion of all
83979 ** 2. Read/write cursors for all indices of pTab must be open as
84555 ** character is exactly one byte in size. Also, all characters are
85020 ** The replace() function. Three arguments are all strings: call
85559 ** All all of the FuncDef structures in the aBuiltinFunc[] array above
85567 ** The following array holds FuncDef structures for all of the functions
85733 ** An UPDATE command requires that all 4 steps above are taken, but only
85983 int isIgnore /* If true, pretend pTab contains all NULL values */
86261 ** and all of its sub-components.
86376 /* Loop through all the foreign key constraints for which pTab is the
86463 /* Loop through all the foreign key constraints that refer to this table */
86820 /* If foreign-key support is enabled, iterate through all FKs that
86838 ** Free all memory associated with foreign key definitions attached to
87068 ** The 2nd register is the one that is returned. That is all the
87100 ** This routine generates code that will initialize all of the
87195 ** above are all no-ops
87218 ** then a list of all columns for the table is substituted. The IDLIST
87241 ** in other words if the SELECT pulls all columns from a single table
87244 ** schemas, including all the same indices, then a special optimization
87251 ** transfer all records in <table2> over to <table>
87256 ** transfer all records from the read to the write cursors
87581 ** all elements of the IDLIST really are columns of the table and
87633 /* If this is not a view, open the table and and all indices */
87806 /* Push onto the stack, data for all columns of the new entry, beginning
87894 /* Close all tables opened */
87974 ** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
88048 /* Test all NOT NULL constraints.
88093 /* Test all CHECK constraints
88190 /* Test all UNIQUE constraints by creating entries for each UNIQUE
88358 ** Generate code that will open cursors for a table and for all
88426 ** * The same DESC and ASC markings occurs on all columns
88463 ** (1) tab1 and tab2 have identical schemas including all the
88593 return 0; /* Affinity must be the same on all columns */
88596 return 0; /* Collating sequence must be the same on all columns */
88657 ** insure that all entries in the union of DEST and SRC will be
88917 ** The following structure holds pointers to all of the SQLite API
89417 ** The following structure contains pointers to all SQLite API routines.
89921 ** Load all automatic extensions.
90190 ** compiler (eg. count_changes). So add an opcode to expire all
90458 ** set on all attached databases, as well as the main db file.
90495 /* Force the schema to be loaded on all databases. This cases all
91074 ** for all tables and indices in the database.
91106 /* Make sure all the indices are constructed correctly.
91197 ** In all cases new databases created using the ATTACH command are
91333 ** Return the names of all compile-time options used in this build,
91396 ** Report the current state of file logs for all databases
91861 ** Initialize all database files - the main database file, the file
91885 /* Once all the other databases have been initialised, load the schema
91927 ** Check schema cookies in all databases. If any cookie is out
91928 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
92033 /* Check to verify that it is possible to get a read lock on all
92045 ** This thread is currently holding mutexes on all Btrees (because
92053 ** but it does *not* override schema lock detection, so this all still
92366 ** Delete all the content of a Select structure but do not deallocate
92446 ** Delete the given Select structure and all of its substructures.
92619 ** Set the EP_FromJoin property on all terms of the given expression.
93336 ** result-set expression in all of the following SELECT statements is
93678 ** This routine requires that all identifiers in the SELECT
93794 ** "LIMIT -1" always shows all rows. There is some
93951 /* Make sure all SELECTs in the statement have the same number of elements
94192 ** Attach the KeyInfo structure to all temporary tables.
94489 ** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
94959 ** Flattening is only attempted if all of the following are true:
94972 ** (4) has since been expanded to exclude all DISTINCT subqueries.
95016 ** (18) If the sub-query is a compound select, then all terms of the
95115 ** which is not at all the same thing.
95277 ** This loop moves all of the FROM elements of the subquery into the
95306 ** then expand the outer query to make space for it to hold all elements
95547 /* Make sure cursor numbers have been assigned to all entries in
95612 ** all columns in all tables. And for every TABLE.* insert the names
95613 ** of all columns in TABLE. The parser inserted a special expression
95616 ** each one to the list of all columns in all tables.
95763 ** This routine "expands" a SELECT statement and all of its subqueries.
95827 ** the Table structures of all FROM-clause subqueries in a
95847 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
95848 ** * Ephemeral Table objects are created for all FROM-clause subqueries.
95853 ** This routine acts recursively on all subqueries within the SELECT.
95876 ** routine simply stores NULLs in all of those memory cells.
96144 /* Generate code for all sub-queries in the FROM clause
96415 /* Remove any and all aliases between the result set and the
96438 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
96475 ** that we do not need it after all, the OP_SorterOpen instruction
96501 /* Begin a loop that will extract all source rows in GROUP BY order.
96845 ** These routines are used to print out the content of all or part of a
97002 ** the names of all columns.
97168 ** Given table pTab, return a list of all the triggers attached to
97173 ** triggers on pTab in the TEMP schema. This routine prepends all
97177 ** To state it another way: This routine returns a list of all triggers
97294 ** Normally, whenever a table is dropped, all associated triggers are
97402 ** This routine is called after all of the trigger actions have been parsed
97772 ** Return a list of all triggers on table pTab if there exists at least
98301 ** If the former, then all row-records are guaranteed to include a value
98370 int openAll = 0; /* True if all indices need to be opened */
98432 /* Allocate a cursors for the main database table and for all indices.
98447 /* Resolve the column names in all the expressions of the
98563 /* Resolve the column names in all the expressions in the
98602 ** action, then we need to open all indices because we might need
98726 ** all columns not modified by the update statement into their
98784 ** all record selected by the WHERE clause have been updated.
98789 /* Close all tables */
98878 ** all updated rows.
99010 ** gdbm_reorganize() on all the database tables. But beginning
99184 ** associated storage, so all we have to do is copy their entries
99381 ** the disconnect is deferred until all locks have been removed.
99422 ** Table p is a virtual table. This function moves all elements in the
99462 ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
99464 ** This function may only be called when the mutexes associated with all
99469 ** 1) By this function. In this case, all BtShared mutexes and the mutex
99499 ** Clear any and all virtual-table information from the Table record.
99639 ** SQLITE_MASTER table. We just need to update that slot with all
100053 ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
100055 ** SQLITE_OK if all xSync operations are successful.
100081 ** Invoke the xRollback method of all virtual tables in the
100090 ** Invoke the xCommit method of all virtual tables in the
100147 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
100158 ** function immediately. If all calls to virtual table methods are successful,
100473 ** An instance of the following structure holds all information about a
100497 Bitmask indexable; /* Bitmask of all indexable tables in the clause */
100531 ** numbers all get mapped into bit numbers that begin with 0 and contain
100566 #define WO_ALL 0xfff /* Mask of all possible WO_* values */
100567 #define WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */
100623 ** Deallocate all memory associated with a WhereOrInfo object.
100631 ** Deallocate all memory associated with a WhereAndInfo object.
100724 ** all terms of the WHERE clause.
100781 ** translate the cursor numbers into bitmask values and OR all
100971 ** Call exprAnalyze on all terms in a WHERE clause.
101147 ** If all subterms are of the form T.C=expr for some single column of C
101160 ** If all subterms are indexable by a single table T, then set
101179 ** All examples A through E above all satisfy case 2. But if a term
101189 ** the union of all rowids using a RowSet object. This is similar
101304 ** sure the same column is used on all terms. The 2-bit case is when
101305 ** the all terms are of the form "table1.column=table2.column". It
101316 int iCursor = -1; /* Table cursor common to all terms */
101434 ** subexpression and populate all the other fields of the WhereTerm
101620 ** LIKE on all candidate expressions by clearing the isComplete flag
101794 ** all expressions in the pDistinct list are delivered grouped together.
101816 /* Loop through all the expressions in the distinct list. If any of them
101882 /* Loop through all indices on the table, checking each to see if it makes
101927 ** set to 1 if the ORDER BY clause is all DESC and it is set to 0 if
101928 ** the ORDER BY clause is all ASC.
102019 /* Indices can only be used if all ORDER BY terms past the
102020 ** equality constraints are all either DESC or ASC. */
102050 ** clause reference other tables in a join. If this is all true then
102374 ** covering index. A "covering index" is an index that contains all
102630 ** and initialized on the first invocation and reused on all subsequent
102687 /* Set the aConstraint[].usable fields and initialize all
102697 ** only valid if all tables referenced in expr occur to the left
102700 ** The aConstraints[] array contains entries for all constraints
102780 ** Region 0 contains all values less than the first sample value. Region
103250 ** fake index the first in a chain of Index objects with all of the real
103275 /* Loop over all indices looking for the best one to use
103339 ** For other indexes, it is true unless all the columns of the table
103437 ** index), determine if all required column data may be obtained without
103567 ** The notValid mask, on the other hand, always has all bits set for
103749 ** beginning and end of zAff are ignored. If all entries in zAff are
103793 ** this routine sets up a loop that will iterate over all values of X.
103850 ** Generate code that will evaluate all == and IN constraints for an
103986 ** SQL expression. Or, if all rows are scanned, NULL is returned.
104326 ** index is on (x,y,z), then the following clauses are all
104414 /* Generate code to evaluate all constraint terms using == or IN
104617 ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
104839 ** scanning through all values on the right-hand side of the IN.
104861 ** loops are evaluated and if false a jump is made around all subsequent
104899 SrcList *pTabList, /* A list of all tables to be scanned */
104916 int andFlags; /* AND-ed combination of all pWC->a[].wtFlags */
104928 /* This function normally generates a nested loop for all tables in
104976 ** expression and either jump over all of the code or fall thru.
104987 ** the bitmask for all FROM clause terms to the left of the N-th term
104991 ** bitmask for all tables to the left of the join. Knowing the bitmask
104992 ** for all tables to the left of a left join is important. Ticket #3015.
104999 ** Note that bitmasks are created for all pTabList->nSrc tables in
105024 /* Analyze all of the subexpressions. Note that exprAnalyze() might
105076 ** next nested loop. The loop tests all FROM clause entries
105157 ** index if it uses any index at all */
105245 ** if it find an index at all. */
105273 /* Open all tables in the pTabList and any indices selected for
105470 /* Close all of the cursors that were opened by sqlite3WhereBegin.
105499 ** directly. This loop scans all that code looking for opcodes
105555 ** Disable all error recovery processing in the parser push-down
105672 /* Next is all token values, in a form suitable for use by makeheaders.
105676 ** These constants (all generated automatically by the parser generator)
105706 ** YYMINORTYPE is the data type used for all minor tokens.
105812 ** yy_action[] A single table containing all actions.
106444 /* For tracing shifts, the names of all terminals and nonterminals
106514 /* For tracing reduce actions, the names of all rules are required.
107023 ** Deallocate and destroy a parser. Destructors are all called for
107024 ** all stack elements before shutting the parser down.
108496 Token all;
108497 all.z = yymsp[-3].minor.yy0.z;
108498 all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
108499 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
109869 ** This means that a SQL string of all whitespace is invalid.
109871 ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
110325 ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
110449 /* Disable all mutexing */
110462 /* Enable all mutexing */
110722 ** Return true if the buffer z[0..n-1] contains all spaces.
110802 ** Close all open savepoints. This function only manipulates fields of the
110849 /* Force xDestroy calls on all virtual tables */
110963 ** Rollback all database files.
111228 ** operation to continue but invalidate all precompiled statements.
111585 ** to contains a zero-length string, all attached databases are
111606 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
112043 ** case we ignore all text in the remainder of the path, name or
112240 ** off all other flags.
112356 /* Register all built-in functions, but do not attempt to read the
112408 ** mode. Doing nothing at all also makes NORMAL the default.
112655 ** This is a convenience routine that makes sure that all thread-specific
112756 ** this has the effect of zeroing all output parameters.
113062 ** If parameter onoff is non-zero, configure the wrappers so that all
113133 ** Head of a linked list of all sqlite3 objects created by this process
113620 ** is encoded. The subtree at iBlockid will contain all terms less
113621 ** than the first term encoded (or all terms if no term is encoded).
113660 ** leaves_end_block, and end_block are all 0.
113670 ** incrementing idx. When idx reaches MERGE_COUNT (default 16), all
113676 ** A segment merge traverses all segments at a given level in
113680 ** After the merge, all segment blocks from the merged level are
113723 ** TODO(shess) Provide a VACUUM type operation to clear out all
113752 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all
114013 ** Macros for looping over all elements of a hash table. The idiom is
114076 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
114082 ** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
114083 ** level values between 0 and 1023 (inclusive) belong to index 0, all levels
114212 ** there is an entry in the aIndex[] array. Index 0 is an index of all the
114281 ** indicating that all columns should be searched,
114937 ** with all double quote characters escaped. For example:
115011 ** If argument zFunc is not NULL, then all but the first question mark
115152 int nString = 0; /* Bytes required to hold all column names */
115183 /* Loop through all of the arguments passed by the user to the FTS3/4
115184 ** module (i.e. all the column names and special arguments). This loop
115655 ** to the term from the interior node, then all terms on the sub-tree
115904 ** into *pp contains all positions of both *pp1 and *pp2 in sorted
116254 ** This function does an "OR" merge of two doclists (output contains all
116300 ** the input list). The same argument applies to all but the first docid
116301 ** read from the 'other' list. And to the contents of all position lists
116411 ** Merge all doclists in the TermSelect.aaOutput[] array into a single
116412 ** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
116424 /* Loop through the doclists in the aaOutput[] array. Merge them all
116465 ** a queried prefix. It merges all these doclists into one, the doclist
116674 ** if isPrefix is true, to scan the doclist for all terms for which
116751 int iColumn, /* Column to query (or -ve for all columns) */
116928 ** statement loops through all rows of the %_content table. For a
117189 ** function merges all segments in the database to a single segment.
117515 ** within the union of all segments of a b-tree. Hence the name.
117932 ** Otherwise, fts3EvalPhraseStart() is called on all phrases within the
117934 ** expressions for which all descendent tokens are deferred.
118056 ** data stored in all rows of each column of the table, from left
118139 /* Iterate through all tokens in this AND/NEAR cluster, in ascending order
118176 /* The number of overflow pages to load for this (and therefore all
118178 ** that will be loaded if all subsequent tokens are deferred.
118360 ** the db. In this case the position-list is not populated at all.
118496 ** phrase instances sufficiently close to their peers to satisfy all NEAR
118597 ** all phrases involved in the NEAR. This is because the snippet(),
118781 ** expression rooted at pExpr, the cursor iterates through all rows matched
118825 ** for all other phrases that are part of the NEAR expression.
118917 ** the FTS table (considering all rows), and
118930 ** * If a phrase consists entirely of deferred tokens, then all output
119027 ** Free all components of the Fts3Phrase structure that were allocated by
119113 ** This function does all the work for both the xConnect and xCreate methods.
119778 ** Fts3PhraseToken structures token buffers are all stored as a single
119790 ** Buffer zTemp: Contains copies of all tokens.
119962 /* Turns out that wasn't a keyword after all. This happens if the
120573 /* Remove all entries from a hash table. Reclaim all memory.
120578 Fts3HashElem *elem; /* For looping over all elements of the table */
121269 /* Do nothing. The work was all in the test */
121277 /* Do nothing. The work was all in the test */
121448 ** part of a token. In other words, delimiters all must have
122300 ** memory incrementally instead of all at once. This can be a big performance
122302 ** method before retrieving all query results (as may happen, for example,
122442 ** the tree is assembled in memory and written out only once all leaves have
122687 ** all rows in the %_segdir table, from oldest to newest. If successful,
122884 ** Tokenize the nul-terminated string zText and add all tokens to the
123089 ** Remove all data from the FTS3 table. Clear the hash table containing
123113 ** (an integer) of a row about to be deleted. Remove all terms from the
123191 ** full, merge all segments in level iLevel into a single iLevel+1
123517 ** normally all that is required to move pointer p to the desired
123601 ** Free all allocations associated with the iterator passed as the
123882 ** the array around until all entries are in sorted order.
124111 ** Write the buffer for the segment node pTree and all of its peers to the
124165 ** Free all memory allocations associated with the tree pTree.
124325 ** Flush all data associated with the SegmentWriter object pWriter to the
124326 ** database. This function must be called after all terms have been added
124362 ** Release all memory held by the SegmentWriter object passed as the
124431 ** 1) Deletes all %_segments entries for the segments associated with
124435 ** 2) deletes all %_segdir entries with level iLevel, or all %_segdir
124768 /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
124776 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
124910 ** Merge all level iLevel segments in the database into a single
124911 ** iLevel+1 segment. Or, if iLevel<0, merge all segments into a
124940 /* This call is to merge all segments in the database to a single
124955 /* This call is to merge all segments at level iLevel. find the next
125086 ** the column for all rows of the table.
125088 ** Varint 1+nCol: The total size, in bytes, of all text values in all
125089 ** columns of all rows of the table.
125206 ** Delete all cached deferred doclists. Deferred doclists are cached
125218 ** Free all entries in the pCsr->pDeffered list. Entries are added to
125233 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
125238 ** table, not for all rows.
125359 ** delete the contents of all three tables and throw away any
125507 ** merge all segments in the database (including the new segment, if
125690 ** Iterate through all phrase nodes in an FTS3 query, except those that
125697 ** all eligible phrase nodes.
125731 ** phrases in the expression (all phrases except those directly or
125733 ** pnToken is not NULL, then it is set to the number of tokens in all
125979 /* Loop through all candidate snippets. Store the best snippet in
126258 ** of the matchinfo array that are constant for all rows returned by the
126269 ** where X is the number of matches for phrase iPhrase is column iCol of all
126273 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
126403 ** finished iterating through all offsets for all columns.
126523 ** If bGlobal is true, then populate all fields of the matchinfo() output.
126720 ** size that contains at least one instance of all phrases in the query
126753 /* Loop through all columns of the table being considered for snippets.
126754 ** If the iCol argument to this function was negative, this means all
126776 /* If all query phrases seen by fts3BestSnippet() are present in at least
127091 ** same data-structure is used for all, but the algorithms for insert and
127230 ** Therefore all non-root nodes must contain at least 3 entries. Since
127417 ** Clear the content of node p (set all bytes to 0x00).
127541 ** of the r-tree structure. A height of zero means all data is stored on
128675 ** all ancestor elements.
128876 ** Arguments aIdx, aDistance and aSpare all point to arrays of size
128948 ** Arguments aIdx, aCell and aSpare all point to arrays of size
129212 ** all cells from node pLeft. Then zero the original node.
129256 ** In this case avoid the all to nodeWrite().
129328 ** still NULL, load all ancestor nodes of pLeaf into memory and populate
129329 ** the pLeaf->pParent chain all the way up to the root node.
130149 ** all nodes, a statement like:
130246 ** scalar user function. This C function is the callback used for all such
130400 ** 1. uPattern is an unescaped match-all character "%",