Lines Matching refs:P2
8467 int p2; /* Second parameter (often the jump destination) */
8516 signed char p2; /* Second parameter (often the jump destination) */
8572 ** The following macro converts a relative address in the p2 field
8743 #define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */
8746 #define OPFLG_IN2 0x0008 /* in2: P2 is an input */
8748 #define OPFLG_OUT2 0x0020 /* out2: P2 is an output */
8788 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
10089 #define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */
10827 int p1, p2; /* Operands of the opcode used to ends the loop */
10935 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
10936 ** the number of columns in P2 can be computed at the same time
21749 /* a: p0<<14 | p2 (unmasked) */
21777 /* a: p0<<14 | p2 (masked) */
21779 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21784 /* s: p0<<14 | p2 (masked) */
21789 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
21802 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21805 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21826 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
21922 /* a: p0<<14 | p2 (unmasked) */
21980 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
59642 ** p1, p2, p3 Operands
59648 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
59665 pOp->p2 = p2;
59685 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
59686 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
59697 int p2, /* The P2 operand */
59702 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59729 int p2, /* The P2 operand */
59733 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59741 ** label can be used as the P2 value of an operation. Later, when
59743 ** through its operation list and change all values of P2 which match
59746 ** The VDBE knows that a P2 value is a label because labels are
59747 ** always negative and P2 values are suppose to be non-negative.
59748 ** Hence, a negative P2 value is a label that has yet to be resolved.
59862 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59863 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59867 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
59887 || (opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1)
59890 && (pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort))
59908 ** Loop through the program looking for P2 values that are negative
59910 ** label by setting the P2 value to its correct non-zero value.
59914 ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
59932 }else if( (opcode==OP_Transaction && pOp->p2!=0) || opcode==OP_Vacuum ){
59936 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
59952 if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){
59953 assert( -1-pOp->p2<p->nLabel );
59954 pOp->p2 = aLabel[-1-pOp->p2];
60010 int p2 = pIn->p2;
60014 if( p2<0 && (sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
60015 pOut->p2 = addr + ADDR(p2);
60017 pOut->p2 = p2;
60049 ** Change the value of the P2 operand for a specific instruction.
60055 p->aOp[addr].p2 = val;
60082 ** Change the P2 operand of instruction addr so that it points to
60560 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
60767 pMem->u.i = pOp->p2; /* P2 */
64361 ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
65018 int p2; /* Register to copy to */
65057 int p2;
65074 int p2; /* column number to retrieve */
65154 int p2;
65505 ** external allocations out of mem[p2] and set mem[p2] to be
65507 ** value or convert mem[p2] to a different type.
65511 assert( pOp->p2>0 );
65512 assert( pOp->p2<=p->nMem );
65513 pOut = &aMem[pOp->p2];
65528 assert( pOp->p2>0 );
65529 assert( pOp->p2<=p->nMem );
65530 assert( memIsValid(&aMem[pOp->p2]) );
65531 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
65540 assert( pOp->p2>0 );
65541 assert( pOp->p2<=p->nMem );
65542 memAboutToChange(p, &aMem[pOp->p2]);
65588 /* Opcode: Goto * P2 * * *
65590 ** An unconditional jump to address P2.
65592 ** the one at index P2 from the beginning of
65597 pc = pOp->p2 - 1;
65601 /* Opcode: Gosub P1 P2 * * *
65604 ** and then jump to address P2.
65614 pc = pOp->p2 - 1;
65647 /* Opcode: HaltIfNull P1 P2 P3 P4 *
65650 ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
65659 /* Opcode: Halt P1 P2 * P4 *
65666 ** For errors, it can be some other value. If P1!=0 then P2 will determine
65668 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
65687 if( pOp->p2==OE_Ignore ){
65689 ** currently being halted. If the p2 instruction of this OP_Halt
65692 ** as the p2 of the calling OP_Program. */
65693 pc = p->aOp[pc].p2-1;
65701 p->errorAction = (u8)pOp->p2;
65724 /* Opcode: Integer P1 P2 * * *
65726 ** The 32-bit integer value P1 is written into register P2.
65733 /* Opcode: Int64 * P2 * P4 *
65736 ** Write that value into register P2.
65745 /* Opcode: Real * P2 * P4 *
65748 ** Write that value into register P2.
65758 /* Opcode: String8 * P2 * P4 *
65792 /* Opcode: String P1 P2 * P4 *
65794 ** The string value P4 of length P1 (bytes) is stored in register P2.
65806 /* Opcode: Null * P2 P3 * *
65808 ** Write a NULL into registers P2. If P3 greater than P2, then also write
65809 ** NULL into register P3 and ever register in between P2 and P3. If P3
65810 ** is less than P2 (typically P3 is zero) then only register P2 is
65817 u.ab.cnt = pOp->p3-pOp->p2;
65831 /* Opcode: Blob P1 P2 * P4
65834 ** blob in register P2.
65844 /* Opcode: Variable P1 P2 * P4 *
65846 ** Transfer the values of bound parameter P1 into register P2
65867 /* Opcode: Move P1 P2 P3 * *
65870 ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
65872 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
65879 int p2; /* Register to copy to */
65884 u.ad.p2 = pOp->p2;
65885 assert( u.ad.n>0 && u.ad.p1>0 && u.ad.p2>0 );
65886 assert( u.ad.p1+u.ad.n<=u.ad.p2 || u.ad.p2+u.ad.n<=u.ad.p1 );
65889 pOut = &aMem[u.ad.p2];
65900 pOut->pScopyFrom += u.ad.p1 - pOp->p2;
65904 REGISTER_TRACE(u.ad.p2++, pOut);
65911 /* Opcode: Copy P1 P2 * * *
65913 ** Make a copy of register P1 into register P2.
65920 pOut = &aMem[pOp->p2];
65924 REGISTER_TRACE(pOp->p2, pOut);
65928 /* Opcode: SCopy P1 P2 * * *
65930 ** Make a shallow copy of register P1 into register P2.
65942 pOut = &aMem[pOp->p2];
65948 REGISTER_TRACE(pOp->p2, pOut);
65952 /* Opcode: ResultRow P1 P2 * * *
65954 ** The registers P1 through P1+P2-1 contain a single row of
65965 assert( p->nResColumn==pOp->p2 );
65967 assert( pOp->p1+pOp->p2
66007 for(u.ae.i=0; u.ae.i<pOp->p2; u.ae.i++){
66025 /* Opcode: Concat P1 P2 P3 * *
66028 ** register P2 and store the result in register P3.
66029 ** If either the P1 or P2 text are NULL then store NULL in P3.
66031 ** P3 = P2 || P1
66034 ** if P3 is the same register as P2, the implementation is able
66043 pIn2 = &aMem[pOp->p2];
66074 /* Opcode: Add P1 P2 P3 * *
66076 ** Add the value in register P1 to the value in register P2
66080 /* Opcode: Multiply P1 P2 P3 * *
66083 ** Multiply the value in register P1 by the value in register P2
66087 /* Opcode: Subtract P1 P2 P3 * *
66089 ** Subtract the value in register P1 from the value in register P2
66093 /* Opcode: Divide P1 P2 P3 * *
66095 ** Divide the value in register P1 by the value in register P2
66096 ** and store the result in register P3 (P3=P2/P1). If the value in
66100 /* Opcode: Remainder P1 P2 P3 * *
66103 ** register P1 by the value in register P2 and store the result in P3.
66104 ** If the value in register P2 is zero the result is NULL.
66122 pIn2 = &aMem[pOp->p2];
66216 /* Opcode: Function P1 P2 P3 P4 P5
66219 ** defines the function) with P5 arguments taken from register P2 and
66248 assert( u.ah.n==0 || (pOp->p2>0 && pOp->p2+u.ah.n<=p->nMem+1) );
66249 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ah.n );
66250 u.ah.pArg = &aMem[pOp->p2];
66256 REGISTER_TRACE(pOp->p2+u.ah.i, u.ah.pArg);
66336 /* Opcode: BitAnd P1 P2 P3 * *
66338 ** Take the bit-wise AND of the values in register P1 and P2 and
66342 /* Opcode: BitOr P1 P2 P3 * *
66344 ** Take the bit-wise OR of the values in register P1 and P2 and
66348 /* Opcode: ShiftLeft P1 P2 P3 * *
66350 ** Shift the integer value in register P2 to the left by the
66355 /* Opcode: ShiftRight P1 P2 P3 * *
66357 ** Shift the integer value in register P2 to the right by the
66374 pIn2 = &aMem[pOp->p2];
66416 /* Opcode: AddImm P1 P2 * * *
66418 ** Add the constant P2 to the value in register P1.
66427 pIn1->u.i += pOp->p2;
66431 /* Opcode: MustBeInt P1 P2 * * *
66435 ** without data loss, then jump immediately to P2, or if P2==0
66442 if( pOp->p2==0 ){
66446 pc = pOp->p2 - 1;
66574 /* Opcode: Lt P1 P2 P3 P4 P5
66577 ** jump to address P2.
66602 ** store a boolean result (either 0, or 1, or NULL) in register P2.
66604 /* Opcode: Ne P1 P2 P3 P4 P5
66616 /* Opcode: Eq P1 P2 P3 P4 P5
66628 /* Opcode: Le P1 P2 P3 P4 P5
66634 /* Opcode: Gt P1 P2 P3 P4 P5
66640 /* Opcode: Ge P1 P2 P3 P4 P5
66678 pOut = &aMem[pOp->p2];
66680 REGISTER_TRACE(pOp->p2, pOut);
66682 pc = pOp->p2-1;
66710 pOut = &aMem[pOp->p2];
66714 REGISTER_TRACE(pOp->p2, pOut);
66716 pc = pOp->p2-1;
66741 /* Opcode: Compare P1 P2 P3 P4 *
66744 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
66760 int p2;
66772 u.ak.p2 = pOp->p2;
66778 assert( u.ak.p2>0 && u.ak.p2+mx<=p->nMem+1 );
66781 assert( u.ak.p2>0 && u.ak.p2+u.ak.n<=p->nMem+1 );
66787 assert( memIsValid(&aMem[u.ak.p2+u.ak.idx]) );
66789 REGISTER_TRACE(u.ak.p2+u.ak.idx, &aMem[u.ak.p2+u.ak.idx]);
66793 iCompare = sqlite3MemCompare(&aMem[u.ak.p1+u.ak.idx], &aMem[u.ak.p2+u.ak.idx], u.ak.pColl);
66803 /* Opcode: Jump P1 P2 P3 * *
66805 ** Jump to the instruction at address P1, P2, or P3 depending on whether
66807 ** equal to, or greater than the P2 vector, respectively.
66813 pc = pOp->p2 - 1;
66820 /* Opcode: And P1 P2 P3 * *
66822 ** Take the logical AND of the values in registers P1 and P2 and
66825 ** If either P1 or P2 is 0 (false) then the result is 0 even if
66829 /* Opcode: Or P1 P2 P3 * *
66831 ** Take the logical OR of the values in register P1 and P2 and
66834 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
66851 pIn2 = &aMem[pOp->p2];
66874 /* Opcode: Not P1 P2 * * *
66877 ** boolean complement in register P2. If the value in register P1 is
66878 ** NULL, then a NULL is stored in P2.
66882 pOut = &aMem[pOp->p2];
66891 /* Opcode: BitNot P1 P2 * * *
66894 ** ones-complement of the P1 value into register P2. If P1 holds
66895 ** a NULL then store a NULL in P2.
66899 pOut = &aMem[pOp->p2];
66908 /* Opcode: Once P1 P2 * * *
66910 ** Check if OP_Once flag P1 is set. If so, jump to instruction P2. Otherwise,
66918 pc = pOp->p2-1;
66925 /* Opcode: If P1 P2 P3 * *
66927 ** Jump to P2 if the value in register P1 is true. The value
66931 /* Opcode: IfNot P1 P2 P3 * *
66933 ** Jump to P2 if the value in register P1 is False. The value
66954 pc = pOp->p2-1;
66959 /* Opcode: IsNull P1 P2 * * *
66961 ** Jump to P2 if the value in register P1 is NULL.
66966 pc = pOp->p2 - 1;
66971 /* Opcode: NotNull P1 P2 * * *
66973 ** Jump to P2 if the value in register P1 is not NULL.
66978 pc = pOp->p2 - 1;
66983 /* Opcode: Column P1 P2 P3 P4 P5
66987 ** information about the format of the data.) Extract the P2-th column
66988 ** from this record. If there are less that (P2+1)
66993 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
67007 int p2; /* column number to retrieve */
67031 u.an.p2 = pOp->p2;
67106 assert( u.an.p2<u.an.nField );
67243 /* Get the column information. If u.an.aOffset[u.an.p2] is non-zero, then
67244 ** deserialize the value from the record. If u.an.aOffset[u.an.p2] is zero,
67249 if( u.an.aOffset[u.an.p2] ){
67253 sqlite3VdbeSerialGet((u8 *)&u.an.zRec[u.an.aOffset[u.an.p2]], u.an.aType[u.an.p2], u.an.pDest);
67255 u.an.len = sqlite3VdbeSerialTypeLen(u.an.aType[u.an.p2]);
67257 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, u.an.aOffset[u.an.p2], u.an.len, u.an.pC->isIndex, &u.an.sMem);
67262 sqlite3VdbeSerialGet((u8*)u.an.zData, u.an.aType[u.an.p2], u.an.pDest);
67296 /* Opcode: Affinity P1 P2 * P4 *
67298 ** Apply affinities to a range of P2 registers starting with P1.
67300 ** P4 is a string that is P2 characters long. The nth character of the
67312 assert( u.ao.zAffinity[pOp->p2]==0 );
67324 /* Opcode: MakeRecord P1 P2 P3 P4 *
67326 ** Convert P2 registers beginning with P1 into the [record format]
67330 ** P4 may be a string that is P2 characters long. The nth character of the
67378 assert( u.ap.nField>0 && pOp->p2>0 && pOp->p2+u.ap.nField<=p->nMem+1 );
67380 u.ap.nField = pOp->p2;
67385 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
67458 /* Opcode: Count P1 P2 * * *
67461 ** opened by cursor P1 in register P2
67648 /* Opcode: AutoCommit P1 P2 * * *
67650 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
67665 u.as.iRollback = pOp->p2;
67724 /* Opcode: Transaction P1 P2 * * *
67735 ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
67740 ** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
67753 ** If P2 is zero, then a read-lock is obtained on the database file.
67765 rc = sqlite3BtreeBeginTrans(u.at.pBt, pOp->p2);
67775 if( pOp->p2 && p->usesStmtJournal
67799 /* Opcode: ReadCookie P1 P2 P3 * *
67801 ** Read cookie number P3 from database P1 and write it into register P2.
67830 /* Opcode: SetCookie P1 P2 P3 * *
67833 ** into cookie number P2 of database P1. P2==1 is the schema version.
67834 ** P2==2 is the database format. P2==3 is the recommended pager cache
67844 assert( pOp->p2<SQLITE_N_BTREE_META );
67853 rc = sqlite3BtreeUpdateMeta(u.av.pDb->pBt, pOp->p2, (int)pIn3->u.i);
67854 if( pOp->p2==BTREE_SCHEMA_VERSION ){
67858 }else if( pOp->p2==BTREE_FILE_FORMAT ){
67871 /* Opcode: VerifyCookie P1 P2 P3 * *
67874 ** schema version) and make sure it is equal to P2 and that the
67906 if( u.aw.iMeta!=pOp->p2 || u.aw.iGen!=pOp->p3 ){
67932 /* Opcode: OpenRead P1 P2 P3 P4 P5
67935 ** P2 in a database file. The database file is determined by P3.
67942 ** If P5!=0 then use the content of register P2 as the root page, not
67943 ** the value of P2 itself.
67962 /* Opcode: OpenWrite P1 P2 P3 P4 P5
67965 ** page is P2. Or if P5!=0 use the content of register P2 to find the
67986 int p2;
68001 u.ax.p2 = pOp->p2;
68018 assert( u.ax.p2>0 );
68019 assert( u.ax.p2<=p->nMem );
68020 pIn2 = &aMem[u.ax.p2];
68024 u.ax.p2 = (int)pIn2->u.i;
68025 /* The u.ax.p2 value always comes from a prior OP_CreateTable opcode and
68026 ** that opcode will always set the u.ax.p2 value to 2 or more or else fail.
68029 if( NEVER(u.ax.p2<2) ) {
68046 rc = sqlite3BtreeCursor(u.ax.pX, u.ax.p2, u.ax.wrFlag, u.ax.pKeyInfo, u.ax.pCur->pCursor);
68062 /* Opcode: OpenEphemeral P1 P2 * P4 P5
68069 ** P2 is the number of columns in the ephemeral table.
68085 /* Opcode: OpenAutoindex P1 P2 * P4 *
68105 u.ay.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68141 /* Opcode: OpenSorter P1 P2 * P4 *
68152 u.az.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68165 /* Opcode: OpenPseudo P1 P2 P3 * *
68169 ** register P2. In other words, cursor P1 becomes an alias for the
68170 ** MEM_Blob content contained in register P2.
68189 u.ba.pCx->pseudoTableReg = pOp->p2;
68207 /* Opcode: SeekGe P1 P2 P3 P4 *
68216 ** greater than or equal to the key and P2 is not zero, then jump to P2.
68220 /* Opcode: SeekGt P1 P2 P3 P4 *
68229 ** the key and P2 is not zero, then jump to P2.
68233 /* Opcode: SeekLt P1 P2 P3 P4 *
68242 ** the key and P2 is not zero, then jump to P2.
68246 /* Opcode: SeekLe P1 P2 P3 P4 *
68255 ** less than or equal to the key and P2 is not zero, then jump to P2.
68273 assert( pOp->p2!=0 );
68298 ** then the seek is not possible, so jump to P2 */
68299 pc = pOp->p2 - 1;
68322 pc = pOp->p2 - 1;
68399 assert( pOp->p2>0 );
68401 pc = pOp->p2 - 1;
68408 pc = pOp->p2 - 1;
68413 /* Opcode: Seek P1 P2 * * *
68415 ** P1 is an open table cursor and P2 is a rowid integer. Arrange
68416 ** for P1 to move so that it points to the rowid given by P2.
68433 pIn2 = &aMem[pOp->p2];
68442 /* Opcode: Found P1 P2 P3 P4 *
68449 ** is a prefix of any entry in P1 then a jump is made to P2 and
68452 /* Opcode: NotFound P1 P2 P3 P4 *
68459 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
68522 if( u.bd.alreadyExists ) pc = pOp->p2 - 1;
68524 if( !u.bd.alreadyExists ) pc = pOp->p2 - 1;
68529 /* Opcode: IsUnique P1 P2 P3 P4 *
68544 ** value, jump immediately to P2.
68549 ** to instruction P2. Otherwise, the rowid of the conflicting index
68584 pc = pOp->p2 - 1;
68606 ** to P2. Otherwise, copy the rowid of the conflicting record to
68610 pc = pOp->p2 - 1;
68618 /* Opcode: NotExists P1 P2 P3 * *
68621 ** with that key does not exist in table of P1, then jump to P2.
68658 pc = pOp->p2 - 1;
68666 pc = pOp->p2 - 1;
68673 /* Opcode: Sequence P1 P2 * * *
68676 ** Write the sequence number into register P2.
68688 /* Opcode: NewRowid P1 P2 P3 * *
68693 ** written to register P2.
68839 /* Opcode: Insert P1 P2 P3 P4 P5
68844 ** number P2. The key is stored in register P3. The key must
68869 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
68870 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
68871 ** and register P2 becomes ephemeral. If the cursor is changed, the
68872 ** value of register P2 will then change. Make sure this does not
68878 /* Opcode: InsertInt P1 P2 P3 P4 P5
68897 u.bh.pData = &aMem[pOp->p2];
68905 REGISTER_TRACE(pOp->p2, u.bh.pData);
68953 /* Opcode: Delete P1 P2 * P4 *
68962 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
69016 if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
69032 /* Opcode: SorterCompare P1 P2 P3
69037 ** fall through to the next instruction. Otherwise, jump to instruction P2.
69050 pc = pOp->p2-1;
69055 /* Opcode: SorterData P1 P2 * * *
69057 ** Write into register P2 the current sorter data for sorter cursor P1.
69064 pOut = &aMem[pOp->p2];
69075 /* Opcode: RowData P1 P2 * * *
69077 ** Write into register P2 the complete row data for cursor P1.
69079 ** It is just copied onto the P2 register exactly as
69085 /* Opcode: RowKey P1 P2 * * *
69087 ** Write into register P2 the complete row key for cursor P1.
69104 pOut = &aMem[pOp->p2];
69160 /* Opcode: Rowid P1 P2 * * *
69162 ** Store in register P2 an integer which is the key of the table entry that
69232 /* Opcode: Last P1 P2 * * *
69236 ** If the table or index is empty and P2>0, then jump immediately to P2.
69237 ** If P2 is 0 or if the table or index is not empty, fall through
69259 if( pOp->p2>0 && u.bo.res ){
69260 pc = pOp->p2 - 1;
69266 /* Opcode: Sort P1 P2 * * *
69290 /* Opcode: Rewind P1 P2 * * *
69294 ** If the table or index is empty and P2>0, then jump immediately to P2.
69295 ** If P2 is 0 or if the table or index is not empty, fall through
69322 assert( pOp->p2>0 && pOp->p2<p->nOp );
69324 pc = pOp->p2 - 1;
69329 /* Opcode: Next P1 P2 * P4 P5
69334 ** jump immediately to P2.
69346 /* Opcode: Prev P1 P2 * * P5
69351 ** jump immediately to P2.
69394 pc = pOp->p2 - 1;
69404 /* Opcode: IdxInsert P1 P2 P3 * P5
69406 ** Register P2 holds an SQL index key made using the
69432 pIn2 = &aMem[pOp->p2];
69455 /* Opcode: IdxDelete P1 P2 P3 * *
69457 ** The content of P3 registers starting at register P2 form
69470 assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
69479 u.bs.r.aMem = &aMem[pOp->p2];
69493 /* Opcode: IdxRowid P1 P2 * * *
69495 ** Write into register P2 an integer which is the last entry in the record at
69530 /* Opcode: IdxGE P1 P2 P3 P4 P5
69537 ** then jump to P2. Otherwise fall through to the next instruction.
69544 /* Opcode: IdxLT P1 P2 P3 P4 P5
69550 ** If the P1 index entry is less than the key value then jump to P2.
69591 pc = pOp->p2 - 1 ;
69597 /* Opcode: Destroy P1 P2 P3 * *
69610 ** is stored in register P2. If no page
69612 ** the last one in the database) then a zero is stored in register P2.
69613 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
69657 /* Opcode: Clear P1 P2 P3
69663 ** The table being clear is in the main database file if P2==0. If
69664 ** P2==1 then the table to be clear is in the auxiliary database file
69681 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
69683 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bw.nChange : 0)
69696 /* Opcode: CreateTable P1 P2 * * *
69701 ** register P2
69709 /* Opcode: CreateIndex P1 P2 * * *
69714 ** register P2.
69851 /* Opcode: IntegrityCk P1 P2 P3 * P5
69863 ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
69881 u.bz.nRoot = pOp->p2;
69914 /* Opcode: RowSetAdd P1 P2 * * *
69916 ** Insert the integer value held by register P2 into a boolean index
69919 ** An assertion fails if P2 is not an integer.
69923 pIn2 = &aMem[pOp->p2];
69933 /* Opcode: RowSetRead P1 P2 P3 * *
69937 ** unchanged and jump to instruction P2.
69950 pc = pOp->p2 - 1;
69958 /* Opcode: RowSetTest P1 P2 P3 P4
69962 ** the value held in P3, jump to register P2. Otherwise, insert the
70007 pc = pOp->p2 - 1;
70020 /* Opcode: Program P1 P2 P3 P4 *
70025 ** cell in an array of values used as arguments to the sub-program. P2
70141 /* Opcode: Param P1 P2 * * *
70145 ** cell of the calling (parent) frame to cell P2 in the current frames
70167 /* Opcode: FkCounter P1 P2 * * *
70169 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
70176 db->nDeferredCons += pOp->p2;
70178 p->nFkConstraint += pOp->p2;
70183 /* Opcode: FkIfZero P1 P2 * * *
70186 ** If so, jump to instruction P2. Otherwise, fall through to the next
70196 if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70198 if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70205 /* Opcode: MemMax P1 P2 * * *
70210 ** its current value and the value in register P2.
70228 pIn2 = &aMem[pOp->p2];
70237 /* Opcode: IfPos P1 P2 * * *
70239 ** If the value of register P1 is 1 or greater, jump to P2.
70248 pc = pOp->p2 - 1;
70253 /* Opcode: IfNeg P1 P2 * * *
70255 ** If the value of register P1 is less than zero, jump to P2.
70264 pc = pOp->p2 - 1;
70269 /* Opcode: IfZero P1 P2 P3 * *
70272 ** value in register P1. If the result is exactly 0, jump to P2.
70282 pc = pOp->p2 - 1;
70287 /* Opcode: AggStep * P2 P3 P4 P5
70294 ** The P5 arguments are taken from register P2 and its
70309 u.cf.pRec = &aMem[pOp->p2];
70352 /* Opcode: AggFinal P1 P2 * P4 *
70357 ** P2 is the number of arguments that the step function takes and
70358 ** P4 is a pointer to the FuncDef for this function. The P2
70384 /* Opcode: Checkpoint P1 P2 P3 * *
70387 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
70404 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70405 || pOp->p2==SQLITE_CHECKPOINT_FULL
70406 || pOp->p2==SQLITE_CHECKPOINT_RESTART
70408 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &u.ch.aRes[1], &u.ch.aRes[2]);
70421 /* Opcode: JournalMode P1 P2 P3 * P5
70430 ** Write a string containing the final journal-mode to register P2.
70515 pOut = &aMem[pOp->p2];
70539 /* Opcode: IncrVacuum P1 P2 * * *
70543 ** P2. Otherwise, fall through to the next instruction.
70555 pc = pOp->p2 - 1;
70581 /* Opcode: TableLock P1 P2 P3 P4 *
70590 ** P2 contains the root-page of the table to lock.
70602 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
70700 /* Opcode: VFilter P1 P2 P3 P4 *
70702 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
70716 ** A jump is made to P2 if the result set after filtering would be empty.
70766 pc = pOp->p2 - 1;
70776 /* Opcode: VColumn P1 P2 P3 * *
70778 ** Store the value of the P2-th column of
70812 rc = u.cn.pModule->xColumn(pCur->pVtabCursor, &u.cn.sContext, pOp->p2);
70835 /* Opcode: VNext P1 P2 * * *
70838 ** jump to instruction P2. Or, if the virtual table has reached
70874 /* If there is data, jump to P2 */
70875 pc = pOp->p2 - 1;
70914 /* Opcode: VUpdate P1 P2 P3 P4 *
70917 ** This opcode invokes the corresponding xUpdate method. P2 values
70919 ** invocation. The value in register (P3+P2-1) corresponds to the
70930 ** If P2==1 then no insert is performed. argv[0] is the rowid of
70948 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
70953 u.cq.nArg = pOp->p2;
70989 /* Opcode: Pagecount P1 P2 * * *
70991 ** Write the current number of pages in database P1 to memory cell P2.
71001 /* Opcode: MaxPgcnt P1 P2 P3 * *
71007 ** Store the maximum page count after the change in register P2.
71102 registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
71457 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
71990 VdbeSorterIter *p2;
72003 p2 = &pSorter->aIter[i2];
72007 }else if( p2->pFile==0 ){
72013 pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
72106 ** Merge the two sorted lists p1 and p2 into a single list.
72112 SorterRecord *p2, /* Second list to merge */
72117 void *pVal2 = p2 ? p2->pVal : 0;
72119 while( p1 && p2 ){
72121 vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res);
72128 *pp = p2;
72129 pp = &p2->pNext;
72130 p2 = p2->pNext;
72131 if( p2==0 ) break;
72132 pVal2 = p2->pVal;
72135 *pp = p1 ? p1 : p2;
84730 ** starts the transactions will be coded and the OP_Goto P2 value
86297 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
86304 ** If p2 is negative, return the p2 characters preceeding p1.
86315 i64 p1, p2;
86342 p2 = sqlite3_value_int(argv[2]);
86343 if( p2<0 ){
86344 p2 = -p2;
86348 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
86353 p2 += p1;
86354 if( p2<0 ) p2 = 0;
86359 }else if( p2>0 ){
86360 p2--;
86363 p1 -= p2;
86365 p2 += p1;
86369 assert( p1>=0 && p2>=0 );
86375 for(z2=z; *z2 && p2; p2--){
86380 if( p1+p2>len ){
86381 p2 = len-p1;
86382 if( p2<0 ) p2 = 0;
86384 sqlite3_result_blob(context, (char*)&z[p1], (int)p2, SQLITE_TRANSIENT);
89111 int tnum = pOp->p2;
89862 pOp->p2 = regRowid;
94269 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
98552 pOp->p2 = iFlag;
104035 CollSeq *p2 = sqlite3ExprCollSeq(pParse, p);
104036 if( p1==p2 ) continue;
106426 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106516 pLevel->p2 = start;
106723 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106959 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
107681 sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
107766 if( pOp->p2==pIdx->aiColumn[j] ){
107767 pOp->p2 = j;
115551 sqlite3 *p2;
115557 for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
115558 if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
115559 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
118549 char *p2 = *pp2;
118551 while( *p1 || *p2 ){
118559 if( *p2==POS_COLUMN ) sqlite3Fts3GetVarint32(&p2[1], &iCol2);
118560 else if( *p2==POS_END ) iCol2 = POSITION_LIST_END;
118569 p2 += n;
118571 /* At this point, both p1 and p2 point to the start of column-lists
118581 fts3GetDeltaVarint(&p2, &i2);
118587 fts3ReadNextPos(&p2, &i2);
118591 fts3ReadNextPos(&p2, &i2);
118598 p2 += fts3PutColNumber(&p, iCol2);
118599 fts3ColumnlistCopy(&p, &p2);
118606 *pp2 = p2 + 1;
118642 char *p2 = *pp2;
118649 assert( p!=0 && *p1!=0 && *p2!=0 );
118654 if( *p2==POS_COLUMN ){
118655 p2++;
118656 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118672 assert( *p2!=POS_END && *p2!=POS_COLUMN );
118674 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118687 if( (*p2&0xFE)==0 ) break;
118688 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118701 fts3ColumnlistCopy(0, &p2);
118702 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
118703 if( 0==*p1 || 0==*p2 ) break;
118707 p2++;
118708 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118711 /* Advance pointer p1 or p2 (whichever corresponds to the smaller of
118722 fts3ColumnlistCopy(0, &p2);
118723 if( 0==*p2 ) break;
118724 p2++;
118725 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118729 fts3PoslistCopy(0, &p2);
118732 *pp2 = p2;
118765 char *p2 = *pp2;
118775 *pp2 = p2;
118906 char *p2 = a2;
118948 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118949 while( p1 || p2 ){
118952 if( p2 && p1 && iDiff==0 ){
118954 fts3PoslistMerge(&p, &p1, &p2);
118956 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118957 }else if( !p2 || (p1 && iDiff<0) ){
118963 fts3PoslistCopy(&p, &p2);
118964 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118998 char *p2 = aRight;
119007 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
119009 while( p1 && p2 ){
119017 if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
119023 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
119028 fts3PoslistCopy(0, &p2);
119029 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
120408 char *p2 = aOut;
120411 fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2);
120436 char *p2;
120441 p2 = pPhrase->doclist.pList;
120445 p2 = aPoslist;
120456 if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){
121048 char *p2;
121054 p2 = pOut = pPhrase->doclist.pList;
121056 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
124729 const sqlite3_tokenizer_module *p2;
124737 rc = queryTokenizer(db, "simple", &p2);
124739 assert( p1==p2 );
124740 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124742 assert( p2==0 );
124748 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124750 assert( p2==p1 );
131557 ** Store the union of cells p1 and p2 in p1.
131559 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131563 p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f);
131564 p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f);
131568 p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i);
131569 p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i);
131575 ** Return true if the area covered by p2 is a subset of the area covered
131578 static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131583 RtreeCoord *a2 = &p2->aCoord[ii];
