Lines Matching defs:p2
10794 sqlite3_snapshot *p2
15578 int p2; /* Second parameter (often the jump destination) */
15635 signed char p2; /* Second parameter (often the jump destination) */
19876 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
32483 /* a: p0<<14 | p2 (unmasked) */
32511 /* a: p0<<14 | p2 (masked) */
32513 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
32518 /* s: p0<<14 | p2 (masked) */
32523 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
32537 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
32540 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
32561 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
32657 /* a: p0<<14 | p2 (unmasked) */
32714 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
63836 ** Return a +ve value if snapshot p1 is newer than p2. A -ve value if
63837 ** p1 is older than p2 and zero if p1 and p2 are the same snapshot.
63839 SQLITE_API int sqlite3_snapshot_cmp(sqlite3_snapshot *p1, sqlite3_snapshot *p2){
63841 WalIndexHdr *pHdr2 = (WalIndexHdr*)p2;
78599 ** p1, p2, p3 Operands
78605 static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
78609 return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
78611 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
78619 return growOp3(p, op, p1, p2, p3);
78626 pOp->p2 = p2;
78654 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
78655 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
78709 int p2, /* The P2 operand */
78714 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
78732 int p2, /* First argument register */
78757 p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
78770 int p2, /* The P2 operand */
78777 return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
78789 return pOp->p2;
78866 int p2, /* The P2 operand */
78870 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
79087 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
79103 if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
79189 if( pOp->p2!=0 ) p->readOnly = 0;
79213 assert( pOp->p2>=0 );
79222 assert( pOp->p2>=0 );
79227 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
79241 if( pOp->p2<0 ){
79246 assert( ADDR(pOp->p2)<-pParse->nLabel );
79247 pOp->p2 = aLabel[ADDR(pOp->p2)];
79255 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
79364 pOut->p2 = aOp->p2;
79365 assert( aOp->p2>=0 );
79366 if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
79367 pOut->p2 += p->nOp;
79430 sqlite3VdbeGetOp(p,addr)->p2 = val;
79828 if( c=='2' ) return pOp->p2;
80231 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3,
80535 sqlite3VdbeMemSetInt64(pMem+1, pOp->p2);
80544 sqlite3VdbeMemSetInt64(pMem+3, pOp->p2);
80771 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
86028 ** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3)
86593 ** Return the register of pOp->p2 after first preparing it to be
86603 assert( pOp->p2>0 );
86604 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
86605 pOut = &p->aMem[pOp->p2];
86751 assert( pOp->p2>0 );
86752 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
86753 assert( memIsValid(&aMem[pOp->p2]) );
86754 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
86755 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
86765 assert( pOp->p2>0 );
86766 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
86767 memAboutToChange(p, &aMem[pOp->p2]);
86836 assert( pOp->p2 < (int)(pOp - aOp) );
86837 assert( pOp->p2 > 1 );
86838 pOp = &aOp[pOp->p2 - 2];
86845 pOp = &aOp[pOp->p2 - 1];
86897 pOp = &aOp[pOp->p2 - 1];
86927 assert( pOp->p2>=0 && pOp->p2<p->nOp );
86933 if( pOp->p2 ) goto jump_to_p2;
86952 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
86953 pOp = &aOp[pCaller->p2 - 1];
86994 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
87037 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
87046 if( pOp->p2==OE_Ignore ){
87048 ** currently being halted. If the p2 instruction of this OP_Halt
87051 ** as the p2 of the calling OP_Program. */
87052 pcx = p->aOp[pcx].p2-1;
87060 p->errorAction = (u8)pOp->p2;
87219 cnt = pOp->p3-pOp->p2;
87284 pOut = &aMem[pOp->p2];
87305 int p2; /* Register to copy to */
87309 p2 = pOp->p2;
87310 assert( n>0 && p1>0 && p2>0 );
87311 assert( p1+n<=p2 || p2+n<=p1 );
87314 pOut = &aMem[p2];
87332 REGISTER_TRACE(p2++, pOut);
87352 pOut = &aMem[pOp->p2];
87361 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
87384 pOut = &aMem[pOp->p2];
87405 pOut = &aMem[pOp->p2];
87422 assert( pOp->p2==1 );
87442 assert( p->nResColumn==pOp->p2 );
87444 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
87454 for(i=0; i<pOp->p2; i++){
87503 pIn2 = &aMem[pOp->p2];
87608 pIn2 = &aMem[pOp->p2];
87740 pIn2 = &aMem[pOp->p2];
87794 pIn1->u.i += pOp->p2;
87811 if( pOp->p2==0 ){
87863 assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
87864 testcase( pOp->p2==SQLITE_AFF_TEXT );
87865 testcase( pOp->p2==SQLITE_AFF_BLOB );
87866 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
87867 testcase( pOp->p2==SQLITE_AFF_INTEGER );
87868 testcase( pOp->p2==SQLITE_AFF_REAL );
87873 rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
88015 pOut = &aMem[pOp->p2];
88019 REGISTER_TRACE(pOp->p2, pOut);
88099 pOut = &aMem[pOp->p2];
88120 REGISTER_TRACE(pOp->p2, pOut);
88207 int p2;
88228 p2 = pOp->p2;
88234 assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
88237 assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
88243 assert( memIsValid(&aMem[p2+idx]) );
88245 REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
88249 iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
88252 && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))
88273 VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
88306 v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
88348 sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
88362 pOut = &aMem[pOp->p2];
88380 pOut = &aMem[pOp->p2];
88552 u32 p2; /* column number to retrieve */
88570 p2 = (u32)pOp->p2;
88575 rc = sqlite3VdbeCursorMoveto(&pC, &p2);
88582 assert( p2<(u32)pC->nField );
88643 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
88656 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
88662 /* Make sure at least the first p2+1 entries of the header have been
88665 if( pC->nHdrParsed<=p2 ){
88667 ** to extract additional fields up through the p2+1-th field
88680 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
88697 }while( (u32)i<=p2 && zHdr<zEndHdr );
88724 ** still not up to p2, that means that the record has fewer than p2
88727 if( pC->nHdrParsed<=p2 ){
88736 t = pC->aType[p2];
88739 /* Extract the content for the p2+1-th column. Control can only
88740 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
88743 assert( p2<pC->nHdrParsed );
88749 assert( t==pC->aType[p2] );
88750 if( pC->szRow>=aOffset[p2+1] ){
88753 zData = pC->aRow + aOffset[p2];
88797 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
88833 assert( pOp->p2>0 );
88834 assert( zAffinity[pOp->p2]==0 );
88930 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
88932 nField = pOp->p2;
88937 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
89389 iRollback = pOp->p2;
89478 assert( p->readOnly==0 || pOp->p2==0 );
89479 assert( pOp->p2>=0 && pOp->p2<=2 );
89482 if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
89489 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
89502 && pOp->p2
89609 assert( pOp->p2<SQLITE_N_BTREE_META );
89617 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
89618 if( pOp->p2==BTREE_SCHEMA_VERSION ){
89622 }else if( pOp->p2==BTREE_FILE_FORMAT ){
89723 u32 p2;
89733 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
89754 p2 = (u32)pOp->p2;
89772 assert( p2>0 );
89773 assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
89775 pIn2 = &aMem[p2];
89779 p2 = (int)pIn2->u.i;
89780 /* The p2 value always comes from a prior OP_CreateBtree opcode and
89781 ** that opcode will always set the p2 value to 2 or more or else fail.
89784 assert( p2>=2 );
89801 pCur->pgnoRoot = p2;
89805 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
89817 testcase( pOp->p2 & OPFLAG_SEEKEQ );
89836 pOrig = p->apCsr[pOp->p2];
89906 assert( pOp->p2>=0 );
89910 assert( pOp->p2==0 ); /* Only used when number of columns is zero */
89926 pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE);
89984 assert( pOp->p2>=0 );
89985 pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER);
90037 pCx->seekResult = pOp->p2;
90183 assert( pOp->p2!=0 );
90274 assert( pOp[1].p2==pOp[0].p2 );
90351 assert( pOp->p2>0 );
90417 /* pOp->p2 points to the first instruction past the OP_IdxGT that
90419 assert( pOp->p2>=(int)(pOp-aOp)+2 );
90420 assert( aOp[pOp->p2-1].opcode==OP_IdxGT || aOp[pOp->p2-1].opcode==OP_IdxGE );
90421 testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
90422 assert( pOp[1].p1==aOp[pOp->p2-1].p1 );
90423 assert( pOp[1].p2==aOp[pOp->p2-1].p2 );
90424 assert( pOp[1].p3==aOp[pOp->p2-1].p3 );
90523 assert( pOp->p3>=pOp->p2 );
90524 if( pC->seekHit<pOp->p2 ){
90525 pC->seekHit = pOp->p2;
90826 if( pOp->p2==0 ){
91037 pData = &aMem[pOp->p2];
91047 REGISTER_TRACE(pOp->p2, pData);
91070 sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
91131 pSrc = p->apCsr[pOp->p2];
91179 opflags = pOp->p2;
91249 if( pOp->p2 & OPFLAG_NCHANGE ){
91333 pOut = &aMem[pOp->p2];
91408 REGISTER_TRACE(pOp->p2, pOut);
91526 assert( pOp->p2==0 );
91537 if( pOp->p2>0 ){
91641 assert( pOp->p2>0 && pOp->p2<p->nOp );
91792 pIn2 = &aMem[pOp->p2];
91828 pIn2 = &aMem[pOp->p2];
91859 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
91870 r.aMem = &aMem[pOp->p2];
91965 sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
92190 assert( DbMaskTest(p->btreeMask, pOp->p2) );
92192 db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0)
92436 nRoot = pOp->p2;
92474 pIn2 = &aMem[pOp->p2];
92749 db->nDeferredImmCons += pOp->p2;
92751 db->nDeferredCons += pOp->p2;
92753 p->nFkConstraint += pOp->p2;
92804 pIn2 = &aMem[pOp->p2];
92957 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
92958 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
93007 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
93013 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
93125 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
93126 || pOp->p2==SQLITE_CHECKPOINT_FULL
93127 || pOp->p2==SQLITE_CHECKPOINT_RESTART
93128 || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
93130 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
93261 pOp->p2 ? &aMem[pOp->p2] : 0);
93309 assert( pOp->p2==0 || pOp->p2==1 );
93311 sqlite3ExpirePreparedStatements(db, pOp->p2);
93313 p->expired = pOp->p2+1;
93371 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
93418 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
93419 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
93420 rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
93600 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
93732 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
93744 nArg = pOp->p2;
93879 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
93887 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
94000 assert( pOp->p2>0 );
94088 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
94091 for(i=0; i<pOp->p2; i++, pMem++){
94147 registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
94529 aOp[0].p2 = pTab->tnum;
94539 aOp[1].p2 = pTab->tnum;
94551 aOp[3].p2 = pTab->nCol;
95557 const u8 * const p2 = (const u8 * const)pKey2;
95559 const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */
95566 getVarint32NR(&p2[1], n2);
95599 const u8 * const p2 = (const u8 * const)pKey2;
95601 const int s2 = p2[1]; /* Right hand serial type */
95603 const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */
96089 ** Merge the two sorted lists p1 and p2 into a single list.
96094 SorterRecord *p2 /* Second list to merge */
96100 assert( p1!=0 && p2!=0 );
96104 pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
96112 *pp = p2;
96116 *pp = p2;
96117 pp = &p2->u.pNext;
96118 p2 = p2->u.pNext;
96120 if( p2==0 ){
96784 PmaReader *p2;
96797 p2 = &pMerger->aReadr[i2];
96801 }else if( p2->pFd==0 ){
96809 pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey
97579 "p2 INT,"
97722 Pgno iRoot = (Pgno)pOp->p2;
97758 case 3: /* p2 */
97759 sqlite3_result_int(ctx, pOp->p2);
105427 && pOp->p2+pOp->p3+1==target+i
116280 ** Append the contents of SrcList p2 to SrcList p1 and return the resulting
116281 ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2
116284 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
116286 if( p2 ){
116287 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
116289 sqlite3SrcListDelete(pParse->db, p2);
116292 memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
116293 sqlite3DbFree(pParse->db, p2);
118713 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
118720 ** If p2 is negative, return the p2 characters preceding p1.
118731 i64 p1, p2;
118766 p2 = sqlite3_value_int(argv[2]);
118767 if( p2<0 ){
118768 p2 = -p2;
118772 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
118777 p2 += p1;
118778 if( p2<0 ) p2 = 0;
118783 }else if( p2>0 ){
118784 p2--;
118787 p1 -= p2;
118789 p2 += p1;
118793 assert( p1>=0 && p2>=0 );
118799 for(z2=z; *z2 && p2; p2--){
118805 if( p1+p2>len ){
118806 p2 = len-p1;
118807 if( p2<0 ) p2 = 0;
118809 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
122352 Pgno tnum = pOp->p2;
122598 aOp[0].p2 = memId;
122604 aOp[4].p2 = memId+1;
122607 aOp[7].p2 = memId+2;
122609 aOp[10].p2 = memId;
122663 aOp[1].p2 = memId+1;
122666 aOp[3].p2 = iRec;
124484 int p2; /* New P2 value for copied conflict check opcode */
124487 p2 = lblRecheckOk;
124489 p2 = x.p2;
124492 sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type);
124494 VdbeCoverageIf(v, p2!=x.p2);
128335 aOp[2].p2 = iAddr+4;
129339 aOp[0].p2 = 1-mxErr;
129468 aOp[1].p2 = iCookie;
131824 pOp->p2 = nKey + nData;
132120 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
132194 pOp->p2 = regPrev;
143387 int p1, p2; /* Operands of the opcode used to end the loop */
145275 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
145317 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
145341 assert( pOp->opcode!=OP_Rowid || pOp->p2==iReg+j+2 );
145343 sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
145494 pLevel->p2 = start;
145805 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
146235 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
148936 pOp->p1 = pOp->p2 + iRegister;
148937 pOp->p2 = pOp->p3;
149708 sqlite3_value *p2 = 0; /* Value extracted from pUpper */
149717 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
149718 nUpper = p2 ? 0 : p->nSample;
149721 if( p1 || p2 ){
149730 if( rc==SQLITE_OK && p2 ){
149731 int res = sqlite3MemCompare(p2, pVal, pColl);
149756 sqlite3ValueFree(p2);
153691 sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2);
153696 sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
153704 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1);
153885 int x = pOp->p2;
153897 pOp->p2 = x;
155265 SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){
155267 if( NEVER(p1==0) || NEVER(p2==0) ) return 1;
155268 if( p1->eFrmType!=p2->eFrmType ) return 1;
155269 if( p1->eStart!=p2->eStart ) return 1;
155270 if( p1->eEnd!=p2->eEnd ) return 1;
155271 if( p1->eExclude!=p2->eExclude ) return 1;
155272 if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
155273 if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
155274 if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){
155277 if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){
155281 if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){
168793 sqlite3 *p2;
168799 for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
168800 if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
168801 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
172235 char *p2 = *pp2;
172237 while( *p1 || *p2 ){
172248 if( *p2==POS_COLUMN ){
172249 fts3GetVarint32(&p2[1], &iCol2);
172252 else if( *p2==POS_END ) iCol2 = 0x7fffffff;
172261 p2 += n;
172263 /* At this point, both p1 and p2 point to the start of column-lists
172273 fts3GetDeltaVarint(&p2, &i2);
172282 fts3ReadNextPos(&p2, &i2);
172286 fts3ReadNextPos(&p2, &i2);
172293 p2 += fts3PutColNumber(&p, iCol2);
172294 fts3ColumnlistCopy(&p, &p2);
172301 *pp2 = p2 + 1;
172338 char *p2 = *pp2;
172345 assert_fts3_nc( p!=0 && *p1!=0 && *p2!=0 );
172350 if( *p2==POS_COLUMN ){
172351 p2++;
172352 p2 += fts3GetVarint32(p2, &iCol2);
172368 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
172382 if( (*p2&0xFE)==0 ) break;
172383 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
172396 fts3ColumnlistCopy(0, &p2);
172397 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
172398 if( 0==*p1 || 0==*p2 ) break;
172402 p2++;
172403 p2 += fts3GetVarint32(p2, &iCol2);
172406 /* Advance pointer p1 or p2 (whichever corresponds to the smaller of
172417 fts3ColumnlistCopy(0, &p2);
172418 if( 0==*p2 ) break;
172419 p2++;
172420 p2 += fts3GetVarint32(p2, &iCol2);
172424 fts3PoslistCopy(0, &p2);
172427 *pp2 = p2;
172460 char *p2 = *pp2;
172470 *pp2 = p2;
172605 char *p2 = a2;
172647 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
172648 while( p1 || p2 ){
172651 if( p2 && p1 && iDiff==0 ){
172653 rc = fts3PoslistMerge(&p, &p1, &p2);
172656 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
172657 }else if( !p2 || (p1 && iDiff<0) ){
172663 fts3PoslistCopy(&p, &p2);
172664 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
172667 assert( (p-aOut)<=((p1?(p1-a1):n1)+(p2?(p2-a2):n2)+FTS3_VARINT_MAX-1) );
172707 char *p2 = aRight;
172722 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
172724 while( p1 && p2 ){
172732 if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
172738 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
172743 fts3PoslistCopy(0, &p2);
172744 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
174327 char *p2 = aOut;
174330 fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2);
174355 char *p2;
174360 p2 = pPhrase->doclist.pList;
174364 p2 = aPoslist;
174375 if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){
175207 char *p2;
175213 p2 = pOut = pPhrase->doclist.pList;
175215 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
179436 const sqlite3_tokenizer_module *p2;
179444 rc = queryTokenizer(db, "simple", &p2);
179446 assert( p1==p2 );
179447 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
179449 assert( p2==0 );
179456 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
179458 assert( p2==p1 );
193292 ** Store the union of cells p1 and p2 in p1.
193294 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
193298 p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f);
193299 p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f);
193304 p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i);
193305 p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i);
193312 ** Return true if the area covered by p2 is a subset of the area covered
193315 static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
193320 RtreeCoord *a2 = &p2->aCoord[ii];
195303 RtreeCoord p1, p2;
195319 readCoord(&pParent[4*(2*i + 1)], &p2);
195322 || (pCheck->bInt ? c2.i>p2.i : c2.f>p2.f)
196404 static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2);
196420 GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);
196421 if( p1 && p2 ){
196422 int x = geopolyOverlap(p1, p2);
196430 sqlite3_free(p2);
196447 unsigned char side; /* 1 for p1, 2 for p2 */
196621 static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){
196622 sqlite3_int64 nVertex = p1->nVertex + p2->nVertex + 2;
196642 geopolyAddSegments(p, p2, 2);
196750 GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);
196751 if( p1 && p2 ){
196752 int x = geopolyOverlap(p1, p2);
196760 sqlite3_free(p2);
212491 static int sqlite3Fts5ExprAnd(Fts5Expr **pp1, Fts5Expr *p2);
215540 const char *p2 = fts5ConfigSkipWhitespace(p);
215541 if( *p2=='\'' ){
215542 p = fts5ConfigSkipLiteral(p2);
215544 p = fts5ConfigSkipBareword(p2);
215547 memcpy(pSpace, p2, p-p2);
215550 pSpace += (p - p2) + 1;
216583 static int sqlite3Fts5ExprAnd(Fts5Expr **pp1, Fts5Expr *p2){
216589 int nPhrase = p1->nPhrase + p2->nPhrase;
216591 p1->pRoot = sqlite3Fts5ParseNode(&sParse, FTS5_AND, p1->pRoot, p2->pRoot,0);
216592 p2->pRoot = 0;
216602 memmove(&ap[p2->nPhrase], ap, p1->nPhrase*sizeof(Fts5ExprPhrase*));
216603 for(i=0; i<p2->nPhrase; i++){
216604 ap[i] = p2->apExprPhrase[i];
216610 sqlite3_free(p2->apExprPhrase);
216611 sqlite3_free(p2);
216613 *pp1 = p2;
217189 ** res = (*p1) - (*p2)
217201 Fts5ExprNode *p2
217203 if( p2->bEof ) return -1;
217205 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
217530 Fts5ExprNode *p2 = pNode->apChild[1];
217534 int cmp = fts5NodeCompare(pExpr, p1, p2);
217536 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
217537 cmp = fts5NodeCompare(pExpr, p1, p2);
217540 if( cmp || p2->bNomatch ) break;
217547 fts5ExprNodeZeroPoslist(p2);
219440 Fts5HashEntry *p2
219444 u8 *pPtr = p2 ? (u8*)p2 : (u8*)p;
219470 if( p2==0 ){
219646 Fts5HashEntry *p2 = pRight;
219650 while( p1 || p2 ){
219652 *ppOut = p2;
219653 p2 = 0;
219654 }else if( p2==0 ){
219660 char *zKey2 = fts5EntryKey(p2);
219664 /* p2 is smaller */
219665 *ppOut = p2;
219666 ppOut = &p2->pScanNext;
219667 p2 = p2->pScanNext;
220864 Fts5StructureSegment *p2 = &p->pStruct->aLevel[i].aSeg[j];
220865 assert_nc( p1->iSegid==p2->iSegid );
220866 assert_nc( p1->pgnoFirst==p2->pgnoFirst );
220867 assert_nc( p1->pgnoLast==p2->pgnoLast );
222333 Fts5SegIter *p2,
222337 int i2 = p2 - pIter->aSeg;
222339 if( p1->pLeaf || p2->pLeaf ){
222342 }else if( p2->pLeaf==0 ){
222345 int nMin = MIN(p1->term.n, p2->term.n);
222346 int res = fts5Memcmp(p1->term.p, p2->term.p, nMin);
222347 if( res==0 ) res = p1->term.n - p2->term.n;
222351 assert( p1->iRowid!=p2->iRowid );
222352 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
222392 Fts5SegIter *p2 = &pIter->aSeg[i+1];
222394 fts5AssertComparisonResult(pIter, p1, p2, pRes);
222399 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
222401 fts5AssertComparisonResult(pIter, p1, p2, pRes);
222422 Fts5SegIter *p2; /* Right-hand Fts5SegIter */
222436 p2 = &pIter->aSeg[i2];
222441 }else if( p2->pLeaf==0 ){ /* If p2 is at EOF */
222444 int res = fts5BufferCompare(&p1->term, &p2->term);
222449 if( p1->iRowid==p2->iRowid ){
222450 p1->bDel = p2->bDel;
222453 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
224676 ** Swap the contents of buffer *p1 with that of *p2.
224678 static void fts5BufferSwap(Fts5Buffer *p1, Fts5Buffer *p2){
224680 *p1 = *p2;
224681 *p2 = tmp;
224710 Fts5Buffer *p2 = &aBuf[0];
224716 sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
224720 fts5NextRowid(p2, &i2, &iRowid2);
224734 fts5NextRowid(p2, &i2, &iRowid2);
232851 /* a: p0<<14 | p2 (unmasked) */
232929 /* a: p0<<14 | p2 (unmasked) */
232957 /* a: p0<<14 | p2 (masked) */
232959 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
232964 /* s: p0<<14 | p2 (masked) */
232969 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
232982 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
232985 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
233006 /* a: p2<<28 | p4<<14 | p6 (unmasked) */