Lines Matching defs:nExt
1439 ** be advantageous to block on the next WAL lock if the lock is not immediately
1457 ** atomically at the next [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. Systems
1827 ** next. Applications that use these interfaces must be prepared for any
1829 ** from one release to the next. Applications must not attempt to access
1838 sqlite3_vfs *pNext; /* Next registered VFS */
2107 ** allocators round up memory allocations at least to the next multiple
2162 ** and/or deletions) from one release of SQLite to the next.
5452 ** or until the next call to
5462 ** one release of SQLite to the next.
5587 ** sqlite3_step() is called again to retrieve the next row of data.
6400 ** occurs is undefined and may change from one release of SQLite to the next.
7408 ** SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].</dd>
7415 ** CAPI3REF: Find the next prepared statement
7418 ** ^This interface returns a pointer to the next [prepared statement] after
7809 ** declaration type and collation sequence is valid until the next
8898 ** next. Applications that override the built-in mutex logic must be
8992 ** operate consistently from one release to the next.
9984 ** restarted by the next call to sqlite3_backup_step(). ^If the source
10024 ** and sqlite3_backup_remaining() until after the next
10414 ** that the next writer will restart the log file from the beginning.
10873 ** routines return SQLITE_OK and set *P to point to the first or next value
10880 ** next call to either of these routines or until the end of the xFilter
11107 ** belonging to the next (if any) database. ^If any databases are skipped
11482 ** until either the next write operation on the connection or when
12107 ** to a single table are processed before moving on to the next table. Tables
12402 ** the iterator to point to the next change in the changeset (if any). If
13253 ** continues to the next change in the changeset.
15015 ** to the next, so we have developed the following set of #if statements
15021 ** that vary from one machine to the next.
15426 ** element pointed to plus the next _ht.count-1 elements in the list.
15451 HashElem *next, *prev; /* Next and previous elements in the table */
15478 #define sqliteHashNext(E) ((E)->next)
16086 ** Round up a number to the next larger multiple of 8. This is used
17341 #define BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */
17610 SubProgram *pNext; /* Next sub-program already visited */
18232 PgHdr *pDirtyNext; /* Next element in list of dirty pages */
18630 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
18792 VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
18827 sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
18995 FuncDef *pNext; /* Next function with same name */
19002 FuncDef *pHash; /* Next with a different name but the same hash */
19416 ** next time a statement is prepared using said sqlite3*. This is done
19435 VTable *pNext; /* Next in linked list (see above) */
19609 FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */
19611 FKey *pNextTo; /* Next with the same zTo. Next child of zTo. */
19819 Index *pNext; /* The next index associated with the same table */
20345 ** and the next table on the list. The parser builds the list this way.
20511 ** context is searched first. If no match is found, the next outer
20512 ** context is checked. If there is still no match, the next context
20531 NameContext *pNext; /* Next outer name context. NULL for outermost */
20591 Upsert *pNextUpsert; /* Next ON CONFLICT clause in the list */
20595 ** The next group of fields stores intermediate data. */
20626 Select *pNext; /* Next select to the left in a compound */
20797 AutoincInfo *pNext; /* Next info block in a list of them all */
20823 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
20865 IndexedExpr *pIENext; /* Next in a list of all indexed expressions */
20877 ParseCleanup *pNext; /* Next cleanup task */
21128 Trigger *pNext; /* Next trigger associated with the table */
21196 TriggerStep *pNext; /* Next in the link-list */
21533 DbClientData *pNext; /* Next in a linked list */
21590 Window *pNextWin; /* Next window function belonging to this SELECT */
21637 ** advance zIn to point to the first byte of the next UTF-8 character.
24392 u32 iHdrOffset; /* Offset to next unparsed byte of the header */
24649 AuxData *pNextAux; /* Next element in list */
24717 DblquoteStr *pNextStr; /* Next string literal in the list */
26216 ** Resolve day-of-month overflow by rolling forward into the next
26331 ** Move the date to the same time on the next occurrence of
27501 ** The next group of routines are convenience wrappers around the
28121 ** Round up a request size to the next valid allocation size.
28393 ** Round up a request size to the next valid allocation size.
28804 u32 next; /* Index in mem3.aPool[] of next free chunk */
28864 u32 next = mem3.aPool[i].u.list.next;
28868 next;
28870 mem3.aPool[prev].u.list.next = next;
28872 if( next ){
28873 mem3.aPool[next].u.list.prev = prev;
28875 mem3.aPool[i].u.list.next = 0;
28905 mem3.aPool[i].u.list.next = *pRoot;
29036 iNext = mem3.aPool[i].u.list.next;
29044 iNext = mem3.aPool[prev].u.list.next;
29097 for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
29202 ** Round up a request size to the next valid allocation size.
29349 for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
29358 for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
29475 int next; /* Index of next free chunk */
29556 int next, prev;
29561 next = MEM5LINK(i)->next;
29564 mem5.aiFreelist[iLogsize] = next;
29566 MEM5LINK(prev)->next = next;
29568 if( next>=0 ){
29569 MEM5LINK(next)->prev = prev;
29584 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
29647 /* Round nByte up to the next valid power of two */
29651 ** block. If not, then split a block of the next larger power of
29819 ** Round up a request size to the next valid allocation size. If
29952 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
32433 char iNxt; /* Next with same hash, or 0 for end of chain */
32575 int c; /* Next character in the format string */
33113 ** to the next character in the format string. */
35905 ** Write a pointer to the next unread byte back into *pzNext.
36925 ** Write into *pLo the next 32 significant bits of the answer after
37741 int i; /* Index into zBuf[] where to put next character */
37786 ** and working back to the right. "i" keeps track of the next slot in
38658 HashElem *next_elem = elem->next;
38706 pNew->next = pHead;
38708 if( pHead->prev ){ pHead->prev->next = pNew; }
38712 pNew->next = pH->first;
38755 next_elem = elem->next;
38792 elem = elem->next;
38807 elem->prev->next = elem->next;
38809 pH->first = elem->next;
38811 if( elem->next ){
38812 elem->next->prev = elem->prev;
38817 pEntry->chain = elem->next;
38942 /* 40 */ "Next" OpHelp(""),
39484 ** one stops and the next begins.
40413 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
40457 /* The next group of variables are used to track whether or not the
41231 struct vxworksFileId *pNext; /* Next in a list of them all */
43613 ** The next division contains implementations for all methods of the
44070 ** entry for the journal might not exist after we reboot. The next
44210 ** (rounded up to the next chunk-size). If the database is already
44244 i64 iWrite; /* Next offset to write to */
44737 u8 nextShmId; /* Next available unixShm.id value */
44756 unixShm *pNext; /* Next unixShm with the same unixShmNode */
50285 ** Round up a request size to the next valid allocation size.
51390 ** The next group of routines implement the I/O methods specified
52750 winShmNode *pNext; /* Next in list of all winShmNode objects */
52752 u8 nextShmId; /* Next available winShm.id value */
52777 winShm *pWinShmNext; /* Next winShm object on same winShmNode */
54924 int i; /* XOR next input into a[i] */
57756 PgHdr1 *pNext; /* Next in hash table chain */
57758 PgHdr1 *pLruNext; /* Next in circular LRU list of unpinned pages */
57844 PgFreeslot *pNext; /* Next free slot */
58997 ** objects. In that alternative use, pRight points to the next entry
59014 struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */
59335 /* Return the next entry on the list */
59889 ** when a read-transaction is next opened on the pager (transitioning
61121 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
61176 /* Advance Pager.journalOff to the start of the next sector. If the
61273 ** journal file descriptor is advanced to the next sector boundary before
61312 /* If in full-sync mode, advance to the next disk sector before writing
61422 ** as a hot-journal and rolled back the next time a read-transaction
61766 ** means that there is a hot-journal left in the file-system, the next
61838 ** value is increased to the start of the next page in the journal.
62025 ** problem. When the page is next fetched by the b-tree layer, it
62345 ** (7) zero padding out to the next sector size.
62435 /* Read the next journal header from the journal file. If there are
62465 ** When rolling back a hot journal, nRec==0 always means that the next
62517 ** so that no further harm will be done. Perhaps the next
63026 ** PagerSavepoint.iOffset and continuing to the next journal header.
63796 ** back or finalize it. The next database user will have to do hot-journal
63892 ** than Pager.journalOff bytes. If the next thing in the journal
65960 ** next time a read transaction is opened the cache will be
67333 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
67950 u8 padToSectorBoundary; /* Pad transactions out to the next sector */
68016 int iNext; /* Next slot in aIndex[] not yet returned */
68551 ** the hash to the next value in the event of a collision.
68922 /* Read and decode the next log frame. */
69181 u32 *piPage, /* OUT: The page number of the next page */
69182 u32 *piFrame /* OUT: Wal frame index of next page */
69559 ** This function updates the shared-memory structures so that the next
69626 u32 iDbpage = 0; /* Next database page to write */
69771 ** the next process to write to the database restarts the wal file.
70323 /* Read and decode the next log frame. */
70374 ** the next invocation of walTryBeginRead() may omit an expected call to
71334 ** the next fsync should occur - passed from sqlite3WalFrames() into
71409 u32 iRead; /* Next frame to read from wal file */
71462 u32 iFrame; /* Next frame address */
71467 i64 iOffset; /* Next byte to write in WAL file */
71605 ** final frame is repeated (with its commit mark) until the next sector
71827 ** next time the pager opens a snapshot on this database it knows that
71962 /* Try to open on pSnapshot when the next read-transaction starts
72244 ** 2 Byte offset of the next freeblock
72285 ** 4 Page number of next overflow page
72294 ** 4 Page number of next trunk page
72399 BtLock *pNext; /* Next in BtShared.pLock list */
72536 BtShared *pNext; /* Next on a list of sharable BtShared structs */
72618 int skipNext; /* Prev() is noop if negative. Next() is noop if positive.
72665 ** indicating that the next sqlite3BtreeNext() or sqlite3BtreePrevious()
73623 ** be zero already. So this next line is harmless in that case.
74393 /* The next block of code is equivalent to:
74410 /* The next block of code is equivalent to:
74912 /* The next slot in the chain comes before the current slot */
75038 int iPtr; /* Address of ptr to next freeblock */
75039 int iFreeBlk; /* Address of the next freeblock */
75246 u32 next, size;
75258 next = get2byte(&data[pc]);
75261 if( next<=pc+size+3 ) break;
75262 pc = next;
75264 if( next>0 ){
76992 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
77336 Pgno iFree; /* The next page to be freed */
78015 #ifndef NDEBUG /* The next routine used only within assert() statements */
78105 ** ovfl), this function finds the page number of the next page in the
78111 ** The page number of the next overflow page in the linked list is
78126 Pgno *pPgnoNext /* OUT: Next overflow page number */
78128 Pgno next = 0;
78136 /* Try to find the next page in the overflow list using the
78137 ** autovacuum pointer-map pages. Guess that the next page in
78140 ** number ovfl to determine the next page number.
78154 next = iGuess;
78161 assert( next==0 || rc==SQLITE_DONE );
78166 next = get4byte(pPage->aData);
78170 *pPgnoNext = next;
78354 ** number for the next page in the overflow chain. The page
78505 ** page of the database. The data might change or move the next time
78539 ** or be destroyed on the next call to any Btree routine,
79415 ** Advance the cursor to the next entry in the database.
79424 ** to the next cell on the current page. The (slower) btreeNext() helper
79687 ** is the page number of the next freelist trunk page in the list or
80696 int ixNx[NB*2]; /* Index of at which we move to the next apEnd[] */
81361 int nxDiv; /* Next divider slot in pParent->aCell[] */
81712 ** The next block of code attempts to adjust the packing of siblings to
82258 ** next iteration of the do-loop will balance the child page.
82298 ** happens, the next iteration of the do-loop will balance pParent
82317 ** become overfull or underfull. The next iteration of the do-loop
82342 /* The pSpace buffer will be freed after the next call to
82351 /* The next iteration of the do-loop balances the parent page. */
82416 int iOffset; /* Next byte of pX->pData to write */
82421 Pgno ovflPgno; /* Next overflow page to write */
82780 ** entry in the table, and the next row inserted has an integer key
82833 u8 *aOut = pBt->pTmpSpace; /* Pointer to next output buffer */
82834 const u8 *aIn; /* Pointer to next input buffer */
82934 ** the next call to BtreeNext() or BtreePrev() moves it to the same row
83024 ** of the 'next' entry, as the previous entry is always a part of the
83636 ** the next page in the tree that has not yet been visited. The
83638 ** of the page, or to the number of cells in the page if the next page
83979 u8 *pCellIdx; /* Next element of the cell pointer array */
83985 u32 x, prev = 0; /* Next and previous entry on the min-heap */
84164 ** big-endian integer which is the offset in the b-tree page of the next
84717 Pgno iNext; /* Page number of the next source page to copy */
84730 sqlite3_backup *pNext; /* Next backup associated with source pager */
87618 u32 iHdr; /* Next unread header byte */
87619 i64 iField; /* Next unread data byte */
88335 ** Resolve label "x" to be the address of the next instruction to
88419 int iAddr; /* Address of next instruction to return */
88783 ** Return the address of the next instruction to be inserted.
89039 ** the address of the next instruction to be coded.
89047 ** the jump lands on the next opcode. Or if the jump instruction was
89049 ** the next instruction counter by one slot so that the jump is
89050 ** overwritten by the next inserted opcode.
89976 ** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN
89986 int *piPc, /* IN/OUT: Current rowid. Overwritten with next rowid */
89993 int i; /* Next instruction address */
90166 /* Figure out which opcode is next to display */
92024 u32 d1; /* Offset into aKey[] of next data element */
92025 u32 idx1; /* Offset into aKey[] of next header element */
92059 /* Read the serial types for the next element in each key. */
92458 u32 d1; /* Offset into aKey[] of next data element */
92459 int i; /* Index of next field to compare */
92463 Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */
93203 u32 idxRec = szHdr; /* Index of next field in record body */
94562 sqlite3_value **ppOut, /* Store the next value from the list here */
94620 ** Set the iterator value pVal to point to the next value in the set.
94893 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
95608 ** Return a pointer to the next prepared statement after pStmt associated
96241 int nextIndex = 1; /* Index of next ? host parameter */
96518 ** The next global variable is incremented each type the OP_Sort opcode
96529 ** The next global variable records the size of the largest MEM_Blob
96555 ** The next global variable is incremented each time the OP_Found opcode
97500 ** The next instruction executed will be
97582 ** values, otherwise execution falls through to the next opcode, and the
97668 ** Yield or Return then continue to the next instruction. But if
97671 ** next instruction.
97888 /* Fall through to the next case, OP_String */
97936 ** a no-op that simply falls through to the next instruction (assuming that
98425 ** P4 is a pointer to a CollSeq object. If the next call to a user function
98836 ** operator actually is. The next block of code depends on the fact
98897 ** Set the permutation used by the OP_Compare operator in the next
98900 ** The permutation is only valid for the next opcode which must be
98919 ** the comparison for use by the next OP_Jump instruct.
99131 ** Fall through to the next instruction the first time this opcode is
99431 const u8 *zHdr; /* Next unparsed byte of the header */
99523 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
99928 u8 *zHdr; /* Where to write next byte of the header */
99929 u8 *zPayload; /* Where to write next byte of the payload */
101203 ** configured to use Next, not Prev.
101221 ** configured to use Next, not Prev.
101239 ** configured to use Prev, not Next.
101257 ** configured to use Prev, not Next.
101387 /* The next line of code computes as follows, only faster:
101486 ** unnecessary seeks on the btree, substituting steps to the next row
101716 ** advanced in the forward direction. The Next instruction will work,
101731 ** falls through to the next instruction and P1 is left pointing at the
101735 ** advanced in either direction. In other words, the Next and Prev
101789 ** advanced in either direction. In other words, the Next and Prev
101902 ** leave the cursor pointing at that record and fall through to the next
101913 ** in either direction. In other words, the Next and Prev opcodes will
101925 ** leave the cursor pointing at that record and fall through to the next
101936 ** in either direction. In other words, the Next and Prev opcodes will
102005 ** Find the next available sequence number for cursor P1.
102055 /* The next rowid or record number (different terms for the same
102314 ** the cursor will be left pointing at either the next or the previous
102315 ** record in the table. If it is left pointing at the next record, then
102316 ** the next Next instruction will be a no-op. As a result, in this case
102317 ** it is ok to delete a record from within a Next loop. If
102475 ** Fall through to next instruction if the two records compare equal to
102689 ** The next use of the Rowid or Column or Prev instruction for P1
102697 ** configured to use Prev, not Next.
102805 ** The next use of the Rowid or Column or Next instruction for P1
102816 ** configured to use Next, not Prev.
102879 /* Opcode: Next P1 P2 P3 * P5
102881 ** Advance cursor P1 so that it points to the next key/data pair in its
102886 ** The Next opcode is only valid following an SeekGT, SeekGE, or
102887 ** OP_Rewind opcode used to position the cursor. Next is not allowed
102930 ** invoked. This opcode advances the cursor to the next sorted
103238 ** then jump to P2. Otherwise fall through to the next instruction.
103249 ** then jump to P2. Otherwise fall through to the next instruction.
103260 ** Otherwise fall through to the next instruction.
103271 ** to P2. Otherwise fall through to the next instruction.
103855 ** next opcode.
104096 next
104155 ** value is unchanged and control passes through to the next instruction.
104348 ** might change from one evaluation to the next. The next block of code
104618 ** P2. Otherwise, fall through to the next instruction.
105052 ** Advance virtual table P1 to the next row in its result set and
105054 ** the end of its result set, then fall through to the next instruction.
105076 ** some other method is next invoked on the save virtual table cursor.
105263 ** sqlite3_set_auxdata() API may be safely retained until the next
105282 ** sqlite3_set_auxdata() API may be safely retained until the next
105304 ** might change from one evaluation to the next. The next block of code
105653 ** Do nothing. Continue downward to the next opcode.
105672 ** are subject to change from one release to the next. Applications
106406 ** sqlite3VdbeSorterNext() Advance the read cursor to the next sorted
106427 ** only occur in between Init()/Reset() and Rewind(). Next(), Rowkey(), and
106434 ** Next()
106443 ** and subsequent calls to Rowkey(), Next() and Compare() read records
106487 ** with merging the next T bytes of data. And so on.
106605 ** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will
106606 ** be advanced to the next key in its segment. Say the next key is
106620 ** In other words, each time we advance to the next sorter element, log2(N)
106622 ** being merged (rounded up to the next power of 2).
106715 ** PMA, in sorted order. The next key to be read is cached in nKey/aKey.
106750 ** a background thread to populate aFile[1] with the next mxSz bytes of
106818 SorterRecord *pNext; /* Pointer to next record in list */
106819 int iNext; /* Offset within aMemory of next record */
106851 ** Read the next nByte bytes of data from the PMA p.
106857 ** next call to this function.
106875 /* If there is no more data to be read from the buffer, read the next
107048 ** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if
107558 ** nReader is automatically rounded up to the next power of two.
108004 ** Advance the MergeEngine to its next entry.
108005 ** Set *pbEof to true there is no next entry because
108011 MergeEngine *pMerger, /* The merge engine to advance to the next row */
108029 ** advanced (iPrev) and the one next to it in the array. */
108047 ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
108301 /* Write the next key to the output. */
108426 ** Recompute pMerger->aTree[iOut] by comparing the next keys on the
109026 ** Advance to the next element in the sorter. Return value:
109323 ** Advance a bytecodevtab_cursor to its next row of output.
109656 FileChunk *pNext; /* Next chunk in the journal */
111023 /* Advance to the next name context. The loop will exit when either
112407 /* Advance to the next term of the compound
113950 ** Wildcards consisting of a single "?" are assigned the next sequential
113959 ** instance of the wildcard, the next sequential variable number is
113974 /* Wildcard of the form "?". Assign the next variable number */
118310 int nextCase; /* GOTO label for next WHEN clause */
121055 RenameToken *pNext; /* Next is a list of all RenameToken objects */
122465 ** Return the number of bytes until the end of the next non-whitespace and
122474 ** all bytes through the next matching ")" if the token is TK_LP.
122569 ** previous column, and tokenize until the next ",". */
122772 /* Now, the current constraint proceeds until the next occurence of one
122914 /* Compare the next token - which may be quoted - with the name of
122922 /* The next token is usually the first token of the constraint
122926 ** There is also the chance that the next token is TK_CONSTRAINT
122934 ** the next iteration of the loop with &zSql[iOff] still pointing
124268 ** In other words, I is K/D rounded up to the next whole integer.
124392 int iTab /* Next available cursor */
124522 ** Next csr
124633 ** Next csr
125273 /* This next condition is true if data has already been loaded from
126447 ** VDBE program and resets the pParse structure for the next
129153 int regRowid; /* Rowid of the next row to insert */
130090 int addr2; /* Address to jump to for next iteration */
134375 ** macro for fast reading of the next character in the common case where
134376 ** the next character is ASCII.
134444 u32 c, c2; /* Next pattern and input string chars */
135130 u8 c; /* Most significant digit of next byte */
135131 u8 d; /* Least significant digit of next byte */
135823 ** Therefore the next statement sets variable 'max' to 1 for the max()
136404 ** average of the nearest two input values, it returns the next lower
138447 /* For ON UPDATE, construct the next term of the WHEN clause.
139583 int iRegStore; /* Register in which to store next column */
140447 /* Return the next index from the list. Return NULL when out of indexes */
140538 ** Processing continues with the next row.
141299 ** the next retest block */
141520 ** If iBase is negative, then allocate the next available cursor.
143727 u32 nExt; /* Number of entries in aExt[] */
143771 for(i=0; i<wsdAutoext.nExt; i++){
143774 if( i==wsdAutoext.nExt ){
143775 u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
143782 wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
143783 wsdAutoext.nExt++;
143814 for(i=(int)wsdAutoext.nExt-1; i>=0; i--){
143816 wsdAutoext.nExt--;
143817 wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt];
143841 wsdAutoext.nExt = 0;
143858 if( wsdAutoext.nExt==0 ){
143873 if( i>=wsdAutoext.nExt ){
145542 ** value will be restored the next time the database is opened.
145684 ** default value will be restored the next time the database is
146103 HashElem *k; /* Loop counter: Next table in schema */
146686 ** or (2) the next entry has a different key */
146825 ** will be overwritten when the schema is next loaded. If it does not
147513 /* Advance the pragma virtual table cursor to the next row */
149431 ** needed to load the next result row that is to be added to the sorter.
149602 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
149678 ** it can be compared to the next. The caller must ensure that this
149905 int iContinue, /* Jump here to continue with next row */
150441 int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
150442 int addr; /* Top of output loop. Jump for Next. */
151545 /* Find the next row in the Queue and output that row */
151548 /* Transfer the next row in Queue over to Current */
152041 ** return the next row of result.
152121 ** is skipped if the next results would be the same as the previous.
152230 ** the permutation to determine if the next row of results comes
152331 VdbeComment((v, "SUBR: next-A"));
152343 VdbeComment((v, "SUBR: next-B"));
152355 ** select as the next output row of the compound select.
152363 ** select as the next output row of the compound select.
152384 VdbeComment((v, "next-B"));
152400 VdbeComment((v, "next-A"));
152409 VdbeComment((v, "next-A"));
152430 VdbeComment((v, "next-B"));
152433 addrAgtB++; /* Just do next-B. Might as well use the next-B call
152434 ** in the next code block */
152441 VdbeComment((v, "next-A"));
152444 VdbeComment((v, "next-B"));
153349 ** outer query (the middle slot) is used by the subquery. The next
157437 ** for the next GROUP BY batch.
159815 int labelContinue; /* Jump here to continue next step of UPDATE loop */
160480 ** case, jump to the next row. No updates or AFTER triggers are
160613 /* Repeat the above with the next record to be updated, until
160917 Upsert *pNext /* Next ON CONFLICT clause in the list */
161049 ** Continue the search with the next index. */
161845 ** database connections to be disconnected at the next opportunity.
163068 WhereMemBlock *pNext; /* Next block in the chain */
163104 int addrNxt; /* Jump here to start the next IN combination */
163105 int addrSkip; /* Jump here for next iteration of skip-scan */
163106 int addrCont; /* Jump here to continue with the next loop cycle */
163110 int addrBignull; /* Jump here for next part of big-null scan */
163196 WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */
163507 int iContinue; /* Jump here to continue with next record */
165151 int addrNxt; /* Where to jump to continue with the next IN case */
165159 int addrCont; /* Jump here to continue with next cycle */
165194 ** Jump to cont to go immediately to the next iteration of the
165198 ** means to continue with the next IN value combination. When
165228 VdbeComment((v, "next row of %s", pTabItem->pSTab->zName));
165320 /* Generate code that will continue to the next row if
166001 ** fall through to the next instruction, just as an OP_Next does if
166224 ** loop to point to this spot, which is the top of the next containing
166245 ** a pseudo-cursor. No need to Rewind or Next such cursors. */
166284 int iNext = 0; /* Next value for iLoop */
167189 int idxNew; /* Index in pWC of the next virtual term */
168598 ** next. As long as allocateIndexInfo() and sqlite3_vtab_collation()
168711 ** immediately with the next row of a WHERE clause.
168917 ** Advance to the next WhereTerm that matches according to the criteria
169584 SrcItem *pSrc; /* The FROM clause term to get the next index */
169772 VdbeComment((v, "next row of %s", pSrc->pSTab->zName));
170300 int iTest; /* Next sample to test */
171525 u8 c; /* Next character of the pattern */
174410 int mxI = 0; /* Index of next entry to replace */
174504 ** of WherePaths as the basis for the next. Keep track of the mxChoice
174528 /* At this point, pWLoop is a candidate to be the next loop.
174730 /* Swap the roles of aFrom and aTo for the next generation */
175589 ** invocation of the current subquery to the next.
176251 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
178057 ** (current) that points to the next row to return to the query engine
178059 ** points to the next row to call the xStep() method of each window function
178061 ** points to the next row to call the xInverse() method of each window
178971 ** Next(csrStart)
179121 ** The new "continue" statement in the above jumps to the next iteration
180078 /* The next sections is a series of control #defines.
180092 ** that indicate what to do in response to the next
180237 /* Next are the tables used to determine what action to take based on the
180964 /* The next table maps tokens (terminal symbols) into fallback tokens.
183368 int yygoto; /* The next state */
183369 YYACTIONTYPE yyact; /* The next action */
185558 ** the next keyword with the same hash is aKWHash[i]-1. */
186007 ** Return the id of the next token in string (*pz). Before returning, set
186052 ** * the next token is either TK_LP or an identifier.
186057 ** * the next token is TK_LP.
186242 /* If the next character is a digit, this is a floating point
186243 ** number that begins with ".". Fall thru into the next case */
186416 i64 n = 0; /* Length of the next token token */
186417 int tokenType; /* type of the next token */
186600 int i; /* Next unread byte of zSql[] */
186821 u8 token; /* Value of the next token */
190262 ** and skip to the next "?", "=" or "&", as appropriate. */
191036 ** by the next COMMIT or ROLLBACK.
191353 ** be used for the next call to sqlite3_randomness().
191710 ** the schema to be reparsed the next time it is needed. This has the
192747 ** 234 at I is the delta to next docid (357). It has one position 70
192775 ** char pTermSuffix[nSuffix];(unshared suffix of next term)
192785 ** of a node is reached, the next term is in the node with the next
192821 ** char pTermSuffix[nSuffix]; (unshared suffix of next term)
193097 ** Retrieve the next token from the tokenizer cursor pCursor. This
193113 ** implementation. It is only required to be valid until the next call
193208 Fts3HashElem *next, *prev; /* Next and previous elements in the table */
193259 #define fts3HashNext(E) ((E)->next)
193632 char *pNextDocid; /* Pointer to next docid */
194089 int iIn = 1; /* Index of next byte to read from input */
194090 int iOut = 0; /* Index of next byte to write to output */
195547 /* Load the next term on the node into zBuffer. Use realloc() to expand
195703 ** routine advances *ppPoslist so that it points to the next docid in
195787 ** called, *pp may point to the start of the next varint in the position-list
195793 ** POSITION_LIST_END and return. Otherwise, read the next varint from *pp,
195795 ** point to the next value before returning.
195801 ** the next position.
196029 ** end of the position list, or the 0x01 that precedes the next
196860 ** Advance the cursor to the next row in the %_content table that
196862 ** the next row that matches. For a full-table scan, this will be
196863 ** simply the next row in the %_content table. For a docid lookup,
197289 ** 0x0A 0x00 <next docid delta varint>
198248 ** Advance the iterator pDL to the next entry in pDL->aAll/nAll. Set *pbEof
198284 ** point to the start of the next docid value. The following line deals
198308 ** multi-token phrase. Advance it to the next matching document in the
198357 ** Advance it to the next matching document in the database and populate
198360 ** If there is no "next" entry and no error occurs, then *pbEof is set to
198369 Fts3Phrase *p, /* Phrase object to advance to next docid */
198460 ** Attempt to move the phrase iterator to point to the next matching docid.
198464 ** If there is no "next" entry and no error occurs, then *pbEof is set to
198470 Fts3Phrase *p, /* Phrase object to advance to next docid */
198762 /* Set nLoad4 to the value of (4^nOther) for the next iteration of the
198926 ** point to the next matching row in the database. Expressions iterate through
198933 ** Fts3Expr.bEof (non-zero if EOF - there is no next row)
198934 ** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row)
198943 ** It says above that this function advances the expression to the next
198952 ** next possible match, considering only non-deferred tokens. In other
198954 ** is advanced to the next row that contains an instance of "A * C",
198959 ** advanced to point to the next row that matches "x AND y".
198966 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
198982 ** Advance the RHS iterator to find the next row visited. */
198988 ** Advance the LHS iterator to find the next row visited. */
199328 ** Advance to the next document that matches the FTS expression in
199364 ** Restart iteration for expression pExpr so that the next call to
199529 /* Advance to the next document */
199990 int iNext = 1; /* Next free argvIndex value */
200097 ** xNext - Advance the cursor to the next row, if any.
200163 if( v==0 ){ /* 0x00. Next integer will be a docid. */
200165 }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
200479 ** called, it sets ParseContext.isNot to true if the 'next node' is a
200574 ** Extract the next token from buffer z (length n) using the tokenizer
200870 ** the next byte must contain either whitespace, an open or close
201274 /* Set $p to point to the next leaf in the tree of eType nodes */
201795 Fts3HashElem *next_elem = elem->next;
201885 pNew->next = pHead;
201887 if( pHead->prev ){ pHead->prev->next = pNew; }
201891 pNew->next = pH->first;
201921 next_elem = elem->next;
201950 elem = elem->next;
201966 elem->prev->next = elem->next;
201968 pH->first = elem->next;
201970 if( elem->next ){
201971 elem->next->prev = elem->prev;
201975 pEntry->chain = elem->next;
202147 int iToken; /* index of next token to be returned */
202688 ** Extract the next token from a tokenization cursor. The cursor must
202894 /* Find the start of the next token. */
203326 int iToken; /* index of next token to be returned */
203435 ** Extract the next token from a tokenization cursor. The cursor must
203827 ** xNext - Advance the cursor to the next row, if any.
204096 Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
204168 sqlite3_int64 iFree; /* Next free slot in %_segments */
205136 sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */
205142 /* Set variable iNext to the next available segdir index at level iLevel. */
205310 ** Move the iterator passed as the first argument to the next term in the
205311 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
205466 ** Advance the SegReader to point to the next docid in the doclist
205477 Fts3SegReader *pReader, /* Reader to advance to next docid */
205540 ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
205541 ** Fts3SegReader.pOffsetList to point to the next offset list before
206012 const char *zNext, /* Buffer containing next term */
206172 sqlite3_int64 iFree, /* Block id of next free slot in %_segments */
206266 /* Find the next free blockid in the %_segments table */
206355 /* Save the current term so that it can be used to prefix-compress the next.
206843 ** a state that if the next two calls are:
207176 ** oldest segment in the range, 1 for the next oldest, and so on.
207266 /* This call is to merge all segments at level iLevel. find the next
207774 ** the next entry on the node.
207777 ** Otherwise return SQLITE_OK. If there is no next entry on the node
207856 ** than or equal to the first key that will be written to the next leaf
208070 /* Advance to the next output block */
208415 int *piIdx /* OUT: Next free index at iAbsLevel+1 */
208627 sqlite3_int64 *piBlock /* OUT: Block number in next layer down */
209013 ** done on iAbsLevel - fall through to the next iteration of the loop
209085 /* Write the hint values into the %_stat table for the next incr-merger */
209909 i64 iHead; /* Next value in position list */
209911 i64 iTail; /* Next value in trailing position list */
210076 ** After it returns, *piPos contains the value of the next element of the
210207 ** Advance the snippet iterator to the next candidate snippet.
210684 ** the next column in the position-list).
210950 ** Advance the iterator passed as an argument to the next position. Return
210952 ** position list for the next column.
211510 ** in column iCol, jump immediately to the next iteration of the loop.
211534 int iMinPos = 0x7FFFFFFF; /* Position of next token */
211535 TermOffset *pTerm = 0; /* TermOffset associated with next token */
211715 int iToken; /* Index of next token to be returned */
211932 ** Extract the next token from a tokenization cursor. The cursor must
211952 /* Scan past any delimiter characters before the start of the next token.
211982 /* If the cursor is not at EOF, read the next character */
217610 /* Advance the cursor to the next element for json_tree() */
218135 ** 2. The next 2 bytes contain the number of entries currently
218396 RtreeSearchPoint sPoint; /* Cached next search point */
218469 RtreeNode *pNext; /* Next node in this hash collision chain */
219823 /* Move to the next entry that matches the configured constraints. */
222552 /* Skip whitespace. Return the next non-whitespace character. */
222559 ** return non-zero on success and zero if the next token is not a number.
223286 GeoEvent *pNext; /* Next event in the sorted list */
223294 GeoSegment *pNext; /* Next segment in a list sorted by y */
224555 /* Read (and consume) the next character from the input pattern. */
225187 ** Extract the next token from a tokenization cursor.
225313 ** b-tree are completed before moving on to the next, and all
225714 ** the next call to sqlite3rbu_vacuum() opens a handle that starts a
225777 ** Database handles returned by this function remain valid until the next
225883 ** RBU is currently building a *-oal file. The next call to sqlite3rbu_step()
225888 ** RBU has finished building the *-oal file. The next call to sqlite3rbu_step()
225891 ** file will become visible to ordinary SQLite clients following the next
225895 ** RBU is currently performing an incremental checkpoint. The next call to
226396 rbu_file *pMainNext; /* Next MAIN_DB file */
226397 rbu_file *pMainRbuNext; /* Next MAIN_DB file with pRbu!=0 */
226794 ** Advance the iterator to the next position.
226797 ** pointing to the next entry. Otherwise, an error code and message is
229636 /* Advance to the next row to process. */
229705 ** this by checkpointing frames until the next page in the aFrame[]
229747 ** things so that the next call to sqlite3rbu_step() continues on from
230193 ** state table. This causes the next call to sqlite3rbu_vacuum()
231411 ** The next to left-most child of the root page is
231930 ** Move a DBSTAT cursor to the next entry. Normally, the next
231931 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
231932 ** the next entry is the next btree.
231948 /* Start measuring space on the next btree */
232081 ** next page. The loop will exit via the return at label-statNext-done
232478 ** Move a dbpagevfs cursor to the next entry in the file.
232946 ** Advance a carray_cursor to its next row of output.
233397 sqlite3_session *pNext; /* Next session object on same db. */
233424 int iNext; /* Offset in aData[] of next change */
234120 ** as to point to the next value in the record.
235299 ** to the next session object attached to this database. */
237111 ** Advance the changeset iterator to the next change. The differences between
237256 ** Advance the changeset iterator to the next change.
237267 ** successfully advanced to the next change in the changeset, an SQLite
237287 ** Advance an iterator created by sqlite3changeset_start() to the next
238715 ** next change. A log message has already been issued. */
242396 /* The next sections is a series of control #defines.
242410 ** that indicate what to do in response to the next
242539 /* Next are the tables used to determine what action to take based on the
242642 /* The next table maps tokens (terminal symbols) into fallback tokens.
243347 int fts5yygoto; /* The next state */
243348 fts5YYACTIONTYPE fts5yyact; /* The next action */
243882 int iInst; /* Next phrase instance index */
243891 ** Advance the iterator to the next coalesced phrase instance. Return
246280 /* Next method for this node. */
246482 int t; /* Next token type */
246895 i64 iLookahead; /* Next position */
247787 ** Move to the next document
248368 int iIn = 0; /* Next input in pColset */
248369 int iMerge = 0; /* Next input in pMerge */
248370 int iOut = 0; /* Next output slot in pColset */
249552 Fts5HashEntry *pHashNext; /* Next hash entry with same hash-key */
249553 Fts5HashEntry *pScanNext; /* Next entry in sorted order */
250176 ** Next, the record continues with three varints:
250219 ** doclist: next doclist
250228 ** poslist: next poslist
250478 ** origin value to apply to the next top-level segment created.
250500 u64 nOriginCntr; /* Origin value for next top-level segment */
250530 u8 bFirstRowidInDoclist; /* True if next rowid is first in doclist */
250531 u8 bFirstRowidInPage; /* True if next rowid is first in page */
250533 u8 bFirstTermInPage; /* True if next term will be first in leaf */
250541 Fts5Buffer btterm; /* Next term to insert into %_idx table */
250577 ** has been exhausted. Do not proceed to the next term in the segment.
250610 /* Next method */
250618 int iPgidxOff; /* Next offset in pgidx */
251607 ** the next populated level, then that segment, and any other adjacent
251895 ** Load the next leaf page into the segment iterator.
251899 Fts5SegIter *pIter /* Iterator to advance to next page */
252256 ** Advance iterator pIter to the next entry.
252289 ** Advance iterator pIter to the next entry.
252308 /* Next entry is on the next page */
252317 /* Next entry is on the current page */
252361 ** Advance iterator pIter to the next entry.
252390 /* The next entry is on the current page. */
252429 /* Next entry is not on the current page */
252693 /* Read the nKeep field of the next term. */
253444 ** Move the iterator to the next entry.
253616 ** start of the next columns hits. */
254158 ** Move the iterator to the next entry at or following iMatch.
254442 ** a copy of iRowid (which will become the first rowid on the next
254443 ** doclist-index leaf page) up into the next level of the b-tree
254512 /* Initialize the next page. */
255363 ** The offset of the next entry following the position list
255365 ** entry overflows onto the next leaf page, this value will be
255408 ** next page and beyond.
256195 PrefixMerger *pNext; /* Next in docid/poslist order */
257280 ** argument bFrom is false, then the iterator is advanced to the next
257565 ** Move to the next matching rowid.
257580 ** Move to the next matching term/rowid. Used by the fts5vocab module.
257602 ** Move to the next matching rowid that occurs at or after iMatch. The
259156 /* Read the term data for the next term*/
259427 ** Advance a bytecodevtab_cursor to its next row of output.
259733 Fts5Auxiliary *pNext; /* Next registered auxiliary function */
259763 Fts5TokenizerModule *pNext; /* Next registered tokenizer module */
259824 Fts5Cursor *pNext; /* Next cursor in Fts5Cursor.pCsr list */
259898 Fts5Auxdata *pNext; /* Next object in linked list */
260608 ** Advance the cursor to the next row in the table that matches the
265520 ** then the next token. */
266431 ** aBuf: Contains 3 characters. The 3 characters of the next trigram.
268160 next row in the table.
268539 StmtRow *pNext; /* Next row to return */
268658 ** Advance a stmt_cursor to its next row of output.
Indexes created Wed Jun 24 00:24:50 UTC 2026