Lines Matching defs:value
210 ** value of 0 means that compiler is not being used. The
218 ** so the GCC_VERSION macro will be set to a correct non-zero value even
296 ** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include
437 ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
488 ** a pointer to a string constant whose value is the same as the
558 ** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the
561 ** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
942 ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
1129 ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
1199 ** current limit. Otherwise the limit is set to the larger of the value
1261 ** is not changed but instead the prior value of that setting is written
1367 ** The argument is a pointer to a value of type sqlite3_int64 that
1369 ** pointer is overwritten with the old value. The limit is not changed if
1370 ** the value originally pointed to is negative, and so the current limit
1392 ** writes the resulting value there.
1455 ** the value that M is to be set to. Before returning, the 32-bit signed
1456 ** integer is overwritten with the previous value of M.
1495 ** value of type (int). The integer value is set to 1 if the database is a wal
1613 ** is incremented. The iVersion value started out as 1 in
1617 ** may be appended to the sqlite3_vfs object and the iVersion value
1740 ** to prevent this by setting mxPathname to a sufficiently large value.
1746 ** of good-quality randomness into zOut. The return value is
1751 ** a floating point value.
1809 ** value will increment whenever this happens.
2035 ** xRealloc is always a value returned by a prior call to xRoundup.
2104 ** value of Single-thread and so [sqlite3_config()] will return
2314 ** disabled. The default value may be changed by compiling with the
2342 ** in three separate circumstances, identified by the value passed as the
2371 ** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
2391 ** [PRAGMA cache_size] setting and this value.
2402 ** threshold to a value such as 64KiB can greatly reduce the amount of
2404 ** The default value for this setting is controlled by the
2410 ** of type (int) - the new value of the sorter-reference size threshold.
2418 ** value for this option is to never use this optimization. Specifying a
2419 ** negative value for this option restores the default behaviour.
2496 ** when the "current value" returned by
2691 ** default value of this setting is determined by the [-DSQLITE_DQS]
2700 ** default value of this setting is determined by the [-DSQLITE_DQS]
2800 ** tables, the value returned by this function may be set explicitly by
2809 ** rowid value using [sqlite3_set_last_insert_rowid()] before returning
2814 ** running. Once the trigger program ends, the value returned
2818 ** successful [INSERT] and does not change the value returned by this
2820 ** and INSERT OR ABORT make no changes to the return value of this
2825 ** the return value of this interface.)^
2836 ** then the value returned by [sqlite3_last_insert_rowid()] is
2843 ** CAPI3REF: Set the Last Insert Rowid value.
2847 ** set the value returned by calling sqlite3_last_insert_rowid(D) to R
2859 ** The two functions are identical except for the type of the return value
2861 ** or DELETE is greater than the maximum value supported by type "int", then
2862 ** the return value of sqlite3_changes() is undefined. ^Executing any other
2863 ** type of SQL statement does not modify the value returned by these functions.
2870 ** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value
2881 ** <li> ^(Before entering a trigger program the value returned by
2883 ** has finished, the original value is restored.)^
2886 ** statement sets the value returned by sqlite3_changes()
2887 ** upon completion as normal. Of course, this value will not include
2889 ** value will be saved and restored after each sub-trigger has run.)^
2894 ** returns the value as set when the calling statement began executing.
2896 ** program, the value returned reflects the number of rows modified by the
2900 ** while [sqlite3_changes()] is running then the value returned
2922 ** type of the return value and that if the number of rows modified by the
2923 ** connection exceeds the maximum value supported by type "int", then
2924 ** the return value of sqlite3_total_changes() is undefined. ^Executing
2925 ** any other type of SQL statement does not affect the value returned by
2941 ** while [sqlite3_total_changes()] is running then the value
3017 ** then the return value from sqlite3_complete16() will be non-zero
3223 ** value but we cannot change the implementation of sqlite3_snprintf()
3294 ** ^The value returned by sqlite3_msize(X) might be larger than the number
3333 ** value of [sqlite3_memory_used()] since the high-water mark
3340 ** ^The memory high-water mark is reset to the current value of
3342 ** [sqlite3_memory_highwater()] is true. ^The value returned
3390 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
3412 ** a NULL value in place of the table column that would have
3646 ** mask M occur. ^The integer return value from the callback is currently
3686 ** ^The progress handler is also disabled by setting N to a value less
3869 ** the value passed as the fourth parameter to sqlite3_open_v2().
3872 ** "rwc", or "memory". Attempting to set it to any other value is
3882 ** or writes from disk is used. ^It is an error to specify a value for
3892 ** a URI filename, its value overrides any behavior requested by setting
3956 ** specifying an octet value. ^Before the path or query components of a
3994 ** parameter, and if so obtains the value of that query parameter.
4010 ** sqlite3_uri_parameter(F,P) returns the value of the P
4013 ** has no explicit value, then sqlite3_uri_parameter(F,P) returns
4017 ** parameter and returns true (1) or false (0) according to the value
4019 ** value of query parameter P is one of "yes", "true", or "on" in any
4020 ** case or if the value begins with a non-zero number. The
4021 ** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of
4023 ** if the value begins with a numeric zero. If P is not a query
4024 ** parameter on F or if the value of P does not match any of the
4027 ** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
4029 ** exist. If the value of P is something other than an integer, then
4033 ** the value) of the N-th query parameter for filename F, or a NULL
4035 ** parameters minus 1. The N value is zero-based so N should be 0 to obtain
4084 ** return value from [sqlite3_db_filename()], then the result is
4136 ** to a key and value for a query parameter. The P parameter may be a NULL
4149 ** corruption or segfaults may occur. The value Y should not be
4180 ** change the value of the error code. The error-code preserving
4278 ** [sqlite3_limit()] interface returns the prior value of the limit.
4279 ** ^Hence, to find the current value of a limit without changing it,
4489 ** ^If the specific value bound to a [parameter | host parameter] in the
4494 ** ^The specific value of a WHERE-clause [parameter] might influence the
4643 ** statement, then sqlite3_stmt_readonly(X) returns the same value as
4772 ** for "?NNN" parameters is the value of NNN.
4773 ** ^The NNN value must be between 1 and the [sqlite3_limit()]
4774 ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 32766).
4776 ** ^The third argument is the value to bind to the parameter.
4799 ** ^(In those routines that have a fourth argument, its value is the
4800 ** number of bytes in the parameter. To be clear: the value is the
4801 ** number of <u>bytes</u> in the value, not the number of characters.)^
4812 ** the value of the fourth parameter then the resulting string value will
4847 ** ^A negative value for the zeroblob results in a zero-length BLOB.
4850 ** [prepared statement] S to have an SQL value of NULL, but to also be
4932 ** ^If the value N is out of range or if the N-th parameter is
4949 ** index value returned is suitable for use as the second
5010 ** ^The name of a result column is the value of the "AS" clause for
5044 ** subquery and is not a column value, then all of these functions return
5118 ** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
5212 ** ^(Every value in SQLite has one of five fundamental datatypes:
5289 ** each return the value of a result column in a specific data format. If
5292 ** is used to extract the value) then an automatic type conversion is performed.
5296 ** of the result column. ^The returned value is one of [SQLITE_INTEGER],
5298 ** The return value of sqlite3_column_type() can be used to decide which
5299 ** of the first six interface should be used to extract the column value.
5300 ** The value returned by sqlite3_column_type() is only meaningful if no
5301 ** automatic type conversions have occurred for the value in question.
5315 ** ^If the result is a numeric value then sqlite3_column_bytes() uses
5316 ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
5324 ** ^If the result is a numeric value then sqlite3_column_bytes16() uses
5325 ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
5337 ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
5446 ** If an out-of-memory error occurs, then the return value from these
5447 ** routines is the same as if the column had contained an SQL NULL value.
5450 ** return value is obtained and before any
5795 ** <tr><td><b>sqlite3_value_blob</b><td>→<td>BLOB value
5796 ** <tr><td><b>sqlite3_value_double</b><td>→<td>REAL value
5797 ** <tr><td><b>sqlite3_value_int</b><td>→<td>32-bit INTEGER value
5798 ** <tr><td><b>sqlite3_value_int64</b><td>→<td>64-bit INTEGER value
5799 ** <tr><td><b>sqlite3_value_pointer</b><td>→<td>Pointer value
5800 ** <tr><td><b>sqlite3_value_text</b><td>→<td>UTF-8 TEXT value
5801 ** <tr><td><b>sqlite3_value_text16</b><td>→<td>UTF-16 TEXT value in
5803 ** <tr><td><b>sqlite3_value_text16be</b><td>→<td>UTF-16be TEXT value
5804 ** <tr><td><b>sqlite3_value_text16le</b><td>→<td>UTF-16le TEXT value
5812 ** datatype of the value
5814 ** <td>→ <td>Best numeric datatype of the value
5819 ** <td>→ <td>True if value originated from a [bound parameter]
5851 ** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER],
5855 ** sqlite3_value_text(V) is called to extract a text value for that
5861 ** numeric affinity to the value. This means that an attempt is
5862 ** made to convert the value to an integer or floating point. If
5864 ** words, if the value is a string that looks like a number)
5870 ** of the value X, assuming that X has type TEXT.)^ If sqlite3_value_type(X)
5871 ** returns something other than SQLITE_TEXT, then the return value from
5875 ** sqlite3_value_bytes16(X) might change the encoding of the value X and
5883 ** the value for that column returned without setting a result (probably
5885 ** was unchanging). ^Within an [xUpdate] method, any value for which
5887 ** to be a NULL value. If sqlite3_value_nochange(X) is invoked anywhere other
5889 ** the return value is arbitrary and meaningless.
5892 ** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()]
5893 ** interfaces. ^If X comes from an SQL literal value, or a table column,
5920 ** If an out-of-memory error occurs, then the return value from these
5921 ** routines is the same as if the column had contained an SQL NULL value.
5924 ** return value is obtained and before any
5952 ** routine to set the subtype for the return value of an SQL function.
5964 ** memory allocation fails. ^If V is a [pointer value], then the result
5965 ** of sqlite3_value_dup(V) is a NULL value.
6000 ** value of N in any subsequent call to sqlite3_aggregate_context() within
6051 ** associate metadata with argument values. If the same value is passed to
6063 ** value to the application-defined function. ^N is zero for the left-most
6096 ** The value of the N parameter to these interfaces should be non-negative.
6114 ** SQLITE_TRANSIENT value means that the content will likely change in
6148 ** an application-defined function to be a floating point value specified
6180 ** ^The sqlite3_result_int() interface sets the return value
6182 ** value given in the 2nd argument.
6183 ** ^The sqlite3_result_int64() interface sets the return value
6185 ** value given in the 2nd argument.
6187 ** ^The sqlite3_result_null() interface sets the return value
6192 ** set the return value of the application-defined function to be
6195 ** ^The sqlite3_result_text64() interface sets the return value of an
6211 ** in the string at a byte offset that is less than the value of the 3rd
6258 ** SQL NULL value, just like [sqlite3_result_null(C)], except that it
6260 ** NULL value such that the pointer can be retrieved within an
6302 ** [sqlite3_context] C to be the value T. Only the lower 8 bits
6335 ** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin
6590 ** Changing the value of this variable while a database connection is
6618 ** [sqlite3_win32_set_directory] interface is used to set the value associated
6620 ** zValue, depending on the value of the type parameter. The zValue parameter
6621 ** should be NULL to cause the previous value to be freed via [sqlite3_free];
6622 ** a non-NULL value will be copied into memory obtained from [sqlite3_malloc]
6625 ** or [SQLITE_NOMEM] if memory could not be allocated. The value of the
6635 void *zValue /* New value for directory being set or reset */
6668 ** connection while this routine is running, then the return value
6692 ** out of range. An N value of 0 means the main database file. An N of 1 is
6718 ** ^The string value returned by this routine is owned and managed by
6719 ** the database connection. ^The value will be valid until the database N
6759 ** <li value="0"> SQLITE_TXN_NONE
6760 ** <li value="1"> SQLITE_TXN_READ
6761 ** <li value="2"> SQLITE_TXN_WRITE
6879 ** ^If the value returned is greater than or equal to the number of
6901 ** then the autovacuum steps callback is cancelled. The return value
7086 ** ^The return value from both sqlite3_soft_heap_limit64() and
7098 ** is invoked with a value of N that is greater than the hard heap limit,
7099 ** the soft heap limit is set to the value of the hard heap limit.
7114 ** <li> The limit value is set to zero.
7496 ** ^The estimatedCost value is an estimate of the cost of a particular
7502 ** ^The estimatedRows value is an estimate of the number of rows that
7527 ** value greater than or equal to 3008002. Similarly, the idxFlags field
7530 ** sqlite3_libversion_number() returns a value greater than or equal to
7578 ** [sqlite3_index_info].aConstraint[].op field. Each value represents
7591 ** value 255 are reserved to represent functions that are overloaded
7829 ** <li> ^(The specified column of row iRow contains a value that is not
7830 ** a TEXT or BLOB value)^,
7892 ** by the rowid value passed as the second argument. Only the row can be
7898 ** it must exist and there must be either a blob or text value stored in
7900 ** it does not contain a blob or text value, or if another error occurs, an
7961 ** ^The size of the blob (and hence the maximum value of N+iOffset)
8001 ** BLOB (and hence the maximum value of N+iOffset) can be determined
8344 ** the xFileControl method. ^The return value of the xFileControl
8345 ** method becomes the return value of this routine.
8350 ** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes
8520 ** [sqlite3_str_finish(X)]. It is always safe to use the value
8527 ** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead
8539 ** pass the returned value to [sqlite3_free()] to avoid a memory leak.
8605 ** content of the dynamic string under construction in X. The value
8627 ** ^The current value of the parameter is returned into *pCurrent.
8628 ** ^The highest recorded value is returned in *pHighwater. ^If the
8629 ** resetFlag is true, then the highest record value is reset after
8631 ** value. For those parameters
8634 ** value. For these latter parameters nothing is written into *pCurrent.)^
8639 ** If either the current value or the highwater mark is too large to
8674 ** internal equivalents). Only the value returned in the
8676 ** The value written into the *pCurrent parameter is undefined.</dd>)^
8686 ** value returned is in pages, not in bytes.</dd>)^
8693 ** returned value includes allocations that overflowed because they
8700 ** handed to the [pagecache memory allocator]. Only the value returned in the
8702 ** The value written into the *pCurrent parameter is undefined.</dd>)^
8715 ** The *pCurrent value is undefined. The *pHighwater value is only
8745 ** ^The current value of the requested parameter is written into *pCur
8746 ** and the highest instantaneous value is written into *pHiwtr. ^If
8747 ** the resetFlg is true, then the highest instantaneous value is
8748 ** reset back down to the current value.
8777 ** satisfied using lookaside memory. Only the high-water value is meaningful;
8778 ** the current value is always zero.)^
8785 ** Only the high-water value is meaningful;
8786 ** the current value is always zero.)^
8793 ** Only the high-water value is meaningful;
8794 ** the current value is always zero.)^
8808 ** value as DBSTATUS_CACHE_USED. Or, if one or more or the pager caches are
8809 ** shared, the value returned by this call will be smaller than that returned
8862 ** <dd>This parameter returns zero for the current value if and only if
8902 ** ^The current value of the requested counter is returned.
8927 ** A non-zero value in this counter may indicate an opportunity to
8933 ** A non-zero value in this counter may indicate an opportunity to
8943 ** then the value returned by this statement status code is undefined.
8963 ** corresponding SQLITE_STMTSTATUS_FILTER_MISS value is the number of
8969 ** used to store the prepared statement. ^This value is not actually
9004 ** of this object as parameters or as their return value.
9043 ** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
9075 ** database page on disk. The value passed into szExtra depends
9080 ** does not have to do anything special based with the value of bPurgeable;
9091 ** instance passed as the first argument. This is the value configured using
9094 ** value; it is advisory only.
9109 ** The page to be fetched is determined by the key. ^The minimum key value
9116 ** cache implementation should use the value of the createFlag
9148 ** The xRekey() method is used to change the key value associated with the
9156 ** to the value of the iLimit parameter passed to xTruncate(). If any
9353 ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
9361 ** is not a permanent error and does not affect the return value of
9640 ** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value
9646 ** previously registered write-ahead log callback. ^The return value is
9667 ** a negative value as the nFrame parameter disables automatic
9806 int eMode, /* SQLITE_CHECKPOINT_* value */
9916 ** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL],
9935 int (*xPutLong)(void *pCtx, int addedRows, int column, sqlite3_int64 value);
9936 int (*xPutDouble)(void *pCtx, int addedRows, int column, double value);
9950 ** column value will not change. The virtual table implementation can use
9951 ** this hint as permission to substitute a return value that is less
9953 ** [xUpdate] method understands as a "no-change" value.
9989 ** The return value is computed as follows:
10020 ** <ol><li value="0"><p>
10027 ** the return value from sqlite3_vtab_distinct().
10028 ** <li value="1"><p>
10034 ** <li value="2"><p>
10043 ** that have the same value for all columns identified by "aOrderBy".
10046 ** <li value="3"><p>
10056 ** values are same value for sorting purposes, two NULL values are considered
10093 ** that invokes the [xFilter|xFilter() method] once for each value
10095 ** only sees a single value from the right-hand side of the IN operator
10122 ** the return value from sqlite3_vtab_in(P,N,F) will always be the same
10133 ** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
10185 ** routines return SQLITE_OK and set *P to point to the first or next value
10188 ** routines return [SQLITE_DONE]. ^The return value might be
10189 ** some other value, such as SQLITE_NOMEM, in the event of a malfunction.
10212 ** attempts to set *V to the value of the right-hand operand of
10216 ** and only if *V is set to a value. ^The sqlite3_vtab_rhs_value(P,J,V)
10223 ** the right-hand operand of a constraint is a literal value in the original
10251 ** return value from the [sqlite3_set_authorizer()] callback and that
10268 ** When the value returned to V is a string, space to hold that string is
10285 ** then this value will approximate the quotient NVISIT/NLOOP and the
10286 ** product of this value for all prior loops with the same SELECTID will
10287 ** be the NLOOP value for the current loop.
10303 ** The select-id is the same value as is output in the first column
10335 ** the statement - a non-zero value is returned and the variable that pOut
10434 ** or any operation on a WITHOUT ROWID table, the value of the sixth
10436 ** seventh parameter is the final rowid value of the row being inserted
10437 ** or updated. The value of the seventh parameter passed to the callback
10454 ** a [protected sqlite3_value] that contains the value of the Nth column of
10463 ** a [protected sqlite3_value] that contains the value of the Nth column of
10498 sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */
10515 ** The return value is OS-dependent. For example, on unix systems, after
10560 ** called, SQLITE_ERROR is returned. The final value of *P is undefined
10672 ** wal file was last deleted, the value returned by this function
10675 ** Otherwise, this API returns a negative value if P1 refers to an older
10677 ** snapshot, and a positive value if P1 is a newer snapshot than P2.
10728 ** returned value to avoid a memory leak. However, if the F argument
10938 sqlite3_rtree_dbl *aParam; /* value of function parameters */
10945 int mxLevel; /* The largest iLevel value in the tree */
11056 ** created. At present the only valid value for the second parameter is
11068 ** pArg must point to a value of type (int). If the value is initially
11071 ** value is less than zero, no change is made. In all cases the (int)
11095 ** Passing zero to this function disables the session. Passing a value
11096 ** greater than zero enables it. Passing a value less than zero is a
11099 ** The return value indicates the final state of the session object: 0 if
11125 ** is set. Passing a value less than zero does not modify the current value
11129 ** The return value indicates the final state of the indirect flag: 0 if
11174 ** rows a zero-length blob (SQL value X'') is stored in the changeset or
11175 ** patchset instead of a NULL value. This allows such changesets to be
11180 ** zero-length blob back to a NULL value when updating the sqlite_stat1
11184 ** conflict-handler callback) then the X'' value is returned. The application
11269 ** deleted or updated rows. For each unique primary key value, data is only
11275 ** NULL value, no record of the change is made.
11649 ** sqlite3_value object containing the iVal'th value from the vector of
11660 sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */
11680 ** sqlite3_value object containing the iVal'th value from the vector of
11683 ** a new value for the requested column, *ppValue is set to NULL and
11694 sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */
11712 ** sqlite3_value object containing the iVal'th value from the
12017 ** Otherwise, if the return value is non-zero or the xFilter argument to
12054 ** returns an illegal value, any changes already made are rolled back and
12056 ** actions are taken by sqlite3changeset_apply() depending on the value
12064 ** contains a row with the same primary key value (or values) as the
12070 ** the non-primary key fields contains a value different from the original
12071 ** row value stored in the changeset, the conflict-handler function is
12109 ** contains a row with the same primary key value (or values) as the
12115 ** the modified non-primary key fields contains a value different from an
12116 ** original row value stored in the changeset, the conflict-handler function
12287 ** If a conflict handler returns this value no special action is taken. The
12292 ** This value may only be returned if the second argument to the conflict
12307 ** If this value is returned, any changes applied so far are rolled back
12557 ** parameter set to a value less than or equal to zero. Other than this,
12657 ** interpretation of the (void*) value passed as the second parameter and
12658 ** the effect of calling this function depends on the value of the first
12665 ** to set and query the value of this configuration setting. The pointer
12666 ** passed as the second argument must point to a value of type (int).
12667 ** If this value is greater than 0, it is used as the new streaming data
12668 ** chunk size for both input and output. Before returning, the (int) value
12669 ** pointed to by pArg is set to the final value of the streaming interface
12810 ** should be greater than or equal to zero and smaller than the value
12842 ** If the callback function returns any value other than SQLITE_OK, the
12844 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
12891 ** In other words, the same value that would be returned by:
13022 ** returned. If an error occurs, some value other than SQLITE_OK should
13023 ** be returned. In this case, fts5 assumes that the final value of *ppOut
13076 ** If an xToken() callback returns any value other than SQLITE_OK, then
13078 ** immediately return a copy of the xToken() return value. Or, if the
13340 ** It used to be the case that setting this value to zero would
13352 ** expression. A value of 0 means that there is no limit.
13363 ** never has more than 3 or 4 terms. Use a value of 0 to disable
13409 ** counted using a signed 8-bit integer which has a maximum value of 127
13418 ** The maximum value of a ?nnn wildcard that the parser will accept.
13419 ** If the value exceeds 32767 then extra space is required for the Expr
13427 /* Maximum page size. The upper bound on this value is 65536. This a limit
13430 ** Earlier versions of SQLite allowed the user to change this value at
13456 ** Ordinarily, if no value is explicitly provided, SQLite creates databases
13459 ** SQLite may choose a larger value. This constant is the maximum value
13474 ** This is really just the default value for the max_page_count pragma.
13475 ** This value can be lowered (or raised) at run-time using that the
13493 ** A value of 1 means that a trigger program will not be able to itself
13494 ** fire any triggers. A value of 0 means that no trigger programs at all
13508 #pragma warn -aus /* Assigned value is never used */
13612 ** To ensure that the correct value of "THREADSAFE" is reported when querying
13677 ** sizes of memory allocations below this value where possible.
14245 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
14253 ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
14278 ** The default value of "20" was chosen to minimize the run-time of the
14286 ** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.
14388 ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
14389 ** that can be stored in a u32 without loss of data. The value
14391 ** have to specify the value in the less intuitive manner shown:
14409 ** logarithms. For quantity X, the value stored is 10*log2(X). This
14411 ** But the allowed values are "grainy". Not every value is representable.
14691 ** The following value as a destructor means to use sqlite3DbFree().
14694 ** this magic value that the code knows to handle differently. Any
15089 ** Changing the value of PENDING_BYTE results in a subtly incompatible
15189 ** value means no limit. This value may be overridden using the
15245 #define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */
15553 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
15569 ** The BTREE_DATA_VERSION value is not really a value stored in the header.
15571 ** the header value access routines since its access pattern is the same.
15572 ** Call it a "virtual meta value".
15583 #define BTREE_DATA_VERSION 15 /* A virtual meta-value */
15596 ** then the value of the node is the value in Mem[pExpr.iTable]. Any
15715 ** aMem not used decomposed key value
15730 sqlite3_value *aMem; /* First of nMem value in the unpacked pKey */
15731 u16 nMem; /* Number of aMem[] value. Might be zero */
15890 int i; /* Integer value if p4type==P4_INT32 */
15966 #define P4_REAL (-12) /* P4 is a 64-bit floating point value */
16175 #define OP_AggValue 164 /* synopsis: r[P3]=value N=P2 */
16236 ** the value of the largest JUMP opcode. The smaller the maximum
16762 ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
16904 u16 szTrue; /* True value of sz, even if disabled */
16918 void *pTrueEnd; /* True value of pEnd, when db->pnBytesFreed!=0 */
17026 int iSysErrno; /* Errno value from last system error */
17256 /* TH3 expects this value ^^^^^^^^^^ to be 0x0000800. Don't change it */
17264 /* TH3 expects this value ^^^^^^^^^^ to be 0x40000. Coordinate any change */
17270 /* TH3 expects this value ^^^^^^^^^^ See flatten04.test */
17314 void (*xValue)(sqlite3_context*); /* Current agg value */
17401 ** value passed as iArg is cast to a (void*) and made available
17457 ** FuncDef.flags variable is set to the value passed as the flags
17579 u8 szEst; /* Est size of value in this column. sizeof(INT)==1 */
17588 ** sqlite3StdTypeLen[] and sqlite3StdType[]. Each value is one more
17590 ** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
17671 ** affinity value.
17938 ** to its default value. CASCADE means that a DELETE or UPDATE of the
17942 ** The OE_Default value is a place holder that means to use whatever
17956 #define OE_SetNull 8 /* Set the foreign key value to NULL */
17957 #define OE_SetDflt 9 /* Set the foreign key value to its default */
17985 #define KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */
18053 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
18061 ** and the value of Index.onError indicates which conflict resolution
18272 ** value is also stored in the Expr.iAgg column in the aggregate so that
18307 u8 op2; /* TK_REGISTER/TK_TRUTH: original value of Expr.op
18308 ** TK_COLUMN: the value of p5 for OP_Column
18316 char *zToken; /* Token value. Zero terminated and dequoted */
18317 int iValue; /* Non-negative integer value if EP_IntValue */
18378 #define EP_FixedCol 0x000020 /* TK_Column with a known fixed value */
18384 #define EP_IntValue 0x000800 /* Integer value contained in u.iValue */
18401 #define EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */
18402 #define EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */
18523 int iConstExprReg; /* Register in which Expr value is cached. Used only
18564 ** Allowed values for IdList.eType, which determines which value of the a.u4
19060 ** the value of the expression can simply be read from the index, then
19064 ** this list is consulted and if a matching expression is found, the value
19071 int iIdxCol; /* The index column that contains value of pExpr */
19254 ** to save the Parse.zAuthContext value so that it can be restored later.
19262 ** Bitfield flags for P5 value in various opcodes.
19345 ** value of "op" as follows:
19490 sqlite3_int64 mxMmap; /* Maximum value for szMmap */
19741 int regOne; /* Register containing constant value 1 */
21052 ** It uses the RDTSC opcode to read the cycle count value out of the
21053 ** processor and returns that value. This can be used for high-res
21073 ret ; return value at EDX:EAX
21224 /* These macros are provided to "stringify" the value of the define
21225 ** for those options in which the value is meaningful. */
22149 ** disabled. The default value may be changed by compiling with the
22178 /* The minimum PMA size is set to this value multiplied by the database
22318 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
22330 ** IMPORTANT: Changing the pending byte to any value other than
22361 ** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
22506 ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
22552 ** A value for VdbeCursor.cacheStatus that means the cache is always invalid.
22558 ** is allocated to store the current value of the program counter, as
22614 ** integer etc.) of the same value.
22618 double r; /* Real value used when MEM_Real is set in flags */
22619 i64 i; /* Integer value used when MEM_Int is set in flags */
22624 char *z; /* String or BLOB value */
22625 int n; /* Number of characters in string value, excluding '\0' */
22628 u8 eSubtype; /* Subtype for this value */
22637 u16 mScopyFlags; /* flags value immediately after the shallow copy */
22648 ** representations of the value stored in the Mem struct.
22650 ** * MEM_Null An SQL NULL value
22682 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
22779 Mem *pOut; /* The return value is stored here */
22796 /* The ScanStatus object holds a single value for the
22819 char z[8]; /* Dequoted value for the string */
22929 i64 iKey1; /* First key value passed to hook */
22930 i64 iKey2; /* Second key value passed to hook */
22941 ** The value as passed into xFilter is an sqlite3_value with a "pointer"
22951 sqlite3_value *pOut; /* Register to hold each decoded output value */
23131 sqlite3StatValueType nowValue[10]; /* Current value */
23132 sqlite3StatValueType mxValue[10]; /* Maximum value */
23168 ** Return the current value of a status parameter. The caller must
23181 ** Add N to the value of a status record. The caller must hold the
23185 ** The value of N is added to the current status value and the high-water
23188 ** The StatusDown() routine lowers the current value by N. The highwater
23307 int *pCurrent, /* Write current value here */
23392 int nByte = 0; /* Used to accumulate return value */
23438 int nByte = 0; /* Used to accumulate return value */
23577 char rawS; /* Raw numeric value stored in s */
23595 ** B: minimum value. Always "0" or "1".
23596 ** C: maximum value, decoded as:
23853 ** or the number of seconds since 1970. If the value if r is within
23855 ** If the value is a valid unix timestamp, put it in p->s and set p->rawS.
23902 ** Multiplying this by 86400000 gives 464269060799999 as the maximum value
24130 float rLimit; /* Maximum NNN value for this transform */
24169 DateTime *p, /* The date/time value to be modified */
24204 ** Always interpret the prior number as a julian-day value. If this
24206 ** value in the allowed range of julian day numbers understood by
24222 ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
24235 ** Treat the current value of p->s as the number of
24438 ** then assume a default value of "now" for argv[0].
24751 ** This function returns the same value as time('now').
24765 ** This function returns the same value as date('now').
24779 ** This function returns the same value as datetime('now').
24990 ** routine has no return value since the return value would be meaningless.
26195 ** A value of zero turns off backtracing. The number is always rounded
26368 ** the u.hdr.prevSize value of the following chunk.
27259 ** or retains a value from a previous allocation */
27365 ** nBytes is always a value obtained from a prior call to
29077 ** Default value of the hard heap limit. 0 means "no limit".
29128 ** obtain the return value.
29130 ** The return value is the value of the heap limit just before this
29169 ** to obtain the return value without affecting the hard heap limit.
29171 ** The return value is the value of the hard heap limit just prior to
29564 ** argument to xRealloc is always a value returned by a prior call to
29918 ** The returned value is normally a copy of the second argument to this
29922 ** If an OOM as occurred, then the connection error-code (the value
29981 ** An "etByte" is an 8-bit unsigned value.
30001 #define FLAG_SIGNED 1 /* True if the value to convert is signed */
30910 ** after the attempted enlargement. The value returned might be zero.
31089 /* Return the current value for p */
33103 ** The following constant value is used by the SQLITE_BIGENDIAN and
33170 ** Translate a single UTF-8 character. Return the unicode value.
33181 ** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
33183 ** * This routine never allows a UTF16 surrogate value to be encoded.
33184 ** If a multi-byte character attempts to encode a value between
33232 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
33241 ** encoding, or if *pMem does not contain a string value.
33634 ** callback and the integer return value form the application-supplied
33651 ** Return true if the floating point value is Not a Number (NaN).
33657 int rc; /* The value return */
33674 ** The value returned will never be negative. Nor will it ever be greater
33676 ** than 1GiB) the value returned might be less than the true string length.
33835 ** The return value is -1 if no dequoting occurs or the length of the
34055 *pResult = 0.0; /* Default return value, in case of an error */
34259 ** value 2^63: 9223372036854775808. Return negative, zero, or positive
34296 ** 1 Excess non-space text after the integer value
34403 ** 1 Excess text after the integer value
34493 ** Return a 32-bit integer value extracted from a string. If the
34601 ** Return the number of bytes read. The value is stored in *v.
34755 ** Return the number of bytes read. The value is stored in *v.
34868 ** value. */
34894 ** Read or write a four-byte big-endian integer value.
34952 ** value. Return a pointer to its binary value. Space to hold the
34953 ** binary value has been obtained from malloc and must be freed by
35030 ** Attempt to add, substract, or multiply the 64-bit signed value iB against
35093 ** Compute the absolute value of a 32-bit signed integer, of possible. Or
35094 ** if the integer has a value of -2147483648, return +2147483647
35136 ** value.
35228 ** value for the pair and the size of the name/number pair, respectively.
35284 ** has the value iVal. Or return a NULL if there is no such variable in
35467 unsigned int *pHash /* Write the hash value here */
35502 unsigned int h /* Hash value for the element */
35766 /* 164 */ "AggValue" OpHelp("r[P3]=value N=P2"),
35982 ** underlying key/value store to use - either "local" or "session".
36009 /* Delete a key (with its corresponding data) from the key/value
36021 /* Read the value associated with a zKey from the key/value namespace given
36023 ** nBuf bytes of zBuf[]. The value might be truncated if zBuf is not large
36024 ** enough to hold it all. The value put into zBuf must always be zero
36190 ** The return value is the number of bytes actually written into aOut[].
36880 ** macros. This might sometimes compute the wrong value for some
37006 sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */
37201 sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
37202 sqlite3_syscall_ptr pDefault; /* Default value */
37390 sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
37426 ** Return the value of a system call. Return NULL if zName is not a
37465 ** Do not accept any file descriptor less than this value, in order to avoid
38029 ** set. It logs a message using sqlite3_log() containing the current value of
38173 ** return value might be uninitialized if an error occurs.
38331 ** to a non-zero value otherwise *pResOut is set to zero. The return value
38384 ** value is set, then it is the number of milliseconds to wait before
38385 ** failing the lock. The iBusyTimeout value is always reset back to
38397 unixFile *pFile /* Structure holding timeout value */
39059 ** to a non-zero value otherwise *pResOut is set to zero. The return value
39243 ** to a non-zero value otherwise *pResOut is set to zero. The return value
39433 ** to a non-zero value otherwise *pResOut is set to zero. The return value
39676 ** to a non-zero value otherwise *pResOut is set to zero. The return value
40114 ** To avoid stomping the errno value on a failed read the lastErrno value
40291 ** To avoid stomping the errno value on a failed write the lastErrno value
40454 ** the value of the dataOnly flag.
40534 ** value.
40740 /* The code below is handling the return value of osFallocate()
40928 /* The value of newLimit may be eventually cast to (size_t) and passed
40929 ** to mmap(). Restrict its value to 2GB if (size_t) is not at least a
41185 u8 nextShmId; /* Next available unixShm.id value */
41222 ** SQLite error code. The final value of *piOut is undefined in this
42130 ** created mapping is either the requested size or the value configured
42169 ** value of *pp is undefined in this case.
42215 /* If p!=0, it must match the iOff value. */
42259 ** A pointer to the F pointer is used as the pAppData value for VFS
42885 ** and a value suitable for passing as the third argument to open(2) is
42887 ** returned and the value of *pMode is not modified.
42894 ** corresponding database file and sets *pMode to this value. Whenever
42951 ** its value as a filename and try to copy the mode, uid and gid from
43100 /* Determine the value of the flags parameter passed to POSIX function
43305 ** test performed depends on the value of flags:
43621 ** The return value is the number of microseconds of sleep actually
43649 ** The following variable, if set to a non-zero value, is interpreted as
44465 /* Need to make a copy of path if we extracted the value
44788 ** to a non-zero value otherwise *pResOut is set to zero. The return value
45245 ** This macro is used when a local variable is set to a value that is
45361 sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */
45424 * in bytes. This value may be zero.
45464 * The initial size of the Win32-specific heap. This value may be zero.
45473 * The maximum size of the Win32-specific heap. This value may be zero.
45480 * The extra flags to use in calls to the Win32 heap APIs. This value may be
45552 ** can manually set this value to 1 to emulate Win98 behavior.
45580 sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
45581 sqlite3_syscall_ptr pDefault; /* Default value */
46242 sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
46278 ** Return the value of a system call. Return NULL if zName is not a
46991 const char *zValue /* New value for directory being set or reset */
47035 const void *zValue /* New value for directory being set or reset */
47052 ** argument is the name of the directory to use. The return value will be
47057 void *zValue /* New value for directory being set or reset */
47063 ** The return value of winGetLastErrorMsg
47148 ** It logs a message using sqlite3_log() containing the current value of
48319 int newLocktype; /* Set pFile->locktype to this value before exiting */
48692 /* The value of newLimit may be eventually cast to (SIZE_T) and passed
48693 ** to MapViewOfFile(). Restrict its value to 2GB if (SIZE_T) is not at
48819 u8 nextShmId; /* Next available winShm.id value */
49481 ** created mapping is either the requested size or the value configured
49581 ** value of *pp is undefined in this case.
49637 /* If p!=0, it must match the iOff value. */
50625 ** the final two cases; therefore, we return the safer return value of TRUE
51007 ** The following variable, if set to a non-zero value, is interpreted as
51026 /* FILETIME structure is a 64-bit value representing the number of
51089 ** it should be truncated. The return value of xGetLastError
52281 ** Otherwise, the value i is redirected into one of BITVEC_NPTR
52361 ** and that the value for "i" is within range of the Bitvec object.
52484 ** Return the value of the iSize parameter specified when Bitvec *p
52659 u8 eCreate; /* eCreate value for for xFetch() */
53448 ** Get the suggested cache-size value.
53456 ** Set the suggested cache-size value.
53466 ** Set the suggested cache-spill value. Make no changes if if the
53653 unsigned int iKey; /* Key value (page number) */
53723 unsigned int nMax; /* Configured "cache_size" value */
53769 /* The following value requires a mutex to change. We skip the mutex on
53771 ** (2) even if an incorrect value is read, no great harm is done since this
54174 ** Discard all pages from cache pCache with a page number (key value)
54480 ** Fetch a page by key value.
54483 ** the value of the createFlag argument. 0 means do not allocate a new
54493 ** depending on the value of parameter createFlag (which may be 0, 1 or 2).
54495 ** 1. Regardless of the value of createFlag, the cache is searched for a
54767 ** been released, the function returns. The return value is the total number
54852 ** extracts the least value from the RowSet.
54863 ** value added by the INSERT will not be visible to the second TEST.
54901 ** RowSet.pForest value points to the head of this forest list.
54904 i64 v; /* ROWID value for this entry */
55022 ** Insert a new value into a RowSet.
55303 /* Test to see if the iRowid value appears anywhere in the forest.
55459 /* Return the value to pass to a sqlite3_wal_hook callback, the
55853 ** to a less exclusive (lower) value than the lock that is actually held
55854 ** at the system level, but it is never set to a more exclusive value.
55906 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
56048 ** larger than the size of the database (the value stored at offset
56050 ** is not an integer multiple of the page-size, the value stored in
56153 u32 cksumInit; /* Quasi-random value added to every checksum */
56247 ** This cksum is initialized to a 32-bit random value that appears in the
56252 ** be correct. But by initializing the checksum to random value which
56274 ** the value of MEMDB will be a constant and the compiler will optimize
56690 ** (a) the value returned by OsDeviceCharacteristics() indicates that
56692 ** (b) the value returned by OsSectorSize() is less than or equal
56695 ** If it can be used, then the value returned is the size of the journal
56699 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
56813 u32 cksum; /* MJ checksum value read from journal */
56852 ** following the value in pPager->journalOff, assuming a sector
56857 ** Pager.journalOff Return value
56889 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
56891 ** journal file in bytes is larger than this value, then truncate the
56975 ** journal header. Normally, zero is written to this value at this time.
56981 ** reading the journal this value tells SQLite to assume that the
57059 ** is set to the value read from the journal header. SQLITE_OK is returned
57151 /* Update the page-size to match the value read from the journal.
57158 /* Update the assumed sector-size to match the value used by
57161 ** is being called from within pager_playback(). The local value
57266 ** Return the pPager->iDataVersion value
57411 ** value returned is a copy of the second argument to this function.
57484 ** the current journal-mode (Pager.journalMode value), as follows:
57684 ** page of data and the current value of pPager->cksumInit.
57687 ** random initial value (pPager->cksumInit) and every 200th byte
57701 u32 cksum = pPager->cksumInit; /* Checksum value to return */
57743 ** value is increased to the start of the next page in the journal.
57749 ** is greater than the current value of Pager.dbSize, then playback is
57989 /* If this was page 1, then restore the value of Pager.dbFileVers.
58200 ** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE.
58214 ** Set the value of the Pager.sectorSize variable for the given
58215 ** pager based on the value returned by the xSectorSize method
58223 ** the value returned by the xSectorSize() method rounded up to 32 if
58228 ** the effective sector size to its minimum value (512). The purpose of
58260 ** in the journal. If this value is 0xffffffff, then compute the
58262 ** (3) 4 byte big-endian integer which is the initial value for the
58278 ** Call the value from the second bullet "nRec". nRec is the number of
58280 ** value of nRec from the size of the journal file. But if a power
58284 ** the value of nRec computed from the file size would be too large. For
58285 ** that reason, we always use the nRec value in the header.
58287 ** If the nRec value is 0xffffffff it means that nRec should be computed
58288 ** from the file size. This value is used when the user selects the
58339 ** mxPathname is 512, which is the same as the minimum allowable value
58375 ** the value of nRec based on this assumption.
58510 ** value. Reset it to the correct value for this process.
58523 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
58524 ** the value read from the database file.
58587 ** Update the value of the change-counter at offsets 24 and 92 in
58598 /* Increment the value just read and write it back to byte 24. */
58912 ** is reset to the value that it held at the start of the savepoint
58913 ** (or transaction). No page with a page-number greater than this value
58933 /* Set the database size back to the value it was before the savepoint
59041 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
59241 ** is a no-op. The value returned is the error state error code (i.e.
59246 ** * the new page size (value of *pPageSize) is valid (a power
59845 /* Write the nRec value into the journal file header. If in
59922 ** is updated accordingly. If page 1 is written out, then the value cached
59923 ** in Pager.dbFileVers[] is updated to match the new value stored in
59986 ** the value now stored in the database file. If writing this
60450 (void)pPtr; /* Suppress warning about unused pPtr value */
60472 ** + The value returned by sqlite3OsSectorSize()
60527 /* The following call to PagerSetPagesize() serves to set the value of
60654 ** code is returned and the value of *pExists is undefined.
61729 ** making changes to a page. The caller must check the return value
61803 ** This routine is called to increment the value of the database file
61834 ** is initialized to the value passed as the isDirectMode parameter
61964 ** Note that if zSuper==NULL, this does not overwrite a previous value
62378 ** current cache hit or miss count, according to the value of eStat. If the
62488 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
62489 ** (the first created). A value of (Pager.nSavepoint-1) means operate
62493 ** If a negative value is passed to this function, then the current
62522 ** operation. Store this value in nNew. Then free resources associated
62585 ** The return value to this routine is always safe to use with
62698 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
62831 ** page number to iNew and sets the value of the PgHdr.flags field to
62832 ** the value passed as the third parameter.
62860 ** the locking-mode is set to the value specified.
62862 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
62889 ** The journalmode is set to the value specified if the change is allowed.
63319 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
63447 ** of the sequence being summed.) The s1 value spans all 32-bit
63456 ** After each checkpoint, the salt-1 value is incremented and the salt-2
63457 ** value is randomized. This prevents old and new frames in the WAL from
63466 ** or is a commit frame itself becomes the value read. If the WAL
63472 ** valid frame in the WAL. The reader uses this recorded "mxFrame" value
63474 ** to the WAL, but as long as the reader uses its original mxFrame value
63563 ** contain a value of 0.
63576 ** iMax be the value between iKey and iUnused, closest to iUnused,
63595 ** reader might be using some value K0 and a second reader that started
63597 ** and to the wal-index) might be using a different value K1, where K1>K0.
63607 ** When a rollback occurs, the value of K is decreased. Hash table entries
63608 ** that correspond to frames greater than the new K value are removed
63678 ** The szPage value can be any power of 2 between 512 and 32768, inclusive.
63706 ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from
63709 ** nBackfillAttempted is the largest value of nBackfill that a checkpoint
63720 ** holds read-lock K, then the value in aReadMark[K] is no greater than
63721 ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)
63723 ** a special case; its value is never used and it exists as a place-holder
63728 ** The value of aReadMark[K] may only be changed by a thread that
63729 ** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of
63737 ** largest value and will increase an unused aReadMark[] to mxFrame if there
63741 ** will choose aReadMark[0] which has value 0 and hence such reader will
63843 /* WAL magic value. Either this value, or the same value with the least
64070 ** architecture, it returns the u32 value that results from interpreting
64071 ** the 4 bytes as a big-endian value. On a big-endian architecture, it
64072 ** returns the value that would be produced by interpreting the 4 bytes
64073 ** of the input value as a little-endian integer.
64093 const u32 *aIn, /* Initial checksum value input */
64094 u32 *aOut /* OUT: Final checksum value output */
64328 ** Compute a hash on a page number. The resulting hash value must land
64330 ** the hash to the next value in the event of a collision.
64343 ** of a page hash table in the wal-index. This becomes the return value
64621 u32 magic; /* Magic value read from WAL header */
64622 u32 version; /* Magic value read from WAL header */
64635 ** data. Similarly, if the 'magic' value is invalid, ignore the whole
64723 ** intermediate value before setting to the final value, and that might
64732 ** changes the destination to some intermediate value before
64733 ** setting the final value, this alternative copy routine is
64741 ** the value needs to be changed, that means it is not being
64882 ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
64884 ** value of 120, we need to know that so there is an assert() to check it.
65136 ** returns an error, the value of *pp is undefined.
65142 WalIterator *p; /* Return value */
65345 ** The value of parameter salt1 is used as the aSalt[1] value in the
65346 ** new wal-index header. It should be passed a pseudo-random value (i.e.
65390 ** This is the only routine that will increase the value of nBackfill.
65392 ** its value.)
65645 ** non-negative value (pWal->mxWalSize>=0). Note that we truncate
65737 ** This is the value that walTryBeginRead returns when it needs to
65747 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
65919 ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY
66078 u32 mxReadMark; /* Largest aReadMark[] value */
66079 int mxI; /* Index of largest aReadMark[] value */
66242 ** value in the aReadMark[] array or the contents of the wal-index
66251 ** happened, then reading the database with the current value of
66291 ** Attempt to reduce the value of the WalCkptInfo.nBackfillAttempted
66301 ** may be left set to a value larger than expected, if a wal frame
66427 ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr
66502 ** error does occur, the final value of *piRead is undefined.
66534 ** table). This means the value just read from the hash
67351 /* Return the value to pass to a sqlite3_wal_hook callback, the
67472 ** Return a +ve value if snapshot p1 is newer than p2. A -ve value if
67479 /* aSalt[0] is a copy of the value stored in the wal file header. It
67496 ** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
67658 ** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default
67700 ** 8 4 Right child (the Ptr(N) value). Omitted on leaves.
67785 /* The following value is the maximum cell size assuming a maximum page
67806 ** You can change this value at compile-time by specifying a
68056 ** this will be declared corrupt. This value is calculated based on a
68080 ** The meaning of skipNext depends on the value of eState:
68356 ** Btree.pBt value. All elements of the list should belong to
68631 ** But if the value is zero, make it 65536.
68633 ** This routine is used to extract the "offset to cell content area" value
68635 ** is empty, the offset should be 65536, but the 2-byte value stores zero.
69297 ** up to the size of 1 varint plus 1 8-byte value when the cursor
69818 u64 iKey; /* Extracted Key value */
69954 u32 nSize; /* Size value to return */
69957 /* The value returned by this function should always be the same as
69958 ** the (CellInfo.nSize) value found by doing a full parse of the
69997 /* The value returned by this function should always be the same as
69998 ** the (CellInfo.nSize) value found by doing a full parse of the
70016 u32 nSize; /* Size value to return */
70019 /* The value returned by this function should always be the same as
70020 ** the (CellInfo.nSize) value found by doing a full parse of the
70036 /* pIter now points at the 64-bit integer key value, a variable length
70038 ** past the end of the key value. */
70339 ** and the reserved space is zero (the usual value for reserved space)
70342 ** integer, so a value of 0 is used in its place. */
70422 u16 iOrigSize = iSize; /* Original value of iSize */
70536 /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an
70539 /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a
70555 /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an
70558 /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a
70568 /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is
70625 ** the start of the cell content area. A zero value for this integer is
70766 pPage->nFree = -1; /* Indicate that this value is yet uncomputed */
70894 ** may remain unchanged, or it may be set to an invalid value.
71342 ** default value. Except, when opening on an existing shared pager-cache,
71536 ** The value returned is the current spill size. If zero is passed
71666 ** The value returned is the larger of the current reserve size and
71683 ** Regardless of the value of mxPage, return the maximum page count.
71729 ** is disabled. The default value for the auto-vacuum property is
71753 ** Return the value of the 'auto-vacuum' property. If auto-vacuum is
71775 ** set to the value passed to this function as the second parameter,
71963 ** 9-byte nKey value
71964 ** 4-byte nData value
72614 Pgno nFin; /* Return value */
73024 /* The rollback may have destroyed the pPage1->aData value. So
73053 ** value passed as the second parameter is the total number of savepoints,
73081 ** savepoint identified by parameter iSavepoint, depending on the value
73369 ** Return the value of the integer key or "rowid" for a table btree.
73430 ** that SQLite can handle) or more. But returning a smaller value might
73459 ** the pointer-map was used to obtain the value for *pPgnoNext), then
73643 ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array
73826 ** key/data is written into *pAmt. If *pAmt==0, then the value
74351 ** Return value negative: Cell at pCur[idx] less than pIdxKey
74353 ** Return value is zero: Cell at pCur[idx] equals pIdxKey
74355 ** Return value positive: Nothing is known about the relationship
74359 ** a positive value as that will cause the optimization to be skipped.
74649 ** as well as the boolean result value.
74681 ** Return value:
74865 ** SQLITE_OK is returned on success. Any other return value indicates
75193 ** The value passed as the second argument to this function is optional.
75195 ** corresponding to page iPage handy, it may pass it as the second value.
75693 Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
75752 ** a btree page has a value of 3 or less, the pCell value might point
75786 ** The minimum value of NN is 1 (of course). Increasing NN above 1
75789 ** The value of NN appears to give the best results overall.
75794 ** we have never tested any other value.
75851 ** are used and they point to the leaf pages only, and the ixNx value are:
75936 u8 *pSrcEnd; /* Current pCArray->apEnd[k] value */
76324 ** a variable length key value (which must be the same value as the
76327 ** To find the largest key value on pPage, first find the right-most
76330 ** and the key value (a variable length integer, may have any value).
76332 ** field. The second while(...) loop copies the key value from the
77009 ** of the right-most new sibling page is set to the value that was
77148 ** The iPg value in the following loop starts at nNew-1 goes down
77292 int rc; /* Return value from subprocedures */
77604 ** For a table btree (used for rowid tables), only the pX.nKey value of
77605 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
77930 ** parameter iKey is used as the rowid value when the record is copied
77933 ** This function does not actually write the new value to cursor pDest.
78106 ** The bPreserve value records which path is required:
78294 /* Read the value of meta[3] from the database to determine where the
78487 ** If pnChange is not NULL, then the integer value pointed to by pnChange
78537 ** The last root page is recorded in meta[3] and the value of
78605 /* Set the new 'max-root-page' value in the database header. This
78606 ** is the old value less one, less one more if that happens to
78648 ** of reading the value out of the header, it instead loads the "DataVersion"
78649 ** from the pager. The BTREE_DATA_VERSION value is not actually stored in the
78745 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
78970 ** root node aHeap[1] is always the minimum value currently in the heap.
78974 ** removes the root element from the heap (the minimum value in the heap)
79468 ** value of this routine is the same regardless of whether the journal file
80562 ** stores a single value in the VDBE. Mem is an opaque structure visible
80600 /* If MEM_Null is set, then either the value is a pure NULL (the usual
80682 ** (1) Check that string value of pMem agrees with its integer or real value.
80685 ** A single int or real value always converts to the same strings. But
80687 ** If a table contains a numeric value and an index is based on the
80688 ** corresponding string value, then it is important that the string be
80689 ** derived from the numeric value, not the other way around, to ensure
80768 ** then the encoding of the value may not have changed.
80792 ** contain a valid string or blob value. */
80882 ** Change pMem so that its MEM_Str or MEM_Blob value is stored in
80962 ** A MEM_Null value will never be passed to this function. This function is
81055 ** If the memory cell contains a value that must be freed by
81057 ** will free that value. It also sets Mem.flags to MEM_Null.
81153 ** Return some kind of integer value which is the best we can do
81154 ** at representing the value that *pMem describes as an integer.
81155 ** If pMem is an integer, then the value is exact. If pMem is
81156 ** a floating-point then the value returned is the integer part.
81159 ** an SQL-NULL value, return 0.
81161 ** If pMem represents a string value, its encoding might be changed.
81164 i64 value = 0;
81165 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
81166 return value;
81189 ** value. If it is a string or blob, try to convert it to a double.
81217 ** Return the value ifNull if pMem is NULL.
81240 /* Only mark the value as an integer if
81284 /* Compare a floating point value to an integer. Return true if the two
81285 ** values are the same within the precision of the floating point value.
81300 /* Convert a floating point value to its closest integer. Do so in
81345 ** Cast the datatype of the value in pMem according to the affinity
81347 ** is forced. In other words, the value is converted into the desired
81404 ** Delete any previous value and set the value stored in *pMem to NULL.
81411 ** Use this routine to reset the Mem prior to insert a new value.
81427 ** Delete any previous value and set the value to be a BLOB of length
81458 ** to a value change. So invoke the destructor, then set the value to
81468 ** Delete any previous value and set the value stored in *pMem to val,
81484 ** Set the value stored in *pMem should already be a NULL.
81504 ** Delete any previous value and set the value stored in *pMem to val,
81528 ** Delete any previous value and set the value of pMem to be an
81587 ** dual type, are allowed, as long as the underlying value is the
81647 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
81664 ** Change the value of a Mem to be a string or a BLOB.
81666 ** The memory management strategy depends on the value of the xDel
81667 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
81675 ** is required to store the string, then value of pMem is unchanged. In
81686 Mem *pMem, /* Memory cell to set to string value */
81692 i64 nByte = n; /* New value for pMem->n */
81694 u16 flags; /* New value for pMem->flags */
81846 ** The pVal argument is known to be a value other than NULL.
81889 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
81992 ** error occurs, output parameter (*ppVal) is set to point to a value
81996 ** If the result is a text value, the sqlite3_value object uses encoding
82009 sqlite3_value **ppVal, /* Write the new value here */
82016 sqlite3_value *pVal = 0; /* New value */
82093 ** Extract a value from the supplied expression in the manner described
82107 sqlite3_value **ppVal, /* Write the new value here */
82141 ** case when the value is -9223372036854775808.
82248 ** Create a new sqlite3_value object, containing the value of pExpr.
82252 ** be converted directly into a value, then the value is allocated and
82254 ** the value by passing it to sqlite3ValueFree() later on. If the expression
82255 ** cannot be converted to a value, then *ppVal is set to NULL.
82262 sqlite3_value **ppVal /* Write the new value here */
82269 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
82272 ** pAlloc if one does not exist and the new value is added to the
82275 ** A value is extracted in the following cases:
82277 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
82281 ** * The expression is a literal value.
82283 ** On success, *ppVal is made to point to the extracted value. The caller
82284 ** is responsible for ensuring that the value is eventually freed.
82288 Expr *pExpr, /* The expression to extract a value from */
82291 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
82336 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
82340 ** * The sqlite3ValueFromExpr() function is able to extract a value
82341 ** from the expression (i.e. the expression is a literal value).
82347 ** Before any value is appended to the record, the affinity of the
82354 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
82358 ** error if a value cannot be extracted from pExpr. If an error does
82365 Expr *pExpr, /* The expression to extract a value from */
82397 ** Attempt to extract a value from expression pExpr using the methods
82400 ** If successful, set *ppVal to point to a new value object and return
82401 ** SQLITE_OK. If no value can be extracted, but no other error occurs
82403 ** does occur, return an SQLite error code. The final value of *ppVal
82408 Expr *pExpr, /* The expression to extract a value from */
82410 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
82417 ** the column value into *ppVal. If *ppVal is initially NULL then a new
82421 ** ensuring that the value written into *ppVal is eventually freed.
82428 sqlite3_value **ppVal /* OUT: Extracted value */
82484 ** Change the string value of an sqlite3_value object
82766 ** the sqlite3VdbeChangeP4() function to change the value of the P4
82842 ** not NULL, or OP_Null if the value is a null pointer. For each "i" character
82869 ** Add an opcode that includes the p4 value as a pointer.
82893 ** while computing a generated column value. 0 is the usual case.
82930 ** Add an opcode that includes the p4 value with a P4_INT64 or
83027 ** Add an opcode that includes the p4 value as an integer.
83064 ** label can be used as the P2 value of an operation. Later, when
83069 ** The VDBE knows that a P2 value is a label because labels are
83071 ** Hence, a negative P2 value is a label that has yet to be resolved.
83084 ** the equivalent positive value.
83235 ** Then check that the value of Parse.mayAbort is true if an
83327 ** (1) For each jump instruction with a negative P2 value (a label)
83328 ** resolve the P2 value to an actual address.
83331 ** and store that value in *pMaxFuncArgs.
83528 ** fail due to a OOM fault and hence that the return value from
83571 ** array. Also, *pnMaxArg is set to the larger of its current value and
83668 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
83753 ** Delete a P4 value if necessary.
83909 ** Change the value of the P4 operand for a specific instruction.
83916 ** A value of n==0 means copy bytes of zP4 up to and including the
83980 ** to the value defined by the arguments. This is a high-speed
84053 ** Set the value if the iSrcLine field for the previously coded instruction.
84066 ** is readable but not writable, though it is cast to a writable value.
84094 ** Return an integer value for one of the parameters to the opcode pOp
84121 const char *zP4 /* Previously obtained value for P4 */
84205 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
84401 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
84561 ** that takes advantage of the fact that the memory cell value is
84642 int iPc; /* Rowid. Copy of value in *piPc */
84648 ** so far. The nRow value will increase as new trigger subprograms are
84927 ** value by the amount needed and return NULL.
85369 ** If the return value of sqlite3BtreeGetFilename() is a zero length
85629 ** database handles deferred constraint counter to the value it had when
86224 ** data and index records. Each serialized value consists of a
86258 ** Return the serial-type for the value stored in pMem.
86260 ** This routine might convert a large MEM_IntReal value into MEM_Real.
86304 /* If the value is IntReal and is going to take up 8 bytes to store
86306 ** point value */
86438 Mem *pMem /* Memory cell to write value into */
86473 Mem *pMem /* Memory cell to write value into */
86631 ** uninitialized memory. Overwrite its value with NULL, to prevent
86738 ** value. */
86790 ** or positive value if *pMem1 is less than, equal to or greater than
86848 /* It is possible to have a Blob value that has some non-zero content
86918 /* If one value is NULL, it is less than the other. If both values
86968 /* If one value is a string and the other is a blob, the string is less.
87004 ** except 7. The second points to a buffer containing an integer value
87006 ** and returns the value.
87072 int rc = 0; /* Return value */
87265 ** value. */
87620 ** This routine sets the value to be returned by subsequent calls to
87677 ** Return a pointer to an sqlite3_value structure containing the value bound
87678 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
87680 ** constants) to the value before returning it.
87682 ** The returned value must be freed by the caller using sqlite3ValueFree().
87702 ** Configure SQL variable iVar so that binding a new value to it signals
87795 ** the required value will be read from the row the cursor points to.
87803 i64 iKey1, /* Initial key value */
88095 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
88192 /* Return true if a parameter value originated from an sqlite3_bind() */
88239 ** on value P is not going to be used and need to be destroyed.
88460 /* Force the INT64 value currently stored as the result to be
88461 ** a MEM_IntReal value. See the SQLITE_TESTCTRL_RESULT_INTREAL
88524 ** value.
88624 ** caller. Set the error code in the database handle to the same value.
88766 ** UPDATE operation and the value of the column will not be modified
88770 ** xColumn method of a virtual table, then the return value is meaningless
88775 ** value, as a signal to the xUpdate routine that the column is unchanged.
88788 sqlite3_value **ppOut, /* Store the next value from the list here */
88831 ** Set the iterator value pVal to point to the first value in the set.
88832 ** Set (*ppOut) to point to this value before returning.
88839 ** Set the iterator value pVal to point to the next value in the set.
88840 ** Set (*ppOut) to point to this value before returning.
88935 ** argument to the user-function defined by pCtx. Any previous value is
89022 ** Return a pointer to static memory containing an SQL NULL value.
89060 ** it is, return a pointer to the Mem for the value of that column.
89061 ** If iCol is not valid, return a pointer to a Mem which has a value
89083 ** column value (i.e. a value returned by evaluating an SQL expression in the
89329 ** Unbind the value bound to variable i in virtual machine p. This is the
89330 ** the same as binding a NULL value to the column. If the "i" parameter is
89337 ** value in any case.
89363 ** binding a new value to this variable invalidates the current query plan.
89365 ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host
89379 ** Bind a text or BLOB value.
89415 ** Bind a blob value to an SQL statement variable.
89725 ** Return the value of a status counter for a prepared statement
89816 UnpackedRecord *pRet; /* Return value */
89974 ** value. Make a copy of the cell contents and return a pointer to it.
89976 ** caller may modify the value text encoding.
90144 ** parameter index is known, locate the value in p->aVar[]. Then render
90145 ** the value as a literal in place of the host parameter name.
90296 ** value of the cell. This macro verifies that shallow copies are
90489 ** An ephemeral string value (signified by the MEM_Ephem flag) contains
90582 ** floating point value of rValue. Return true and set *piValue to the
90583 ** integer value if the string is in range to be an integer. Otherwise,
90597 ** Try to convert a value into a numeric representation if we can
90628 ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */
90652 Mem *pRec, /* The value to apply affinity to */
90827 ** Print the value of a register for tracing purposes:
90977 ** overwritten with an integer value.
91217 ** that comment is used to determine the particular value of the opcode.
91220 ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
91327 ** The value in register P1 is unchanged by this opcode.
91334 ** value is a byte-code indentation hint. See tag-20220407a in
91401 ** Swap the program counter with the value in register P1. This
91427 ** Check the value in register P3. If it is NULL then Halt using
91429 ** value in register P3 is not NULL, then this routine is a no-op.
91449 ** For errors, it can be some other value. If P1!=0 then P2 will determine
91457 ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
91541 ** The 32-bit integer value P1 is written into register P2.
91552 ** P4 is a pointer to a 64-bit integer value.
91553 ** Write that value into register P2.
91566 ** P4 is a pointer to a 64-bit floating point value.
91567 ** Write that value into register P2.
91621 ** The string value P4 of length P1 (bytes) is stored in register P2.
91663 ** the OP_Return opcode has a P3 value of 1). Thus if the subroutine is
91679 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
91709 ** Set register P1 to have the value NULL as seen by the OP_MakeRecord
91711 ** the register, so that if the value was a string or blob that was
91748 ** The P4 value is used by sqlite3_bind_parameter_name().
91824 ** This instruction makes a deep copy of the value. A duplicate
91857 ** This instruction makes a shallow copy of the value. If the value
91880 ** Transfer the integer value held in register P1 into register P2.
92064 ** Add the value in register P1 to the value in register P2
92072 ** Multiply the value in register P1 by the value in register P2
92079 ** Subtract the value in register P1 from the value in register P2
92086 ** Divide the value in register P1 by the value in register P2
92087 ** and store the result in register P3 (P3=P2/P1). If the value in
92096 ** If the value in register P1 is zero the result is NULL.
92106 i64 iA; /* Integer value of left operand */
92107 i64 iB; /* Integer value of right operand */
92108 double rA; /* Real value of left operand */
92109 double rB; /* Real value of right operand */
92225 ** Shift the integer value in register P2 to the left by the
92233 ** Shift the integer value in register P2 to the right by the
92293 ** Add the constant P2 to the value in register P1.
92308 ** Force the value in register P1 to be an integer. If the value
92335 ** If register P1 holds an integer convert it to a real value.
92340 ** to have only a real value.
92358 ** Force the value in register P1 to be the type defined by P2.
92368 ** A NULL value is not changed by this routine. It remains NULL.
92403 ** Once any conversions have taken place, and neither value is NULL,
92447 ** Once any conversions have taken place, and neither value is NULL,
92489 u16 flags1; /* Copy of initial value of pIn1->flags */
92490 u16 flags3; /* Copy of initial value of pIn3->flags */
92831 ** Interpret the value in register P1 as a boolean value. Store that
92832 ** boolean (a 0 or 1) in register P2. Or if the value in register P1 is
92857 ** Interpret the value in register P1 as a boolean value. Store the
92858 ** boolean complement in register P2. If the value in register P1 is
92876 ** ones-complement of the P1 value into register P2. If P1 holds
92930 ** Jump to P2 if the value in register P1 is true. The value
92931 ** is considered true if it is numeric and non-zero. If the value
92944 ** Jump to P2 if the value in register P1 is False. The value
92945 ** is considered false if it has a numeric value of zero. If the value
92959 ** Jump to P2 if the value in register P1 is NULL.
92984 ** from the value in that register.
92991 ** value determined by P1 and P3 corresponds to one of the bits in the
93078 ** Jump to P2 if the value in register P1 is not NULL.
93119 ** This opcode does not use P2 itself, but the P2 value is used by the
93157 ** The value extracted is stored in register P3.
93160 ** if the P4 argument is a P4_MEM use the value of the P4 argument as
93177 Mem *pDest; /* Where to write the extracted value */
93358 ** columns. So the result will be either the default value or a NULL.
93394 /* If the column value is a string, we need a persistent value, not
93395 ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent
93462 ** Take the affinities from the Table object in P4. If any value
93523 ** so that we keep the high-resolution integer value but know that
93555 sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s",
93586 ** so that we keep the high-resolution integer value but know that
93631 ** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value
93633 ** accept no-change records with serial_type 10. This value is
93703 ** have a non-NULL default value. Also, the record must be left with
93705 ** index of the right-most column with a non-NULL default value */
93719 ** Mem.uTemp value type
93747 ** computing an unchanging column value in an UPDATE statement.
93798 /* If the value is IntReal and is going to take up 8 bytes to store
93800 ** point value */
93837 ** value is the size of the header in bytes including the size varint
93855 ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
93898 /* NULL value. No change in zPayload */
93947 ** Store the number of entries (an integer value) in the table or index
93976 ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
94132 ** constraint violations present in the database to the value stored
94250 ** The cookie changes its value whenever the database schema changes.
94313 /* Store the current value of the database handles deferred constraint
94315 ** the value of this counter needs to be restored too. */
94351 /* Set changeCntOn to 0 to prevent the value returned by sqlite3_changes()
94393 ** Write the integer value P3 into cookie number P2 of database P1.
94456 ** The P4 value may be either an integer (P4_INT32) or a pointer to
94461 ** value, then the table being opened must be a [table b-tree] with a
94462 ** number of columns no less than the value of P4.
94475 ** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must
94495 ** The P4 value may be either an integer (P4_INT32) or a pointer to
94500 ** value, then the table being opened must be a [table b-tree] with a
94501 ** number of columns no less than the value of P4.
94514 ** as the root page, not the value of P2 itself.
94584 /* The p2 value always comes from a prior OP_CreateBtree opcode and
94585 ** that opcode will always set the p2 value to 2 or more or else fail.
94713 /* Make register reg[P3] into a value that can be used as the data
94805 ** the sequence value.
94889 ** use the value in register P3 as the key. If cursor P1 refers
94894 ** is greater than or equal to the key value. If there are no records
94916 ** use the value in register P3 as a key. If cursor P1 refers
94921 ** is greater than the key value. If there are no records greater than
94934 ** use the value in register P3 as a key. If cursor P1 refers
94939 ** is less than the key value. If there are no records less than
94952 ** use the value in register P3 as a key. If cursor P1 refers
94957 ** is less than or equal to the key value. If there are no records
95012 /* The input value in P3 might be of any type: integer, real, string,
95020 iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */
95024 /* If the P3 value could not be converted into an integer without
95355 ** Increase or decrease the seekHit value for cursor P1, if necessary,
95359 ** there is known to be at least one match. If the seekHit value is smaller
95456 ** A value of N in the seekHit flag of cursor P1 means that there exists
95483 ** contains any NULL value, jump immediately to P2. If all terms of the
95609 ** the P3 register must be guaranteed to contain an integer value. With this
95613 ** (with arbitrary multi-value keys).
95632 ** P3 register to contain a non-integer value, in which case the jump is
95636 ** (with arbitrary multi-value keys).
95657 ** integer value of pIn3. Jump to P2 if pIn3 cannot be converted
95733 ** allowed to be less than this value. When this value reaches its maximum,
95865 ** entry is overwritten. The data is the value MEM_Blob stored in register
95891 ** value of register P2 will then change. Make sure this does not
95994 i64 iKey; /* Rowid value to insert with */
96039 ** of the memory cell that contains the value that the rowid of the row will
96144 ** The value of the change counter is copied to the database handle
96532 ** table or index. If there are no more key/value pairs then fall through
96543 ** The P3 value is a hint to the btree implementation. If P3==1, that
96556 ** table or index. If there is no previous key/value pairs then fall through
96568 ** The P3 value is a hint to the btree implementation. If P3==1, that
96877 ** key that omits the PRIMARY KEY. Compare this key value against the index
96881 ** If the P1 index entry is greater than or equal to the key value
96888 ** key that omits the PRIMARY KEY. Compare this key value against the index
96892 ** If the P1 index entry is greater than the key value
96899 ** key that omits the PRIMARY KEY or ROWID. Compare this key value against
96903 ** If the P1 index entry is less than the key value then jump to P2.
96910 ** key that omits the PRIMARY KEY or ROWID. Compare this key value against
96914 ** If the P1 index entry is less than or equal to the key value then jump
97003 ** value of the root page that moved - its value before the move occurred -
97061 ** If the P3 value is non-zero, then the row change count is incremented
97063 ** than zero, then the value stored in register P3 is also incremented
97351 ** Insert the integer value held by register P2 into a RowSet object
97371 ** Extract the smallest value from the RowSet object in P1
97372 ** and put that value into register P3.
97389 /* A value was pulled from the index */
97399 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
97401 ** the value held in P3, jump to register P2. Otherwise, insert the
97407 ** Each set is identified by a unique P4 value. The first set
97413 ** (b) when P4==-1 there is no need to insert the value, as it will
97414 ** never be tested for, and (c) when a value that is part of set X is
97415 ** inserted, there is no need to search to see if the same value was
97489 ** single trigger all have the same value for the SubProgram.token
97511 ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
97601 ** OP_Program instruction. Copy a value currently stored in a memory
97607 ** the value of the P1 argument to the value of the P1 argument to the
97672 ** within a sub-program). Set the value of register P1 to the maximum of
97673 ** its current value and the value in register P2.
97701 ** If the value of register P1 is 1 or greater, subtract P3 from the
97702 ** value in P1 and jump to P2.
97704 ** If the initial value of register P1 is less than 1, then the
97705 ** value is unchanged and control passes through to the next instruction.
97723 ** holds the offset counter. The opcode computes the combined value
97724 ** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2]
97725 ** value computed is the total number of rows that will need to be
97729 ** and r[P2] is set to be the value of the LIMIT, r[P1].
97763 ** initially greater than zero, then decrement the value in register P1.
97781 ** Register P1 must hold an integer. Decrement the value in P1
97782 ** and jump to P2 if the new value is exactly zero.
97963 ** Synopsis: r[P3]=value N=P2
98486 ** Store in register P3 the value of the P2-th column of
98489 ** If the VColumn opcode is being used to fetch the value of
98491 ** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange()
98588 ** This opcode invokes the corresponding xRename method. The value
98626 ** invocation. The value in register (P3+P2-1) corresponds to the
98641 ** is successful, then the value returned by sqlite3_last_insert_rowid()
98642 ** is set to the value of the rowid for the row just inserted.
98719 ** Try to set the maximum page count for database P1 to the value in P3.
98721 ** do not change the maximum page count value if P3==0.
98888 ** even if the value is in the bloom filter. A false negative causes
98941 ** Increment the value of P1 so that OP_Once opcodes will jump the
99071 ** a change to the value of the source register for the OP_SCopy will no longer
99301 ** contain a value of type TEXT or BLOB in the column nominated when the
99316 /* Set the value of register r[1] in the SQL statement to integer iRow.
99342 zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
99461 /* If the value is being opened for writing, check that the
99737 ** contain a blob or text value, then an error code is returned and the
99864 ** the value returned by "PRAGMA main.page_size" multipled by
99877 ** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater
99879 ** "PRAGMA threads=N" with some value of N greater than 0.
99897 ** Parameter T is set to half the value of the memory threshold used
99982 ** The aTree[] array is also N elements in size. The value of N is stored in
99991 ** other key value. If the keys are equal (only possible with two EOF
99997 ** currently points to the smallest key value. aTree[0] is unused.
100012 ** The current element is "Apple" (the value of the key indicated by
100021 ** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree.
100022 ** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader
100024 ** so the value written into element 1 of the array is 0. As follows:
100354 ** the value read.
100386 ** Or, if an error occurs, return an SQLite error code. The final value of
100505 i64 *pnByte /* IN/OUT: Increment this value by PMA size */
100576 ** the first field of each key is a TEXT value and that the collation
100587 const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */
100588 const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */
100619 ** the first field of each key is an INTEGER value.
100631 const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */
100632 const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */
100633 int res; /* Return value */
100688 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
100690 ** records being sorted. However, if the value passed as argument nField
100776 /* A negative cache-size value C indicates that the cache is abs(C)
101300 ** Write value iVal encoded as a varint to the PMA. Return
101424 /* If pReadr1 contained the smaller value, set aTree[i] to its index.
101432 ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent
101435 ** If the two values were equal, then the value from the oldest
101572 ** flush the contents of memory to a new PMA if (a) at least one value is
101573 ** already in memory and (b) the new value will not fit in memory.
101884 ** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use
102081 ** PMA before returning. If an error does occur, then the final value of
102115 ** SORTER_MAX_MERGE_COUNT. The returned value does not include leaf nodes.
102194 ** error occurs, an SQLite error code is returned and the final value
102404 ** Advance to the next element in the sorter. Return value:
102501 ** Otherwise, set *pRes to a negative, zero or positive value if the
102585 char *zP4; /* Rendered P4 value */
102844 ** rowid is the same as the output value.
103316 ** The behaviour of the journal file depends on the value of parameter
103320 ** positive value, then the journal file is initially created in-memory
103465 ** The return value from the callback should be one of the WRC_*
103476 ** The return value from this routine is WRC_Abort to abandon the tree walk
103738 ** alias is removed from the original expression. The usual value is
103897 ** The zDb variable is the name of the database (the "X"). This value may be
103900 ** value can be NULL if zDb is also NULL. If zTable is NULL it
103924 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
104269 sqlite3ErrorMsg(pParse, "row value misused");
104295 ** supplied) and the value of Z is enclosed in double-quotes, then
104420 /* Increment the nRef value on all name contexts from TopNC up to
104506 ** Expression p should encode a floating point value between 1.0 and 0.0.
104507 ** Return 1024 times this value. Or return -1 if p is not a floating point
104508 ** value between 1.0 and 0.0.
104967 sqlite3ErrorMsg(pParse, "row value misused");
105025 ** The left-most column is 1. In other words, the value returned is the
105026 ** same integer value that would be used in the SQL statement to indicate
105041 u8 savedSuppErr; /* Saved value of db->suppressErr */
105082 int mx, /* Largest permissible value of i */
105529 ** within the ORDER BY clause has been transformed to an integer value.
105771 ** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
105772 ** nodes of the expression is set to -1 and the Expr.iColumn value is
105846 ** or a sub-select with a column as the return value, then the
106130 ** Return the P5 value that should be used for a binary comparison
106293 ** ensuring that the returned value eventually gets freed.
106374 ** the register number of a register that contains the value of
106449 sqlite3ErrorMsg(pParse, "row value misused");
106539 ** If this maximum height is greater than the current value pointed
106541 ** value.
106857 ** a value of false.
107144 ** The size of the structure can be found by masking the return value
107146 ** return value with EP_Reduced|EP_TokenOnly.
107160 assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
107201 ** The value returned includes space to create a copy of the Expr struct
107204 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
107597 ** but is not necessarily true from the return value of sqlite3ExprListDup().
107969 ** Walker.eCode value determines the type of "constant" we are looking
107983 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
108188 ** the value of the HAVING clause term must be the same for all members of
108257 ** to fit in a 32-bit integer, return 1 and put the value of the integer
108300 ** when we know that a value cannot be NULL. Hence, a false positive
108437 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
108481 ** The returned value of this function indicates the b-tree type, as follows:
108531 ** if there is any chance that the (...) might contain a NULL value at
108534 ** NULL value, then *prRhsHasNull is left unchanged.
108537 ** the value in that register will be NULL if the b-tree contains one or more
108538 ** NULL values, and it will be some non-NULL value if the b-tree contains no
108828 ** "row value misused"
108837 sqlite3ErrorMsg(pParse, "row value misused");
108856 ** If the LHS expression ("x" in the examples) is a column value, or
108857 ** the SELECT statement returns a column value, then the affinity of that
109060 ** return value is the register of the left-most result column.
109207 ** x IN (value, value, ...)
109215 ** The IN operator is true if the LHS value is contained within the RHS.
109480 ** value described by z[0..n-1] into register iMem.
109488 double value;
109489 sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
109490 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
109491 if( negateFlag ) value = -value;
109492 sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL);
109513 i64 value;
109516 c = sqlite3DecOrHexToI64(z, &value);
109517 if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){
109532 if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; }
109533 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
109539 /* Generate code that will load into register regOut a value that is
109547 int regOut /* Store the index column value in this register */
109564 ** Generate code that will compute the value of generated column pCol
109591 ** Generate code to extract the value of the iCol-th column of a table.
109595 Table *pTab, /* The table containing the value */
109598 int regOut /* Extract the value into this register */
109644 ** table pTab and store the column value in register iReg.
109655 u8 p5 /* P5 value for OP_Column + FLAGS */
109677 ** the correct value for the expression.
109788 /* The UNLIKELY() function is a no-op. The result is the value
109855 ** return the register into which the value has been read. If pExpr is
109877 ** cannot extract the value from the index. The value must be
110519 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
110529 sqlite3ErrorMsg(pParse, "row value misused");
110535 ** Expr.iTable value is the table number for the right-hand table.
110624 ** The value in regFree1 might get SCopy-ed into the file result.
110700 ** store the value whereever it wants. The register where the expression
110709 int regDest /* Store the value in this register */
110839 ** Generate code that pushes the value of every element of the given
110854 ** in registers at srcReg, and so the value can be copied from there.
111160 /* The value of pExpr->op and op are related as follows:
111174 ** The value of TK_ and OP_ constants are arranged such that we
111334 ** If pExpr is a simple SQL value - an integer, real, string, blob
111335 ** or NULL value - then the VDBE currently being prepared is configured
111336 ** to re-prepare each time a new value is bound to variable pVar.
111338 ** Additionally, if pExpr is a simple SQL value and the value is the
111341 ** SQL value, zero is returned.
111397 ** pB causes a return value of 2.
111538 int seenNot /* Return true only if p can be any non-NULL value */
112647 Expr *pDflt; /* Default value for the new column */
112677 ** If there is a NOT NULL constraint, then the default value for the
112690 /* If the default value for the new column was specified with a
112701 "Cannot add a REFERENCES column with non-NULL default value");
112705 "Cannot add a NOT NULL column with default value NULL");
113019 ** to look up the actual token value that created some element in
114181 ** The returned value is the modified SQL statement. For example, given
114303 ** The return value is computed as follows:
114383 ** The value returned is a string containing the CREATE TABLE statement
114656 ** value in the first column of the index. The third integer is the average
114657 ** number of rows in the index that have the same value for the first two
114659 ** the index which have the same value for the first N-1 columns. For
114684 ** inclusive are samples of the left-most key value in the index taken at
114742 ** column contains the actual value of the left-most column instead
114921 /* Initialize the BLOB value of a ROWID
114937 /* Initialize the INTEGER value of a ROWID.
115002 ** value is a pointer to the StatAccum object. The datatype of the
115003 ** return value is BLOB, but it is really just a pointer to the StatAccum
115089 ** value. */
115108 ** considering only any trailing columns and the sample hash value, this
115252 ** index. The value of anEq[iChng] and subsequent anEq[] elements are
115439 /* Return the value to store in the "stat" column of the sqlite_stat1
115442 ** The value is a string composed of a list of integers describing
115448 ** if the index is on columns (a,b) and the sqlite_stat1 value is
115463 ** instead keep the I value at 1.0.
116265 ** the nEq values for column iCol for the same set (adding the value
116757 zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
117274 ** user-supplied authorization function returned an illegal value.
118151 ** the DEFAULT value, but might also be the expression that computes
118152 ** the value for a generated column.
118576 ** The storage column number (0,1,2,....) is the index of the value
118599 ** The storage column number (0,1,2,....) is the index of the value
118608 ** in storage. But the value sometimes is cached in registers that
119195 ** The expression is the default value for the most recently added column
119198 ** Default value expressions must be constant. Raise an exception if this
119206 Expr *pExpr, /* The parsed expression of the default value */
119207 const char *zStart, /* Start of the default value text */
119208 const char *zEnd /* First character past end of defaut value text */
119218 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
119501 ** database changes. After each schema change, the cookie value
119509 ** set back to prior value. But schema changes are infrequent
119510 ** and the probability of hitting the same cookie value is only
120025 ** restored to its original value prior to this routine returning.
120733 ** The "#NNN" in the SQL is a special constant that means whatever value
121974 ** number of rows in the table that match any particular value of the
122016 ** 6 and each subsequent value (if any) is 5. */
122197 ** than 64 tables in a join. So any value larger than 64 here
122218 ** the iStart value would be 0. The result then would
122286 ** a new one. If an OOM error does occurs, then the prior value of pList
123353 ** The return value is either the collation sequence to be used in database
123427 ** that uses encoding enc. The value returned indicates how well the
123428 ** request is matched. A higher value indicates a better match.
123438 ** The returned value is always between 0 and 6, as follows:
123561 int h; /* Hash value */
124000 int iPk = 0; /* First of nPk registers holding PRIMARY KEY value */
124148 ** this optimization caused the row change count (the value returned by
124642 ** holds the correct value and the loading of that register is skipped.
124691 ** But we are getting ready to store this value back into an index, where
124811 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
124871 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
124884 ** equivalent positive 64-bit two complement value. */
124902 ** that cannot be converted to a numeric value.
125140 /* The value has no fractional part so there is nothing to round */
125247 ** number of you get the same value back again. To do this
125249 ** values, resulting in a positive value. Then take the
125250 ** 2s complement of that positive value. The end result can
125284 ** value is the same as the sqlite3_last_insert_rowid() API function.
125317 ** Implementation of the total_changes() SQL function. The return value is
125703 ** sqlite3_log(). The return value is NULL. The function exists purely for
125771 ** value contained in pValue.
125836 ** value of its argument suitable for inclusion into an SQL statement.
125858 ** The unicode() function. Return the integer unicode code-point value
126264 u8 approx; /* True if non-integer value was input to the sum */
126274 ** value. TOTAL never fails, but SUM might through an exception if
127161 ** committed, the commit fails if the current value of the counter is
127489 /* Invoke MustBeInt to coerce the child key value to an integer (i.e.
127492 ** the value. Otherwise, the value inserted into the child key column
127705 ** be applied to each child key value before the comparison takes place.
128243 ** parameter aChange is passed a NULL value. For an UPDATE, aChange points
128247 ** the value is 0 or greater. Parameter chngRowid is set to true if the
128943 /* On the second pass, compute the value of each NOT-AVAILABLE column.
128999 ** (4) The original value of the max ROWID in pTab, or NULL if none
129269 ** load value into register R..R+n
129724 ** SELECT, go ahead and copy the value into the rowid slot now, so that
129725 ** the value does not get overwritten by a NULL at tag-20191021-002. */
129734 ** computed after the rowid since they might depend on the value
129770 ** get there default value */
129782 ** default value */
129790 /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */
129850 /* Compute the new value for generated columns after all other
129898 ** to generate a unique primary key value.
129921 /* Compute the new value for generated columns after all other
129968 ** constant value -1, in case one or more of the returned expressions
130204 ** value for either the rowid column or its INTEGER PRIMARY KEY alias.
130254 ** NOT NULL REPLACE The NULL value is replace by the default
130255 ** value for that column. If the default value
130265 ** is used. Or if pParse->onError==OE_Default then the onError value
130340 int iReg; /* Register holding column value */
130364 || pCol->iDflt==0 /* REPLACE is ABORT if no DEFAULT value */
131019 int p2; /* New P2 value for copied conflict check opcode */
131246 u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
133237 ** replaced by the lowercase value of every ASCII alphabetic
133702 u8 ePragTyp; /* PragTyp_XXX value */
134305 ** Interpret the given string as a boolean value.
134318 ** Interpret the given string as a locking mode value.
134330 ** Interpret the given string as an auto-vacuum mode value.
134425 ** Generate code to return a single integer value.
134427 static void returnSingleInt(Vdbe *v, i64 value){
134428 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, 1, 0, (const u8*)&value, P4_INT64);
134433 ** Generate code to return a single text value.
134591 ** Generate code to output a single-column result row with a value of the
134609 ** PRAGMA [schema.]id [= value]
134611 ** The identifier might also be a string. The value is a string, and
134612 ** identifier, or a number. If minusFlag is true, then the value is
134623 Token *pValue, /* Token for <value>, or NULL */
134624 int minusFlag /* True if a '-' sign preceded <value> */
134627 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
134632 int rc; /* return value form SQLITE_FCNTL_PRAGMA */
134751 ** page cache size. The value returned is the maximum number of
134753 ** page cache size value and the persistent page cache size value
134759 ** size. But continue to take the absolute value of the default cache
134804 ** database page size value. The value can only be set if
134831 ** flag setting and reports the new value.
134864 ** The absolute value of N is used. This is undocumented and might
135007 ** Get or set the value of the database 'auto-vacuum' parameter.
135008 ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL
135028 ** "incremental", write the value of meta[6] in the database
135086 ** page cache size value. If N is positive then that is the
135156 ** This value is advisory. The underlying VFS is free to memory map
135194 ** Return or set the local value of the temp_store flag. Changing
135195 ** the local value does not make changes to the disk file and the default
135196 ** value will be restored the next time the database is opened.
135214 ** Return or set the local value of the temp_store_directory flag. Changing
135215 ** the value sets a specific directory to be used for temporary files.
135258 ** Return or set the local value of the data_store_directory flag. Changing
135259 ** the value sets a specific directory to be used for database files that
135264 ** by this setting, regardless of its value.
135300 ** Return or set the value of the lock_proxy_file flag. Changing
135301 ** the value sets a specific file to be used for database access locks.
135336 ** Return or set the local value of the synchronous flag. Changing
135337 ** the local value does not make changes to the disk file and the
135338 ** default value will be restored the next time the database is
135396 ** compiled SQL statements after modifying a pragma value.
135416 ** dflt_value: The default value for the column, if any.
135494 ** and virtual tables. Each time we initialize a Table.nCol value
136077 ** be a TEXT value that can be losslessly converted to numeric.
136129 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
136153 zErr = sqlite3MPrintf(db, "non-%s value in %s.%s",
136163 zErr = sqlite3MPrintf(db, "NUMERIC value in %s.%s",
136168 ** be a TEXT value that can be converted to numeric. */
136179 zErr = sqlite3MPrintf(db, "TEXT value in %s.%s",
136352 /* Only change the value of sqlite.enc if the database handle is not
136353 ** initialized. If the main database exists, the new sqlite.enc value
136355 ** already exists, it will be created to use the new encoding value.
136391 ** the value of the schema-version and user-version, respectively. Both
136412 /* Write the specified cookie value */
136432 /* Read the specified cookie value */
136500 ** after accumulating N frames in the log. Or query for the current value
136643 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
136999 /* Increment the xRowid value */
137649 ** will be closed immediately after reading the meta-value. */
137661 ** value stored as part of the in-memory schema representation,
137689 ** created by a sub-select). In this case the return value of this
137763 ** another way to check for early cleanup is to check the return value.
137765 ** return value thereafter. Something like this:
138283 ** itself depending on the value of bFree
138341 Expr *pLimit /* LIMIT value. NULL means not used */
139007 ** value is not zero, then it is a label of where to jump. Otherwise,
139054 ** are available. Which is used depends on the value of parameter eTnctType,
139068 ** The returned value in this case is a copy of parameter iTab.
139077 ** The returned value in this case is the register number of the first
139085 ** No special action is required. The return value is zero.
139095 int eTnctType, /* WHERE_DISTINCT_* value */
139179 int eTnctType, /* WHERE_DISTINCT_* value */
139193 ** bit on the first register of the previous value. This will cause the
139217 ** the sorter to return to the user, the required value of bigblob is
139320 ** same value. However, if the results are being sent to the sorter, the
139397 ** iOrderByCol value to one more than the index of the ORDER BY
140578 pTab->szTabRow = 1; /* Any non-zero value works */
140645 ** The iOffset register (if it exists) is initialized to the value
140799 ** with a positive value, then the first OFFSET outputs are discarded rather
140936 ** the value for the recursive-table. Store the results in the Queue.
141508 ** if it is the RHS of a row-value IN operator.
141615 ** output value. A comparison is made against this value and the output
141675 int savedLimit; /* Saved value of p->iLimit */
141676 int savedOffset; /* Saved value of p->iOffset */
141984 ** flag is set, then the value in the register is set to NULL and the original
141997 ** "m" value of the subquery so that a NULL will be loaded instead of 59
142448 ** return the value X for which Y was maximal.)
142919 ** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
143018 ** Argument pExpr is a candidate expression to be replaced by a value. If
143020 ** then overwrite it with the corresponding value. Except, do not do so
143125 ** and the "123" value is hung off of the pLeft pointer. Code generator
143127 ** column value. Also, to avoid collation problems, this optimization is
143136 ** The query should return no rows, because the t1.x value is '10.0' not '10'
143405 int eRet = WHERE_ORDERBY_NORMAL; /* Return value */
143621 ** If a non-NULL value is returned, set *ppContext to point to the With
143627 With **ppContext /* OUT: WITH clause return value belongs to */
143661 ** calling this routine, Instead, use only the return value.
143734 With *pSavedWith; /* Initial value of pParse->pWith */
145335 ** a trigger, then we only need to compute the value of the subquery
147158 /* The first time a RETURNING trigger is seen, the "op" value tells
147711 ** reg+1 OLD.* value of left-most column of pTab
147713 ** reg+N OLD.* value of right-most column of pTab
147715 ** reg+N+2 NEW.* value of left-most column of pTab
147717 ** reg+N+N+1 NEW.* value of right-most column of pTab
147724 ** ON INSERT trigger, the value passed to this function as parameter reg
147787 ** the second leftmost column value is required, and so on. If there
147874 ** OP_Column to the default value, if any.
147876 ** The default value of a column is specified by a DEFAULT clause in the
147880 ** may not contain a value for the column and the default value, taken
147882 ** If the former, then all row-records are guaranteed to include a value
147883 ** for the column and the P4 value is not required.
147887 ** complicated default expression value was provided, it is evaluated
147891 ** Therefore, the P4 parameter is only required if the default value for
147897 ** (not a virtual table) then the value might have been stored as an
147979 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
148024 ** rowid value in <other-columns> is used as the integer key, and the
148160 int eOnePass; /* ONEPASS_XXX value from where.c */
148176 int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */
148189 int regKey = 0; /* composite PRIMARY KEY value */
148371 ** reference any changing column. The actual aXRef[] value for
148373 ** is non-negative, so the value of aXRef[] for generated columns can be
148374 ** set to any non-negative number. We use 99999 so that the value is
148715 /* If the rowid value will change, set register regNewRowid to
148716 ** contain the new value. If the rowid is not being modified,
148787 /* This branch loads the value of a column that will not be changed
148789 ** if there are one or more BEFORE triggers that use this value via
148894 /* If changing the rowid value, or if there are foreign key constraints
148900 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
149662 u32 saved_mDbFlags; /* Saved value of db->mDbFlags */
149663 u64 saved_flags; /* Saved value of db->flags */
149664 i64 saved_nChange; /* Saved value of db->nChange */
149665 i64 saved_nTotalChange; /* Saved value of db->nTotalChange */
149666 u32 saved_openFlags; /* Saved value of db->openFlags */
149697 /* Save the current value of the database flags so that it can be
149857 ** vacuum. Even entries are the meta value number and odd entries
149858 ** are an increment to apply to the meta value after the vacuum.
149902 /* Restore the original value of db->flags */
151578 u16 eOperator; /* A WO_xx value describing <op> */
151617 #define TERM_SLICE 0x8000 /* One slice of a row-value/vector comparison */
151906 #define WO_ROWVAL 0x2000 /* A row-value term */
152348 ** * the affinity change in zAff is guaranteed not to change the value.
152437 ** single value. Since the parser never creates such a vector, some
152475 ** The current value for the constraint is left in a register, the index
152478 ** constraint is a TK_EQ or TK_IS, then the current value might be left in
152650 ** example, the third "c" value is an inequality. So only two
152655 ** In the example above nEq==2. But this subroutine works for any value
152669 ** key value of the loop. If one or more IN operators appear, then
152684 ** no conversion should be attempted before using a t2.b value as part of
152769 /* No affinity ever needs to be (or should be) applied to a value
152772 ** affinity of the comparison has been applied to the value. */
152871 ** a TK_COLUMN node that does affect the value of the expression is set
152919 int reg = ++pWalker->pParse->nMem; /* Register for column value */
153050 ** a rowid value just read from cursor iIdxCur, open on index pIdx. This
153186 ** then clear the WhereLevel.regFilter value to prevent the Bloom filter
153297 ** means to continue with the next IN value combination. When
153401 VdbeOp *pOp; /* Opcode to access the value of the IN constraint */
153404 /* Reload the constraint value into reg[iReg+j+2]. The same value
153407 ** encoding of the value in the register, so it *must* be reloaded.
153864 /* Load the value for the inequality constraint at the end of the
153875 ** over that initialization, leaving the range-end value set to the
153876 ** range-start value, resulting in a wrong answer.
154139 ** 2022-02-04: Do not push down slices of a row-value comparison.
154332 ** loop. The byte-code formatter will use that P2 value as a hint to
154373 ** constraints to be generated. The value of stack variable iLoop
154385 int iNext = 0; /* Next value for iLoop */
154998 ** value of the variable means there is no need to invoke the LIKE
155042 ** appropriate virtual table operator. The return value is 1 or 2 if there
155051 unsigned char *peOp2, /* OUT: 0 for MATCH, or else an op2 value */
155097 ** functions where xFindFunction returns a value of at least
155763 unsigned char eOp2 = 0; /* op2 value for LIKE/REGEXP/GLOB */
156240 ** where-clause passed as the first argument. The value for the term
156243 ** In the common case where the value is a simple integer
156250 int iReg, /* Register that will hold value of the limit/offset */
156712 ** Either value may be -1, indicating that cursor is not used.
157173 ** where X is a constant value. The collation sequences of the
157199 ** Estimate the logarithm of the input value to base 2.
157594 ** from the loop, but the regFilter value is set to a register that implements
157638 ** P3==1 and use that value to initialize the blob. But that makes
157639 ** testing complicated. By basing the blob size on the value in the
158158 /* Restore the pRec->nField value before returning. */
158170 ** If the user explicitly specified a likelihood() value for this term,
158171 ** then the return value is the likelihood multiplied by the number of
158222 ** N is the total number of samples, the pLoop->nOut value is adjusted
158227 ** If pLower is NULL, or a value cannot be extracted from the term, L is
158228 ** set to zero. If pUpper is NULL, or a value cannot be extracted from it,
158232 ** if no value can be extracted from either pLower or pUpper (and so the
158243 WhereLoop *pLoop, /* Update the .nOut value of this loop */
158244 int *pbDone /* Set to true if at least one expr. value extracted */
158326 ** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index
158379 ** columns of the index, and $L is the value in pLower.
158382 ** is not a simple variable or literal value), the lower bound of the
158558 ** below would return the same value. */
158599 ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */
158958 /* In the current implementation, the rSetup value is either zero
159143 ** Adjust the WhereLoop.nOut value downward to account for terms of the
159159 ** value corresponds to -1 in LogEst notation, so this means decrement
159167 ** "x" column is boolean or else -1 or 0 or 1 is a common default value
159257 ** then this function would be invoked with nEq=1. The value returned in
159328 ** terms only. If it is modified, this value is restored before this
159347 Bitmask saved_prereq; /* Original value of pNew->prereq */
159348 u16 saved_nLTerm; /* Original value of pNew->nLTerm */
159349 u16 saved_nEq; /* Original value of pNew->u.btree.nEq */
159350 u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */
159351 u16 saved_nTop; /* Original value of pNew->u.btree.nTop */
159352 u16 saved_nSkip; /* Original value of pNew->nSkip */
159353 u32 saved_wsFlags; /* Original value of pNew->wsFlags */
159354 LogEst saved_nOut; /* Original value of pNew->nOut */
159457 /* "x IN (value, value, ...)" */
159563 ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */
159631 /* TUNING: If there is no likelihood() value, assume that a
159902 ** where K is a value between 1.1 and 3.0 set based on the relative
159931 LogEst aiRowEstPk[2]; /* The aiRowLogEst[] value for the sPk index */
159932 i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */
159938 int b; /* A boolean value */
160012 ** tables or 0.5 (LogEst=-10) for views and subqueries. The value
160028 ** not be unreasonable to make this value much larger. */
160079 ** a column with just two distinct values where each value has about
160334 ** (2) Multiple outputs from a single IN value will not merge
160344 ** xFilter for each value on the RHS of the IN) and a LIMIT or
160451 ** If possible, set (*ppVal) to point to an object containing the value
160457 sqlite3_value **ppVal /* Write value extracted here */
160620 /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq)
161044 ** for isOrderDistinct to be true. So the isOrderDistint value
162085 ** The return value is a pointer to an opaque structure that contains
162087 ** should invoke sqlite3WhereEnd() with the return value of this function
162184 WhereInfo *pWInfo; /* Will become the return value of this function */
162230 ** return value. A single allocation is used to store the WhereInfo
162263 pMaskSet->ix[0] = -99; /* Initialize ix[0] to a value that can never be
162606 /* iAuxArg is always set to a positive value if ONEPASS is possible */
163041 /* Proof that the "+1" on the k value above is safe */
163330 ** is not set to the default value "NO OTHERS".
164285 ** value should be a non-negative integer. If the value is not a
164554 ** regApp+1: integer value used to ensure keys are unique
164596 ** value of the second argument to nth_value() (eCond==2) has just been
164598 ** code to check that the value is a non-negative integer and throws an
164939 int regCRowid = 0; /* Current rowid value */
164941 int regRowid = 0; /* AggStep rowid value */
165205 ** The value of parameter op may also be OP_Gt or OP_Le. In these cases the
165233 int regString = ++pParse->nMem; /* Reg. for constant value '' */
165239 /* Read the peer-value from each cursor into a register */
165304 /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
165305 ** This block adds (or subtracts for DESC) the numeric value in regVal
165306 ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
165328 ** reg1 or reg2 contain a NULL value. */
165550 ** pExpr evaluates to a value that, when cast to an integer, is greater
165832 ** In the above notation, "csr.key" means the current value of the ORDER BY
166667 ** value associated with a terminal or non-terminal
166691 ** YY_MAX_SHIFT Maximum value for shift actions
166692 ** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
166693 ** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
166697 ** YY_MIN_REDUCE Minimum value for reduce actions
166698 ** YY_MAX_REDUCE Maximum value for reduce actions
166717 struct {int value; int mask;} yy231;
166775 ** functions that take a state number and lookahead value and return an
167647 ** + The value of the token stored at this level of the stack.
167650 ** + The semantic value stored at this level of the stack. This is
167660 YYCODETYPE major; /* The major token value. This is the code
167662 YYMINORTYPE minor; /* The user-supplied minor token value. This
167663 ** is the value of the token */
168557 /* The following function deletes the "minor type" or semantic value
168560 ** a pointer to the value to be deleted. The code used to do the
170020 { yymsp[-1].minor.yy394 = (yymsp[-1].minor.yy394 & ~yymsp[0].minor.yy231.mask) | yymsp[0].minor.yy231.value; }
170023 { yymsp[-1].minor.yy231.value = 0; yymsp[-1].minor.yy231.mask = 0x000000; }
170026 { yymsp[-2].minor.yy231.value = 0; yymsp[-2].minor.yy231.mask = 0x000000; }
170029 { yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394; yymsp[-2].minor.yy231.mask = 0x0000ff; }
170032 { yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394<<8; yymsp[-2].minor.yy231.mask = 0x00ff00; }
170762 ** regardless of the value of expr1.
171453 sqlite3ParserTOKENTYPE yyminor /* The value for the token */
171512 ** enough on the stack to push the LHS value */
171894 /* aKWHash[i] is the hash value for the i-th keyword */
173518 ** pointer to a string constant whose value is the same as the
174099 ** unsigned integer value that specifies the maximum size of the created
174502 ** Set the value returned by the sqlite3_last_insert_rowid() API function.
174670 /* Closing the handle. Fourth parameter is passed the value 2. */
175080 ** again until a timeout value is reached. The timeout value is
175772 ** is greater than sqlite3.pWalArg cast to an integer (the value configured by
175793 ** more frames in the log file. Passing zero or a negative value as the
175852 int eMode, /* SQLITE_CHECKPOINT_* value */
175970 ** The value returned depends on the value of db->temp_store (runtime
175971 ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
175973 ** and this functions return value.
176256 ** Change the value of a limit. Report the old value.
176258 ** Make no changes but still report the old value if the
176320 ** the default flags to open the database handle with. The value stored in
176326 ** point to a buffer containing the name of the file to open. The value
176330 ** the value returned in *pzFile to avoid a memory leak.
176409 ** 1: Parsing name section of a name=value query parameter.
176410 ** 2: Parsing value section of a name=value query parameter.
176427 ** value currently being parsed. So ignore the current character
177476 ** x!=0 && db!=0 Seed the PRNG to the current value of the
177483 ** x!=0 && db==0 Seed the PRNG to the value of x.
177527 ** value from sqlite3FaultSim(0) becomes the return from
177564 ** Set the PENDING byte to the value in the argument, if X>0.
177565 ** Make no changes if X==0. Return the value of the pending byte
177589 ** is enabled, then the return value is true. If X is true and
177590 ** assert() is disabled, then the return value is zero. If X is
177593 ** return value is zero.
177631 ** The return value is ALWAYS(X) if X is true, or 0 if X is false.
177633 ** The recommended test is X==2. If the return value is 2, that means
177635 ** default setting. If the return value is 1, then ALWAYS() is either
177755 ** By default this is 0x7ffffffe (over 2 billion), but that value is
177757 ** provided to set a small and easily reachable reset value.
177847 ** This test-control causes the most recent sqlite3_result_int64() value
177852 ** inject an intreal() value at arbitrary places in an SQL statement,
177883 ** op==1 Set sqlite3TreeTrace to the value *ptr
177885 ** op==3 Set sqlite3WhereTrace to the value *ptr
177900 ** double fIn, // Input value
177924 ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
177926 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
178036 ** parameter, and if so obtains the value of the query parameter.
178040 ** query parameter we seek. This routine returns the value of the zParam
178065 ** Return a boolean value for a query parameter.
178074 ** Return a 64-bit integer value for a query parameter.
178414 ** 1) Each entry in the list has a non-NULL value for either
178417 ** 2) All entries in the list that share a common value for
178799 ** value: 123 5 9 1 1 14 35 0 234 72 0
178801 ** The 123 value is the first docid. For column zero in this document
179381 ** value stored in the "%_segdir.level" column. Given this value L, the index
179653 ** The lower 16-bits of the sqlite3_index_info.idxNum value set by
179654 ** the xBestIndex() method contains the Fts3Cursor.eSearch value described
180022 ** The value is stored in *v.
180032 ** The value is stored in *v.
180131 ** to the first byte past the end of the varint. Add the value of the varint
180144 ** and sets *pVal by the varint value.
180314 "(id INTEGER PRIMARY KEY, value BLOB);",
180423 ** <key> = <value>
180425 ** There may not be whitespace surrounding the "=" character. The <value>
180608 ** Buffer z contains a positive integer value encoded as utf-8 text.
180609 ** Decode this value and store it in *pnOut, returning the number of bytes
180610 ** consumed. If an overflow error occurs return a negative value.
180625 ** value. It reads the integer and sets *pnOut to the value read, then
180627 ** the integer value.
180629 ** Only decimal digits ('0'..'9') may be part of an integer value.
180632 ** the output value undefined. Otherwise SQLITE_OK is returned.
180638 int nInt = 0; /* Output value */
180656 ** more "prefix" indexes, depending on the value of the "prefix=" parameter
180659 ** Argument zParam is passed the value of the "prefix=" option if one was
180718 ** The third argument passed to this function is the value passed to the
180732 ** by eventually passing the *pazCol value to sqlite3_free().
180840 /* The results of parsing supported FTS4 key=value options: */
180843 char *zPrefix = 0; /* Prefix parameter value (or NULL) */
181710 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
181711 sqlite3_int64 iVal /* Write this value to the list */
181739 ** of some other, multi-byte, value.
181802 ** as large or larger than any value that might appear on the
181816 ** increment the current value of *pi by the value read, and set *pp to
181817 ** point to the next value before returning.
181819 ** Before calling this routine *pi must be initialized to the value of
181821 ** in the position-list. Because positions are delta-encoded, the value
181822 ** of the previous position is needed in order to compute the value of
181841 ** the value of iCol encoded as a varint to *pp. This will start a new
182143 ** If bDescIdx is false, the value read is added to *pVal before returning.
182144 ** If it is true, the value read is subtracted from *pVal before this
182151 sqlite3_int64 *pVal /* IN/OUT: Integer value */
182169 ** end of the value written.
182171 ** If *pbFirst is zero when this function is called, the value written to
182174 ** If *pbFirst is non-zero when this function is called, then the value
182179 ** to the value of parameter iVal.
182184 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
182186 sqlite3_int64 iVal /* Write this value to the list */
182206 ** arguments are 64-bit docid values. If the value of the stack variable
182221 ** passed a non-zero value.
182262 ** the difference between it and the previous value in the output must
182263 ** be a positive value less than or equal to the delta value read from
182270 ** be larger in the output than it was in the input (since the delta value
182328 ** order, it should be passed a non-zero value.
182401 ** The value returned is the number of bytes written to pOut (if any).
182862 int nDoc = 0; /* Return value */
183082 ** This is the xColumn method, called by SQLite to request a value from
183087 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
183093 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
183095 int iCol /* Index of column to read value from */
183101 /* The column value supplied by SQLite must be in range. */
183191 int mxLevel = 0; /* Maximum relative level value in db */
183289 /* Search backwards for a varint with value zero (the end of the previous
183319 ** If the value passed as the third argument is a blob of size
183671 ** Calling sqlite3Fts3SimpleTokenizerModule() sets the value pointed
184246 ** point to the start of the next docid value. The following line deals
184567 ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
184600 testcase( a==0 ); /* If %_stat.value set to X'' */
184724 /* Set nLoad4 to the value of (4^nOther) for the next iteration of the
184725 ** for-loop. Except, limit the value to 2^24 to prevent it from
185148 ** the appropriate SQLite error code. In this case the returned value is
185156 int bHit = 1; /* Return value */
185565 ** The returned value is either NULL or a pointer to a buffer containing
185798 int iCol; /* Current value of 'col' column */
185830 int rc; /* value returned by declare_vtab() */
185918 int iNext = 1; /* Next free argvIndex value */
186032 /* Increment our pretend rowid value. */
186138 int iEq = -1; /* Index of term=? value in apVal */
186139 int iGe = -1; /* Index of term>=? value in apVal */
186140 int iLe = -1; /* Index of term<=? value in apVal */
186141 int iLangid = -1; /* Index of languageid=? value in apVal */
186198 /* If the user specified a negative value for the languageid, use zero
186227 ** xColumn - Return a column value.
186230 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
186232 int iCol /* Index of column to read value from */
186271 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
186272 sqlite_int64 *pRowid /* OUT: Rowid value */
186862 ** except an FTSQUERY_PHRASE). Return an integer value representing the
187669 ** FTS3_HASH_BINARY or FTS3_HASH_STRING. The value of keyClass
187750 ** single parameter "keyClass". The return value of ftsHashFunction()
187751 ** is a pointer to another function. Specifically, the return value
187866 int h /* Hash value for the element */
187946 int hraw; /* Raw hash value of the key */
188179 ** number of vowel consonant pairs. This routine computes the value
188182 ** Return true if the m-value for z is 1 or more. In other words,
188196 /* Like mgt0 above except we are looking for a value of m which is
188210 /* Like mgt0 above except we are looking for a value of m>1 instead
188577 ** whose value is greater than 0x80 (any UTF character) can be
188720 ** If the <pointer> argument is specified, it must be a blob value
188726 ** Whether or not the <pointer> argument is specified, the value returned
188913 ** The return value is a string that may be interpreted as a Tcl
189130 ** of the key when a value is inserted. i.e. by a call similar to:
189492 int iRowid; /* Current 'rowid' value */
189493 const char *zToken; /* Current 'token' value */
189495 int iStart; /* Current 'start' value */
189496 int iEnd; /* Current 'end' value */
189497 int iPos; /* Current 'pos' value */
189532 ** The final value of *pazDequote is undefined in this case.
189802 ** xColumn - Return a column value.
189805 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
189807 int iCol /* Index of column to read value from */
189837 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
189838 sqlite_int64 *pRowid /* OUT: Rowid value */
190210 /* 22 */ "SELECT value FROM %Q.'%q_stat' WHERE id=?",
190240 ** Modify the idx value for the segment with idx=:3 on absolute level :2
190246 ** level :1 with index value :2. */
190439 ** separate component values into the single 64-bit integer value that
190699 /* If the user has inserted a NULL value, this function may be called with
190880 ** a value for the "rowid" field, for the "docid" field, or for both.
190882 ** same value. For example:
190901 ** new docid value.
191001 ** with 0, so the allocated index is one greater than the value returned
191831 ** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs,
191861 char *zRoot, /* Blob value for "root" field */
192318 ** The first value in the apVal[] array is assumed to contain an integer.
192368 ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR).
192388 ** final value of *pbMax is undefined.
192396 ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR).
192573 sqlite3_int64 *piDocid, /* OUT: Docid value */
192649 ** equal or greater value than the specified term. This prevents many
192889 /* Calculate the 'docid' delta value to write into the merged
192968 ** to the integer value and *pnByte to zero before returning. In the second,
192969 ** set *piEndBlock to the first value and *pnByte to the second.
193031 ** contain a size value. This happens if it was written by an
193834 ** If the size of the value in blob pPrev is zero, then this is the first
194097 ** error code. The final value of *pbRes is undefined in this case.
194121 ** It checks if the existing segment with index value iIdx at absolute level
194277 ** Determine the largest segment index value that exists within absolute
194278 ** level iAbsLevel+1. If no error occurs, set *piIdx to this value plus
194282 ** If an error occurs, return an SQLite error code. The final value of
194306 ** with idx value iIdx.
194318 ** of input segments, multiplied by two. This value is stored in stack
194327 ** In the actual code below, the value "16" is replaced with the
194563 sqlite3_int64 iNewStart = 0; /* New value for iStartBlock */
194564 sqlite3_int64 iOldStart = 0; /* Old value for iStartBlock */
194709 ** If successful, populate blob *pHint with the value read from the %_stat
194858 ** value of nHintSeg to avoid a large memory allocation in case the
194970 ** its value. Advance *pz to point to the first character past
195002 /* Read the first integer value */
195005 /* If the first integer value is followed by a ',', read the second
195006 ** integer value. */
195090 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
195092 ** return value is undefined in this case.
195170 ** code. The final value of *pbOk is undefined in this case.
195301 ** meaningful value to insert is the text 'optimize'.
195487 ** SQLite value pRowid contains the rowid of a row that may or may not be
195593 ** value, then this operation requires constraint handling.
195602 /* Find the value object that holds the new rowid value. */
195622 ** This branch may also run if pNewRowid contains a value that cannot
195627 ** docid=$pNewRowid if $pNewRowid is not an integer value).
195731 #define FTS3_MATCHINFO_NPHRASE 'p' /* 1 value */
195732 #define FTS3_MATCHINFO_NCOL 'c' /* 1 value */
195733 #define FTS3_MATCHINFO_NDOC 'n' /* 1 value */
195742 ** The default value for the second argument to matchinfo().
195778 i64 iHead; /* Next value in position list */
195780 i64 iTail; /* Next value in trailing position list */
195927 ** element of the list is represented by an FTS3 varint that takes the value
195940 ** the list. *piPos contains the value of the previous entry in the list.
195941 ** After it returns, *piPos contains the value of the next element of the
196050 ** arguments so that it points to the first element with a value greater
196469 /* Variable DUMMY1 is initialized to a negative value above. Elsewhere
196796 ** If LcsIterator.iCol is set to the following value, the iterator has
196867 int nLcs = 0; /* LCS value for this column */
196921 ** default value "pcx" if no second argument was specified). The format
196931 ** occurs. If a value other than SQLITE_OK is returned, the state the
197581 ** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all
197591 int bAlnum, /* Replace Isalnum() return value with this */
197641 ** Return true if the p->aiException[] array contains the value iCode.
197885 ** The results are undefined if the value passed to this function
197893 ** The most significant 22 bits in each 32-bit value contain the first
197895 ** the size of the range (always at least 1). In other words, the value
198103 ** The results are undefined if the value passed to this function
198381 u32 iHold; /* Replace cache line with the lowest iHold value */
198542 ** Append a function parameter value to the JSON string under
198604 ** Appended elements are not counted. The value returned is the number
198606 ** next peer value.
198729 sqlite3_context *pCtx, /* Return value for this function */
198771 ** Make the JsonNode the return value of the function.
198775 sqlite3_context *pCtx, /* Return value for this function */
199002 ** Parse a single JSON value which begins at pParse->zJson[i]. Return the
199003 ** index of the first character past the end of the value parsed.
199668 ** Implementation of the json_QUOTE(VALUE) function. Return a JSON value
199669 ** corresponding to the SQL value input. Mostly this means putting
199752 ** jsonSetFunc() via the user-data value.
199836 ** element of the array being the value selected by one of the PATHs */
199973 ** object that contains all name/value given in arguments. Or if any name
199974 ** is not a string or if any value is a BLOB, throw an error.
200048 ** Replace the value at PATH with VALUE. If PATH does not already exist,
200094 ** Set the value at PATH to VALUE. Create the PATH if it does not already
200372 u32 iEnd; /* EOF when i equals or exceeds this value */
200411 "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
200577 /* Return the value of a column */
200677 /* Return the current rowid value */
200726 /* No JSON input. Leave estimatedCost at the huge value that it was
201235 int mxLevel; /* iLevel value for root of the tree */
201251 RtreeValue f; /* Floating point value */
201252 int i; /* Integer value */
201257 ** The argument is an RtreeCoord. Return the value stored within the RtreeCoord
201279 RtreeDValue rValue; /* Constraint value. */
201444 ** 64 bit integer. The deserialized value is returned.
201495 ** 64 bit integer. The value returned is the number of bytes written
201863 ** Return the 64-bit integer value associated with cell iCell of
202091 ** Convert raw bits from the on-disk RTree record into a coordinate value.
202222 sqlite3_rtree_dbl val; /* Coordinate value convert to a double */
202279 RtreeDValue xN; /* Coordinate value converted to a double */
202301 ** integer value equal to iRowid. Return the index of this cell.
202744 ** as the second argument for a MATCH constraint. The value passed as the
203338 ** minimum value of dimension iDim is considered first, the
204116 ** (at pRtree->base.zErrMsg) to an appropriate value and returns
204189 ** 1. A duplicate rowid value, or
204234 /* If a rowid value was supplied, check if it is already present in
204258 /* If aData[0] is not an SQL NULL value, it is the rowid of a
204581 ** that returns a single integer value. The statement is compiled and executed
204582 ** using database connection db. If successful, the integer value returned
204584 ** code is returned and the value of *piVal after returning is not defined.
204858 ** The depth value is 0 for all nodes other than the root node, and the root
204978 ** in the RtreeCheck object. The final value of *pnNode is undefined in
204982 u8 *pRet = 0; /* Return value */
205022 ** IPK value iKey and the second column set to iVal.
205029 i64 iVal /* Expected value for mapping */
205301 ** table corresponding to the cell's rowid value that
205510 /* Parse out a number. Write the value into *pVal if pVal!=0.
205565 ** four coordinates and where each coordinate is itself a two-value array,
205650 sqlite3_value *pVal, /* The value to decode */
205835 ** This routine returns a negative value for clockwise (CW) polygons.
206231 double y; /* Current y value */
206232 float y0; /* Initial y value */
206521 ** Determine whether or not P1 and P2 overlap. Return value:
206927 ** argv[2] = new value for _shape
206928 ** argv[3] = new value for first application-defined column....
206976 /* If a rowid value was supplied, check if it is already present in
206993 /* If aData[0] is not an SQL NULL value, it is the rowid of a
207701 ** of the locale to use. Passing an empty string ("") or SQL NULL value
207794 assert(!"Unexpected return value from ucol_strcoll()");
208379 ** not function like a primary key value cannot be updated using RBU. For
208404 ** with the "rbu_control" column set to contain integer value 0. The
208409 ** possible to insert a NULL value into the IPK column. Attempting to
208414 ** with the "rbu_control" column set to contain integer value 1. The
208421 ** with the "rbu_control" column set to contain a value of type text.
208424 ** the new values of all columns being update. The text value in the
208430 ** rbu_control value should be set to '.'. For example, given the tables
208439 ** Instead of an 'x' character, characters of the rbu_control value specified
208441 ** target table with the value stored in the corresponding data_% column, the
208444 ** original value currently stored in the target table column and the
208445 ** value specified in the data_xxx table.
208457 ** to be a "fossil delta" - a patch to be applied to a blob value in the
208459 ** the existing value within the target database table must be of type BLOB.
208464 ** KEY, the rbu_control value should not include a character corresponding
208465 ** to the rbu_rowid value. For example, this:
208551 ** If the zState argument is passed a NULL value, the RBU extension stores
208560 ** value as when the RBU update was started.
208607 ** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
208630 ** In all cases the returned value is the current limit in bytes (zero
208685 ** Once a call to sqlite3rbu_step() has returned a value other than
208687 ** that immediately return the same value.
208724 ** Return the total number of key-value operations (inserts, deletes or
208746 ** to a value between 0 and 10000 to indicate the permyriadage progress of
208747 ** stage 2. A value of 5000 indicates that stage 2 is half finished,
208752 ** value to which (*pnOne) is set depends on whether or not the RBU
208767 ** table exists but is not correctly populated, the value of the *pnOne
208967 ** Valid if STAGE==1. The current change-counter cookie value in the
209082 int eType; /* Table type - an RBU_PK_XXX value */
209151 ** If the RBU database contains an rbu_count table, this value is set to
209184 ** first pass of each source table. The updated nPhaseOneStep value is
209211 u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */
209259 u32 iCookie; /* Cookie value for main db files */
209260 u8 iWriteVer; /* "write-version" value for main db files */
209554 ** of the value returned by sqlite3_reset().
209618 pIter->eType = 0; /* Invalid value */
210602 ** the text ", old._rowid_" to the returned value.
210682 ** is something wrong with the rbu_control value in the rbu_control value
210688 p->zErrmsg = sqlite3_mprintf("invalid rbu_control value");
211397 const char *zMask, /* rbu_control value ('x.x.') */
212088 ** point to the text value indicating the columns to update.
212090 ** If the rbu_control field contains an invalid value, an error code and
212095 int res = 0; /* Return value */
212275 /* Bind the rbu_rowid value to column _rowid_ */
212325 ** value stored in the RBU_STATE_STAGE column is eStage. All other values
212384 ** where $val is the value returned by the first PRAGMA invocation.
212386 ** In short, it copies the value of the specified PRAGMA setting from
212861 /* At this point (pTargetFd->iCookie) contains the value of the
213077 ** Return the total number of key-value operations (inserts, deletes or
213239 ** written, the value of the change-counter cookie is stored in
213240 ** rbu_file.iCookie. Similarly, the value of the "write-version"
213426 ** Write an unsigned 32-bit value in big-endian format to the supplied
214224 ** The value of the 'path' column describes the path taken from the
214225 ** root-node of the b-tree structure to each page. The value of the
214228 ** The value of the path for the left-most child page of the root of
214233 ** value. The children of the 451st left-most sibling have paths such
214237 ** six-digit hexadecimal value to the path to the cell they are linked
214405 ** 1 and request the value of that constraint be sent to xFilter. And
214690 ** the current value of pCsr->iPageno.
214924 char *zSql; /* String value of pSql */
214933 /* schema=? constraint is present. Get its value */
215117 ** value must be a BLOB which is the correct page size, otherwise the
215438 zErr = "bad page value";
215658 ** 0x00: Undefined value.
215659 ** 0x01: Integer value.
215660 ** 0x02: Real value.
215661 ** 0x03: Text value.
215662 ** 0x04: Blob value.
215663 ** 0x05: SQL NULL value.
215671 ** A varint containing the number of bytes in the value (encoded using
215673 ** of the text value. There is no nul terminator.
215676 ** A varint containing the number of bytes in the value, followed by
215677 ** a buffer containing the value itself.
215680 ** An 8-byte big-endian integer value.
215683 ** An 8-byte big-endian IEEE 754-2008 real value.
215820 ** Write a varint with value iVal into the buffer at aBuf. Return the
215828 ** Return the number of bytes required to store value iVal as a varint.
215835 ** Read a varint value from aBuf[] into *piVal. Return the number of
215846 ** Read a 64-bit big-endian integer value from buffer aRec[]. Return
215847 ** the value read.
215857 ** Write a 64-bit big-endian integer value to the buffer aBuf[].
215871 ** This function is used to serialize the contents of value pValue (see
215874 ** If it is non-NULL, the serialized form of the value is written to
215884 u8 *aBuf, /* If non-NULL, write serialized value here */
215888 int nByte; /* Size of serialized value in bytes */
215978 ** as a series of unsigned integers. In order to calculate a hash-key value
215983 ** hash_key_value = HASH_APPEND(0, <value 1>);
215984 ** hash_key_value = HASH_APPEND(hash_key_value, <value 2>);
215985 ** hash_key_value = HASH_APPEND(hash_key_value, <value 3>);
215994 ** hash-key value passed as the first. Return the new hash-key value.
216003 ** the hash-key value passed as the first. Return the new hash-key value.
216013 ** hash-key value passed as the first. Return the new hash-key value.
216034 int *piHash, /* OUT: Hash value */
216037 unsigned int h = 0; /* Hash value to return */
216091 ** The buffer that the argument points to contains a serialized SQL value.
216092 ** Return the number of bytes of space occupied by the value (including
216200 ** aRight record contains a value for the column, copy the value from
216201 ** their. Otherwise, if aLeft contains a value, copy it. If neither
216202 ** record contains a value for a given column, then neither does the
216236 ** When this function is called, both *paOne and *paTwo point to a value
216238 ** as to point to the next value in the record.
216240 ** If, when this function is called, *paTwo points to a valid value (i.e.
216241 ** *paTwo[0] is not 0x00 - the "no value" placeholder), a copy of the *paTwo
216243 ** serialized value. Otherwise, a copy of *paOne is returned and *pnVal
216244 ** set to the number of bytes in the value at *paOne. If *paOne points
216245 ** to the "no value" placeholder, *pnVal is set to 1. In other words:
216254 int *pnVal /* OUT: Bytes in returned value */
216378 int eType = *a++; /* Type of value from change record */
216395 /* A SessionChange object never has a NULL value in a PK column */
216672 ** blob each time a NULL value is read from the "idx" column of the
216863 ** includes a NULL value, exit early. Such changes are ignored by the
216897 /* This may fail if SQLite value p contains a utf-16 string that must
217011 sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */
217356 /* Zero the output value in case an error occurs. */
217523 /* The value of SESSION_MAX_BUFFER_SZ is copied from the implementation
217548 ** Append the value passed as the second argument to the buffer passed
217683 ** called. Otherwse, it appends the serialized version of the value stored
217689 sqlite3_stmt *pStmt, /* Handle pointing to row containing value */
217690 int iCol, /* Column to read value from */
217742 ** If all of the old.* values are equal to their corresponding new.* value
218475 ** This function sets the value of the sqlite3_value object passed as the
218481 sqlite3_value *pVal, /* Set the value of this object */
218509 ** is set to point to an sqlite3_value object containing the value read
218510 ** from the corresponding position in the record. If that value is not
218534 int eType = 0; /* Type of value (SQLITE_NULL, TEXT etc.) */
218614 ** large value for nCol may cause nRead to wrap around and become
218642 ** final value of *pnByte is undefined in this case.
218681 ** also allocated or resized according to the new value of p->nCol. The
218954 ** iVal'th value in the old.* record. Or, if that particular value is not
218958 ** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
218963 int iVal, /* Index of old.* value to retrieve */
218964 sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */
218982 ** iVal'th value in the new.* record. Or, if that particular value is not
218986 ** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
218991 int iVal, /* Index of new.* value to retrieve */
218992 sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */
219007 ** they omit all error checking and return a pointer to the requested value.
219018 ** containing the iVal'th value of the conflicting record.
219020 ** If value iVal is out-of-range or some other error occurs, an SQLite error
219025 int iVal, /* Index of conflict record value to fetch */
219086 int rc = SQLITE_OK; /* Return value */
219629 sqlite3_stmt *pStmt, /* Statement to bind value to */
219636 ** the (pVal->z) variable remains as it was or the type of the value is
219652 ** New.* value $i from the iterator is bound to variable ($i+1) of
219682 /* The value in the changeset was "undefined". This indicates a
219703 ** statement pSelect. If any other value is returned, the statement does
219792 ** eType value Value passed to xConflict
219803 ** eType value PK Record found? Value passed to xConflict
219815 ** returned. Or, if the conflict handler returns an invalid value,
221034 ** or "replaced" (0xFF), the old.* value is replaced by the value
221471 ** should be greater than or equal to zero and smaller than the value
221503 ** If the callback function returns any value other than SQLITE_OK, the
221505 ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK.
221552 ** In other words, the same value that would be returned by:
221683 ** returned. If an error occurs, some value other than SQLITE_OK should
221684 ** be returned. In this case, fts5 assumes that the final value of *ppOut
221737 ** If an xToken() callback returns any value other than SQLITE_OK, then
221739 ** immediately return a copy of the xToken() return value. Or, if the
222083 ** attempt to merge together. A value of 1 sets the object to use the
222089 ** The value of the content_rowid= option, if one was specified. Or
222105 ** are ignored. This value is configured using:
222119 int eContent; /* An FTS5_CONTENT value */
222121 char *zContentRowid; /* "content_rowid=" option value */
222122 int bColumnsize; /* "columnsize=" option value (dflt==1) */
222123 int eDetail; /* FTS5_DETAIL_XXX value */
222148 /* Current expected value of %_config table 'version' field */
222183 /* Set the value of a single config attribute */
222323 ** Return a simple checksum value based on the arguments.
222391 ** unique token in the document with an iCol value less than zero. The iPos
222823 ** the value of the %name directive from the grammar. Otherwise, the content
222898 ** value associated with a terminal or non-terminal
222922 ** fts5YY_MAX_SHIFT Maximum value for shift actions
222923 ** fts5YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
222924 ** fts5YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
222928 ** fts5YY_MIN_REDUCE Minimum value for reduce actions
222929 ** fts5YY_MAX_REDUCE Maximum value for reduce actions
222991 ** functions that take a state number and lookahead value and return an
223116 ** + The value of the token stored at this level of the stack.
223119 ** + The semantic value stored at this level of the stack. This is
223129 fts5YYCODETYPE major; /* The major token value. This is the code
223131 fts5YYMINORTYPE minor; /* The user-supplied minor token value. This
223132 ** is the value of the token */
223357 /* The following function deletes the "minor type" or semantic value
223360 ** a pointer to the value to be deleted. The code used to do the
224059 sqlite3Fts5ParserFTS5TOKENTYPE fts5yyminor /* The value for the token */
224118 ** enough on the stack to push the LHS value */
224404 char *zOut; /* Output value */
224412 ** If *pRc is set to any value other than SQLITE_OK when this function is
224645 ** Return the value in pVal interpreted as utf-8 text. Except, if pVal
224646 ** contains a NULL value, return a pointer to a static string zero
224926 double score = 0.0; /* SQL function return value */
225036 ** Encode value iVal as an SQLite varint and append it to the buffer object
225356 /* Calculate a hash value for this term. This is the same hash checksum
225522 ** finished. Or, if it is a floating point value, it may continue
225544 ** If the close-quote is found, the value returned is the byte offset of
226112 ** If the callback returns a non-zero value the tokenization is abandoned
226119 ** because the callback returned another non-zero value, it is assumed
227044 ** The return value is undefined in both these cases.
227141 ** Advance iterator pIter until it points to a value equal to or laster
227142 ** than the initial value of *piLast. If this means the iterator points
227143 ** to a value laster than *piLast, update *piLast to the new lastest value.
227147 ** are set, return a non-zero value. Otherwise, return zero.
227317 ** If pExpr is an ASC iterator, this function returns a value with the
227847 ** parameter is passed a non-zero value, iteration is in descending rowid
228326 ** a new colset object containing the contents of (p) with new value column
229513 i16 iCol; /* Column of last value written */
229514 int iPos; /* Position of last value written */
229515 i64 iRowid; /* Rowid of last value written */
229679 ** of bByte and (pToken/nToken). The value is (iRowid/iCol/iPos).
229683 ** Or, if iCol is negative, then the value is a delete marker.
229802 /* Append a new column value, if necessary */
230077 ** of a single 32-bit configuration cookie value followed by a list of
230080 ** the same cookie value.
230087 ** + value of write counter.
230101 ** The first value is the number of rows in the index. Then, for each column
230164 ** within the page, delta-compressed against the previous value. In
230174 ** is stored as a literal value:
230351 int iPrevPgidx; /* Previous value written into pgidx */
230359 i64 iPrev; /* Previous rowid value written to page */
230900 int *piCookie, /* Configuration cookie value */
230911 /* Grab the cookie value */
231184 int iCookie; /* Cookie value to store */
231637 ** position-list size field. Read the value of the field and store it
231695 ** "nSuffix" field of a term. Function parameter nKeep contains the value
232673 ** If the returned value is non-zero, then it is the index of an entry
232767 ** past rowid iFrom. Regardless of the value of iFrom, the iterator is
233081 /* Search through to find the first varint with value 1. This is the
234083 ** rowid-pointer in the page-header. Also append a value to the dlidx
234203 ** optimization over binding the same value over and over as rows are
234360 int nPos; /* position-list size field value */
234508 u64 nWrite; /* Initial value of write-counter */
235097 ** number will be larger on disk than the literal integer value
235102 ** (the value PoslistNext64() uses for EOF) as a position and appending
235519 ** unique token in the document with an iCol value less than zero. The iPos
235754 ** Set the 32-bit cookie value stored at the start of all structure
235755 ** records to the value passed as the second argument.
235795 ** Return a simple checksum value based on the arguments.
235865 u64 *pCksum /* IN/OUT: Checksum value */
236447 ** after either the input buffer is exhausted or a 0 value is read.
236449 ** The return value is the number of bytes read from the input buffer.
236469 ** The return value is the number of bytes read from the input buffer.
236650 int iPgidxPrev = 0; /* Previous value read from pgidx */
236964 ** the value of which is the offset within aPoslist[] following the last
237002 int ePlan; /* FTS5_PLAN_XXX value */
237069 void *pPtr; /* Pointer value */
238337 ** Argument pVal is the value assigned to column "fts" by the INSERT
238484 ** any conflict on the rowid value must be detected before any
239296 ** This is the xColumn method, called by SQLite to request a value from
239300 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
239302 int iCol /* Index of column to read value from */
239318 /* User is requesting the value of the special column with the same name
239319 ** as the table. Return the cursor integer id number. This value is only
239325 /* The value of the "rank" column. */
240118 int szCol; /* Size of column value in tokens */
240218 i64 iRowid, /* id value */
240219 Fts5Buffer *pBuf /* sz value */
240425 ** a NULL value is inserted into the rowid column. The new rowid is allocated
241221 ** Return true if the p->aiException[] array contains the value iCode.
242454 ** The results are undefined if the value passed to this function
243219 ** Return the number of bytes read. The value is stored in *v.
243484 ** One row for each term/column combination. The value of $doc is set to
243492 ** One row for each term in the database. The value of $doc is set to
243538 i64 rowid; /* This table's current rowid value */
243539 Fts5Buffer term; /* Current value of 'term' column */
243555 ** Bits for the mask used as the idxNum value by xBestIndex/xFilter.
243565 ** value and return SQLITE_OK. Otherwise, set *pzErr to an error message
244145 sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
244147 int iCol /* Index of column to read value from */
244299 sqlite3_int64 iRowid; /* Rowid value */
244448 ** rowid is the same as the output value.
245862 CODEC_STATIC void sqlite3CodecReturnPragmaResult(Parse *parse, const char *label, const char *value){
245866 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, value, 0);