Lines Matching refs:P3
15714 #define OP_VFilter 9 /* jump, synopsis: iplan=r[P3] zplan='P4' */
15715 #define OP_VUpdate 10 /* synopsis: data=r[P3@P2] */
15726 #define OP_IfNullRow 21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */
15727 #define OP_SeekLT 22 /* jump, synopsis: key=r[P3@P4] */
15728 #define OP_SeekLE 23 /* jump, synopsis: key=r[P3@P4] */
15729 #define OP_SeekGE 24 /* jump, synopsis: key=r[P3@P4] */
15730 #define OP_SeekGT 25 /* jump, synopsis: key=r[P3@P4] */
15732 #define OP_IfNoHope 27 /* jump, synopsis: key=r[P3@P4] */
15733 #define OP_NoConflict 28 /* jump, synopsis: key=r[P3@P4] */
15734 #define OP_NotFound 29 /* jump, synopsis: key=r[P3@P4] */
15735 #define OP_Found 30 /* jump, synopsis: key=r[P3@P4] */
15736 #define OP_SeekRowid 31 /* jump, synopsis: intkey=r[P3] */
15737 #define OP_NotExists 32 /* jump, synopsis: intkey=r[P3] */
15743 #define OP_IdxLE 38 /* jump, synopsis: key=r[P3@P4] */
15744 #define OP_IdxGT 39 /* jump, synopsis: key=r[P3@P4] */
15745 #define OP_IdxLT 40 /* jump, synopsis: key=r[P3@P4] */
15746 #define OP_IdxGE 41 /* jump, synopsis: key=r[P3@P4] */
15747 #define OP_RowSetRead 42 /* jump, synopsis: r[P3]=rowset(P1) */
15748 #define OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */
15749 #define OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */
15750 #define OP_RowSetTest 45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */
15753 #define OP_IfPos 48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
15757 #define OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */
15758 #define OP_Eq 53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */
15759 #define OP_Gt 54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */
15760 #define OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */
15761 #define OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */
15762 #define OP_Ge 57 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */
15768 #define OP_PureFunc 63 /* synopsis: r[P3]=func(r[P2@NP]) */
15769 #define OP_Function 64 /* synopsis: r[P3]=func(r[P2@NP]) */
15772 #define OP_HaltIfNull 67 /* synopsis: if r[P3]=null halt */
15777 #define OP_Null 72 /* synopsis: r[P2..P3]=NULL */
15781 #define OP_Move 76 /* synopsis: r[P2@P3]=r[P1@P3] */
15782 #define OP_Copy 77 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */
15792 #define OP_Compare 87 /* synopsis: r[P1@P3] <-> r[P2@P3] */
15793 #define OP_IsTrue 88 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */
15794 #define OP_Offset 89 /* synopsis: r[P3] = sqlite_offset(P1) */
15795 #define OP_Column 90 /* synopsis: r[P3]=PX */
15797 #define OP_MakeRecord 92 /* synopsis: r[P3]=mkrec(r[P1@P2]) */
15801 #define OP_ReopenIdx 96 /* synopsis: root=P2 iDb=P3 */
15802 #define OP_OpenRead 97 /* synopsis: root=P2 iDb=P3 */
15803 #define OP_OpenWrite 98 /* synopsis: root=P2 iDb=P3 */
15807 #define OP_BitAnd 102 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
15808 #define OP_BitOr 103 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
15809 #define OP_ShiftLeft 104 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
15810 #define OP_ShiftRight 105 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
15811 #define OP_Add 106 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
15812 #define OP_Subtract 107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
15813 #define OP_Multiply 108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
15814 #define OP_Divide 109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
15815 #define OP_Remainder 110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
15816 #define OP_Concat 111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
15820 #define OP_OpenPseudo 115 /* synopsis: P3 columns in r[P2] */
15825 #define OP_SeekHit 120 /* synopsis: set P2<=seekHit<=P3 */
15828 #define OP_Insert 123 /* synopsis: intkey=r[P3] data=r[P2] */
15832 #define OP_SorterCompare 127 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
15840 #define OP_IdxDelete 135 /* synopsis: key=r[P2@P3] */
15841 #define OP_DeferredSeek 136 /* synopsis: Move P3 to P1.rowid if needed */
15847 #define OP_CreateBtree 142 /* synopsis: r[P2]=root iDb=P1 flags=P3 */
15860 #define OP_OffsetLimit 155 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
15861 #define OP_AggInverse 156 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */
15862 #define OP_AggStep 157 /* synopsis: accum=r[P3] step(r[P2@P5]) */
15863 #define OP_AggStep1 158 /* synopsis: accum=r[P3] step(r[P2@P5]) */
15864 #define OP_AggValue 159 /* synopsis: r[P3]=value N=P2 */
15869 #define OP_TableLock 164 /* synopsis: iDb=P1 root=P2 write=P3 */
15874 #define OP_VColumn 169 /* synopsis: r[P3]=vcolumn(P2) */
15880 #define OP_ReleaseReg 175 /* synopsis: release r[P1@P2] mask P3 */
15892 #define OPFLG_IN3 0x08 /* in3: P3 is an input */
15894 #define OPFLG_OUT3 0x20 /* out3: P3 is an output */
15990 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
33487 /* 9 */ "VFilter" OpHelp("iplan=r[P3] zplan='P4'"),
33488 /* 10 */ "VUpdate" OpHelp("data=r[P3@P2]"),
33499 /* 21 */ "IfNullRow" OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"),
33500 /* 22 */ "SeekLT" OpHelp("key=r[P3@P4]"),
33501 /* 23 */ "SeekLE" OpHelp("key=r[P3@P4]"),
33502 /* 24 */ "SeekGE" OpHelp("key=r[P3@P4]"),
33503 /* 25 */ "SeekGT" OpHelp("key=r[P3@P4]"),
33505 /* 27 */ "IfNoHope" OpHelp("key=r[P3@P4]"),
33506 /* 28 */ "NoConflict" OpHelp("key=r[P3@P4]"),
33507 /* 29 */ "NotFound" OpHelp("key=r[P3@P4]"),
33508 /* 30 */ "Found" OpHelp("key=r[P3@P4]"),
33509 /* 31 */ "SeekRowid" OpHelp("intkey=r[P3]"),
33510 /* 32 */ "NotExists" OpHelp("intkey=r[P3]"),
33516 /* 38 */ "IdxLE" OpHelp("key=r[P3@P4]"),
33517 /* 39 */ "IdxGT" OpHelp("key=r[P3@P4]"),
33518 /* 40 */ "IdxLT" OpHelp("key=r[P3@P4]"),
33519 /* 41 */ "IdxGE" OpHelp("key=r[P3@P4]"),
33520 /* 42 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"),
33521 /* 43 */ "Or" OpHelp("r[P3]=(r[P1] || r[P2])"),
33522 /* 44 */ "And" OpHelp("r[P3]=(r[P1] && r[P2])"),
33523 /* 45 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"),
33526 /* 48 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
33530 /* 52 */ "Ne" OpHelp("IF r[P3]!=r[P1]"),
33531 /* 53 */ "Eq" OpHelp("IF r[P3]==r[P1]"),
33532 /* 54 */ "Gt" OpHelp("IF r[P3]>r[P1]"),
33533 /* 55 */ "Le" OpHelp("IF r[P3]<=r[P1]"),
33534 /* 56 */ "Lt" OpHelp("IF r[P3]<r[P1]"),
33535 /* 57 */ "Ge" OpHelp("IF r[P3]>=r[P1]"),
33541 /* 63 */ "PureFunc" OpHelp("r[P3]=func(r[P2@NP])"),
33542 /* 64 */ "Function" OpHelp("r[P3]=func(r[P2@NP])"),
33545 /* 67 */ "HaltIfNull" OpHelp("if r[P3]=null halt"),
33550 /* 72 */ "Null" OpHelp("r[P2..P3]=NULL"),
33554 /* 76 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"),
33555 /* 77 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
33565 /* 87 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
33566 /* 88 */ "IsTrue" OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"),
33567 /* 89 */ "Offset" OpHelp("r[P3] = sqlite_offset(P1)"),
33568 /* 90 */ "Column" OpHelp("r[P3]=PX"),
33570 /* 92 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"),
33574 /* 96 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
33575 /* 97 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
33576 /* 98 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
33580 /* 102 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"),
33581 /* 103 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"),
33582 /* 104 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<<r[P1]"),
33583 /* 105 */ "ShiftRight" OpHelp("r[P3]=r[P2]>>r[P1]"),
33584 /* 106 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"),
33585 /* 107 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"),
33586 /* 108 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"),
33587 /* 109 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"),
33588 /* 110 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"),
33589 /* 111 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"),
33593 /* 115 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"),
33598 /* 120 */ "SeekHit" OpHelp("set P2<=seekHit<=P3"),
33601 /* 123 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"),
33605 /* 127 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
33613 /* 135 */ "IdxDelete" OpHelp("key=r[P2@P3]"),
33614 /* 136 */ "DeferredSeek" OpHelp("Move P3 to P1.rowid if needed"),
33620 /* 142 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"),
33633 /* 155 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
33634 /* 156 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"),
33635 /* 157 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
33636 /* 158 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"),
33637 /* 159 */ "AggValue" OpHelp("r[P3]=value N=P2"),
33642 /* 164 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
33647 /* 169 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"),
33653 /* 175 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"),
78710 int p3, /* The P3 operand */
78771 int p3, /* The P3 operand */
78867 int p3, /* The P3 operand */
79420 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
79911 if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
86914 /* Opcode: InitCoroutine P1 P2 P3 * *
86917 ** located at address P3.
86983 /* Opcode: HaltIfNull P1 P2 P3 P4 P5
86984 ** Synopsis: if r[P3]=null halt
86986 ** Check the value in register P3. If it is NULL then Halt using
86988 ** value in register P3 is not NULL, then this routine is a no-op.
87172 /* Opcode: String P1 P2 P3 P4 P5
87177 ** If P3 is not zero and the content of register P3 is equal to P5, then
87182 ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
87203 /* Opcode: Null P1 P2 P3 * *
87204 ** Synopsis: r[P2..P3]=NULL
87206 ** Write a NULL into registers P2. If P3 greater than P2, then also write
87207 ** NULL into register P3 and every register in between P2 and P3. If P3
87208 ** is less than P2 (typically P3 is zero) then only register P2 is
87293 /* Opcode: Move P1 P2 P3 * *
87294 ** Synopsis: r[P2@P3]=r[P1@P3]
87296 ** Move the P3 values in register P1..P1+P3-1 over into
87297 ** registers P2..P2+P3-1. Registers P1..P1+P3-1 are
87299 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error
87300 ** for P3 to be less than 1.
87339 /* Opcode: Copy P1 P2 P3 * *
87340 ** Synopsis: r[P2@P3+1]=r[P1@P3+1]
87342 ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
87484 /* Opcode: Concat P1 P2 P3 * *
87485 ** Synopsis: r[P3]=r[P2]+r[P1]
87488 ** register P2 and store the result in register P3.
87489 ** If either the P1 or P2 text are NULL then store NULL in P3.
87491 ** P3 = P2 || P1
87493 ** It is illegal for P1 and P3 to be the same register. Sometimes,
87494 ** if P3 is the same register as P2, the implementation is able
87555 /* Opcode: Add P1 P2 P3 * *
87556 ** Synopsis: r[P3]=r[P1]+r[P2]
87559 ** and store the result in register P3.
87562 /* Opcode: Multiply P1 P2 P3 * *
87563 ** Synopsis: r[P3]=r[P1]*r[P2]
87567 ** and store the result in register P3.
87570 /* Opcode: Subtract P1 P2 P3 * *
87571 ** Synopsis: r[P3]=r[P2]-r[P1]
87574 ** and store the result in register P3.
87577 /* Opcode: Divide P1 P2 P3 * *
87578 ** Synopsis: r[P3]=r[P2]/r[P1]
87581 ** and store the result in register P3 (P3=P2/P1). If the value in
87585 /* Opcode: Remainder P1 P2 P3 * *
87586 ** Synopsis: r[P3]=r[P2]%r[P1]
87589 ** register P1 and store the result in register P3.
87700 /* Opcode: BitAnd P1 P2 P3 * *
87701 ** Synopsis: r[P3]=r[P1]&r[P2]
87704 ** store the result in register P3.
87707 /* Opcode: BitOr P1 P2 P3 * *
87708 ** Synopsis: r[P3]=r[P1]|r[P2]
87711 ** store the result in register P3.
87714 /* Opcode: ShiftLeft P1 P2 P3 * *
87715 ** Synopsis: r[P3]=r[P2]<<r[P1]
87719 ** Store the result in register P3.
87722 /* Opcode: ShiftRight P1 P2 P3 * *
87723 ** Synopsis: r[P3]=r[P2]>>r[P1]
87727 ** Store the result in register P3.
87881 /* Opcode: Eq P1 P2 P3 P4 P5
87882 ** Synopsis: IF r[P3]==r[P1]
87884 ** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then
87893 ** back into the input registers P1 and P3. So this opcode can cause
87894 ** persistent changes to registers P1 and P3.
87916 /* Opcode: Ne P1 P2 P3 P4 P5
87917 ** Synopsis: IF r[P3]!=r[P1]
87920 ** the operands in registers P1 and P3 are not equal. See the Eq opcode for
87927 /* Opcode: Lt P1 P2 P3 P4 P5
87928 ** Synopsis: IF r[P3]<r[P1]
87930 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
87935 ** reg(P3) is NULL then the take the jump. If the SQLITE_JUMPIFNULL
87943 ** back into the input registers P1 and P3. So this opcode can cause
87944 ** persistent changes to registers P1 and P3.
87956 /* Opcode: Le P1 P2 P3 P4 P5
87957 ** Synopsis: IF r[P3]<=r[P1]
87960 ** the content of register P3 is less than or equal to the content of
87963 /* Opcode: Gt P1 P2 P3 P4 P5
87964 ** Synopsis: IF r[P3]>r[P1]
87967 ** the content of register P3 is greater than the content of
87970 /* Opcode: Ge P1 P2 P3 P4 P5
87971 ** Synopsis: IF r[P3]>=r[P1]
87974 ** the content of register P3 is greater than or equal to the content of
88074 ** less than, equal to, or greater than reg[P3], respectively. Compute
88183 /* Opcode: Compare P1 P2 P3 P4 P5
88184 ** Synopsis: r[P1@P3] <-> r[P2@P3]
88186 ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
88187 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
88263 /* Opcode: Jump P1 P2 P3 * *
88265 ** Jump to the instruction at address P1, P2, or P3 depending on whether
88280 /* Opcode: And P1 P2 P3 * *
88281 ** Synopsis: r[P3]=(r[P1] && r[P2])
88284 ** write the result into register P3.
88290 /* Opcode: Or P1 P2 P3 * *
88291 ** Synopsis: r[P3]=(r[P1] || r[P2])
88294 ** store the answer in register P3.
88324 /* Opcode: IsTrue P1 P2 P3 P4 *
88325 ** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4
88332 ** NULL, then the P3 is stored in register P2. Invert the answer if P4
88338 ** <li> If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE
88339 ** <li> If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE
88340 ** <li> If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE
88341 ** <li> If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE
88427 /* Opcode: If P1 P2 P3 * *
88431 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
88441 /* Opcode: IfNot P1 P2 P3 * *
88445 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
88483 /* Opcode: IfNullRow P1 P2 P3 * *
88484 ** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2
88487 ** If it is, then set register P3 to NULL and jump immediately to P2.
88502 /* Opcode: Offset P1 P2 P3 * *
88503 ** Synopsis: r[P3] = sqlite_offset(P1)
88505 ** Store in register r[P3] the byte offset into the database file that is the
88511 ** code generator. The P1, P2, and P3 operands to this opcode are the
88531 /* Opcode: Column P1 P2 P3 P4 P5
88532 ** Synopsis: r[P3]=PX
88540 ** The value extracted is stored in register P3.
88866 /* Opcode: MakeRecord P1 P2 P3 P4 *
88867 ** Synopsis: r[P3]=mkrec(r[P1@P2])
89167 ** If P3==0, then an exact count is obtained, which involves visiting
89168 ** every btree page of the table. But if P3 is non-zero, an estimate
89438 /* Opcode: Transaction P1 P2 P3 P4 P5
89462 ** If P5!=0 then this opcode also checks the schema cookie against P3
89467 ** cookie in P3 differs from the schema cookie in the database header or
89559 /* Opcode: ReadCookie P1 P2 P3 * *
89561 ** Read cookie number P3 from database P1 and write it into register P2.
89562 ** P3==1 is the schema version. P3==2 is the database format.
89563 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
89590 /* Opcode: SetCookie P1 P2 P3 * P5
89592 ** Write the integer value P3 into cookie number P2 of database P1.
89601 ** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement
89636 /* Opcode: OpenRead P1 P2 P3 P4 P5
89637 ** Synopsis: root=P2 iDb=P3
89640 ** P2 in a database file. The database file is determined by P3.
89641 ** P3==0 means the main database, P3==1 means the database used for
89642 ** temporary tables, and P3>1 means used the corresponding attached
89664 /* Opcode: ReopenIdx P1 P2 P3 P4 P5
89665 ** Synopsis: root=P2 iDb=P3
89673 ** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must
89686 /* Opcode: OpenWrite P1 P2 P3 P4 P5
89687 ** Synopsis: root=P2 iDb=P3
89861 /* Opcode: OpenEphemeral P1 P2 P3 P4 P5
89882 ** If P3 is positive, then reg[P3] is modified slightly so that it
89908 /* Make register reg[P3] into a value that can be used as the data
89970 /* Opcode: SorterOpen P1 P2 P3 P4 *
89976 ** If argument P3 is non-zero, then it indicates that the sorter may
89977 ** assume that a stable sort considering the first P3 fields of each
90013 /* Opcode: OpenPseudo P1 P2 P3 * *
90014 ** Synopsis: P3 columns in r[P2]
90026 ** P3 is the number of fields in the records that will be stored by
90080 /* Opcode: SeekGE P1 P2 P3 P4 *
90081 ** Synopsis: key=r[P3@P4]
90084 ** use the value in register P3 as the key. If cursor P1 refers
90085 ** to an SQL index, then P3 is the first in an array of P4 registers
90107 /* Opcode: SeekGT P1 P2 P3 P4 *
90108 ** Synopsis: key=r[P3@P4]
90111 ** use the value in register P3 as a key. If cursor P1 refers
90112 ** to an SQL index, then P3 is the first in an array of P4 registers
90125 /* Opcode: SeekLT P1 P2 P3 P4 *
90126 ** Synopsis: key=r[P3@P4]
90129 ** use the value in register P3 as a key. If cursor P1 refers
90130 ** to an SQL index, then P3 is the first in an array of P4 registers
90143 /* Opcode: SeekLE P1 P2 P3 P4 *
90144 ** Synopsis: key=r[P3@P4]
90147 ** use the value in register P3 as a key. If cursor P1 refers
90148 ** to an SQL index, then P3 is the first in an array of P4 registers
90207 /* The input value in P3 might be of any type: integer, real, string,
90219 /* If the P3 value could not be converted into an integer without
90382 ** The SeekGE.P3 and SeekGE.P4 operands identify an unpacked key which
90504 /* Opcode: SeekHit P1 P2 P3 * *
90505 ** Synopsis: set P2<=seekHit<=P3
90508 ** so that it is no less than P2 and no greater than P3.
90546 /* Opcode: Found P1 P2 P3 P4 *
90547 ** Synopsis: key=r[P3@P4]
90549 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
90550 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
90553 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
90563 /* Opcode: NotFound P1 P2 P3 P4 *
90564 ** Synopsis: key=r[P3@P4]
90566 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
90567 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
90570 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
90572 ** does contain an entry whose prefix matches the P3/P4 record then control
90582 /* Opcode: IfNoHope P1 P2 P3 P4 *
90583 ** Synopsis: key=r[P3@P4]
90585 ** Register P3 is the first of P4 registers that form an unpacked
90595 ** a key P3:N that will match some record in the index. We want to know
90596 ** if it is possible for a record P3:P4 to match some record in the
90613 /* Opcode: NoConflict P1 P2 P3 P4 *
90614 ** Synopsis: key=r[P3@P4]
90616 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
90617 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
90620 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
90728 /* Opcode: SeekRowid P1 P2 P3 * *
90729 ** Synopsis: intkey=r[P3]
90732 ** keys). If register P3 does not contain an integer or if P1 does not
90733 ** contain a record with rowid P3 then jump immediately to P2.
90735 ** a record with rowid P3 then
90740 ** the P3 register must be guaranteed to contain an integer value. With this
90741 ** opcode, register P3 might not contain an integer.
90752 /* Opcode: NotExists P1 P2 P3 * *
90753 ** Synopsis: intkey=r[P3]
90756 ** keys). P3 is an integer rowid. If P1 does not contain a record with
90757 ** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an
90758 ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then
90763 ** P3 register to contain a non-integer value, in which case the jump is
90764 ** always taken. This opcode requires that P3 always contain an integer.
90854 /* Opcode: NewRowid P1 P2 P3 * *
90862 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
90865 ** an SQLITE_FULL error is generated. The P3 register is updated with the '
90866 ** generated record number. This P3 mechanism is used to help implement the
90934 /* Assert that P3 is a valid memory cell. */
90938 /* Assert that P3 is a valid memory cell. */
90942 /* Assert that P3 is a valid memory cell. */
90951 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
90991 /* Opcode: Insert P1 P2 P3 P4 P5
90992 ** Synopsis: intkey=r[P3] data=r[P2]
90997 ** number P2. The key is stored in register P3. The key must
91008 ** seeks on the cursor or if the most recent seek used a key equal to P3.
91111 /* Opcode: RowCell P1 P2 P3 * *
91116 ** tables, register P3 contains the rowid to use with the new record in
91117 ** P1. If they are opened on index tables, P3 is not used.
91138 /* Opcode: Delete P1 P2 P3 P4 P5
91169 ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
91285 /* Opcode: SorterCompare P1 P2 P3 P4
91286 ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
91289 ** record blob in register P3 against a prefix of the entry that
91291 ** of r[P3] and the sorter record are compared.
91293 ** If either P3 or the sorter contains a NULL in one of their significant
91318 /* Opcode: SorterData P1 P2 P3 * *
91322 ** Then clear the column header cache on cursor P3.
91327 ** parameter P3. Clearing the P3 column cache as part of this opcode saves
91344 /* Opcode: RowData P1 P2 P3 * *
91359 ** If P3!=0 then this opcode is allowed to make an ephemeral pointer
91363 ** position in order that they can write to the same table. If P3==0
91364 ** then a copy of the data is made into memory. P3!=0 is faster, but
91365 ** P3==0 is safer.
91367 ** If P3!=0 then the content of the P2 register is unsuitable for use
91544 /* Opcode: IfSmaller P1 P2 P3 * *
91547 ** estimate is less than approximately 2**(0.1*P3).
91647 /* Opcode: Next P1 P2 P3 P4 P5
91661 ** The P3 value is a hint to the btree implementation. If P3==1, that
91663 ** omitted if that index had been unique. P3 is usually 0. P3 is
91674 /* Opcode: Prev P1 P2 P3 P4 P5
91689 ** The P3 value is a hint to the btree implementation. If P3==1, that
91691 ** omitted if that index had been unique. P3 is usually 0. P3 is
91755 /* Opcode: IdxInsert P1 P2 P3 P4 P5
91763 ** key of reg(P2). In that case, P3 is the index of the first register
91838 /* Opcode: IdxDelete P1 P2 P3 * P5
91839 ** Synopsis: key=r[P2@P3]
91841 ** The content of P3 registers starting at register P2 form
91886 /* Opcode: DeferredSeek P1 * P3 P4 *
91887 ** Synopsis: Move P3 to P1.rowid if needed
91889 ** P1 is an open index cursor and P3 is a cursor on the corresponding
91890 ** table. This opcode does a deferred seek of the P3 table cursor
91898 ** one entry for each column in the P3 table. If array entry a(i)
91899 ** is non-zero, then reading column a(i)-1 from cursor P3 is
91901 ** from P1. This information is stored in P3 and used to redirect
91902 ** reads against P3 over to P1, thus possibly avoiding the need to
91903 ** seek and read cursor P3.
91988 /* Opcode: IdxGE P1 P2 P3 P4 *
91989 ** Synopsis: key=r[P3@P4]
91991 ** The P4 register values beginning with P3 form an unpacked index
91999 /* Opcode: IdxGT P1 P2 P3 P4 *
92000 ** Synopsis: key=r[P3@P4]
92002 ** The P4 register values beginning with P3 form an unpacked index
92010 /* Opcode: IdxLT P1 P2 P3 P4 *
92011 ** Synopsis: key=r[P3@P4]
92013 ** The P4 register values beginning with P3 form an unpacked index
92021 /* Opcode: IdxLE P1 P2 P3 P4 *
92022 ** Synopsis: key=r[P3@P4]
92024 ** The P4 register values beginning with P3 form an unpacked index
92106 /* Opcode: Destroy P1 P2 P3 * *
92111 ** The table being destroyed is in the main database file if P3==0. If
92112 ** P3==1 then the table to be clear is in the auxiliary database file
92166 /* Opcode: Clear P1 P2 P3
92176 ** If the P3 value is non-zero, then the table referred to must be an
92179 ** If P3 is greater than zero, then the value stored in register P3 is
92231 /* Opcode: CreateBtree P1 P2 P3 * *
92232 ** Synopsis: r[P2]=root iDb=P1 flags=P3
92236 ** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
92409 /* Opcode: IntegrityCk P1 P2 P3 P4 P5
92415 ** The register P3 contains one less than the maximum number of allowed errors.
92416 ** At most reg(P3) errors will be reported.
92484 /* Opcode: RowSetRead P1 P2 P3 * *
92485 ** Synopsis: r[P3]=rowset(P1)
92488 ** and put that value into register P3.
92489 ** Or, if RowSet object P1 is initially empty, leave P3
92512 /* Opcode: RowSetTest P1 P2 P3 P4
92513 ** Synopsis: if r[P3] in rowset(P1) goto P2
92515 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
92517 ** the value held in P3, jump to register P2. Otherwise, insert the
92518 ** integer in P3 into the RowSet and continue on to the
92528 ** the RowSet object for P3, as it is guaranteed not to contain it,
92567 /* Opcode: Program P1 P2 P3 P4 P5
92574 ** exception using the RAISE() function. Register P3 contains the address
92813 /* Opcode: IfPos P1 P2 P3 * *
92814 ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
92817 ** If the value of register P1 is 1 or greater, subtract P3 from the
92834 /* Opcode: OffsetLimit P1 P2 P3 * *
92835 ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
92838 ** LIMIT and OFFSET process. r[P1] holds the limit counter. r[P3]
92844 ** If r[P3] is zero or negative, that means there is no OFFSET
92850 ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
92910 /* Opcode: AggStep * P2 P3 P4 P5
92911 ** Synopsis: accum=r[P3] step(r[P2@P5])
92915 ** FuncDef structure that specifies the function. Register P3 is the
92921 /* Opcode: AggInverse * P2 P3 P4 P5
92922 ** Synopsis: accum=r[P3] inverse(r[P2@P5])
92926 ** FuncDef structure that specifies the function. Register P3 is the
92932 /* Opcode: AggStep1 P1 P2 P3 P4 P5
92933 ** Synopsis: accum=r[P3] step(r[P2@P5])
92937 ** FuncDef structure that specifies the function. Register P3 is the
93063 /* Opcode: AggValue * P2 P3 P4 *
93064 ** Synopsis: r[P3]=value N=P2
93066 ** Invoke the xValue() function and store the result in register P3.
93106 /* Opcode: Checkpoint P1 P2 P3 * *
93110 ** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns
93112 ** WAL after the checkpoint into mem[P3+1] and the number of pages
93114 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
93115 ** mem[P3+2] are initialized to -1.
93144 /* Opcode: JournalMode P1 P2 P3 * *
93146 ** Change the journal mode of database P1 to P3. P3 must be one of the
93349 /* Opcode: TableLock P1 P2 P3 P4 *
93350 ** Synopsis: iDb=P1 root=P2 write=P3
93356 ** on which the lock is acquired. A readlock is obtained if P3==0 or
93357 ** a write lock if P3==1.
93493 /* Opcode: VFilter P1 P2 P3 P4 *
93494 ** Synopsis: iplan=r[P3] zplan='P4'
93505 ** P3. Register P3+1 stores the argc parameter to be passed to the
93506 ** xFilter method. Registers P3+2..P3+1+argc are the argc
93508 ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
93558 /* Opcode: VColumn P1 P2 P3 * P5
93559 ** Synopsis: r[P3]=vcolumn(P2)
93561 ** Store in register P3 the value of the P2-th column of
93696 /* Opcode: VUpdate P1 P2 P3 P4 P5
93697 ** Synopsis: data=r[P3@P2]
93701 ** are contiguous memory cells starting at P3 to pass to the xUpdate
93702 ** invocation. The value in register (P3+P2-1) corresponds to the
93706 ** The argv[0] element (which corresponds to memory cell P3)
93793 /* Opcode: MaxPgcnt P1 P2 P3 * *
93795 ** Try to set the maximum page count for database P1 to the value in P3.
93797 ** do not change the maximum page count value if P3==0.
93817 /* Opcode: Function P1 P2 P3 P4 *
93818 ** Synopsis: r[P3]=func(r[P2@NP])
93825 ** in register P3. Register P3 must not be one of the function inputs.
93836 /* Opcode: PureFunc P1 P2 P3 P4 *
93837 ** Synopsis: r[P3]=func(r[P2@NP])
93844 ** in register P3. Register P3 must not be one of the function inputs.
93905 /* Copy the result of the function into register P3 */
93923 /* Opcode: Init P1 P2 P3 P4 *
93938 ** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT
94053 /* Opcode: ReleaseReg P1 P2 P3 * P5
94054 ** Synopsis: release r[P1@P2] mask P3
94060 ** except if bit ii of P3 set, then do not release register P1+ii.
94061 ** In other words, P3 is a mask of registers to preserve.
111789 pSchema->schema_cookie, /* P3 */
113718 ** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY
113754 /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
143386 u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */
144687 ** set P3 and P5 on the OP_String opcode so that the string will be cast
144946 ** the statement currently being coded is a SELECT, then P3 of OP_DeferredSeek
145286 int iReg; /* P3 Value for OP_VFilter */