Lines Matching refs:next
1402 ** be advantageous to block on the next WAL lock if the lock is not immediately
1420 ** atomically at the next [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. Systems
1767 ** next. Applications that use these interfaces must be prepared for any
1769 ** from one release to the next. Applications must not attempt to access
2043 ** allocators round up memory allocations at least to the next multiple
2493 ** rounded down to the next smaller multiple of 8. ^(The lookaside memory
5003 ** or until the next call to
5013 ** one release of SQLite to the next.
5138 ** sqlite3_step() is called again to retrieve the next row of data.
5858 ** occurs is undefined and may change from one release of SQLite to the next.
6795 ** to SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].</dd>
6802 ** CAPI3REF: Find the next prepared statement
6805 ** ^This interface returns a pointer to the next [prepared statement] after
7188 ** declaration type and collation sequence is valid until the next
8293 ** next. Applications that override the built-in mutex logic must be
8387 ** operate consistently from one release to the next.
9336 ** restarted by the next call to sqlite3_backup_step(). ^If the source
9376 ** and sqlite3_backup_remaining() until after the next
9742 ** that the next writer will restart the log file from the beginning.
10185 ** routines return SQLITE_OK and set *P to point to the first or next value
10192 ** next call to either of these routines or until the end of the xFilter
10381 ** belonging to the next (if any) database. ^If any databases are skipped
11255 ** to a single table are processed before moving on to the next table. Tables
11548 ** the iterator to point to the next change in the changeset (if any). If
12289 ** continues to the next change in the changeset.
13543 ** to the next, so we have developed the following set of #if statements
13549 ** that vary from one machine to the next.
13922 ** element pointed to plus the next _ht.count-1 elements in the list.
13947 HashElem *next, *prev; /* Next and previous elements in the table */
13973 #define sqliteHashNext(E) ((E)->next)
14520 ** Round up a number to the next larger multiple of 8. This is used
17116 VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
17720 ** next time a statement is prepared using said sqlite3*. This is done
18091 Index *pNext; /* The next index associated with the same table */
18576 ** and the next table on the list. The parser builds the list this way.
18711 ** context is searched first. If no match is found, the next outer
18712 ** context is checked. If there is still no match, the next context
18792 ** The next group of fields stores intermediate data. */
19773 ** advance zIn to point to the first byte of the next UTF-8 character.
22526 u32 iHdrOffset; /* Offset to next unparsed byte of the header */
24285 ** Move the date to the same time on the next occurrence of
25075 ** The next group of routines are convenience wrappers around the
25695 ** Round up a request size to the next valid allocation size.
25967 ** Round up a request size to the next valid allocation size.
26378 u32 next; /* Index in mem3.aPool[] of next free chunk */
26438 u32 next = mem3.aPool[i].u.list.next;
26442 *pRoot = next;
26444 mem3.aPool[prev].u.list.next = next;
26446 if( next ){
26447 mem3.aPool[next].u.list.prev = prev;
26449 mem3.aPool[i].u.list.next = 0;
26479 mem3.aPool[i].u.list.next = *pRoot;
26610 iNext = mem3.aPool[i].u.list.next;
26618 iNext = mem3.aPool[prev].u.list.next;
26671 for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
26776 ** Round up a request size to the next valid allocation size.
26923 for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
26932 for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
27049 int next; /* Index of next free chunk */
27130 int next, prev;
27135 next = MEM5LINK(i)->next;
27138 mem5.aiFreelist[iLogsize] = next;
27140 MEM5LINK(prev)->next = next;
27142 if( next>=0 ){
27143 MEM5LINK(next)->prev = prev;
27158 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
27221 /* Round nByte up to the next valid power of two */
27225 ** block. If not, then split a block of the next larger power of
27393 ** Round up a request size to the next valid allocation size. If
27526 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
33175 ** Write a pointer to the next unread byte back into *pzNext.
35362 HashElem *next_elem = elem->next;
35403 pNew->next = pHead;
35405 if( pHead->prev ){ pHead->prev->next = pNew; }
35409 pNew->next = pH->first;
35453 next_elem = elem->next;
35491 elem = elem->next;
35506 elem->prev->next = elem->next;
35508 pH->first = elem->next;
35510 if( elem->next ){
35511 elem->next->prev = elem->prev;
35516 pEntry->chain = elem->next;
36137 ** one stops and the next begins.
37024 /* The next group of variables are used to track whether or not the
40097 ** The next division contains implementations for all methods of the
40584 ** entry for the journal might not exist after we reboot. The next
40724 ** (rounded up to the next chunk-size). If the database is already
46636 ** Round up a request size to the next valid allocation size.
47648 ** The next group of routines implement the I/O methods specified
50923 int i; /* XOR next input into a[i] */
54899 ** objects. In that alternative use, pRight points to the next entry
55237 /* Return the next entry on the list */
55786 ** when a read-transaction is next opened on the pager (transitioning
57024 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
57079 /* Advance Pager.journalOff to the start of the next sector. If the
57176 ** journal file descriptor is advanced to the next sector boundary before
57215 /* If in full-sync mode, advance to the next disk sector before writing
57325 ** as a hot-journal and rolled back the next time a read-transaction
57657 ** means that there is a hot-journal left in the file-system, the next
57743 ** value is increased to the start of the next page in the journal.
57949 ** problem. When the page is next fetched by the b-tree layer, it
58269 ** (7) zero padding out to the next sector size.
58359 /* Read the next journal header from the journal file. If there are
58389 ** When rolling back a hot journal, nRec==0 always means that the next
58441 ** so that no further harm will be done. Perhaps the next
58952 ** PagerSavepoint.iOffset and continuing to the next journal header.
59708 ** back or finalize it. The next database user will have to do hot-journal
59809 ** than Pager.journalOff bytes. If the next thing in the journal
61883 ** next time a read transaction is opened the cache will be
63885 u8 padToSectorBoundary; /* Pad transactions out to the next sector */
64330 ** the hash to the next value in the event of a collision.
64698 /* Read and decode the next log frame. */
64953 u32 *piPage, /* OUT: The page number of the next page */
64954 u32 *piFrame /* OUT: Wal frame index of next page */
65341 ** This function updates the shared-memory structures so that the next
65543 ** the next process to write to the database restarts the wal file.
65994 /* Read and decode the next log frame. */
66854 ** the next fsync should occur - passed from sqlite3WalFrames() into
67135 ** final frame is repeated (with its commit mark) until the next sector
67323 ** next time the pager opens a snapshot on this database it knows that
67462 /* Try to open on pSnapshot when the next read-transaction starts
67728 ** 2 Byte offset of the next freeblock
67769 ** 4 Page number of next overflow page
67778 ** 4 Page number of next trunk page
68143 ** indicating that the next sqlite3BtreeNext() or sqlite3BtreePrevious()
69077 ** be zero already. So this next line is harmless in that case.
69826 /* The next block of code is equivalent to:
69842 /* The next block of code is equivalent to:
70293 /* The next slot in the chain comes before the current slot */
70418 u16 iPtr; /* Address of ptr to next freeblock */
70419 u16 iFreeBlk; /* Address of the next freeblock */
70638 u32 next, size;
70650 next = get2byte(&data[pc]);
70653 if( next<=pc+size+3 ) break;
70654 pc = next;
70656 if( next>0 ){
72349 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
72693 Pgno iFree; /* The next page to be freed */
73353 #ifndef NDEBUG /* The next routine used only within assert() statements */
73445 ** ovfl), this function finds the page number of the next page in the
73451 ** The page number of the next overflow page in the linked list is
73468 Pgno next = 0;
73476 /* Try to find the next page in the overflow list using the
73477 ** autovacuum pointer-map pages. Guess that the next page in
73480 ** number ovfl to determine the next page number.
73494 next = iGuess;
73501 assert( next==0 || rc==SQLITE_DONE );
73506 next = get4byte(pPage->aData);
73510 *pPgnoNext = next;
73685 ** number for the next page in the overflow chain. The page
73837 ** page of the database. The data might change or move the next time
73871 ** or be destroyed on the next call to any Btree routine,
74680 ** Advance the cursor to the next entry in the database.
74689 ** to the next cell on the current page. The (slower) btreeNext() helper
74948 ** is the page number of the next freelist trunk page in the list or
75869 int ixNx[NB*2]; /* Index of at which we move to the next apEnd[] */
76860 ** The next block of code attempts to adjust the packing of siblings to
77396 ** next iteration of the do-loop will balance the child page.
77436 ** happens, the next iteration of the do-loop will balance pParent
77455 ** become overfull or underfull. The next iteration of the do-loop
77480 /* The pSpace buffer will be freed after the next call to
77489 /* The next iteration of the do-loop balances the parent page. */
77890 ** entry in the table, and the next row inserted has an integer key
77945 u8 *aOut = pBt->pTmpSpace; /* Pointer to next output buffer */
77946 const u8 *aIn; /* Pointer to next input buffer */
78045 ** the next call to BtreeNext() or BtreePrev() moves it to the same row
78132 ** of the 'next' entry, as the previous entry is always a part of the
78744 ** the next page in the tree that has not yet been visited. The
78746 ** of the page, or to the number of cells in the page if the next page
79225 ** big-endian integer which is the offset in the b-tree page of the next
79773 Pgno iNext; /* Page number of the next source page to copy */
83091 ** Resolve label "x" to be the address of the next instruction to
83172 int iAddr; /* Address of next instruction to return */
83516 ** Return the address of the next instruction to be inserted.
83706 ** the address of the next instruction to be coded.
83714 ** the jump lands on the next opcode. Or if the jump instruction was
83716 ** the next instruction counter by one slot so that the jump is
83717 ** overwritten by the next inserted opcode.
84622 ** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN
84632 int *piPc, /* IN/OUT: Current rowid. Overwritten with next rowid */
84813 /* Figure out which opcode is next to display */
86656 u32 d1; /* Offset into aKey[] of next data element */
86657 u32 idx1; /* Offset into aKey[] of next header element */
86691 /* Read the serial types for the next element in each key. */
87068 u32 d1; /* Offset into aKey[] of next data element */
87069 int i; /* Index of next field to compare */
88788 sqlite3_value **ppOut, /* Store the next value from the list here */
88839 ** Set the iterator value pVal to point to the next value in the set.
89103 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
89701 ** Return a pointer to the next prepared statement after pStmt associated
90153 int nextIndex = 1; /* Index of next ? host parameter */
90333 ** The next global variable is incremented each type the OP_Sort opcode
90344 ** The next global variable records the size of the largest MEM_Blob
90370 ** The next global variable is incremented each time the OP_Found opcode
91239 ** The next instruction executed will be
91321 ** values, otherwise execution falls through to the next opcode, and the
91405 ** Yield or Return then continue to the next instruction. But if
91408 ** next instruction.
91614 /* Fall through to the next case, OP_String */
91662 ** a no-op that simply falls through to the next instruction (assuming that
92187 ** P4 is a pointer to a CollSeq object. If the next call to a user function
92591 ** operator actually is. The next block of code depends on the fact
92650 ** Set the permutation used by the OP_Compare operator in the next
92653 ** The permutation is only valid for the next opcode which must be
92672 ** the comparison for use by the next OP_Jump instruct.
92892 ** Fall through to the next instruction the first time this opcode is
93272 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
93649 u8 *zHdr; /* Where to write next byte of the header */
93650 u8 *zPayload; /* Where to write next byte of the payload */
95092 /* The next line of code computes as follows, only faster:
95191 ** unnecessary seeks on the btree, substituting steps to the next row
95435 ** falls through to the next instruction and P1 is left pointing at the
95605 ** leave the cursor pointing at that record and fall through to the next
95628 ** leave the cursor pointing at that record and fall through to the next
95708 ** Find the next available sequence number for cursor P1.
95758 /* The next rowid or record number (different terms for the same
96012 ** the cursor will be left pointing at either the next or the previous
96013 ** record in the table. If it is left pointing at the next record, then
96014 ** the next Next instruction will be a no-op. As a result, in this case
96167 ** Fall through to next instruction if the two records compare equal to
96381 ** The next use of the Rowid or Column or Prev instruction for P1
96487 ** The next use of the Rowid or Column or Next instruction for P1
96531 ** Advance cursor P1 so that it points to the next key/data pair in its
96580 ** invoked. This opcode advances the cursor to the next sorted
96882 ** then jump to P2. Otherwise fall through to the next instruction.
96893 ** then jump to P2. Otherwise fall through to the next instruction.
96904 ** Otherwise fall through to the next instruction.
96915 ** to P2. Otherwise fall through to the next instruction.
97403 ** next opcode.
97646 ** If so, jump to instruction P2. Otherwise, fall through to the next
97705 ** value is unchanged and control passes through to the next instruction.
97901 ** might change from one evaluation to the next. The next block of code
98169 ** P2. Otherwise, fall through to the next instruction.
98545 ** Advance virtual table P1 to the next row in its result set and
98547 ** the end of its result set, then fall through to the next instruction.
98569 ** some other method is next invoked on the save virtual table cursor.
98755 ** sqlite3_set_auxdata() API may be safely retained until the next
98774 ** sqlite3_set_auxdata() API may be safely retained until the next
98796 ** might change from one evaluation to the next. The next block of code
99814 ** sqlite3VdbeSorterNext() Advance the read cursor to the next sorted
99895 ** with merging the next T bytes of data. And so on.
100014 ** be advanced to the next key in its segment. Say the next key is
100028 ** In other words, each time we advance to the next sorter element, log2(N)
100030 ** being merged (rounded up to the next power of 2).
100119 ** PMA, in sorted order. The next key to be read is cached in nKey/aKey.
100154 ** a background thread to populate aFile[1] with the next mxSz bytes of
100221 SorterRecord *pNext; /* Pointer to next record in list */
100222 int iNext; /* Offset within aMemory of next record */
100254 ** Read the next nByte bytes of data from the PMA p.
100260 ** next call to this function.
100278 /* If there is no more data to be read from the buffer, read the next
100450 ** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if
100950 ** nReader is automatically rounded up to the next power of two.
101382 ** Advance the MergeEngine to its next entry.
101383 ** Set *pbEof to true there is no next entry because
101389 MergeEngine *pMerger, /* The merge engine to advance to the next row */
101407 ** advanced (iPrev) and the one next to it in the array. */
101425 ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
101679 /* Write the next key to the output. */
101804 ** Recompute pMerger->aTree[iOut] by comparing the next keys on the
102404 ** Advance to the next element in the sorter. Return value:
102696 ** Advance a bytecodevtab_cursor to its next row of output.
104284 /* Advance to the next name context. The loop will exit when either
105584 /* Advance to the next term of the compound
106948 ** Wildcards consisting of a single "?" are assigned the next sequential
106957 ** instance of the wildcard, the next sequential variable number is
106972 /* Wildcard of the form "?". Assign the next variable number */
110593 int nextCase; /* GOTO label for next WHEN clause */
115460 ** In other words, I is K/D rounded up to the next whole integer.
116397 /* This next condition is true if data has already been loaded from
117591 ** VDBE program and resets the pParse structure for the next
120291 int regRowid; /* Rowid of the next row to insert */
121212 int addr2; /* Address to jump to for next iteration */
125345 ** macro for fast reading of the next character in the common case where
125346 ** the next character is ASCII.
126429 ** Therefore the next statement sets variable 'max' to 1 for the max()
128392 /* For ON UPDATE, construct the next term of the WHEN clause.
129314 int iRegStore; /* Register in which to store next column */
130160 /* Return the next index from the list. Return NULL when out of indexes */
130251 ** Processing continues with the next row.
131011 ** the next retest block */
131232 ** If iBase is negative, then allocate the next available cursor.
135196 ** value will be restored the next time the database is opened.
135338 ** default value will be restored the next time the database is
136234 ** or (2) the next entry has a different key */
136354 ** will be overwritten when the schema is next loaded. If it does not
136994 /* Advance the pragma virtual table cursor to the next row */
138839 ** needed to load the next result row that is to be added to the sorter.
139006 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
139079 ** it can be compared to the next. The caller must ensure that this
139306 int iContinue, /* Jump here to continue with next row */
139872 int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
140912 /* Find the next row in the Queue and output that row */
140915 /* Transfer the next row in Queue over to Current */
141537 ** return the next row of result.
141616 ** is skipped if the next results would be the same as the previous.
141729 ** the permutation used to determine if the next
141851 ** select as the next output row of the compound select.
141859 ** select as the next output row of the compound select.
142796 ** outer query (the middle slot) is used by the subquery. The next
145884 ** for the next GROUP BY batch.
148163 int labelContinue; /* Jump here to continue next step of UPDATE loop */
148819 ** case, jump to the next row. No updates or AFTER triggers are
148950 /* Repeat the above with the next record to be updated, until
149383 ** Continue the search with the next index. */
150161 ** database connections to be disconnected at the next opportunity.
151384 int addrNxt; /* Jump here to start the next IN combination */
151385 int addrSkip; /* Jump here for next iteration of skip-scan */
151386 int addrCont; /* Jump here to continue with the next loop cycle */
151390 int addrBignull; /* Jump here for next part of big-null scan */
151778 int iContinue; /* Jump here to continue with next record */
153252 int addrNxt; /* Where to jump to continue with the next IN case */
153261 int addrCont; /* Jump here to continue with next cycle */
153293 ** Jump to cont to go immediately to the next iteration of the
153297 ** means to continue with the next IN value combination. When
153331 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
153420 /* Generate code that will continue to the next row if
154108 ** fall through to the next instruction, just as an OP_Next does if
154331 ** loop to point to this spot, which is the top of the next containing
155219 int idxNew; /* Index in pWC of the next virtual term */
156578 ** next. As long as allocateIndexInfo() and sqlite3_vtab_collation()
156686 ** immediately with the next row of a WHERE clause.
156856 ** Advance to the next WhereTerm that matches according to the criteria
157373 const SrcItem *pSrc, /* The FROM clause term to get the next index */
157541 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
161335 int mxI = 0; /* Index of next entry to replace */
161414 ** of WherePaths as the basis for the next. Keep track of the mxChoice
161438 /* At this point, pWLoop is a candidate to be the next loop.
161622 /* Swap the roles of aFrom and aTo for the next generation */
162859 /* The common case: Advance to the next row */
162931 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
164705 ** (current) that points to the next row to return to the query engine
164707 ** points to the next row to call the xStep() method of each window function
164709 ** points to the next row to call the xInverse() method of each window
165767 ** The new "continue" statement in the above jumps to the next iteration
166649 /* The next sections is a series of control #defines.
166663 ** that indicate what to do in response to the next
167438 /* The next table maps tokens (terminal symbols) into fallback tokens.
169800 int yygoto; /* The next state */
169801 YYACTIONTYPE yyact; /* The next action */
171909 ** the next keyword with the same hash is aKWHash[i]-1. */
172358 ** Return the id of the next token in string (*pz). Before returning, set
172403 ** * the next token is either TK_LP or an identifier.
172408 ** * the next token is TK_LP.
172592 /* If the next character is a digit, this is a floating point
172593 ** number that begins with ".". Fall thru into the next case */
172734 int n = 0; /* Length of the next token token */
172735 int tokenType; /* type of the next token */
173126 u8 token; /* Value of the next token */
176428 ** and skip to the next "?", "=" or "&", as appropriate. */
177169 ** by the next COMMIT or ROLLBACK.
177489 ** be used for the next call to sqlite3_randomness().
177809 ** the schema to be reparsed the next time it is needed. This has the
178806 ** 234 at I is the delta to next docid (357). It has one position 70
178834 ** char pTermSuffix[nSuffix];(unshared suffix of next term)
178844 ** of a node is reached, the next term is in the node with the next
178880 ** char pTermSuffix[nSuffix]; (unshared suffix of next term)
179146 ** Retrieve the next token from the tokenizer cursor pCursor. This
179162 ** implementation. It is only required to be valid until the next call
179257 Fts3HashElem *next, *prev; /* Next and previous elements in the table */
179308 #define fts3HashNext(E) ((E)->next)
179665 char *pNextDocid; /* Pointer to next docid */
180110 int iIn = 1; /* Index of next byte to read from input */
180111 int iOut = 0; /* Index of next byte to write to output */
181569 /* Load the next term on the node into zBuffer. Use realloc() to expand
181725 ** routine advances *ppPoslist so that it points to the next docid in
181809 ** called, *pp may point to the start of the next varint in the position-list
181815 ** POSITION_LIST_END and return. Otherwise, read the next varint from *pp,
181817 ** point to the next value before returning.
181823 ** the next position.
182046 ** end of the position list, or the 0x01 that precedes the next
182877 ** Advance the cursor to the next row in the %_content table that
182879 ** the next row that matches. For a full-table scan, this will be
182880 ** simply the next row in the %_content table. For a docid lookup,
183308 ** 0x0A 0x00 <next docid delta varint>
184210 ** Advance the iterator pDL to the next entry in pDL->aAll/nAll. Set *pbEof
184246 ** point to the start of the next docid value. The following line deals
184270 ** multi-token phrase. Advance it to the next matching document in the
184319 ** Advance it to the next matching documnent in the database and populate
184322 ** If there is no "next" entry and no error occurs, then *pbEof is set to
184331 Fts3Phrase *p, /* Phrase object to advance to next docid */
184422 ** Attempt to move the phrase iterator to point to the next matching docid.
184426 ** If there is no "next" entry and no error occurs, then *pbEof is set to
184432 Fts3Phrase *p, /* Phrase object to advance to next docid */
184724 /* Set nLoad4 to the value of (4^nOther) for the next iteration of the
184888 ** point to the next matching row in the database. Expressions iterate through
184895 ** Fts3Expr.bEof (non-zero if EOF - there is no next row)
184896 ** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row)
184905 ** It says above that this function advances the expression to the next
184914 ** next possible match, considering only non-deferred tokens. In other
184916 ** is advanced to the next row that contains an instance of "A * C",
184921 ** advanced to point to the next row that matches "x AND y".
184928 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
184945 ** Advance the RHS iterator to find the next row visited. */
184951 ** Advance the LHS iterator to find the next row visited. */
185291 ** Advance to the next document that matches the FTS expression in
185327 ** Restart interation for expression pExpr so that the next call to
185463 /* Advance to the next document */
186025 ** xNext - Advance the cursor to the next row, if any.
186406 ** called, it sets ParseContext.isNot to true if the 'next node' is a
186484 ** Extract the next token from buffer z (length n) using the tokenizer
186773 ** the next byte must contain either whitespace, an open or close
187177 /* Set $p to point to the next leaf in the tree of eType nodes */
187699 Fts3HashElem *next_elem = elem->next;
187789 pNew->next = pHead;
187791 if( pHead->prev ){ pHead->prev->next = pNew; }
187795 pNew->next = pH->first;
187825 next_elem = elem->next;
187854 elem = elem->next;
187870 elem->prev->next = elem->next;
187872 pH->first = elem->next;
187874 if( elem->next ){
187875 elem->next->prev = elem->prev;
187879 pEntry->chain = elem->next;
188051 int iToken; /* index of next token to be returned */
188592 ** Extract the next token from a tokenization cursor. The cursor must
188798 /* Find the start of the next token. */
189234 int iToken; /* index of next token to be returned */
189343 ** Extract the next token from a tokenization cursor. The cursor must
189735 ** xNext - Advance the cursor to the next row, if any.
191021 sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */
191027 /* Set variable iNext to the next available segdir index at level iLevel. */
191195 ** Move the iterator passed as the first argument to the next term in the
191196 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
191351 ** Advance the SegReader to point to the next docid in the doclist
191362 Fts3SegReader *pReader, /* Reader to advance to next docid */
191425 ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
191426 ** Fts3SegReader.pOffsetList to point to the next offset list before
191897 const char *zNext, /* Buffer containing next term */
192057 sqlite3_int64 iFree, /* Block id of next free slot in %_segments */
192151 /* Find the next free blockid in the %_segments table */
192240 /* Save the current term so that it can be used to prefix-compress the next.
192726 ** a state that if the next two calls are:
193059 ** oldest segment in the range, 1 for the next oldest, and so on.
193149 /* This call is to merge all segments at level iLevel. find the next
193654 ** the next entry on the node.
193657 ** Otherwise return SQLITE_OK. If there is no next entry on the node
193736 ** than or equal to the first key that will be written to the next leaf
193944 /* Advance to the next output block */
194500 sqlite3_int64 *piBlock /* OUT: Block number in next layer down */
194886 ** done on iAbsLevel - fall through to the next iteration of the loop
194958 /* Write the hint values into the %_stat table for the next incr-merger */
195941 ** After it returns, *piPos contains the value of the next element of the
196073 ** Advance the snippet iterator to the next candidate snippet.
196546 ** the next column in the position-list).
196812 ** Advance the iterator passed as an argument to the next position. Return
196814 ** position list for the next column.
197348 ** in column iCol, jump immediately to the next iteration of the loop.
197372 int iMinPos = 0x7FFFFFFF; /* Position of next token */
197373 TermOffset *pTerm = 0; /* TermOffset associated with next token */
197553 int iToken; /* Index of next token to be returned */
197770 ** Extract the next token from a tokenization cursor. The cursor must
197790 /* Scan past any delimiter characters before the start of the next token.
197820 /* If the cursor is not at EOF, read the next character */
198606 ** next peer value.
200479 /* Advance the cursor to the next element for json_tree() */
200992 ** 2. The next 2 bytes contain the number of entries currently
201238 RtreeSearchPoint sPoint; /* Cached next search point */
202640 /* Move to the next entry that matches the configured constraints. */
205504 /* Skip whitespace. Return the next non-whitespace character. */
205511 ** return non-zero on success and zero if the next token is not a number.
207483 /* Read (and consume) the next character from the input pattern. */
208082 ** Extract the next token from a tokenization cursor.
208208 ** b-tree are completed before moving on to the next, and all
208609 ** the next call to sqlite3rbu_vacuum() opens a handle that starts a
208672 ** Database handles returned by this function remain valid until the next
208778 ** RBU is currently building a *-oal file. The next call to sqlite3rbu_step()
208783 ** RBU has finished building the *-oal file. The next call to sqlite3rbu_step()
208786 ** file will become visible to ordinary SQLite clients following the next
208790 ** RBU is currently performing an incremental checkpoint. The next call to
209666 ** Advance the iterator to the next position.
209669 ** pointing to the next entry. Otherwise, an error code and message is
212489 /* Advance to the next row to process. */
212558 ** this by checkpointing frames until the next page in the aFrame[]
212600 ** things so that the next call to sqlite3rbu_step() continues on from
213044 ** state table. This causes the next call to sqlite3rbu_vacuum()
214231 ** The next to left-most child of the root page is
214747 ** Move a DBSTAT cursor to the next entry. Normally, the next
214748 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
214749 ** the next entry is the next btree.
214765 /* Start measuring space on the next btree */
214898 ** next page. The loop will exit via the return at label-statNext-done
215280 ** Move a dbpagevfs cursor to the next entry in the file.
215593 int iNext; /* Offset in aData[] of next change */
216238 ** as to point to the next value in the record.
217023 ** to the next session object attached to this database. */
218728 ** Advance the changeset iterator to the next change. The differences between
218871 ** Advance the changeset iterator to the next change.
218882 ** successfully advanced to the next change in the changeset, an SQLite
218902 ** Advance an iterator created by sqlite3changeset_start() to the next
220298 ** next change. A log message has already been issued. */
222880 /* The next sections is a series of control #defines.
222894 ** that indicate what to do in response to the next
223092 /* The next table maps tokens (terminal symbols) into fallback tokens.
223782 int fts5yygoto; /* The next state */
223783 fts5YYACTIONTYPE fts5yyact; /* The next action */
224333 ** Advance the iterator to the next coalesced phrase instance. Return
227885 ** Move to the next document
230120 ** doclist: next doclist
230129 ** poslist: next poslist
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 */
230416 ** has been exhausted. Do not proceed to the next term in the segment.
231280 ** the next populated level, then that segment, and any other adjacent
231585 ** Load the next leaf page into the segment iterator.
231589 Fts5SegIter *pIter /* Iterator to advance to next page */
231923 ** Advance iterator pIter to the next entry.
231956 ** Advance iterator pIter to the next entry.
231975 /* Next entry is on the next page */
232027 ** Advance iterator pIter to the next entry.
232056 /* The next entry is on the current page. */
232357 /* Read the nKeep field of the next term. */
232913 ** Move the iterator to the next entry.
233082 ** start of the next columns hits. */
233616 ** Move the iterator to the next entry at or following iMatch.
233897 ** a copy of iRowid (which will become the first rowid on the next
233898 ** doclist-index leaf page) up into the next level of the b-tree
233967 /* Initialize the next page. */
235644 ** Move to the next matching rowid.
235654 ** Move to the next matching term/rowid. Used by the fts5vocab module.
235676 ** Move to the next matching rowid that occurs at or after iMatch. The
236620 /* Read the term data for the next term*/
237719 ** Advance the cursor to the next row in the table that matches the
241384 ** then the next token. */
243935 ** Advance the cursor to the next row in the table.
244417 ** Advance a stmt_cursor to its next row of output.