Lines Matching refs:P2
7368 #define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */
7371 #define OPFLG_IN2 0x0008 /* in2: P2 is an input */
7373 #define OPFLG_OUT2 0x0020 /* out2: P2 is an output */
7412 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
8643 #define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */
9470 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
9471 ** the number of columns in P2 can be computed at the same time
47335 int p2, /* The P2 operand */
47352 int p2, /* The P2 operand */
47364 ** label can be used as the P2 value of an operation. Later, when
47366 ** through its operation list and change all values of P2 which match
47369 ** The VDBE knows that a P2 value is a label because labels are
47370 ** always negative and P2 values are suppose to be non-negative.
47371 ** Hence, a negative P2 value is a label that has yet to be resolved.
47481 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
47482 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
47486 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
47527 ** Loop through the program looking for P2 values that are negative
47529 ** label by setting the P2 value to its correct non-zero value.
47533 ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
47663 ** Change the value of the P2 operand for a specific instruction.
47698 ** Change the P2 operand of instruction addr so that it points to
48318 pMem->u.i = pOp->p2; /* P2 */
51656 ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
52858 /* Opcode: Goto * P2 * * *
52860 ** An unconditional jump to address P2.
52862 ** the one at index P2 from the beginning of
52871 /* Opcode: Gosub P1 P2 * * *
52874 ** and then jump to address P2.
52915 /* Opcode: HaltIfNull P1 P2 P3 P4 *
52918 ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
52927 /* Opcode: Halt P1 P2 * P4 *
52934 ** For errors, it can be some other value. If P1!=0 then P2 will determine
52936 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
52985 /* Opcode: Integer P1 P2 * * *
52987 ** The 32-bit integer value P1 is written into register P2.
52994 /* Opcode: Int64 * P2 * P4 *
52997 ** Write that value into register P2.
53005 /* Opcode: Real * P2 * P4 *
53008 ** Write that value into register P2.
53017 /* Opcode: String8 * P2 * P4 *
53051 /* Opcode: String P1 P2 * P4 *
53053 ** The string value P4 of length P1 (bytes) is stored in register P2.
53065 /* Opcode: Null * P2 * * *
53067 ** Write a NULL into register P2.
53075 /* Opcode: Blob P1 P2 * P4
53078 ** blob in register P2. This instruction is not coded directly
53092 /* Opcode: Variable P1 P2 P3 P4 *
53095 ** P2..P2+P3-1.
53129 /* Opcode: Move P1 P2 P3 * *
53132 ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
53134 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
53166 /* Opcode: Copy P1 P2 * * *
53168 ** Make a copy of register P1 into register P2.
53183 /* Opcode: SCopy P1 P2 * * *
53185 ** Make a shallow copy of register P1 into register P2.
53204 /* Opcode: ResultRow P1 P2 * * *
53206 ** The registers P1 through P1+P2-1 contain a single row of
53273 /* Opcode: Concat P1 P2 P3 * *
53276 ** register P2 and store the result in register P3.
53277 ** If either the P1 or P2 text are NULL then store NULL in P3.
53279 ** P3 = P2 || P1
53282 ** if P3 is the same register as P2, the implementation is able
53322 /* Opcode: Add P1 P2 P3 * *
53324 ** Add the value in register P1 to the value in register P2
53328 /* Opcode: Multiply P1 P2 P3 * *
53331 ** Multiply the value in register P1 by the value in register P2
53335 /* Opcode: Subtract P1 P2 P3 * *
53337 ** Subtract the value in register P1 from the value in register P2
53341 /* Opcode: Divide P1 P2 P3 * *
53343 ** Divide the value in register P1 by the value in register P2
53344 ** and store the result in register P3 (P3=P2/P1). If the value in
53348 /* Opcode: Remainder P1 P2 P3 * *
53351 ** register P1 by the value in register P2 and store the result in P3.
53352 ** If the value in register P2 is zero the result is NULL.
53458 /* Opcode: Function P1 P2 P3 P4 P5
53461 ** defines the function) with P5 arguments taken from register P2 and
53572 /* Opcode: BitAnd P1 P2 P3 * *
53574 ** Take the bit-wise AND of the values in register P1 and P2 and
53578 /* Opcode: BitOr P1 P2 P3 * *
53580 ** Take the bit-wise OR of the values in register P1 and P2 and
53584 /* Opcode: ShiftLeft P1 P2 P3 * *
53586 ** Shift the integer value in register P2 to the left by the
53591 /* Opcode: ShiftRight P1 P2 P3 * *
53593 ** Shift the integer value in register P2 to the right by the
53628 /* Opcode: AddImm P1 P2 * * *
53630 ** Add the constant P2 to the value in register P1.
53642 /* Opcode: MustBeInt P1 P2 * * *
53646 ** without data loss, then jump immediately to P2, or if P2==0
53783 /* Opcode: Lt P1 P2 P3 P4 P5
53786 ** jump to address P2.
53811 ** store a boolean result (either 0, or 1, or NULL) in register P2.
53813 /* Opcode: Ne P1 P2 P3 P4 P5
53825 /* Opcode: Eq P1 P2 P3 P4 P5
53837 /* Opcode: Le P1 P2 P3 P4 P5
53843 /* Opcode: Gt P1 P2 P3 P4 P5
53849 /* Opcode: Ge P1 P2 P3 P4 P5
53941 /* Opcode: Compare P1 P2 P3 P4 *
53944 ** one "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
54001 /* Opcode: Jump P1 P2 P3 * *
54003 ** Jump to the instruction at address P1, P2, or P3 depending on whether
54005 ** equal to, or greater than the P2 vector, respectively.
54018 /* Opcode: And P1 P2 P3 * *
54020 ** Take the logical AND of the values in registers P1 and P2 and
54023 ** If either P1 or P2 is 0 (false) then the result is 0 even if
54027 /* Opcode: Or P1 P2 P3 * *
54029 ** Take the logical OR of the values in register P1 and P2 and
54032 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
54072 /* Opcode: Not P1 P2 * * *
54075 ** boolean complement in register P2. If the value in register P1 is
54076 ** NULL, then a NULL is stored in P2.
54089 /* Opcode: BitNot P1 P2 * * *
54092 ** ones-complement of the P1 value into register P2. If P1 holds
54093 ** a NULL then store a NULL in P2.
54106 /* Opcode: If P1 P2 P3 * *
54108 ** Jump to P2 if the value in register P1 is true. The value is
54112 /* Opcode: IfNot P1 P2 P3 * *
54114 ** Jump to P2 if the value in register P1 is False. The value is
54140 /* Opcode: IsNull P1 P2 * * *
54142 ** Jump to P2 if the value in register P1 is NULL.
54152 /* Opcode: NotNull P1 P2 * * *
54154 ** Jump to P2 if the value in register P1 is not NULL.
54164 /* Opcode: Column P1 P2 P3 P4 P5
54168 ** information about the format of the data.) Extract the P2-th column
54169 ** from this record. If there are less that (P2+1)
54174 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
54464 /* Opcode: Affinity P1 P2 * P4 *
54466 ** Apply affinities to a range of P2 registers starting with P1.
54468 ** P4 is a string that is P2 characters long. The nth character of the
54491 /* Opcode: MakeRecord P1 P2 P3 P4 *
54493 ** Convert P2 registers beginning with P1 into a single entry
54500 ** P4 may be a string that is P2 characters long. The nth character of the
54625 /* Opcode: Count P1 P2 * * *
54628 ** opened by cursor P1 in register P2
54799 /* Opcode: AutoCommit P1 P2 * * *
54801 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
54872 /* Opcode: Transaction P1 P2 * * *
54883 ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
54888 ** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
54901 ** If P2 is zero, then a read-lock is obtained on the database file.
54943 /* Opcode: ReadCookie P1 P2 P3 * *
54945 ** Read cookie number P3 from database P1 and write it into register P2.
54974 /* Opcode: SetCookie P1 P2 P3 * *
54977 ** into cookie number P2 of database P1. P2==1 is the schema version.
54978 ** P2==2 is the database format. P2==3 is the recommended pager cache
55014 /* Opcode: VerifyCookie P1 P2 *
55017 ** schema version) and make sure it is equal to P2.
55069 /* Opcode: OpenRead P1 P2 P3 P4 P5
55072 ** P2 in a database file. The database file is determined by P3.
55079 ** If P5!=0 then use the content of register P2 as the root page, not
55080 ** the value of P2 itself.
55099 /* Opcode: OpenWrite P1 P2 P3 P4 P5
55102 ** page is P2. Or if P5!=0 use the content of register P2 to find the
55201 /* Opcode: OpenEphemeral P1 P2 * P4 *
55208 ** P2 is the number of columns in the virtual table.
55266 /* Opcode: OpenPseudo P1 P2 P3 * *
55270 ** register P2. In other words, cursor P1 becomes an alias for the
55271 ** MEM_Blob content contained in register P2.
55308 /* Opcode: SeekGe P1 P2 P3 P4 *
55317 ** greater than or equal to the key and P2 is not zero, then jump to P2.
55321 /* Opcode: SeekGt P1 P2 P3 P4 *
55330 ** the key and P2 is not zero, then jump to P2.
55334 /* Opcode: SeekLt P1 P2 P3 P4 *
55343 ** the key and P2 is not zero, then jump to P2.
55347 /* Opcode: SeekLe P1 P2 P3 P4 *
55356 ** less than or equal to the key and P2 is not zero, then jump to P2.
55398 ** then the seek is not possible, so jump to P2 */
55510 /* Opcode: Seek P1 P2 * * *
55512 ** P1 is an open table cursor and P2 is a rowid integer. Arrange
55513 ** for P1 to move so that it points to the rowid given by P2.
55539 /* Opcode: Found P1 P2 P3 P4 *
55546 ** is a prefix of any entry in P1 then a jump is made to P2 and
55549 /* Opcode: NotFound P1 P2 P3 P4 *
55556 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
55622 /* Opcode: IsUnique P1 P2 P3 P4 *
55637 ** value, jump immediately to P2.
55642 ** to instruction P2. Otherwise, the rowid of the conflicting index
55696 ** to P2. Otherwise, copy the rowid of the conflicting record to
55708 /* Opcode: NotExists P1 P2 P3 * *
55711 ** with that key does not exist in table of P1, then jump to P2.
55763 /* Opcode: Sequence P1 P2 * * *
55766 ** Write the sequence number into register P2.
55778 /* Opcode: NewRowid P1 P2 P3 * *
55783 ** written to register P2.
55921 /* Opcode: Insert P1 P2 P3 P4 P5
55926 ** number P2. The key is stored in register P3. The key must
55951 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
55952 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
55953 ** and register P2 becomes ephemeral. If the cursor is changed, the
55954 ** value of register P2 will then change. Make sure this does not
55960 /* Opcode: InsertInt P1 P2 P3 P4 P5
56033 /* Opcode: Delete P1 P2 * P4 *
56042 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
56112 /* Opcode: RowData P1 P2 * * *
56114 ** Write into register P2 the complete row data for cursor P1.
56116 ** It is just copied onto the P2 register exactly as
56122 /* Opcode: RowKey P1 P2 * * *
56124 ** Write into register P2 the complete row key for cursor P1.
56194 /* Opcode: Rowid P1 P2 * * *
56196 ** Store in register P2 an integer which is the key of the table entry that
56269 /* Opcode: Last P1 P2 * * *
56273 ** If the table or index is empty and P2>0, then jump immediately to P2.
56274 ** If P2 is 0 or if the table or index is not empty, fall through
56304 /* Opcode: Sort P1 P2 * * *
56324 /* Opcode: Rewind P1 P2 * * *
56328 ** If the table or index is empty and P2>0, then jump immediately to P2.
56329 ** If P2 is 0 or if the table or index is not empty, fall through
56359 /* Opcode: Next P1 P2 * * *
56364 ** jump immediately to P2.
56370 /* Opcode: Prev P1 P2 * * *
56375 ** jump immediately to P2.
56415 /* Opcode: IdxInsert P1 P2 P3 * P5
56417 ** Register P2 holds a SQL index key made using the
56457 /* Opcode: IdxDelete P1 P2 P3 * *
56459 ** The content of P3 registers starting at register P2 form
56492 /* Opcode: IdxRowid P1 P2 * * *
56494 ** Write into register P2 an integer which is the last entry in the record at
56529 /* Opcode: IdxGE P1 P2 P3 P4 P5
56536 ** then jump to P2. Otherwise fall through to the next instruction.
56543 /* Opcode: IdxLT P1 P2 P3 * P5
56549 ** If the P1 index entry is less than the key value then jump to P2.
56592 /* Opcode: Destroy P1 P2 P3 * *
56605 ** is stored in register P2. If no page
56607 ** the last one in the database) then a zero is stored in register P2.
56608 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
56650 /* Opcode: Clear P1 P2 P3
56656 ** The table being clear is in the main database file if P2==0. If
56657 ** P2==1 then the table to be clear is in the auxiliary database file
56687 /* Opcode: CreateTable P1 P2 * * *
56692 ** register P2
56700 /* Opcode: CreateIndex P1 P2 * * *
56705 ** register P2.
56733 /* Opcode: ParseSchema P1 P2 * P4 *
56736 ** that match the WHERE clause P4. P2 is the "force" flag. Always do
56737 ** the parsing if P2 is true. If P2 is false, then this routine is a
56738 ** no-op if the schema is not currently loaded. In other words, if P2
56861 /* Opcode: IntegrityCk P1 P2 P3 * P5
56873 ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
56924 /* Opcode: RowSetAdd P1 P2 * * *
56926 ** Insert the integer value held by register P2 into a boolean index
56929 ** An assertion fails if P2 is not an integer.
56943 /* Opcode: RowSetRead P1 P2 P3 * *
56947 ** unchanged and jump to instruction P2.
56968 /* Opcode: RowSetTest P1 P2 P3 P4
56972 ** the value held in P3, jump to register P2. Otherwise, insert the
57030 /* Opcode: Program P1 P2 P3 P4 *
57035 ** cell in an array of values used as arguments to the sub-program. P2
57145 /* Opcode: Param P1 P2 * * *
57149 ** cell of the calling (parent) frame to cell P2 in the current frames
57171 /* Opcode: FkCounter P1 P2 * * *
57173 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
57187 /* Opcode: FkIfZero P1 P2 * * *
57190 ** If so, jump to instruction P2. Otherwise, fall through to the next
57209 /* Opcode: MemMax P1 P2 * * *
57214 ** its current value and the value in register P2.
57240 /* Opcode: IfPos P1 P2 * * *
57242 ** If the value of register P1 is 1 or greater, jump to P2.
57256 /* Opcode: IfNeg P1 P2 * * *
57258 ** If the value of register P1 is less than zero, jump to P2.
57272 /* Opcode: IfZero P1 P2 P3 * *
57275 ** value in register P1. If the result is exactly 0, jump to P2.
57290 /* Opcode: AggStep * P2 P3 P4 P5
57297 ** The P5 arguments are taken from register P2 and its
57345 /* Opcode: AggFinal P1 P2 * P4 *
57350 ** P2 is the number of arguments that the step function takes and
57351 ** P4 is a pointer to the FuncDef for this function. The P2
57393 /* Opcode: IncrVacuum P1 P2 * * *
57397 ** P2. Otherwise, fall through to the next instruction.
57435 /* Opcode: TableLock P1 P2 P3 P4 *
57444 ** P2 contains the root-page of the table to lock.
57562 /* Opcode: VFilter P1 P2 P3 P4 *
57564 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
57578 ** A jump is made to P2 if the result set after filtering would be empty.
57641 /* Opcode: VColumn P1 P2 P3 * *
57643 ** Store the value of the P2-th column of
57705 /* Opcode: VNext P1 P2 * * *
57708 ** jump to instruction P2. Or, if the virtual table has reached
57748 /* If there is data, jump to P2 */
57785 /* Opcode: VUpdate P1 P2 P3 P4 *
57788 ** This opcode invokes the corresponding xUpdate method. P2 values
57790 ** invocation. The value in register (P3+P2-1) corresponds to the
57801 ** If P2==1 then no insert is performed. argv[0] is the rowid of
57848 /* Opcode: Pagecount P1 P2 * * *
57850 ** Write the current number of pages in database P1 to memory cell P2.
58228 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
69655 ** starts the transactions will be coded and the OP_Goto P2 value