Lines Matching defs:p5
16442 u16 p5; /* Fifth parameter is an unsigned 16-bit integer */
16587 #define OP_IsType 18 /* jump, synopsis: if typeof(P1.P3) in P5 goto P2 */
16730 #define OP_AggInverse 161 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */
16731 #define OP_AggStep 162 /* synopsis: accum=r[P3] step(r[P2@P5]) */
16732 #define OP_AggStep1 163 /* synopsis: accum=r[P3] step(r[P2@P5]) */
16876 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u16 P5);
18912 ** TK_COLUMN: the value of p5 for OP_Column
19880 ** Bitfield flags for P5 value in various opcodes.
19892 /* Also used in P2 (not P5) of OP_Delete */
35913 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
35946 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
36858 /* 18 */ "IsType" OpHelp("if typeof(P1.P3) in P5 goto P2"),
37001 /* 161 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"),
37002 /* 162 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
37003 /* 163 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"),
84657 pOp->p5 = 0;
84706 pOp->p5 = 0;
84934 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
84937 sqlite3VdbeChangeP5(p, p5);
85526 pOut->p5 = 0;
85637 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
85656 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){
85658 if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5;
85669 pOp->p5 |= OPFLAG_TYPEOFARG;
86074 return pOp->p5;
86471 zP4 ? zP4 : "", pOp->p5,
86690 if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break;
86809 sqlite3VdbeMemSetInt64(pMem+6, pOp->p5);
89720 if( pOp->p5 & NC_IsCheck ){
89722 }else if( pOp->p5 & NC_GenCol ){
91301 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", /* EXPLAIN */
92768 ** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5.
93632 /* In debugging mode, when the p5 flags is set on an OP_Goto, that
93635 if( pOp->p5 ){
93805 /* Opcode: HaltIfNull P1 P2 P3 P4 P5
93811 ** The P5 parameter should be 1.
93823 /* Opcode: Halt P1 P2 * P4 P5
93838 ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
93846 ** If P5 is not zero and P4 is NULL, then everything after the ":" is
93888 assert( pOp->p5<=4 );
93890 if( pOp->p5 ){
93893 testcase( pOp->p5==1 );
93894 testcase( pOp->p5==2 );
93895 testcase( pOp->p5==3 );
93896 testcase( pOp->p5==4 );
93897 sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
93999 /* Opcode: String P1 P2 P3 P4 P5
94004 ** If P3 is not zero and the content of register P3 is equal to P5, then
94009 ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
94024 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
94195 /* Opcode: Copy P1 P2 P3 * P5
94200 ** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the
94201 ** destination. The 0x0001 bit of P5 indicates that this Copy opcode cannot
94219 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
94732 /* Opcode: Eq P1 P2 P3 P4 P5
94738 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
94756 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
94760 ** the SQLITE_NULLEQ flag were omitted from P5.
94765 /* Opcode: Ne P1 P2 P3 P4 P5
94772 /* Opcode: Lt P1 P2 P3 P4 P5
94778 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
94782 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
94803 /* Opcode: Le P1 P2 P3 P4 P5
94810 /* Opcode: Gt P1 P2 P3 P4 P5
94817 /* Opcode: Ge P1 P2 P3 P4 P5
94843 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
94850 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
94857 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
94863 VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
94868 if( pOp->p5 & SQLITE_NULLEQ ){
94874 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
94875 testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
94889 if( pOp->p5 & SQLITE_JUMPIFNULL ){
94899 affinity = pOp->p5 & SQLITE_AFF_MASK;
94958 VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95002 ** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5.
95011 assert( pOp[1].p5 & OPFLAG_PERMUTE );
95015 /* Opcode: Compare P1 P2 P3 P4 P5
95022 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
95048 if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
95309 /* Opcode: IsType P1 P2 P3 P4 P5
95310 ** Synopsis: if typeof(P1.P3) in P5 goto P2
95313 ** by the P5 bitmask.
95325 ** P5 is a bitmask of data types. SQLITE_INTEGER is the least significant
95337 ** P5 bitmask.
95395 VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2);
95396 if( typeMask & pOp->p5 ){
95493 /* Opcode: Column P1 P2 P3 P4 P5
95508 ** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed
95759 u8 p5;
95763 if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
95764 && (p5==OPFLAG_TYPEOFARG
95765 || (t>=12 && ((t&1)==0 || p5==OPFLAG_BYTELENARG))
95977 ** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM
95980 ** * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index
95983 ** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value
96056 ** at least one field. If P5>0 then it will be one more than the
96058 if( pOp->p5 ){
96059 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
96104 assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
96580 /* Opcode: Transaction P1 P2 P3 P4 P5
96604 ** If P5!=0 then this opcode also checks the schema cookie against P3
96676 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
96678 && pOp->p5
96747 /* Opcode: SetCookie P1 P2 P3 * P5
96758 ** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement
96759 ** has P5 set to 1, so that the internal schema version will be different
96777 *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5;
96794 /* Opcode: OpenRead P1 P2 P3 P4 P5
96805 ** Allowed P5 bits:
96822 /* Opcode: ReopenIdx P1 P2 P3 P4 P5
96830 ** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
96835 ** Allowed P5 bits:
96844 /* Opcode: OpenWrite P1 P2 P3 P4 P5
96849 ** OPFLAG_P2ISREG bit is set in P5 - see below).
96859 ** Allowed P5 bits:
96888 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
96902 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
96923 wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
96931 if( pOp->p5 & OPFLAG_P2ISREG ){
96977 testcase( pOp->p5 & OPFLAG_BULKCSR );
96980 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
97022 /* Opcode: OpenEphemeral P1 P2 P3 P4 P5
97038 ** The P5 parameter can be a mask of the BTREE_* flags defined
97091 BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
97104 BTREE_BLOBKEY | pOp->p5);
97120 pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
97205 assert( pOp->p5==0 );
97532 /* Opcode: SeekScan P1 P2 * * P5
97542 ** the P1, P2 and P5 operands of this opcode are also used, and are called
97543 ** This.P1, This.P2 and This.P5.
97565 ** The This.P5 parameter is a flag that indicates what to do if the
97567 ** row. If This.P5 is false (0) then a jump is made to SeekGE.P2. If
97568 ** This.P5 is true (non-zero) then a jump is made to This.P2. The P5==0
97570 ** the IN constraint. The jump to SeekGE.P2 ends the loop. The P5!=0 case
97597 ** jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0.
97608 /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the
97613 if( pOp->p5==0 ){
97660 if( res>0 && pOp->p5==0 ){
98217 /* Opcode: Insert P1 P2 P3 P4 P5
98226 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
98227 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
98231 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
98271 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
98286 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
98295 if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
98303 if( pOp->p5 & OPFLAG_ISNOOP ) break;
98306 assert( (pOp->p5 & OPFLAG_LASTROWID)==0 || (pOp->p5 & OPFLAG_NCHANGE)!=0 );
98307 if( pOp->p5 & OPFLAG_NCHANGE ){
98309 if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
98314 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
98323 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
98336 (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
98360 assert( pOp[1].p5 & OPFLAG_PREFORMAT );
98369 /* Opcode: Delete P1 P2 P3 P4 P5
98373 ** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
98378 ** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
98381 ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
98387 ** If the OPFLAG_NCHANGE (0x01) flag of P2 (NB: P2 not P5) is set, then
98390 ** If the OPFLAG_ISNOOP (0x40) flag of P2 (not P5!) is set, then the
98427 && pOp->p5==0
98430 /* If p5 is zero, the seek operation that positioned the cursor prior to
98440 ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
98448 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
98474 assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
98481 && (pOp->p5 & OPFLAG_AUXDELETE)==0
98492 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
98874 assert( pOp->p5==0 );
98903 /* Opcode: Next P1 P2 P3 * P5
98922 ** If P5 is positive and the jump is taken, then event counter
98923 ** number P5-1 in the prepared statement is incremented.
98927 /* Opcode: Prev P1 P2 P3 * P5
98947 ** If P5 is positive and the jump is taken, then event counter
98948 ** number P5-1 in the prepared statement is incremented.
98950 /* Opcode: SorterNext P1 P2 * * P5
98967 assert( pOp->p5==0
98968 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
98969 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
98982 assert( pOp->p5==0
98983 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
98984 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
99000 p->aCounter[pOp->p5]++;
99012 /* Opcode: IdxInsert P1 P2 P3 P4 P5
99024 ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
99027 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
99031 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
99050 assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
99051 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
99061 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
99062 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
99095 /* Opcode: IdxDelete P1 P2 P3 * P5
99102 ** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error
99107 ** entry is found. For those cases, P5 is zero. Also, do not raise
99134 }else if( pOp->p5 && !sqlite3WritableSchema(db) ){
99591 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
99695 /* Opcode: IntegrityCk P1 P2 P3 P4 P5
99709 ** If P5 is not zero, the check is done on the auxiliary database
99731 assert( pOp->p5<db->nDb );
99732 assert( DbMaskTest(p->btreeMask, pOp->p5) );
99733 rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
99854 /* Opcode: Program P1 P2 P3 P4 P5
99867 ** If P5 is non-zero, then recursive program invocation is enabled.
99883 /* If the p5 flag is clear, then recursive invocation of triggers is
99884 ** disabled for backwards compatibility (p5 is set if this sub-program
99894 if( pOp->p5 ){
100191 /* Opcode: AggStep * P2 P3 P4 P5
100192 ** Synopsis: accum=r[P3] step(r[P2@P5])
100195 ** The function has P5 arguments. P4 is a pointer to the
100199 ** The P5 arguments are taken from register P2 and its
100202 /* Opcode: AggInverse * P2 P3 P4 P5
100203 ** Synopsis: accum=r[P3] inverse(r[P2@P5])
100206 ** The function has P5 arguments. P4 is a pointer to the
100210 ** The P5 arguments are taken from register P2 and its
100213 /* Opcode: AggStep1 P1 P2 P3 P4 P5
100214 ** Synopsis: accum=r[P3] step(r[P2@P5])
100217 ** aggregate. The function has P5 arguments. P4 is a pointer to the
100221 ** The P5 arguments are taken from register P2 and its
100236 n = pOp->p5;
100913 /* Opcode: VColumn P1 P2 P3 * P5
100920 ** an unchanging column during an UPDATE operation, then the P5
100923 ** table implementation. The P5 column might also contain other
100953 assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
100954 if( pOp->p5 & OPFLAG_NOCHNG ){
101054 /* Opcode: VUpdate P1 P2 P3 P4 P5
101078 ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
101090 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
101091 || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
101114 db->vtabOnConflict = pOp->p5;
101123 if( pOp->p5==OE_Ignore ){
101126 p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
101529 /* Opcode: ReleaseReg P1 P2 P3 * P5
101544 ** If P5 is set, then all released registers have their type set
101548 ** P5 ought to be set on every call to this opcode.
101570 if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
105099 "p5 INT,"
105300 case 6: /* p5 */
105301 sqlite3_result_int(ctx, pOp->p5);
108783 ** Return the P5 value that should be used for a binary comparison
108789 int jumpIfNull /* Extra flags added to P5 */
108857 int p5;
108867 p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
108870 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
109077 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
109078 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
109079 ** otherwise: op==pExpr->op and p5==0
109086 u8 p5 /* SQLITE_NULLEQ or zero */
109113 assert( p5==0 || pExpr->op!=op );
109114 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
109133 codeCompare(pParse, pL, pR, opx, r1, r2, addrDone, p5, isCommuted);
109147 if( p5==SQLITE_NULLEQ ){
112493 u8 p5 /* P5 value for OP_Column + FLAGS */
112496 assert( (p5 & (OPFLAG_NOCHNG|OPFLAG_TYPEOFARG|OPFLAG_LENGTHARG))==p5 );
112497 assert( IsVirtual(pTab) || (p5 & OPFLAG_NOCHNG)==0 );
112499 if( p5 ){
112501 if( pOp->opcode==OP_Column ) pOp->p5 = p5;
112502 if( pOp->opcode==OP_VColumn ) pOp->p5 = (p5 & OPFLAG_NOCHNG);
112566 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
112809 int p5 = 0;
113035 p5 = SQLITE_NULLEQ;
113045 codeVectorCompare(pParse, pExpr, target, op, p5);
113051 sqlite3VdbeCurrentAddr(v)+2, p5,
113059 if( p5==SQLITE_NULLEQ ){
113237 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
113821 && pOp->p5==0 /* The do-not-merge flag must be clear */
115521 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
115525 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
115526 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
127710 u8 p5 = 0;
127722 if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;
127723 sqlite3VdbeChangeP5(v, p5);
132639 aOp[3].p5 = SQLITE_JUMPIFNULL;
132704 aOp[3].p5 = OPFLAG_APPEND;
133540 ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
134571 sqlite3VdbeChangeP5(v, x.p5);
134642 ** Change the P5 operand on the last opcode (which should be an OP_MakeRecord)
134645 ** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
134789 u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
134802 assert( op==OP_OpenWrite || p5==0 );
134829 p5 = 0;
134834 sqlite3VdbeChangeP5(v, p5);
140024 aOp[1].p5 = 1;
143092 ** case set the p5 parameter of the OP_MakeRecord to OPFLAG_NOCHNG_MAGIC.
151894 /* Set the P5 operand of the OP_Program instruction to non-zero if
155626 u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */
157056 ** set P3 and P5 on the OP_String opcode so that the string will be cast
157083 pOp->p5 = (u8)(pLevel->iLikeRepCntr&1); /* ASC or DESC */
157843 assert( pLevel->p5==0 );
158252 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
158254 assert( pLevel->p5==0 );
158611 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
161510 pOp->p5 = 2; /* Cause the MEM_Subtype flag to be cleared */
167581 sqlite3VdbeChangeP5(v, pLevel->p5);
254428 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
254461 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
Indexes created Mon Mar 02 05:31:46 UTC 2026