Lines Matching refs:P1
7370 #define OPFLG_IN1 0x0004 /* in1: P1 is an input */
7411 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
8529 ** and as the P1 argument to the OP_Savepoint instruction.
47334 int p1, /* The P1 operand */
47351 int p1, /* The P1 operand */
47481 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
47482 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
47649 ** Change the value of the P1 operand for a specific instruction.
48313 pMem->u.i = pOp->p1; /* P1 */
51656 ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
52354 int p1; /* P1 value of the opcode */
52401 int p1; /* Value of P1 operand */
52871 /* Opcode: Gosub P1 P2 * * *
52873 ** Write the current address onto register P1
52886 /* Opcode: Return P1 * * * *
52888 ** Jump to the next instruction after the address in register P1.
52897 /* Opcode: Yield P1 * * * *
52899 ** Swap the program counter with the value in register P1.
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 *
52932 ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
52934 ** For errors, it can be some other value. If P1!=0 then P2 will determine
52985 /* Opcode: Integer P1 P2 * * *
52987 ** The 32-bit integer value P1 is written into register P2.
53051 /* Opcode: String P1 P2 * P4 *
53053 ** The string value P4 of length P1 (bytes) is stored in register P2.
53075 /* Opcode: Blob P1 P2 * P4
53077 ** P4 points to a blob of data P1 bytes long. Store this
53092 /* Opcode: Variable P1 P2 P3 P4 *
53094 ** Transfer the values of bound parameters P1..P1+P3-1 into registers
53129 /* Opcode: Move P1 P2 P3 * *
53131 ** Move the values in register P1..P1+P3-1 over into
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
53209 ** structure to provide access to the top P1 values as the result
53273 /* Opcode: Concat P1 P2 P3 * *
53275 ** Add the text in register P1 onto the end of the text in
53277 ** If either the P1 or P2 text are NULL then store NULL in P3.
53279 ** P3 = P2 || P1
53281 ** It is illegal for P1 and P3 to be the same register. Sometimes,
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
53345 ** register P1 is zero, then the result is NULL. If either input is
53348 /* Opcode: Remainder P1 P2 P3 * *
53351 ** register P1 by the value in register P2 and store the result in P3.
53458 /* Opcode: Function P1 P2 P3 P4 P5
53465 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
53467 ** argument was constant then bit 0 of P1 is set. This is used to determine
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 * *
53587 ** number of bits specified by the integer in regiser P1.
53591 /* Opcode: ShiftRight P1 P2 P3 * *
53594 ** number of bits specified by the integer in register P1.
53628 /* Opcode: AddImm P1 P2 * * *
53630 ** Add the constant P2 to the value in register P1.
53642 /* Opcode: MustBeInt P1 P2 * * *
53644 ** Force the value in register P1 to be an integer. If the value
53645 ** in P1 is not an integer and cannot be converted into an integer
53665 /* Opcode: RealAffinity P1 * * * *
53667 ** If register P1 holds an integer convert it to a real value.
53683 /* Opcode: ToText P1 * * * *
53685 ** Force the value in register P1 to be text.
53705 /* Opcode: ToBlob P1 * * * *
53707 ** Force the value in register P1 to be a BLOB.
53728 /* Opcode: ToNumeric P1 * * * *
53730 ** Force the value in register P1 to be numeric (either an
53747 /* Opcode: ToInt P1 * * * *
53749 ** Force the value in register P1 be an integer. If
53765 /* Opcode: ToReal P1 * * * *
53767 ** Force the value in register P1 to be a floating point number.
53783 /* Opcode: Lt P1 P2 P3 P4 P5
53785 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
53788 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
53797 ** back into the input registers P1 and P3. So this opcode can cause
53798 ** persistent changes to registers P1 and P3.
53813 /* Opcode: Ne P1 P2 P3 P4 P5
53816 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
53825 /* Opcode: Eq P1 P2 P3 P4 P5
53828 ** the operands in registers P1 and P3 are equal.
53837 /* Opcode: Le P1 P2 P3 P4 P5
53841 ** register P1. See the Lt opcode for additional information.
53843 /* Opcode: Gt P1 P2 P3 P4 P5
53847 ** register P1. See the Lt opcode for additional information.
53849 /* Opcode: Ge P1 P2 P3 P4 P5
53853 ** register P1. See the Lt opcode for additional information.
53941 /* Opcode: Compare P1 P2 P3 P4 *
53943 ** Compare to vectors of registers in reg(P1)..reg(P1+P3-1) (all this
54001 /* Opcode: Jump P1 P2 P3 * *
54003 ** Jump to the instruction at address P1, P2, or P3 depending on whether
54004 ** in the most recent OP_Compare instruction the P1 vector was less than
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 * * *
54074 ** Interpret the value in register P1 as a boolean value. Store the
54075 ** boolean complement in register P2. If the value in register P1 is
54089 /* Opcode: BitNot P1 P2 * * *
54091 ** Interpret the content of register P1 as an integer. Store the
54092 ** ones-complement of the P1 value into register P2. If P1 holds
54106 /* Opcode: If P1 P2 P3 * *
54108 ** Jump to P2 if the value in register P1 is true. The value is
54110 ** in P1 is NULL then take the jump if P3 is true.
54112 /* Opcode: IfNot P1 P2 P3 * *
54114 ** Jump to P2 if the value in register P1 is False. The value is
54116 ** in P1 is NULL then take the jump if P3 is true.
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
54166 ** Interpret the data that cursor P1 points to as a structure built using
54178 ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
54187 int p1; /* P1 value of the opcode */
54464 /* Opcode: Affinity P1 P2 * P4 *
54466 ** Apply affinities to a range of P2 registers starting with P1.
54491 /* Opcode: MakeRecord P1 P2 P3 P4 *
54493 ** Convert P2 registers beginning with P1 into a single entry
54535 ** Data(0) is taken from register P1. Data(1) comes from register P1+1
54625 /* Opcode: Count P1 P2 * * *
54628 ** opened by cursor P1 in register P2
54648 /* Opcode: Savepoint P1 * * P4 *
54651 ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
54652 ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
54656 int p1; /* Value of P1 operand */
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 * * *
54878 ** P1 is the index of the database file on which the transaction is
54943 /* Opcode: ReadCookie P1 P2 P3 * *
54945 ** Read cookie number P3 from database P1 and write it into register P2.
54947 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
54948 ** the main database file and P1==1 is the database file used to store
54974 /* Opcode: SetCookie P1 P2 P3 * *
54977 ** into cookie number P2 of database P1. P2==1 is the schema version.
54979 ** size, and so forth. P1==0 is the main database file and P1==1 is the
55014 /* Opcode: VerifyCookie P1 P2 *
55018 ** P1 is the database number which is 0 for the main database file
55069 /* Opcode: OpenRead P1 P2 P3 P4 P5
55075 ** database. Give the new cursor an identifier of P1. The P1
55076 ** values need not be contiguous but all P1 values should be small integers.
55077 ** It is an error for P1 to be negative.
55099 /* Opcode: OpenWrite P1 P2 P3 P4 P5
55101 ** Open a read/write cursor named P1 on the table or index whose root
55201 /* Opcode: OpenEphemeral P1 P2 * P4 *
55203 ** Open a new cursor P1 to a transient table.
55266 /* Opcode: OpenPseudo P1 P2 P3 * *
55270 ** register P2. In other words, cursor P1 becomes an alias for the
55296 /* Opcode: Close P1 * * * *
55298 ** Close a cursor previously opened as P1. If P1 is not
55308 /* Opcode: SeekGe P1 P2 P3 P4 *
55310 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
55311 ** use the value in register P3 as the key. If cursor P1 refers
55315 ** Reposition cursor P1 so that it points to the smallest entry that
55321 /* Opcode: SeekGt P1 P2 P3 P4 *
55323 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
55324 ** use the value in register P3 as a key. If cursor P1 refers
55328 ** Reposition cursor P1 so that it points to the smallest entry that
55334 /* Opcode: SeekLt P1 P2 P3 P4 *
55336 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
55337 ** use the value in register P3 as a key. If cursor P1 refers
55341 ** Reposition cursor P1 so that it points to the largest entry that
55347 /* Opcode: SeekLe P1 P2 P3 P4 *
55349 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
55350 ** use the value in register P3 as a key. If cursor P1 refers
55354 ** Reposition cursor P1 so that it points to the largest entry that
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 *
55545 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
55546 ** is a prefix of any entry in P1 then a jump is made to P2 and
55547 ** P1 is left pointing at the matching entry.
55549 /* Opcode: NotFound P1 P2 P3 P4 *
55555 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
55556 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
55558 ** falls through to the next instruction and P1 is left pointing at the
55622 /* Opcode: IsUnique P1 P2 P3 P4 *
55624 ** Cursor P1 is open on an index b-tree - that is to say, a btree which
55631 ** that make up an unpacked index key that can be used with cursor P1.
55639 ** Otherwise, this instruction checks if cursor P1 contains an entry
55661 /* Assert that the values of parameters P1 and P4 are in range. */
55708 /* Opcode: NotExists P1 P2 P3 * *
55711 ** with that key does not exist in table of P1, then jump to P2.
55716 ** operation assumes the key is an integer and that P1 is a table whereas
55718 ** P1 is an index.
55763 /* Opcode: Sequence P1 P2 * * *
55765 ** Find the next available sequence number for cursor P1.
55778 /* Opcode: NewRowid P1 P2 P3 * *
55782 ** table that cursor P1 points to. The new record number is written
55921 /* Opcode: Insert P1 P2 P3 P4 P5
55923 ** Write an entry into the table of cursor P1. A new entry is
55951 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
55960 /* Opcode: InsertInt P1 P2 P3 P4 P5
56033 /* Opcode: Delete P1 P2 * P4 *
56035 ** Delete the record at which the P1 cursor is currently pointing.
56045 ** P1 must not be pseudo-table. It has to be a real table with
56048 ** If P4 is not NULL, then it is the name of the table that P1 is
56050 ** If P4 is not NULL then the P1 cursor must have been positioned
56112 /* Opcode: RowData P1 P2 * * *
56114 ** Write into register P2 the complete row data for cursor P1.
56119 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
56122 /* Opcode: RowKey P1 P2 * * *
56124 ** Write into register P2 the complete row key for cursor P1.
56129 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
56194 /* Opcode: Rowid P1 P2 * * *
56197 ** P1 is currently point to.
56199 ** P1 can be either an ordinary table or a virtual table. There used to
56247 /* Opcode: NullRow P1 * * * *
56249 ** Move the cursor P1 to a null row. Any OP_Column operations
56269 /* Opcode: Last P1 P2 * * *
56271 ** The next use of the Rowid or Column or Next instruction for P1
56304 /* Opcode: Sort P1 P2 * * *
56324 /* Opcode: Rewind P1 P2 * * *
56326 ** The next use of the Rowid or Column or Next instruction for P1
56359 /* Opcode: Next P1 P2 * * *
56361 ** Advance cursor P1 so that it points to the next key/data pair in its
56366 ** The P1 cursor must be for a real table, not a pseudo-table.
56370 /* Opcode: Prev P1 P2 * * *
56372 ** Back up cursor P1 so that it points to the previous key/data pair in its
56377 ** The P1 cursor must be for a real table, not a pseudo-table.
56415 /* Opcode: IdxInsert P1 P2 P3 * P5
56419 ** into the index P1. Data for the entry is nil.
56457 /* Opcode: IdxDelete P1 P2 P3 * *
56461 ** index opened by cursor P1.
56492 /* Opcode: IdxRowid P1 P2 * * *
56495 ** the end of the index key pointed to by cursor P1. This integer should be
56529 /* Opcode: IdxGE P1 P2 P3 P4 P5
56533 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
56535 ** If the P1 index entry is greater than or equal to the key value
56543 /* Opcode: IdxLT P1 P2 P3 * P5
56547 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
56549 ** If the P1 index entry is less than the key value then jump to P2.
56592 /* Opcode: Destroy P1 P2 P3 * *
56595 ** file is given by P1.
56650 /* Opcode: Clear P1 P2 P3
56653 ** in the database file is given by P1. But, unlike Destroy, do not
56687 /* Opcode: CreateTable P1 P2 * * *
56689 ** Allocate a new table in the main database file if P1==0 or in the
56690 ** auxiliary database file if P1==1 or in an attached database if
56691 ** P1>1. Write the root page number of the new table into
56700 /* Opcode: CreateIndex P1 P2 * * *
56702 ** Allocate a new index in the main database file if P1==0 or in the
56703 ** auxiliary database file if P1==1 or in an attached database if
56704 ** P1>1. Write the root page number of the new table into
56733 /* Opcode: ParseSchema P1 P2 * P4 *
56735 ** Read and parse all entries from the SQLITE_MASTER table of database P1
56810 /* Opcode: LoadAnalysis P1 * * * *
56812 ** Read the sqlite_stat1 table for database P1 and load the content
56823 /* Opcode: DropTable P1 * * P4 *
56826 ** the table named P4 in database P1. This is called after a table
56835 /* Opcode: DropIndex P1 * * P4 *
56838 ** the index named P4 in database P1. This is called after an index
56847 /* Opcode: DropTrigger P1 * * P4 *
56850 ** the trigger named P4 in database P1. This is called after a trigger
56861 /* Opcode: IntegrityCk P1 P2 P3 * P5
56864 ** register P1 the text of an error message describing any problems.
56865 ** If no problems are found, store a NULL in register P1.
56869 ** In other words, the analysis stops as soon as reg(P1) errors are
56870 ** seen. Reg(P1) is updated with the number of errors remaining.
56873 ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
56924 /* Opcode: RowSetAdd P1 P2 * * *
56927 ** held in register P1.
56943 /* Opcode: RowSetRead P1 P2 P3 * *
56945 ** Extract the smallest value from boolean index P1 and put that value into
56946 ** register P3. Or, if boolean index P1 is initially empty, leave P3
56968 /* Opcode: RowSetTest P1 P2 P3 P4
56970 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
57002 /* If there is anything other than a rowset object in memory cell P1,
57003 ** delete it now and initialize P1 with an empty rowset
57030 /* Opcode: Program P1 P2 P3 P4 *
57034 ** P1 contains the address of the memory cell that contains the first memory
57145 /* Opcode: Param P1 P2 * * *
57154 ** the value of the P1 argument to the value of the P1 argument to the
57171 /* Opcode: FkCounter P1 P2 * * *
57174 ** If P1 is non-zero, the database constraint counter is incremented
57175 ** (deferred foreign key constraints). Otherwise, if P1 is zero, the
57187 /* Opcode: FkIfZero P1 P2 * * *
57193 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
57194 ** is zero (the one that counts deferred constraint violations). If P1 is
57209 /* Opcode: MemMax P1 P2 * * *
57211 ** P1 is a register in the root frame of this VM (the root frame is
57213 ** within a sub-program). Set the value of register P1 to the maximum of
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 * *
57274 ** The register P1 must contain an integer. Add literal P3 to the
57275 ** value in register P1. If the result is exactly 0, jump to P2.
57345 /* Opcode: AggFinal P1 P2 * P4 *
57347 ** Execute the finalizer function for an aggregate. P1 is
57393 /* Opcode: IncrVacuum P1 P2 * * *
57396 ** the P1 database. If the vacuum has finished, jump to instruction
57416 /* Opcode: Expire P1 * * * *
57422 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
57435 /* Opcode: TableLock P1 P2 P3 P4 *
57440 ** P1 is the index of the database in sqlite3.aDb[] of the database
57492 /* Opcode: VCreate P1 * * P4 *
57494 ** P4 is the name of a virtual table in database P1. Call the xCreate method
57504 /* Opcode: VDestroy P1 * * P4 *
57506 ** P4 is the name of a virtual table in database P1. Call the xDestroy method
57518 /* Opcode: VOpen P1 * * P4 *
57521 ** P1 is a cursor number. This opcode opens a cursor to the virtual
57522 ** table and stores that cursor in P1.
57562 /* Opcode: VFilter P1 P2 P3 P4 *
57564 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
57572 ** by P1. The integer query plan parameter to xFilter is stored in register
57641 /* Opcode: VColumn P1 P2 P3 * *
57645 ** P1 cursor is pointing to into register P3.
57705 /* Opcode: VNext P1 P2 * * *
57707 ** Advance virtual table P1 to the next row in its result set and
57756 /* Opcode: VRename P1 * * P4 *
57760 ** in register P1 is passed as the zName argument to the xRename method.
57785 /* Opcode: VUpdate P1 P2 P3 P4 *
57804 ** P1 is a boolean flag. If it is set to true and the xUpdate call
57848 /* Opcode: Pagecount P1 P2 * * *
57850 ** Write the current number of pages in database P1 to memory cell P2.
65764 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this