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) */
59670 ** p1, p2, p3 Operands
59676 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
59693 pOp->p2 = p2;
59713 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
59714 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
59725 int p2, /* The P2 operand */
59730 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59757 int p2, /* The P2 operand */
59761 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59769 ** label can be used as the P2 value of an operation. Later, when
59771 ** through its operation list and change all values of P2 which match
59774 ** The VDBE knows that a P2 value is a label because labels are
59775 ** always negative and P2 values are suppose to be non-negative.
59776 ** Hence, a negative P2 value is a label that has yet to be resolved.
59890 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59891 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59895 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
59915 || (opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1)
59918 && (pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort))
59936 ** Loop through the program looking for P2 values that are negative
59938 ** label by setting the P2 value to its correct non-zero value.
59942 ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
59960 }else if( (opcode==OP_Transaction && pOp->p2!=0) || opcode==OP_Vacuum ){
59964 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
59980 if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){
59981 assert( -1-pOp->p2<p->nLabel );
59982 pOp->p2 = aLabel[-1-pOp->p2];
60038 int p2 = pIn->p2;
60042 if( p2<0 && (sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
60043 pOut->p2 = addr + ADDR(p2);
60045 pOut->p2 = p2;
60077 ** Change the value of the P2 operand for a specific instruction.
60083 p->aOp[addr].p2 = val;
60110 ** Change the P2 operand of instruction addr so that it points to
60588 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
60795 pMem->u.i = pOp->p2; /* P2 */
64389 ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
65046 int p2; /* Register to copy to */
65085 int p2;
65102 int p2; /* column number to retrieve */
65182 int p2;
65533 ** external allocations out of mem[p2] and set mem[p2] to be
65535 ** value or convert mem[p2] to a different type.
65539 assert( pOp->p2>0 );
65540 assert( pOp->p2<=p->nMem );
65541 pOut = &aMem[pOp->p2];
65556 assert( pOp->p2>0 );
65557 assert( pOp->p2<=p->nMem );
65558 assert( memIsValid(&aMem[pOp->p2]) );
65559 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
65568 assert( pOp->p2>0 );
65569 assert( pOp->p2<=p->nMem );
65570 memAboutToChange(p, &aMem[pOp->p2]);
65616 /* Opcode: Goto * P2 * * *
65618 ** An unconditional jump to address P2.
65620 ** the one at index P2 from the beginning of
65625 pc = pOp->p2 - 1;
65629 /* Opcode: Gosub P1 P2 * * *
65632 ** and then jump to address P2.
65642 pc = pOp->p2 - 1;
65675 /* Opcode: HaltIfNull P1 P2 P3 P4 *
65678 ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
65687 /* Opcode: Halt P1 P2 * P4 *
65694 ** For errors, it can be some other value. If P1!=0 then P2 will determine
65696 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
65715 if( pOp->p2==OE_Ignore ){
65717 ** currently being halted. If the p2 instruction of this OP_Halt
65720 ** as the p2 of the calling OP_Program. */
65721 pc = p->aOp[pc].p2-1;
65729 p->errorAction = (u8)pOp->p2;
65752 /* Opcode: Integer P1 P2 * * *
65754 ** The 32-bit integer value P1 is written into register P2.
65761 /* Opcode: Int64 * P2 * P4 *
65764 ** Write that value into register P2.
65773 /* Opcode: Real * P2 * P4 *
65776 ** Write that value into register P2.
65786 /* Opcode: String8 * P2 * P4 *
65820 /* Opcode: String P1 P2 * P4 *
65822 ** The string value P4 of length P1 (bytes) is stored in register P2.
65834 /* Opcode: Null * P2 P3 * *
65836 ** Write a NULL into registers P2. If P3 greater than P2, then also write
65837 ** NULL into register P3 and ever register in between P2 and P3. If P3
65838 ** is less than P2 (typically P3 is zero) then only register P2 is
65845 u.ab.cnt = pOp->p3-pOp->p2;
65859 /* Opcode: Blob P1 P2 * P4
65862 ** blob in register P2.
65872 /* Opcode: Variable P1 P2 * P4 *
65874 ** Transfer the values of bound parameter P1 into register P2
65895 /* Opcode: Move P1 P2 P3 * *
65898 ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
65900 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
65907 int p2; /* Register to copy to */
65912 u.ad.p2 = pOp->p2;
65913 assert( u.ad.n>0 && u.ad.p1>0 && u.ad.p2>0 );
65914 assert( u.ad.p1+u.ad.n<=u.ad.p2 || u.ad.p2+u.ad.n<=u.ad.p1 );
65917 pOut = &aMem[u.ad.p2];
65928 pOut->pScopyFrom += u.ad.p1 - pOp->p2;
65932 REGISTER_TRACE(u.ad.p2++, pOut);
65939 /* Opcode: Copy P1 P2 * * *
65941 ** Make a copy of register P1 into register P2.
65948 pOut = &aMem[pOp->p2];
65952 REGISTER_TRACE(pOp->p2, pOut);
65956 /* Opcode: SCopy P1 P2 * * *
65958 ** Make a shallow copy of register P1 into register P2.
65970 pOut = &aMem[pOp->p2];
65976 REGISTER_TRACE(pOp->p2, pOut);
65980 /* Opcode: ResultRow P1 P2 * * *
65982 ** The registers P1 through P1+P2-1 contain a single row of
65993 assert( p->nResColumn==pOp->p2 );
65995 assert( pOp->p1+pOp->p2<=p->nMem+1 );
66035 for(u.ae.i=0; u.ae.i<pOp->p2; u.ae.i++){
66053 /* Opcode: Concat P1 P2 P3 * *
66056 ** register P2 and store the result in register P3.
66057 ** If either the P1 or P2 text are NULL then store NULL in P3.
66059 ** P3 = P2 || P1
66062 ** if P3 is the same register as P2, the implementation is able
66071 pIn2 = &aMem[pOp->p2];
66102 /* Opcode: Add P1 P2 P3 * *
66104 ** Add the value in register P1 to the value in register P2
66108 /* Opcode: Multiply P1 P2 P3 * *
66111 ** Multiply the value in register P1 by the value in register P2
66115 /* Opcode: Subtract P1 P2 P3 * *
66117 ** Subtract the value in register P1 from the value in register P2
66121 /* Opcode: Divide P1 P2 P3 * *
66123 ** Divide the value in register P1 by the value in register P2
66124 ** and store the result in register P3 (P3=P2/P1). If the value in
66128 /* Opcode: Remainder P1 P2 P3 * *
66131 ** register P1 by the value in register P2 and store the result in P3.
66132 ** If the value in register P2 is zero the result is NULL.
66150 pIn2 = &aMem[pOp->p2];
66244 /* Opcode: Function P1 P2 P3 P4 P5
66247 ** defines the function) with P5 arguments taken from register P2 and
66276 assert( u.ah.n==0 || (pOp->p2>0 && pOp->p2+u.ah.n<=p->nMem+1) );
66277 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ah.n );
66278 u.ah.pArg = &aMem[pOp->p2];
66284 REGISTER_TRACE(pOp->p2+u.ah.i, u.ah.pArg);
66364 /* Opcode: BitAnd P1 P2 P3 * *
66366 ** Take the bit-wise AND of the values in register P1 and P2 and
66370 /* Opcode: BitOr P1 P2 P3 * *
66372 ** Take the bit-wise OR of the values in register P1 and P2 and
66376 /* Opcode: ShiftLeft P1 P2 P3 * *
66378 ** Shift the integer value in register P2 to the left by the
66383 /* Opcode: ShiftRight P1 P2 P3 * *
66385 ** Shift the integer value in register P2 to the right by the
66402 pIn2 = &aMem[pOp->p2];
66444 /* Opcode: AddImm P1 P2 * * *
66446 ** Add the constant P2 to the value in register P1.
66455 pIn1->u.i += pOp->p2;
66459 /* Opcode: MustBeInt P1 P2 * * *
66463 P2, or if P2==0
66470 if( pOp->p2==0 ){
66474 pc = pOp->p2 - 1;
66602 /* Opcode: Lt P1 P2 P3 P4 P5
66605 ** jump to address P2.
66630 ** store a boolean result (either 0, or 1, or NULL) in register P2.
66632 /* Opcode: Ne P1 P2 P3 P4 P5
66644 /* Opcode: Eq P1 P2 P3 P4 P5
66656 /* Opcode: Le P1 P2 P3 P4 P5
66662 /* Opcode: Gt P1 P2 P3 P4 P5
66668 /* Opcode: Ge P1 P2 P3 P4 P5
66706 pOut = &aMem[pOp->p2];
66708 REGISTER_TRACE(pOp->p2, pOut);
66710 pc = pOp->p2-1;
66738 pOut = &aMem[pOp->p2];
66742 REGISTER_TRACE(pOp->p2, pOut);
66744 pc = pOp->p2-1;
66769 /* Opcode: Compare P1 P2 P3 P4 *
66772 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
66788 int p2;
66800 u.ak.p2 = pOp->p2;
66806 assert( u.ak.p2>0 && u.ak.p2+mx<=p->nMem+1 );
66809 assert( u.ak.p2>0 && u.ak.p2+u.ak.n<=p->nMem+1 );
66815 assert( memIsValid(&aMem[u.ak.p2+u.ak.idx]) );
66817 REGISTER_TRACE(u.ak.p2+u.ak.idx, &aMem[u.ak.p2+u.ak.idx]);
66821 iCompare = sqlite3MemCompare(&aMem[u.ak.p1+u.ak.idx], &aMem[u.ak.p2+u.ak.idx], u.ak.pColl);
66831 /* Opcode: Jump P1 P2 P3 * *
66833 ** Jump to the instruction at address P1, P2, or P3 depending on whether
66835 ** equal to, or greater than the P2 vector, respectively.
66841 pc = pOp->p2 - 1;
66848 /* Opcode: And P1 P2 P3 * *
66850 ** Take the logical AND of the values in registers P1 and P2 and
66853 ** If either P1 or P2 is 0 (false) then the result is 0 even if
66857 /* Opcode: Or P1 P2 P3 * *
66859 ** Take the logical OR of the values in register P1 and P2 and
66862 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
66879 pIn2 = &aMem[pOp->p2];
66902 /* Opcode: Not P1 P2 * * *
66905 ** boolean complement in register P2. If the value in register P1 is
66906 ** NULL, then a NULL is stored in P2.
66910 pOut = &aMem[pOp->p2];
66919 /* Opcode: BitNot P1 P2 * * *
66922 ** ones-complement of the P1 value into register P2. If P1 holds
66923 ** a NULL then store a NULL in P2.
66927 pOut = &aMem[pOp->p2];
66936 /* Opcode: Once P1 P2 * * *
66938 ** Check if OP_Once flag P1 is set. If so, jump to instruction P2. Otherwise,
66946 pc = pOp->p2-1;
66953 /* Opcode: If P1 P2 P3 * *
66955 ** Jump to P2 if the value in register P1 is true. The value
66959 /* Opcode: IfNot P1 P2 P3 * *
66961 ** Jump to P2 if the value in register P1 is False. The value
66982 pc = pOp->p2-1;
66987 /* Opcode: IsNull P1 P2 * * *
66989 ** Jump to P2 if the value in register P1 is NULL.
66994 pc = pOp->p2 - 1;
66999 /* Opcode: NotNull P1 P2 * * *
67001 ** Jump to P2 if the value in register P1 is not NULL.
67006 pc = pOp->p2 - 1;
67011 /* Opcode: Column P1 P2 P3 P4 P5
67015 ** information about the format of the data.) Extract the P2-th column
67016 ** from this record. If there are less that (P2+1)
67021 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
67035 int p2; /* column number to retrieve */
67059 u.an.p2 = pOp->p2;
67134 assert( u.an.p2<u.an.nField );
67271 /* Get the column information. If u.an.aOffset[u.an.p2] is non-zero, then
67272 ** deserialize the value from the record. If u.an.aOffset[u.an.p2] is zero,
67277 if( u.an.aOffset[u.an.p2] ){
67281 sqlite3VdbeSerialGet((u8 *)&u.an.zRec[u.an.aOffset[u.an.p2]], u.an.aType[u.an.p2], u.an.pDest);
67283 u.an.len = sqlite3VdbeSerialTypeLen(u.an.aType[u.an.p2]);
67285 rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, u.an.aOffset[u.an.p2], u.an.len, u.an.pC->isIndex, &u.an.sMem);
67290 sqlite3VdbeSerialGet((u8*)u.an.zData, u.an.aType[u.an.p2], u.an.pDest);
67324 /* Opcode: Affinity P1 P2 * P4 *
67326 ** Apply affinities to a range of P2 registers starting with P1.
67328 ** P4 is a string that is P2 characters long. The nth character of the
67340 assert( u.ao.zAffinity[pOp->p2]==0 );
67352 /* Opcode: MakeRecord P1 P2 P3 P4 *
67354 ** Convert P2 registers beginning with P1 into the [record format]
67358 ** P4 may be a string that is P2 characters long. The nth character of the
67406 assert( u.ap.nField>0 && pOp->p2>0 && pOp->p2+u.ap.nField<=p->nMem+1 );
67408 u.ap.nField = pOp->p2;
67413 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
67486 /* Opcode: Count P1 P2 * * *
67489 ** opened by cursor P1 in register P2
67676 /* Opcode: AutoCommit P1 P2 * * *
67678 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
67693 u.as.iRollback = pOp->p2;
67752 /* Opcode: Transaction P1 P2 * * *
67763 ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
67768 ** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
67781 ** If P2 is zero, then a read-lock is obtained on the database file.
67793 rc = sqlite3BtreeBeginTrans(u.at.pBt, pOp->p2);
67803 if( pOp->p2 && p->usesStmtJournal
67827 /* Opcode: ReadCookie P1 P2 P3 * *
67829 ** Read cookie number P3 from database P1 and write it into register P2.
67858 /* Opcode: SetCookie P1 P2 P3 * *
67861 ** into cookie number P2 of database P1. P2==1 is the schema version.
67862 ** P2==2 is the database format. P2==3 is the recommended pager cache
67872 assert( pOp->p2<SQLITE_N_BTREE_META );
67881 rc = sqlite3BtreeUpdateMeta(u.av.pDb->pBt, pOp->p2, (int)pIn3->u.i);
67882 if( pOp->p2==BTREE_SCHEMA_VERSION ){
67886 }else if( pOp->p2==BTREE_FILE_FORMAT ){
67899 /* Opcode: VerifyCookie P1 P2 P3 * *
67902 ** schema version) and make sure it is equal to P2 and that the
67934 if( u.aw.iMeta!=pOp->p2 || u.aw.iGen!=pOp->p3 ){
67960 /* Opcode: OpenRead P1 P2 P3 P4 P5
67963 ** P2 in a database file. The database file is determined by P3.
67970 ** If P5!=0 then use the content of register P2 as the root page, not
67971 ** the value of P2 itself.
67990 /* Opcode: OpenWrite P1 P2 P3 P4 P5
67993 ** page is P2. Or if P5!=0 use the content of register P2 to find the
68014 int p2;
68029 u.ax.p2 = pOp->p2;
68046 assert( u.ax.p2>0 );
68047 assert( u.ax.p2<=p->nMem );
68048 pIn2 = &aMem[u.ax.p2];
68052 u.ax.p2 = (int)pIn2->u.i;
68053 /* The u.ax.p2 value always comes from a prior OP_CreateTable opcode and
68054 ** that opcode will always set the u.ax.p2 value to 2 or more or else fail.
68057 if( NEVER(u.ax.p2<2) ) {
68074 rc = sqlite3BtreeCursor(u.ax.pX, u.ax.p2, u.ax.wrFlag, u.ax.pKeyInfo, u.ax.pCur->pCursor);
68090 /* Opcode: OpenEphemeral P1 P2 * P4 P5
68097 ** P2 is the number of columns in the ephemeral table.
68113 /* Opcode: OpenAutoindex P1 P2 * P4 *
68133 u.ay.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68169 /* Opcode: OpenSorter P1 P2 * P4 *
68180 u.az.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68193 /* Opcode: OpenPseudo P1 P2 P3 * *
68197 ** register P2. In other words, cursor P1 becomes an alias for the
68198 ** MEM_Blob content contained in register P2.
68217 u.ba.pCx->pseudoTableReg = pOp->p2;
68235 /* Opcode: SeekGe P1 P2 P3 P4 *
68244 ** greater than or equal to the key and P2 is not zero, then jump to P2.
68248 /* Opcode: SeekGt P1 P2 P3 P4 *
68257 ** the key and P2 is not zero, then jump to P2.
68261 /* Opcode: SeekLt P1 P2 P3 P4 *
68270 ** the key and P2 is not zero, then jump to P2.
68274 /* Opcode: SeekLe P1 P2 P3 P4 *
68283 ** less than or equal to the key and P2 is not zero, then jump to P2.
68301 assert( pOp->p2!=0 );
68326 ** then the seek is not possible, so jump to P2 */
68327 pc = pOp->p2 - 1;
68350 pc = pOp->p2 - 1;
68427 assert( pOp->p2>0 );
68429 pc = pOp->p2 - 1;
68436 pc = pOp->p2 - 1;
68441 /* Opcode: Seek P1 P2 * * *
68443 ** P1 is an open table cursor and P2 is a rowid integer. Arrange
68444 ** for P1 to move so that it points to the rowid given by P2.
68461 pIn2 = &aMem[pOp->p2];
68470 /* Opcode: Found P1 P2 P3 P4 *
68477 ** is a prefix of any entry in P1 then a jump is made to P2 and
68480 /* Opcode: NotFound P1 P2 P3 P4 *
68487 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
68550 if( u.bd.alreadyExists ) pc = pOp->p2 - 1;
68552 if( !u.bd.alreadyExists ) pc = pOp->p2 - 1;
68557 /* Opcode: IsUnique P1 P2 P3 P4 *
68572 ** value, jump immediately to P2.
68577 ** to instruction P2. Otherwise, the rowid of the conflicting index
68612 pc = pOp->p2 - 1;
68634 ** to P2. Otherwise, copy the rowid of the conflicting record to
68638 pc = pOp->p2 - 1;
68646 /* Opcode: NotExists P1 P2 P3 * *
68649 ** with that key does not exist in table of P1, then jump to P2.
68686 pc = pOp->p2 - 1;
68694 pc = pOp->p2 - 1;
68701 /* Opcode: Sequence P1 P2 * * *
68704 ** Write the sequence number into register P2.
68716 /* Opcode: NewRowid P1 P2 P3 * *
68721 ** written to register P2.
68867 /* Opcode: Insert P1 P2 P3 P4 P5
68872 ** number P2. The key is stored in register P3. The key must
68897 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
68898 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
68899 ** and register P2 becomes ephemeral. If the cursor is changed, the
68900 ** value of register P2 will then change. Make sure this does not
68906 /* Opcode: InsertInt P1 P2 P3 P4 P5
68925 u.bh.pData = &aMem[pOp->p2];
68933 REGISTER_TRACE(pOp->p2, u.bh.pData);
68981 /* Opcode: Delete P1 P2 * P4 *
68990 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
69044 if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
69060 /* Opcode: SorterCompare P1 P2 P3
69065 ** fall through to the next instruction. Otherwise, jump to instruction P2.
69078 pc = pOp->p2-1;
69083 /* Opcode: SorterData P1 P2 * * *
69085 ** Write into register P2 the current sorter data for sorter cursor P1.
69092 pOut = &aMem[pOp->p2];
69103 /* Opcode: RowData P1 P2 * * *
69105 ** Write into register P2 the complete row data for cursor P1.
69107 ** It is just copied onto the P2 register exactly as
69113 /* Opcode: RowKey P1 P2 * * *
69115 ** Write into register P2 the complete row key for cursor P1.
69132 pOut = &aMem[pOp->p2];
69188 /* Opcode: Rowid P1 P2 * * *
69190 ** Store in register P2 an integer which is the key of the table entry that
69260 /* Opcode: Last P1 P2 * * *
69264 ** If the table or index is empty and P2>0, then jump immediately to P2.
69265 ** If P2 is 0 or if the table or index is not empty, fall through
69287 if( pOp->p2>0 && u.bo.res ){
69288 pc = pOp->p2 - 1;
69294 /* Opcode: Sort P1 P2 * * *
69318 /* Opcode: Rewind P1 P2 * * *
69322 ** If the table or index is empty and P2>0, then jump immediately to P2.
69323 ** If P2 is 0 or if the table or index is not empty, fall through
69350 assert( pOp->p2>0 && pOp->p2<p->nOp );
69352 pc = pOp->p2 - 1;
69357 /* Opcode: Next P1 P2 * P4 P5
69362 ** jump immediately to P2.
69374 /* Opcode: Prev P1 P2 * * P5
69379 ** jump immediately to P2.
69422 pc = pOp->p2 - 1;
69432 /* Opcode: IdxInsert P1 P2 P3 * P5
69434 ** Register P2 holds an SQL index key made using the
69460 pIn2 = &aMem[pOp->p2];
69483 /* Opcode: IdxDelete P1 P2 P3 * *
69485 ** The content of P3 registers starting at register P2 form
69498 assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
69507 u.bs.r.aMem = &aMem[pOp->p2];
69521 /* Opcode: IdxRowid P1 P2 * * *
69523 ** Write into register P2 an integer which is the last entry in the record at
69558 /* Opcode: IdxGE P1 P2 P3 P4 P5
69565 ** then jump to P2. Otherwise fall through to the next instruction.
69572 /* Opcode: IdxLT P1 P2 P3 P4 P5
69578 ** If the P1 index entry is less than the key value then jump to P2.
69619 pc = pOp->p2 - 1 ;
69625 /* Opcode: Destroy P1 P2 P3 * *
69638 ** is stored in register P2. If no page
69640 ** the last one in the database) then a zero is stored in register P2.
69641 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
69685 P2 P3
69691 ** The table being clear is in the main database file if P2==0. If
69692 ** P2==1 then the table to be clear is in the auxiliary database file
69709 assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
69711 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bw.nChange : 0)
69724 /* Opcode: CreateTable P1 P2 * * *
69729 ** register P2
69737 /* Opcode: CreateIndex P1 P2 * * *
69742 ** register P2.
69879 /* Opcode: IntegrityCk P1 P2 P3 * P5
69891 ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
69909 u.bz.nRoot = pOp->p2;
69942 /* Opcode: RowSetAdd P1 P2 * * *
69944 ** Insert the integer value held by register P2 into a boolean index
69947 ** An assertion fails if P2 is not an integer.
69951 pIn2 = &aMem[pOp->p2];
69961 /* Opcode: RowSetRead P1 P2 P3 * *
69965 ** unchanged and jump to instruction P2.
69978 pc = pOp->p2 - 1;
69986 /* Opcode: RowSetTest P1 P2 P3 P4
69990 ** the value held in P3, jump to register P2. Otherwise, insert the
70035 pc = pOp->p2 - 1;
70048 /* Opcode: Program P1 P2 P3 P4 *
70053 ** cell in an array of values used as arguments to the sub-program. P2
70169 /* Opcode: Param P1 P2 * * *
70173 ** cell of the calling (parent) frame to cell P2 in the current frames
70195 /* Opcode: FkCounter P1 P2 * * *
70197 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
70204 db->nDeferredCons += pOp->p2;
70206 p->nFkConstraint += pOp->p2;
70211 /* Opcode: FkIfZero P1 P2 * * *
70214 ** If so, jump to instruction P2. Otherwise, fall through to the next
70224 if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70226 if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70233 /* Opcode: MemMax P1 P2 * * *
70238 ** its current value and the value in register P2.
70256 pIn2 = &aMem[pOp->p2];
70265 /* Opcode: IfPos P1 P2 * * *
70267 ** If the value of register P1 is 1 or greater, jump to P2.
70276 pc = pOp->p2 - 1;
70281 /* Opcode: IfNeg P1 P2 * * *
70283 ** If the value of register P1 is less than zero, jump to P2.
70292 pc = pOp->p2 - 1;
70297 /* Opcode: IfZero P1 P2 P3 * *
70300 ** value in register P1. If the result is exactly 0, jump to P2.
70310 pc = pOp->p2 - 1;
70315 /* Opcode: AggStep * P2 P3 P4 P5
70322 ** The P5 arguments are taken from register P2 and its
70337 u.cf.pRec = &aMem[pOp->p2];
70380 /* Opcode: AggFinal P1 P2 * P4 *
70385 ** P2 is the number of arguments that the step function takes and
70386 ** P4 is a pointer to the FuncDef for this function. The P2
70412 /* Opcode: Checkpoint P1 P2 P3 * *
70415 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
70432 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70433 || pOp->p2==SQLITE_CHECKPOINT_FULL
70434 || pOp->p2==SQLITE_CHECKPOINT_RESTART
70436 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &u.ch.aRes[1], &u.ch.aRes[2]);
70449 /* Opcode: JournalMode P1 P2 P3 * P5
70458 ** Write a string containing the final journal-mode to register P2.
70543 pOut = &aMem[pOp->p2];
70567 /* Opcode: IncrVacuum P1 P2 * * *
70571 ** P2. Otherwise, fall through to the next instruction.
70583 pc = pOp->p2 - 1;
70609 /* Opcode: TableLock P1 P2 P3 P4 *
70618 ** P2 contains the root-page of the table to lock.
70630 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
70728 /* Opcode: VFilter P1 P2 P3 P4 *
70730 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
70744 ** A jump is made to P2 if the result set after filtering would be empty.
70794 pc = pOp->p2 - 1;
70804 /* Opcode: VColumn P1 P2 P3 * *
70806 ** Store the value of the P2-th column of
70840 rc = u.cn.pModule->xColumn(pCur->pVtabCursor, &u.cn.sContext, pOp->p2);
70863 /* Opcode: VNext P1 P2 * * *
70866 ** jump to instruction P2. Or, if the virtual table has reached
70902 /* If there is data, jump to P2 */
70903 pc = pOp->p2 - 1;
70942 /* Opcode: VUpdate P1 P2 P3 P4 *
70945 ** This opcode invokes the corresponding xUpdate method. P2 values
70947 ** invocation. The value in register (P3+P2-1) corresponds to the
70958 ** If P2==1 then no insert is performed. argv[0] is the rowid of
70976 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
70981 u.cq.nArg = pOp->p2;
71017 /* Opcode: Pagecount P1 P2 * * *
71019 ** Write the current number of pages in database P1 to memory cell P2.
71029 /* Opcode: MaxPgcnt P1 P2 P3 * *
71035 ** Store the maximum page count after the change in register P2.
71130 registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
71485 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
72018 VdbeSorterIter *p2;
72031 p2 = &pSorter->aIter[i2];
72035 }else if( p2->pFile==0 ){
72041 pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
72134 ** Merge the two sorted lists p1 and p2 into a single list.
72140 SorterRecord *p2, /* Second list to merge */
72145 void *pVal2 = p2 ? p2->pVal : 0;
72147 while( p1 && p2 ){
72149 vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res);
72156 *pp = p2;
72157 pp = &p2->pNext;
72158 p2 = p2->pNext;
72159 if( p2==0 ) break;
72160 pVal2 = p2->pVal;
72163 *pp = p1 ? p1 : p2;
84766 ** starts the transactions will be coded and the OP_Goto P2 value
86333 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
86340 ** If p2 is negative, return the p2 characters preceeding p1.
86351 i64 p1, p2;
86378 p2 = sqlite3_value_int(argv[2]);
86379 if( p2<0 ){
86380 p2 = -p2;
86384 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
86389 p2 += p1;
86390 if( p2<0 ) p2 = 0;
86395 }else if( p2>0 ){
86396 p2--;
86399 p1 -= p2;
86401 p2 += p1;
86405 assert( p1>=0 && p2>=0 );
86411 for(z2=z; *z2 && p2; p2--){
86416 if( p1+p2>len ){
86417 p2 = len-p1;
86418 if( p2<0 ) p2 = 0;
86420 sqlite3_result_blob(context, (char*)&z[p1], (int)p2, SQLITE_TRANSIENT);
89147 int tnum = pOp->p2;
89898 pOp->p2 = regRowid;
94305 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
98588 pOp->p2 = iFlag;
104071 CollSeq *p2 = sqlite3ExprCollSeq(pParse, p);
104072 if( p1==p2 ) continue;
106462 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106552 pLevel->p2 = start;
106759 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106995 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
107717 sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
107802 if( pOp->p2==pIdx->aiColumn[j] ){
107803 pOp->p2 = j;
115587 sqlite3 *p2;
115593 for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
115594 if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
115595 assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
118585 char *p2 = *pp2;
118587 while( *p1 || *p2 ){
118595 if( *p2==POS_COLUMN ) sqlite3Fts3GetVarint32(&p2[1], &iCol2);
118596 else if( *p2==POS_END ) iCol2 = POSITION_LIST_END;
118605 p2 += n;
118607 /* At this point, both p1 and p2 point to the start of column-lists
118617 fts3GetDeltaVarint(&p2, &i2);
118623 fts3ReadNextPos(&p2, &i2);
118627 fts3ReadNextPos(&p2, &i2);
118634 p2 += fts3PutColNumber(&p, iCol2);
118635 fts3ColumnlistCopy(&p, &p2);
118642 *pp2 = p2 + 1;
118678 char *p2 = *pp2;
118685 assert( p!=0 && *p1!=0 && *p2!=0 );
118690 if( *p2==POS_COLUMN ){
118691 p2++;
118692 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118708 assert( *p2!=POS_END && *p2!=POS_COLUMN );
118710 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118723 if( (*p2&0xFE)==0 ) break;
118724 fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118737 fts3ColumnlistCopy(0, &p2);
118738 assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
118739 if( 0==*p1 || 0==*p2 ) break;
118743 p2++;
118744 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118747 /* Advance pointer p1 or p2 (whichever corresponds to the smaller of
118758 fts3ColumnlistCopy(0, &p2);
118759 if( 0==*p2 ) break;
118760 p2++;
118761 p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118765 fts3PoslistCopy(0, &p2);
118768 *pp2 = p2;
118801 char *p2 = *pp2;
118811 *pp2 = p2;
118942 char *p2 = a2;
118984 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118985 while( p1 || p2 ){
118988 if( p2 && p1 && iDiff==0 ){
118990 fts3PoslistMerge(&p, &p1, &p2);
118992 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118993 }else if( !p2 || (p1 && iDiff<0) ){
118999 fts3PoslistCopy(&p, &p2);
119000 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
119034 char *p2 = aRight;
119043 fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
119045 while( p1 && p2 ){
119053 if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
119059 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
119064 fts3PoslistCopy(0, &p2);
119065 fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
120454 char *p2 = aOut;
120457 fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2);
120482 char *p2;
120487 p2 = pPhrase->doclist.pList;
120491 p2 = aPoslist;
120502 if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){
121094 char *p2;
121100 p2 = pOut = pPhrase->doclist.pList;
121102 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
124775 const sqlite3_tokenizer_module *p2;
124783 rc = queryTokenizer(db, "simple", &p2);
124785 assert( p1==p2 );
124786 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124788 assert( p2==0 );
124794 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124796 assert( p2==p1 );
131603 ** Store the union of cells p1 and p2 in p1.
131605 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131609 p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f);
131610 p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f);
131614 p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i);
131615 p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i);
131621 ** Return true if the area covered by p2 is a subset of the area covered
131624 static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131629 RtreeCoord *a2 = &p2->aCoord[ii];
