Lines Matching refs:P3
7369 #define OPFLG_IN3 0x0010 /* in3: P3 is an input */
7371 #define OPFLG_OUT3 0x0040 /* out3: P3 is an output */
7410 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
47333 int p3, /* The P3 operand */
47350 int p3, /* The P3 operand */
47672 ** Change the value of the P3 operand for a specific instruction.
48321 pMem->u.i = pOp->p3; /* P3 */
51653 ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
52469 i64 R; /* Rowid stored in register P3 */
52912 /* Opcode: HaltIfNull P1 P2 P3 P4 *
52914 ** Check the value in register P3. If is is NULL then Halt using
52916 ** value in register P3 is not NULL, then this routine is a no-op.
53089 /* Opcode: Variable P1 P2 P3 P4 *
53091 ** Transfer the values of bound parameters P1..P1+P3-1 into registers
53092 ** P2..P2+P3-1.
53094 ** If the parameter is named, then its name appears in P4 and P3==1.
53126 /* Opcode: Move P1 P2 P3 * *
53128 ** Move the values in register P1..P1+P3-1 over into
53129 ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
53131 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
53270 /* Opcode: Concat P1 P2 P3 * *
53273 ** register P2 and store the result in register P3.
53274 ** If either the P1 or P2 text are NULL then store NULL in P3.
53276 ** P3 = P2 || P1
53278 ** It is illegal for P1 and P3 to be the same register. Sometimes,
53279 ** if P3 is the same register as P2, the implementation is able
53319 /* Opcode: Add P1 P2 P3 * *
53322 ** and store the result in register P3.
53325 /* Opcode: Multiply P1 P2 P3 * *
53329 ** and store the result in register P3.
53332 /* Opcode: Subtract P1 P2 P3 * *
53335 ** and store the result in register P3.
53338 /* Opcode: Divide P1 P2 P3 * *
53341 ** and store the result in register P3 (P3=P2/P1). If the value in
53345 /* Opcode: Remainder P1 P2 P3 * *
53348 ** register P1 by the value in register P2 and store the result in P3.
53455 /* Opcode: Function P1 P2 P3 P4 P5
53459 ** successors. The result of the function is stored in register P3.
53460 ** Register P3 must not be one of the function inputs.
53558 /* Copy the result of the function into register P3 */
53569 /* Opcode: BitAnd P1 P2 P3 * *
53572 ** store the result in register P3.
53575 /* Opcode: BitOr P1 P2 P3 * *
53578 ** store the result in register P3.
53581 /* Opcode: ShiftLeft P1 P2 P3 * *
53585 ** Store the result in register P3.
53588 /* Opcode: ShiftRight P1 P2 P3 * *
53592 ** Store the result in register P3.
53780 /* Opcode: Lt P1 P2 P3 P4 P5
53782 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
53786 ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
53794 ** back into the input registers P1 and P3. So this opcode can cause
53795 ** persistent changes to registers P1 and P3.
53810 /* Opcode: Ne P1 P2 P3 P4 P5
53813 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
53822 /* Opcode: Eq P1 P2 P3 P4 P5
53825 ** the operands in registers P1 and P3 are equal.
53834 /* Opcode: Le P1 P2 P3 P4 P5
53837 ** the content of register P3 is less than or equal to the content of
53840 /* Opcode: Gt P1 P2 P3 P4 P5
53843 ** the content of register P3 is greater than the content of
53846 /* Opcode: Ge P1 P2 P3 P4 P5
53849 ** the content of register P3 is greater than or equal to the content of
53938 /* Opcode: Compare P1 P2 P3 P4 *
53940 ** Compare to vectors of registers in reg(P1)..reg(P1+P3-1) (all this
53941 ** one "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
53998 /* Opcode: Jump P1 P2 P3 * *
54000 ** Jump to the instruction at address P1, P2, or P3 depending on whether
54015 /* Opcode: And P1 P2 P3 * *
54018 ** write the result into register P3.
54024 /* Opcode: Or P1 P2 P3 * *
54027 ** store the answer in register P3.
54103 /* Opcode: If P1 P2 P3 * *
54107 ** in P1 is NULL then take the jump if P3 is true.
54109 /* Opcode: IfNot P1 P2 P3 * *
54113 ** in P1 is NULL then take the jump if P3 is true.
54161 /* Opcode: Column P1 P2 P3 P4 P5
54169 ** The value extracted is stored in register P3.
54488 /* Opcode: MakeRecord P1 P2 P3 P4 *
54940 /* Opcode: ReadCookie P1 P2 P3 * *
54942 ** Read cookie number P3 from database P1 and write it into register P2.
54943 ** P3==1 is the schema version. P3==2 is the database format.
54944 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
54971 /* Opcode: SetCookie P1 P2 P3 * *
54973 ** Write the content of register P3 (interpreted as an integer)
55066 /* Opcode: OpenRead P1 P2 P3 P4 P5
55069 ** P2 in a database file. The database file is determined by P3.
55070 ** P3==0 means the main database, P3==1 means the database used for
55071 ** temporary tables, and P3>1 means used the corresponding attached
55096 /* Opcode: OpenWrite P1 P2 P3 P4 P5
55263 /* Opcode: OpenPseudo P1 P2 P3 * *
55275 ** P3 is the number of fields in the records that will be stored by
55305 /* Opcode: SeekGe P1 P2 P3 P4 *
55308 ** use the value in register P3 as the key. If cursor P1 refers
55309 ** to an SQL index, then P3 is the first in an array of P4 registers
55318 /* Opcode: SeekGt P1 P2 P3 P4 *
55321 ** use the value in register P3 as a key. If cursor P1 refers
55322 ** to an SQL index, then P3 is the first in an array of P4 registers
55331 /* Opcode: SeekLt P1 P2 P3 P4 *
55334 ** use the value in register P3 as a key. If cursor P1 refers
55335 ** to an SQL index, then P3 is the first in an array of P4 registers
55344 /* Opcode: SeekLe P1 P2 P3 P4 *
55347 ** use the value in register P3 as a key. If cursor P1 refers
55348 ** to an SQL index, then P3 is the first in an array of P4 registers
55382 /* The input value in P3 might be of any type: integer, real, string,
55390 /* If the P3 value could not be converted into an integer without
55394 /* If the P3 value cannot be converted into any kind of a number,
55399 /* If we reach this point, then the P3 value must be a floating
55404 /* The P3 value is too large in magnitude to be expressed as an
55536 /* Opcode: Found P1 P2 P3 P4 *
55538 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
55539 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
55542 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
55546 /* Opcode: NotFound P1 P2 P3 P4 *
55548 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
55549 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
55552 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
55554 ** does contain an entry whose prefix matches the P3/P4 record then control
55619 /* Opcode: IsUnique P1 P2 P3 P4 *
55626 ** The P3 register contains an integer record number. Call this record
55640 ** entry is copied to register P3 and control falls through to the next
55653 i64 R; /* Rowid stored in register P3 */
55688 /* Extract the value of u.bc.R from register P3. */
55694 ** register P3 and fall through to the next instruction. */
55705 /* Opcode: NotExists P1 P2 P3 * *
55707 ** Use the content of register P3 as a integer key. If a record
55775 /* Opcode: NewRowid P1 P2 P3 * *
55782 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
55785 ** a SQLITE_FULL error is generated. The P3 register is updated with the '
55786 ** generated record number. This P3 mechanism is used to help implement the
55856 /* Assert that P3 is a valid memory cell. */
55860 /* Assert that P3 is a valid memory cell. */
55864 /* Assert that P3 is a valid memory cell. */
55871 assert( (u.be.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
55918 /* Opcode: Insert P1 P2 P3 P4 P5
55923 ** number P2. The key is stored in register P3. The key must
55957 /* Opcode: InsertInt P1 P2 P3 P4 P5
55960 ** integer value P3, not the value of the integer stored in register P3.
56123 ** The key is copied onto the P3 register exactly as
56412 /* Opcode: IdxInsert P1 P2 P3 * P5
56418 ** P3 is a flag that provides a hint to the b-tree layer that this
56454 /* Opcode: IdxDelete P1 P2 P3 * *
56456 ** The content of P3 registers starting at register P2 form
56526 /* Opcode: IdxGE P1 P2 P3 P4 P5
56528 ** The P4 register values beginning with P3 form an unpacked index
56537 ** that if the key from register P3 is a prefix of the key in the cursor,
56540 /* Opcode: IdxLT P1 P2 P3 * P5
56542 ** The P4 register values beginning with P3 form an unpacked index
56589 /* Opcode: Destroy P1 P2 P3 * *
56594 ** The table being destroyed is in the main database file if P3==0. If
56595 ** P3==1 then the table to be clear is in the auxiliary database file
56647 /* Opcode: Clear P1 P2 P3
56657 ** If the P3 value is non-zero, then the table referred to must be an
56660 ** If P3 is greater than zero, then the value stored in register P3 is
56858 /* Opcode: IntegrityCk P1 P2 P3 * P5
56864 ** The register P3 contains the maximum number of allowed errors.
56865 ** At most reg(P3) errors will be reported.
56940 /* Opcode: RowSetRead P1 P2 P3 * *
56943 ** register P3. Or, if boolean index P1 is initially empty, leave P3
56965 /* Opcode: RowSetTest P1 P2 P3 P4
56967 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
56969 ** the value held in P3, jump to register P2. Otherwise, insert the
56970 ** integer in P3 into the RowSet and continue on to the
56981 ** the rowset object for P3, as it is guaranteed not to contain it,
57027 /* Opcode: Program P1 P2 P3 P4 *
57034 ** exception using the RAISE() function. Register P3 contains the address
57269 /* Opcode: IfZero P1 P2 P3 * *
57271 ** The register P1 must contain an integer. Add literal P3 to the
57287 /* Opcode: AggStep * P2 P3 P4 P5
57292 ** P3 as the accumulator.
57432 /* Opcode: TableLock P1 P2 P3 P4 *
57438 ** on which the lock is acquired. A readlock is obtained if P3==0 or
57439 ** a write lock if P3==1.
57559 /* Opcode: VFilter P1 P2 P3 P4 *
57570 ** P3. Register P3+1 stores the argc parameter to be passed to the
57571 ** xFilter method. Registers P3+2..P3+1+argc are the argc
57573 ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
57638 /* Opcode: VColumn P1 P2 P3 * *
57642 ** P1 cursor is pointing to into register P3.
57682 /* Copy the result of the function to the P3 register. We
57782 /* Opcode: VUpdate P1 P2 P3 P4 *
57786 ** are contiguous memory cells starting at P3 to pass to the xUpdate
57787 ** invocation. The value in register (P3+P2-1) corresponds to the
57791 ** The argv[0] element (which corresponds to memory cell P3)
89377 int iReg; /* P3 Value for OP_VFilter */