Lines Matching defs:list
1239 ** over the list of options that were defined at compile time by
1798 ** A [file control opcodes | list of opcodes] less than 100 is available.
2287 ** Registered sqlite3_vfs objects are kept on a linked list formed by
2289 ** and [sqlite3_vfs_unregister()] interfaces manage this list
2291 ** searches the list. Neither the application code nor the VFS
5502 ** there may be gaps in the list.)^
7777 ** on the list of automatic extensions is a harmless no-op. ^No entry point
7792 ** unregistered and it returns 0 if X was not on the list of initialization
8094 ** table modules from database connection D except those named on list L.
8716 #define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */
13973 ** All elements of the hash table are on a single doubly-linked list.
13974 ** Hash.first points to the head of this list.
13977 ** the global doubly-linked list. The contents of the bucket are the
13978 ** element pointed to plus the next _ht.count-1 elements in the list.
13981 ** by a linear search of the global list. For small tables, the
13997 ** structure. All elements are stored on a single doubly-linked list.
15924 ** together near the beginning of the list.
16191 PgHdr *pDirty; /* Transient list of dirty sorted by pgno */
16205 PgHdr *pDirtyNext; /* Next element in list of dirty pages */
16206 PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */
16212 #define PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */
16213 #define PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */
16263 SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
16272 /* Get a list of all dirty pages in the cache, sorted by page number */
16826 ** the lookaside subsystem is stored on a linked list of LookasideSlot
16842 ** Lookaside buffers are initially held on the pInit list. As they are
16843 ** used and freed, they are added back to the pFree list. New allocations
16844 ** come off of pFree first, then pInit as a fallback. This dual-list
16847 ** allocations on the pInit list from the total number of allocations.
16880 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
17101 sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
17440 ** All current savepoints are stored in a linked list starting at
17441 ** sqlite3.pSavepoint. The first element in the list is the most recently
17442 ** opened savepoint. Savepoints are added to the list by the vdbe
17609 ** database schema are initially stored in a linked-list pointed to by
17612 ** table, it searches the list for the VTable that corresponds to the
17619 ** immediately. Instead, they are moved from the Table.pVTable list to
17620 ** another linked list headed by the sqlite3.pDisconnect member of the
17626 ** list without holding the corresponding sqlite3.mutex mutex.
17640 VTable *pNext; /* Next in linked list (see above) */
17658 FKey *pFKey; /* Linked list of all foreign keys in this table */
17661 /* ... also used as column name list in a VIEW */
17778 ** The list of all parents for child Table X is held at X.pFKey.
17780 ** A list of all children for a table named Z (which might not even exist)
18123 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
18332 ** A list of expressions. Each expression may optionally have a
18334 ** as the list of "expr AS ID" fields following a "SELECT" or in the
18335 ** list of "ID = expr" items in an UPDATE. A list of expressions can
18354 int nExpr; /* Number of expressions on the list */
18355 struct ExprList_item { /* For each expression in the list */
18371 } a[1]; /* One slot for each expression in the list */
18382 ** An instance of this structure can hold a simple list of identifiers,
18383 ** such as the list "a,b,c" in the following statements:
18389 ** The IdList.a.idx field is used when the IdList represents the list of
18401 int nId; /* Number of identifiers on the list */
18455 ** and the next table on the list. The parser builds the list this way.
18465 SrcItem a[1]; /* One entry for each identifier on the list */
18515 ** names. The context consists of a list of tables (the pSrcList) field and
18516 ** a list of named expression (pEList). The named expression list may
18531 ** NameContext list corresponds to searching through successively outer
18538 ExprList *pEList; /* Optional list of result-set columns */
18588 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
18598 Upsert *pNextUpsert; /* Next ON CONFLICT clause in the list */
18809 AutoincInfo *pNext; /* Next info block in a list of them all */
18818 ** statement. All such objects are stored in the linked list headed at
18825 ** The Parse.pTriggerPrg list never contains two entries with the same
18835 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
18885 ** list.
18986 TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */
19077 * 2. All triggers associated with a single table form a linked list, using the
19079 * linked list is stored as the "pTrigger" member of the associated
19082 * The "step_list" member points to the first element of a linked list
19092 IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
19093 the <column-list> is stored here */
19096 TriggerStep *step_list; /* Link list of trigger program steps */
19114 * Instances of struct TriggerStep are stored in a singly linked list (linked
19116 * associated struct Trigger instance. The first element of the linked list is
19143 * pExprList -> A list of the columns to update and the expressions to update
19161 TriggerStep *pNext; /* Next in the link-list */
19162 TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */
19442 ** (2) All window functions in a single SELECT form a linked-list
19447 ** object on a linked list attached to Select.pWinDefn.
19468 Window **ppThis; /* Pointer to this object in Select.pWin list */
21042 /* Elements of the linked list at Vdbe.pAuxData */
21139 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
21140 ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
21159 AuxData *pAuxData; /* Linked list of auxdata allocations */
21292 ** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed
21300 AuxData *pNextAux; /* Next element in list */
21347 ** string for a prepared statement. A linked list of these objects
21350 ** list is consulted for each double-quoted identifier to see if the
21355 DblquoteStr *pNextStr; /* Next string literal in the list */
21368 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
21428 int nFrame; /* Number of frames in pFrame list */
21430 SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
21431 AuxData *pAuxData; /* Linked list of auxdata allocations */
21770 ** Return the number of LookasideSlot elements on the linked list
23589 ** The list of all registered VFS implementations.
23596 ** first VFS on the list.
23620 ** Unlink a VFS from the linked list
24189 struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
24222 ** Head and tail of a linked list of all outstanding allocations
24734 ** The second block of free chunks is of the form u.list. The
24735 ** two fields form a double-linked list of chunks of related sizes.
24736 ** Pointers to the head of the list are stored in mem3.aiSmall[]
24753 } list;
24807 ** Unlink the chunk at mem3.aPool[i] from list it is currently
24808 ** on. *pRoot is the list that i is a member of.
24811 u32 next = mem3.aPool[i].u.list.next;
24812 u32 prev = mem3.aPool[i].u.list.prev;
24817 mem3.aPool[prev].u.list.next = next;
24820 mem3.aPool[next].u.list.prev = prev;
24822 mem3.aPool[i].u.list.next = 0;
24823 mem3.aPool[i].u.list.prev = 0;
24828 ** whatever list is currently a member of.
24847 ** Link the chunk at mem3.aPool[i] so that is on the list rooted
24852 mem3.aPool[i].u.list.next = *pRoot;
24853 mem3.aPool[i].u.list.prev = 0;
24855 mem3.aPool[*pRoot].u.list.prev = i;
24862 ** small chunk list, or into the large chunk hash table.
24963 ** *pRoot is the head of a list of free chunks of the same size
24967 ** This routine examines all entries on the given list and tries
24983 iNext = mem3.aPool[i].u.list.next;
24991 iNext = mem3.aPool[prev].u.list.next;
25044 for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
25296 for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
25305 for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
25473 ** Lists of free blocks. aiFreelist[0] is a list of free blocks of
25499 ** Unlink the chunk at mem5.aPool[i] from list it is currently
25522 ** free list.
29699 va_list ap; /* Vararg list */
30481 ** Generate a human-readable explanation of an expression list.
33161 ** the list
33345 HashElem *elem; /* Used to loop thru the element list */
33432 HashElem *elem; /* Used to loop thru the element list */
34764 ** structures on a linked list.
34767 struct vxworksFileId *pNext; /* Next in a list of them all */
34775 ** All unique filenames are held on a linked list headed by this
34823 ** and added to the global list if necessary.
34952 ** The unixInodeInfo structure keeps a list of file descriptors that need to
34953 ** be closed and that list is walked (and cleared) when the last lock
35164 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
35744 ** pUnused list.
36005 ** descriptor to pInode->pUnused list. It will be automatically closed
38276 ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
38509 ** left to do is to link the new object into the linked list starting
38747 ** in the following list than the lock being obtained are already held:
38754 ** occur later in the above list than the lock being obtained may be
45845 winShmNode *pNext; /* Next in list of all winShmNode objects */
45854 ** The winShmMutexHeld() must be true while reading or writing this list.
45937 ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
46107 ** left to do is to link the new object into the linked list starting
49343 ** All dirty pages are linked into the doubly linked list using
49344 ** PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order
49345 ** such that p was added to the list more recently than p->pDirtyNext.
49346 ** PCache.pDirty points to the first (newest) element in the list and
49353 ** to either the oldest page in the pDirty/pDirtyTail list that has a
49360 PgHdr *pSynced; /* Last synced page in dirty page list */
49433 assert( pCache->pDirty!=pPg ); /* CLEAN pages not on dirty list */
49465 #define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */
49466 #define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */
49467 #define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */
49470 ** Manage pPage's participation on the dirty list. Bits of the addRemove
49472 ** remove pPage from the dirty list. The 0x02 means add pPage back to
49473 ** the dirty list. Doing both moves pPage to the front of the dirty list.
49531 ** entries of the dirty-list for a page with NEED_SYNC clear anyway. */
49735 ** If the LRU page in the dirty list that has a clear PGHDR_NEED_SYNC
50036 ** Sort the list of pages in accending order by pgno. Pages are
50065 ** the input list. But that is impossible.
50079 ** Return a list of all dirty pages in the cache, sorted by page number.
50315 PgHdr1 *pLruNext; /* Next in LRU list of unpinned pages */
50316 PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */
50321 ** A page is pinned if it is not on the LRU list. To be "pinned" means
50355 PgHdr1 lru; /* The beginning and end of the LRU list */
50388 unsigned int nRecyclable; /* Number of pages in the LRU list */
50779 ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
50780 ** LRU list, then this function is a no-op.
51191 ** then attempt to recycle a page from the LRU list. If it is the right
51291 ** part of the PGroup LRU list.
51299 /* Add the page to the PGroup LRU list. */
51564 ** This same object is reused to store a linked list of trees of RowSetEntry
51566 ** in the list, pLeft points to the tree, and v is unused. The
51567 ** RowSet.pForest value points to the head of this forest list.
51571 struct RowSetEntry *pRight; /* Right subtree (larger entries) or list */
51578 ** chunks are kept on a linked list so that they can be deallocated
51582 struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */
51595 struct RowSetEntry *pLast; /* Last entry on the pEntry list */
51725 struct RowSetEntry *pA, /* First sorted list to be merged */
51726 struct RowSetEntry *pB /* Second sorted list to be merged */
51756 ** Sort all elements on the list of RowSetEntry objects into order of
51785 ** Convert this tree into a linked list connected by the pRight pointers
51786 ** and return pointers to the first and last elements of the new list.
51790 struct RowSetEntry **ppFirst, /* Write head of the output list here */
51791 struct RowSetEntry **ppLast /* Write tail of the output list here */
51811 ** Convert a sorted list of elements (connected by pRight) into a binary
51816 ** Use as many entries from the input list as required and update the
51817 ** *ppList to point to the unused elements of the list. If the input
51818 ** list contains too few elements, then construct an incomplete tree
51856 ** Convert a sorted list of elements into a binary tree. Make the tree
51857 ** as deep as it needs to be in order to contain the entire list.
51895 /* Merge the forest into a single sorted list on first call */
51903 /* Return the next entry on the list */
52812 sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
54544 ** if the page is on the free-list at the start of the transaction, then
55259 ** the contents of the list of pages headed by pList (connected by pDirty),
55263 ** The list of pages passed into this routine is always sorted by page number.
55264 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
55279 /* Verify that the page list is in accending order */
55290 ** list here. */
56193 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
56463 ** The argument is the first in a linked list of dirty pages connected
56465 ** in-memory pages in the list to the database file. The argument may
56466 ** be NULL, representing an empty list. In this case this function is
56479 ** the pages are written out to the database file in list order. Writing
57588 ** a) When reading a free-list leaf page from the database, and
58165 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
58711 ** last page in the db image moved to the free-list. In this case the
61376 ** This function merges two sorted lists into a single sorted list.
61400 ht_slot *aLeft, /* IN: Left hand input list */
61402 ht_slot **paRight, /* IN/OUT: Right hand input list */
61439 ** Sort the elements in list aList using aContent[] as the sort key.
61463 ht_slot *aList; /* Pointer to sub-list content */
61466 const int nList = *pnList; /* Size of input list */
61467 int nMerge = 0; /* Number of elements in list aMerge */
61469 int iList; /* Index into input list */
63368 PgHdr *pLast = 0; /* Last frame in list */
64082 ** Unused space within the cell content area is collected into a linked list of
64128 ** Overflow pages form a linked list. Each page except the last is completely
64137 ** file header points to the first in a linked list of trunk page. Each trunk
64236 ** A linked list of the following structures is stored at BtShared.pLock.
64239 ** from this list when a transaction is committed or rolled back, or when
64246 BtLock *pNext; /* Next in BtShared.pLock list */
64285 Btree *pPrev; /* Back pointer of the same list */
64357 BtCursor *pCursor; /* A list of all open cursors */
64380 Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
64383 BtShared *pNext; /* Next on a list of sharable BtShared structs */
64469 BtCursor *pNext; /* Forms a linked list of all cursors */
64573 ** PTRMAP_OVERFLOW1: The database page is the first page in a list of
64577 ** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of
64579 ** page in the overflow page list.
64709 ** by all database connections. The p->pNext is a list of other
64717 /* Some basic sanity checking on the Btree. The list of Btrees
64719 ** Btree.pBt value. All elements of the list should belong to
64720 ** the same connection. Only shared Btrees are on the list. */
65023 ** A list of BtShared objects that are eligible for participation
65057 ** manipulate entries in the BtShared.pLock linked list used to store
65336 /* First search the list for an existing lock on this table. */
65345 ** with table iTable, allocate one and link it into the list.
65474 ** Invalidate the overflow page-list cache for all cursors opened
65526 ** when a page that previously contained data becomes a free-list leaf
65531 ** free-list leaf pages:
65534 ** a free-list leaf page, the page is not written to the database
65535 ** (as free-list leaf pages contain no meaningful data). Sometimes
65539 ** 2) When a free-list leaf page is reused, its content is not read
65545 ** a page is moved to the free-list and then reused within the same
65547 ** it is moved to the free-list and it is also not journalled when it
65548 ** is extracted from the free-list and reused, then the original data
65553 ** moved to become a free-list leaf page, the corresponding bit is
65554 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
65577 ** This function is called when a free-list leaf page is removed from the
65578 ** free-list for reuse. It returns false if it is safe to retrieve the
66383 ** page so that there are no free-blocks on the free-block list.
66516 ** Search the free-list on page pPg for space to store a cell nByte bytes in
66518 ** from the free-list.
66520 ** If no suitable space can be found on the free-list, return NULL.
66525 ** Slots on the free list that are between 1 and 3 bytes larger than nByte
66552 /* Remove the slot from the free-list. Update the number of
66561 /* The slot remains on the free-list. Reduce its size to account
66687 ** Even though the freeblock list was checked by btreeComputeFreeSpace(),
66711 /* The list of freeblocks must be in ascending order. Find the
66712 ** spot on the list where iStart should be inserted.
67523 /* Add the new BtShared object to the linked list sharable BtShareds.
67546 ** Btree into the list of all sharable Btrees for the same connection.
67547 ** The list is kept in ascending order by pBt address.
67611 ** remove the BtShared structure from the sharing list. Return
67727 /* The pBt is no longer on the sharing list, so we can access
68586 ** overflow page in the list.
68744 Pgno nFreeList; /* Number of pages still on the free-list */
68769 /* Remove the page from the files free-list. This is not required
68770 ** if bCommit is non-zero. In that case, the free-list will be
68795 ** is swapped with the first free page pulled off the free list.
69406 ** variables and link the cursor into the BtShared list. */
69645 ** linked list of overflow pages. If possible, it uses the auto-vacuum
69650 ** The page number of the next overflow page in the linked list is
69652 ** list, *pPgnoNext is set to zero.
69675 /* Try to find the next page in the overflow list using the
69677 ** the overflow list is page number (ovfl+1). If that guess turns
69766 ** the overflow page-list cache array (BtCursor.aOverflow).
69770 ** Once an overflow page-list cache has been allocated, it must be
69773 ** mode, the following events may invalidate an overflow page-list cache.
69860 /* If the overflow page-list cache has been allocated and the
69873 /* If required, populate the overflow page-list cache. */
69884 ** page-list cache, if any, then fall back to the getOverflowPage()
70908 ** anywhere on the free-list, then it is guaranteed to be returned. If
70942 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
70946 ** shows that the page 'nearby' is somewhere on the free-list, then
70947 ** the entire-list will be searched for that page.
70966 /* Decrement the free-list count by 1. Set iTrunk to the index of the
70967 ** first free-list trunk page. iPrevTrunk is initially 1.
70975 ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT)
70982 ** is the page number of the next freelist trunk page in the list or
71007 /* The trunk has no leaves and the list is not being searched.
71028 /* The list is being searched and this trunk page is the page
71050 ** pointers to free-list leaves. The first leaf becomes a trunk
71224 ** This function is used to add page iPage to the database file free-list.
71225 ** It is assumed that the page is not already a part of the free-list.
71236 MemPage *pTrunk = 0; /* Free-list trunk page */
71237 Pgno iTrunk = 0; /* Page number of free-list trunk page */
71241 u32 nFree; /* Initial number of pages on free-list */
71283 /* Now manipulate the actual database free-list structure. There are two
71284 ** possibilities. If the free-list is currently empty, or if the first
71285 ** trunk page in the free-list is full, then this page will become a
71286 ** new free-list trunk page. Otherwise, it will become a leaf of the
71287 ** first trunk page in the current free-list. This block tests if it
71288 ** is possible to add the page as a new free-list leaf.
71344 ** the page being freed as a leaf page of the first trunk in the free-list.
71345 ** Possibly because the free-list is empty, or possibly because the
71346 ** first trunk in the free-list is full. Either way, the page being freed
71347 ** will become the new first trunk page in the free-list.
72091 ** that is currently stored within the body of pPg to the pPg free-list.
72094 ** This function returns the total number of cells added to the free-list.
73836 ** the leftover space to the free list. But experiments show that
74532 ** number in the database, put the root page on the free list.
74851 ** Check the integrity of the freelist or of an overflow page list.
74852 ** Verify that the number of pages on the list is N.
74856 int isFreeList, /* True for a freelist. False for overflow page list */
74857 Pgno iPage, /* Page number for first page in the list */
74858 u32 N /* Expected number of pages in the list */
74900 ** page in this overflow list, check that the pointer-map entry for
74915 isFreeList ? "size" : "overflow list length",
75118 /* Check the content overflow list */
75257 ** If the first entry in aRoot[] is 0, that indicates that the list of
76271 sqlite3_backup **pp; /* Ptr to head of pagers backup list */
78459 ** Add a new element to the Vdbe->pDblStr list.
78590 ** Add a new instruction to the list of instructions current in the
78899 ** through its operation list and change all values of P2 which match
79178 /* Only JUMP opcodes and the short list of special opcodes in the switch
79180 ** all these opcodes together near the front of the opcode list. Skip
79341 ** Add a whole list of operations to the operation stack. Return a
79562 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
80320 ** frame to a list of frames to be deleted when the Vdbe halts.
81265 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
81807 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
84702 ** select list of a SELECT statement) that may cause a malloc() failure. If
86577 ** linked list starting at sqlite3.pSavepoint.
89255 /* Link the new savepoint into the database handle's list. */
94913 typedef struct SorterList SorterList; /* In-memory list of records */
94926 ** An in-memory list of objects to be sorted.
94934 SorterRecord *pList; /* Linked list of records */
95047 SorterList list; /* List for thread to write to a PMA */
95074 SorterList list; /* List of in-memory records */
95075 int iMemory; /* Offset of free space in list.aMemory */
95076 int nMemory; /* Size of list.aMemory allocation in bytes */
95175 ** How the linked list is connected depends on how memory is being managed
95177 ** (VdbeSorter.list.aMemory==0), then the list is always connected using the
95180 ** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0),
95181 ** then while records are being accumulated the list is linked using the
95185 ** is full, the list is sorted. As part of the sorting process, it is
95192 SorterRecord *pNext; /* Pointer to next record in list */
95760 pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz);
95761 if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT;
95778 ** Free the list of sorted records starting at pRecord.
95796 /* pTask->list.aMemory can only be non-zero if it was handed memory
95798 if( pTask->list.aMemory ){
95799 sqlite3_free(pTask->list.aMemory);
95803 assert( pTask->list.aMemory==0 );
95804 vdbeSorterRecordFree(0, pTask->list.pList);
95994 if( pSorter->list.aMemory==0 ){
95995 vdbeSorterRecordFree(0, pSorter->list.pList);
95997 pSorter->list.pList = 0;
95998 pSorter->list.szPMA = 0;
96015 sqlite3_free(pSorter->list.aMemory);
96089 ** Merge the two sorted lists p1 and p2 into a single list.
96093 SorterRecord *p1, /* First list to merge */
96094 SorterRecord *p2 /* Second list to merge */
96143 ** Sort the linked list of records headed at pTask->pList. Return
96280 ** Write the current contents of in-memory linked-list pList to a level-0
96321 /* Sort the list */
96432 rc = vdbeSorterListToPMA(pTask, &pTask->list);
96439 ** Flush the current contents of VdbeSorter.list to a new PMA, possibly
96445 return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list);
96456 /* Select a sub-task to sort and flush the current list of in-memory
96476 rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list);
96484 assert( pTask->list.pList==0 );
96485 assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
96487 aMem = pTask->list.aMemory;
96490 pTask->list = pSorter->list;
96491 pSorter->list.pList = 0;
96492 pSorter->list.szPMA = 0;
96494 pSorter->list.aMemory = aMem;
96496 }else if( pSorter->list.aMemory ){
96497 pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory);
96498 if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT;
96518 SorterRecord *pNew; /* New list element */
96547 ** * The total memory allocated for the in-memory list is greater
96550 ** * The total memory allocated for the in-memory list is greater
96556 if( pSorter->list.aMemory ){
96560 (pSorter->list.szPMA > pSorter->mxPmaSize)
96561 || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull())
96566 pSorter->list.szPMA = 0;
96568 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
96572 pSorter->list.szPMA += nPMA;
96577 if( pSorter->list.aMemory ){
96584 if( pSorter->list.pList ){
96585 iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
96590 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
96593 pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
96595 pSorter->list.aMemory = aNew;
96599 pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
96601 if( pSorter->list.pList ){
96602 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
96609 pNew->u.pNext = pSorter->list.pList;
96614 pSorter->list.pList = pNew;
97335 ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly
97336 ** from the in-memory list. */
97338 if( pSorter->list.pList ){
97340 rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list);
97347 /* Write the current in-memory list to a PMA. When the VdbeSorterWrite()
97349 ** creates a new list consisting of a single key immediately afterwards.
97350 ** So the list is never empty at this point. */
97351 assert( pSorter->list.pList );
97403 SorterRecord *pFree = pSorter->list.pList;
97404 pSorter->list.pList = pFree->u.pNext;
97406 if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree);
97407 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
97434 *pnKey = pSorter->list.pList->nVal;
97435 pKey = SRVAL(pSorter->list.pList);
97974 ** The rollback journal is composed of a linked list of these structures.
98013 FileChunk *pFirst; /* Head of in-memory chunk-list */
98071 ** Free the list of FileChunk structures headed at MemJournal.pFirst.
98399 ** Walk all expressions linked into the list of Window objects passed
98483 ** Call sqlite3WalkExpr() for every expression in list p or until
98877 NameContext *pTopNC = pNC; /* First namecontext in the list */
99516 ExprList *pList = pExpr->x.pList; /* The argument list */
99821 ** pEList is a list of expressions which are really the result set of the
99824 ** to the AS-name of one of the terms of the expression list. If it is,
100108 ** Select.pWin list of Select object pSelect.
100192 ** objects belonging to the expression from the Select.pWin list. */
100296 ** resolve the result-set expression list.
100325 /* Add the output column list to the name-context before parsing the
100418 ** number of expressions in the select list. */
100523 ** Resolve all names for all expression in an expression list. This is
100525 ** list rather than a single expression.
100529 ExprList *pList /* The expression list to be analyzed. */
100621 ExprList *pList /* Expression list to resolve. May be NULL. */
101627 ExprList *pList, /* Argument list */
101820 ** pExpr to the pParse->pConstExpr list with a register number of 0.
102090 ** objects found there, assembling them onto the linked list at Select->pWin.
102124 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
102307 ** Add a new element to the end of an expression list. If pList is
102308 ** initially NULL, then create a new expression list.
102317 ** If a memory allocation error occurs, the entire list is freed and
102366 ** expression list pList. In the case of a subquery on the RHS, append
102465 ** on the expression list.
102500 ** on the expression list.
102525 ** If the expression list pEList contains more than iLimit elements,
102542 ** Delete an entire expression list.
102794 ** can be added to the pParse->pConstExpr list and evaluated once when
103110 ** The argument is an IN operator with a list (not a subquery) on the
103111 ** right-hand side. Return TRUE if that list is constant.
103128 ** might be either a list of expressions or a subquery.
103152 ** If the RHS of the IN operator is a list or a more complex subquery, then
103175 ** if the RHS of the IN operator is a list (not a subquery) then this
103377 ** and the RHS of the IN operator is a list, not a subquery
103497 ** x IN (4,5,11) -- IN operator with list on right-hand side
103533 ** * The right-hand side is an expression list containing variables
103722 ** * The right-hand side is an expression list containing variables
103843 ** a list of values, the LHS must be a scalar.
105367 ** expression list into a sequence of registers beginning at target.
105379 ** The SQLITE_ECEL_REF flag means that expressions in the list with
105387 ExprList *pList, /* The expression list to be coded */
105496 ** it into the Parse.pConstExpr list. We should use a new bit for this,
106667 ** expression list. Return the number of errors.
107415 ** A list of RenameToken objects can be constructed during parsing.
107427 RenameToken *pNext; /* Next is a list of all RenameToken objects */
107448 ** rename-token list.
107450 ** 2. Dereferences each pointer in the rename-token list.
107488 ** to the list of RenameToken objects currently being built up
107602 ** Remove all nodes that are part of expression pExpr from the rename list.
107617 ** Remove all nodes that are part of expression-list pEList from the
107618 ** rename list.
107637 ** Free the list of RenameToken objects given in the second argument
107655 ** the list maintained by the RenameCtx object.
107696 ** RenameToken object to the list of RenameToken objects being
107716 ** The RenameCtx contains a list of tokens that reference a column that
107765 ** For each name in the the expression-list pEList (i.e. each
107791 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
107853 /* Ensure that all mappings in the Parse.pRename list really do map to
107871 ** by the linked list pRename with the text of zNew. If argument bQuote is
107909 /* At this point pRename->pList contains a list of RenameToken objects
108813 ** a string consisting of a list of integers. The first integer in this
108814 ** list is the number of rows in the index. (This is the same as the
108824 ** The list of integers in the stat column can optionally be followed
108878 ** list of integers. The first integer is the approximate number
108883 ** And so forth. nLt is another list of integers that show the approximate
109604 ** The value is a string composed of a list of integers describing
109605 ** the index. The first integer in the list is the total number of
109606 ** entries in the index. There is one additional integer in the list
110239 ** list of space separated integers. Read the first nOut of these into
111249 SrcList *pList /* The Source list to check and modify */
111816 ** The pConstExpr list might also contain expressions that we simply
111900 ** list of users and their access credentials.
112137 /* Justification of ALWAYS(); The index must be on the list of
112151 ** Look through the list of open database files in db->aDb[] and if
112152 ** any have been closed, remove them from the list. Reallocate the
113213 ** Designate the PRIMARY KEY for the table. pList is a list of names
114263 ExprList *pCNames, /* Optional list of view column names */
114424 ** a VIEW it holds the list of column names.
114436 /* CREATE VIEW name AS... without an argument list. Construct
114581 ** a free-list page.
114848 ** the table referred to (a.k.a the "parent" table). pToCol is a list
115145 ** If expression list pList contains an expression that was parsed with
115173 ** pList is a list of columns to be indexed. pList will be NULL if this
115182 ExprList *pList, /* A list of columns to be indexed */
115369 ** So create a fake list to simulate this.
115434 /* Analyze the list of expressions that form the terms of the index and
115732 /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
115733 ** The list was already ordered when this routine was entered, so at this
115751 ** of the index list. In other words, no other index type ever
115752 ** comes after a REPLACE index on the list. */
116257 ** element of the source-list passed as the second argument.
116300 ** Add the list of function arguments to the SrcList entry for a
116808 ExprList *pArglist, /* Optional column name list for the table */
117267 int nDef /* Length of the apDef[] list */
117606 ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */
119079 ** [...] Matches one character from the enclosed list of
119082 ** [^...] Matches one character not in the enclosed list.
119085 ** in the list by making it the first character after '[' or '^'. A
119088 ** it the last character in the list.
120959 ** map to an explicit list of columns in table pParent. Check if this
121379 ** This function returns a linked list of FKey objects (connected by
121879 ** passed a pointer to the list of columns being modified. If it is a
121908 ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */
121928 ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */
122099 ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */
122702 ** then a list of all (non-hidden) columns for the table is substituted.
122843 /* If the Select object is really just a simple VALUES() list with a
123266 /* A column not named in the insert column list gets its
123584 ** the indexes of a table in the order provided in the Table->pIndex list.
123596 int eType; /* 0 for Index.pNext list. 1 for an array of IndexListTerm */
123597 int i; /* Index of the current item from the list */
123599 struct { /* Use this object for eType==0: A Index.pNext list */
123614 int ix; /* Which entry in the original Table.pIndex list is this index*/
123617 /* Return the first index on the list */
123629 /* Return the next index from the list. Return NULL when out of indexes */
123678 ** the same as the order of indices on the linked list of indices
123694 ** for the first index in the pTab->pIndex list. Cursors for other indices
123695 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
123971 ** list of indexes attached to a table puts all OE_Replace indexes last
123972 ** in the list. See sqlite3CreateIndex() for where that happens.
124046 ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
124643 /* All REPLACE indexes are at the end of the list */
124702 ** pTab->pIndex list.
126728 ** The following object holds the list of automatically loaded
126731 ** This list is shared across threads. The SQLITE_MUTEX_STATIC_MAIN
126732 ** mutex must be held while accessing this list.
126801 ** is currently on the list. If xInit is not on the list, then this
126804 ** Return 1 if xInit was found on the list and removed. Return 0 if xInit
126805 ** was not on the list.
131950 ** output variable (*ppExtra) is set to an expression list containing
132511 ** Given an expression list, generate a KeyInfo structure that records
132512 ** the collating sequence for each expression in that expression list.
133105 ** Given an expression list (which is really the list of expressions
133107 ** column names for a table that would hold the expression list.
133128 ExprList *pEList, /* Expr list from which to derive column names */
133130 Column **paCol /* Write the new column list here */
133220 ** Add type and collation information to a column list based on
133223 ** The column list presumably came from selectColumnNamesFromExprList().
133224 ** The column list has only names, not types or collations. This
135037 ** function in the select list or ORDER BY clause, flattening
135230 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
135925 ** If the source-list item passed as an argument was augmented with an
136047 ** Argument pWith (which may be NULL) points to a linked list of nested
136104 ** pParse->pWith linked list). And if currently processing a CTE
136342 ** (4) Scan the list of columns in the result set (pEList) looking
136465 /* For every "*" that occurs in the column list, insert the names of
136469 ** list. The following code just has to locate the TK_ASTERISK
136470 ** expressions and expand each one to the list of all columns in
136555 ** result-set list unless the SELECT has the SF_IncludeHidden
137606 ** if the select-list is the same as the ORDER BY list, then this query
137790 struct ExprList_item *pItem; /* For looping over expression in a list */
138539 ** Delete a linked list of TriggerStep structures.
138559 ** Given table pTab, return a list of all the triggers attached to
138560 ** the table. The list is connected by Trigger.pNext pointers.
138565 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
138566 ** and returns the combined list.
138568 ** To state it another way: This routine returns a list of all triggers
138569 ** that fire off of pTab. The list will include any TEMP triggers on
138622 IdList *pColumns, /* column list if this is an UPDATE OF trigger */
139030 ExprList *pEList, /* The SET clause: list of column and new values */
139243 ** Return a list of all triggers on table pTab if there exists at least
139350 ** list is of the form "*". Raise an error if the terms if of the
139367 /* The input list pList is the list of result set terms from a RETURNING
139618 ** list of the top-level Parse object sooner rather than later. */
139726 ** in the Parse.pTriggerPrg list. Search for such an entry. */
139783 ** parameter pChanges is passed the list of columns being modified.
139822 ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
139829 Trigger *p; /* Used to iterate through pTrigger list */
139891 ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
140062 ** table in the source-list (pSrc->a[0]).
140299 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
141268 ** Free a list of Upsert objects
141310 Upsert *pNext /* Next ON CONFLICT clause in the list */
141360 ** includes both the list of columns and the optional partial-index
141477 ** Given the list of ON CONFLICT clauses described by pUpsert, and
142112 ** on the azNames list.
142197 ** p->pVTable list to the sqlite3.pDisconnect lists of their associated
142200 ** connection db is left in the p->pVTable list.
142210 ** this makes it safe to access the sqlite3.pDisconnect list of any
142211 ** database connection that may have an entry in the p->pVTable list.
142237 ** list in p->pVTab. It also decrements the VTable ref count. This is
142261 ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
142265 ** caller. This is done to protect the sqlite3.pDisconnect list. The
142266 ** sqlite3.pDisconnect list is accessed only as follows:
142272 ** the sqlite3.pDisconnect list. In this case either the BtShared mutex
142303 ** to the head of a linked list of VTable structures. Each VTable
142308 ** in the list are moved to the sqlite3.pDisconnect list of the associated
142348 ** statement. The module name has been parsed, but the optional list
142396 ** in pParse->zArg[] and appends it to the list of arguments on the
142606 ** into the linked list headed by pTab->pVTable. Then loop through the
143757 WhereExprMod *pNext; /* Next translation on a list of them all */
143827 SrcList *pTabList, /* Table list this loop refers to */
144030 SrcList *pTabList, /* Table list this loop refers to */
145038 ** Preserve pExpr on the WhereETrans list of the WhereInfo.
145967 SrcList *pOrTab; /* Shortened table list or OR-clause generation */
145995 SrcItem *origSrc; /* Original list of tables */
148792 ExprList *pList, /* Expression list to search */
148837 ** Return true if the DISTINCT expression-list passed as the third argument
148840 ** A DISTINCT list is redundant if any subset of the columns in the
148841 ** DISTINCT list are collectively unique and individually non-null.
148877 ** list, or else the WHERE clause contains a term of the form "col=X",
148879 ** comparison and select-list expressions must match those of the index.
150035 ** is a list of values. Example:
150051 ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */
150375 ** Search the list of WhereLoops in *ppPrev looking for one that can be
150378 ** Return NULL if pTemplate does not belong on the WhereLoop list.
150384 ** If pTemplate cannot replace any existing element of the list but needs
150385 ** to be added to the list as a new entry, then return a pointer to the
150386 ** tail of the list.
150518 /* There already exists a WhereLoop on the list that is better
150548 /* Allocate a new WhereLoop to add to the end of the list */
150555 ** go through the rest of the list and delete any other entries besides
152352 ** the planner assumes that the specified pOrderBy list is actually a GROUP
152438 ** Given the list of WhereLoop objects at pWInfo->pLoops, this routine
153058 SrcList *pTabList, /* FROM clause: A list of all tables to be scanned */
153958 ** either the select list or ORDER BY clause (the only two places window
153986 ** select-list and ORDER BY expressions in the parent query are
154582 ** linked list of WINDOW definitions for the current SELECT statement.
154588 ** search list pList for a matching WINDOW definition, and update pWin
154682 ** this function appends to the output expression-list and updates
154781 ** Iterate through each expression in expression-list pEList. For each:
154786 ** Window list passed as the second argument (pWin).
154788 ** Append the node to output expression-list (*ppSub). And replace it
154797 ExprList *pEList, /* Rewrite expressions in this list */
154799 ExprList **ppSub /* IN/OUT: Sub-select expression-list */
154824 ** Append a copy of each expression in expression-list pAppend to
154825 ** expression list pList. Return a pointer to the result list.
154894 ExprList *pSublist = 0; /* Expression list for sub-query */
154942 ** sub-select expression list. They are required to figure out where
154948 ** sub-select expression list. Also allocate two registers for each
155058 ** Free the linked list of Window objects starting at the second argument.
155114 ** starting boundary type may not occur earlier in the following list than
155182 ** stored in the linked list starting at pWin->pNextWin. This function
155238 ** Possibly link window pWin into the list at pSel->pWin (window functions
155451 ** in the WindowCodeArg.pMWin list.
155498 Window *pMWin; /* First in list of functions being processed */
155535 ** linked list starting at pMWin. Or, for built-in window functions
155553 Window *pMWin, /* Linked list of window functions */
155661 ** (bFin==1) for each window function in the linked list starting at
155700 ** p->pMWin list by doing a full scan of the current window frame. Store the
155882 ** in the linked list passed as the second argument to NULL. And perform
155884 ** in the list.
156289 ** Return a copy of the linked list of Window objects passed as the
157059 ** Then the "b" IdList records the list "a,b,c".
157099 ** all elements in the list. And make sure list length does not exceed
157193 ** list of identifiers. Report an error if the ID list contains
161135 sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy338,"set list");
168767 ** Head of a linked list of all sqlite3 objects created by this process
168777 ** properties of the blocked connections list:
168779 ** 1) Each entry in the list has a non-NULL value for either
168782 ** 2) All entries in the list that share a common value for
168786 ** blocked connections list have pUnlockConnection or pBlockingConnection
168812 ** Remove connection db from the blocked connections list. If connection
168813 ** db is not currently a part of the list, this function is a no-op.
168827 ** Add connection db to the blocked connections list. It is assumed
168828 ** that it is not already a part of the list.
168945 ** list and does the following:
168947 ** 1) If the sqlite3.pBlockingConnection member of a list entry is
168950 ** 2) If the sqlite3.pUnlockConnection member of a list entry is
168956 ** list.
168969 /* This loop runs once for each entry in the blocked-connections list. */
169038 /* Remove connection p from the blocked connections list. */
169055 ** being closed. The connection is removed from the blocked list.
169128 ** A doclist (document list) holds a docid-sorted list of hits for a
169141 ** array { (position list for column 0)
169145 ** varint POS_COLUMN; (marks start of position list for new column)
169158 ** ending a position list array. POS_END is 0. POS_COLUMN is 1.
169174 ** A "position-list" is the list of positions for multiple columns for
169175 ** a single docid. A "column-list" is the set of positions for a single
169176 ** column. Hence, a position-list consists of one or more column-lists,
169177 ** a document record consists of a docid followed by a position-list and
169616 ** structure. All elements are stored on a single doubly-linked list.
169769 #define POS_COLUMN (1) /* Column-list terminator */
169770 #define POS_END (0) /* Position-list terminator */
170033 char *pList; /* Pointer to position list following iDocid */
170034 int nList; /* Length of position list */
170504 ** varint that is part of a doclist (or position-list, or any other list
170647 /* Create a list of user columns for the virtual table */
170700 /* Create a list of user columns for the content table */
170868 ** Return a list of comma separated SQL expressions and a FROM clause that
170871 ** SELECT <list of expressions> FROM %_content AS x ...
170928 ** Return a list of N comma separated question marks, where N is the number
172068 ** varints. Each call to this function appends a single varint to a list.
172072 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
172073 sqlite3_int64 iVal /* Write this value to the list */
172082 ** start of a position-list. After it returns, *ppPoslist points to the
172083 ** first byte after the position-list.
172085 ** A position list is list of positions (delta encoded) and columns for
172090 ** If pp is not NULL, then the contents of the position list are copied
172098 /* The end of a position list is marked by a zero encoded as an FTS3
172106 ** last byte in the position-list.
172126 ** start of a column-list. After it returns, *ppPoslist points to the
172127 ** to the terminator (POS_COLUMN or POS_END) byte of the column-list.
172129 ** A column-list is list of delta-encoded positions for a single column
172132 ** The column-list is terminated either by a POS_COLUMN varint (1) or
172134 ** the POS_COLUMN or POS_END that terminates the column-list.
172136 ** If pp is not NULL, then the contents of the column-list are copied
172145 /* A column-list is terminated by either a 0x01 or 0x00 byte that is
172163 ** Value used to signify the end of an position-list. This must be
172165 ** position-list, even a position list that has been corrupted.
172171 ** called, *pp may point to the start of the next varint in the position-list
172172 ** being parsed, or it may point to 1 byte past the end of the position-list
172176 ** If *pp points past the end of the current position-list, set *pi to
172183 ** in the position-list. Because positions are delta-encoded, the value
172188 char **pp, /* IN/OUT: Pointer into position-list buffer */
172189 sqlite3_int64 *pi /* IN/OUT: Value read from position-list */
172204 ** column list.
172230 char **pp1, /* Left input list */
172231 char **pp2 /* Right input list */
172265 ** A column-list is a list of non-negative delta-encoded varints, each
172266 ** incremented by 2 before being stored. Each list is terminated by a
172269 ** after the list written. No terminator (POS_END or POS_COLUMN) is
172307 ** called, *pp1 and *pp2 must both point to position lists. A position-list is
172313 ** Then the position list for this row for token 'b' would consist of:
172320 ** If isSaveLeft is 0, an entry is added to the output position list for
172333 char **pp1, /* IN/OUT: Left input list */
172334 char **pp2 /* IN/OUT: Right input list */
172408 ** end of the position list, or the 0x01 that precedes the next
172409 ** column-number in the position list.
172443 ** Position list *pp1 corresponds to the left-hand side of the NEAR
172448 ** The output position list - written to *pp - is a copy of *pp2 with those
172456 char **pp1, /* IN/OUT: Left input list */
172457 char **pp2 /* IN/OUT: Right input list */
172546 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
172548 sqlite3_int64 iVal /* Write this value to the list */
172615 ** then the first docid in each list is simply encoded as a varint. For
172617 ** current and previous docid (a positive number - since the list is in
172622 ** read from. And each subsequent docid read from the same input list
172626 ** the input list). The same argument applies to all but the first docid
172627 ** read from the 'other' list. And to the contents of all position lists
172631 ** then the encoding of the first docid from the 'other' input list may
172758 ** Argument pList points to a position list nList bytes in size. This
172759 ** function checks to see if the position list contains any entries for
172761 ** to the output buffer pOut, followed by a position list consisting only
172767 char *pList, /* Position list (no 0x00 term) */
173219 ** contains a position-list following each docid. Otherwise, it is assumed
173220 ** that the doclist is simply a list of docids stored as delta encoded
173231 fts3PoslistCopy(0, &p); /* Skip over position list */
173634 ** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function
173636 ** same position list.
174289 ** current position list to include only those positions that are really
174298 char *aPoslist = 0; /* Position list for deferred tokens */
174590 ** list for document pDL->iDocid. However, if this position-list was
175164 ** Invalidate the current position list for phrase pPhrase.
175176 ** This function is called to edit the position list associated with
175184 ** the position list, and *pnToken is the number of phrase tokens in the
175187 ** the position list associated with phrase "abc".
175189 ** All positions in the pPhrase position list that are not sufficiently
175190 ** close to a position in the *paPoslist position list are removed. If this
175200 char **paPoslist, /* IN/OUT: Position list */
175246 ** at EOF, then the following variables are populated with the position list
175250 ** FTs3Expr.pPhrase->doclist.pList (pointer to position list)
175257 ** the db. In this case the position-list is not populated at all.
175264 ** where "*" may match any single token. The position list in this case
175409 ** If the current row is a match, the position list associated with each
175618 ** memory and scan it to determine the position list for each deferred
175722 ** the values in Fts3Expr.aMI[] according to the position-list currently
175914 ** a position-list indicating the occurrences of the phrase in column iCol
175920 ** if the requested column contains "a b X c d X X" and the position-list
175931 int iCol, /* Column to return position list for */
175932 char **ppOut /* OUT: Pointer to position list */
176420 ** start of a position list for column 0.
177530 /* Link pParent into the free node list. It will be used as an
177559 ** and pFree list. Everything else is cleaned up by the call to
178181 Fts3HashElem *elem; /* Used to loop thru the element list */
178288 Fts3HashElem *elem; /* Used to loop thru the element list */
179254 ** list. For each token in the <input-string>, three elements are
179255 ** added to the returned list. The first is the token position, the
180336 ** Each cursor has a (possibly empty) linked list of the following objects.
180341 Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
180600 ** Return the list of valid segment indexes for absolute level ? */
180897 /* Append the new serialized varint to the end of the list. */
181088 ** fts3PendingTermsAdd() are to add term/position-list pairs for the
181683 ** *ppOffsetList is set to point to the first column-offset list
181691 char **ppOffsetList, /* OUT: Pointer to current position-list */
181721 /* Pointer p currently points at the first byte of an offset list. The
181723 ** the same offset list. */
181742 ** size of the previous offset-list.
181754 ** Fts3SegReader.pOffsetList to point to the next offset list before
182131 /* Check that the list really is sorted now. */
182827 ** a position list that may (or may not) feature multiple columns. This
182829 ** identify the subset of the position list that corresponds to column iCol.
182831 ** If there are no entries in the input position list for column iCol, then
182834 ** If parameter bZero is non-zero, then any part of the input list following
182835 ** the end of the output list is zeroed before returning.
182840 char **ppList, /* IN/OUT: Pointer to position list */
182904 char **paPoslist, /* OUT: Pointer to position list */
182905 int *pnPoslist /* OUT: Size of position list in bytes */
183124 ** forward. Then sort the list in order of current term again.
185679 ** Free all entries in the pCsr->pDeffered list. Entries are added to
185680 ** this list using sqlite3Fts3DeferToken().
185694 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
185782 ** Add an entry for token pToken to the pCsr->pDeferred list.
186094 char *pList; /* Pointer to start of phrase position list */
186095 int iHead; /* Next value in position list */
186096 char *pHead; /* Position list data following iHead */
186097 int iTail; /* Next value in trailing position list */
186098 char *pTail; /* Position list data following iTail */
186243 ** This function is used to help iterate through a position-list. A position
186244 ** list is a list of unique integers, sorted from smallest to largest. Each
186245 ** element of the list is represented by an FTS3 varint that takes the value
186247 ** two. For example, to store the position-list:
186258 ** the list. *piPos contains the value of the previous entry in the list.
186260 ** list and *pp is advanced to the following varint.
186367 ** Advance the position list iterator specified by the first two
186857 ** This function is used to count the entries in a column-list (a
186858 ** delta-encoded list of term offsets within a single column of a single
186860 ** beginning of the first varint in the column-list (the varint that
186863 ** the last varint in the column-list (either the 0x00 signifying the end
186864 ** of the position-list, or the 0x01 that precedes the column number of
186865 ** the next column in the position-list).
186867 ** The number of elements in the column-list is returned.
186874 /* A column-list is terminated by either a 0x01 or 0x00. */
187102 ** iterating through a multi-column position-list corresponding to the
187133 ** position list for the next column.
187566 char *pList; /* Position-list */
187586 char *pList; /* Pointer to position list for phrase */
187587 int iPos = 0; /* First position in position-list */
193964 ** the Rtree.pDeleted list. Its contents will be re-inserted later on.
195029 ** The human readable string takes the form of a Tcl list with one
195031 ** list, containing the 8-byte rowid/pageno followed by the
196441 GeoEvent *pNext; /* Next event in the sorted list */
196449 GeoSegment *pNext; /* Next segment in a list sorted by y */
196543 ** Sort an array of nEvent event objects into a list.
196592 ** Sort a list of GeoSegments in order of increasing Y and in the event of
197450 ** contains the geometry-checking callback routines and a list of
200410 ** string containing some SQL clause or list based on one or more of the
200429 ** Return a comma separated list of the quoted PRIMARY KEY column names,
200636 ** This function is used to create a SELECT list (the list of SQL
200794 /* For a table with implicit rowids, append "old._rowid_" to the list. */
200860 ** Return a nul-terminated string containing the comma separated list of
201023 char *zCols = 0; /* Used to build up list of table cols */
201577 ** last object in the list. */
203346 ** to point to the new file. A mutex protected linked list of all main
203425 ** main list and is only added to the pDb!=0 list.
203463 ** either the xOpen() or xAccess() VFS method, search the main-db list for
203583 rbuPutU32(&aBuf[32], 0); /* first page on free list trunk */
204030 ** mutex protected linked list of all such files. */
205681 ** stored in a linked list starting at sqlite3_session.pTable.
207296 /* Add the new session object to the linked list of session objects
207309 ** Free the list of table objects passed as the first argument. The contents
207341 /* Unlink the session from the linked list of sessions attached to the
207413 /* Populate the new SessionTable object and link it into the list.
207414 ** The new object must be linked onto the end of the list, not
210535 /* Search the list for a matching table */
210558 /* The new object must be linked on to the end of the list, not
210642 ** hash tables attached to the SessionTable objects in list p->pList.
212070 const u8 *a; /* Position list to iterate through */
215052 ** Append position iPos to the position list being accumulated in buffer
215054 ** The previous position written to this list is *piPrev. *piPrev is set
215957 ** a comma-separated list of SQL literals followed by a ')' character.
215985 ** + Zero or more SQL literals in a comma separated list
216287 Fts5ExprTerm *pSynonym; /* Pointer to first in list of synonyms */
216296 Fts5Buffer poslist; /* Current position list */
216816 const u8 *a; /* Buffer containing position list */
216818 int i; /* Current offset in position list */
216834 const u8 *a, int n, /* Buffer to read position list from */
216864 ** If no error occurs and non-zero (a match) is returned, the position-list
216930 /* Add an entry to each output position list */
219023 ** This function is used to access the current position list for phrase
219288 ** key immediately follows the object in memory. The position list
219295 ** * Position list, without 0x00 terminator.
219296 ** * Size of previous position list and rowid, as a 4 byte
219639 ** single list and returns a pointer to its first element.
219682 ** Extract all tokens from hash table iHash and link them into a list
219685 ** list.
219880 ** of a single 32-bit configuration cookie value followed by a list of
219903 ** A single record within the %_data table. The data is a list of varints.
220000 ** * A list of varints, one for each subsequent termless page. A
220013 ** * A list of delta-encoded varints - the first rowid on each subsequent
220202 ** position list data (one byte passed the position-list size field).
220204 ** position list data. The exception is if the rowid for the current entry
220231 ** start of the "position-list-size" field within the page.
220265 int nPos; /* Number of bytes in current position list */
221366 ** position list size field. Read the varint and return the number of bytes
221368 ** list, and *pbDel to true if the delete flag is set, or false otherwise.
221382 ** position-list size field. Read the value of the field and store it
221389 ** position list content (if any).
221450 ** the first position list. The position list belonging to document
221543 ** the position-list size field for the first relevant rowid on the page.
221550 ** byte of the position list content associated with said rowid.
221655 ** position-list.
221788 /* Search for the end of the position list within the current page. */
221918 ** position-list content for the current rowid. Back it up so that it
221919 ** points to the start of the position-list size field. */
221958 ** pIter->iLeafOffset is already set to point to the position-list size
222909 ** function appends the position list data for the current entry to
222910 ** buffer pBuf. It does not make a copy of the position-list size
222943 ** Parameter pPos points to a buffer containing a position list, size nPos.
222945 ** and sets pIter->base.pData/nData to point to the new position list.
222946 ** If memory is required for the new position list, use buffer pIter->poslist.
222947 ** Or, if the new position list is a contiguous subset of the input, set
222957 const u8 *pPos, int nPos, /* Position list */
222963 const u8 *pEnd = &p[nPos]; /* One byte past end of position list */
223057 ** fts5IterSetOutputs_Col100 if the column-list spans more than one page.
223794 ** Append a rowid and position-list size field to the writers output.
224084 int nPos; /* position-list size field value */
224118 /* Append the position-list data to the output */
224276 ** Buffer aBuf[] contains a list of varints, all small enough to fit
224278 ** list nMax bytes or less in size.
224622 /* Read position list size */
224697 ** In this case the buffers consist of a delta-encoded list of rowids only.
224701 Fts5Buffer *p1, /* First list to merge */
224745 i64 iPos; /* For iterating through a position list */
224786 Fts5Buffer *p1, /* First list to merge */
224802 ** a linked-list starting at pHead in ascending order of rowid. Avoid
224803 ** linking any iterators already at EOF into the linked list at all. */
224827 ** position-list, hence (nBuf+1) 10 byte paddings. */
226149 ** Buffer (a/n) is assumed to contain a list of serialized varints. Read
226203 ** tables. This function appends a human-readable version of that list to
226214 const u8 *pData, int nData /* Data to decode list-of-rowids from */
226370 /* Decode the position list tail at the start of the page */
226598 Fts5Auxiliary *pAux; /* First in list of all aux. functions */
226599 Fts5TokenizerModule *pTok; /* First in list of all tokenizer modules */
226601 Fts5Cursor *pCsr; /* First in list of all open cursors */
226607 ** of the Fts5Global.pAux list.
226621 ** of the Fts5Global.pTok list.
226653 ** byte of the position list for the corresponding phrase.
226685 Fts5Cursor *pNext; /* Next cursor in Fts5Cursor.pCsr list */
226710 Fts5Auxdata *pAuxdata; /* First in linked list of saved aux-data */
226759 Fts5Auxdata *pNext; /* Next object in linked list */
227307 /* Remove the cursor from the Fts5Global.pCsr list */
228619 /* Search through the cursors list of Fts5Auxdata objects for one that
228913 ** Return a "position-list blob" corresponding to the current position of
228914 ** cursor pCsr via sqlite3_result_blob(). A position-list blob contains
228915 ** the current position-list for each phrase in the query associated with
228918 ** A position-list blob begins with (nPhrase-1) varints, where nPhrase is
228922 ** The first varint (if it exists) contains the size of the position list
228924 ** list 1. And so on. There is no size field for the final position list,
233656 const u8 *pPos; int nPos; /* Position list */
233658 int iOff = 0; /* Current offset within position list */