xref: /third_party/sqlite/src/sqlite3.c

84 ** This should be done first so that it can successfully prevent spurious
182 ** system #includes.  Hence, this block of code must be the very first
306 ** first in QNX.  Also, the _USE_32BIT_TIME_T macro must appear first for
944 ** first then the size of the file is extended, never the other
1058 ** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
1131 ** first then the size of the file is extended, never the other
1254 ** of 25 milliseconds before the first retry and with the delay increasing
1259 ** integers where the first integer is the new retry count and the second
1326 ** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element
1348 ** - an array of two (void *) values. The first (void *) actually points
1386 ** was first opened.
1886 ** the first time sqlite3_initialize() is invoked during the lifetime of
1887 ** the process, or if it is the first time sqlite3_initialize() is invoked
1892 ** A call to sqlite3_shutdown() is an "effective" call if it is the first
1976 ** The first argument to sqlite3_config() is an integer
1980 ** in the first argument.
1995 ** [database connection] (specified in the first argument).
2046 ** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
2087 ** can be passed as the first argument to the [sqlite3_config()] interface.
2227 ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
2232 ** The first pointer (the memory pointer) must be aligned to an 8-byte
2265 ** The first argument is the
2292 ** passed through as the first parameter to the application-defined logger
2294 ** the logger function is a copy of the first parameter to the corresponding
2339 ** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
2483 ** ^The first argument (the third parameter to [sqlite3_db_config()] is a
2485 ** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
2489 ** slots.  The size of the buffer in the first argument must be greater than
2506 ** The first argument is an integer which is 0 to disable FK enforcement,
2517 ** The first argument is an integer which is 0 to disable triggers,
2534 ** The first argument is an integer which is 0 to disable views,
2553 ** The first argument is an integer which is 0 to disable fts3_tokenizer() or
2568 ** When the first argument to this interface is 1, then only the C-API is
2569 ** enabled and the SQL function remains disabled.  If the first argument to
2571 ** If the first argument is -1, then no changes are made to state of either the
2594 ** override this behaviour. The first parameter passed to this operation
2611 ** The first argument to this setting is an integer which is 0 to disable
2622 ** behavior. The first parameter passed to this operation is an integer -
2669 ** The first argument to this setting is an integer which is 0 to disable
2893 ** by the first INSERT, UPDATE or DELETE statement within a trigger, it
3046 ** ^The first argument to the busy handler is a copy of the void* pointer which
3064 ** to promote to an exclusive lock.  The first process cannot proceed
3066 ** proceed because it is blocked by the first.  If both processes
3068 ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
3069 ** will induce the first process to release its read lock and allow
3130 ** There are (N+1)*M elements in the array.  The first M pointers point
3216 ** the first parameter. Note that the order of the
3217 ** first two parameters is reversed from snprintf().)^  This is an
3227 ** guarantees that the buffer is always zero-terminated.  ^The first
3378 ** [database connection], supplied in the first argument.
3400 ** ^The first parameter to the authorizer callback is a copy of the third
3550 ** SQL statement text as the statement first begins executing.
3581 ** the following constants.  ^The first argument to the trace callback
3595 ** first begins running and possibly at other times during the
3853 ** ^(On windows, the first component of an absolute path
3996 ** The first parameter to these interfaces (hereafter referred to
4036 ** the name of the first query parameter, 1 for the second parameter, and
4212 ** the time of the first error and the call to these interfaces.
4262 ** on a connection by connection basis.  The first parameter is the
4413 ** To execute an SQL statement, it must first be compiled into a byte-code
4427 ** The first argument, "db", is a [database connection] obtained from a
4438 ** first zero terminator. ^If nByte is positive, then it is the
4446 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
4447 ** past the end of the first SQL statement in zSql.  These routines only
4448 ** compile the first statement in zSql, so *pzTail is left pointing to
4492 ** a schema change, on the first [sqlite3_step()] call following any change
4730 ** is always first parameter to [application-defined SQL functions].
4762 ** ^The first argument to the sqlite3_bind_*() routines is always
4769 ** occurrences have the same index as the first occurrence.
4791 ** found in first character, which is removed, or in the absence of a BOM
4804 ** the number of bytes up to the first zero terminator.
4930 ** ^The first host parameter has an index of 1, not 0.
4996 ** UTF-16 string.  ^The first parameter is the [prepared statement]
5002 ** reprepared by the first call to [sqlite3_step()] for a particular run
5031 ** reprepared by the first call to [sqlite3_step()] for a particular run
5038 ** ^The first argument to these interfaces is a [prepared statement].
5071 ** ^(The first parameter is a [prepared statement].
5088 ** column (i==1), and a NULL pointer for the first result column (i==0).)^
5132 ** machine without first calling [sqlite3_reset()] to reset the virtual
5268 ** result row of a query.  ^In every case the first argument is a pointer
5288 ** The first six interfaces (_blob, _double, _int, _int64, _text, and _text16)
5299 ** of the first six interface should be used to extract the column value.
5419 ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
5534 ** ^The first parameter is the [database connection] to which the SQL
5981 ** ^The first time the sqlite3_aggregate_context(C,N) routine is called
5992 ** first time from within xFinal().)^
5995 ** when first called if N is less than or equal to zero or if a memory
5999 ** determined by the N parameter on first successful call.  Changing the
6009 ** The first parameter must be a copy of the
6010 ** [sqlite3_context | SQL function context] that is the first parameter
6161 ** message all text up through the first zero character.
6203 ** the string length itself by searching the 2nd parameter for the first
6238 ** first two bytes of input are skipped and the remaining input
6315 ** with the [database connection] specified as the first argument.
6339 ** through as the first argument to the collating function callback.
6354 ** if the first string is less than, equal to, or greater than the second,
6429 ** ^(When the callback is invoked, the first argument passed is a copy
6680 ** that was the first argument
6682 ** create the statement in the first place.
6807 ** then this interface returns a pointer to the first prepared statement
6836 ** the first call for each function on D.
6843 ** or rollback hook in the first place.
6938 ** with the [database connection] identified by the first argument
6946 ** ^The first argument to the callback is a copy of the third argument
6977 ** the first call on D.
7240 ** entry point name on its own.  It first tries "sqlite3_extension_init".
7243 ** characters in the filename from the last "/" to the first following
7466 ** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62),
7469 ** to the right of the first 63 is required, then bit 63 of colUsed is also
7640 ** by the first parameter.  ^The name of the module is given by the
7993 ** ^If the [BLOB handle] passed as the first argument was not opened for
8110 ** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
8377 ** purposes.  ^The first parameter is an operation code that determines
8395 ** as the first argument to [sqlite3_test_control()].
8624 ** highwater marks.  ^The first argument is an integer code for
8737 ** about a single [database connection].  ^The first argument is the
8898 ** a [prepared statement].  The first argument is the prepared statement
8954 ** The counter is incremented on the first [sqlite3_step()] call of each
9069 ** first parameter, szPage, is the size in bytes of the pages that must
9091 ** instance passed as the first argument. This is the value configured using
9325 ** ^The first call to sqlite3_backup_step() obtains an exclusive lock
9445 ** the first argument to register for a callback that will be invoked
9482 ** it an array of void* context pointers. The first argument passed to
9628 ** ^The first parameter passed to the callback function when it is invoked
9837 ** which is passed in as the first argument to the [xConnect] or [xCreate]
9979 ** The first argument must be the pointer to the [sqlite3_index_info] object
9980 ** that is the first parameter to the xBestIndex() method. The second argument
9985 ** The first parameter must be the same pointer that is passed into the
9986 ** xBestMethod() method.  The first parameter may not be a pointer to a
10185 ** routines return SQLITE_OK and set *P to point to the first or next value
10303 ** The select-id is the same value as is output in the first column
10412 ** the first parameter to callbacks.
10533 ** as it existed for the point in time when the transaction first started.
10574 **        file immediately after it is first opened. At least one transaction
10575 **        must be written to it first.
10900 ** A pointer to a structure of the following type is passed as the first
10931 ** Note that the first 5 fields of this structure are identical to
11076 **   the first table has been attached to the session object.
11139 ** to the session object passed as the first argument. All subsequent changes
11221 ** session object passed as the first argument. If successful,
11270 ** recorded once - the first time a row with said primary key is inserted,
11347 ** If it is not already attached to the session object passed as the first
11447 ** the session object passed as the first argument. Otherwise, if one or
11546 ** is not empty, the first call to this function advances the iterator to
11547 ** point to the first change in the changeset. Each subsequent call advances
11979 ** in the same order as for the very first changeset added to the changegroup.
11981 ** changes for tables that do not appear in the first changeset, they are
11983 ** which they are first encountered.
12015 ** passed as the sixth argument as the first. If the "filter callback"
12395 ** In order to rebase a local changeset, the remote changeset must first
12447 ** rebaser object passed as the first argument. If successful, (*ppOut)
12512 ** Each time the xInput callback is invoked by the sessions module, the first
12547 ** the application. The first parameter passed to each call is a copy of the
12655 ** The first argument to the sqlite3session_config() function must be one
12658 ** the effect of calling this function depends on the value of the first
12815 **   first token of the phrase. Returns SQLITE_OK if successful, or an error
13012 **   The first argument passed to this function is a copy of the (void*)
13033 **   by argument pText. pText may or may not be nul-terminated. The first
13062 **   be invoked. The first argument to it should be a copy of the pointer
13066 **   of the first byte of and first byte immediately following the text from
13087 **   user wishes to query for a phrase such as "first place". Using the
13088 **   built-in tokenizers, the FTS5 query 'first + place' will match instances
13089 **   of "first place" within the document set, but not alternative forms
13091 **   all instances of "first place" or "1st place" regardless of which form
13098 **            same token for inputs "first" and "1st". Say that token is in
13099 **            fact "first", so that when the user inserts the document "I won
13101 **            "first" and "place". If the user then queries for '1st + place',
13102 **            the tokenizer substitutes "first" for "1st" and the query works
13112 **     ... MATCH 'first place'</codeblock>
13114 **            the tokenizer offers both "1st" and "first" as synonyms for the
13115 **            first token in the MATCH query and FTS5 effectively runs a query
13119 **     ... MATCH '(first OR 1st) place'</codeblock>
13122 **            still appears to contain just two phrases - "(first OR 1st)"
13128 **            document such as "I won first place" is tokenized, entries are
13129 **            added to the FTS index for "i", "won", "first", "1st" and
13135 **            'first + place' or '1st + place', as there are entries in the
13136 **            FTS index corresponding to both forms of the first token.
13142 **   when parsing the document "I won first place", a tokenizer that supports
13148 **       xToken(pCtx, 0, "first",                  5,  6, 11);
13153 **   It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
13163 **   token "first" is substituted for "1st" by the tokenizer, then the query:
13169 **   will probably not map "1s" to any prefix of "first").
13172 **   because the index contains entries for both "first" and "1st", prefix
13179 **   token "1st", but not "first" (assuming the tokenizer is not able to
13181 **   will match against "1st" and "first". This method does not require
13779 ** or "ductile" rather than being "brittle" and crashing at the first
13918 ** Hash.first points to the head of this list.
13933   HashElem *first;          /* The first element of the array */
13936     HashElem *chain;           /* Pointer to first entry with this hash */
13972 #define sqliteHashFirst(H)  ((H)->first)
14462 ** In other words, S is a buffer and E is a pointer to the first byte after
15092 ** The default location of PENDING_BYTE is the first byte past the
15197 ** The type used to represent a page number.  The first page in a file
15591 **     The first argument is an Expr* (which is guaranteed to be constant for
16416 **                                     // taken on the first two ways.  The
16884 ** come off of pFree first, then pInit as a fallback.  This dual-list
16895 ** (1200-byte) slots.   Allocations are filled from the small-pool first,
16914                           ** the first byte of LOOKASIDE_SMALL buffers */
17442 **     the C functions xStep and xFinal. The first four parameters
17443 **     are interpreted in the same way as the first 4 parameters to
17448 **     the C functions xStep and xFinal. The first four parameters
17449 **     are interpreted in the same way as the first 4 parameters to
17515 ** sqlite3.pSavepoint. The first element in the list is the most recently
17658 ** for a numeric type is a single comparison.  And the BLOB type is first.
17728 ** the first argument.
17963 ** An instance of the following structure is passed as the first
18011 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
18013 ** find the first match.
18018 ** before the first match or immediately after the last match.  The
18054 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
18711 ** context is searched first.  If no match is found, the next outer
18803   int iIdxCur;              /* Index of the first index cursor */
18909 **                     Store the first column of the first result row
18922 **                     the table first.
18951 **                     table is an intkey table - in this case the first
19096 ** generate call themselves recursively, the first part of the structure
19181   ** first field in the recursive region.
19302 **    pNext member of struct Trigger. A pointer to the first element of the
19306 ** The "step_list" member points to the first element of a linked list
19340 ** associated struct Trigger instance. The first element of the linked list is
19341 ** the first step of the trigger-program.
19740   int iArgCol;            /* Offset of first argument for this function */
19772 ** Assuming zIn points to the first byte of a UTF-8 character,
19773 ** advance zIn to point to the first byte of the next UTF-8 character.
22518   ** initialized prior to first use. */
22767 ** instance of this structure is the first argument to the routines used
23876 ** In the first form, the +/-HH:MM is always optional.  The fractional
24205       ** is not the first modifier, or if the prior argument is not a numeric
24889 SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
25223 ** first VFS on the list.
26340 ** more blocks where each block is 8 bytes.  The first 8 bytes are
26344 ** free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
26357 ** the chunk.  In this way, the first chunk has an index of 1.
27013 **   3.  New memory is allocated from the first available free block.
28279 ** The first two constants cause sqlite3_mutex_alloc() to create
28767   /* The first to increment to 1 does actual initialization */
28789   /* The first to decrement to 0 does actual shutdown
28827 ** The first two constants cause sqlite3_mutex_alloc() to create
28960   ** first doing some #defines that prevent SQLite from building on Win98.
30007 ** most frequently used conversion types first.
30571         /* "0" digits after the decimal point but before the first
30869 ** The z string points to the first character of a token that is
30972 ** So enlarge if first, then do the append.
31224 ** Oops:  The first two arguments of sqlite3_snprintf() are backwards
32719   ** the first time this routine is called.
33110 ** This lookup table is used to help decode the first byte of
33187 **  *  Bytes in the range of 0x80 through 0xbf which occur as the first
33472 ** the first 0x00 byte. If nByte is not less than zero, return the
33473 ** number of unicode characters in the first nByte of pZ (or up to
33474 ** the first 0x00, whichever comes first).
33548 ** Return the number of bytes in the first nChar unicode characters
34813   ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
35222 ** The first integer is the number of integers allocated for the whole
35342   pNew->first = 0;
35356   elem = pH->first;
35357   pH->first = 0;
35406     else             { pH->first = pNew; }
35409     pNew->next = pH->first;
35410     if( pH->first ){ pH->first->prev = pNew; }
35412     pH->first = pNew;
35451   for(elem=pH->first, pH->first=0; elem; elem = next_elem){
35482     elem = pH->first;
35508     pH->first = elem->next;
35524     assert( pH->first==0 );
36022 ** by zClass and put the text data associated with that key in the first
36231 ** The first few characters of the text encoding will be a little-endian
36990   sqlite3_io_methods const *pMethod;  /* Always the first entry */
37444 ** Return the name of the first system call after zName.  If zName==NULL
37445 ** then return the name of the first system call.  Return NULL if zName
37546 ** OK to get the pLockMutex without holding unixBigLock first, but if
37863 ** second overrides the first, even though they were on different
37895 ** Any attempt to lock or unlock a file first checks the locking
37977 ** and pLockMutex are needed, then unixBigLock must be acquired first.
38033 ** The first argument passed to the macro should be the error code that
38213   ** an ASCII 'S' character which also happens to be the first byte
38216   ** the first page of the database, no damage is done.
38278 ** Return TRUE if pFile has been renamed or unlinked since it was first opened.
38422 ** the first time any lock is attempted.  All subsequent system locking
38500   ** SQLite was first developed, Windows95 systems were still very common,
38730 ** the byte range is divided into 2 parts and the first part is unlocked then
39617   unsigned long long offset;        /* offset to first byte to lock */
40242 ** Attempt to seek the file-descriptor passed as the first argument to
41214 #define UNIX_SHM_BASE   ((22+SQLITE_SHM_NLOCK)*4)         /* first lock byte */
41400   ** is the first to open it. In this case take an EXCLUSIVE lock on the
41424       /* The first connection to attach must truncate the -shm file.  We
42720 ** Initialize first two members of azTempDirs[] array.
42933     ** the '-' might be missing or the '-' might be the first character in
43011   ** a file-descriptor on the directory too. The first time unixSync()
43817 ** The conch file - to use a proxy file, sqlite must first "hold the conch"
43836 ** only taken when the first request to lock database file is made.
43843 ** to be created the first time they are used.
44003   /* 1. first try to open/create the file
45158 ** target system.  GetVersionEx was first deprecated in Win8.1.
45337   const sqlite3_io_methods *pMethod; /*** Must be first ***/
46296 ** Return the name of the first system call after zName.  If zName==NULL
46297 ** then return the name of the first system call.  Return NULL if zName
47152 ** The first argument passed to the macro should be the error code that
47185 ** antivirus software.  Also the initial delay before the first retry.
47368   /* Set a flag that indicates we're the first to create the memory so it
47660 ** Move the current position of the file handle passed as the first
48857 #define WIN_SHM_BASE   ((22+SQLITE_SHM_NLOCK)*4)        /* first lock byte */
48869   int ofst,             /* Offset to first byte to be locked/unlocked */
51314 ** using "file:/name?vfs=memdb".  The first character of the name must be
52401   /* we didn't find it in the hash.  h points to the first */
52638 **   PCache.pDirty points to the first (newest) element in the list and
52762   ** in step 3, and page might be written into the database without first
52787 ** argument determines what operation to do.  The 0x01 bit means first
52923 ** szExtra is some extra space allocated for each page.  The first
53606 ** sqlite3Malloc() call and that memory is used for the first N pages allocated.
53652   sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */
54067 ** as the first argument.
54512 **   4. If none of the first three conditions apply and the cache is marked
54864 ** The initial batch number is zero, so if the very first TEST contains
54874 ** of the first SMALLEST is O(NlogN).  Second and subsequent SMALLEST
55120 ** and return pointers to the first and last elements of the new list.
55229   /* Merge the forest into a single sorted list on first call */
55255 ** If this is the first test of a new batch and if there exist entries
55265   /* Sort entries into the forest on the first test of a new batch.
55549 **     first 100 bytes of the database file.
55690 **    is first opened on the database. In WRITER_LOCKED state, all locks
55714 **    * Nothing (not even the first header) has been written to the journal.
55719 **    first modified by the upper layer. In rollback mode the journal file
55725 **    * The journal file is open and the first header has been written
55738 **    * The journal file is open and the first header has been written
55823 **     of the first four states.
55932   Pgno iSubRec;                /* Index of first record in sub-journal */
55984 **   need only update the change-counter once, for the first transaction
55997 **   finalized by overwriting the first journal header with zeroes. If
56003 **   simply by overwriting the first journal-header with zeroes, as the
56069 **   write-transaction is first opened, and updated when VFS calls are made
56133   ** when the pager is first created or else only change when there is a
57089   /* Read in the first 8 bytes of the journal header. If they do not match
57104   /* Read the first three 32-bit fields of the journal header: The nRec
57409 ** The first argument is a pointer to the pager structure, the second
57470 ** the journal file or writing the very first journal-header of a
57494 **     The first 28 bytes of the journal file are zeroed. This invalidates
57495 **     the first journal header in the file, and hence the entire journal
57515 ** unlock operation fails as well, then the first error code related
57516 ** to the first error encountered (the journal finalization one) is
58275 ** When we speak of the journal header, we mean the first 7 items above.
58294 ** journal file then all pages up to the first corrupted page are rolled
58318   int needPagerReset;      /* True to reset page prior to first page rollback */
58401     /* If this is the first header read from the journal, truncate the
58435           ** first place so it is OK to simply abandon the rollback. */
58687 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
58906 ** rolled back the first time it is encountered in either journal.
58918   i64 iHdrOff;             /* End of first segment of main-journal records */
58970   ** the first journal header seen and continuing until the effective end
59383 ** Read the first N bytes from the beginning of the file into memory
59825         ** as a temporary buffer to inspect the first couple of bytes of
59846         ** full-synchronous mode, sync the journal first. This ensures that
59899 ** The argument is the first in a linked list of dirty pages connected
59948   /* Before the first write, give the VFS a hint of what the final
60100 ** soft memory limit. The first argument is a pointer to a Pager object
60104 ** is always associated with the Pager object passed as the first
60226 ** first 8 bytes of this space are zeroed but the remainder is uninitialized.
60511     ** opening the file until the first call to OsWrite().
60635 **   * The first byte of the journal file exists and is not 0x00.
60719             u8 first = 0;
60720             rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
60727             *pExists = (first!=0);
60916       ** occurring on the very first access to a file, in order to save a
60920       ** at offset 24 into the file.  The first 4 of these 16 bytes are
61019 ** first time a page is loaded into memory. If the page requested is
61050 ** to find a page in the in-memory cache first.  If the page is not already
61052 ** just returns 0.  This routine acquires a read-lock the first time it
61099     ** be initialized. But first some error checks:
61284 ** The btree layer always holds page1 open until the end, so these first
61387     /* Write the first journal header to the journal file and open
61667   ** of the first page of the sector pPg is located on.
61961 ** (delete, truncate or zero the first part of) the journal file (or
62489 ** (the first created). A value of (Pager.nSavepoint-1) means operate
62829 ** The page handle passed as the first argument refers to a dirty page
63151 ** If the pager passed as the first argument is open on a real database
63404 **    24: Checksum-1 (first part of checksum for first 24 bytes of header).
63405 **    28: Checksum-2 (second part of checksum for first 24 bytes of header).
63428 **        WAL header and the first 8 bytes and the content of all frames
63432 ** magic number in the first 4 bytes of the WAL is 0x377f0683 and it
63446 ** in reverse order (the largest fibonacci weight occurs on the first element
63450 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
63464 ** first checks the WAL to see if it contains page P.  If so, then the
63520 ** Each index block except for the first contains information on
63521 ** HASHTABLE_NPAGE frames. The first index block contains information on
63524 ** first index block are the same size as all other index blocks in the
63534 ** for the first index block) 32-bit page numbers. The first entry in the
63535 ** first index-block contains the database page number corresponding to the
63536 ** first frame in the WAL file. The first entry in the second index block
63548 ** starting with the last index block and moving toward the first, and
63550 ** beginning.  The first entry that equals P corresponds to the frame
63565 ** To look for page P in the hash table, first compute a hash iKey on
63572 ** reached) until an unused hash slot is found. Let the first unused slot
63584 ** first index block, looking for entries corresponding to page P.  On
63600 ** K>K0 but to the first reader, those entries will appear to be unused
63601 ** slots in the hash table and so the first reader will get an answer as
63603 ** in the first place - which is what reader one wants.  Meanwhile, the
63652 ** should be 120) is the location in the shm file for the first locking
63749 ** the writer will first "reset" the WAL back to the beginning and start
63845 ** big-endian format in the first 4 bytes of a WAL file.
63874   int szFirstBlock;          /* Size of first block written to WAL file */
63963 ** The block of page numbers associated with the first hash-table in a
64241   ** all prior frams, the first 16 bytes of this frame-header,
64289 ** through the unlocked state first.
64349   volatile u32 *aPgno;      /* aPgno[1] is the page of first frame indexed */
64350   u32 iZero;                /* One less than the frame number of first indexed*/
64360 ** number of the first frame indexed by this hash table. If a
64365 ** first frame indexed by the hash table, frame (pLoc->iZero).
64511     /* If this is the first entry to be added to this hash-table, zero the
64576 ** This routine first tries to establish an exclusive lock on the
65308   int lockIdx,                    /* Offset of first byte to lock */
65689   /* The first page of the wal-index must be mapped at this point. */
65699   ** When reading, read [0] first then [1].  Writes are in the reverse order.
65789   /* If the first page of the wal-index has been mapped, try to read the
65796   /* If the first attempt failed, it might have been due to a race
66099   ** After 5 RETRYs, we begin calling sqlite3OsSleep().  The first few
66256   ** since it was read, set Wal.minFrame to the first frame in the wal
66296 ** first frame for which the wal file content matches the db file.
66662   /* Cannot start a write transaction without first holding a read
66870 ** first write the part before iSyncPoint, then sync, then write the
66944   ** first checksum. If the first frame is frame 1 (implying that the current
67026   /* If this is the first frame written into the log, write the WAL
67161   /* If this frame set completes the first transaction in the WAL and
67613 ** The file is divided into pages.  The first page is called page 1,
67619 ** The first page is always a btree page.  The first 100 bytes of the first
67650 ** All of the integer values are big-endian (most significant byte first).
67696 **      1       2      byte offset to the first freeblock
67698 **      5       2      first byte of the cell content area
67708 ** The cell pointer array begins on the first byte after the page header.
67720 ** to the first freeblock is given in the header.  Freeblocks occur in
67739 ** the first byte with bit 8 clear.  The most significant byte of the integer
67740 ** appears first.  A variable-length integer may not be more than 9 bytes long.
67773 ** file header points to the first in a linked list of trunk page.  Each trunk
67820 ** first byte of on-disk image of every BTree page.
67833 ** instance of this object and zeros the first 8 bytes.  (This is the
67844   /* Only the first 8 bytes (above) are zeroed by pager.c when a new page
67853   u16 cellOffset;      /* Index in aData of first cell pointer */
68003   u8 max1bytePayload;   /* Maximum first byte of cell for a 1-byte payload */
68104 #define BTCURSOR_FIRST_UNINIT pBt   /* Name of first uninitialized field */
68173 ** database page. The first argument to each is the number of usable
68210 ** PTRMAP_OVERFLOW1: The database page is the first page in a list of
68269   Pgno v1;          /* Value for first %u substitution in zPfx */
68349 ** p, then first unlock all of the others on p->pNext, then wait
68400   /* To avoid deadlock, first release all locks with a larger
68787 ** caller should have first obtained a lock specifying the root page of
69130 ** Invalidate the overflow cache of the cursor passed as the first argument.
69394   BtCursor *p,         /* The first cursor that needs saving */
69638     /* The first byte of the extra data is the MemPage.isInit byte.
69710 ** Given a btree page and a cell index (0 means the first cell on
70037   ** integer. The following block moves pIter to point at the first byte
70308 ** as the first argument. Write into *pIdx the index into pPage->aData[]
70309 ** of the first byte of allocated space. Return either SQLITE_OK or
70315 ** the first two bytes past the cell pointer area since presumably this
70406 ** The first byte of the new free block is pPage->aData[iStart]
70515 ** Decode the flags byte (the first byte of the header) for a page
70633   ** start of the first freeblock on the page, or is zero if there are no
70641       ** always be at least one cell before the first freeblock.
70782   u16 first;
70793   first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8);
70797   pPage->nFree = (u16)(pBt->usableSize - first);
70799   pPage->cellOffset = first;
70801   pPage->aCellIdx = &data[first];
71411   ** first write cursor for the BtShared object */
71425   ** can mean that fillInCell() only initializes the first 2 or 3
71426   ** bytes of pTmpSpace, but that the first 4 bytes are copied from
71430   ** zero the first 4 bytes of temp space here.
71598 ** the first byte past the 1GB boundary, 0x40000000) needs to occur
71921       /* After reading the first page of the database assuming a page size
72017 ** this routine unrefs the first page of the database file which
72036 ** into a new empty database by initializing the first page of
72079 ** Initialize the first page of the database file (creating a database
72103 ** will work unless a transaction is started first:
72197     ** block for the WRITER lock first if possible. */
72356     /* The pointer is always the first 4 bytes of the page in this case.  */
72448   ** If pDbPage is an overflow page, then the first 4 bytes may store a
72562       ** is swapped with the first free page pulled off the free list.
72565       ** looping until a free-page located within the first nFin pages
72607 ** The database opened by the first argument is an auto-vacuum database
72760 ** This routine does the first phase of a two-phase commit.  This routine
72852 ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should
73642     ** in the overflow chain. The page number of the first overflow page is
73664       ** entry for the first required overflow page is valid, skip
73686         ** data is not required. So first try to lookup the overflow
73971 ** the cursor is set to point to the first cell located on the root
74065 ** The left-most leaf is the one with the smallest key - the first
74112 /* Move the cursor to the first entry in the table.  Return SQLITE_OK
74465   **    (2) If the cursor is on the last page of the table and the first
74538       ** stored entirely within the b-tree page by inspecting the first
74644 ** the first entry.  TRUE is also returned if the table is empty.
74777 **     SQLITE_DONE   the cursor is already on the first element of the table
74933     ** first free-list trunk page. iPrevTrunk is initially 1.
74947         /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page
74953         ** stores the page number of the first page of the freelist, or zero if
75016           ** pointers to free-list leaves. The first leaf becomes a trunk
75149       ** at the end of the file instead of one. The first allocated page
75250   ** possibilities. If the free-list is currently empty, or if the first
75253   ** first trunk page in the current free-list. This block tests if it
75310   ** the page being freed as a leaf page of the first trunk in the free-list.
75312   ** first trunk in the free-list is full. Either way, the page being freed
75313   ** will become the new first trunk page in the free-list.
75518   **   pPrior             Where to write the pgno of the first overflow page
75580       ** If this is the first overflow page, then write a partial entry
75693   Pgno iChild,      /* If non-zero, replace first 4 bytes with this value */
75755       ** reading the first 4 bytes */
75831 **       2.  The first divider cell from Parent
75845 **    ixNx[1] = Number of cells in Child-1 plus 1 for first divider.
75992 ** Argument pCellptr points to the first entry in the cell-pointer array
76014   int iFirst,                     /* Index of first cell to add */
76135   int iOld,                       /* Index of first cell currently on page */
76136   int iNew,                       /* Index of new first cell on page */
76327     ** To find the largest key value on pPage, first find the right-most
76328     ** cell on pPage. The first two fields of this cell are the
76331     ** The first of the while(...) loops below skips over the record-length
76464 ** side if the page is the first or last child of its parent. If the page
76614       ** This is safe because dropping a cell only overwrites the first
76615       ** four bytes of it, and this function does not need the first
76712     ** first.
76787   **   cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to
76871     int d;              /* Index of first cell to the left of right sibling */
77022   **      entry associated with the first page in the overflow chain, and
77347 ** first SQL table, violating invariants on the first insert.
77461           ** calling balance_nonroot() (balance_deeper() may be called first,
77482           ** comes first. */
77510   int iOffset,              /* Offset of first byte to write */
77563   /* Overwrite the local portion first */
78198   ** then the cursor still points to that page. In this case the first
78207   ** on the leaf node first. If the balance proceeds far enough up the
78709 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
78743     ** points to the first interior cell that it points to the parent of
78841 ** if this is the first reference to the page.
78897   Pgno iPage,           /* Page number for first page in the list */
78980 ** The upper 16 bits are the index of the first byte of a range and the
79155       keyCanBeEqual = 0;     /* Only the first key on the page may ==maxKey */
79214     ** is the offset of the first freeblock, or zero if there are no
79224       /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
79239     ** There is an implied first entry the covers the page header, the cell
79249     prev = contentOffset - 1;   /* Implied first min-heap entry */
79297 ** If the first entry in aRoot[] is 0, that indicates that the list of
79490 ** Run a checkpoint on the Btree passed as the first argument.
79528 ** The first time this is called on a shared-btree, nBytes bytes of memory
80041       ** and the pager code use this trick (clearing the first byte
80133     ** is the first call to backup_step() for the current backup operation),
81682 ** excluding the first zero character.  The n parameter must be
83173   int iSub;                  /* 0 = main program, 1 = first sub-program etc. */
83566 ** the Vdbe passed as the first argument. It is the callers responsibility
83590 ** pointer to the first operation inserted.
83593 ** so that the jump target is relative to the first operation inserted.
83599   int iLineno                  /* Source-file line number of first opcode */
83880   int iFirst,          /* Index of first register to be released */
83917 ** first null byte.  If n>0 then copy n+1 bytes of zP4.
84368       u32 n = ai[0];   /* The first element of an INTARRAY is always the
84769 ** When p->explain==1, first the main program is listed, then each of
84803     /* The first 8 memory cells are used for the result set.  So we will
84997 ** Prepare a virtual machine for execution for the first time after
85040   /* Each cursor uses a memory cell.  The first cursor (cursor 0) can
85086   ** passes.  On the first pass, we try to reuse unused memory at the
85494     ** If the error occurs during the first call to
85582 ** If the Vdbe passed as the first argument opened a statement-transaction,
85896 ** as the first argument to its database handle (so that they will be
86057 ** the first argument.
86067 **    * the corresponding bit in argument mask is clear (where the first
86565 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
86839 ** Compare two blobs.  Return negative, zero, or positive if the first
86873 ** number.  Return negative, zero, or positive if the first (i64) is less than,
86903 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
87002 ** The first argument passed to this function is a serial-type that
87052 ** determined that the first fields of the keys are equal.
87066   int bSkip                       /* If true, skip the first field */
87071   u32 idx1;                       /* Offset of first type in header */
87078   /* If bSkip is true, then the caller has already determined that the first
87283 ** that (a) the first field of pPKey2 is an integer, and (b) the
87365     /* The first fields of the two keys are equal. Compare the trailing
87369     /* The first fields of the two keys are equal and there are no trailing
87381 ** that (a) the first field of pPKey2 is a string, that (b) the first field
87463   ** limit the size of the header to 64 bytes in cases where the first field
87467   ** 13 fields or less. If the first field is an integer, the maximum legal
88831 ** Set the iterator value pVal to point to the first value in the set.
88851 ** the time returned is always the time of the first call.
88892 ** context is allocated on the first call.  Subsequent calls return the
89368   ** as if there had been a schema change, on the first sqlite3_step() call
89619 ** Transfer all bindings from the first statement over to the second.
89669 ** the first argument to the sqlite3_prepare() that was used to create
89670 ** the statement in the first place.
89702 ** with database connection pDb.  If pStmt is NULL, return the first
90100 ** bytes in this text up to but excluding the first character in
90976 ** Return the register of pOp->p2 after first preparing it to be
91332 ** to be not including the current Return.   P2 should be the first opcode
91582 ** into a String opcode before it is executed for the first time.  During
91658 ** the OP_Return will jump back to the first instruction after the OP_Gosub.
92656 ** The first integer in the P4 integer array is the length of the array
92892 ** Fall through to the next instruction the first time this opcode is
92896 ** Top-level programs determine first invocation by comparing the P1
93181   const u8 *zEndHdr; /* Pointer to first byte after the header */
93271       /* This is an optimization.  By skipping over the first few tests
93295   /* Make sure at least the first p2+1 entries of the header have been
94188       ** return an error indicating that the other VMs must complete first.
94469 ** The ReopenIdx opcode works like OP_OpenRead except that it first
94658   /* The sqlite3BtreeCursor() routine can only fail for the first cursor
94782 ** assume that a stable sort considering the first P3 fields of each
94871 ** (P4_INT64) in which the first 63 bits are one for each of the
94872 ** first 63 columns of the table or index that are actually used
94890 ** to an SQL index, then P3 is the first in an array of P4 registers
94917 ** to an SQL index, then P3 is the first in an array of P4 registers
94935 ** to an SQL index, then P3 is the first in an array of P4 registers
94953 ** to an SQL index, then P3 is the first in an array of P4 registers
95252   /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the
95253   ** OP_IdxGT that follows the OP_SeekGE. Otherwise, it points to the first
95412 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
95429 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
95447 ** Register P3 is the first of P4 registers that form an unpacked
95479 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
96160 ** the sorter cursor currently points to.  Only the first P4 fields
96488 ** will refer to the first entry in the database table or index.
96646 ** key of reg(P2).  In that case, P3 is the index of the first register
97407 ** Each set is identified by a unique P4 value. The first set
97455 ** P1 contains the address of the memory cell that contains the first memory
97585   ** try to reuse register values from the first use. */
97841 ** This opcode is initially coded as OP_AggStep0.  On first evaluation,
98395 ** can be used as the first argument to sqlite3_vtab_in_first() and
98752 ** function was determined to be constant at compile time. If the first
98771 ** function was determined to be constant at compile time. If the first
98932 ** Programs contain a single instance of this opcode as the very first
98942 ** first time they are evaluated for this run.
99812 **                                  first sorted element.
99902 ** First, T bytes of data from the first SORTER_MAX_MERGE_COUNT PMAs on
100019 ** The contents of aTree[] are updated first by comparing the new PmaReader
100494 ** leaves the PmaReader pointing to the first key in the PMA (or EOF if the
100530 ** determined that the first field of key1 is equal to the first field of
100576 ** the first field of each key is a TEXT value and that the collation
100619 ** the first field of each key is an INTEGER value.
100933   ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */
100988 ** the first argument.
101054 ** The first argument is a file-handle open on a temporary file. The file
101339   /* If the first temporary PMA file has not been opened, open it now. */
101406     /* Find the first two PmaReaders to compare. The one that was just
101489   ** round-robin between the first (pSorter->nTask-1) tasks. Except, if
101491   ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
101492   ** fall back to using the final sub-task. The first (pSorter->nTask-1)
101553   int t;                          /* serial type of first record field */
101874 ** function returns, the first key of merged data may be read from the
101882 ** its first key.
101934 ** The PmaReader passed as the first argument is guaranteed to be an
101942 ** the first key in its range.
101949 ** to its first key. A call to vdbePmaReaderNext() is still required to do
101962 ** the current PmaReader set to point to the first key in its range.
102014     ** first results are ready from this merger object anyway.
102044 ** If the PmaReader passed as the first argument is not an incremental-reader
102079 ** first PMA to read from pTask->file. Assuming no error occurs, it is
102494 ** passed as the first argument currently points to. For the purposes of
102569   sqlite3_vtab base;     /* Base class - must be first */
102578   sqlite3_vtab_cursor base;  /* Base class - must be first */
103184     ** atomic-write optimization. In this case the first 28 bytes of the
103860 ** in *ppList.  Create a new *ppList if this is the first term in the
104551     /* The special operator TK_ROW means use the rowid for the first
105101 ** At the first match, the ORDER BY expression is transformed into
105380   /* Normally sqlite3SelectExpand() will be called first and will have
105979 ** COLLATE operators take first precedence.  Left operands take
106356 ** sub-select returns more than one column, the first in an array
106379 ** case parameter regSelect should be the first in an array of registers
106537 ** first argument.
106956 ** as the previous instance of the same wildcard.  Or if this is the first
107115 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
107198 ** expression passed as the first argument. The second argument is a
107225 ** if any. Before returning, *pzBuffer is set to the first byte past the
108182 ** Walk the expression tree passed as the first argument. Return non-zero
108806 ** Load the Parse object passed as the first argument with an error
108851 ** constructed ephermeral table is returned.  The first time the ephemeral
109114   ** the first row into an array of registers and return the index of
109115   ** the first register.
109429   ** For a scalar LHS, it is sufficient to check just the first row
109439     ** FALSE if the first comparison is not NULL */
109691 ** the first register used to store the result.
109754       ** arguments past the first non-NULL argument.
109789       ** of the first argument.
109994           ** immediately prior to the first column.
110350       /* Possibly overload the function if the first argument is
110354       ** second argument, not the first, as the argument to test to
110587     ** The result of the expression is the Ri for the first matching Ei,
113278 ** Search the Parse object passed as the first argument for a RenameToken
113500 ** true, then zNew is always quoted first. If no error occurs, the result
114652 ** a string consisting of a list of integers.  The first integer in this
114656 ** value in the first column of the index.  The third integer is the average
114657 ** number of rows in the index that have the same value for the first two
114659 ** the index which have the same value for the first N-1 columns.  For
114702 ** sqlite_stat4 format will be described first.  Further information
114717 ** list of integers.  The first integer is the approximate number
114721 ** first two columns match the first two columns of the sample.
114723 ** number of entries that are strictly less than the sample.  The first
114727 ** where the first K columns are less than the first K columns of the
114745 ** all contain just a single integer which is the same as the first
115230   /* Zero the first nEqZero entries in the anEq[] array. */
115324     /* This is the first call to this function. Do initialization. */
115443     ** the index. The first integer in the list is the total number of
116065 ** The first argument points to a nul-terminated string containing a
116066 ** list of space separated integers. Read the first nOut of these into
117216 ** various fields of the database.  The first argument to the auth function
117806 ** first matching table is returned.  (No checking for duplicate table
117807 ** names is done.)  The search order is TEMP first, then MAIN, then any
117856     /* Match against TEMP first */
117992 ** table and the first matching index is returned.  (No checking
117994 ** TEMP first, then MAIN, then any auxiliary databases added
118562 ** find the (first) offset of that column in index pIdx.  Or return -1
118670 ** the first of several action routines that get called in response
118917 ** type on the first call to sqlite3TriggersExist().
118964 ** first to get things going.  Then this routine is called for each
119502 ** changes.  When a process first reads the schema it records the
119541 ** The first parameter is a pointer to an output buffer. The second
119546 ** to the first byte after the last byte written before returning.
119702 /* Return true if column number x is any of the first nCol entries of aiCol[].
119704 ** first nCol entries of an index.
119716 ** Return true if any of the first nKey entries of index pIdx exactly
119721 ** The first nKey entries of pIdx are guaranteed to be ordinary columns,
119752 ** columns that are within the first 63 columns of the table and a 1 for
120683 ** being moved.  So we cannot stop searching after the first match
120684 ** because the first match might be for one of the deleted indices
121975 ** first column of the index.  aiRowEst[2] is an estimate of the number
121976 ** of rows that match any particular combination of the first 2 columns
121997   /* Set the first entry (number of rows in the index) to the estimated
122229   int iStart         /* Index in pSrc->a[] of first new slot */
122403 ** if this is the first term of the FROM clause.  pTable and pDatabase
123255 ** array of three CollSeq structures. The first is the collation sequence
123425 ** is called to test how well the function passed as the first argument
123542 ** If nArg is -2, then the first valid function found is returned.  A
123988   int iIdxCur = 0;       /* Cursor number of the first index */
124623 ** Return a register number which is the first in a block of
124915 ** instr(haystack,needle) finds the first occurrence of needle
124920 ** the number of bytes in haystack prior to the first occurrence of needle,
125019 ** p1 is 1-indexed.  So substr(x,1,1) returns the first character
125064   ** as substr(X,1,N) - it returns the first N characters of X.  This
125371 ** Compare two UTF-8 strings for equality where the first string is
125390 ** in the list by making it the first character after '[' or '^'.  A
125450       /* At this point variable c contains the first character of the
125452       ** first matching character and recursively continue the match from
125577 ** the build-in LIKE operator.  The first argument to the function is the
125654 ** Implementation of the NULLIF(x,y) function.  The result is the first
125840 ** and hence the returned string literal is truncated prior to the first NUL.
125859 ** for the first character of the input string.
126306   /* p is always non-NULL because sumStep() will have been called first
126391   /* p is always non-NULL since countStep() will have been called first */
126716   ** the first three statements in the compareInfo structure.  The
127280 ** N is the number of columns in the parent key. The first element of the
127591 ** regBase is the first of an array of register that contains the data
127592 ** for pTab.  regBase itself holds the rowid.  regBase+1 holds the first
127731   ** The first form is used for rowid tables.  The second form is used
127974 ** Return true if the parser passed as the first argument is being
127997 ** first register in an array of (pTab->nCol+1) registers containing the
128003 ** first register of an array of (pTab->nCol+1) registers containing the new
128190         ** Note 2: At first glance it may seem like SQLite could simply omit
128677     /* The first time a column affinity string for a particular index is
128774 ** the first of a series of registers that will form the new record.
128882   int iRegStore,    /* Register holding the first column */
128895   /* Before computing generated columns, first go through and make sure
128927   ** this is a two-pass algorithm.  On the first pass, mark all generated
128991 ** first use of table pTab.  On 2nd and subsequent uses, the original
129201 ** first two forms shown above.  A VALUES clause is really just short-hand
129322   int regData;          /* register holding first column to insert */
130148 /* Return the first index on the list */
130181 ** The regNewData parameter is the first register in a range that contains
130183 ** pTab->nCol+1 registers in this range.  The first register (the one
130186 ** contain the content of the first table column.  The third register will
130214 ** register identified by aRegIdx[nIdx] - in other words in the first
130225 ** for the first index in the pTab->pIndex list.  Cursors for other indices
130424         ** first pass, recomputed values for all generated columns, as
130526       ** checked first and in order. */
130635         /* The first ON CONFLICT clause has a conflict target other than
130636         ** the IPK.  We have to jump ahead to that first ON CONFLICT clause
131151 ** The arguments to this routine should be the same as the first six
131227 ** ROWID table) is returned in *piDataCur.  The first index cursor is
131230 ** Use iBase as the first cursor (either the *piDataCur for rowid tables
131231 ** or the first index for WITHOUT ROWID tables) if it is non-negative.
131250   int *piIdxCur    /* Write the first index cursor number here */
131789 ** the xCallback() function is called.  pArg becomes the first
132749 ** Extensions that use newer APIs should first call the
133238   ** character in the filename after the last "/" upto the first ".",
133239   ** and eliding the first three characters if they are "lib".
134750   ** The first form reports the current persistent setting for the
134802   ** The first form reports the current setting for the
134829   ** The first form reports the current setting for the
134859   ** The first form reports the current setting for the
135084   ** The first form reports the current local setting for the
135108   ** The first form reports the current local setting for the
136311   ** In its first form, this pragma returns the encoding of the main
136532   ** Attempt to optimize the database.  All schemas are optimized in the first
136837   sqlite3_vtab base;        /* Base class.  Must be first */
136841   u8 iHidden;               /* Index of the first hidden column */
136844   sqlite3_vtab_cursor base; /* Base class.  Must be first */
136925 ** possible, and especially on the first hidden parameter.  So return a
137589   /* Do the main schema first */
137681 ** If the same database is attached more than once, the first
138117   /* This function currently works by first transforming the UTF-16
138286 ** If bFree==0, Leave the first Select object unfreed
138552 ** The first match found is returned.
138688 ** The left most table is the first entry in Select.pSrc.  The right-most
138953     int regPrevKey;   /* The first nOBSat columns of the previous row */
139077 **     The returned value in this case is the register number of the first
139193       ** bit on the first register of the previous value.  This will cause the
139194       ** OP_Ne added in codeDistinct() to always fail on the first iteration of
139195       ** the loop even if the first row is all NULLs.  */
139318   /* Usually, regResult is the first cell in an array of memory cells
139590         /* At first glance you would think we could optimize out the
139652     ** index with pSO->nExpr+2 columns.  Build a key using pSO for the first
140361       /* An AS clause always takes first priority */
140793 ** ORDER BY order and the first entry is extracted for each cycle.  Without
140799 ** with a positive value, then the first OFFSET outputs are discarded rather
141379           ** always safely abort as soon as the first unused slot is found */
141429 ** If regPrev>0 then it is the first register in a vector that
141469   /* Suppress the first OFFSET entries if there is an OFFSET clause
141619 ** subroutines first, then put the control logic at the bottom.  Like this:
142314 ** subquery first and store the results in a temporary table, then
142402 **        (17g) either the subquery is the first element of the outer
142458 **        is the first element of the parent query.  Two subcases:
143137 ** and '10.0' is not LIKE '10'.  But if we are not careful, the first WHERE
143320   /* Only the first term of a compound can have a WITH clause.  But make
143443 ** The select statement passed as the first argument is an aggregate query.
143721     **   (2)  This is the first term in the FROM clause of an UPDATE.
144110   ** The first loop just checks to see if there are any "*" operators
144344 ** Expanding a SELECT statement is the first step in processing a
144566         /* If this is the first row of the group (regAcc contains 0), clear the
144570         ** the first row (regAcc contains 1), set the magnet register so that
145790         ** each row into a sorting index, terminate the first loop,
145924       ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
146029         ** will contain 0 the first time the inner loop runs, and 1 thereafter.
146033         ** first row visited by the aggregate, so that they are updated at
146225   /* If this is the first row, then generate an extra row containing
147158         /* The first time a RETURNING trigger is seen, the "op" value tells
147320   int regIn            /* The first in an array of registers */
147703 ** The reg argument is the address of the first in an array of registers
147740   int reg,             /* The first in an array of registers (see above) */
147980 ** expression to be a TK_COLUMN reading column iCol of the first
148145   int iIdxCur;           /* Cursor for the first index */
149553     ** or INSERT.  Historically there have been attacks that first
150318 ** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
150353   ** The first invocation, to obtain permission to INSERT a row into the
150395   ** first time (in other words if the virtual table is actually being
150464 ** The parser calls this routine when it sees the first token
150474 ** The parser calls this routine for each token after the first token
150904 ** array. Return the error code for the first error that occurs, or
151049 ** The first parameter (pDef) is a function implementation.  The
151050 ** second parameter (pExpr) is the first argument to this function.
151435   Bitmask prereq;       /* Bitmask of other loops that must run first */
151760 ** first part does the start of the WHERE loop and the second
151762 ** this structure is returned by the first half and passed
151973   int iTerm,                  /* Zero-based index of first term. */
152205 ** Configure the VM passed as the first argument with an
152258 ** virtual terms are tested first.  For example:
152653 ** in consecutive registers and the index of the first register is returned.
152666 ** the index of the first memory cell in that range. The code that
152685 ** a key to search the index. Hence the first byte in the returned affinity
153111 ** code to write the first nReg elements of the vector into an array
153712     ** it is not. For an ASC sort, the non-NULL entries are scanned first.
153713     ** For DESC, NULL entries are scanned first.
153742       ** point to a valid row for the first iteration of this loop. */
154288           ** uses an index, and this is either the first OR-connected term
154914     /* Count the number of prefix characters prior to the first wildcard */
155096     /* We can also match against the first column of overloaded
155494           ** current term is from the first iteration.  So skip this term. */
155706   ** on the first element of the vector.  */
156045       u8 c, *pC;       /* Last character before the first wildcard */
156049         /* The point is to increment the last character before the first
156240 ** where-clause passed as the first argument. The value for the term
156969 ** first match.  Return NULL if there are no matches.
157221   int iRegister,      /* The first column is in this register */
157992   int i;                      /* Index of first sample >= pRec */
158007   /* Do a binary search to find the first sample greater than or equal
158010   ** than one fields, all fields following the first are ignored.
158045   ** sample 2 is the first sample of a block of N samples, so at first it
158134     /* At this point, the (iCol+1) field prefix of aSample[i] is the first
158799 ** Transfer content from the second pLoop into the first.
158965     ** case first.  Hence compatible candidate WhereLoops never have a larger
159112     /* We will be overwriting WhereLoop p[].  But before we do, first
159244 ** Term pTerm is a vector range comparison operation. The first comparison
159452         ** first such term in use, and sets nIn back to 0 if it is not. */
159960     ** fake index the first in a chain of Index objects with all of the real
160455   sqlite3_index_info *pIdxInfo,   /* Copy of first argument to xBestIndex */
161273 ** nOrderby columns and that the first nSorted columns are already in
161386     ** cost of sorting nRowEst rows of data where the first X terms of
161398   ** of computing an automatic index is not paid back within the first 28
162167 ** the first cursor in an array of cursors for all indices.  iIdxCur should
162224   ** only generate code for the first table in pTabList and assume that
162302     ** pTabList, not just the first nTabList tables.  nTabList is normally
164674 **   ordinary aggregate function does). This variable is set to the first
164766 ** the first register in an array of registers guaranteed to be large
165165 ** regOld and regNew are each the first register in an array of size
165589 **       if( first row of partition ){
165599 **         // rows. The first row in the partition, which all three cursors
165650 **       if( first row of partition ){
165678 **     if( first row of partition ){
165722 **     if( first row of partition ){
165756 **     if( first row of partition ){
165782 **         if( first row of partition ){
165807 **       if( first row of partition ){
165843 **       if( first row of partition ){
165873 **       if( first row of partition ){
166055   /* This block is run for the first row of each partition */
171383 ** The following code executes when a syntax error first occurs.
171432 ** The first argument is a pointer to a structure obtained from
171618       ** they intend to abandon the parse upon the first syntax error seen.
172439   switch( aiClass[*z] ){  /* Switch on the character-class of the first byte
173099 **   (6) SEMI      We've seen the first semicolon in the ";END;" that occurs at
173585 ** This routine is a no-op except on its very first call for the process,
173586 ** or for the first call after a call to sqlite3_shutdown.
173588 ** The first thread to call this routine runs the initialization to
173589 ** completion.  If subsequent threads call this routine before the first
173591 ** threads must block until the first thread finishes with the initialization.
173593 ** The first thread might call this routine recursively.  Recursive
173597 ** Let X be the first thread to enter this routine.  Let Y be some other
173994         /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
174024     /* Record a pointer to the logger function and its first argument.
175081 ** an integer number of milliseconds passed in as the first
176316 ** The first argument to this function is the name of the VFS to use (or
176902   ** database schema yet. This is delayed until the first time the database
177190 **       a low-level error is first detected.
177637     ** The first behavior (hard-coded to true) is the case if
177960 ** backwards for the first byte following four consecutive zero bytes.
177972 ** Append text z[] to the end of p[].  Return a pointer to the first
178766 ** A position is the index of a word within the document.  The first
178796 ** 2 for the first position.  Example:
178801 ** The 123 value is the first docid.  For column zero in this document
178826 ** varint nTerm;               (length of first term)
178827 ** char pTerm[nTerm];          (content of first term)
178874 **   varint nTerm;           (length of first term)
178875 **   char pTerm[nTerm];      (content of first term)
178888 ** subtree blocks are contiguous, so only the first subtree's blockid
178890 ** than the first term encoded (or all terms if no term is encoded).
178923 **   start_block         - first leaf node
179156   ** *piEndOffset. *piStartOffset should be set to the index of the first
179158   ** to the index of the first byte just past the end of the token in
179242   Fts3HashElem *first;    /* The first element of the array */
179246     Fts3HashElem *chain;     /* Pointer to first entry with this hash */
179307 #define fts3HashFirst(H)  ((H)->first)
179752 ** Candidate values for Fts3Query.eType. Note that the order of the first
180113     /* If the first byte was a '[', then the close-quote character is a ']' */
180131 ** to the first byte past the end of the varint.  Add the value of the varint
180141 ** When this function is called, *pp points to the first byte following a
180146 ** Argument pStart points to the first byte of the doclist that the
180157   /* Pointer p now points at the first byte past the varint we are
180267 ** passed as the first argument. This is done as part of the xConnect()
180514 ** function named zFunc first. For example, if zFunc is "unzip" and the
180570 ** If argument zFunc is not NULL, then all but the first question mark
181301     ** If there is more than one MATCH constraint available, use the first
181541   int isFirstTerm = 1;            /* True when processing first term on page */
181721 ** first byte after the position-list.
181726 ** the doclist, or to the first byte past the end of the doclist.
181729 ** to *pp. *pp is set to point to the first byte past the last byte copied
181741   ** The following while-loop moves pEnd to point to the first byte that is not
181775 ** to *pp. *pp is set to point to the first byte past the last byte copied
181820 ** the previous position, or zero if we are reading the first position
182185   int *pbFirst,                   /* IN/OUT: True after first int written */
182253   ** then the first docid in each list is simply encoded as a varint. For
182258   ** The first docid written to the output is therefore encoded using the
182264   ** the input list). The same argument applies to all but the first docid
182268   ** However, if the first docid copied to the output is a negative number,
182269   ** then the encoding of the first docid from the 'other' input list may
182497 ** as the first argument. The merge is an "OR" merge (see function
182516     /* If this is the first term selected, copy the doclist to the output
182526     ** may be smaller than (-1), as in the first example the -1 may be stored
183279 ** moves *ppPoslist so that it instead points to the first byte of the
183302   ** is the first in the doclist. In this case do not skip forward 2 bytes.
183304   ** is required for cases where the first byte of a doclist and the
183305   ** doclist is empty. For example, if the first docid is 10, a doclist
183336     char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc);
184071   ** MAX_INCR_PHRASE_TOKENS or fewer tokens, none of which are are "^first"
184570 ** The average document size in pages is calculated by first calculating
184585     ** The first varint is the number of documents currently stored in
184684   **      first iteration of this loop), or
185328 ** fts3EvalNext() visits the first row. Do not allow incremental
186615   ** The first pass, in the block below, uses a tokenizer cursor to iterate
186839   ** first implemented. Whichever it was, this module duplicates the
187331 ** The first parameter, pTokenizer, is passed the fts3 tokenizer module to
187433 ** expression passed as the first argument. The buffer is obtained from
187490 ** The first argument, <tokenizer>, is the name of the fts3 tokenizer used
187679   pNew->first = 0;
187693   elem = pH->first;
187694   pH->first = 0;
187792     else             { pH->first = pNew; }
187795     pNew->next = pH->first;
187796     if( pH->first ){ pH->first->prev = pNew; }
187798     pH->first = pNew;
187823   for(elem=pH->first, pH->first=0; elem; elem = next_elem){
187872     pH->first = elem->next;
187891     assert( pH->first==0 );
188138 ** isConsonant() and isVowel() determine if their first character in
188180 ** of m for the first i bytes of a word.
188236 ** the first two characters of z[].
188248 ** first three letters and the first one cannot be in [wxy].
188915 ** added to the returned list. The first is the token position, the
189582 **   argv[3]: first argument (tokenizer name)
190029   sqlite3_int64 iStartBlock;      /* Rowid of first leaf block to traverse */
190402 ** writing data to the fts3 table. If this lock is not acquired first, then
190444 ** for language-id 0 is allocate values 0-1023. The first prefix index
190947 ** The first element in the apVal[] array is assumed to contain the docid
191195 ** Move the iterator passed as the first argument to the next term in the
191325 ** Set the SegReader to point to the first docid in the doclist associated
191355 ** *ppOffsetList is set to point to the first column-offset list
191393     /* Pointer p currently points at the first byte of an offset list. The
191401       ** incrementally and pointer "p" now points to the first byte past
191746 ** Compare the term that the Fts3SegReader object passed as the first argument
191942         /* An unusual case: this is the first term to be added to the node
191957         /* There is no prefix-length field for first term in a node */
191988   ** If this is the first node in the tree, the term is added to it.
192056   sqlite3_int64 iLeaf,            /* Block id of first leaf node */
192115 ** *ppWriter. When adding the first term to a segment, *ppWriter should
192306 ** first argument.
192318 ** The first value in the apVal[] array is assumed to contain an integer.
192709   /* Advance each of the segments to point to the first docid. */
192793     /* Advance the first pCsr->nAdvance entries in the apSegment[] array
192819     ** Similarly, if this is a search for an exact match, and the first term
192859       /* The current term of the first nMerge entries in the array
192963 ** statement passed as the first argument.
192967 ** by one or more space (0x20) characters. In the first case, set *piEndBlock
192969 ** set *piEndBlock to the first value and *pnByte to the second.
193603   sqlite3_int64 iStart;           /* Block number of first allocated block */
193653 ** Attempt to advance the node-reader object passed as the first argument to
193663   int bFirst = (p->term.n==0);    /* True for first term on the node */
193713 ** point to the first entry on the node (if any). Otherwise, an SQLite
193736 ** than or equal to the first key that will be written to the next leaf
193834 ** If the size of the value in blob pPrev is zero, then this is the first
193855   int bFirst = (pPrev->n==0);     /* True if this is the first term written */
194130 **   * The first key read from the input (arguments zKey and nKey) is
194323 ** array of leaf nodes starts at the first block allocated. The array
194341   sqlite3_stmt *pFirstBlock = 0;  /* SQL used to determine first block */
194355   /* Calculate the first block to use in the output segment */
194487 ** The first two arguments are a pointer to and the size of a segment b-tree
194597   /* Variable iNewStart now contains the first valid leaf node. */
194970 ** its value.  Advance *pz to point to the first character past
195002   /* Read the first integer value */
195005   /* If the first integer value is followed by a ',',  read the second
195266 **     + The index number (0 for the main index, 1 for the first prefix
195786   int iPos;                       /* Index of first token in snippet */
196049 ** Advance the position list iterator specified by the first two
196050 ** arguments so that it points to the first element with a value greater
196079     /* The SnippetIter object has just been initialized. The first snippet
196085     /* Advance the 'head' iterator of each phrase to the first offset that
196213 **   (b) +1000 points for the first occurrence of each matchable phrase in
196300 ** Append a string to the string-buffer passed as the first argument.
196348 ** are to the left of the first highlighted term. For example, to this:
196369     int nLeft;                    /* Tokens to the left of first highlight */
196471     ** is initialized to zero before the first (*but not necessarily
196501       ** required. They are required if (a) this is not the first fragment,
196541 ** beginning of the first varint in the column-list (the varint that
196542 ** contains the position of the first matching term in the column data).
196543 ** Before returning, *ppCollist is set to point to the first byte after
196839 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
196843 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
197081   /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the
197156   ** the data in the current row. The first iteration of the for(...) loop
197893   ** The most significant 22 bits in each 32-bit value contain the first
199003 ** index of the first character past the end of the value parsed.
199006 ** first non-whitespace character is '}' and return -3 if the first
199249 ** Obtain a complete parse of the JSON found in the first argument
200255 ** It works by removing the first element of the group by searching forward
200256 ** to the first comma (",") that is not within a string and deleting all
200368   sqlite3_vtab_cursor base;  /* Base class - must be first */
200370   u32 iBegin;                /* The first node of the scan */
200988 **   1. If the node is the root node (node 1), then the first 2 bytes
200990 **      For non-root nodes, the first 2 bytes are left unused.
201092   sqlite3_vtab base;          /* Base class.  Must be first */
201185   RtreeDValue rScore;    /* The score for this node.  Smallest goes first. */
201216 ** Number of entries in the cursor RtreeNode cache.  The first entry is
201218 ** entries cache the RtreeNode for the first elements of the priority queue.
201226   sqlite3_vtab_cursor base;         /* Base class.  Must be first */
202337 ** Compare two search points.  Return negative, zero, or positive if the first
202340 ** The rScore is the primary key.  Smaller rScore values come first.
202342 ** iLevel values coming first.  In this way, if rScore is the same for all
202344 ** is a depth-first search, which is the desired default behavior.
202745 ** first argument to this function is the right-hand operand to the MATCH
202910 ** constraint used. The first two bytes of idxStr correspond to
202914 ** The first of each pair of bytes in idxStr identifies the constraint
203338 ** minimum value of dimension iDim is considered first, the
204192   ** In the first case, if the conflict-handling mode is REPLACE, then
204202     /* Populate the cell.aCoord[] array. The first coordinate is aData[3].
204969 ** in the RtreeCheck object indicated by the first argument. NULL is
205184 ** by the first argument.
205445 ** the last vertex back to the first.  (This differs from the GeoJSON
205446 ** standard in which the final vertex is a repeat of the first.)
205466   GeoCoord a[8];        /* 2*nVertex values. X (longitude) first, then Y */
206921 **     argv[3] = first application-defined column....
206928 **     argv[3] = new value for first application-defined column....
207403 ** The scalar function context passed as the first argument is
207435 ** This lookup table is used to help decode the first byte of
207467 ** Compare two UTF-8 strings for equality where the first string is
207548 ** the build-in LIKE operator.  The first argument to the function is the
207609 ** two arguments. The first is a regular expression pattern to compile
208587 ** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
208624 ** the RBU handle passed as the first argument. The new limit is specified
208649 ** The first argument passed to this function must be a valid, open, RBU
208820 ** first argument passed to the xRename() callback is a copy of the second
209184 **   first pass of each source table. The updated nPhaseOneStep value is
209292 ** finished, leave *pz pointing to the first character past the end of
209481 ** arguments must be passed to this function. The first is the blob to
209553 ** Reset the SQL statement passed as the first argument. Return a copy
209670 ** left in the RBU handle passed as the first argument. A copy of the
209734 ** accepts one or two arguments. The first argument is the name of a table -
209750 ** For an rbu vacuum handle, a copy of the first argument is returned if
209785 ** pointing to the first entry. Otherwise, an error code and message is
209786 ** left in the RBU handle passed as the first argument. A copy of the
209817 ** an error code is stored in the RBU handle passed as the first argument.
209871 ** error code in the rbu handle passed as the first argument. Or, if an
209894 ** error code in the RBU handle passed as the first argument.
209912 ** The first argument must be a nul-terminated string. This function
210704 ** string, an error code is left in the rbu handle passed as the first
210758 ** string, an error code is left in the rbu handle passed as the first
210907 ** in the sqlite3rbu object indicated by the first argument and returns
211781 ** The checksum is store in the first page of xShmMap memory as an 8-byte
212326 ** are determined by inspecting the rbu handle passed as the first argument.
212384 ** where $val is the value returned by the first PRAGMA invocation.
212604 ** rbu handle passed as the first argument.
212813       /* If the first attempt to open the database file fails and the bRetry
212877         /* Point the object iterator at the first object */
213238 ** 1. Whenever the first page of a main database file is read or
213467       /* If this is being called to read the first page of the target
213469       ** contents of the first page if it does not yet exist. Otherwise,
213483           rbuPutU32(&aBuf[32], 0);          /* first page on free list trunk */
213958   **      in wal mode, even if the first page of the database file has
215129   sqlite3_vtab_cursor base;       /* Base class.  Must be first */
215139   sqlite3_vtab base;              /* Base class.  Must be first */
215793 ** In a rebase blob, the first field is set to SQLITE_INSERT if the change
215994 ** hash-key value passed as the first. Return the new hash-key value.
216003 ** the hash-key value passed as the first. Return the new hash-key value.
216013 ** hash-key value passed as the first. Return the new hash-key value.
216289   u8 *aOldRecord1,                /* old.* record for first change */
216291   u8 *aNewRecord1,                /* new.* record for first change */
216307     /* Write the old.* vector first. */
216383       ** within sessionPreupdateHash(). The first two asserts below verify
216630 ** write to table pTab, part of session pSession. If this is the first
216810 ** (UPDATE, INSERT, DELETE) is specified by the first argument.
217382 ** Free the list of table objects passed as the first argument. The contents
217549 ** as the first.
217845 ** Append a DELETE change to the buffer passed as the first argument. Use
217955 ** to the SELECT statement passed as the first argument. The SELECT statement
218048 ** passed as the first argument.
218179 ** session object passed as the first argument.
218225 ** session object passed as the first argument.
218240 ** Enable or disable the session object passed as the first argument.
218254 ** Enable or disable the session object passed as the first argument.
218292 ** Configure the session object passed as the first argument.
218476 ** first argument to a copy of the string or blob held in the aData[]
218636 ** The input pointer currently points to the first byte of the first field
218788     /* The first record in the changeset is not a table header. Must be a
219894 ** Attempt to apply the change that the iterator passed as the first argument
220041 ** Attempt to apply the change that the iterator passed as the first argument
220660 ** the first argument to the changegroup hash tables.
220769 ** added to the changegroup object passed as the first argument.
221093 ** object passed as the first argument. If no error occurs and argument xOutput
221476 **   first token of the phrase. Returns SQLITE_OK if successful, or an error
221673 **   The first argument passed to this function is a copy of the (void*)
221694 **   by argument pText. pText may or may not be nul-terminated. The first
221723 **   be invoked. The first argument to it should be a copy of the pointer
221727 **   of the first byte of and first byte immediately following the text from
221748 **   user wishes to query for a phrase such as "first place". Using the
221749 **   built-in tokenizers, the FTS5 query 'first + place' will match instances
221750 **   of "first place" within the document set, but not alternative forms
221752 **   all instances of "first place" or "1st place" regardless of which form
221759 **            same token for inputs "first" and "1st". Say that token is in
221760 **            fact "first", so that when the user inserts the document "I won
221762 **            "first" and "place". If the user then queries for '1st + place',
221763 **            the tokenizer substitutes "first" for "1st" and the query works
221773 **     ... MATCH 'first place'</codeblock>
221775 **            the tokenizer offers both "1st" and "first" as synonyms for the
221776 **            first token in the MATCH query and FTS5 effectively runs a query
221780 **     ... MATCH '(first OR 1st) place'</codeblock>
221783 **            still appears to contain just two phrases - "(first OR 1st)"
221789 **            document such as "I won first place" is tokenized, entries are
221790 **            added to the FTS index for "i", "won", "first", "1st" and
221796 **            'first + place' or '1st + place', as there are entries in the
221797 **            FTS index corresponding to both forms of the first token.
221803 **   when parsing the document "I won first place", a tokenizer that supports
221809 **       xToken(pCtx, 0, "first",                  5,  6, 11);
221814 **   It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
221824 **   token "first" is substituted for "1st" by the tokenizer, then the query:
221830 **   will probably not map "1s" to any prefix of "first").
221833 **   because the index contains entries for both "first" and "1st", prefix
221840 **   token "1st", but not "first" (assuming the tokenizer is not able to
221842 **   will match against "1st" and "first". This method does not require
223991 ** The following code executes when a syntax error first occurs.
224038 ** The first argument is a pointer to a structure obtained from
224224       ** they intend to abandon the parse upon the first syntax error seen.
224410 ** negative, everything up until the first '\0' is appended to the output.
224539   int *aFirst;                    /* Array of first token in each sentence */
224564 ** function. Its job is to identify tokens that are the first in a sentence.
224784     /* Advance iterator ctx.iter so that it points to the first coalesced
224812 ** The first time the bm25() function is called for a query, an instance
225444 ** string. Return a pointer to the first character following *pIn in
225457 ** string. Return a pointer to the first character following *pIn in
225537 ** The first character of the string pointed to by argument z is guaranteed
225810 ** Gobble up the first bareword or quoted word from the input buffer zIn.
226110 **     int iPos            // Position of token in input (first token is 0)
226136 ** Argument pIn points to the first character in what is expected to be
226464   u8 bFirst;                      /* True if token must be first in column */
226467   Fts5ExprTerm *pSynonym;         /* Pointer to first in list of synonyms */
226522 ** Read the first token from the nul-terminated string at *pz.
227034 ** The near-set object passed as the first argument contains more than
227465 ** Advance the first term iterator in the first phrase of pNear. Set output
227794 ** Set node pNode, which is part of expression pExpr, to point to the first
227846 ** the MATCH expression passed as the first argument. If the "bDesc"
227850 ** If iterating in ascending rowid order (bDesc==0), the first document
227853 ** then the first document visited must have a rowid smaller than or
227943 ** Set the "bFirst" flag on the first token of the phrase passed as the
229236 ** passed as the first argument. Argument bLive is true if the expression
229497 **   Offset of last rowid written to data area. Relative to first byte of
229743     /* Add the first rowid field to the hash-entry */
229836 ** single list and returns a pointer to its first element.
230041 **     records that contain a copy of the first rowid on each page spanned by
230095 **         + first leaf page number (often 1, always greater than 0)
230101 **   The first value is the number of rows in the index. Then, for each column
230110 **     general format of term/doclist, starting with the first term
230113 **         varint : size of first term
230114 **         blob:    first term data
230115 **         doclist: first doclist
230125 **         varint:  first rowid
230126 **         poslist: first poslist
230145 **         varint: first offset + 2
230155 **       * The byte offset of the first rowid on the page, if it exists
230156 **         and occurs before the first term (otherwise 0).
230165 **     other words, the first varint in the footer is the byte offset of
230166 **     the first term, the second is the byte offset of the second less that
230167 **     of the first, and so on.
230173 **       + if the first rowid on a page occurs before the first term, it
230176 **             varint:  first rowid
230178 **       + the first term on each page is stored in the same way as the
230179 **         very first term of the segment:
230181 **             varint : size of first term
230182 **             blob:    first term data
230206 **     * Page number of first child page. As a varint.
230208 **     * Copy of first rowid on page indicated by previous field. As a varint.
230210 **     * A list of delta-encoded varints - the first rowid on each subsequent
230366   u8 bFirstRowidInDoclist;        /* True if next rowid is first in doclist */
230367   u8 bFirstRowidInPage;           /* True if next rowid is first in page */
230369   u8 bFirstTermInPage;            /* True if next term will be first in leaf */
230398 **   Byte offset within the current leaf that is the first byte of the
230445   ** is the offset of the first rowid in the current doclist.  */
230573 ** the Fts5Index handle passed as the first argument.
231395 ** The iterator passed as the first argument has the following fields set
231397 ** points to the first rowid in the doclist-index.
231454     /* Currently iOff points to the first byte of a varint. This block
231455     ** decrements iOff until it points to the first byte of the previous
231636 ** Fts5SegIter.iLeafOffset currently points to the first byte of a
231643 ** Leave Fts5SegIter.iLeafOffset pointing to the first byte of the
231694 ** Fts5SegIter.iLeafOffset currently points to the first byte of the
231697 ** the first term in the segment).
231705 ** the first position list. The position list belonging to document
231753 ** segment pSeg. The iterator is left pointing to the first entry when
231799 ** the position-list size field for the first relevant rowid on the page.
231805 ** is in its regular state - Fts5SegIter.iLeafOffset points to the first
231875       ** thing on the page - i.e. the first rowid is on the following page.
232160 ** Iterator pIter currently points to the first rowid in a doclist. This
232176     /* Currently, Fts5SegIter.iLeafOffset points to the first byte of
232218   ** field associated with the first relevant rowid on the page.
232222   ** first rowid on this page.
232248 ** Iterator pIter currently points to the first rowid of a doclist.
232729 ** Move the seg-iter so that it points to the first rowid on page iLeafPgno.
233081     /* Search through to find the first varint with value 1. This is the
233445 ** is zero or greater, data from the first nSegment segments on level iLevel
233448 ** The iterator initially points to the first term/rowid entry in the
233521   ** to the first entry in its segment. In this case initialize the
233806 ** Fts5SegWriter.btterm currently contains the first term on page iBtPage.
233829 ** This is called once for each leaf page except the first that contains
233832 ** smaller than the first term on the new leaf.
233880 ** first on the page. This function appends an appropriate entry to the current
233897       ** a copy of iRowid (which will become the first rowid on the next
233900       ** also push its first rowid upwards. */
233911         /* This was the root node. Push its first rowid up to the new root. */
234025       /* This is the first term on a leaf that is not the leftmost leaf in
234034       ** is if this is the first term written in an incremental-merge step.
234082     /* If this is to be the first rowid written to the page, set the
234224       ** Set both the first and last page-numbers to 0 to indicate that the
234229       int iOff = pSeg->iTermLeafOffset;     /* Offset on new first leaf page */
234640             fts5PutU16(&pBuf->p[0], (u16)pBuf->n);   /* first rowid on page */
234757   ** In the first case, return NULL. In the second, increment the ref-count
235095   ** first rowid in one input is a large negative number, and the first in
236128       int iOff;                   /* Offset of first term on leaf */
236129       int iRowidOff;              /* Offset of first rowid on leaf */
236266   ** Two versions of the same checksum are calculated. The first (stack
236608     /* Decode any entries that occur before the first term. */
236687     ** first term. */
236696       int bFirst = (iPgidxOff==szLeaf);     /* True for first term on page */
236780         "first arg to fts5_rowid() must be 'segment'" , -1
236992 **   is the upper limit (i.e. the "first" rowid visited) and iLastRowid
237683 ** If the REQUIRE_RESEEK flag is set on the cursor passed as the first
238527         /* If this is a REPLACE, first remove the current entry (if any) */
239237 ** The first varint (if it exists) contains the size of the position list
239320     ** useful in that it may be passed as the first argument to an FTS5
241352 ** passed as the first argument, codepoint iCode is considered a token
243189   ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
244310   sqlite3_vtab base;  /* Base class - must be first */
244320   sqlite3_vtab_cursor base;  /* Base class - must be first */
244467 ** to the first row of output.  This method is always called at least
244959 CODEC_STATIC int sqlite3CodecKeyCtxCmp(KeyContext *first, KeyContext *second){
244960   if(memcmp((unsigned char *)first, (unsigned char *)second, sizeof(CodecConstant))){
244963   if(first->iter != second->iter){
244966   if(first->passwordSize != second->passwordSize){
244969   if((first->password != second->password) && memcmp(first->password, second->password, first->passwordSize)){

Indexes created Thu Nov 07 10:32:03 CST 2024