Lines Matching refs:pOp
12160 int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */
86108 static void test_addop_breakpoint(int pc, Op *pOp){
86111 (void)pOp;
86138 VdbeOp *pOp = &p->aOp[addr]; local
86139 pOp->p4type = P4_INT32;
86140 pOp->p4.i = p4;
86169 VdbeOp *pOp; local
86179 pOp = &p->aOp[i];
86180 assert( pOp!=0 );
86181 pOp->opcode = (u8)op;
86182 pOp->p5 = 0;
86183 pOp->p1 = p1;
86184 pOp->p2 = p2;
86185 pOp->p3 = p3;
86186 pOp->p4.p = 0;
86187 pOp->p4type = P4_NOTUSED;
86192 pOp->zComment = 0;
86195 pOp->nExec = 0;
86196 pOp->nCycle = 0;
86205 pOp->iSrcLine = 0;
86221 VdbeOp *pOp; local
86228 pOp = &p->aOp[i];
86229 assert( pOp!=0 );
86230 pOp->opcode = (u8)op;
86231 pOp->p5 = 0;
86232 pOp->p1 = p1;
86233 pOp->p2 = p2;
86234 pOp->p3 = p3;
86235 pOp->p4.i = p4;
86236 pOp->p4type = P4_INT32;
86241 pOp->zComment = 0;
86244 pOp->nExec = 0;
86245 pOp->nCycle = 0;
86254 pOp->iSrcLine = 0;
86389 VdbeOp *pOp; local
86391 pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
86392 return pOp->p2;
86670 Op *pOp; local
86677 while( (pOp = opIterNext(&sIter))!=0 ){
86678 int opcode = pOp->opcode;
86685 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
86690 if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1;
86696 if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1;
86701 if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
86768 Op *pOp; local
86775 pOp = &p->aOp[p->nOp-1];
86784 if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){
86787 switch( pOp->opcode ){
86789 if( pOp->p2!=0 ) p->readOnly = 0;
86807 assert( pOp->p2>=0 );
86812 if( pOp->p2>nMaxVtabArgs ) nMaxVtabArgs = pOp->p2;
86820 assert( (pOp - p->aOp) >= 3 );
86821 assert( pOp[-1].opcode==OP_Integer );
86822 assert( pOp[-1].p2==pOp->p3+1 );
86823 n = pOp[-1].p1;
86830 if( pOp->p2<0 ){
86834 assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
86835 assert( ADDR(pOp->p2)<-pParse->nLabel );
86837 pOp->p2 = aLabel[ADDR(pOp->p2)];
86842 assert( pOp->p2>0
86843 || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP0)!=0 );
86846 assert( pOp->p2<p->nOp
86847 || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)==0 );
86854 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
86856 assert( pOp>p->aOp );
86857 pOp--;
86896 VdbeOp *pOp; local
86906 pOp = &v->aOp[iFirst];
86907 for(i=iFirst; i<=iLast; i++, pOp++){
86908 if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ){
86909 int iDest = pOp->p2; /* Jump destination */
86911 if( pOp->opcode==OP_Gosub ) continue;
86912 if( pOp->p3==20230325 && pOp->opcode==OP_NotNull ){
87203 VdbeOp *pOp = sqlite3VdbeGetLastOp(p); local
87205 while( pOp->opcode==OP_ReleaseReg ) pOp--;
87207 if( pOp->p3==iDest && pOp->opcode==OP_Column ){
87208 pOp->p5 |= OPFLAG_TYPEOFARG;
87334 Op *pOp = &aOp[nOp-1]; local
87336 if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
87338 sqlite3DbFree(db, pOp->zComment);
87340 if( pOp==aOp ) break;
87341 pOp--;
87368 VdbeOp *pOp; local
87371 pOp = &p->aOp[addr];
87372 freeP4(p->db, pOp->p4type, pOp->p4.p);
87373 pOp->p4type = P4_NOTUSED;
87374 pOp->p4.z = 0;
87375 pOp->opcode = OP_Noop;
87444 Op *pOp,
87448 if( pOp->p4type ){
87449 assert( pOp->p4type > P4_FREE_IF_LE );
87450 pOp->p4type = 0;
87451 pOp->p4.p = 0;
87454 sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
87457 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
87458 pOp->p4type = P4_DYNAMIC;
87462 Op *pOp; local
87477 pOp = &p->aOp[addr];
87478 if( n>=0 || pOp->p4type ){
87479 vdbeChangeP4Full(p, pOp, zP4, n);
87485 pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
87486 pOp->p4type = P4_INT32;
87489 pOp->p4.p = (void*)zP4;
87490 pOp->p4type = (signed char)n;
87505 VdbeOp *pOp; local
87513 pOp = &p->aOp[p->nOp-1];
87514 assert( pOp->p4type==P4_NOTUSED );
87515 pOp->p4type = n;
87516 pOp->p4.p = pP4;
87614 static int translateP(char c, const Op *pOp){
87615 if( c=='1' ) return pOp->p1;
87616 if( c=='2' ) return pOp->p2;
87617 if( c=='3' ) return pOp->p3;
87618 if( c=='4' ) return pOp->p4.i;
87619 return pOp->p5;
87637 const Op *pOp, /* The opcode to be commented */
87648 zOpName = sqlite3OpcodeName(pOp->opcode);
87664 if( pOp->zComment && pOp->zComment[0] ){
87665 sqlite3_str_appendall(&x, pOp->zComment);
87670 int v1 = translateP(c, pOp);
87674 v2 = translateP(zSynopsis[ii], pOp);
87685 sqlite3_context *pCtx = pOp->p4.pCtx;
87686 if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){
87698 if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
87707 if( !seenCom && pOp->zComment ){
87708 sqlite3_str_appendf(&x, "; %s", pOp->zComment);
87710 }else if( pOp->zComment ){
87711 sqlite3_str_appendall(&x, pOp->zComment);
87800 SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
87805 switch( pOp->p4type ){
87808 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
87825 displayP4Expr(&x, pOp->p4.pExpr);
87831 CollSeq *pColl = pOp->p4.pColl;
87838 FuncDef *pDef = pOp->p4.pFunc;
87843 FuncDef *pDef = pOp->p4.pCtx->pFunc;
87848 sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
87852 sqlite3_str_appendf(&x, "%d", pOp->p4.i);
87856 sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
87860 Mem *pMem = pOp->p4.pMem;
87877 sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
87884 u32 *ai = pOp->p4.ai;
87898 zP4 = pOp->p4.pTab->zName;
87902 SubrtnSig *pSig = pOp->p4.pSubrtnSig;
87907 zP4 = pOp->p4.z;
88002 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
88010 zP4 = sqlite3VdbeDisplayP4(&dummyDb, pOp);
88012 zCom = sqlite3VdbeDisplayComment(0, pOp, zP4);
88020 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3,
88021 zP4 ? zP4 : "", pOp->p5,
88241 Op *pOp = aOp + i; local
88242 if( pOp->opcode==OP_OpenRead ) break;
88243 if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break;
88244 if( pOp->opcode==OP_ReopenIdx ) break;
88307 Op *pOp; /* Current opcode */ local
88341 pOp = aOp + i;
88347 char *zP4 = sqlite3VdbeDisplayP4(db, pOp);
88349 sqlite3VdbeMemSetInt64(pMem, pOp->p1);
88350 sqlite3VdbeMemSetInt64(pMem+1, pOp->p2);
88351 sqlite3VdbeMemSetInt64(pMem+2, pOp->p3);
88356 sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode),
88358 sqlite3VdbeMemSetInt64(pMem+2, pOp->p1);
88359 sqlite3VdbeMemSetInt64(pMem+3, pOp->p2);
88360 sqlite3VdbeMemSetInt64(pMem+4, pOp->p3);
88362 sqlite3VdbeMemSetInt64(pMem+6, pOp->p5);
88365 char *zCom = sqlite3VdbeDisplayComment(db, pOp, zP4);
88397 const VdbeOp *pOp = &p->aOp[0]; local
88398 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
88399 z = pOp->p4.z;
88413 VdbeOp *pOp; local
88416 pOp = &p->aOp[0];
88417 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
88420 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
91291 const VdbeOp *pOp; local
91295 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
91296 if( pOp->opcode==OP_PureFunc ){
91299 if( pOp->p5 & NC_IsCheck ){
91301 }else if( pOp->p5 & NC_GenCol ){
94009 Op *pOp = &aOp[iOp]; local
94010 if( pOp->p1!=iEnd ) continue;
94011 if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){
94048 Op *pOp = &p->aOp[ii]; local
94049 pOp->nExec = 0;
94050 pOp->nCycle = 0;
94483 static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
94486 (void)pOp;
94533 # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
95010 static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
95012 assert( pOp->p2>0 );
95013 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
95014 pOut = &p->aMem[pOp->p2];
95028 static u64 filterHash(const Mem *aMem, const Op *pOp){
95032 assert( pOp->p4type==P4_INT32 );
95033 for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){
95158 Op *pOp = aOp; /* Current operation */
95239 for(pOp=&aOp[p->pc]; 1; pOp++){
95244 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
95248 pOp->nExec++;
95249 pnCycle = &pOp->nCycle;
95253 pOp->nExec++;
95254 pnCycle = &pOp->nCycle;
95263 sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
95264 test_trace_breakpoint((int)(pOp - aOp),pOp,p);
95284 u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
95286 assert( pOp->p1>0 );
95287 assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
95288 assert( memIsValid(&aMem[pOp->p1]) );
95289 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
95290 REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
95293 assert( pOp->p2>0 );
95294 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
95295 assert( memIsValid(&aMem[pOp->p2]) );
95296 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
95297 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
95300 assert( pOp->p3>0 );
95301 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
95302 assert( memIsValid(&aMem[pOp->p3]) );
95303 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
95304 REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
95307 assert( pOp->p2>0 );
95308 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
95309 memAboutToChange(p, &aMem[pOp->p2]);
95312 assert( pOp->p3>0 );
95313 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
95314 memAboutToChange(p, &aMem[pOp->p3]);
95319 pOrigOp = pOp;
95322 switch( pOp->opcode ){
95377 if( pOp->p5 ){
95378 assert( pOp->p2 < (int)(pOp - aOp) );
95379 assert( pOp->p2 > 1 );
95380 pOp = &aOp[pOp->p2 - 2];
95381 assert( pOp[1].opcode==OP_ReleaseReg );
95387 pOp = &aOp[pOp->p2 - 1];
95428 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
95429 pIn1 = &aMem[pOp->p1];
95433 pIn1->u.i = (int)(pOp-aOp);
95434 REGISTER_TRACE(pOp->p1, pIn1);
95461 pIn1 = &aMem[pOp->p1];
95463 if( pOp->p3 ){ VdbeBranchTaken(1, 2); }
95464 pOp = &aOp[pIn1->u.i];
95465 }else if( ALWAYS(pOp->p3) ){
95483 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
95484 assert( pOp->p2>=0 && pOp->p2<p->nOp );
95485 assert( pOp->p3>=0 && pOp->p3<p->nOp );
95486 pOut = &aMem[pOp->p1];
95488 pOut->u.i = pOp->p3 - 1;
95490 if( pOp->p2==0 ) break;
95495 assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */
95496 assert( pOp->p2<p->nOp ); /* Jumps must be in range */
95497 pOp = &aOp[pOp->p2 - 1];
95513 pIn1 = &aMem[pOp->p1];
95519 pIn1->u.i = (int)(pOp - p->aOp) - 1;
95520 pOp = &aOp[pCaller->p2 - 1];
95539 pIn1 = &aMem[pOp->p1];
95543 pIn1->u.i = (int)(pOp - aOp);
95544 REGISTER_TRACE(pOp->p1, pIn1);
95545 pOp = &aOp[pcDest];
95558 pIn3 = &aMem[pOp->p3];
95560 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
95606 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
95608 assert( pOp->p4type==P4_NOTUSED
95609 || pOp->p4type==P4_STATIC
95610 || pOp->p4type==P4_DYNAMIC );
95615 assert( pOp->p1!=SQLITE_INTERNAL );
95617 if( p->pFrame && pOp->p1==SQLITE_OK ){
95624 if( pOp->p2==OE_Ignore ){
95634 pOp = &aOp[pcx];
95637 p->rc = pOp->p1;
95638 p->errorAction = (u8)pOp->p2;
95639 assert( pOp->p5<=4 );
95641 if( pOp->p3>0 && pOp->p4type==P4_NOTUSED ){
95643 assert( pOp->p3<=(p->nMem + 1 - p->nCursor) );
95644 zErr = sqlite3ValueText(&aMem[pOp->p3], SQLITE_UTF8);
95646 }else if( pOp->p5 ){
95649 testcase( pOp->p5==1 );
95650 testcase( pOp->p5==2 );
95651 testcase( pOp->p5==3 );
95652 testcase( pOp->p5==4 );
95653 sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
95654 if( pOp->p4.z ){
95655 p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
95658 sqlite3VdbeError(p, "%s", pOp->p4.z);
95660 pcx = (int)(pOp - aOp);
95661 sqlite3_log(pOp->p1, "abort at %d: %s; [%s]", pcx, p->zErrMsg, p->zSql);
95681 pOut = out2Prerelease(p, pOp);
95682 pOut->u.i = pOp->p1;
95693 pOut = out2Prerelease(p, pOp);
95694 assert( pOp->p4.pI64!=0 );
95695 pOut->u.i = *pOp->p4.pI64;
95707 pOut = out2Prerelease(p, pOp);
95709 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
95710 pOut->u.r = *pOp->p4.pReal;
95724 assert( pOp->p4.z!=0 );
95725 pOut = out2Prerelease(p, pOp);
95726 pOp->p1 = sqlite3Strlen30(pOp->p4.z);
95730 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
95738 if( pOp->p4type==P4_DYNAMIC ){
95739 sqlite3DbFree(db, pOp->p4.z);
95741 pOp->p4type = P4_DYNAMIC;
95742 pOp->p4.z = pOut->z;
95743 pOp->p1 = pOut->n;
95746 if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
95749 pOp->opcode = OP_String;
95768 assert( pOp->p4.z!=0 );
95769 pOut = out2Prerelease(p, pOp);
95771 pOut->z = pOp->p4.z;
95772 pOut->n = pOp->p1;
95776 if( pOp->p3>0 ){
95777 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
95778 pIn3 = &aMem[pOp->p3];
95780 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
95824 pOut = out2Prerelease(p, pOp);
95825 cnt = pOp->p3-pOp->p2;
95826 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
95827 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
95852 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
95853 pOut = &aMem[pOp->p1];
95866 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
95867 pOut = out2Prerelease(p, pOp);
95868 if( pOp->p4.z==0 ){
95869 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
95872 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
95887 assert( pOp->p1>0 && pOp->p1<=p->nVar );
95888 pVar = &p->aVar[pOp->p1 - 1];
95892 pOut = &aMem[pOp->p2];
95915 n = pOp->p3;
95916 p1 = pOp->p1;
95917 p2 = pOp->p2;
95964 n = pOp->p3;
95965 pIn1 = &aMem[pOp->p1];
95966 pOut = &aMem[pOp->p2];
95972 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
95978 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
96000 pIn1 = &aMem[pOp->p1];
96001 pOut = &aMem[pOp->p2];
96021 pIn1 = &aMem[pOp->p1];
96023 pOut = &aMem[pOp->p2];
96056 assert( p->nResColumn==pOp->p2 );
96057 assert( pOp->p1>0 || CORRUPT_DB );
96058 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
96061 p->pResultRow = &aMem[pOp->p1];
96066 for(i=0; i<pOp->p2; i++){
96068 REGISTER_TRACE(pOp->p1+i, &pMem[i]);
96082 p->pc = (int)(pOp - aOp) + 1;
96105 pIn1 = &aMem[pOp->p1];
96106 pIn2 = &aMem[pOp->p2];
96107 pOut = &aMem[pOp->p3];
96208 pIn1 = &aMem[pOp->p1];
96210 pIn2 = &aMem[pOp->p2];
96212 pOut = &aMem[pOp->p3];
96217 switch( pOp->opcode ){
96245 switch( pOp->opcode ){
96298 assert( pOp->p4type==P4_COLLSEQ );
96299 if( pOp->p1 ){
96300 sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
96344 pIn1 = &aMem[pOp->p1];
96345 pIn2 = &aMem[pOp->p2];
96346 pOut = &aMem[pOp->p3];
96353 op = pOp->opcode;
96396 pIn1 = &aMem[pOp->p1];
96399 *(u64*)&pIn1->u.i += (u64)pOp->p2;
96411 pIn1 = &aMem[pOp->p1];
96416 if( pOp->p2==0 ){
96440 pIn1 = &aMem[pOp->p1];
96445 REGISTER_TRACE(pOp->p1, pIn1);
96468 assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
96469 testcase( pOp->p2==SQLITE_AFF_TEXT );
96470 testcase( pOp->p2==SQLITE_AFF_BLOB );
96471 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
96472 testcase( pOp->p2==SQLITE_AFF_INTEGER );
96473 testcase( pOp->p2==SQLITE_AFF_REAL );
96474 pIn1 = &aMem[pOp->p1];
96478 rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
96481 REGISTER_TRACE(pOp->p1, pIn1);
96589 pIn1 = &aMem[pOp->p1];
96590 pIn3 = &aMem[pOp->p3];
96596 if( sqlite3aGTb[pOp->opcode] ){
96597 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
96603 if( sqlite3aLTb[pOp->opcode] ){
96604 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
96610 if( sqlite3aEQb[pOp->opcode] ){
96611 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
96617 VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
96622 if( pOp->p5 & SQLITE_NULLEQ ){
96628 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
96629 testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
96643 if( pOp->p5 & SQLITE_JUMPIFNULL ){
96653 affinity = pOp->p5 & SQLITE_AFF_MASK;
96688 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
96689 res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
96701 res2 = sqlite3aLTb[pOp->opcode];
96703 res2 = sqlite3aEQb[pOp->opcode];
96705 res2 = sqlite3aGTb[pOp->opcode];
96716 VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
96741 for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
96766 assert( pOp->p4type==P4_INTARRAY );
96767 assert( pOp->p4.ai );
96768 assert( pOp[1].opcode==OP_Compare );
96769 assert( pOp[1].p5 & OPFLAG_PERMUTE );
96806 if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
96809 assert( pOp>aOp );
96810 assert( pOp[-1].opcode==OP_Permutation );
96811 assert( pOp[-1].p4type==P4_INTARRAY );
96812 aPermute = pOp[-1].p4.ai + 1;
96815 n = pOp->p3;
96816 pKeyInfo = pOp->p4.pKeyInfo;
96819 p1 = pOp->p1;
96820 p2 = pOp->p2;
96853 assert( pOp[1].opcode==OP_Jump );
96866 assert( pOp>aOp && pOp[-1].opcode==OP_Compare );
96869 VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
96871 VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
96873 VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
96903 v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
96904 v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
96905 if( pOp->opcode==OP_And ){
96912 pOut = &aMem[pOp->p3];
96943 assert( pOp->p4type==P4_INT32 );
96944 assert( pOp->p4.i==0 || pOp->p4.i==1 );
96945 assert( pOp->p3==0 || pOp->p3==1 );
96946 sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
96947 sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
96959 pIn1 = &aMem[pOp->p1];
96960 pOut = &aMem[pOp->p2];
96977 pIn1 = &aMem[pOp->p1];
96978 pOut = &aMem[pOp->p2];
97014 iAddr = (int)(pOp - p->aOp);
97021 if( p->aOp[0].p1==pOp->p1 ){
97027 pOp->p1 = p->aOp[0].p1;
97039 c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
97053 c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
97065 pIn1 = &aMem[pOp->p1];
97109 assert( pOp->p1>=(-1) && pOp->p1<p->nCursor );
97110 assert( pOp->p1>=0 || (pOp->p3>=0 && pOp->p3<=(p->nMem+1 - p->nCursor)) );
97111 if( pOp->p1>=0 ){
97112 pC = p->apCsr[pOp->p1];
97114 assert( pOp->p3>=0 );
97115 if( pOp->p3<pC->nHdrParsed ){
97116 serialType = pC->aType[pOp->p3];
97143 typeMask = 1 << (pOp->p4.i - 1);
97151 assert( memIsValid(&aMem[pOp->p3]) );
97152 typeMask = 1 << (sqlite3_value_type((sqlite3_value*)&aMem[pOp->p3])-1);
97159 VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2);
97160 if( typeMask & pOp->p5 ){
97174 if( (aMem[pOp->p1].flags & MEM_Null)!=0
97175 || (aMem[pOp->p3].flags & MEM_Null)!=0
97177 sqlite3VdbeMemSetNull(aMem + pOp->p2);
97179 sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0);
97190 pIn1 = &aMem[pOp->p1];
97210 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97211 pC = p->apCsr[pOp->p1];
97213 sqlite3VdbeMemSetNull(aMem + pOp->p3);
97237 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97238 pC = p->apCsr[pOp->p1];
97239 pOut = &p->aMem[pOp->p3];
97295 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97296 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
97297 pC = p->apCsr[pOp->p1];
97298 p2 = (u32)pOp->p2;
97321 pDest = &aMem[pOp->p3];
97470 pDest = &aMem[pOp->p3];
97472 if( pOp->p4type==P4_MEM ){
97473 sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
97489 pDest = &aMem[pOp->p3];
97527 if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
97561 REGISTER_TRACE(pOp->p3, pDest);
97566 pOp = &aOp[aOp[0].p3-1];
97605 assert( pOp->p4type==P4_TABLE );
97606 pTab = pOp->p4.pTab;
97608 assert( pTab->nNVCol==pOp->p2 );
97610 pIn1 = &aMem[pOp->p1];
97614 if( pOp->p3 ){ pIn1++; continue; }
97616 assert( pIn1 < &aMem[pOp->p1+pOp->p2] );
97667 assert( pIn1 == &aMem[pOp->p1+pOp->p2] );
97690 zAffinity = pOp->p4.z;
97692 assert( pOp->p2>0 );
97693 assert( zAffinity[pOp->p2]==0 );
97694 pIn1 = &aMem[pOp->p1];
97786 nField = pOp->p1;
97787 zAffinity = pOp->p4.z;
97788 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
97790 nField = pOp->p2;
97794 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
97795 pOut = &aMem[pOp->p3];
97822 if( pOp->p5 ){
97823 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
97868 assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
98065 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
98066 REGISTER_TRACE(pOp->p3, pOut);
98084 assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
98085 pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
98087 if( pOp->p3 ){
98094 pOut = out2Prerelease(p, pOp);
98116 p1 = pOp->p1;
98117 zName = pOp->p4.z;
98207 p->pc = (int)(pOp - aOp);
98300 desiredAutoCommit = pOp->p1;
98301 iRollback = pOp->p2;
98326 p->pc = (int)(pOp - aOp);
98391 assert( p->readOnly==0 || pOp->p2==0 );
98392 assert( pOp->p2>=0 && pOp->p2<=2 );
98393 assert( pOp->p1>=0 && pOp->p1<db->nDb );
98394 assert( DbMaskTest(p->btreeMask, pOp->p1) );
98396 if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){
98407 pDb = &db->aDb[pOp->p1];
98411 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
98416 p->pc = (int)(pOp - aOp);
98424 && pOp->p2
98446 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
98448 && pOp->p5
98449 && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i)
98471 if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
98472 sqlite3ResetOneSchema(db, pOp->p1);
98504 iDb = pOp->p1;
98505 iCookie = pOp->p3;
98506 assert( pOp->p3<SQLITE_N_BTREE_META );
98512 pOut = out2Prerelease(p, pOp);
98536 assert( pOp->p2<SQLITE_N_BTREE_META );
98537 assert( pOp->p1>=0 && pOp->p1<db->nDb );
98538 assert( DbMaskTest(p->btreeMask, pOp->p1) );
98540 pDb = &db->aDb[pOp->p1];
98542 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
98544 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
98545 if( pOp->p2==BTREE_SCHEMA_VERSION ){
98547 *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5;
98549 sqlite3FkClearTriggerCache(db, pOp->p1);
98550 }else if( pOp->p2==BTREE_FILE_FORMAT ){
98552 pDb->pSchema->file_format = pOp->p3;
98554 if( pOp->p1==1 ){
98658 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
98659 assert( pOp->p4type==P4_KEYINFO );
98660 pCur = p->apCsr[pOp->p1];
98661 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
98662 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
98672 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
98674 assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
98684 p2 = (u32)pOp->p2;
98685 iDb = pOp->p3;
98691 if( pOp->opcode==OP_OpenWrite ){
98693 wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
98698 if( pOp->p5 & OPFLAG_P2ISREG ){
98714 assert( (pOp->p5 & OPFLAG_P2ISREG)==0 );
98716 if( pOp->p4type==P4_KEYINFO ){
98717 pKeyInfo = pOp->p4.pKeyInfo;
98721 }else if( pOp->p4type==P4_INT32 ){
98722 nField = pOp->p4.i;
98724 assert( pOp->p1>=0 );
98727 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
98742 pCur->isTable = pOp->p4type!=P4_KEYINFO;
98747 testcase( pOp->p5 & OPFLAG_BULKCSR );
98748 testcase( pOp->p2 & OPFLAG_SEEKEQ );
98750 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
98767 pOrig = p->apCsr[pOp->p2];
98771 pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE);
98836 assert( pOp->p1>=0 );
98837 assert( pOp->p2>=0 );
98838 if( pOp->p3>0 ){
98841 assert( pOp->p2==0 ); /* Only used when number of columns is zero */
98842 assert( pOp->opcode==OP_OpenEphemeral );
98843 assert( aMem[pOp->p3].flags & MEM_Null );
98844 aMem[pOp->p3].n = 0;
98845 aMem[pOp->p3].z = "";
98847 pCx = p->apCsr[pOp->p1];
98848 if( pCx && !pCx->noReuse && ALWAYS(pOp->p2<=pCx->nField) ){
98857 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE);
98861 BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
98871 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
98872 assert( pOp->p4type==P4_KEYINFO );
98874 BTREE_BLOBKEY | pOp->p5);
98890 pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
98891 assert( p->apCsr[pOp->p1]==pCx );
98895 p->apCsr[pOp->p1] = 0; /* Not required; helps with static analysis */
98919 assert( pOp->p1>=0 );
98920 assert( pOp->p2>=0 );
98921 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER);
98923 pCx->pKeyInfo = pOp->p4.pKeyInfo;
98926 rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
98940 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98941 pC = p->apCsr[pOp->p1];
98969 assert( pOp->p1>=0 );
98970 assert( pOp->p3>=0 );
98971 pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO);
98974 pCx->seekResult = pOp->p2;
98981 assert( pOp->p5==0 );
98991 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98992 sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
98993 p->apCsr[pOp->p1] = 0;
99010 pC = p->apCsr[pOp->p1];
99012 pC->maskUsed = *(u64*)pOp->p4.pI64;
99119 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99120 assert( pOp->p2!=0 );
99121 pC = p->apCsr[pOp->p1];
99129 oc = pOp->opcode;
99133 pC->seekOp = pOp->opcode;
99147 pIn3 = &aMem[pOp->p3];
99208 assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
99209 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
99210 assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT );
99211 assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT );
99212 assert( pOp[1].p1==pOp[0].p1 );
99213 assert( pOp[1].p2==pOp[0].p2 );
99214 assert( pOp[1].p3==pOp[0].p3 );
99215 assert( pOp[1].p4.i==pOp[0].p4.i );
99218 nField = pOp->p4.i;
99219 assert( pOp->p4type==P4_INT32 );
99237 r.aMem = &aMem[pOp->p3];
99243 if( i>0 ) REGISTER_TRACE(pOp->p3+i, &r.aMem[i]);
99296 assert( pOp->p2>0 );
99301 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
99302 pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */
99382 assert( pOp[1].opcode==OP_SeekGE );
99387 assert( pOp->p2>=(int)(pOp-aOp)+2 );
99389 if( pOp->p5==0 ){
99391 assert( pOp[1].p1==aOp[pOp->p2-1].p1 );
99392 assert( pOp[1].p2==aOp[pOp->p2-1].p2 );
99393 assert( pOp[1].p3==aOp[pOp->p2-1].p3 );
99394 assert( aOp[pOp->p2-1].opcode==OP_IdxGT
99395 || aOp[pOp->p2-1].opcode==OP_IdxGE );
99396 testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
99399 assert( pOp->p2==(int)(pOp-aOp)+2 );
99400 assert( aOp[pOp->p2-1].opcode==OP_SeekGE );
99404 assert( pOp->p1>0 );
99405 pC = p->apCsr[pOp[1].p1];
99417 nStep = pOp->p1;
99420 r.nField = (u16)pOp[1].p4.i;
99422 r.aMem = &aMem[pOp[1].p3];
99428 REGISTER_TRACE(pOp[1].p3+i, &aMem[pOp[1].p3+i]);
99436 if( res>0 && pOp->p5==0 ){
99441 printf("... %d steps and then skip\n", pOp->p1 - nStep);
99445 pOp++;
99452 printf("... %d steps and then success\n", pOp->p1 - nStep);
99462 printf("... fall through after %d steps\n", pOp->p1);
99501 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99502 pC = p->apCsr[pOp->p1];
99504 assert( pOp->p3>=pOp->p2 );
99505 if( pC->seekHit<pOp->p2 ){
99508 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
99511 pC->seekHit = pOp->p2;
99512 }else if( pC->seekHit>pOp->p3 ){
99515 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
99518 pC->seekHit = pOp->p3;
99532 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99533 pCur = p->apCsr[pOp->p1];
99633 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99634 pC = p->apCsr[pOp->p1];
99641 if( pC->seekHit>=pOp->p4.i ) break;
99655 if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
99658 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99659 assert( pOp->p4type==P4_INT32 );
99660 pC = p->apCsr[pOp->p1];
99663 pC->seekOp = pOp->opcode;
99665 r.aMem = &aMem[pOp->p3];
99669 r.nField = (u16)pOp->p4.i;
99679 if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
99686 assert( pOp->opcode!=OP_NoConflict );
99704 if( pOp->opcode==OP_Found ){
99712 if( pOp->opcode==OP_NoConflict ){
99724 if( pOp->opcode==OP_IfNoHope ){
99725 pC->seekHit = pOp->p4.i;
99784 pIn3 = &aMem[pOp->p3];
99804 pIn3 = &aMem[pOp->p3];
99805 assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
99806 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99809 pC = p->apCsr[pOp->p1];
99812 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
99829 if( pOp->p2==0 ){
99848 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99849 assert( p->apCsr[pOp->p1]!=0 );
99850 assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
99851 pOut = out2Prerelease(p, pOp);
99852 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
99884 pOut = out2Prerelease(p, pOp);
99885 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99886 pC = p->apCsr[pOp->p1];
99936 if( pOp->p3 ){
99938 assert( pOp->p3>0 );
99942 assert( pOp->p3<=pFrame->nMem );
99943 pMem = &pFrame->aMem[pOp->p3];
99946 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
99947 pMem = &aMem[pOp->p3];
99952 REGISTER_TRACE(pOp->p3, pMem);
99970 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
100040 pData = &aMem[pOp->p2];
100041 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100043 pC = p->apCsr[pOp->p1];
100048 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
100049 assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
100050 REGISTER_TRACE(pOp->p2, pData);
100053 pKey = &aMem[pOp->p3];
100056 REGISTER_TRACE(pOp->p3, pKey);
100059 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
100062 pTab = pOp->p4.pTab;
100063 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
100072 if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
100073 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
100080 if( pOp->p5 & OPFLAG_ISNOOP ) break;
100083 assert( (pOp->p5 & OPFLAG_LASTROWID)==0 || (pOp->p5 & OPFLAG_NCHANGE)!=0 );
100084 if( pOp->p5 & OPFLAG_NCHANGE ){
100086 if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
100091 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
100100 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
100113 (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
100134 assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert );
100135 assert( pOp[1].opcode==OP_Insert || pOp->p3==0 );
100136 assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 );
100137 assert( pOp[1].p5 & OPFLAG_PREFORMAT );
100138 pDest = p->apCsr[pOp->p1];
100139 pSrc = p->apCsr[pOp->p2];
100140 iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0;
100192 opflags = pOp->p2;
100193 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100194 pC = p->apCsr[pOp->p1];
100202 if( pOp->p4type==P4_TABLE
100203 && HasRowid(pOp->p4.pTab)
100204 && pOp->p5==0
100220 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
100222 assert( pOp->p4.pTab!=0 );
100224 pTab = pOp->p4.pTab;
100225 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
100235 assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
100239 || (aMem[pOp->p3].flags & MEM_Int)
100244 pOp->p3, -1
100251 assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
100258 && (pOp->p5 & OPFLAG_AUXDELETE)==0
100263 if( pOp->p2 & OPFLAG_NCHANGE ){
100269 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
100320 pC = p->apCsr[pOp->p1];
100322 assert( pOp->p4type==P4_INT32 );
100323 pIn3 = &aMem[pOp->p3];
100324 nKeyCol = pOp->p4.i;
100348 pOut = &aMem[pOp->p2];
100349 pC = p->apCsr[pOp->p1];
100353 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100355 p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
100392 pOut = out2Prerelease(p, pOp);
100394 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100395 pC = p->apCsr[pOp->p1];
100421 if( !pOp->p3 ) Deephemeralize(pOut);
100423 REGISTER_TRACE(pOp->p2, pOut);
100443 pOut = out2Prerelease(p, pOp);
100444 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100445 pC = p->apCsr[pOp->p1];
100490 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100491 pC = p->apCsr[pOp->p1];
100495 pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
100542 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100543 pC = p->apCsr[pOp->p1];
100550 pC->seekOp = pOp->opcode;
100552 if( pOp->opcode==OP_SeekEnd ){
100553 assert( pOp->p2==0 );
100564 if( pOp->p2>0 ){
100585 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100586 assert( pOp->p4type==P4_INT32 );
100587 assert( pOp->p3>=-1 && pOp->p3<=640*2 );
100588 assert( pOp->p4.i>=-1 && pOp->p4.i<=640*2 );
100589 pC = p->apCsr[pOp->p1];
100602 res = sz>=pOp->p3 && sz<=pOp->p4.i;
100660 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100661 assert( pOp->p5==0 );
100662 assert( pOp->p2>=0 && pOp->p2<p->nOp );
100664 pC = p->apCsr[pOp->p1];
100666 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
100683 if( pOp->p2>0 ){
100747 pC = p->apCsr[pOp->p1];
100753 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100754 assert( pOp->p5==0
100755 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
100756 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
100757 pC = p->apCsr[pOp->p1];
100764 rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
100768 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100769 assert( pOp->p5==0
100770 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
100771 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
100772 pC = p->apCsr[pOp->p1];
100780 rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
100787 p->aCounter[pOp->p5]++;
100831 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100832 pC = p->apCsr[pOp->p1];
100836 pIn2 = &aMem[pOp->p2];
100837 assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
100838 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
100845 x.aMem = aMem + pOp->p3;
100846 x.nMem = (u16)pOp->p4.i;
100848 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
100849 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
100867 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100868 pC = p->apCsr[pOp->p1];
100872 pIn2 = &aMem[pOp->p2];
100903 assert( pOp->p3>0 );
100904 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
100905 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100906 pC = p->apCsr[pOp->p1];
100913 r.nField = (u16)pOp->p3;
100915 r.aMem = &aMem[pOp->p2];
100921 }else if( pOp->p5 && !sqlite3WritableSchema(db) ){
100965 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
100966 pC = p->apCsr[pOp->p1];
100972 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
100989 if( pOp->opcode==OP_DeferredSeek ){
100990 assert( pOp->p3>=0 && pOp->p3<p->nCursor );
100991 pTabCur = p->apCsr[pOp->p3];
101000 assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
101002 pTabCur->ub.aAltMap = pOp->p4.ai;
101006 pOut = out2Prerelease(p, pOp);
101010 assert( pOp->opcode==OP_IdxRowid );
101011 sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
101025 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
101026 pC = p->apCsr[pOp->p1];
101086 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
101087 pC = p->apCsr[pOp->p1];
101093 assert( pOp->p4type==P4_INT32 );
101095 r.nField = (u16)pOp->p4.i;
101096 if( pOp->opcode<OP_IdxLT ){
101097 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
101100 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
101103 r.aMem = &aMem[pOp->p3];
101109 REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
101139 if( (pOp->opcode&1)==(OP_IdxLT&1) ){
101140 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
101143 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
101185 assert( pOp->p1>1 );
101186 pOut = out2Prerelease(p, pOp);
101193 iDb = pOp->p3;
101196 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
101202 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
101235 assert( DbMaskTest(p->btreeMask, pOp->p2) );
101236 rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);
101237 if( pOp->p3 ){
101239 if( pOp->p3>0 ){
101240 assert( memIsValid(&aMem[pOp->p3]) );
101241 memAboutToChange(p, &aMem[pOp->p3]);
101242 aMem[pOp->p3].u.i += nChange;
101260 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
101261 pC = p->apCsr[pOp->p1];
101288 pOut = out2Prerelease(p, pOp);
101290 assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
101291 assert( pOp->p1>=0 && pOp->p1<db->nDb );
101292 assert( DbMaskTest(p->btreeMask, pOp->p1) );
101294 pDb = &db->aDb[pOp->p1];
101296 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
101331 if( pOp->p1 & 0x0001 ){
101337 if( pOp->p1 & 0x0002 ){
101338 db->nAnalysisLimit = pOp->p2;
101340 rc = sqlite3_exec(db, pOp->p4.z, 0, 0, &zErr);
101381 iDb = pOp->p1;
101388 if( pOp->p4.z==0 ){
101391 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
101405 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
101444 assert( pOp->p1>=0 && pOp->p1<db->nDb );
101445 rc = sqlite3AnalysisLoad(db, pOp->p1);
101461 sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
101475 sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
101489 sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
101522 assert( pOp->p4type==P4_INTARRAY );
101523 nRoot = pOp->p2;
101524 aRoot = pOp->p4.ai;
101528 assert( pOp->p1>0 && (pOp->p1+1)<=(p->nMem+1 - p->nCursor) );
101529 pnErr = &aMem[pOp->p1];
101532 pIn1 = &aMem[pOp->p1+1];
101533 assert( pOp->p5<db->nDb );
101534 assert( DbMaskTest(p->btreeMask, pOp->p5) );
101535 rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1],
101536 &aMem[pOp->p3], nRoot, (int)pnErr->u.i+1, &nErr, &z);
101562 pIn1 = &aMem[pOp->p1];
101563 pIn2 = &aMem[pOp->p2];
101584 pIn1 = &aMem[pOp->p1];
101596 sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
101628 pIn1 = &aMem[pOp->p1];
101629 pIn3 = &aMem[pOp->p3];
101630 iSet = pOp->p4.i;
101640 assert( pOp->p4type==P4_INT32 );
101683 pProgram = pOp->p4.pProgram;
101684 pRt = &aMem[pOp->p3];
101698 if( pOp->p5 ){
101740 pFrame->pc = (int)(pOp - aOp);
101763 assert( (int)(pOp - aOp)==pFrame->pc );
101795 pOp = &aOp[-1];
101814 pOut = out2Prerelease(p, pOp);
101816 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
101833 if( pOp->p1 ){
101834 db->nDeferredCons += pOp->p2;
101837 db->nDeferredImmCons += pOp->p2;
101839 p->nFkConstraint += pOp->p2;
101858 if( pOp->p1 ){
101885 pIn1 = &pFrame->aMem[pOp->p1];
101887 pIn1 = &aMem[pOp->p1];
101891 pIn2 = &aMem[pOp->p2];
101911 pIn1 = &aMem[pOp->p1];
101915 pIn1->u.i -= pOp->p3;
101941 pIn1 = &aMem[pOp->p1];
101942 pIn3 = &aMem[pOp->p3];
101943 pOut = out2Prerelease(p, pOp);
101971 pIn1 = &aMem[pOp->p1];
101988 pIn1 = &aMem[pOp->p1];
102042 assert( pOp->p4type==P4_FUNCDEF );
102043 n = pOp->p5;
102044 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
102045 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
102046 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
102063 pCtx->pFunc = pOp->p4.pFunc;
102064 pCtx->iOp = (int)(pOp - aOp);
102070 pOp->p4type = P4_FUNCCTX;
102071 pOp->p4.pCtx = pCtx;
102074 assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
102076 pOp->opcode = OP_AggStep1;
102085 assert( pOp->p4type==P4_FUNCCTX );
102086 pCtx = pOp->p4.pCtx;
102087 pMem = &aMem[pOp->p3];
102090 if( pOp->p1 ){
102106 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
102112 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
102121 if( pOp->p1 ){
102133 assert( pOp[-1].opcode==OP_CollSeq );
102134 i = pOp[-1].p1;
102177 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
102178 assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
102179 pMem = &aMem[pOp->p1];
102182 if( pOp->p3 ){
102183 memAboutToChange(p, &aMem[pOp->p3]);
102184 rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
102185 pMem = &aMem[pOp->p3];
102189 rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
102222 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
102223 || pOp->p2==SQLITE_CHECKPOINT_FULL
102224 || pOp->p2==SQLITE_CHECKPOINT_RESTART
102225 || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
102227 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
102233 for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
102261 pOut = out2Prerelease(p, pOp);
102262 eNew = pOp->p3;
102271 assert( pOp->p1>=0 && pOp->p1<db->nDb );
102274 pBt = db->aDb[pOp->p1].pBt;
102358 rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
102359 pOp->p2 ? &aMem[pOp->p2] : 0);
102375 assert( pOp->p1>=0 && pOp->p1<db->nDb );
102376 assert( DbMaskTest(p->btreeMask, pOp->p1) );
102378 pBt = db->aDb[pOp->p1].pBt;
102407 assert( pOp->p2==0 || pOp->p2==1 );
102408 if( !pOp->p1 ){
102409 sqlite3ExpirePreparedStatements(db, pOp->p2);
102411 p->expired = pOp->p2+1;
102423 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
102424 pC = p->apCsr[pOp->p1];
102438 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
102439 pC = p->apCsr[pOp->p1];
102463 u8 isWriteLock = (u8)pOp->p3;
102465 int p1 = pOp->p1;
102469 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
102472 const char *z = pOp->p4.z;
102494 pVTab = pOp->p4.pVtab;
102516 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
102517 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
102518 rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
102523 rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
102539 rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
102563 pVtab = pOp->p4.pVtab->pVtab;
102577 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
102606 pOut = &aMem[pOp->p2];
102608 assert( pOp->p4type==P4_TABLEREF );
102609 pTab = pOp->p4.pTab;
102621 assert( pOp->p1>=0 && pOp->p1<db->nDb );
102622 rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
102623 pOp->p3, &zErr);
102651 pC = p->apCsr[pOp->p1];
102655 pRhs->pOut = &aMem[pOp->p3];
102656 pOut = out2Prerelease(p, pOp);
102697 pQuery = &aMem[pOp->p3];
102699 pCur = p->apCsr[pOp->p1];
102701 REGISTER_TRACE(pOp->p3, pQuery);
102719 rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
102752 VdbeCursor *pCur = p->apCsr[pOp->p1];
102754 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
102755 pDest = &aMem[pOp->p3];
102771 assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
102772 if( pOp->p5 & OPFLAG_NOCHNG ){
102779 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
102786 REGISTER_TRACE(pOp->p3, pDest);
102807 pCur = p->apCsr[pOp->p1];
102850 pVtab = pOp->p4.pVtab->pVtab;
102851 pName = &aMem[pOp->p1];
102855 REGISTER_TRACE(pOp->p1, pName);
102908 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
102909 || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
102914 pVtab = pOp->p4.pVtab->pVtab;
102920 nArg = pOp->p2;
102921 assert( pOp->p4type==P4_VTAB );
102925 pX = &aMem[pOp->p3];
102933 db->vtabOnConflict = pOp->p5;
102937 if( rc==SQLITE_OK && pOp->p1 ){
102941 if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
102942 if( pOp->p5==OE_Ignore ){
102945 p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
102962 pOut = out2Prerelease(p, pOp);
102963 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
102982 pOut = out2Prerelease(p, pOp);
102983 pBt = db->aDb[pOp->p1].pBt;
102985 if( pOp->p3 ){
102987 if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
103045 assert( pOp->p4type==P4_FUNCCTX );
103046 pCtx = pOp->p4.pCtx;
103052 pOut = &aMem[pOp->p3];
103057 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
103065 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
103078 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
103088 REGISTER_TRACE(pOp->p3, pOut);
103099 pIn1 = &aMem[pOp->p1];
103111 pIn1 = &aMem[pOp->p1];
103112 pOut = &aMem[pOp->p2];
103128 pIn1 = &aMem[pOp->p1];
103129 pOut = &aMem[pOp->p2];
103149 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
103150 pIn1 = &aMem[pOp->p1];
103153 h = filterHash(aMem, pOp);
103157 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
103185 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
103186 pIn1 = &aMem[pOp->p1];
103189 h = filterHash(aMem, pOp);
103193 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
103252 assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
103255 assert( pOp==p->aOp || pOp->opcode==OP_Trace );
103260 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
103278 zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
103289 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
103295 assert( pOp->p2>0 );
103296 if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
103297 if( pOp->opcode==OP_Trace ) break;
103301 pOp->p1 = 0;
103303 pOp->p1++;
103319 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
103320 assert( pOp->p4type==P4_EXPR );
103321 pC = p->apCsr[pOp->p1];
103325 pOp->p4.pExpr, aMem);
103382 assert( pOp->p1>0 );
103383 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
103384 pMem = &aMem[pOp->p1];
103385 constMask = pOp->p3;
103386 for(i=0; i<pOp->p2; i++, pMem++){
103389 if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
103423 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
103452 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
103504 (int)(pOp - aOp), p->zErrMsg, p->zSql);
107083 Op *pOp = pCur->aOp + pCur->iAddr;
107091 int iDb = pOp->p3;
107092 Pgno iRoot = (Pgno)pOp->p2;
107122 sqlite3_result_text(ctx, (char*)sqlite3OpcodeName(pOp->opcode),
107126 sqlite3_result_int(ctx, pOp->p1);
107129 sqlite3_result_int(ctx, pOp->p2);
107132 sqlite3_result_int(ctx, pOp->p3);
107137 pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp);
107143 char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4);
107149 sqlite3_result_int(ctx, pOp->p5);
107167 sqlite3_result_int64(ctx, pOp->nExec);
107170 sqlite3_result_int64(ctx, pOp->nCycle);
107189 sqlite3_result_int(ctx, pOp->opcode==OP_OpenWrite);
113784 VdbeOp *pOp, *pEnd;
113797 pOp = sqlite3VdbeGetOp(v, 1);
113799 for(; pOp<pEnd; pOp++){
113800 if( pOp->p4type!=P4_SUBRTNSIG ) continue;
113801 assert( pOp->opcode==OP_BeginSubrtn );
113802 pSig = pOp->p4.pSubrtnSig;
114428 const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
114429 assert( pOp->opcode==OP_Once || pParse->nErr );
114430 if( pOp->opcode==OP_Once && pOp->p3>0 ){ /* tag-202407032019 */
114432 sqlite3VdbeAddOp4Int(v, OP_Filter, pOp->p3, destIfFalse,
114698 VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
114699 if( pOp->opcode==OP_Column ) pOp->p5 = p5;
114700 if( pOp->opcode==OP_VColumn ) pOp->p5 = (p5 & OPFLAG_NOCHNG);
116103 VdbeOp *pOp;
116105 && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy
116106 && pOp->p1+pOp->p3+1==inReg
116107 && pOp->p2+pOp->p3+1==target+i
116108 && pOp->p5==0 /* The do-not-merge flag must be clear */
116110 pOp->p3++;
130407 VdbeOp *pOp;
130409 pOp = &context->pVdbe->aOp[context->iOp-1];
130410 assert( pOp->opcode==OP_CollSeq );
130411 assert( pOp->p4type==P4_COLLSEQ );
130412 return pOp->p4.pColl;
135052 VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
135053 assert( pOp!=0 );
135054 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
135056 Pgno tnum = pOp->p2;
135067 if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
135068 assert( pOp->p4.pVtab!=0 );
135069 assert( pOp->p4type==P4_VTAB );
135105 VdbeOp *pOp;
135116 pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
135117 if( pOp->opcode==OP_Affinity ){
135122 char *zP4 = pOp->p4.z;
135124 assert( pOp->p4type==P4_DYNAMIC );
135134 }else if( pOp->opcode==OP_TypeCheck ){
135138 pOp->p3 = 1;
145630 VdbeOp *pOp; /* Opcode that opens the sorter */
145645 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
145647 pOp->p2 = nKey + nData;
145648 pKI = pOp->p4.pKeyInfo;
145652 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
145654 pOp = 0; /* Ensure pOp not used after sqlite3VdbeAddOp3() */
145873 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr);
145874 pOp->opcode = OP_Null;
145875 pOp->p1 = 1;
145876 pOp->p2 = iVal;
146076 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
146077 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
146078 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
159729 VdbeOp *pOp = sqlite3VdbeGetOp(pParse->pVdbe, addr);
159826 assert( pOp->opcode==OP_Explain );
159827 assert( pOp->p4type==P4_DYNAMIC || pOp->p4.z==0 );
159828 sqlite3DbFree(db, pOp->p4.z);
159829 pOp->p4type = P4_DYNAMIC;
159830 pOp->p4.z = sqlite3StrAccumFinish(&str);
159963 VdbeOp *pOp;
159966 pOp = sqlite3VdbeGetOp(v, addr-1);
159967 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
159968 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
159969 sqlite3VdbeScanStatusRange(v, addrExplain, addr, pOp->p2-1);
160620 VdbeOp *pOp;
160622 pOp = sqlite3VdbeGetLastOp(v);
160623 assert( pOp!=0 );
160624 assert( pOp->opcode==OP_String8
160626 pOp->p3 = (int)(pLevel->iLikeRepCntr>>1); /* Register holding counter */
160627 pOp->p5 = (u8)(pLevel->iLikeRepCntr&1); /* ASC or DESC */
161233 VdbeOp *pOp; /* Opcode to access the value of the IN constraint */
161242 pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop);
161243 if( (pOp->opcode==OP_Column && pOp->p3==iReg+j+2)
161244 || (pOp->opcode==OP_Rowid && pOp->p2==iReg+j+2)
161246 testcase( pOp->opcode==OP_Rowid );
161247 sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
165192 VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
165201 for(; iStart<iEnd; iStart++, pOp++){
165202 if( pOp->p1!=iTabCur ) continue;
165203 if( pOp->opcode==OP_Column ){
165209 pOp->opcode = OP_Copy;
165210 pOp->p1 = pOp->p2 + iRegister;
165211 pOp->p2 = pOp->p3;
165212 pOp->p3 = 0;
165213 pOp->p5 = 2; /* Cause the MEM_Subtype flag to be cleared */
165214 }else if( pOp->opcode==OP_Rowid ){
165220 pOp->opcode = OP_Sequence;
165221 pOp->p1 = iAutoidxCur;
165224 pOp->opcode = OP_Null;
165225 pOp->p3 = 0;
171794 VdbeOp *pOp
171797 sqlite3VdbePrintOp(0, pc, pOp);
171985 VdbeOp *pOp, *pLastOp;
172062 pOp = sqlite3VdbeGetOp(v, k - 1);
172063 assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur );
172064 assert( pOp->opcode!=OP_Rowid || pOp->p1!=pLevel->iTabCur );
172065 assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur );
172067 pOp = sqlite3VdbeGetOp(v, k);
172068 pLastOp = pOp + (last - k);
172069 assert( pOp<=pLastOp );
172071 if( pOp->p1!=pLevel->iTabCur ){
172073 }else if( pOp->opcode==OP_Column
172075 || pOp->opcode==OP_Offset
172078 int x = pOp->p2;
172081 if( pOp->opcode==OP_Offset ){
172095 pOp->p2 = x;
172096 pOp->p1 = pLevel->iIdxCur;
172097 OpcodeRewriteTrace(db, k, pOp);
172122 }else if( pOp->opcode==OP_Rowid ){
172123 pOp->p1 = pLevel->iIdxCur;
172124 pOp->opcode = OP_IdxRowid;
172125 OpcodeRewriteTrace(db, k, pOp);
172126 }else if( pOp->opcode==OP_IfNullRow ){
172127 pOp->p1 = pLevel->iIdxCur;
172128 OpcodeRewriteTrace(db, k, pOp);
172133 }while( (++pOp)<pLastOp );
173892 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOp);
173893 if( pOp->opcode==OP_Column && pOp->p1==pMWin->iEphCsr ){
173894 pOp->p1 = csr;
190354 struct Fts4Option *pOp = &aFts4Opt[iOpt];
190355 if( nKey==pOp->nOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
209186 static int jsonIs4HexB(const char *z, int *pOp){
209189 *pOp = JSONB_TEXTJ;
232050 int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */
232053 *pOp = pIter->op;