Lines Matching defs:pX
24021 struct tm *pX;
24026 pX = localtime(t);
24032 pX = pTm;
24034 pX = 0;
24038 if( pX ) *pTm = *pX;
24042 rc = pX==0;
28021 static int debugMutexHeld(sqlite3_mutex *pX){
28022 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28025 static int debugMutexNotheld(sqlite3_mutex *pX){
28026 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28072 static void debugMutexFree(sqlite3_mutex *pX){
28073 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28095 static void debugMutexEnter(sqlite3_mutex *pX){
28096 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28097 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
28100 static int debugMutexTry(sqlite3_mutex *pX){
28101 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28102 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
28113 static void debugMutexLeave(sqlite3_mutex *pX){
28114 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
28115 assert( debugMutexHeld(pX) );
28117 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
31626 Window *pX;
31629 for(pX=p->pWin; pX; pX=pX->pNextWin){
31630 sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0);
31656 Window *pX;
31658 for(pX=p->pWinDefn; pX; pX=pX->pNextWin){
31659 sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0);
32087 const Expr *pX, *pY, *pZ;
32088 pX = pExpr->pLeft;
32094 sqlite3TreeViewExpr(pView, pX, 1);
41765 unixShm *pX;
41770 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
41773 if( pX->exclMask & (1<<i) ){
41776 }else if( pX->sharedMask & (1<<i) ){
49152 winShm *pX; /* For looping over all siblings */
49176 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
49177 if( pX==p ) continue;
49178 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
49179 allMask |= pX->sharedMask;
49201 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
49202 if( (pX->exclMask & mask)!=0 ){
49206 allShared |= pX->sharedMask;
49226 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
49227 if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
53855 PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
53856 pX->page.pBuf = zBulk;
53857 pX->page.pExtra = &pX[1];
53858 pX->isBulkLocal = 1;
53859 pX->isAnchor = 0;
53860 pX->pNext = pCache->pFree;
53861 pX->pLruPrev = 0; /* Initializing this saves a valgrind error */
53862 pCache->pFree = pX;
73169 BtCursor *pX; /* Looping over other all cursors */
73210 for(pX=pBt->pCursor; pX; pX=pX->pNext){
73211 if( pX->pgnoRoot==iTable ){
73212 pX->curFlags |= BTCF_Multiple;
75442 const BtreePayload *pX, /* Payload with which to construct the cell */
75466 nPayload = pX->nData + pX->nZero;
75467 pSrc = pX->pData;
75468 nSrc = pX->nData;
75471 nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey);
75473 assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
75474 nSrc = nPayload = (int)pX->nKey;
75475 pSrc = pX->pKey;
75528 assert( info.nKey==pX->nKey );
77503 /* Overwrite content from pX into pDest. Only do the write if the
77509 const BtreePayload *pX, /* Source of data to write */
77513 int nData = pX->nData - iOffset;
77527 int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
77532 if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
77539 memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt);
77547 ** contained in pX.
77549 static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
77550 int iOffset; /* Next byte of pX->pData to write */
77551 int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */
77564 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
77587 rc = btreeOverwriteContent(pPage, pPage->aData+4, pX,
77600 ** is described by the pX object. The pCur cursor is used only to
77604 ** For a table btree (used for rowid tables), only the pX.nKey value of
77605 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
77606 ** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields
77610 ** key is an arbitrary byte sequence stored in pX.pKey,nKey. The
77611 ** pX.pData,nData,nZero fields must be zero.
77624 ** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked
77625 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
77630 const BtreePayload *pX, /* Content of the row to be inserted */
77692 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
77695 assert( pX->pKey==0 );
77699 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
77708 assert( pX->nKey==pCur->info.nKey );
77717 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
77720 assert( pX->nData>=0 && pX->nZero>=0 );
77722 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
77725 return btreeOverwriteCell(pCur, pX);
77733 rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
77751 if( pX->nMem ){
77754 r.aMem = pX->aMem;
77755 r.nField = pX->nMem;
77760 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
77772 if( pCur->info.nKey==pX->nKey ){
77774 x2.pData = pX->pKey;
77775 x2.nData = pX->nKey;
77785 assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
77798 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
77816 rc = fillInCell(pPage, newCell, pX, &szNew);
77910 pCur->pKey = sqlite3Malloc( pX->nKey );
77914 memcpy(pCur->pKey, pX->pKey, pX->nKey);
77918 pCur->nKey = pX->nKey;
81575 Mem *pX;
81576 for(i=1, pX=pVdbe->aMem+1; i<pVdbe->nMem; i++, pX++){
81577 if( pX->pScopyFrom==pMem ){
81581 (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem));
81583 /* If pX is marked as a shallow copy of pMem, then try to verify that
81584 ** no significant changes have been made to pX since the OP_SCopy.
81586 ** function for pX. Minor changes, such as adding or removing a
81589 mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
81590 assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i );
81592 /* pMem is the register that is changing. But also mark pX as
81594 pX->flags = MEM_Undefined;
81595 pX->pScopyFrom = 0;
83485 VdbeOp *pX = &v->aOp[j];
83486 if( pX->opcode==OP_Return ){
83487 if( pX->p1==iRetReg ) break;
83490 if( pX->opcode==OP_Noop ) continue;
83491 if( pX->opcode==OP_Explain ) continue;
94528 Btree *pX;
94563 pX = pDb->pBt;
94564 assert( pX!=0 );
94610 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
98654 Mem *pX;
98673 pX = &aMem[pOp->p3];
98675 assert( memIsValid(pX) );
98676 memAboutToChange(p, pX);
98677 apArg[i] = pX;
98678 pX++;
108388 ** pX is the RHS of an IN operator. If pX is a SELECT statement
108390 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
108395 static Select *isCandidateForInOpt(const Expr *pX){
108401 if( !ExprUseXSelect(pX) ) return 0; /* Not a subquery */
108402 if( ExprHasProperty(pX, EP_VarSelect) ) return 0; /* Correlated subq */
108403 p = pX->x.pSelect;
108471 ** The pX parameter is the expression on the RHS of the IN operator, which
108491 ** An existing b-tree might be used if the RHS expression pX is a simple
108498 ** pX->iTable made to point to the ephemeral table instead of an
108501 ** will be set on pX and the pX->y.sub fields will be set to show where
108555 Expr *pX, /* The IN expression */
108567 assert( pX->op==TK_IN );
108576 if( prRhsHasNull && ExprUseXSelect(pX) ){
108578 ExprList *pEList = pX->x.pSelect->pEList;
108590 if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){
108629 Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
108672 Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
108732 && ExprUseXList(pX)
108733 && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
108752 assert( pX->op==TK_IN );
108753 sqlite3CodeRhsOfIN(pParse, pX, iTab);
108762 n = sqlite3ExprVectorSize(pX->pLeft);
110599 Expr *pX; /* The X expression */
110610 if( (pX = pExpr->pLeft)!=0 ){
110611 pDel = sqlite3ExprDup(db, pX, 0);
110616 testcase( pX->op==TK_COLUMN );
110630 if( pX ){
120210 Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
120213 if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
129806 Expr *pX = pList->a[k].pExpr;
129807 int y = sqlite3ExprCodeTarget(pParse, pX, iRegStore);
129810 ExprHasProperty(pX, EP_Subquery) ? OP_Copy : OP_SCopy, y, iRegStore);
140445 struct ExprList_item *pX = &pEList->a[i];
140449 if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){
140452 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
140471 assert( zName==pX->zEName ); /* pointer comparison intended */
140498 if( pX->fg.bNoExpand ){
140502 if( zName && sqlite3HashInsert(&ht, zName, pX)==pX ){
143325 Select *pX;
143326 for(pX=pSubq; pX; pX=pX->pPrior){
143327 assert( (pX->selFlags & (SF_Recursive))==0 );
143543 Select *pX;
143552 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
143553 if( pX==0 ) return WRC_Continue;
144197 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
144198 assert( pX->zEName==0 );
144199 pX->zEName = sqlite3MPrintf(db,"..%s", zUName);
144200 pX->fg.eEName = ENAME_TAB;
144201 pX->fg.bUsingTerm = 1;
144209 struct ExprList_item *pX; /* Newly added ExprList term */
144271 pX = &pNew->a[pNew->nExpr-1];
144272 assert( pX->zEName==0 );
144275 pX->zEName = sqlite3DbStrDup(db, pNestedFrom->a[j].zEName);
144276 testcase( pX->zEName==0 );
144278 pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
144280 testcase( pX->zEName==0 );
144282 pX->fg.eEName = ENAME_TAB;
144288 pX->fg.bNoExpand = 1;
144291 pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
144292 pX->fg.eEName = ENAME_NAME;
144294 pX->zEName = sqlite3DbStrDup(db, zName);
144295 pX->fg.eEName = ENAME_NAME;
146445 Trigger *pX;
146447 for(pX=pList; pX; pX=pX->pNext){
146448 printf(" %s", pX->zName);
152368 ** pX is an expression of the form: (vector) IN (SELECT ...)
152373 ** This routine makes a copy of the input pX expression and then adjusts
152385 ** The pX expression
152392 ** The reduced pX is different from the original (obviously) and thus is
152400 Expr *pX /* The IN expression to be reduced */
152404 pNew = sqlite3ExprDup(db, pX, 0);
152419 if( pLoop->aLTerm[i]->pExpr==pX ){
152461 sqlite3TreeViewExpr(0, pX, 0);
152493 Expr *pX = pTerm->pExpr;
152499 if( pX->op==TK_EQ || pX->op==TK_IS ){
152500 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
152501 }else if( pX->op==TK_ISNULL ){
152522 assert( pX->op==TK_IN );
152526 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
152533 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
152537 if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
152538 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
152543 pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
152546 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab);
152549 sqlite3ExprDelete(db, pX);
152551 int n = sqlite3ExprVectorSize(pX->pLeft);
152553 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
152555 pX = pExpr;
152586 if( pLoop->aLTerm[i]->pExpr==pX ){
153509 Expr *pX; /* The expression that defines the start bound */
153528 pX = pStart->pExpr;
153529 assert( pX!=0 );
153531 if( sqlite3ExprIsVector(pX->pRight) ){
153533 codeExprOrVector(pParse, pX->pRight, r1, 1);
153534 testcase( pX->op==TK_GT );
153535 testcase( pX->op==TK_GE );
153536 testcase( pX->op==TK_LT );
153537 testcase( pX->op==TK_LE );
153538 op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1];
153539 assert( pX->op!=TK_GT || op==OP_SeekGE );
153540 assert( pX->op!=TK_GE || op==OP_SeekGE );
153541 assert( pX->op!=TK_LT || op==OP_SeekLE );
153542 assert( pX->op!=TK_LE || op==OP_SeekLE );
153544 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
153546 op = aMoveOp[(pX->op - TK_GT)];
153550 VdbeCoverageIf(v, pX->op==TK_GT);
153551 VdbeCoverageIf(v, pX->op==TK_LE);
153552 VdbeCoverageIf(v, pX->op==TK_LT);
153553 VdbeCoverageIf(v, pX->op==TK_GE);
153561 Expr *pX;
153562 pX = pEnd->pExpr;
153563 assert( pX!=0 );
153568 codeExprOrVector(pParse, pX->pRight, memEndValue, 1);
153569 if( 0==sqlite3ExprIsVector(pX->pRight)
153570 && (pX->op==TK_LT || pX->op==TK_GT)
153576 if( 0==sqlite3ExprIsVector(pX->pRight) ){
156863 Expr *pX; /* An expression being tested */
156887 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
156891 if( pScan->aiCur[j]==pX->iTable
156892 && pScan->aiColumn[j]==pX->iColumn ){
156897 pScan->aiCur[j] = pX->iTable;
156898 pScan->aiColumn[j] = pX->iColumn;
156907 pX = pTerm->pExpr;
156908 if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
156911 assert(pX->pLeft);
156912 pColl = sqlite3ExprCompareCollSeq(pParse, pX);
156919 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
156920 && pX->op==TK_COLUMN
156921 && pX->iTable==pScan->aiCur[0]
156922 && pX->iColumn==pScan->aiColumn[0]
157490 Expr *pX = pTerm->pExpr;
157493 pColl = sqlite3ExprCompareCollSeq(pParse, pX);
158868 const WhereLoop *pX, /* First WhereLoop to compare */
158872 if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
158875 if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0;
158876 if( pY->nSkip > pX->nSkip ) return 0;
158877 for(i=pX->nLTerm-1; i>=0; i--){
158878 if( pX->aLTerm[i]==0 ) continue;
158880 if( pY->aLTerm[j]==pX->aLTerm[i] ) break;
158884 if( (pX->wsFlags&WHERE_IDX_ONLY)!=0
158939 ** If pX is a WhereLoop that pTemplate can replace, then return the
158940 ** link that points to pX.
159176 WhereTerm *pTerm, *pX;
159188 pX = pLoop->aLTerm[j];
159189 if( pX==0 ) continue;
159190 if( pX==pTerm ) break;
159191 if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
160420 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
160421 if( pX->pLeft ){
160422 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
161090 Expr *pX = pLoop->aLTerm[j]->pExpr;
161092 if( pLoop->aLTerm[i]->pExpr==pX ){
161345 WhereLoop **pX; /* Used to divy up the pSpace memory */
161378 pX = (WhereLoop**)(aFrom+mxChoice);
161379 for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){
161380 pFrom->aLoop = pX;
161389 aSortCost = (LogEst*)pX;
161393 assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX );
180041 const unsigned char *pX = (const unsigned char*)pEnd;
180045 u64 c = p<pX ? *p : 0;
235181 PrefixMerger *pX = &aMerger[i];
235182 if( pX->iter.aPoslist && pX->iter.iRowid==iLastRowid ){
235183 fts5DoclistIterNext(&pX->iter);
235184 fts5PrefixMergerInsertByRowid(&pHead, pX);