Lines Matching defs:pList
10414 ** for(rc=sqlite3_vtab_in_first(pList, &pVal);
10416 ** rc=sqlite3_vtab_in_next(pList, &pVal)
18926 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
18930 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
18967 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
18994 ExprList *pList; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
19051 #define EP_xIsSelect 0x001000 /* x.pSelect is valid (otherwise x.pList is) */
33272 pFarg = pExpr->x.pList;
33305 sqlite3TreeViewExprList(pView, pOB->x.pList, pWin!=0, "ORDERBY");
33316 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY");
33348 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
33362 ** Y is stored in pExpr->pList->a[0].pExpr.
33363 ** Z is stored in pExpr->pList->a[1].pExpr.
33369 assert( pExpr->x.pList->nExpr==2 );
33370 pY = pExpr->x.pList->a[0].pExpr;
33371 pZ = pExpr->x.pList->a[1].pExpr;
33394 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
33420 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
33476 const ExprList *pList,
33480 if( pList==0 ){
33485 for(i=0; i<pList->nExpr; i++){
33486 int j = pList->a[i].u.x.iOrderByCol;
33487 char *zName = pList->a[i].zEName;
33488 int moreToFollow = i<pList->nExpr - 1;
33494 switch( pList->a[i].fg.eEName ){
33500 if( pList->a[i].fg.bUsed ) fprintf(stdout, "(used) ");
33501 if( pList->a[i].fg.bUsingTerm ) fprintf(stdout, "(USING-term) ");
33502 if( pList->a[i].fg.bNoExpand ) fprintf(stdout, "(NoExpand) ");
33515 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
33524 const ExprList *pList,
33529 sqlite3TreeViewBareExprList(pView, pList, zLabel);
33538 const IdList *pList,
33542 if( pList==0 ){
33547 for(i=0; i<pList->nId; i++){
33548 char *zName = pList->a[i].zName;
33549 int moreToFollow = i<pList->nId - 1;
33553 if( pList->eU4==EU4_NONE ){
33555 }else if( pList->eU4==EU4_IDX ){
33556 fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx);
33558 assert( pList->eU4==EU4_EXPR );
33559 if( pList->a[i].u4.pExpr==0 ){
33563 sqlite3TreeViewPush(&pView, i<pList->nId-1);
33564 sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0);
33574 const IdList *pList,
33579 sqlite3TreeViewBareIdList(pView, pList, zLabel);
56815 static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){
56820 assert( pList!=0 );
56821 p = pList;
56822 pList = p->pRight;
56824 for(iDepth=1; pList; iDepth++){
56826 p = pList;
56827 pList = p->pRight;
56829 p->pRight = rowSetNDeepTree(&pList, iDepth);
60246 PgHdr *pList; /* List of dirty pages to revert */
60257 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60258 while( pList && rc==SQLITE_OK ){
60259 PgHdr *pNext = pList->pDirty;
60260 rc = pagerUndoCallback((void *)pPager, pList->pgno);
60261 pList = pNext;
60269 ** the contents of the list of pages headed by pList (connected by pDirty),
60278 PgHdr *pList, /* List of frames to log */
60283 int nList; /* Number of pages in pList */
60287 assert( pList );
60290 for(p=pList; p && p->pDirty; p=p->pDirty){
60295 assert( pList->pDirty==0 || isCommit );
60301 PgHdr **ppNext = &pList;
60303 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
60309 assert( pList );
60315 if( pList->pgno==1 ) pager_write_changecounter(pList);
60317 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
60320 for(p=pList; p; p=p->pDirty){
60326 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60327 for(p=pList; p; p=p->pDirty){
61510 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
61517 assert( isOpen(pPager->fd) || pList->pDirty==0 );
61534 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
61541 while( rc==SQLITE_OK && pList ){
61542 Pgno pgno = pList->pgno;
61552 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
61556 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
61557 if( pList->pgno==1 ) pager_write_changecounter(pList);
61559 pData = pList->pData;
61577 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
61580 PAGERID(pPager), pgno, pager_pagehash(pList)));
61586 pager_set_pagehash(pList);
61587 pList = pList->pDirty;
61770 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
61772 while( rc==SQLITE_OK && pList ){
61773 PgHdr *pNext = pList->pDirty;
61774 if( pList->nRef==0 ){
61775 rc = pagerStress((void*)pPager, pList);
61777 pList = pNext;
63579 PgHdr *pList;
63582 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63583 if( pList==0 ){
63587 pList = pPageOne;
63588 pList->pDirty = 0;
63591 if( ALWAYS(pList) ){
63592 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
63695 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63700 rc = pager_write_pagelist(pPager, pList);
63730 rc = pager_write_pagelist(pPager, pList);
68905 PgHdr *pList, /* List of dirty pages to write */
68912 PgHdr *p; /* Iterator to run through pList with. */
68921 assert( pList );
68929 { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
69004 for(p=pList; p; p=p->pDirty){
69099 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
69142 PgHdr *pList, /* List of dirty pages to write */
69149 rc = walFrames(pWal, szPage, pList, nTruncate, isCommit, sync_flags);
73369 BtShared *pList;
73380 pList = GLOBAL(BtShared*,sqlite3SharedCacheList);
73381 while( ALWAYS(pList) && pList->pNext!=pBt ){
73382 pList=pList->pNext;
73384 if( ALWAYS(pList) ){
73385 pList->pNext = pBt->pNext;
84292 ExprList *pList = 0; /* Function arguments */
84298 pList = p->x.pList;
84299 if( pList ) nVal = pList->nExpr;
84312 if( pList ){
84319 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
102988 SorterRecord *pList; /* Linked list of records */
102989 u8 *aMemory; /* If non-NULL, bulk memory to hold pList */
102990 i64 szPMA; /* Size of pList as PMA in bytes */
103859 vdbeSorterRecordFree(0, pTask->list.pList);
104051 vdbeSorterRecordFree(0, pSorter->list.pList);
104053 pSorter->list.pList = 0;
104199 ** Sort the linked list of records headed at pTask->pList. Return
104203 static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){
104212 p = pList->pList;
104218 if( pList->aMemory ){
104219 if( (u8*)p==pList->aMemory ){
104222 assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
104223 pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
104243 pList->pList = p;
104336 ** Write the current contents of in-memory linked-list pList to a level-0
104349 static int vdbeSorterListToPMA(SortSubtask *pTask, SorterList *pList){
104357 i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof;
104362 assert( pList->szPMA>0 );
104374 vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9);
104379 rc = vdbeSorterSort(pTask, pList);
104389 vdbePmaWriteVarint(&writer, pList->szPMA);
104390 for(p=pList->pList; p; p=pNext){
104394 if( pList->aMemory==0 ) sqlite3_free(p);
104396 pList->pList = p;
104401 assert( rc!=SQLITE_OK || pList->pList==0 );
104540 assert( pTask->list.pList==0 );
104547 pSorter->list.pList = 0;
104624 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
104640 if( pSorter->list.pList ){
104641 iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
104649 pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
104657 if( pSorter->list.pList ){
104658 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
104665 pNew->u.pNext = pSorter->list.pList;
104670 pSorter->list.pList = pNew;
105395 if( pSorter->list.pList ){
105408 assert( pSorter->list.pList );
105460 SorterRecord *pFree = pSorter->list.pList;
105461 pSorter->list.pList = pFree->u.pNext;
105464 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
105491 *pnKey = pSorter->list.pList->nVal;
105492 pKey = SRVAL(pSorter->list.pList);
106487 static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){
106489 for(pWin=pList; pWin; pWin=pWin->pNextWin){
106534 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
106546 if( pExpr->x.pList ){
106547 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
107400 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
107505 pExpr->x.pList = pFJMatch;
107842 ExprList *pList = pExpr->x.pList; /* The argument list */
107843 int n = pList ? pList->nExpr : 0; /* Number of arguments */
107870 pExpr->iTable = exprProbability(pList->a[1].pExpr);
108015 sqlite3WalkExprList(pWalker, pList);
108020 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
108138 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
108140 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
108887 ExprList *pList /* The expression list to be analyzed. */
108892 if( pList==0 ) return SQLITE_OK;
108900 for(i=0; i<pList->nExpr; i++){
108901 Expr *pExpr = pList->a[i].pExpr;
108980 ExprList *pList /* Expression list to resolve. May be NULL. */
109006 if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
109089 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
109155 ExprList *pList = pExpr->x.pList;
109156 assert( ExprUseXList(pExpr) && pList!=0 );
109157 assert( pList->nExpr > 0);
109158 for(ii=1; ii<pList->nExpr; ii+=2){
109159 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
109161 if( pList->nExpr % 2 ){
109162 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
109229 assert( pExpr->x.pList->nExpr>0 );
109231 pExpr = pExpr->x.pList->a[0].pExpr;
109280 p = p->x.pList->a[0].pExpr;
109294 assert( !ExprUseXList(p) || p->x.pList==0 || p->pRight==0 );
109295 if( ExprUseXList(p) && p->x.pList!=0 && !db->mallocFailed ){
109297 for(i=0; i<p->x.pList->nExpr; i++){
109298 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
109299 pNext = p->x.pList->a[i].pExpr;
109519 return pExpr->x.pList->nExpr;
109552 return pVector->x.pList->a[i].pExpr;
109615 ppVector = &pVector->x.pList->a[iField].pExpr;
109685 *ppExpr = pVector->x.pList->a[iField].pExpr;
109847 ** argument. An expression with no children, Expr.pList or
109852 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
109862 }else if( p->x.pList ){
109863 heightOfExprList(p->x.pList, &nHeight);
109864 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
109874 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
109894 ** Propagate all EP_Propagate flags from the Expr.x.pList into
109899 if( p && ExprUseXList(p) && p->x.pList ){
109900 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
110107 nExprElem = pExpr->x.pList->nExpr;
110118 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
110119 pExpr->x.pList = 0;
110170 ExprList *pList, /* Argument list */
110179 sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
110184 if( pList
110185 && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
110190 pNew->x.pList = pList;
110237 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
110253 pOB->x.pList = pOrderBy;
110392 assert( !ExprUseXList(p) || p->x.pList==0 );
110397 assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 );
110405 sqlite3ExprListDelete(db, p->x.pList);
110532 if( p->pLeft || p->x.pList ){
110564 ** substructure such as Expr.x.pList, Expr.x.pSelect, and Expr.y.pWin.
110695 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
110699 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList,
111000 ** Add a new element to the end of an expression list. If pList is
111003 ** The pList argument must be either NULL or a pointer to an ExprList
111016 ExprList *pList;
111018 pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 );
111019 if( pList==0 ){
111023 pList->nAlloc = 4;
111024 pList->nExpr = 1;
111025 pItem = &pList->a[0];
111028 return pList;
111032 ExprList *pList, /* List to which to append. Might be NULL */
111037 pList->nAlloc *= 2;
111038 pNew = sqlite3DbRealloc(db, pList,
111039 sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0]));
111041 sqlite3ExprListDelete(db, pList);
111045 pList = pNew;
111047 pItem = &pList->a[pList->nExpr++];
111050 return pList;
111054 ExprList *pList, /* List to which to append. Might be NULL */
111058 if( pList==0 ){
111061 if( pList->nAlloc<pList->nExpr+1 ){
111062 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
111064 pItem = &pList->a[pList->nExpr++];
111067 return pList;
111078 ** expression list pList. In the case of a subquery on the RHS, append
111083 ExprList *pList, /* List to which to append. Might be NULL */
111090 int iFirst = pList ? pList->nExpr : 0;
111111 pList = sqlite3ExprListAppend(pParse, pList, pSubExpr);
111112 if( pList ){
111113 assert( pList->nExpr==iFirst+i+1 );
111114 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
111119 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
111120 Expr *pFirst = pList->a[iFirst].pExpr;
111137 return pList;
111177 ** pList might be NULL following an OOM error. But pName should never be
111183 ExprList *pList, /* List to which to add the span. */
111187 assert( pList!=0 || pParse->db->mallocFailed!=0 );
111189 if( pList ){
111191 assert( pList->nExpr>0 );
111192 pItem = &pList->a[pList->nExpr-1];
111212 ** pList might be NULL following an OOM error. But pSpan should never be
111218 ExprList *pList, /* List to which to add the span. */
111223 assert( pList!=0 || db->mallocFailed!=0 );
111224 if( pList ){
111225 struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
111226 assert( pList->nExpr>0 );
111254 static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){
111255 int i = pList->nExpr;
111256 struct ExprList_item *pItem = pList->a;
111257 assert( pList->nExpr>0 );
111264 sqlite3DbNNFreeNN(db, pList);
111266 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
111267 if( pList ) exprListDeleteNN(db, pList);
111269 SQLITE_PRIVATE void sqlite3ExprListDeleteGeneric(sqlite3 *db, void *pList){
111270 if( ALWAYS(pList) ) exprListDeleteNN(db, (ExprList*)pList);
111277 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){
111280 assert( pList!=0 );
111281 for(i=0; i<pList->nExpr; i++){
111282 Expr *pExpr = pList->a[i].pExpr;
111396 ExprList *pList; /* List of arguments */
111402 || (pList = pExpr->x.pList)==0
111406 n = pList->nExpr;
111407 sqlite3WalkExprList(pWalker, pList);
112300 && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
112548 }else if( ALWAYS(pExpr->x.pList!=0) ){
112558 ExprList *pList = pExpr->x.pList;
112575 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
112895 ExprList *pList;
112902 pList = pExpr->x.pList;
112908 for(ii=0; ii<pList->nExpr; ii++){
112909 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
112910 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
112914 if( ii<pList->nExpr-1 || destIfNull!=destIfFalse ){
112918 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
112919 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
112920 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull);
112921 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull);
113295 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
113351 caseExpr.x.pList = pFarg;
113929 pFarg = pExpr->x.pList;
114084 ** Y is stored in pExpr->pList->a[0].pExpr.
114085 ** Z is stored in pExpr->pList->a[1].pExpr.
114231 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
114232 ** odd. The Y is also optional. If the number of elements in x.pList
114234 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
114253 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
114254 assert(pExpr->x.pList->nExpr > 0);
114255 pEList = pExpr->x.pList;
114497 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
114514 ExprList *pList, /* The expression list to be coded */
114523 assert( pList!=0 );
114526 n = pList->nExpr;
114528 for(pItem=pList->a, i=0; i<n; i++, pItem++){
114613 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
114616 compRight.pRight = pExpr->x.pList->a[1].pExpr;
115124 if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
115202 assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) );
115206 ExprList *pList;
115208 pList = p->x.pList;
115209 assert( pList!=0 );
115210 assert( pList->nExpr==2 );
115212 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
115213 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
115391 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
115400 assert( pExpr->x.pList->nExpr==2 );
115402 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
115403 pExpr->x.pList->a[1].pExpr);
115648 sqlite3WalkExprList(&w, pExpr->x.pList);
115652 assert( pExpr->pLeft->x.pList!=0 );
115653 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
115923 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
115937 pOBList = pExpr->pLeft->x.pList;
115943 pExpr->x.pList->a[0].pExpr,0)==0
116004 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
116007 if( pList ){
116008 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
116095 const ExprList *pList = pParse->pConstExpr;
116096 if( pList ){
116098 for(i=0; i<pList->nExpr; i++){
116099 if( pList->a[i].u.iConstExprReg>=iMin ){
116100 iMin = pList->a[i].u.iConstExprReg + 1;
116130 ExprList *pList = pParse->pConstExpr;
116131 for(i=0; i<pList->nExpr; i++){
116132 int iReg = pList->a[i].u.iConstExprReg;
116855 RenameToken *pList; /* List of tokens to overwrite */
116856 int nList; /* Number of tokens in pList */
117029 ExprList *pList = p->pEList;
117030 for(i=0; i<pList->nExpr; i++){
117031 if( pList->a[i].zEName && pList->a[i].fg.eEName==ENAME_NAME ){
117032 sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
117122 pToken->pNext = pCtx->pList;
117123 pCtx->pList = pToken;
117183 RenameToken *pBest = pCtx->pList;
117190 for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
117368 /* At this point pRename->pList contains a list of RenameToken objects
117375 while( pRename->pList ){
117789 renameTokenFree(db, sCtx.pList);
117999 renameTokenFree(db, sCtx.pList);
118113 renameTokenFree(db, sCtx.pList);
120954 SrcList *pList = pSelect->pSrc;
120956 if( NEVER(pList==0) ) return WRC_Continue;
120957 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
120974 if( pList->a[i].fg.isUsing==0
120975 && sqlite3WalkExpr(&pFix->w, pList->a[i].u3.pOn)
121035 SrcList *pList /* The Source list to check and modify */
121038 if( pList ){
121041 s.pSrc = pList;
122068 ExprList *pList;
122070 pList = pTab->u.tab.pDfltList;
122072 || NEVER(pList==0)
122073 || NEVER(pList->nExpr<pCol->iDflt)
122075 pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;
122076 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
122078 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
122079 pList->a[pCol->iDflt-1].pExpr = pExpr;
122808 SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){
122820 sqlite3ExprListDelete(db, pList);
122825 pRet->pReturnEL = pList;
122840 pRet->retTStep.pExprList = pList;
123179 ** Designate the PRIMARY KEY for the table. pList is a list of names
123180 ** of columns that form the primary key. If pList is NULL, then the
123198 ExprList *pList, /* List of field names to be indexed */
123214 if( pList==0 ){
123220 nTerm = pList->nExpr;
123222 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
123244 if( IN_RENAME_OBJECT && pList ){
123245 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
123252 if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags;
123253 (void)sqlite3HasExplicitNulls(pParse, pList);
123260 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
123262 pList = 0;
123266 sqlite3ExprListDelete(pParse->db, pList);
123746 ExprList *pList;
123749 pList = sqlite3ExprListAppend(pParse, 0,
123751 if( pList==0 ){
123756 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123758 pList->a[0].fg.sortFlags = pParse->iPkSortOrder;
123761 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
123957 static void markExprListImmutable(ExprList *pList){
123958 if( pList ){
123964 sqlite3WalkExprList(&w, pList);
125256 ** If expression list pList contains an expression that was parsed with
125260 SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
125261 if( pList ){
125263 for(i=0; i<pList->nExpr; i++){
125264 if( pList->a[i].fg.bNulls ){
125265 u8 sf = pList->a[i].fg.sortFlags;
125284 ** pList is a list of columns to be indexed. pList will be NULL if this
125293 ExprList *pList, /* A list of columns to be indexed */
125297 int sortOrder, /* Sort order of primary key when pList==NULL */
125312 struct ExprList_item *pListItem; /* For looping over pList */
125329 if( sqlite3HasExplicitNulls(pParse, pList) ){
125480 /* If pList==0, it means this routine was called to make a primary
125484 if( pList==0 ){
125489 pList = sqlite3ExprListAppend(pParse, 0,
125491 if( pList==0 ) goto exit_create_index;
125492 assert( pList->nExpr==1 );
125493 sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
125495 sqlite3ExprListCheckLength(pParse, pList, "index");
125502 for(i=0; i<pList->nExpr; i++){
125503 Expr *pExpr = pList->a[i].pExpr;
125516 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
125517 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
125532 pIndex->nKeyCol = pList->nExpr;
125557 pListItem = pList->a;
125559 pIndex->aColExpr = pList;
125560 pList = 0;
125578 pIndex->aColExpr = pList;
125579 pList = 0;
125878 sqlite3ExprListDelete(db, pList);
126057 SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
126060 if( pList==0 ){
126061 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
126062 if( pList==0 ) return 0;
126065 pNew = sqlite3DbRealloc(db, pList,
126066 sizeof(IdList) + pList->nId*sizeof(pList->a));
126068 sqlite3IdListDelete(db, pList);
126071 pList = pNew;
126073 i = pList->nId++;
126074 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
126075 if( IN_RENAME_OBJECT && pList->a[i].zName ){
126076 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
126078 return pList;
126084 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
126087 if( pList==0 ) return;
126088 assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */
126089 for(i=0; i<pList->nId; i++){
126090 sqlite3DbFree(db, pList->a[i].zName);
126092 sqlite3DbNNFreeNN(db, pList);
126096 ** Return the index in pList of the identifier named zId. Return -1
126099 SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
126101 assert( pList!=0 );
126102 for(i=0; i<pList->nId; i++){
126103 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
126201 ** a new one. If an OOM error does occurs, then the prior value of pList
126231 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
126241 if( pList==0 ){
126242 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
126243 if( pList==0 ) return 0;
126244 pList->nAlloc = 1;
126245 pList->nSrc = 1;
126246 memset(&pList->a[0], 0, sizeof(pList->a[0]));
126247 pList->a[0].iCursor = -1;
126249 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
126251 sqlite3SrcListDelete(db, pList);
126254 pList = pNew;
126257 pItem = &pList->a[pList->nSrc-1];
126268 return pList;
126274 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
126277 assert( pList || pParse->db->mallocFailed );
126278 if( ALWAYS(pList) ){
126279 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
126292 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
126296 if( pList==0 ) return;
126297 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
126311 sqlite3DbNNFreeNN(db, pList);
126438 SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
126444 pItem->u1.pFuncArg = pList;
126447 sqlite3ExprListDelete(pParse->db, pList);
127864 pLhs->x.pList = sqlite3ExprListDup(db, pEList, 0);
130931 if( !pExpr->x.pList ){
130934 nExpr = pExpr->x.pList->nExpr;
130956 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
132648 ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */
132725 pList = sqlite3ExprListAppend(pParse, pList, pNew);
132726 sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
132772 pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
132785 sqlite3ExprListDelete(db, pList);
133798 ExprList *pList = 0; /* List of VALUES() to be inserted */
133829 pList = pSelect->pEList;
133870 sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList,
133911 assert( pList==0 );
134084 if( pList ){
134085 nColumn = pList->nExpr;
134086 if( sqlite3ResolveExprListNames(&sNC, pList) ){
134306 Expr *pX = pList->a[k].pExpr;
134337 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
134389 Expr *pIpk = pList->a[ipkColumn].pExpr;
134394 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
134530 sqlite3ExprListDelete(db, pList);
143314 if( p->x.pList ){
143316 for(i=0; i<p->x.pList->nExpr; i++){
143317 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
143352 if( p->x.pList ){
143354 for(i=0; i<p->x.pList->nExpr; i++){
143355 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
143441 IdList *pList = pRight->u3.pUsing;
143443 assert( pList!=0 );
143444 for(j=0; j<pList->nId; j++){
143453 zName = pList->a[j].zName;
144465 ExprList *pList, /* Form the KeyInfo object from this ExprList */
144466 int iStart, /* Begin with this column of pList */
144475 nExpr = pList->nExpr;
144479 for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
146825 substExprList(pSubst, pExpr->x.pList);
146840 ExprList *pList /* List to scan and in which to make substitutes */
146843 if( pList==0 ) return;
146844 for(i=0; i<pList->nExpr; i++){
146845 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
147022 ExprList *pList;
147026 pList = p->pEList;
147027 for(ii=0; ii<pList->nExpr; ii++){
147030 assert( pList->a[ii].pExpr!=0 );
147031 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
148090 const ExprList *pList = pSel->pEList;
148091 assert( pList!=0 );
148092 for(ii=0; ii<pList->nExpr; ii++){
148093 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
148250 ExprList *pList = pSub->pOrderBy;
148251 for(j=0; j<pList->nExpr; j++){
148252 u16 iCol = pList->a[j].u.x.iOrderByCol;
148303 pEList = pFunc->x.pList;
149425 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
149429 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
149573 if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
149578 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
149593 pOBList = pFunc->pFExpr->pLeft->x.pList;
149600 nExtra += pFunc->pFExpr->x.pList->nExpr;
149603 nExtra += pFunc->pFExpr->x.pList->nExpr;
149627 ExprList *pList;
149629 pList = pF->pFExpr->x.pList;
149642 nArg = pList->nExpr;
149650 assert( pF->pFExpr->pLeft->x.pList!=0 );
149651 nKey = pF->pFExpr->pLeft->x.pList->nExpr;
149675 pList ? pList->nExpr : 0);
149718 ExprList *pList;
149722 pList = pF->pFExpr->x.pList;
149750 assert( pList!=0 );
149751 nArg = pList->nExpr;
149756 pOBList = pF->pFExpr->pLeft->x.pList;
149780 sqlite3ExprCodeExprList(pParse, pList, regDistinct, 0, SQLITE_ECEL_DUP);
149790 }else if( pList ){
149791 nArg = pList->nExpr;
149794 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
149799 if( pF->iDistinct>=0 && pList ){
149804 pF->iDistinct, addrNext, pList, regDistinct);
149819 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
149820 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
150035 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
151042 && pAggInfo->aFunc[0].pFExpr->x.pList!=0
151044 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
151396 pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList;
151764 Trigger *pList; /* List of triggers to return */
151770 pList = pTab->pTrigger;
151778 pTrig->pNext = pList;
151779 pList = pTrig;
151788 pTrig->pNext = pList;
151789 pList = pTrig;
151794 if( pList ){
151797 for(pX=pList; pX; pX=pX->pNext){
151804 return pList;
152487 Trigger *pList = 0;
152490 pList = sqlite3TriggerList(pParse, pTab);
152491 assert( pList==0 || IsVirtual(pTab)==0
152492 || (pList->bReturning && pList->pNext==0) );
152493 if( pList!=0 ){
152494 p = pList;
152499 ** only TEMP triggers are allowed. Truncate the pList so that it
152501 if( pList==pTab->pTrigger ){
152502 pList = 0;
152507 p = pList;
152540 return (mask ? pList : 0);
152622 /* The input list pList is the list of result set terms from a RETURNING
152625 ** This routine makes a copy of the pList, and at the same time expands
152630 ExprList *pList, /* The arguments to RETURNING */
152637 for(i=0; i<pList->nExpr; i++){
152638 Expr *pOldExpr = pList->a[i].pExpr;
152656 if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){
152658 pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
152659 pItem->fg.eEName = pList->a[i].fg.eEName;
153473 ExprList *pList = 0;
153513 pList = sqlite3ExprListAppend(pParse, pList, pNew);
153518 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
153523 pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
153533 pList = sqlite3ExprListAppend(pParse, pList,
153538 pSelect = sqlite3SelectNew(pParse, pList,
154511 ExprList *pList;
154530 pList = sqlite3ExprListAppend(pParse, 0, pRow);
154534 pList = sqlite3ExprListAppend(pParse, pList,
154540 pList = sqlite3ExprListAppend(pParse, pList, pRowExpr);
154544 updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0);
154545 sqlite3ExprListDelete(db, pList);
157927 pOrigLhs = pNew->pLeft->x.pList;
157947 pNew->pLeft->x.pList = pLhs;
158645 const ExprList *pList;
158647 pList = p->x.pList;
158648 assert( nReg<=pList->nExpr );
158650 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
158967 assert( iFld<=pLeft->x.pList->nExpr );
158968 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
160422 ExprList *pList; /* List of operands to the LIKE operator */
160438 pList = pExpr->x.pList;
160439 pLeft = pList->a[1].pExpr;
160441 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
160609 ExprList *pList;
160614 pList = pExpr->x.pList;
160615 if( pList==0 || pList->nExpr!=2 ){
160626 pCol = pList->a[1].pExpr;
160633 *ppRight = pList->a[0].pExpr;
160650 pCol = pList->a[0].pExpr;
160667 *ppRight = pList->a[1].pExpr;
161104 ExprList *pList = 0; /* The RHS of the IN operator */
161115 pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
161125 pNew->x.pList = pList;
161132 sqlite3ExprListDelete(db, pList);
161260 pExpr = pExpr->x.pList->a[0].pExpr;
161338 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
161345 || pExpr->x.pList!=0
161400 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
161480 ExprList *pList;
161484 pList = pExpr->x.pList;
161485 assert( pList!=0 );
161486 assert( pList->nExpr==2 );
161492 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
161578 pLeft = pExpr->x.pList->a[1].pExpr;
162003 assert( p->x.pList==0 );
162007 }else if( p->x.pList ){
162008 mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
162032 SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){
162035 if( pList ){
162036 for(i=0; i<pList->nExpr; i++){
162037 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
162445 inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
162689 ** This function searches pList for an entry that matches the iCol-th column
162692 ** If such an expression is found, its index in pList->a[] is returned. If
162697 ExprList *pList, /* Expression list to search */
162705 for(i=0; i<pList->nExpr; i++){
162706 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
162712 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
164326 ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */
164338 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
164340 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
165048 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
165053 pRhs = pRhs->x.pList->a[i].pExpr;
165232 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
165234 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
165371 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
168141 n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
169978 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
169980 for(p=pList; p; p=p->pNextWin){
169991 ** for a window function within a SELECT statement. Argument pList is a
169998 ** search list pList for a matching WINDOW definition, and update pWin
170008 Window *pList, /* List of named windows for this SELECT */
170013 Window *p = windowFind(pParse, pList, pWin->zName);
170024 sqlite3WindowChain(pParse, pWin, pList);
170237 ** expression list pList. Return a pointer to the result list.
170241 ExprList *pList, /* List to which to append. Might be NULL */
170247 int nInit = pList ? pList->nExpr : 0;
170265 pList = sqlite3ExprListAppend(pParse, pList, pDup);
170266 if( pList ) pList->a[nInit+i].fg.sortFlags = pAppend->a[i].fg.sortFlags;
170269 return pList;
170387 pArgs = pWin->pOwner->x.pList;
170624 SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){
170627 Window *pExist = windowFind(pParse, pList, pWin->zBase);
170781 ExprList *pList;
170784 pList = pWin->pOwner->x.pList;
170785 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
170873 const ExprList *pList;
170875 pList = pWin->pOwner->x.pList;
170876 return (pList ? pList->nExpr : 0);
171061 assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr );
171062 assert( pWin->bExprArgs || nArg ||pWin->pOwner->x.pList==0 );
171075 nArg = pWin->pOwner->x.pList->nExpr;
171077 sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0);
171090 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
171300 int nArg = pWin->pOwner->x.pList->nExpr;
176938 ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
176941 yymsp[-4].minor.yy454->x.pList = pList;
176942 if( ALWAYS(pList->nExpr) ){
176943 yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
176946 sqlite3ExprListDelete(pParse->db, pList);
176967 ExprList *pList;
176970 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
176971 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
176972 yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176979 ExprList *pList;
176982 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176983 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
176984 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176985 yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
177041 ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
177042 pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
177043 yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
177053 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
177054 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
177057 yymsp[-4].minor.yy454->x.pList = pList;
177059 sqlite3ExprListDelete(pParse->db, pList);
177095 int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
177102 yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
177144 yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
186172 sqlite3_int64 iDocid; /* Current docid (if pList!=0) */
186173 int bFreeList; /* True if pList should be sqlite3_free()d */
186174 char *pList; /* Pointer to position list following iDocid */
188906 ** Argument pList points to a position list nList bytes in size. This
188910 ** of the entries from pList at position 0, and terminated by an 0x00 byte.
188915 char *pList, /* Position list (no 0x00 term) */
188916 int nList, /* Size of pList in bytes */
188921 char *p = pList;
188922 char *pEnd = &pList[nList];
190403 ** Arguments pList/nList contain the doclist for token iToken of phrase p.
190406 ** This function assumes that pList points to a buffer allocated using
190414 Fts3Phrase *p, /* Phrase to merge pList/nList into */
190415 int iToken, /* Token pList/nList corresponds to */
190416 char *pList, /* Pointer to doclist */
190417 int nList /* Number of bytes in pList */
190422 if( pList==0 ){
190429 p->doclist.aAll = pList;
190434 sqlite3_free(pList);
190447 pRight = pList;
190453 pLeft = pList;
190508 ** means that the phrase does not appear in the current row, doclist.pList
190518 char *aFree = (pPhrase->doclist.bFreeList ? pPhrase->doclist.pList : 0);
190525 char *pList;
190527 int rc = sqlite3Fts3DeferredTokenList(pDeferred, &pList, &nList);
190530 if( pList==0 ){
190533 pPhrase->doclist.pList = 0;
190538 aPoslist = pList;
190542 char *aOut = pList;
190549 aPoslist = pList;
190554 pPhrase->doclist.pList = 0;
190566 pPhrase->doclist.pList = aPoslist;
190578 p2 = pPhrase->doclist.pList;
190581 p1 = pPhrase->doclist.pList;
190592 pPhrase->doclist.pList = aOut;
190596 pPhrase->doclist.nList = (int)(aOut - pPhrase->doclist.pList);
190599 pPhrase->doclist.pList = 0;
190606 if( pPhrase->doclist.pList!=aFree ) sqlite3_free(aFree);
190805 pDL->pList = pIter;
190807 pDL->nList = (int)(pIter - pDL->pList);
190830 char *pList;
190856 p->pList = pPhrase->doclist.pList;
190866 pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList
190868 if( p->pList==0 ) *pbEof = 1;
190886 ** the Fts3Doclist.pList and nList fields.
190911 &pDL->iDocid, &pDL->pList, &pDL->nList
190913 if( pDL->pList==0 ) bEof = 1;
190957 memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
190962 char *pL = a[i].pList;
190973 pDL->pList = aDoclist;
191011 pDL->pList = pDL->pNextDocid;
191301 char *pList = 0;
191302 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
191303 assert( rc==SQLITE_OK || pList==0 );
191306 pTab, pTC->pPhrase, pTC->iToken,pList,nList
191387 sqlite3_free(pPhrase->doclist.pList);
191389 pPhrase->doclist.pList = 0;
191430 assert( pPhrase->doclist.pList );
191432 p2 = pOut = pPhrase->doclist.pList;
191437 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
191440 assert( pPhrase->doclist.pList[nNew]=='\0' );
191441 memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
191444 *paPoslist = pPhrase->doclist.pList;
191468 ** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes)
191469 ** FTs3Expr.pPhrase->doclist.pList (pointer to position list)
191540 memset(pDl->pList, 0, pDl->nList);
191547 memset(pDl->pList, 0, pDl->nList);
191625 ** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression.
191676 char *aPoslist = p->pPhrase->doclist.pList;
191685 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
191781 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
191788 bHit = (pPhrase->doclist.pList!=0);
191940 ** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase
191946 if( pPhrase && pPhrase->doclist.pList ){
191948 char *p = pPhrase->doclist.pList;
192177 pIter = pPhrase->doclist.pList;
196588 PendingList *pList; /* Doclist is assembled here */
197214 static void fts3PendingListDelete(PendingList *pList){
197215 sqlite3_free(pList);
197229 PendingList *pList;
197232 pList = (PendingList *)fts3HashFind(pHash, zToken, nToken);
197233 if( pList ){
197234 p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem));
197236 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
197237 if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){
197242 sqlite3_free(pList);
197247 p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem));
197375 PendingList *pList = (PendingList *)fts3HashData(pElem);
197376 fts3PendingListDelete(pList);
197807 PendingList *pList = (PendingList *)fts3HashData(pElem);
197808 int nCopy = pList->nData+1;
197823 memcpy(aCopy, pList->aData, nCopy);
199097 char *pList = *ppList;
199099 char *pEnd = &pList[nList];
199101 char *p = pList;
199109 nList = (int)(p - pList);
199113 nList -= (int)(p - pList);
199114 pList = p;
199118 p = &pList[1];
199122 if( bZero && (pEnd - &pList[nList])>0){
199123 memset(&pList[nList], 0, pEnd - &pList[nList]);
199125 *ppList = pList;
199138 char *pList,
199151 memcpy(pMsr->aBuffer, pList, nList);
199183 char *pList;
199188 rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
199202 rc = fts3MsrBufferData(pMsr, pList, (i64)nList+1);
199205 pList = pMsr->aBuffer;
199209 fts3ColumnFilter(pMsr->iColFilter, 1, &pList, &nList);
199213 *paPoslist = pList;
199455 char *pList = 0;
199459 fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
199470 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
199496 nWrite = sqlite3Fts3FirstFilter(iDelta, pList, nList, a);
199505 memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
201956 fts3PendingListDelete(pDef->pList);
201957 pDef->pList = 0;
201970 fts3PendingListDelete(pDef->pList);
202018 fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc);
202028 if( pDef->pList ){
202029 rc = fts3PendingListAppendVarint(&pDef->pList, 0);
202049 if( p->pList==0 ){
202053 pRet = (char *)sqlite3_malloc64(p->pList->nData);
202056 nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
202057 *pnData = p->pList->nData - nSkip;
202060 memcpy(pRet, &p->pList->aData[nSkip], *pnData);
202381 char *pList; /* Pointer to start of phrase position list */
202790 pPhrase->pList = pCsr;
202802 pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0
203181 char *pIter = pPhrase->doclist.pList;
203854 char *pList; /* Position-list */
203855 i64 iPos; /* Position just read from pList */
203874 char *pList; /* Pointer to position list for phrase */
203879 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
203881 if( pList ){
203882 fts3GetDeltaPosition(&pList, &iPos);
203889 pT->pList = pList;
203985 if( pT->pList && (pT->iPos-pT->iOff)<iMinPos ){
203996 if( 0==(0xFE&*pTerm->pList) ){
203997 pTerm->pList = 0;
203999 fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos);
215643 static GeoSegment *geopolySortSegmentsByYAndC(GeoSegment *pList){
215648 while( pList ){
215649 p = pList;
215650 pList = pList->pNext;
219392 sqlite3_stmt *pList = 0;
219397 p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg,
219403 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
219404 const char *zIdx = (const char*)sqlite3_column_text(pList, 1);
219405 int bPartial = sqlite3_column_int(pList, 4);
219431 rbuFinalize(p, pList);
227188 static void sessionDeleteTable(sqlite3_session *pSession, SessionTable *pList){
227192 for(pTab=pList; pTab; pTab=pNext){
230314 SessionTable *pList; /* List of tables in current patch */
230636 for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
230669 for(ppNew=&pGrp->pList; *ppNew; ppNew=&(*ppNew)->pNext);
230706 if( pGrp->pList==0 ){
230820 ** hash tables attached to the SessionTable objects in list p->pList.
230822 for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
230881 if( pGrp->pList || pGrp->db ){
230977 sessionDeleteTable(0, pGrp->pList);
231192 for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
231379 sessionDeleteTable(0, p->grp.pList);
240387 Fts5HashEntry *pList;
240413 pList = 0;
240415 pList = fts5HashEntryMerge(pList, ap[i]);
240419 *ppSorted = pList;
242723 const u8 *pList = 0;
242728 sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
242729 if( pList==0 ) goto next_none_eof;
242730 pIter->pLeaf->p = (u8*)pList;
242735 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
242798 const u8 *pList = 0;
242805 sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
242807 if( pList==0 ){
242811 pIter->pLeaf->p = (u8*)pList;
242816 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
243332 const u8 *pList = 0;
243335 sqlite3Fts5HashScanEntry(p->pHash, (const char**)&z, &n, &pList, &nList);
243336 if( pList ){
243339 pLeaf->p = (u8*)pList;