Lines Matching +full:100 +full:base +full:- +full:fx
17 ** language. The code for the "sqlite3" command-line shell is also in a
20 ** The content in this amalgamation comes from Fossil check-in
51 ** NO_TEST - The branches on this line are not
56 ** OPTIMIZATION-IF-TRUE - This branch is allowed to always be false
60 ** OPTIMIZATION-IF-FALSE - This branch is allowed to always be true
64 ** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread
69 ** slash-asterisk...asterisk-slash comment marks, with no spaces between the
144 ** 2015-03-02
182 ** large file support, or if the OS is windows, these should be no-ops.
188 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
197 ** on 2008-11-28.) These days, all Linux kernels support large files, so
214 ** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
221 ** so the GCC_VERSION macro will be set to a correct non-zero value even
274 ** some MinGW-specific macros). When compiling for MinGW, either the
297 /* Optionally #include a user-defined header, whereby compilation options
315 ** 2001-09-15
326 ** presents to client programs. If a C-function, structure, datatype,
337 ** The official C-language API documentation for SQLite is derived
382 ** that require non-default calling conventions.
407 ** These no-op macros are used in front of interfaces to mark those
409 ** should not use deprecated interfaces - they are supported for backwards
433 ** CAPI3REF: Compile-Time Library Version Numbers
449 ** <a href="http://www.fossil-scm.org/">Fossil configuration management
451 ** a string which identifies a particular check-in of SQLite
453 ** string contains the date and time of the check-in (UTC) and a SHA1
454 ** or SHA3-256 hash of the entire source tree. If the source code has
464 #define SQLITE_SOURCE_ID "2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c60e…
467 ** CAPI3REF: Run-Time Library Version Numbers
504 ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
513 ** returning the N-th compile time option string. ^If N is out of range,
538 ** [SQLITE_THREADSAFE] compile-time option being set to 0.
556 ** This interface only reports on the compile-time mutex setting
562 ** sqlite3_threadsafe() function shows only the compile-time setting of
563 ** thread safety, not any run-time changes to that setting made by
588 ** CAPI3REF: 64-Bit Integer Types
591 ** Because there is no cross-platform way to specify 64-bit integer types
592 ** SQLite includes typedefs for 64-bit signed and unsigned integers.
599 ** between -9223372036854775808 and +9223372036854775807 inclusive. ^The
622 ** substitute integer for floating-point.
664 ** argument is a harmless no-op.
677 ** CAPI3REF: One-Step Query Execution Interface
685 ** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
686 ** semicolon-separate SQL statements passed into its 2nd argument,
708 ** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
760 /* beginning-of-error-codes */
789 #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */
791 /* end-of-error-codes */
799 ** these result codes are too coarse-grained. They do not provide as
905 ** [sqlite3_open_v2()] has historically be a no-op and might become an
961 ** read-only media and cannot be changed even by processes with
1023 ** (Third-party VFS implementations might also make the distinction
1058 ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
1082 ** requested lock, then the call to xLock() is a no-op.
1085 ** to xUnlock() is a no-op.
1098 ** locking strategy (for example to use dot-file locks), to inquire
1100 ** core reserves all opcodes less than 100 for its own use.
1101 ** A [file control opcodes | list of opcodes] less than 100 is available.
1103 ** greater than 100 to avoid conflicts. VFS implementations should
1145 ** fails to zero-fill short reads might seem to work. However,
1146 ** failure to zero-fill short reads will eventually lead to
1202 ** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that
1204 ** of the in-memory database. The argument is a pointer to a [sqlite3_int64].
1214 ** point to an integer (type int) containing the new chunk-size to use
1216 ** chunks (say 1MB at a time), may reduce file-system fragmentation and
1227 ** the [rollback journal] or the [write-ahead log]) for a particular database
1240 ** this file-control is NULL. However, if the database file is being synced
1241 ** as part of a multi-database commit, the argument points to a nul-terminated
1242 ** string containing the transactions super-journal file name. VFSes that
1259 ** anti-virus programs. By default, the windows VFS will retry file read,
1285 ** WAL mode. If the integer is -1, then it is overwritten with the current
1290 ** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting
1294 ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
1295 ** mode. If the integer is -1, then it is overwritten with the current
1296 ** zero-damage mode setting.
1307 ** final bottom-level VFS are written into memory obtained from
1311 ** all file-control actions, there is no guarantee that this will actually
1313 ** pointer in case this file-control is not implemented. This file-control
1317 ** ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level
1321 ** to a pointer to the top-level VFS.)^
1323 ** upper-most shim only.
1340 ** VFS has handled the PRAGMA itself and the parser generates a no-op
1342 ** of the result string if the string is non-NULL.
1348 ** it is able to override built-in [PRAGMA] statements.
1352 ** file-control may be invoked by SQLite on the database file handle
1354 ** to the connection's busy-handler callback. The argument is of type (void**)
1355 ** - an array of two (void *) values. The first (void *) actually points
1357 ** busy-handler, this function should be invoked with the second (void *) in
1358 ** the array as the only argument. If it returns non-zero, then the operation
1363 ** ^Applications can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control
1373 ** maximum number of bytes that will be used for memory-mapped I/O.
1379 ** file-control is used internally to implement [PRAGMA mmap_size].
1385 ** The argument is a zero-terminated string. Higher layers in the
1387 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
1412 ** Applications should <em>not</em> use this file-control.
1461 ** The parameter is a pointer to a 32-bit signed integer that contains
1462 ** the value that M is to be set to. Before returning, the 32-bit signed
1467 ** a database file. The argument is a pointer to a 32-bit unsigned integer.
1493 ** file to the database file, but before the *-shm file is updated to
1498 ** whether or not there is a database client in another process with a wal-mode
1500 ** (void*) argument passed with this file-control should be a pointer to a
1504 ** the database is not a wal-mode db, or if there is no such connection in any
1514 ** database is not a temp db, then the [SQLITE_FCNTL_RESET_CACHE] file-control
1515 ** purges the contents of the in-memory page cache. If there is an open
1516 ** transaction, or if the db is a temp-db, this opcode is a no-op, not an error.
1594 ** as a normal, nul-terminated, UTF-8 buffer containing the filename, but
1637 ** in a thread-safe way. The [sqlite3_vfs_find()] interface
1655 ** consist of a single "-" character followed by no more than
1656 ** 11 alphanumeric and/or "-" characters.
1671 ** If xOpen() opens a file read-only then it sets *pOutFlags to
1691 ** the open of a journal file a no-op. Writes to this journal would
1692 ** also be no-ops, and any attempt to read the journal would return
1694 ** file will be doing page-aligned sector reads and writes in a random
1733 ** flag is never actually used and is not implemented in the built-in
1736 ** non-zero error code if there is an I/O error or if the name of
1738 ** is returned, then non-zero or zero is written into *pResOut to indicate
1752 ** of good-quality randomness into zOut. The return value is
1760 ** a 24-hour day).
1786 void *pAppData; /* Pointer to application-specific data */
1896 ** are harmless no-ops.)^
1901 ** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
1924 ** compile-time option, then the automatic calls to sqlite3_initialize()
1933 ** The sqlite3_os_init() routine does operating-system specific
1949 ** (using the [SQLITE_OS_OTHER=1] compile-time
1951 ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied
1989 ** implementation of an application-defined [sqlite3_os_init()].
1993 ** then this routine returns a non-zero [error code].
2007 ** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
2020 ** and low-level memory allocation routines.
2032 ** Note that SQLite comes with several [built-in memory allocators]
2037 ** memory allocator that simulates memory out-of-memory conditions in
2104 ** [sqlite3_shutdown()] is a no-op that returns SQLITE_MISUSE.
2119 ** non-zero [error code] if a discontinued or unsupported configuration option
2125 ** [threading mode] to Single-thread. In other words, it disables
2128 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2130 ** value of Single-thread and so [sqlite3_config()] will return
2136 ** [threading mode] to Multi-thread. In other words, it disables
2140 ** are enabled so that SQLite will be safe to use in a multi-threaded
2143 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2144 ** it is not possible to set the Multi-thread [threading mode] and
2159 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2168 ** alternative low-level memory allocation routines to be used in place of
2196 ** disabled, the following SQLite interfaces become non-operational:
2217 ** This configuration option is a no-op if an application-defined page
2220 ** 8-byte aligned memory (pMem), the size of each page cache line (sz),
2228 ** argument must be either a NULL pointer or a pointer to an 8-byte
2235 ** ^If pMem is NULL and N is non-zero, then each database connection
2238 ** of -1024*N bytes if N is negative, . ^If additional
2251 ** An 8-byte aligned pointer to the memory,
2258 ** The first pointer (the memory pointer) must be aligned to an 8-byte
2266 ** The argument specifies alternative low-level mutex routines to be used
2270 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2283 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2316 ** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
2318 ** passed through as the first parameter to the application-defined logger
2326 ** In a multi-threaded application, the application-defined logger
2331 ** If non-zero, then URI handling is globally enabled. If the parameter is zero,
2348 ** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
2349 ** if that compile-time option is omitted.
2359 ** They are retained for backwards compatibility but are now no-ops.
2365 ** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
2381 ** <dd>^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values
2388 ** compile-time maximum mmap size set by the
2389 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
2391 ** changed to its compile-time default.
2396 ** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro
2397 ** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
2413 ** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched
2422 ** becomes the [statement journal] spill-to-disk threshold.
2425 ** Or if the threshold is -1, statement journals are always held
2431 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
2436 ** of type (int) - the new value of the sorter-reference size threshold.
2440 ** of a table column that its values are likely to be very large - larger
2441 ** than the configured sorter-reference size threshold - then a reference
2447 ** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
2452 ** [sqlite3_int64] parameter which is the default maximum size for an in-memory
2455 ** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this
2457 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that
2458 ** compile-time option is not set, then the default maximum is 1073741824.
2464 ** compiled with -DSQLITE_ALLOW_ROWID_IN_VIEW, in which case the capability
2472 ** is compiled without -DSQLITE_ALLOW_ROWID_IN_VIEW (which is the usual and
2490 #define SQLITE_CONFIG_PCACHE 14 /* no-op */
2491 #define SQLITE_CONFIG_GETPCACHE 15 /* no-op */
2518 ** non-zero [error code] if a discontinued or unsupported configuration option
2534 ** must be aligned to an 8-byte boundary. ^If the second argument to
2570 ** triggers in the main database schema or in the schemas of ATTACH-ed
2587 ** views in the main database schema or in the schemas of ATTACH-ed
2594 ** [FTS3] full-text search engine extension.
2609 ** C-API [sqlite3_load_extension()] and the SQL function [load_extension()].
2611 ** When the first argument to this interface is 1, then only the C-API is
2613 ** this interface is 0, then both the C-API and the SQL function are disabled.
2614 ** If the first argument is -1, then no changes are made to state of either the
2615 ** C-API or the SQL function.
2638 ** is an integer - positive to disable checkpoints-on-close, or zero (the
2641 ** into which is written 0 or 1 to indicate whether checkpoints-on-close
2642 ** have been disabled - 0 if they are not disabled, 1 if they are.
2665 ** behavior. The first parameter passed to this operation is an integer -
2669 ** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if
2727 ** behaves as it did prior to [version 3.24.0] (2018-06-04). See the
2736 ** the legacy [double-quoted string literal] misfeature for DML statements
2738 ** default value of this setting is determined by the [-DSQLITE_DQS]
2739 ** compile-time option.
2745 ** the legacy [double-quoted string literal] misfeature for DDL statements,
2747 ** default value of this setting is determined by the [-DSQLITE_DQS]
2748 ** compile-time option.
2775 ** created database file to have a schema format version number (the 4-byte
2802 ** an integer.. The first argument is 1, 0, or -1 to enable, disable, or
2817 ** argument is 1, 0, or -1 to enable, disable, or leave unchanged the
2863 ** has a unique 64-bit signed
2944 ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
2966 ** any changes performed by sub-triggers, as the sqlite3_changes()
2967 ** value will be saved and restored after each sub-trigger has run.)^
3035 ** CAPI3REF: Interrupt A Long-Running Query
3041 ** or Ctrl-C where the user wants a long query operation to halt
3066 ** SQL statements is a no-op and has no effect on SQL statements
3079 ** These routines are useful during command-line input to determine if the
3085 ** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within
3100 ** then the return value from sqlite3_complete16() will be non-zero
3103 ** The input to [sqlite3_complete()] must be a zero-terminated
3104 ** UTF-8 string.
3106 ** The input to [sqlite3_complete16()] must be a zero-terminated
3107 ** UTF-16 string in native byte order.
3114 ** KEYWORDS: {busy-handler callback} {busy handler}
3136 ** ^If the callback returns non-zero, then another attempt
3212 ** A result table is an array of pointers to zero-terminated UTF-8 strings.
3214 ** to zero-terminated strings that contain the names of the columns.
3216 ** in NULL pointers. All other values are in their UTF-8 zero-terminated
3228 ** -----------------------
3250 ** semicolon-separated SQL statements in the zero-terminated UTF-8
3282 ** These routines are work-alikes of the "printf()" family of functions
3286 ** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]).
3287 ** See the [built-in printf()] documentation for details.
3310 ** guarantees that the buffer is always zero-terminated. ^The first
3313 ** written will be n-1 characters.
3317 ** See also: [built-in printf()], [printf() SQL function]
3329 ** does not include operating-system specific [VFS] implementation. The
3340 ** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead
3341 ** of a signed 32-bit integer.
3346 ** a no-op if is called with a NULL pointer. Passing a NULL pointer
3351 ** might result if sqlite3_free() is called with a non-NULL pointer that
3371 ** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead
3372 ** of a 32-bit signed integer.
3387 ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
3411 ** routines, which form the built-in memory allocation subsystem.
3416 ** value of [sqlite3_memory_used()] since the high-water mark
3423 ** ^The memory high-water mark is reset to the current value of
3426 ** by [sqlite3_memory_highwater(1)] is the high-water mark
3433 ** CAPI3REF: Pseudo-Random Number Generator
3435 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
3438 ** the built-in random() and randomblob() SQL functions. This interface allows
3449 ** non-NULL P then the pseudo-randomness is generated
3456 ** CAPI3REF: Compile-Time Authorization Callbacks
3487 ** to the callback are either NULL pointers or zero-terminated strings
3515 ** user-entered SQL is being [sqlite3_prepare | prepared] that
3534 ** statement might be re-prepared during [sqlite3_step()] due to a
3580 ** is the name of the inner-most trigger or view that is responsible for
3582 ** top-level SQL code.
3632 ** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
3636 ** contain a UTF-8 SQL comment that identifies the trigger.)^
3638 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
3643 ** the original statement text and an estimate of wall-clock time
3663 ** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of
3685 ** interface by using the X argument when X begins with "--" and invoking
3692 ** X argument points to a 64-bit integer which is approximately
3722 ** M argument should be the bitwise OR-ed combination of
3774 ** ^If the progress callback returns non-zero, the operation is
3798 ** filename argument. ^The filename argument is interpreted as UTF-8 for
3799 ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
3810 ** ^The default encoding will be UTF-8 for databases created using
3812 ** created using sqlite3_open16() will be UTF-16 in the native byte order.
3826 ** <dd>The database is opened in read-only mode. If the database does
3834 ** read-write mode fails due to OS-level permissions, an attempt is
3835 ** made to open it in read-only mode. [sqlite3_db_readonly()] can be
3837 ** read-write.</dd>)^
3853 ** <dd>The database will be opened as an in-memory database. The database
3854 ** is named by the "filename" argument for the purposes of cache-sharing,
3859 ** <dd>The new database connection will use the "multi-thread"
3877 ** this option is a no-op.
3903 ** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op
3914 ** ^If the filename is ":memory:", then a private, temporary in-memory database
3915 ** is created for the connection. ^This in-memory database will vanish when
3923 ** on-disk database will be created. ^This private database will be
3933 ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
3956 ** SQLite and its built-in [VFSes] interpret the
3971 ** ^If "ro" is specified, then the database is opened for read-only
3974 ** "rw", then the database is opened for read-write (but not create)
3978 ** set to "memory" then a pure [in-memory database] that never reads
4005 ** read-only media. ^When immutable is set, SQLite assumes that the
4007 ** privilege, and so the database is opened read-only and all locking
4032 ** <tr><td style="white-space:nowrap">
4036 ** necessary - space characters can be used literally
4039 ** Open file "data.db" in the current directory for read-only access.
4040 ** Regardless of whether or not shared-cache mode is enabled by
4042 ** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
4043 ** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
4044 ** that uses dot-files in place of posix advisory locking.
4052 ** percent sign - "%" - followed by exactly two hexadecimal digits
4054 ** URI filename are interpreted, they are encoded using UTF-8 and all
4056 ** corresponding octet. If this process generates an invalid UTF-8 encoding,
4060 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
4062 ** characters must be converted to UTF-8 prior to passing them into
4072 const char *filename, /* Database filename (UTF-8) */
4076 const void *filename, /* Database filename (UTF-16) */
4080 const char *filename, /* Database filename (UTF-8) */
4117 ** case or if the value begins with a non-zero number. The
4125 ** 64-bit signed integer and returns that integer, or D if P does not
4130 ** the value) of the N-th query parameter for filename F, or a NULL
4132 ** parameters minus 1. The N value is zero-based so N should be 0 to obtain
4191 ** ^If X is the name of a rollback or WAL-mode journal file that is
4197 ** only. It is not a general-purpose interface.
4241 ** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op.
4277 ** change the value of the error code. The error-code preserving
4288 ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
4289 ** text that describes the error, as either UTF-8 or UTF-16 respectively,
4297 ** ^The sqlite3_errstr(E) interface returns the English-language text
4298 ** that describes the [result code] E, as UTF-8, or NULL if E is not an
4308 ** SQL, then the sqlite3_error_offset() function returns -1.
4343 ** The life-cycle of a prepared statement object usually goes like this:
4358 ** CAPI3REF: Run-time Limits
4371 ** set at compile-time by a C preprocessor macro called
4380 ** simply invoke this interface with the third parameter set to -1.
4382 ** Run-time limits are intended for use in applications that manage
4395 ** New run-time limit categories may be added in future releases.
4400 ** CAPI3REF: Run-Time Limit Categories
4404 ** that can be lowered at run-time using [sqlite3_limit()].
4490 ** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
4513 ** To execute an SQL statement, it must first be compiled into a byte-code
4522 ** The use of the UTF-8 interfaces is preferred, as SQLite currently
4523 ** does all parsing using UTF-8. The UTF-16 interfaces are provided
4524 ** as a convenience. The UTF-16 interfaces work by converting the
4525 ** input text into UTF-8, then invoking the corresponding UTF-8 interface.
4532 ** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(),
4534 ** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(),
4535 ** and sqlite3_prepare16_v3() use UTF-16.
4541 ** If the caller knows that the supplied string is nul-terminated, then
4544 ** the nul-terminator.
4594 ** ^The specific value of a WHERE-clause [parameter] might influence the
4595 ** choice of query plan if the parameter is the left-hand side of a [LIKE]
4597 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
4609 const char *zSql, /* SQL statement, UTF-8 encoded */
4616 const char *zSql, /* SQL statement, UTF-8 encoded */
4623 const char *zSql, /* SQL statement, UTF-8 encoded */
4631 const void *zSql, /* SQL statement, UTF-16 encoded */
4638 const void *zSql, /* SQL statement, UTF-16 encoded */
4645 const void *zSql, /* SQL statement, UTF-16 encoded */
4656 ** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8
4660 ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
4663 ** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8
4679 ** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of
4680 ** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time
4691 ** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined.
4703 ** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
4707 ** Note that [application-defined SQL functions] or
4711 ** change the database file through side-effects:
4737 ** makes it a no-op, but the sqlite3_stmt_readonly() result would still
4739 ** read-only no-op if the table already exists, but
4799 ** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
4836 ** sqlite3_value object. If SQLite is compiled to be single-threaded
4847 ** implementation of [application-defined SQL functions] are protected.
4865 ** is always first parameter to [application-defined SQL functions].
4866 ** The application-defined SQL function implementation will pass this
4916 ** it should be a pointer to well-formed UTF8 text.
4918 ** it should be a pointer to well-formed UTF16 text.
4920 ** it should be a pointer to a well-formed unicode string that is
4924 ** [[byte-order determination rules]] ^The byte-order of
4925 ** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)
4942 ** If a non-negative fourth parameter is provided to sqlite3_bind_text()
4982 ** ^A negative value for the zeroblob results in a zero-length BLOB.
4984 ** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in
5056 ** the name of the N-th [SQL parameter] in the [prepared statement] P.
5067 ** ^If the value N is out of range or if the N-th parameter is
5069 ** always in UTF-8 encoding even if the named parameter was
5070 ** originally specified as UTF-16 in [sqlite3_prepare16()],
5087 ** name must be given in UTF-8 even if the original statement
5088 ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or
5129 ** interface returns a pointer to a zero-terminated UTF-8 string
5130 ** and sqlite3_column_name16() returns a pointer to a zero-terminated
5131 ** UTF-16 string. ^The first parameter is the [prepared statement]
5142 ** (for example during a conversion from UTF-8 to UTF-16) then a
5161 ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
5170 ** ^The names returned are the original un-aliased names of the
5176 ** ^The left-most column is column 0 for these routines.
5185 ** UTF-16 encoded strings and the other functions return UTF-8.
5188 ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
5212 ** ^The returned string is always UTF-8 encoded.
5225 ** ^SQLite uses dynamic run-time typing. ^So just because a column
5275 ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
5301 ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
5331 ** will return non-zero if previous call to [sqlite3_step](P) returned
5333 ** where it always returns zero since each step of that multi-step
5347 ** <li> 64-bit signed integer
5348 ** <li> 64-bit IEEE floating point number
5381 ** <tr><td><b>sqlite3_column_int</b><td>→<td>32-bit INTEGER result
5382 ** <tr><td><b>sqlite3_column_int64</b><td>→<td>64-bit INTEGER result
5383 ** <tr><td><b>sqlite3_column_text</b><td>→<td>UTF-8 TEXT result
5384 ** <tr><td><b>sqlite3_column_text16</b><td>→<td>UTF-16 TEXT result
5389 ** or a UTF-8 TEXT result in bytes
5391 ** <td>→ <td>Size of UTF-16
5443 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
5445 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
5446 ** the string to UTF-8 and then returns the number of bytes.
5448 ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
5452 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
5454 ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
5455 ** the string to UTF-16 and then returns the number of bytes.
5457 ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
5468 ** even empty strings, are always zero-terminated. ^The return
5469 ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
5485 ** [application-defined SQL functions] or [virtual tables], not within
5486 ** top-level application code.
5504 ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT
5525 ** sqlite3_column_text16() is called. A zero-terminator might
5527 ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
5529 ** to UTF-16.</li>
5530 ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
5532 ** to UTF-8.</li>
5535 ** ^Conversions between UTF-16be and UTF-16le are always done in place and do
5566 ** fail if an out-of-memory error occurs during a format conversion.
5567 ** Only the following subset of interfaces are subject to out-of-memory
5578 ** If an out-of-memory error occurs, then the return value from these
5580 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
5614 ** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
5629 ** object back to its initial state, ready to be re-executed.
5681 ** connection then application-defined SQL functions must be added
5685 ** redefined. ^The length of the name is limited to 255 bytes in a UTF-8
5686 ** representation, exclusive of the zero-terminator. ^Note that the name
5687 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
5693 ** aggregate takes. ^If this parameter is -1, then the SQL function or
5696 ** parameter is less than -1 or greater than 127 then the behavior is
5715 ** deterministic. The built-in [random()] SQL function is an example of a
5726 ** all application-defined SQL functions that do not need to be
5740 ** pointers to C-language functions that implement the SQL function or
5750 ** C-language callbacks that implement the new function. xStep and xFinal
5751 ** must both be non-NULL. xValue and xInverse may either both be NULL, in
5753 ** non-NULL, in which case the new function may be used as either an aggregate
5756 ** [user-defined window functions|available here].
5771 ** SQL function is used. ^A function implementation with a non-negative
5780 ** ^Built-in functions may be overloaded by new application-defined functions.
5782 ** ^An application-defined function is permitted to call other
5837 #define SQLITE_UTF8 1 /* IMP: R-37514-35566 */
5838 #define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */
5839 #define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */
5866 ** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in
5871 ** [application-defined SQL function]
5872 ** that has side-effects or that could potentially leak sensitive information.
5875 ** modified to invoke the application-defined function in ways that are
5879 ** [application-defined SQL functions], regardless of whether or not they
5883 ** that do not have access to the application-defined functions.
5902 ** the function is tagged with SQLITE_INNOCUOUS. Most built-in functions
5904 ** SQLITE_INNOCUOUS flag for application-defined functions unless the
5906 ** security-adverse side-effects and information-leaks.
5911 ** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5912 ** This flag instructs SQLite to omit some corner-case optimizations that
5918 ** a non-zero subtype was specified by the function argument expression.
5922 ** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
5926 ** might become a no-op if the function is used as term in an
5968 ** <tr><td><b>sqlite3_value_int</b><td>→<td>32-bit INTEGER value
5969 ** <tr><td><b>sqlite3_value_int64</b><td>→<td>64-bit INTEGER value
5971 ** <tr><td><b>sqlite3_value_text</b><td>→<td>UTF-8 TEXT value
5972 ** <tr><td><b>sqlite3_value_text16</b><td>→<td>UTF-16 TEXT value in
5974 ** <tr><td><b>sqlite3_value_text16be</b><td>→<td>UTF-16be TEXT value
5975 ** <tr><td><b>sqlite3_value_text16le</b><td>→<td>UTF-16le TEXT value
5978 ** or a UTF-8 TEXT in bytes
5980 ** <td>→ <td>Size of UTF-16
5998 ** implement [application-defined SQL functions] and [virtual tables].
6008 ** ^The sqlite3_value_text16() interface extracts a UTF-16 string
6009 ** in the native byte-order of the host machine. ^The
6011 ** extract UTF-16 strings as big-endian and little-endian respectively.
6052 ** ^The sqlite3_value_frombind(X) interface returns non-zero if the
6067 ** fail if an out-of-memory error occurs during a format conversion.
6068 ** Only the following subset of interfaces are subject to out-of-memory
6081 ** If an out-of-memory error occurs, then the return value from these
6083 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
6131 ** an [application-defined SQL function] argument V. The subtype
6136 ** Every [application-defined SQL function] that invoke this interface
6157 ** then sqlite3_value_free(V) is a harmless no-op.
6218 ** the application-defined function is running.
6238 ** These functions may be used by (non-aggregate) SQL functions to
6243 ** regular-expression matching function. The compiled version of the regular
6251 ** value to the application-defined function. ^N is zero for the left-most
6257 ** N-th argument of the application-defined function. ^Subsequent
6283 ** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
6289 ** function parameters that are compile-time constants, including literal
6292 ** The value of the N parameter to these interfaces should be non-negative.
6317 ** If P and X are both non-NULL, then the destructor X is invoked with
6320 ** <li> An out-of-memory error occurs during the call to
6376 #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
6392 ** an application-defined function to be the BLOB whose content is pointed
6397 ** interfaces set the result of the application-defined function to be
6401 ** an application-defined function to be a floating point value specified
6409 ** message string from sqlite3_result_error() as UTF-8. ^SQLite
6410 ** interprets the string from sqlite3_result_error16() as UTF-16 using
6411 ** the same [byte-order determination rules] as [sqlite3_bind_text16()].
6416 ** sqlite3_result_error16() is non-negative then SQLite takes that many
6434 ** of the application-defined function to be the 32-bit signed integer
6437 ** of the application-defined function to be the 64-bit signed integer
6441 ** of the application-defined function to be NULL.
6445 ** set the return value of the application-defined function to be
6446 ** a text string which is represented as UTF-8, UTF-16 native byte order,
6447 ** UTF-16 little endian, or UTF-16 big endian, respectively.
6449 ** application-defined function to be a text string in an encoding
6459 ** is non-negative, then as many bytes (not characters) of the text
6460 ** pointed to by the 2nd parameter are taken as the application-defined
6461 ** function result. If the 3rd parameter is non-negative, then it
6468 ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
6484 ** byte-order mark (BOM, U+FEFF) then the BOM is removed from the
6486 ** byte-order specified by the BOM. ^The byte-order specified by
6487 ** the BOM at the beginning of the text overrides the byte-order
6490 ** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the
6501 ** the application-defined function to be a copy of the
6512 ** also associates the host-language pointer P or type T with that
6514 ** [application-defined SQL function] using [sqlite3_value_pointer()].
6522 ** than the one containing the application-defined function that received
6554 ** the result from the [application-defined SQL function] with
6561 ** Every [application-defined SQL function] that invokes this interface
6569 ** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
6572 ** an error. Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
6584 ** ^The name of the collation is a UTF-8 string
6586 ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
6649 ** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should
6692 ** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
6693 ** the names are passed as UTF-16 in machine native byte order.
6694 ** ^A call to either function replaces the existing collation-needed callback.
6760 ** created by SQLite when using a built-in [sqlite3_vfs | VFS]
6802 ** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
6803 ** TemporaryFolder->Path->Data();
6806 ** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
6819 ** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
6858 ** a non-NULL value will be copied into memory obtained from [sqlite3_malloc]
6863 ** the current directory on the sub-platforms of Win32 where that concept is
6867 ** UTF-8 or UTF-16, respectively.
6886 ** CAPI3REF: Test For Auto-Commit Mode
6890 ** ^The sqlite3_get_autocommit() interface returns non-zero or
6894 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
6896 ** If certain kinds of errors occur on a statement within a multi-statement
6927 ** for the N-th database on database connection D, or a NULL pointer of N is
6929 ** the "temp" schema. Larger values of N correspond to various ATTACH-ed
6937 ** remember the string long-term should make their own copy. Applications that
6939 ** threads should mutex-protect calls to this API and should make their own
6951 ** connection D, or if database N is a temporary or in-memory database, then
6956 ** is [DETACH]-ed or until the database connection closes.
6977 ** CAPI3REF: Determine if a database is read-only
6981 ** of connection D is read-only, 0 if it is read/write, or -1 if N is not
7000 ** a valid schema, then -1 is returned.
7066 ** ^If the callback on a commit hook function returns non-zero,
7088 ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
7090 ** hook returning non-zero, just as it would be with any other rollback.
7110 ** the schema-name of the attached database that is being autovacuumed,
7118 ** <p>^If there are multiple ATTACH-ed database files that are being
7239 ** [-DSQLITE_OMIT_SHARED_CACHE]. The [-DSQLITE_OMIT_SHARED_CACHE]
7240 ** compile-time option is recommended because the
7266 ** shared cache mode should be enabled per-database connection via
7270 ** 32-bit integer is atomic.
7272 ** See Also: [SQLite Shared-Cache Mode]
7280 ** of heap memory by deallocating non-essential memory allocations
7282 ** pages to improve performance is an example of non-essential memory.
7285 ** ^The sqlite3_release_memory() routine is a no-op returning zero
7299 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
7334 ** sqlite3_soft_heap_limit64(-1) or sqlite3_hard_heap_limit(-1).
7358 ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
7359 ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
7392 ** interface returns SQLITE_OK and fills in the non-NULL pointers in
7396 ** ^If the column-name parameter to sqlite3_table_column_metadata() is a
7463 int *pAutoinc /* OUTPUT: True if column is auto-increment */
7475 ** with various operating-system specific extensions added.
7484 ** X is consists of the lower-case equivalent of all ASCII alphabetic
7523 ** [extension loading] while evaluating user-entered SQL, the following API
7531 ** ^This interface enables or disables both the C-API
7534 ** to enable or disable only the C-API.)^
7574 ** on the list of automatic extensions is a harmless no-op. ^No entry point
7676 ** inputs to xBestIndex and are read-only. xBestIndex inserts its
7688 ** expr on the right-hand side can be evaluated (and thus the constraint
7703 ** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62),
7709 ** non-zero.
7713 ** the right-hand side of the corresponding aConstraint[] is evaluated
7714 ** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit
7743 ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
7774 int iColumn; /* Column constrained. -1 for ROWID */
7777 int iTermOffset; /* Used internally - xBestIndex should ignore */
7819 ** ^The left-hand operand of the operator is given by the corresponding
7820 ** aConstraint[].iColumn field. ^An iColumn of -1 indicates the left-hand
7823 ** operators have no left-hand operand, and so for those operators the
7832 ** The right-hand operands for each constraint might be accessible using
7833 ** the [sqlite3_vtab_rhs_value()] interface. Usually the right-hand
7835 ** in the input SQL. If the right-hand operand is another column or an
7839 ** SQLITE_INDEX_CONSTRAINT_ISNOTNULL operators have no right-hand operand
7844 ** the [sqlite3_vtab_collation()] interface. For most real-world virtual
8039 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
8041 ** read-only access.
8077 ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
8093 ** and the built-in [zeroblob] SQL function may be used to create a
8094 ** zero-filled blob to read or write using the incremental-blob interface.
8124 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
8146 ** ^If the blob handle being closed was opened for read-write access, and if
8147 ** the database is in auto-commit mode and there are no other open read-write
8155 ** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function
8182 ** caller-supplied buffer. N bytes of data are copied into buffer Z
8211 ** caller-supplied buffer. N bytes of data are copied from the buffer Z
8260 ** ^Names are zero-terminated UTF-8 strings.
8291 ** is selected automatically at compile-time. The following
8302 ** a single-threaded application. The SQLITE_MUTEX_PTHREADS and
8307 ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
8344 ** cases where it really needs one. If a faster non-recursive mutex
8393 ** then any of the four routines behaves as a no-op.
8406 ** An instance of this structure defines the low-level routines
8456 ** xMutexInit() must be no-ops.
8502 ** the routine should return 1. This seems counter-intuitive since
8506 ** call to sqlite3_mutex_held() to fail, so a non-zero return is
8522 ** next. Applications that override the built-in mutex logic must be
8538 #define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */
8553 ** ^If the [threading mode] is Single-thread or Multi-thread then this
8559 ** CAPI3REF: Low-Level Control Of Database Files
8674 ** by enclosing in double-quotes) so as not to confuse the parser.
8679 ** The sqlite3_keyword_name(N,Z,L) interface finds the 0-based N-th keyword and
8682 ** zero-terminated. The sqlite3_keyword_name(N,Z,L) routine returns
8688 ** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero
8700 ** <li> Put all identifier names inside double-quotes. This is the official
8711 ** compile-time options. For example, "VACUUM" is not a keyword if
8712 ** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option. Also,
8723 ** An instance of the sqlite3_str object contains a dynamically-sized
8747 ** valid [sqlite3_str] object, though in the event of an out-of-memory
8787 ** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
8792 ** onto the end of the [sqlite3_str] object X. N must be non-negative.
8793 ** S must contain at least N non-zero bytes of content. To append a
8794 ** zero-terminated string in its entirety, use the [sqlite3_str_appendall()]
8798 ** zero-terminated string S onto the end of [sqlite3_str] object X.
8801 ** single-byte character C onto the end of [sqlite3_str] object X.
8827 ** [SQLITE_NOMEM] following any out-of-memory error, or
8834 ** zero-termination byte.
8869 ** SQLITE_OK on success and a non-zero [error code] on failure.
8872 ** be represented by a 32-bit integer, then the values returned by
8890 ** These integer constants designate various run-time status parameters
8898 ** and internal memory usage by the SQLite library. Auxiliary page-cache
8983 ** non-zero [error code] on failure.
8999 ** The [sqlite3_db_status()] interface will return a non-zero error code
9009 ** satisfied using lookaside memory. Only the high-water value is meaningful;
9017 ** Only the high-water value is meaningful;
9025 ** Only the high-water value is meaningful;
9048 ** with the connection - main, temp, and any [ATTACH]-ed databases.)^
9088 ** to disk all at once. When pages spill mid-transaction, that introduces
9159 ** A non-zero value in this counter may indicate an opportunity to
9165 ** A non-zero value in this counter may indicate an opportunity to
9194 ** step was bypassed because a Bloom filter returned not-found. The
9264 ** The built-in page cache is recommended for most uses.
9279 ** built-in default page cache is used instead of the application defined
9311 ** false if it is used for an in-memory database. The cache implementation
9322 ** suggested maximum cache-size (number of pages stored by) the cache
9368 ** as its second argument. If the third parameter, discard, is non-zero,
9402 ** is not obligated to free any memory, but well-behaved implementations should
9461 ** for copying in-memory databases to or from persistent files.
9467 ** ^The source database is read-locked only while it is being read;
9501 ** there is already a read or read-write transaction open on the
9533 ** <li> the destination database was opened read-only, or
9534 ** <li> the destination database is using write-ahead-log journaling
9536 ** <li> the destination database is an in-memory database and the
9540 ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
9541 ** the [sqlite3_busy_handler | busy-handler function]
9543 ** busy-handler returns non-zero before the lock is available, then
9564 ** sqlite3_backup_step(), the source database may be modified mid-way
9581 ** active write-transaction on the destination database is rolled back.
9588 ** ^If an out-of-memory condition or IO error occurred during any prior
9657 ** ^When running in shared-cache mode, a database operation may fail with
9658 ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
9659 ** individual tables within the shared-cache cannot be obtained. See
9660 ** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
9664 ** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
9668 ** ^Shared-cache locks are released when a database connection concludes
9672 ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
9682 ** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
9688 ** ^If the blocked connection is attempting to obtain a write-lock on a
9689 ** shared-cache table, and more than one other connection currently holds
9690 ** a read-lock on the same table, then SQLite arbitrarily selects one of
9693 ** ^(There may be at most one unlock-notify callback registered by a
9695 ** blocked connection already has a registered unlock-notify callback,
9698 ** unlock-notify callback is canceled. ^The blocked connections
9699 ** unlock-notify callback may also be canceled by closing the blocked
9702 ** The unlock-notify callback is not reentrant. If an application invokes
9703 ** any sqlite3_xxx API functions from within an unlock-notify callback, a
9711 ** When an unlock-notify callback is registered, the application provides a
9715 ** an unlock-notify callback is a pointer to an array of void* pointers,
9719 ** more than one blocked connection that has registered for an unlock-notify
9729 ** Assuming that after registering for an unlock-notify callback a
9740 ** unlock-notify callback is registered. The system is said to be in
9741 ** a deadlocked state if connection A has registered for an unlock-notify
9743 ** B has itself registered for an unlock-notify callback when connection
9746 ** registered for an unlock-notify callback on the conclusion of connection
9758 ** sqlite3_unlock_notify() results in the unlock-notify callback being
9759 ** invoked immediately. If the application then re-attempts the "DROP TABLE"
9779 ** and extensions to compare the contents of two buffers containing UTF-8
9780 ** strings in a case-independent fashion, using the same definition of "case
9796 ** Note that this routine returns zero on a match and non-zero if the strings
9813 ** insensitive - equivalent upper and lower case ASCII characters match
9819 ** Note that this routine returns zero on a match and non-zero if the strings
9843 ** a fixed-length buffer on the stack. If the log message is longer than
9850 ** CAPI3REF: Write-Ahead Log Commit Hook
9857 ** the associated write-lock on the database released)^, so the implementation
9863 ** ^The third parameter is the name of the database that was written to -
9864 ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
9865 ** is the number of pages currently in the write-ahead log file,
9870 ** SQLite code base to cause the statement that provoked the callback
9876 ** A single database handle may have at most a single write-ahead log callback
9878 ** previously registered write-ahead log callback. ^The return value is
9891 ** CAPI3REF: Configure an auto-checkpoint
9898 ** more frames in the [write-ahead log] file. ^Passing zero or
9913 ** ^Every new [database connection] defaults to having the auto-checkpoint
9929 ** [write-ahead log] for database X on [database connection] D to be
9930 ** transferred into the database file and for the write-ahead log to
9956 ** in the log were checkpointed. ^The [busy-handler callback]
9963 ** [sqlite3_busy_handler|busy-handler callback]) until there is no
9972 ** [busy-handler callback])
9985 ** the log file or to -1 if the checkpoint could not run because
9989 ** was called) or to -1 if the checkpoint could not run due to an error or
9997 ** busy-handler configured, it will not be invoked in this case.
10001 ** obtained immediately, and a busy-handler is configured, it is invoked and
10002 ** the writer lock retried until either the busy-handler returns 0 or the lock
10003 ** is successfully obtained. ^The busy-handler is also invoked while waiting for
10004 ** database readers as described above. ^If the busy-handler returns 0 before
10007 ** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
10023 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
10099 ** If X is non-zero, then the virtual table implementation guarantees
10143 ** all schemas ("main", "temp", and any ATTACH-ed databases) whenever the
10174 ** [xUpdate] method understands as a "no-change" value.
10336 ** on the right-hand side of the IN operator.)^ Thus the virtual table
10337 ** only sees a single value from the right-hand side of the IN operator
10341 ** table to see all values on the right-hand of the IN operator all at
10346 ** ^A call to sqlite3_vtab_in(P,N,-1) will return true (non-zero)
10347 ** if and only if the [sqlite3_index_info|P->aConstraint][N] constraint
10349 ** sqlite3_vtab_in() with -1 in the third argument is a mechanism
10350 ** by which the virtual table can ask SQLite if all-at-once processing
10356 ** the IN operator all-at-once, respectively. ^Thus when the third
10357 ** parameter (F) is non-negative, this interface is the mechanism by
10366 ** (non-zero), that means that the constraint is an IN operator
10367 ** that can be processed all-at-once. ^If the constraint is not an IN
10368 ** operator or cannot be processed all-at-once, then the interface returns
10371 ** ^(All-at-once processing of the IN operator is selected if both of the
10375 ** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
10377 ** use the N-th constraint.
10380 ** non-negative had F>=1.
10384 ** the traditional one-at-a-time processing strategy for the IN constraint.
10385 ** ^If both conditions are true, then the argvIndex-th parameter to the
10388 ** [sqlite3_vtab_in_next()] to find all values on the right-hand side
10394 ** CAPI3REF: Find all elements on the right-hand side of an IN constraint.
10404 ** a parameter that was previously selected for all-at-once IN constraint
10407 ** an xFilter argument that was selected for all-at-once IN constraint
10410 ** ^(Use these routines to access all values on the right-hand side
10452 ** J being a 0-based index into P->aConstraint[], then this routine
10453 ** attempts to set *V to the value of the right-hand operand of
10454 ** that constraint if the right-hand operand is known. ^If the
10455 ** right-hand operand is not known, then *V is set to a NULL pointer.
10458 ** inteface returns SQLITE_NOTFOUND if the right-hand side of the J-th
10464 ** the right-hand operand of a constraint is a literal value in the original
10465 ** SQL statement. If the right-hand operand is an expression or a reference
10470 ** [SQLITE_INDEX_CONSTRAINT_ISNOTNULL], have no right-hand operand. For such
10479 ** "Right-Hand Side".
10514 ** not available, the output variable is set to -1 if the value is numeric,
10520 ** set to the total number of times that the X-th loop has run.</dd>
10524 ** to the total number of rows examined by all iterations of the X-th loop.</dd>
10529 ** iteration of the X-th loop. If the query planner's estimates was accurate,
10536 ** to a zero-terminated UTF-8 string containing the name of the index or table
10537 ** used for the X-th loop.
10541 ** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
10542 ** description for the X-th loop.
10546 ** id for the X-th query plan element. The id value is unique within the
10547 ** statement. The select-id is the same value as is output in the first
10558 ** according to the processor time-stamp counter, that elapsed while the
10560 ** all query elements - if it is unavailable the output variable is
10561 ** set to -1.
10584 ** compile-time option.
10592 ** one flag is defined - SQLITE_SCANSTAT_COMPLEX. If SQLITE_SCANSTAT_COMPLEX
10602 ** for. Query elements are numbered starting from zero. A value of -1 may be
10604 ** - less than -1 or greater than or equal to the total number of query
10605 ** elements used to implement the statement - a non-zero value is returned and
10631 ** CAPI3REF: Zero Scan-Status Counters
10636 ** This API is only available if the library is built with pre-processor
10642 ** CAPI3REF: Flush caches to disk mid-transaction
10645 ** ^If a write-transaction is open on [database connection] D when the
10647 ** pages in the pager-cache that are not currently in use are written out
10651 ** interface flushes caches for all schemas - "main", "temp", and
10656 ** immediately and there is a busy-handler callback configured, it is invoked
10664 ** example an IO error or out-of-memory condition), then processing is
10675 ** CAPI3REF: The pre-update hook.
10679 ** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option.
10755 ** operation; or 1 for inserts, updates, or deletes invoked by top-level
10756 ** triggers; or 2 for changes resulting from triggers called by top-level
10760 ** the pre-update hook is invoked with SQLITE_DELETE. This is because the
10765 ** pre-update hook is being invoked for some other reason, including a
10766 ** regular DELETE, sqlite3_preupdate_blobwrite() returns -1.
10792 ** CAPI3REF: Low-level system error code
10797 ** The return value is OS-dependent. For example, on unix systems, after
10837 ** If there is not already a read-transaction open on schema S when
10869 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10903 ** is returned. If another error code - for example SQLITE_PROTOCOL or an
10904 ** SQLITE_IOERR error code - is returned, then the final state of the
10918 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10935 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
11002 ** For an ordinary on-disk database file, the serialization is just a
11003 ** copy of the disk file. For an in-memory database or a "TEMP" database,
11047 ** Zero or more of the following constants can be OR-ed together for
11051 ** a pointer to contiguous in-memory database that it is currently using,
11053 ** a contiguous in-memory database, then this option causes
11055 ** using a contiguous in-memory database if it has been initialized by a
11065 ** reopen S as an in-memory database based on the serialization contained
11069 ** permitted to add content to the in-memory database as long as the total
11131 ** should be treated as read-only.
11135 #define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */
11188 /* The double-precision datatype used by RTree depends on the
11189 ** SQLITE_RTREE_INT_ONLY compile-time option.
11199 ** R-Tree geometry query as follows:
11224 ** Register a 2nd-generation geometry callback named zScore that can be
11225 ** used as part of an R-Tree geometry query as follows:
11331 ** is not possible for an application to register a pre-update hook on a
11334 ** which a pre-update hook is already defined. The results of attempting
11415 ** disabled - it does not. A newly created session object is enabled.
11422 ** no-op, and may be used to query the current state of the session.
11499 ** rows a zero-length blob (SQL value X'') is stored in the changeset or
11505 ** zero-length blob back to a NULL value when updating the sqlite_stat1
11509 ** conflict-handler callback) then the X'' value is returned. The application
11557 ** database row along with the updated values for each updated non-primary-key
11566 ** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL,
11568 ** with non-NULL PRIMARY KEY values is updated so that one or more of its
11581 ** are sorted in the same order in which they were attached (or auto-attached)
11595 ** recorded once - the first time a row with said primary key is inserted,
11602 ** The session object therefore accumulates two types of records - those
11620 ** found and one or more of the non-primary key fields have been
11637 ** This may appear to have some counter-intuitive effects if a single row
11653 ** CAPI3REF: Return An Upper-limit For The Size Of The Changeset
11675 ** does not have a primary key, this function is a no-op (but does not return
11695 ** used to update the table in database zFrom (call this the "from-table")
11697 ** object (call this the "to-table"). Specifically:
11700 ** <li> For each row (primary key) that exists in the to-table but not in
11701 ** the from-table, an INSERT record is added to the session object.
11703 ** <li> For each row (primary key) that exists in the to-table but not in
11704 ** the from-table, a DELETE record is added to the session object.
11707 ** different non-PK values in each, an UPDATE record is added to the
11752 ** Because the non-primary key "old.*" fields are omitted, no
11771 ** Return non-zero if no changes to attached tables have been recorded by
11779 ** are restored. However, if this function returns non-zero, then it is
11866 ** a conflict-handler callback by [sqlite3changeset_apply()], SQLITE_MISUSE
11890 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
11903 ** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
11906 ** or until the conflict-handler function returns.
11953 unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */
11962 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
11993 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
12027 ** conflict-handler callback by [sqlite3changeset_apply()] with either
12038 ** "conflicting row" associated with the current conflict-handler callback
12076 ** function with an iterator passed to a conflict-handler by
12084 ** returned. This is to allow the following pattern (pseudo-code):
12281 ** <table border=1 style="margin-left:8ex;margin-right:8ex">
12282 ** <tr><th style="white-space:pre">Existing Change </th>
12283 ** <th style="white-space:pre">New Change </th>
12333 ** detected, SQLITE_CORRUPT is returned. Or, if an out-of-memory condition
12415 ** Otherwise, if the return value is non-zero or the xFilter argument to
12451 ** SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If the conflict-handler
12455 ** returned by each invocation of the conflict-handler function. Refer to
12464 ** stored in all non-primary key columns also match the values stored in
12468 ** the non-primary key fields contains a value different from the original
12469 ** row value stored in the changeset, the conflict-handler function is
12472 ** only the values of those non-primary key fields are compared against
12473 ** the current database contents - any trailing database table columns
12477 ** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND]
12482 ** conflict-handler function is invoked with [SQLITE_CHANGESET_CONSTRAINT]
12501 ** This includes the case where the INSERT operation is re-attempted because
12509 ** stored in all modified non-primary key columns also match the values
12513 ** the modified non-primary key fields contains a value different from an
12514 ** original row value stored in the changeset, the conflict-handler function
12516 ** UPDATE changes only contain values for non-primary key fields that are
12518 ** avoid the SQLITE_CHANGESET_DATA conflict-handler callback.
12521 ** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND]
12525 ** SQLITE_CONSTRAINT, the conflict-handler function is invoked with
12543 ** If the output parameters (ppRebase) and (pnRebase) are non-NULL and
12641 ** Values that may be passed as the second argument to a conflict-handler.
12648 ** (non primary-key) fields modified by the update do not contain the
12809 ** combined on a per-field basis, not per-row. This means that in the
12893 ** corresponding non-streaming API functions:
12895 ** <table border=1 style="margin-left:8ex;margin-right:8ex">
12896 ** <tr><th>Streaming function<th>Non-streaming equivalent</th>
12906 ** Non-streaming functions that accept changesets (or patchsets) as input
12911 ** low-memory environment is required to handle very large changesets, the
13175 ** non-negative but less than the number of columns in the table, return
13190 ** non-negative but less than the number of columns in the table, set
13207 ** containing the text in utf-8 encoding, (*pn) is set to the size in bytes
13312 ** If the bClear argument is non-zero, then the auxiliary data is cleared
13334 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
13336 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
13342 ** modify this structure directly - it should only be used as shown above
13350 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
13364 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
13366 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
13375 ** xPhraseFirstColumn() set iCol to -1).
13484 ** The second and third arguments are an array of nul-terminated strings
13502 ** by argument pText. pText may or may not be nul-terminated. The first
13510 ** <ul><li> <b>FTS5_TOKENIZE_DOCUMENT</b> - A document is being inserted into
13515 ** <li> <b>FTS5_TOKENIZE_QUERY</b> - A MATCH query is being executed
13519 ** <li> <b>(FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX)</b> - Same as
13524 ** <li> <b>FTS5_TOKENIZE_AUX</b> - The tokenizer is being invoked to
13557 ** built-in tokenizers, the FTS5 query 'first + place' will match instances
13591 ** still appears to contain just two phrases - "(first OR 1st)"
13602 ** when tokenizing query text (it should not - to do so would be
13649 ** provide synonyms for prefixes). However, a non-prefix query like '1st'
13750 ** autoconf-based build
13778 ** The hard limit is the ability of a 32-bit signed integer
13779 ** to count the size: 2^31-1 or 2147483647.
13797 ** tell you that in a well-normalized database, you usually should
13855 ** The suggested maximum number of in-memory pages to use for
13858 ** IMPLEMENTATION-OF: R-30185-15359 The default suggested cache size is -2000,
13860 ** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be
13861 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options.
13864 # define SQLITE_DEFAULT_CACHE_SIZE -2000
13878 ** counted using a signed 8-bit integer which has a maximum value of 127
13890 ** as a signed 32-bit integer can hold.
13897 ** imposed by the use of 16-bit offsets within each page.
13903 ** with a page-size of 65536 bytes crashes, then an instance of SQLite
13904 ** compiled with the default page-size limit will not be able to rollback
13927 ** device characteristics (sector-size and atomic write() support),
13944 ** This value can be lowered (or raised) at run-time using that the
13975 #pragma warn -rch /* unreachable code */
13976 #pragma warn -ccc /* Condition is always true or false */
13977 #pragma warn -aus /* Assigned value is never used */
13978 #pragma warn -csu /* Comparing signed and unsigned */
13979 #pragma warn -spa /* Suspicious pointer arithmetic */
13987 # define __has_extension(x) 0 /* compatibility with non-clang compilers */
14020 ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
14033 # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
14034 #else /* Generates a warning - but it always works */
14079 ** SEH support if the -DSQLITE_OMIT_SEH option is given.
14089 ** disables it using -DSQLITE_DIRECT_OVERFLOW_READ=0
14092 /* Disable if -DSQLITE_DIRECT_OVERFLOW_READ=0 */
14104 ** level of threadsafety. 2 means the library is multithreaded - multiple
14112 ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
14120 # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
14126 ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
14133 ** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
14162 # error "Two or more of the following compile-time configuration options\
14200 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
14265 ** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage
14277 ** of SQLite to unexpected behavior - to make the code "self-healing"
14283 ** When doing coverage testing ALWAYS and NEVER are hard-coded to
14371 ** Return true (non-zero) if the input is an integer that is too large
14372 ** to fit in 32-bits. This macro is used inside of various testcase()
14373 ** macros to verify that we have tested SQLite for large-file support.
14400 ** This is the header file for the generic hash-table implementation
14411 ** The internals of this structure are intended to be opaque -- client
14418 ** All elements of the hash table are on a single doubly-linked list.
14422 ** the global doubly-linked list. The contents of the bucket are the
14423 ** element pointed to plus the next _ht.count-1 elements in the list.
14442 ** structure. All elements are stored on a single doubly-linked list.
14473 #define sqliteHashFirst(H) ((H)->first)
14474 #define sqliteHashNext(E) ((E)->next)
14475 #define sqliteHashData(E) ((E)->data)
14476 /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
14477 /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
14482 #define sqliteHashCount(H) ((H)->count)
14589 #define TK_CTIME_KW 100
14693 int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
14698 ** substitute integer for floating-point
14729 ** the VDBE-level file format changes. The following macros define the
14740 ** changed at run-time using a pragma.
14748 ** on the command-line
14778 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
14780 ** The default value of "20" was chosen to minimize the run-time of the
14781 ** speedtest1 test program with options: --shrink-memory --reprepare
14795 ** The compile-time options SQLITE_MMAP_READWRITE and
14808 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
14839 ** types can be conveniently redefined at compile-type. Like this:
14841 ** cc '-DUINTPTR_TYPE=long long int' ...
14881 typedef sqlite_int64 i64; /* 8-byte signed integer */
14882 typedef sqlite_uint64 u64; /* 8-byte unsigned integer */
14883 typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
14884 typedef UINT16_TYPE u16; /* 2-byte unsigned integer */
14885 typedef INT16_TYPE i16; /* 2-byte signed integer */
14886 typedef UINT8_TYPE u8; /* 1-byte unsigned integer */
14887 typedef INT8_TYPE i8; /* 1-byte signed integer */
14895 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
14904 ** Estimated quantities used for query planning are stored as 16-bit
14906 ** gives a possible range of values of approximately 1.0e986 to 1e-986.
14915 ** 1 -> 0 20 -> 43 10000 -> 132
14916 ** 2 -> 10 25 -> 46 25000 -> 146
14917 ** 3 -> 16 100 -> 66 1000000 -> 199
14918 ** 4 -> 20 1000 -> 99 1048576 -> 200
14919 ** 10 -> 33 1024 -> 100 4294967296 -> 320
14924 ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
14967 ** if the sub-buffer S..E-1 overflows the buffer whose last byte is P-1.
14972 ** |-----------------| FALSE
14973 ** |-------|
14977 ** |-----------------|
14978 ** |-------| TRUE
14982 ** |-----------------|
14983 ** |-------| FALSE
14990 ** and whether or not that determination is run-time or compile-time.
14992 ** For best performance, an attempt is made to guess at the byte-order
14993 ** using C-preprocessor macros. If that is unsuccessful, or if
14994 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
14995 ** at run-time.
15000 ** -DSQLITE_BYTEORDER=1234
15004 ** -DSQLITE_BYTEORDER=4321
15006 ** to cause the build to work for little-endian or big-endian processors,
15009 #ifndef SQLITE_BYTEORDER /* Replicate changes at tag-20230904a */
15047 ** Constants for the largest and smallest possible 64-bit signed integers.
15048 ** These macros are designed to work correctly on both 32-bit and 64-bit
15053 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
15057 ** to force 8-byte alignment on 64-bit architectures.
15062 ** pointers in size, and so it is a no-op on systems where the pointer
15078 ** Assert that the pointer X is aligned to an 8-byte boundary. This
15083 ** underlying malloc() implementation might return us 4-byte aligned
15084 ** pointers. In that case, only verify 4-byte alignment.
15087 # define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&3)==0)
15089 # define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&7)==0)
15101 ** Default maximum size of memory used by memory-mapped I/O in the VFS
15121 ** default MMAP_SIZE is specified at compile-time, make sure that it does
15145 sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
15157 ** 0x00000008 Result-set wildcard expansion
15163 ** 0x00000200 Count-of-view optimization
15168 ** 0x00004000 Push-down optimization
15169 ** 0x00008000 After all FROM-clause analysis
15191 ** (---any--) Top-level block structure
15192 ** 0x-------F High-level debug messages
15193 ** 0x----FFF- More detail
15194 ** 0xFFFF---- Low-level debug messages
15220 ** An instance of the following structure is used to store the busy-handler
15225 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
15259 ** The root-page of the schema table.
15278 #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
15297 ** directly, we use its constant as a key to lookup the run-time allocated
15299 ** for the run-time allocated buffer.
15302 ** macros become no-ops and have zero performance impact.
15403 ** Changing this from a 64-bit to a 32-bit type limits the number of
15425 #define ALLBITS ((Bitmask)-1)
15426 #define TOPBIT (((Bitmask)1)<<(BMS-1))
15455 ** This header file (together with is companion C source-code file
15459 ** This header file is #include-ed by sqliteInt.h and thus ends up
15467 ** necessary pre-processor macros for it.
15483 ** This file contains pre-processor directives related to operating system
15504 ** If SQLITE_OS_OTHER=1 is specified at compile-time, then the application
15567 ** a no-op
15600 ** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
15602 ** 2006-10-31: The default prefix used to be "sqlite_". But then
15603 ** Mcafee started using SQLite in their anti-virus product and it
15649 ** A SHARED_LOCK is obtained by locking a single randomly-chosen
15757 ** sqlite3_malloc() to obtain space for the file-handle structure.
15793 #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1
15816 ** is devoted to storing a super-journal name - there are no more pages to
15820 #define PAGER_SJ_PGNO_COMPUTED(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
15821 #define PAGER_SJ_PGNO(x) ((x)->lckPgno)
15829 #define PAGER_MEMORY 0x0002 /* In-memory database */
15834 #define PAGER_LOCKINGMODE_QUERY -1
15845 #define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */
15850 #define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */
15851 #define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */
15857 #define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */
15879 ** that make up the Pager sub-system API. See source code comments for
16031 ** This header file defines the interface that the sqlite B-Tree file
16044 ** If defined as non-zero, auto-vacuum is enabled by default. Otherwise
16051 #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
16052 #define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */
16065 sqlite3_vfs *pVfs, /* VFS to use with this b-tree */
16080 #define BTREE_MEMORY 2 /* This is an in-memory DB */
16081 #define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */
16135 ** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data
16138 ** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL
16141 #define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */
16142 #define BTREE_BLOBKEY 2 /* Table has keys only - no data */
16162 ** For example, the free-page-count field is located at byte offset 36 of
16163 ** the database file header. The incr-vacuum-flag field is located at
16167 ** It is a read-only number computed by the pager. But we merge it with
16180 #define BTREE_DATA_VERSION 15 /* A virtual meta-value */
16194 ** TK_COLUMN node in the expression tree refers to the Expr.iColumn-th
16195 ** column of the b-tree of the cursor. The Expr tree will not contain
16196 ** any function calls nor subqueries nor references to b-trees other than
16199 ** The design of the _RANGE hint is aid b-tree implementations that try
16200 ** to prefetch content from remote machines - to provide those
16225 #define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */
16230 ** For read-only cursors the wrFlag argument is always zero. For read-write
16241 ** by this, the native b-tree engine of SQLite, but it is available to
16243 ** b-tree system. For alternative storage engines in which a delete of
16247 ** and DELETE operations as no-ops, and any READ operation against a
16250 #define BTREE_WRCSR 0x00000004 /* read-write cursor */
16256 int wrFlag, /* 1 for writing. 0 for read-only */
16402 ** Enter and Leave procedures no-ops.
16489 u16 p5; /* Fifth parameter is an unsigned 16-bit integer */
16516 u32 iSrcLine; /* Source-code line that generated this opcode
16528 ** A sub-routine used to implement a trigger program.
16531 VdbeOp *aOp; /* Array of opcodes for sub-program */
16537 SubProgram *pNext; /* Next sub-program already visited */
16557 #define P4_STATIC (-1) /* Pointer to a static string */
16558 #define P4_COLLSEQ (-2) /* P4 is a pointer to a CollSeq structure */
16559 #define P4_INT32 (-3) /* P4 is a 32-bit signed integer */
16560 #define P4_SUBPROGRAM (-4) /* P4 is a pointer to a SubProgram structure */
16561 #define P4_TABLE (-5) /* P4 is a pointer to a Table structure */
16563 #define P4_FREE_IF_LE (-6)
16564 #define P4_DYNAMIC (-6) /* Pointer to memory from sqliteMalloc() */
16565 #define P4_FUNCDEF (-7) /* P4 is a pointer to a FuncDef structure */
16566 #define P4_KEYINFO (-8) /* P4 is a pointer to a KeyInfo structure */
16567 #define P4_EXPR (-9) /* P4 is a pointer to an Expr tree */
16568 #define P4_MEM (-10) /* P4 is a pointer to a Mem* structure */
16569 #define P4_VTAB (-11) /* P4 is a pointer to an sqlite3_vtab structure */
16570 #define P4_REAL (-12) /* P4 is a 64-bit floating point value */
16571 #define P4_INT64 (-13) /* P4 is a 64-bit signed integer */
16572 #define P4_INTARRAY (-14) /* P4 is a vector of 32-bit integers */
16573 #define P4_FUNCCTX (-15) /* P4 is a pointer to an sqlite3_context object */
16574 #define P4_TABLEREF (-16) /* Like P4_TABLE, but reference counted */
16675 #define OP_IfPos 59 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
16676 #define OP_IfNotZero 60 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
16677 #define OP_DecrJumpZero 61 /* jump, synopsis: if (--r[P1])==0 goto P2 */
16706 #define OP_Compare 90 /* synopsis: r[P1@P3] <-> r[P2@P3] */
16716 #define OP_SetCookie 100
16723 #define OP_Subtract 107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
16740 #define OP_SeekScan 124 /* synopsis: Scan-ahead up to P1 rows */
16776 #define OP_OffsetLimit 160 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) …
16857 ** Additional non-public SQLITE_PREPARE_* flags
16912 # define sqlite3ExplainBreakpoint(A,B) /*no-op*/
16917 # define sqlite3ExplainBreakpoint(A,B) /*no-op*/
16996 ** Use the SQLITE_ENABLE_MODULE_COMMENTS macro to see some extra no-op
17033 ** VdbeCoverageNeverNull(v) // Previous three-way branch is only
17038 ** // in distinguishing equal and not-equal.
17041 ** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and
17042 ** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch()
17050 ** is responsible for keeping track of this and reporting byte-code branches
17188 /* Modify the page-size after the cache has been created. */
17210 /* Change a page number. Used by incr-vacuum. */
17252 /* Set and get the suggested cache-size for the specified pager-cache.
17255 ** the total number of pages cached by purgeable pager-caches to the sum
17256 ** of the suggested cache-sizes.
17263 /* Set or get the suggested spill-size for the specified pager-cache.
17265 ** The spill-size is the minimum number of pages in cache before the cache
17329 ** at start-time.
17331 ** SQLITE_MUTEX_NOOP For single-threaded applications. No
17334 ** start-time.
17336 ** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix.
17338 ** SQLITE_MUTEX_W32 For multi-threaded applications on Win32.
17355 ** If this is a no-op implementation, implement everything as macros.
17376 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
17396 ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
17397 ** In other words, the zero-based numbers are used for all external interfaces
17398 ** and the one-based values are used internally.
17426 ** the Schema for the TEMP database (sqlite3.aDb[1]) which is free-standing.
17455 ** Db.pSchema->flags field.
17457 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
17458 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
17459 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
17460 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
17463 ** Allowed values for the DB.pSchema->flags field.
17483 ** Lookaside malloc is a set of fixed-size buffers that can be used
17505 ** in a performance-critical path. sz should be set by to szTrue whenever
17510 ** come off of pFree first, then pInit as a fallback. This dual-list
17511 ** allows use to compute a high-water mark - the maximum number of allocations
17512 ** outstanding at any point in the past - by subtracting the number of
17515 ** Enhancement on 2019-12-12: Two-size-lookaside
17516 ** The default lookaside configuration is 100 slots of 1200 bytes each.
17519 ** The two-size-lookaside enhancement breaks up the lookaside allocation
17520 ** into two pools: One of 128-byte slots and the other of the default size
17521 ** (1200-byte) slots. Allocations are filled from the small-pool first,
17522 ** failing over to the full-size pool if that does not work. Thus more
17539 void *pMiddle; /* First byte past end of full-size buffers and
17544 void *pTrueEnd; /* True value of pEnd, when db->pnBytesFreed!=0 */
17550 #define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0
17551 #define EnableLookaside db->lookaside.bDisable--;\
17552 db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue
17554 /* Size of the smaller allocations in two-size lookaside */
17562 ** A hash table for built-in function definitions. (Application-defined
17577 See ext/userauth/user-auth.txt for details."
17649 u32 nSchemaLock; /* Do not reset the schema when non-zero */
17657 u8 autoCommit; /* The auto-commit flag. */
17661 u8 dfltLockMode; /* Default locking-mode for attached dbs */
17667 u8 noSharedCache; /* True if no shared-cache backends */
17715 PreUpdate *pPreUpdate; /* Context for active pre-update callback */
17753 int nSavepoint; /* Number of non-transaction savepoints */
17754 int nStatement; /* Number of nested statement-transactions */
17784 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
17785 #define ENC(db) ((db)->enc)
17790 ** C-compilers still do not accept LL integer literals.
17833 #define SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/
17834 #define SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/
17840 #define SQLITE_ReadUncommit HI(0x00004) /* READ UNCOMMITTED in shared-cache */
17857 #define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */
17878 #define SQLITE_CountOfView 0x00000200 /* The count-of-view optimization */
17882 #define SQLITE_PushDown 0x00001000 /* WHERE-clause push-down opt */
17884 #define SQLITE_SkipScan 0x00004000 /* Skip-scans */
17892 #define SQLITE_BalancedMerge 0x00200000 /* Balance multi-way merges */
17897 #define SQLITE_Coroutines 0x02000000 /* Co-routines for subqueries */
17899 #define SQLITE_OnePass 0x08000000 /* Single-pass DELETE and UPDATE */
17905 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
17906 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
17912 #define ConstFactorOk(P) ((P)->okConstFactor)
17927 ** structure. For global built-in functions (ex: substr(), max(), count())
17929 ** For per-connection application-defined functions, a pointer to this
17930 ** structure is held in the db->aHash hash table.
17932 ** The u.pHash field is used by the global built-ins. The u.pDestructor
17933 ** field is used by per-connection app-def functions.
17936 i8 nArg; /* Number of arguments. -1 means unlimited */
17940 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
17943 void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */
17952 ** This structure encapsulates a user-function destructor callback (as
17985 ** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!!
17992 ** See multiple instances of tag-20230109-1.
17996 #define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
17999 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
18000 #define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
18001 #define SQLITE_FUNC_BYTELEN 0x00c0 /* Built-in octet_length() function */
18002 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
18003 /* 0x0200 -- available for reuse */
18004 #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
18008 ** single query - might change over time */
18009 #define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */
18011 #define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */
18016 #define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */
18017 #define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */
18021 /* Identifier numbers for each in-line function */
18039 ** as the user-data (sqlite3_user_data()) for the function. If
18050 ** zName is the name of a function that is implemented by in-line
18056 ** zName is the name of a test-only function implemented by in-line
18065 ** a single query. The iArg is ignored. The user-data is always set
18069 ** For math-library functions. xPtr is an arbitrary pointer.
18074 ** ignored and the user-data for these functions is set to an
18075 ** arbitrary non-NULL pointer. The bNC parameter is not used.
18093 ** available as the function user-data (sqlite3_user_data()). The
18158 char *zName; /* Savepoint name (nul-terminated) */
18219 u16 iDflt; /* 1-based index of DEFAULT. 0 means "none" */
18250 #define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */
18270 char *zName; /* Name of the collating sequence, UTF-8 encoded */
18282 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
18336 ** database connections, even when the rest of the in-memory database
18346 ** database schema are initially stored in a linked-list pointed to by
18353 ** When an in-memory Table object is deleted (for example when the
18404 LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
18435 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
18436 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
18446 #define TF_Readonly 0x00000001 /* Read-only system table */
18456 #define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */
18457 #define TF_OOOHidden 0x00000400 /* Out-of-Order hidden columns */
18472 #define IsView(X) ((X)->eTabType==TABTYP_VIEW)
18473 #define IsOrdinaryTable(X) ((X)->eTabType==TABTYP_NORM)
18481 # define IsVirtual(X) ((X)->eTabType==TABTYP_VTAB)
18483 ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB)
18491 ** only works for non-virtual tables (ordinary tables and views) and is
18496 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
18497 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
18499 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
18508 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
18509 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
18511 /* Macro is true if the SQLITE_ALLOW_ROWID_IN_VIEW (mis-)feature is
18533 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
18536 ** from-table == child-table
18537 ** to-table == parent-table
18540 ** which is attached to the from-table. The to-table need not exist when
18541 ** the from-table is created. The existence of the to-table is not checked.
18555 /* EV: R-30323-21917 */
18621 u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
18649 ** pKeyInfo->nField.
18653 ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
18657 ** an equals comparison. default_rc can be -1, 0, or +1. If there are
18658 ** multiple entries in the b-tree with the same key (when only looking
18659 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
18664 ** get and equal results when comparing this structure to a b-tree record.
18668 ** b-tree.
18671 KeyInfo *pKeyInfo; /* Collation and sort-order information */
18710 ** algorithm to employ when an attempt is made to insert a non-unique
18717 ** "colUsed & colNotIdxed" will be non-zero if the index is not a
18719 ** be true (note-20221022-a). If a column beyond the 63rd column of the
18720 ** table is used, the "colUsed & colNotIdxed" test will always be non-zero
18730 ** number (it cannot - the database page is not allocated until the VDBE
18755 unsigned noSkipScan:1; /* Do not try to use skip-scan if true */
18757 unsigned bLowQual:1; /* sqlite_stat1 says this is a low-quality index */
18768 IndexSample *aSample; /* Samples of the left-most key */
18769 tRowcnt *aiRowEst; /* Non-logarithmic stat1 data for this index */
18770 tRowcnt nRowEst0; /* Non-logarithmic number of rows in the index */
18784 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
18787 #define IsUniqueIndex(X) ((X)->onError!=OE_None)
18792 #define XN_ROWID (-1) /* Indexed column is the rowid */
18793 #define XN_EXPR (-2) /* Indexed column is an expression */
18825 const char *z; /* Text of the token. Not NULL-terminated! */
18849 int sortingIdxPTab; /* Cursor number of pseudo-table */
18884 ** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg.
18887 #define AggInfoColumnReg(A,I) (assert((A)->iFirstReg),(A)->iFirstReg+(I))
18889 (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))
18892 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
18893 ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
18894 ** than 32767 we have to make it 32-bit. 16-bit is preferred because
18899 ** the option is available (at compile-time).
18914 ** to represent the greater-than-or-equal-to operator in the expression
18928 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
18947 ** subquery gives a constant result, then iTable is -1. If the subquery
18952 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
18983 int iValue; /* Non-negative integer value if EP_IntValue */
19008 ** TK_TRIGGER: 1 -> new, 0 -> old
19013 ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
19016 i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
19080 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
19081 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
19082 #define ExprSetProperty(E,P) (E)->flags|=(P)
19083 #define ExprClearProperty(E,P) (E)->flags&=~(P)
19084 #define ExprAlwaysTrue(E) (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue)
19085 #define ExprAlwaysFalse(E) (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse)
19086 #define ExprIsFullSize(E) (((E)->flags&(EP_Reduced|EP_TokenOnly))==0)
19091 #define ExprUseUToken(E) (((E)->flags&EP_IntValue)==0)
19092 #define ExprUseUValue(E) (((E)->flags&EP_IntValue)!=0)
19093 #define ExprUseWOfst(E) (((E)->flags&(EP_InnerON|EP_OuterON))==0)
19094 #define ExprUseWJoin(E) (((E)->flags&(EP_InnerON|EP_OuterON))!=0)
19095 #define ExprUseXList(E) (((E)->flags&EP_xIsSelect)==0)
19096 #define ExprUseXSelect(E) (((E)->flags&EP_xIsSelect)!=0)
19097 #define ExprUseYTab(E) (((E)->flags&(EP_WinFunc|EP_Subrtn))==0)
19098 #define ExprUseYWin(E) (((E)->flags&EP_WinFunc)!=0)
19099 #define ExprUseYSub(E) (((E)->flags&EP_Subrtn)!=0)
19108 ** processes but is a no-op for delivery.
19111 # define ExprSetVVAProperty(E,P) (E)->vvaFlags|=(P)
19112 # define ExprHasVVAProperty(E,P) (((E)->vvaFlags&(P))!=0)
19113 # define ExprClearVVAProperties(E) (E)->vvaFlags = 0
19133 #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
19143 ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \
19159 ** ---------- -------------------------
19219 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
19228 Expr *pExpr; /* Expr to implement a USING variable -- NOT USED */
19239 #define EU4_EXPR 2 /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
19250 ** In the colUsed field, the high-order bit (bit 63) is set if the table
19251 ** contains more than 63 columns and the 64-th or later column is used.
19271 int regResult; /* Registers holding results of a co-routine */
19276 unsigned isTabFunc :1; /* True if table-valued-function syntax */
19277 unsigned isCorrelated :1; /* True if sub-query is correlated */
19279 unsigned viaCoroutine :1; /* Implemented as a co-routine */
19285 unsigned isOn :1; /* u3.pOn was once valid and non-NULL */
19298 ExprList *pFuncArg; /* Arguments to table-valued-function */
19349 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
19352 #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
19355 #define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
19364 #define WHERE_KEEP_ALL_JOINS 0x2000 /* Do not do the omit-noop-join opt */
19384 ** NameContexts can be nested. When resolving names, the inner-most
19400 ExprList *pEList; /* Optional list of result-set columns */
19442 #define NC_NoSelect 0x080000 /* Do not descend into sub-selects */
19451 ** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the
19452 ** conflict-target clause.) The pUpsertTargetWhere is the optional
19557 #define SF_PushDown 0x1000000 /* Modified by WHERE-clause push-down opt */
19565 #define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)
19573 ** identified by pDest->iSDParm.
19575 ** SRT_Except Remove results from the temporary index pDest->iSDParm.
19577 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
19582 ** the side-effects of functions.
19589 ** in register pDest->iSDParm then abandon the rest
19593 ** row of result as the key in table pDest->iSDParm.
19594 ** Apply the affinity pDest->affSdst before storing
19597 ** SRT_EphemTab Create an temporary table pDest->iSDParm and store
19603 ** SRT_Coroutine Generate a co-routine that returns a new row of
19605 ** of the co-routine is stored in register pDest->iSDParm
19606 ** and the result row is stored in pDest->nDest registers
19607 ** starting with pDest->iSdst.
19609 ** SRT_Table Store results in temporary table pDest->iSDParm.
19615 ** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
19616 ** But also use temporary table pDest->iSDParm+1 as
19620 ** SRT_Queue Store results in priority queue pDest->iSDParm (really
19624 ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
19626 ** index at pDest->iSDParm+1 hold all prior stores.
19629 ** pDest->iSDParm. If (pDest->iSDParm<0), then the temp
19630 ** table is an intkey table - in this case the first
19632 ** key. If (pDest->iSDParm>0), then the table is an index
19633 ** table. (pDest->iSDParm) is the number of key columns in
19645 #define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue)
19651 #define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo)
19669 int iSdst; /* Base register where results are written */
19679 ** the code generator needs. We have to keep per-table autoincrement
19698 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
19780 ** The nTableLock and aTableLock variables are only used if the shared-cache
19781 ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
19782 ** used to store the set of table-locks required by the statement being
19816 ** of the base register during check-constraint eval */
19828 int nMaxArg; /* Max args passed to user function by sub-program */
19835 TableLock *aTableLock; /* Required table locks for shared-cache mode */
19880 int nHeight; /* Expression tree height of current sub-select */
19892 const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
19914 #define PARSE_HDR_SZ (offsetof(Parse,aTempReg)-offsetof(Parse,zErrMsg)) /* Recursive part w/o aColC…
19916 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
19925 #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)
19931 #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)
19937 #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)
19961 #define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
19965 #define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
19969 #define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
20005 IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
20006 the <column-list> is stored here */
20025 ** that is a part of a trigger-program.
20030 ** the first step of the trigger-program.
20037 ** orconf -> stores the ON CONFLICT algorithm
20038 ** pSelect -> The content to be inserted - either a SELECT statement or
20040 ** zTarget -> Dequoted name of the table to insert into.
20041 ** pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
20042 ** statement, then this stores the column-names to be
20044 ** pUpsert -> The ON CONFLICT clauses for an Upsert
20047 ** zTarget -> Dequoted name of the table to delete from.
20048 ** pWhere -> The WHERE clause of the DELETE statement if one is specified.
20052 ** zTarget -> Dequoted name of the table to update.
20053 ** pWhere -> The WHERE clause of the UPDATE statement if one is specified.
20055 ** pExprList -> A list of the columns to update and the expressions to update
20060 ** pSelect -> The SELECT statement
20063 ** pExprList -> The list of expressions that follow the RETURNING keyword.
20079 TriggerStep *pNext; /* Next in the link-list */
20080 TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */
20110 #define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
20114 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
20117 ** The following object is the header for an "RCStr" or "reference-counted
20128 ** 3. Make a (read-only) copy of a read-only RCStr string using
20162 ** on debug-builds of the CLI using ".testctrl tune ID VALUE". Tuning
20165 ** be used on trunk check-ins. They are a temporary mechanism available
20170 #define SQLITE_NTUNE 6 /* Should be zero for all trunk check-ins */
20172 # define Tuning(X) (sqlite3Config.aTune[(X)-1])
20187 u8 bUseCis; /* Use covering indices for full-scans */
20192 u8 bJsonSelfcheck; /* Double-check JSON parsing */
20195 int neverCorrupt; /* Database is always well-formed */
20198 int nStmtSpill; /* Stmt-journal spill-to-disk threshold */
20199 sqlite3_mem_methods m; /* Low-level memory allocation interface */
20200 sqlite3_mutex_methods mutex; /* Low-level mutex interface */
20201 sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */
20211 int sharedCacheEnabled; /* true if shared-cache mode enabled */
20213 /* The above might be initialized to non-zero. The following need to always
20249 u32 szSorterRef; /* Min size in bytes to use sorter-refs */
20251 /* vvvv--- must be last ---vvv */
20259 ** the assert is only valid on a well-formed database. Instead of:
20271 ** things that are always true for well-formed databases.
20276 ** Context pointer passed down through the tree-walk.
20285 u16 mWFlags; /* Use-dependent flags */
20319 const char *zType; /* Type of the container - used for error messages */
20320 const Token *pName; /* Name of the container - used for error messages */
20348 ** Return code from the parse-tree walking primitives and their
20419 ** data structures on sqlite3DebugPrintf() using a tree-like view.
20423 u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */
20436 ** (2) All window functions in a single SELECT form a linked-list
20452 char *zBase; /* Name of base window for chaining (may be NULL) */
20509 ** Assuming zIn points to the first byte of a UTF-8 character,
20510 ** advance zIn to point to the first byte of the next UTF-8 character.
20521 ** routines that report the line-number on which the error originated
20566 ** The ctype.h header is needed for non-ASCII systems. It is also
20702 # define MAN754 ((((u64)1)<<52)-1)
20728 char sign; /* '+' or '-' */
20869 # define sqlite3TableColumnToStorage(T,X) (X) /* No-op pass-through */
20870 # define sqlite3StorageColumnToTable(T,X) (X) /* No-op pass-through */
20879 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
21140 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
21141 # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
21205 ** Routines to read and write variable-length integers. These used to
21433 ** The interface to the LEMON-generated parser
21494 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
21571 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
21573 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
21575 ** provided (enforcement of FK constraints requires the triggers sub-system).
21626 #define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
21680 ** sqlite3IoTrace is a pointer to a printf-like routine used to
21713 ** passed back to non-lookaside free() routines. Asserts such as the
21714 ** example above are placed on the non-lookaside free() routines to verify
21717 ** All of this is no-op for a production build. It only comes into
21718 ** play when the SQLITE_MEMDEBUG compile-time option is used.
21725 # define sqlite3MemdebugSetType(X,Y) /* no-op */
21769 # define IS_STMT_SCANSTATUS(db) (db->flags & SQLITE_StmtScanStatus)
21791 ** all of the platform-specific files (os_*.c) and is #included into those
21803 ** switch. The following code should catch this problem at compile-time.
21818 #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
21842 || sqlite3_io_error_pending-- == 1 ) \
21857 sqlite3_diskfull_pending--; \
21900 ** This file implements routines used to report what compile-time options
21903 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */
21907 ** autoconf-based build
21921 ** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */
21927 ** An array of names of all compile-time options. This array should
21928 ** be sorted A-Z.
21931 ** only a handful of compile-time options, so most times this array is usually
21969 "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "."
21973 "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),
21975 "COMPILER=gcc-" __VERSION__,
22695 /* An array to map all upper-case characters into their corresponding
22696 ** lower-case character.
22698 ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
22707 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
22709 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
22727 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */
22736 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */
22738 /* All of the upper-to-lower conversion data is above. The following
22755 ** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus
22756 ** be undefined behavior. That's goofy, but the C-standards people thought
22764 SQLITE_PRIVATE const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne];
22765 SQLITE_PRIVATE const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne];
22766 SQLITE_PRIVATE const unsigned char *sqlite3aGTb = &sqlite3UpperToLower[256+12-OP_Ne];
22769 ** The following 256 byte lookup table is used to support SQLites built-in
22778 ** SQLite identifier character 0x40 $, _, or non-ascii
22782 ** case. i.e. if the character is a lower-case ASCII character.
22783 ** If x is a lower-case ASCII character, then its upper-case equivalent
22784 ** is (x - 0x20). Therefore toupper() can be implemented as:
22791 ** Bit 0x40 is set if the character is non-alphanumeric and can be used in an
22793 ** non-ASCII UTF character. Hence the test for whether or not a character is
22802 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */
22834 /* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards
22838 ** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled
22839 ** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
22841 ** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally
22849 /* EVIDENCE-OF: R-38720-18127 The default setting is determined by the
22850 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
22851 ** that compile-time option is omitted.
22857 # error "Compile-time disabling of covering index scan using the\
22858 -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\
22874 ** before 3.12.0). -1 means always keep the entire statement journal in
22884 ** The default lookaside-configuration, the format "SZ,N". SZ is the
22886 ** and N is the number of slots. The lookaside-configuration can be
22887 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
22888 ** or at run-time for an individual database connection using
22891 ** With the two-size-lookaside enhancement, less lookaside is required.
22892 ** The default configuration of 1200,40 actually provides 30 1200-byte slots
22893 ** and 93 128-byte slots, which is more lookaside than is available
22894 ** using the older 1200,100 configuration without two-size-lookaside.
22898 # define SQLITE_DEFAULT_LOOKASIDE 1200,100 /* 120KB of memory */
22905 /* The default maximum size of an in-memory database created using
22971 0, /* mNoVisibleRowid. 0 == allow rowid-in-view */
22984 ** Hash table for global functions - functions common to all
22986 ** read-only.
23005 ** sqlite3Hwtime() for profiling. This is a no-op on standard builds.
23012 ** 1-gibabyte boundary) in a compatible database. SQLite never uses
23172 ** * A b-tree cursor
23173 ** - In the main database or in an ephemeral database
23174 ** - On either an index or a table
23177 ** * A one-row "pseudotable" stored in a single register
23182 i8 iDb; /* Index of cursor database in db->aDb[] */
23191 Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */
23194 Bool colCache:1; /* pCache pointer is initialized and non-NULL */
23243 /* Return true if P is a null-only cursor
23246 ((P)->eCurType==CURTYPE_PSEUDO && (P)->nullRow && (P)->seekResult==0)
23268 ** When a sub-program is executed (OP_Program), a structure of this type
23271 ** values stored in the Vdbe struct. When the sub-program is finished,
23273 ** restoring the state of the VM to as it was before the sub-program
23309 i64 nDbChange; /* Value of db->nChange */
23344 void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
23363 ** UPDATE no-change flag set
23369 ** * MEM_Null|MEM_Cleared Special SQL NULL that compares non-equal
23373 ** length Mem.n. Zero-terminated if
23429 /* Return TRUE if Mem X contains dynamically allocated content - anything
23433 (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)
23439 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
23442 ** True if Mem X is a NULL-nochng type.
23445 (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \
23446 && (X)->n==0 && (X)->u.nZero==0)
23457 #define memIsValid(M) ((M)->flags & MEM_AffMask)!=0
23523 int iSelectID; /* The "Select-ID" for this loop */
23528 /* The DblquoteStr object holds the text of a double-quoted
23532 ** list is consulted for each double-quoted identifier to see if the
23580 i64 startTime; /* Time when query started - used for profiling */
23594 bft changeCntOn:1; /* True to update the change-counter */
23599 yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
23605 DblquoteStr *pDblStr; /* List of double-quoted string literals */
23612 SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
23652 ** set of values on the right-hand side of an IN constraint.
23668 ** single-byte varint.
23826 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
23871 ** we have to locate the state vector at run-time. In the more common
23901 ** The value of N is added to the current status value and the high-water
23905 ** mark is unchanged. N must be non-negative for StatusDown().
23925 wsdStat.nowValue[op] -= N; in sqlite3StatusDown()
23997 p = p->pNext; in countLookasideSlots()
24007 u32 nInit = countLookasideSlots(db->lookaside.pInit); in sqlite3LookasideUsed()
24008 u32 nFree = countLookasideSlots(db->lookaside.pFree); in sqlite3LookasideUsed()
24010 nInit += countLookasideSlots(db->lookaside.pSmallInit); in sqlite3LookasideUsed()
24011 nFree += countLookasideSlots(db->lookaside.pSmallFree); in sqlite3LookasideUsed()
24013 if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit; in sqlite3LookasideUsed()
24014 return db->lookaside.nSlot - (nInit+nFree); in sqlite3LookasideUsed()
24024 int *pHighwater, /* Write high-water mark here */ in sqlite3_db_status()
24025 int resetFlag /* Reset high-water mark if true */ in sqlite3_db_status()
24033 sqlite3_mutex_enter(db->mutex); in sqlite3_db_status()
24038 LookasideSlot *p = db->lookaside.pFree; in sqlite3_db_status()
24040 while( p->pNext ) p = p->pNext; in sqlite3_db_status()
24041 p->pNext = db->lookaside.pInit; in sqlite3_db_status()
24042 db->lookaside.pInit = db->lookaside.pFree; in sqlite3_db_status()
24043 db->lookaside.pFree = 0; in sqlite3_db_status()
24046 p = db->lookaside.pSmallFree; in sqlite3_db_status()
24048 while( p->pNext ) p = p->pNext; in sqlite3_db_status()
24049 p->pNext = db->lookaside.pSmallInit; in sqlite3_db_status()
24050 db->lookaside.pSmallInit = db->lookaside.pSmallFree; in sqlite3_db_status()
24051 db->lookaside.pSmallFree = 0; in sqlite3_db_status()
24064 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); in sqlite3_db_status()
24065 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); in sqlite3_db_status()
24067 *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT]; in sqlite3_db_status()
24069 db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0; in sqlite3_db_status()
24084 for(i=0; i<db->nDb; i++){ in sqlite3_db_status()
24085 Btree *pBt = db->aDb[i].pBt; in sqlite3_db_status()
24111 db->pnBytesFreed = &nByte; in sqlite3_db_status()
24112 assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); in sqlite3_db_status()
24113 db->lookaside.pEnd = db->lookaside.pStart; in sqlite3_db_status()
24114 for(i=0; i<db->nDb; i++){ in sqlite3_db_status()
24115 Schema *pSchema = db->aDb[i].pSchema; in sqlite3_db_status()
24120 pSchema->tblHash.count in sqlite3_db_status()
24121 + pSchema->trigHash.count in sqlite3_db_status()
24122 + pSchema->idxHash.count in sqlite3_db_status()
24123 + pSchema->fkeyHash.count in sqlite3_db_status()
24125 nByte += sqlite3_msize(pSchema->tblHash.ht); in sqlite3_db_status()
24126 nByte += sqlite3_msize(pSchema->trigHash.ht); in sqlite3_db_status()
24127 nByte += sqlite3_msize(pSchema->idxHash.ht); in sqlite3_db_status()
24128 nByte += sqlite3_msize(pSchema->fkeyHash.ht); in sqlite3_db_status()
24130 for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){ in sqlite3_db_status()
24133 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ in sqlite3_db_status()
24138 db->pnBytesFreed = 0; in sqlite3_db_status()
24139 db->lookaside.pEnd = db->lookaside.pTrueEnd; in sqlite3_db_status()
24156 db->pnBytesFreed = &nByte; in sqlite3_db_status()
24157 assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); in sqlite3_db_status()
24158 db->lookaside.pEnd = db->lookaside.pStart; in sqlite3_db_status()
24159 for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pVNext){ in sqlite3_db_status()
24162 db->lookaside.pEnd = db->lookaside.pTrueEnd; in sqlite3_db_status()
24163 db->pnBytesFreed = 0; in sqlite3_db_status()
24165 *pHighwater = 0; /* IMP: R-64479-57858 */ in sqlite3_db_status()
24187 for(i=0; i<db->nDb; i++){ in sqlite3_db_status()
24188 if( db->aDb[i].pBt ){ in sqlite3_db_status()
24189 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); in sqlite3_db_status()
24193 *pHighwater = 0; /* IMP: R-42420-56072 */ in sqlite3_db_status()
24194 /* IMP: R-54100-20147 */ in sqlite3_db_status()
24195 /* IMP: R-29431-39229 */ in sqlite3_db_status()
24200 /* Set *pCurrent to non-zero if there are unresolved deferred foreign in sqlite3_db_status()
24205 *pHighwater = 0; /* IMP: R-11967-56545 */ in sqlite3_db_status()
24206 *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0; in sqlite3_db_status()
24214 sqlite3_mutex_leave(db->mutex); in sqlite3_db_status()
24234 ** There is only one exported symbol in this file - the function
24243 ** 1970-01-01 00:00:00 is JD 2440587.5
24244 ** 2000-01-01 00:00:00 is JD 2451544.5
24246 ** This implementation requires years to be expressed as a 4-digit number
24247 ** which means that only dates between 0000-01-01 and 9999-12-31 can
24253 ** use the julian calendar for dates prior to 1582-10-15 and for some
24261 ** ISBN 0-943396-61-1
24262 ** Willmann-Bell, Inc
24310 ** of a four-character format specifiers ABCD is:
24324 ** Example: To translate an ISO-8601 date YYYY-MM-DD, the format would
24325 ** be "40f-21a-20c". The "40f-" indicates the 4-digit year followed by "-".
24326 ** The "21a-" indicates the 2-digit month followed by "-". The "20c" indicates
24327 ** the 2-digit day which is the last integer in the set.
24340 char N = zFormat[0] - '0'; in getDigits()
24341 char min = zFormat[1] - '0'; in getDigits()
24346 max = aMx[zFormat[2] - 'a']; in getDigits()
24349 while( N-- ){ in getDigits()
24353 val = val*10 + *zDate - '0'; in getDigits()
24370 ** Parse a timezone extension on the end of a date-time.
24373 ** (+/-)HH:MM
24380 ** of change in p->tz and return 0. If a parser error occurs,
24381 ** return non-zero.
24390 p->tz = 0; in parseTimezone()
24392 if( c=='-' ){ in parseTimezone()
24393 sgn = -1; in parseTimezone()
24398 p->isLocal = 0; in parseTimezone()
24399 p->isUtc = 1; in parseTimezone()
24409 p->tz = sgn*(nMn + nHr*60); in parseTimezone()
24439 ms = ms*10.0 + *zDate - '0'; in parseHhMmSs()
24448 p->validJD = 0; in parseHhMmSs()
24449 p->rawS = 0; in parseHhMmSs()
24450 p->validHMS = 1; in parseHhMmSs()
24451 p->h = h; in parseHhMmSs()
24452 p->m = m; in parseHhMmSs()
24453 p->s = s + ms; in parseHhMmSs()
24463 p->isError = 1; in datetimeError()
24467 ** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume
24468 ** that the YYYY-MM-DD is according to the Gregorian calendar.
24475 if( p->validJD ) return; in computeJD()
24476 if( p->validYMD ){ in computeJD()
24477 Y = p->Y; in computeJD()
24478 M = p->M; in computeJD()
24479 D = p->D; in computeJD()
24481 Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ in computeJD()
24485 if( Y<-4713 || Y>9999 || p->rawS ){ in computeJD()
24490 Y--; in computeJD()
24493 A = Y/100; in computeJD()
24494 B = 2 - A + (A/4); in computeJD()
24495 X1 = 36525*(Y+4716)/100; in computeJD()
24497 p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000); in computeJD()
24498 p->validJD = 1; in computeJD()
24499 if( p->validHMS ){ in computeJD()
24500 p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5); in computeJD()
24501 if( p->tz ){ in computeJD()
24502 p->iJD -= p->tz*60000; in computeJD()
24503 p->validYMD = 0; in computeJD()
24504 p->validHMS = 0; in computeJD()
24505 p->tz = 0; in computeJD()
24506 p->isUtc = 1; in computeJD()
24507 p->isLocal = 0; in computeJD()
24513 ** Given the YYYY-MM-DD information current in p, determine if there
24514 ** is day-of-month overflow and set nFloor to the number of days that
24519 assert( p->validYMD || p->isError ); in computeFloor()
24520 assert( p->D>=0 && p->D<=31 ); in computeFloor()
24521 assert( p->M>=0 && p->M<=12 ); in computeFloor()
24522 if( p->D<=28 ){ in computeFloor()
24523 p->nFloor = 0; in computeFloor()
24524 }else if( (1<<p->M) & 0x15aa ){ in computeFloor()
24525 p->nFloor = 0; in computeFloor()
24526 }else if( p->M!=2 ){ in computeFloor()
24527 p->nFloor = (p->D==31); in computeFloor()
24528 }else if( p->Y%4!=0 || (p->Y%100==0 && p->Y%400!=0) ){ in computeFloor()
24529 p->nFloor = p->D - 28; in computeFloor()
24531 p->nFloor = p->D - 29; in computeFloor()
24538 ** YYYY-MM-DD HH:MM:SS.FFF
24539 ** YYYY-MM-DD HH:MM:SS
24540 ** YYYY-MM-DD HH:MM
24541 ** YYYY-MM-DD
24544 ** on success and 1 if the input string is not a well-formed
24550 if( zDate[0]=='-' ){ in parseYyyyMmDd()
24556 if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){ in parseYyyyMmDd()
24564 p->validHMS = 0; in parseYyyyMmDd()
24568 p->validJD = 0; in parseYyyyMmDd()
24569 p->validYMD = 1; in parseYyyyMmDd()
24570 p->Y = neg ? -Y : Y; in parseYyyyMmDd()
24571 p->M = M; in parseYyyyMmDd()
24572 p->D = D; in parseYyyyMmDd()
24574 if( p->tz ){ in parseYyyyMmDd()
24589 p->iJD = sqlite3StmtCurrentTime(context); in setDateTimeToCurrent()
24590 if( p->iJD>0 ){ in setDateTimeToCurrent()
24591 p->validJD = 1; in setDateTimeToCurrent()
24592 p->isUtc = 1; in setDateTimeToCurrent()
24593 p->isLocal = 0; in setDateTimeToCurrent()
24605 ** If the value is a valid unix timestamp, put it in p->s and set p->rawS.
24608 p->s = r; in setRawDateNumber()
24609 p->rawS = 1; in setRawDateNumber()
24611 p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5); in setRawDateNumber()
24612 p->validJD = 1; in setRawDateNumber()
24622 ** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM
24626 ** In the first form, the +/-HH:MM is always optional. The fractional
24650 p->useSubsec = 1; in parseDateOrTime()
24656 /* The julian day number for 9999-12-31 23:59:59.999 is 5373484.4999999.
24679 if( p->validYMD ) return; in computeYMD()
24680 if( !p->validJD ){ in computeYMD()
24681 p->Y = 2000; in computeYMD()
24682 p->M = 1; in computeYMD()
24683 p->D = 1; in computeYMD()
24684 }else if( !validJulianDay(p->iJD) ){ in computeYMD()
24688 Z = (int)((p->iJD + 43200000)/86400000); in computeYMD()
24689 A = (int)((Z - 1867216.25)/36524.25); in computeYMD()
24690 A = Z + 1 + A - (A/4); in computeYMD()
24692 C = (int)((B - 122.1)/365.25); in computeYMD()
24693 D = (36525*(C&32767))/100; in computeYMD()
24694 E = (int)((B-D)/30.6001); in computeYMD()
24696 p->D = B - D - X1; in computeYMD()
24697 p->M = E<14 ? E-1 : E-13; in computeYMD()
24698 p->Y = p->M>2 ? C - 4716 : C - 4715; in computeYMD()
24700 p->validYMD = 1; in computeYMD()
24708 if( p->validHMS ) return; in computeHMS()
24710 day_ms = (int)((p->iJD + 43200000) % 86400000); in computeHMS()
24711 p->s = (day_ms % 60000)/1000.0; in computeHMS()
24713 p->m = day_min % 60; in computeHMS()
24714 p->h = day_min / 60; in computeHMS()
24715 p->rawS = 0; in computeHMS()
24716 p->validHMS = 1; in computeHMS()
24731 p->validYMD = 0; in clearYMD_HMS_TZ()
24732 p->validHMS = 0; in clearYMD_HMS_TZ()
24733 p->tz = 0; in clearYMD_HMS_TZ()
24743 ** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx.
24757 ** using whatever operating-system specific localtime facility that
24759 ** non-zero on any kind of error.
24761 ** If the sqlite3GlobalConfig.bLocaltimeFault variable is non-zero then this
24764 ** invoked in place of the OS-defined localtime() function.
24766 ** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C
24832 if( p->iJD<2108667600*(i64)100000 /* 1970-01-01 */ in toLocaltime()
24833 || p->iJD>2130141456*(i64)100000 /* 2038-01-18 */ in toLocaltime()
24835 /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only in toLocaltime()
24842 iYearDiff = (2000 + x.Y%4) - x.Y; in toLocaltime()
24846 t = (time_t)(x.iJD/1000 - 21086676*(i64)10000); in toLocaltime()
24849 t = (time_t)(p->iJD/1000 - 21086676*(i64)10000); in toLocaltime()
24852 sqlite3_result_error(pCtx, "local time unavailable", -1); in toLocaltime()
24855 p->Y = sLocal.tm_year + 1900 - iYearDiff; in toLocaltime()
24856 p->M = sLocal.tm_mon + 1; in toLocaltime()
24857 p->D = sLocal.tm_mday; in toLocaltime()
24858 p->h = sLocal.tm_hour; in toLocaltime()
24859 p->m = sLocal.tm_min; in toLocaltime()
24860 p->s = sLocal.tm_sec + (p->iJD%1000)*0.001; in toLocaltime()
24861 p->validYMD = 1; in toLocaltime()
24862 p->validHMS = 1; in toLocaltime()
24863 p->validJD = 0; in toLocaltime()
24864 p->rawS = 0; in toLocaltime()
24865 p->tz = 0; in toLocaltime()
24866 p->isError = 0; in toLocaltime()
24876 ** Where NNN is an arbitrary floating-point number and "days" can be one
24899 if( !p->rawS || p->validJD ){ in autoAdjustDate()
24900 p->rawS = 0; in autoAdjustDate()
24901 }else if( p->s>=-21086676*(i64)10000 /* -4713-11-24 12:00:00 */ in autoAdjustDate()
24902 && p->s<=(25340230*(i64)10000)+799 /* 9999-12-31 23:59:59 */ in autoAdjustDate()
24904 double r = p->s*1000.0 + 210866760000000.0; in autoAdjustDate()
24906 p->iJD = (sqlite3_int64)(r + 0.5); in autoAdjustDate()
24907 p->validJD = 1; in autoAdjustDate()
24908 p->rawS = 0; in autoAdjustDate()
24913 ** Process a modifier to a date-time stamp. The modifiers are
24922 ** +/-YYYY-MM-DD HH:MM:SS.SSS
24960 if( idx>1 ) return 1; /* IMP: R-33611-57934 */ in parseModifier()
24970 ** Resolve day-of-month overflow by rolling forward into the next in parseModifier()
24972 ** a no-op that is only included for symmetry. See "floor". in parseModifier()
24978 p->nFloor = 0; in parseModifier()
24986 ** Resolve day-of-month overflow by rolling back to the end of the in parseModifier()
24991 p->iJD -= p->nFloor*86400000; in parseModifier()
25001 ** Always interpret the prior number as a julian-day value. If this in parseModifier()
25007 if( idx>1 ) return 1; /* IMP: R-31176-64601 */ in parseModifier()
25008 if( p->validJD && p->rawS ){ in parseModifier()
25010 p->rawS = 0; in parseModifier()
25023 rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx); in parseModifier()
25024 p->isUtc = 0; in parseModifier()
25025 p->isLocal = 1; in parseModifier()
25034 ** Treat the current value of p->s as the number of in parseModifier()
25037 if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){ in parseModifier()
25038 if( idx>1 ) return 1; /* IMP: R-49255-55373 */ in parseModifier()
25039 r = p->s*1000.0 + 210866760000000.0; in parseModifier()
25042 p->iJD = (sqlite3_int64)(r + 0.5); in parseModifier()
25043 p->validJD = 1; in parseModifier()
25044 p->rawS = 0; in parseModifier()
25050 if( p->isUtc==0 ){ in parseModifier()
25057 iGuess = iOrigJD = p->iJD; in parseModifier()
25062 iGuess -= iErr; in parseModifier()
25068 iErr = new.iJD - iOrigJD; in parseModifier()
25071 p->iJD = iGuess; in parseModifier()
25072 p->validJD = 1; in parseModifier()
25073 p->isUtc = 1; in parseModifier()
25074 p->isLocal = 0; in parseModifier()
25087 ** date is already on the appropriate weekday, this is a no-op. in parseModifier()
25094 p->tz = 0; in parseModifier()
25095 p->validJD = 0; in parseModifier()
25097 Z = ((p->iJD + 129600000)/86400000) % 7; in parseModifier()
25098 if( Z>n ) Z -= 7; in parseModifier()
25099 p->iJD += (n - Z)*86400000; in parseModifier()
25122 p->useSubsec = 1; in parseModifier()
25127 if( !p->validJD && !p->validYMD && !p->validHMS ) break; in parseModifier()
25130 p->validHMS = 1; in parseModifier()
25131 p->h = p->m = 0; in parseModifier()
25132 p->s = 0.0; in parseModifier()
25133 p->rawS = 0; in parseModifier()
25134 p->tz = 0; in parseModifier()
25135 p->validJD = 0; in parseModifier()
25137 p->D = 1; in parseModifier()
25140 p->M = 1; in parseModifier()
25141 p->D = 1; in parseModifier()
25149 case '-': in parseModifier()
25168 if( z[n]=='-' ){ in parseModifier()
25177 if( z[n]=='-' ){ in parseModifier()
25178 /* A modifier of the form (+|-)YYYY-MM-DD adds or subtracts the in parseModifier()
25180 ** the range 0-11 and DD is limited to 0-30. in parseModifier()
25182 if( z0!='+' && z0!='-' ) break; /* Must start with +/- */ in parseModifier()
25184 if( getDigits(&z[1], "40f-20a-20d", &Y, &M, &D)!=3 ) break; in parseModifier()
25187 if( getDigits(&z[1], "50f-20a-20d", &Y, &M, &D)!=3 ) break; in parseModifier()
25193 p->validJD = 0; in parseModifier()
25194 if( z0=='-' ){ in parseModifier()
25195 p->Y -= Y; in parseModifier()
25196 p->M -= M; in parseModifier()
25197 D = -D; in parseModifier()
25199 p->Y += Y; in parseModifier()
25200 p->M += M; in parseModifier()
25202 x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; in parseModifier()
25203 p->Y += x; in parseModifier()
25204 p->M -= x*12; in parseModifier()
25207 p->validHMS = 0; in parseModifier()
25208 p->validYMD = 0; in parseModifier()
25209 p->iJD += (i64)D*86400000; in parseModifier()
25224 /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the in parseModifier()
25236 tx.iJD -= 43200000; in parseModifier()
25238 tx.iJD -= day*86400000; in parseModifier()
25239 if( z0=='-' ) tx.iJD = -tx.iJD; in parseModifier()
25242 p->iJD += tx.iJD; in parseModifier()
25253 if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--; in parseModifier()
25256 rRounder = r<0 ? -0.5 : +0.5; in parseModifier()
25257 p->nFloor = 0; in parseModifier()
25261 && r>-aXformType[i].rLimit && r<aXformType[i].rLimit in parseModifier()
25267 p->M += (int)r; in parseModifier()
25268 x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; in parseModifier()
25269 p->Y += x; in parseModifier()
25270 p->M -= x*12; in parseModifier()
25272 p->validJD = 0; in parseModifier()
25273 r -= (int)r; in parseModifier()
25280 assert( p->M>=0 && p->M<=12 ); in parseModifier()
25281 p->Y += y; in parseModifier()
25283 p->validJD = 0; in parseModifier()
25284 r -= (int)r; in parseModifier()
25289 p->iJD += (sqlite3_int64)(r*1000.0*aXformType[i].rXform + rRounder); in parseModifier()
25305 ** Process time function arguments. argv[0] is a date-time stamp.
25342 if( p->isError || !validJulianDay(p->iJD) ) return 1; in isDate()
25343 if( argc==1 && p->validYMD && p->D>28 ){ in isDate()
25344 /* Make sure a YYYY-MM-DD is normalized. in isDate()
25345 ** Example: 2023-02-31 -> 2023-03-03 */ in isDate()
25346 assert( p->validJD ); in isDate()
25347 p->validYMD = 0; in isDate()
25379 ** the unix epoch of 1970-01-01 00:00:00 GMT.
25390 sqlite3_result_double(context, (x.iJD - 21086676*(i64)10000000)/1000.0); in unixepochFunc()
25392 sqlite3_result_int64(context, x.iJD/1000 - 21086676*(i64)10000); in unixepochFunc()
25400 ** Return YYYY-MM-DD HH:MM:SS
25413 if( Y<0 ) Y = -Y; in datetimeFunc()
25415 zBuf[2] = '0' + (Y/100)%10; in datetimeFunc()
25418 zBuf[5] = '-'; in datetimeFunc()
25421 zBuf[8] = '-'; in datetimeFunc()
25436 zBuf[21] = '0' + (s/100)%10; in datetimeFunc()
25449 zBuf[0] = '-'; in datetimeFunc()
25452 sqlite3_result_text(context, &zBuf[1], n-1, SQLITE_TRANSIENT); in datetimeFunc()
25483 zBuf[9] = '0' + (s/100)%10; in timeFunc()
25502 ** Return YYYY-MM-DD
25515 if( Y<0 ) Y = -Y; in dateFunc()
25517 zBuf[2] = '0' + (Y/100)%10; in dateFunc()
25520 zBuf[5] = '-'; in dateFunc()
25523 zBuf[8] = '-'; in dateFunc()
25528 zBuf[0] = '-'; in dateFunc()
25539 ** In other words, compute the zero-based day number for the
25549 assert( pDate->validJD ); in daysAfterJan01()
25554 return (int)((pDate->iJD-jan01.iJD+43200000)/86400000); in daysAfterJan01()
25566 assert( pDate->validJD ); in daysAfterMonday()
25567 return (int)((pDate->iJD+43200000)/86400000) % 7; in daysAfterMonday()
25579 assert( pDate->validJD ); in daysAfterSunday()
25580 return (int)((pDate->iJD+129600000)/86400000) % 7; in daysAfterSunday()
25588 ** %d day of month 01-31
25589 ** %e day of month 1-31
25591 ** %F ISO date. YYYY-MM-DD
25592 ** %G ISO year corresponding to %V 0000-9999.
25593 ** %g 2-digit ISO year corresponding to %V 00-99
25594 ** %H hour 00-24
25595 ** %k hour 0-24 (leading zero converted to space)
25596 ** %I hour 01-12
25597 ** %j day of year 001-366
25599 ** %l hour 1-12 (leading zero converted to space)
25600 ** %m month 01-12
25601 ** %M minute 00-59
25605 ** %s seconds since 1970-01-01
25606 ** %S seconds 00-59
25608 ** %u day of week 1-7 Monday==1, Sunday==7
25609 ** %w day of week 0-6 Sunday==0, Monday==1
25610 ** %U week of year 00-53 (First Sunday is start of week 01)
25611 ** %V week of year 01-53 (First week containing Thursday is week 01)
25612 ** %W week of year 00-53 (First Monday is start of week 01)
25613 ** %Y year 0000-9999
25630 if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return; in strftimeFunc()
25632 sqlite3StrAccumInit(&sRes, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); in strftimeFunc()
25639 if( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j)); in strftimeFunc()
25649 case 'f': { /* Fractional seconds. (Non-standard) */ in strftimeFunc()
25656 sqlite3_str_appendf(&sRes, "%04d-%02d-%02d", x.Y, x.M, x.D); in strftimeFunc()
25664 y.iJD += (3 - daysAfterMonday(&x))*86400000; in strftimeFunc()
25668 sqlite3_str_appendf(&sRes, "%02d", y.Y%100); in strftimeFunc()
25682 if( h>12 ) h -= 12; in strftimeFunc()
25691 case 'J': { /* Julian day number. (Non-standard) */ in strftimeFunc()
25719 (x.iJD - 21086676*(i64)10000000)/1000.0); in strftimeFunc()
25721 i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000); in strftimeFunc()
25741 case 'U': { /* Week num. 00-53. First Sun of the year is week 01 */ in strftimeFunc()
25743 (daysAfterJan01(&x)-daysAfterSunday(&x)+7)/7); in strftimeFunc()
25746 case 'V': { /* Week num. 01-53. First week with a Thur is week 01 */ in strftimeFunc()
25750 y.iJD += (3 - daysAfterMonday(&x))*86400000; in strftimeFunc()
25756 case 'W': { /* Week num. 00-53. First Mon of the year is week 01 */ in strftimeFunc()
25758 (daysAfterJan01(&x)-daysAfterMonday(&x)+7)/7); in strftimeFunc()
25775 if( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j)); in strftimeFunc()
25813 ** +YYYY-MM-DD HH:MM:SS.SSS
25815 ** The initial "+" becomes "-" if DATE1 occurs before DATE2. For
25821 ** ISO-8601 string. The unix timestamps are not supported by this
25840 Y = d1.Y - d2.Y; in timediffFunc()
25846 M = d1.M - d2.M; in timediffFunc()
25848 Y--; in timediffFunc()
25857 M--; in timediffFunc()
25860 Y--; in timediffFunc()
25862 d2.M--; in timediffFunc()
25865 d2.Y--; in timediffFunc()
25870 d1.iJD -= d2.iJD; in timediffFunc()
25873 sign = '-'; in timediffFunc()
25874 Y = d2.Y - d1.Y; in timediffFunc()
25880 M = d2.M - d1.M; in timediffFunc()
25882 Y--; in timediffFunc()
25891 M--; in timediffFunc()
25894 Y--; in timediffFunc()
25904 d1.iJD = d2.iJD - d1.iJD; in timediffFunc()
25909 sqlite3StrAccumInit(&sRes, 0, 0, 0, 100); in timediffFunc()
25910 sqlite3_str_appendf(&sRes, "%c%04d-%02d-%02d %02d:%02d:%06.3f", in timediffFunc()
25911 sign, Y, M, d1.D-1, d1.h, d1.m, d1.s); in timediffFunc()
25933 ** If the library is compiled to omit the full-scale date and time
25939 ** This function uses the C-library functions time(), gmtime()
25941 ** as the user-data for the function.
25960 t = iT/1000 - 10000*(sqlite3_int64)21086676; in currentTimeFunc()
25971 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); in currentTimeFunc()
26000 sqlite3_result_text(context, zJson, -1, sqlite3_free); in datedebugFunc()
26014 PURE_DATE(julianday, -1, 0, 0, juliandayFunc ), in sqlite3RegisterDateTimeFunctions()
26015 PURE_DATE(unixepoch, -1, 0, 0, unixepochFunc ), in sqlite3RegisterDateTimeFunctions()
26016 PURE_DATE(date, -1, 0, 0, dateFunc ), in sqlite3RegisterDateTimeFunctions()
26017 PURE_DATE(time, -1, 0, 0, timeFunc ), in sqlite3RegisterDateTimeFunctions()
26018 PURE_DATE(datetime, -1, 0, 0, datetimeFunc ), in sqlite3RegisterDateTimeFunctions()
26019 PURE_DATE(strftime, -1, 0, 0, strftimeFunc ), in sqlite3RegisterDateTimeFunctions()
26022 PURE_DATE(datedebug, -1, 0, 0, datedebugFunc ), in sqlite3RegisterDateTimeFunctions()
26029 STR_FUNCTION(current_date, 0, "%Y-%m-%d", 0, currentTimeFunc), in sqlite3RegisterDateTimeFunctions()
26030 STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc), in sqlite3RegisterDateTimeFunctions()
26062 SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
26080 ** from within OsOpen()), but some third-party implementations may.
26120 if( pId->pMethods ){ in sqlite3OsClose()
26121 pId->pMethods->xClose(pId); in sqlite3OsClose()
26122 pId->pMethods = 0; in sqlite3OsClose()
26127 return id->pMethods->xRead(id, pBuf, amt, offset); in sqlite3OsRead()
26131 return id->pMethods->xWrite(id, pBuf, amt, offset); in sqlite3OsWrite()
26134 return id->pMethods->xTruncate(id, size); in sqlite3OsTruncate()
26138 return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK; in sqlite3OsSync()
26142 return id->pMethods->xFileSize(id, pSize); in sqlite3OsFileSize()
26147 return id->pMethods->xLock(id, lockType); in sqlite3OsLock()
26151 return id->pMethods->xUnlock(id, lockType); in sqlite3OsUnlock()
26155 return id->pMethods->xCheckReservedLock(id, pResOut); in sqlite3OsCheckReservedLock()
26167 if( id->pMethods==0 ) return SQLITE_NOTFOUND; in sqlite3OsFileControl()
26177 ** confuses the test scripts - the COMMIT command returns SQLITE_NOMEM in sqlite3OsFileControl()
26185 ** The CKPT_DONE and CKPT_START file-controls are write-only signals in sqlite3OsFileControl()
26192 return id->pMethods->xFileControl(id, op, pArg); in sqlite3OsFileControl()
26195 if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg); in sqlite3OsFileControlHint()
26199 int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; in sqlite3OsSectorSize()
26203 if( NEVER(id->pMethods==0) ) return 0; in sqlite3OsDeviceCharacteristics()
26204 return id->pMethods->xDeviceCharacteristics(id); in sqlite3OsDeviceCharacteristics()
26208 return id->pMethods->xShmLock(id, offset, n, flags); in sqlite3OsShmLock()
26211 id->pMethods->xShmBarrier(id); in sqlite3OsShmBarrier()
26214 return id->pMethods->xShmUnmap(id, deleteFlag); in sqlite3OsShmUnmap()
26224 return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp); in sqlite3OsShmMap()
26232 return id->pMethods->xFetch(id, iOff, iAmt, pp); in sqlite3OsFetch()
26235 return id->pMethods->xUnfetch(id, iOff, p); in sqlite3OsUnfetch()
26238 /* No-op stubs to use when memory-mapped I/O is disabled */
26266 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); in sqlite3OsOpen()
26267 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
26273 return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK; in sqlite3OsDelete()
26282 return pVfs->xAccess(pVfs, zPath, flags, pResOut); in sqlite3OsAccess()
26292 return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); in sqlite3OsFullPathname()
26297 assert( strlen(zPath)<=SQLITE_MAX_PATHLEN ); /* tag-20210611-1 */ in sqlite3OsDlOpen()
26298 return pVfs->xDlOpen(pVfs, zPath); in sqlite3OsDlOpen()
26301 pVfs->xDlError(pVfs, nByte, zBufOut); in sqlite3OsDlError()
26304 return pVfs->xDlSym(pVfs, pHdle, zSym); in sqlite3OsDlSym()
26307 pVfs->xDlClose(pVfs, pHandle); in sqlite3OsDlClose()
26317 return pVfs->xRandomness(pVfs, nByte, zBufOut); in sqlite3OsRandomness()
26322 return pVfs->xSleep(pVfs, nMicro); in sqlite3OsSleep()
26325 return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0; in sqlite3OsGetLastError()
26329 /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64() in sqlite3OsCurrentTimeInt64()
26335 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ in sqlite3OsCurrentTimeInt64()
26336 rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut); in sqlite3OsCurrentTimeInt64()
26339 rc = pVfs->xCurrentTime(pVfs, &r); in sqlite3OsCurrentTimeInt64()
26354 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); in sqlite3OsOpenMalloc()
26412 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ in sqlite3_vfs_find()
26414 if( strcmp(zVfs, pVfs->zName)==0 ) break; in sqlite3_vfs_find()
26426 /* No-op */ in vfsUnlink()
26428 vfsList = pVfs->pNext; in vfsUnlink()
26431 while( p->pNext && p->pNext!=pVfs ){ in vfsUnlink()
26432 p = p->pNext; in vfsUnlink()
26434 if( p->pNext==pVfs ){ in vfsUnlink()
26435 p->pNext = pVfs->pNext; in vfsUnlink()
26459 pVfs->pNext = vfsList; in sqlite3_vfs_register()
26462 pVfs->pNext = vfsList->pNext; in sqlite3_vfs_register()
26463 vfsList->pNext = pVfs; in sqlite3_vfs_register()
26505 ** Most malloc failures are non-benign. After they occur, SQLite
26529 ** we have to locate the state vector at run-time. In the more common
26559 ** indicates that subsequent malloc failures are non-benign.
26590 ** This file contains a no-op memory allocation drivers for use when
26600 ** used when no other memory allocator is specified using compile-time
26606 ** No-op versions of all memory allocation routines
26619 ** Populate the low-level memory allocation function pointers in
26652 ** This file contains low-level memory allocation drivers for when
26653 ** SQLite will use the standard C-library malloc/realloc/free interface
26656 ** This file contains implementations of the low-level memory allocation
26664 ** C-preprocessor macro summary:
26671 ** a different name, using a separate -D
26687 ** used when no other memory allocator is specified using compile-time
26707 (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
26712 ** Use standard C library malloc and free on non-Apple systems.
26729 ** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires
26763 ** For this low-level routine, we are guaranteed that nByte>0 because
26797 ** For this low-level routine, we already know that pPrior!=0 since
26799 ** by higher-level routines.
26807 p--; in sqlite3MemFree()
26824 p--; in sqlite3MemSize()
26833 ** For this low-level interface, we know that pPrior!=0. Cases where
26834 ** pPrior==0 while have been intercepted by higher-level routine and
26836 ** cases where nByte<=0 will have been intercepted by higher-level
26852 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
26853 p--; in sqlite3MemRealloc()
26913 ** Populate the low-level memory allocation function pointers in
26946 ** This file contains low-level memory allocation drivers for when
26947 ** SQLite will use the standard C-library malloc/realloc/free interface
26952 ** This file contains implementations of the low-level memory allocation
26978 ** ------------------------------------------------------------------------
26980 ** ------------------------------------------------------------------------
27038 char zTitle[100]; /* The title text */
27064 if( i>NCSIZE-1 ){ in adjustStats()
27065 i = NCSIZE - 1; in adjustStats()
27074 mem.nCurrent[i]--; in adjustStats()
27092 p--; in sqlite3MemsysGetHeader()
27093 assert( p->iForeGuard==(int)FOREGUARD ); in sqlite3MemsysGetHeader()
27094 nReserve = ROUND8(p->iSize); in sqlite3MemsysGetHeader()
27102 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); in sqlite3MemsysGetHeader()
27115 return (int)pHdr->iSize; in sqlite3MemSize()
27148 ** Fill a buffer with pseudo-random bytes. This is used to preset
27157 x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); in randomFill()
27162 nByte -= 4; in randomFill()
27164 while( nByte-- > 0 ){ in randomFill()
27165 x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); in randomFill()
27193 pHdr->pNext = 0; in sqlite3MemMalloc()
27194 pHdr->pPrev = mem.pLast; in sqlite3MemMalloc()
27196 mem.pLast->pNext = pHdr; in sqlite3MemMalloc()
27201 pHdr->iForeGuard = FOREGUARD; in sqlite3MemMalloc()
27202 pHdr->eType = MEMTYPE_HEAP; in sqlite3MemMalloc()
27203 pHdr->nBacktraceSlots = mem.nBacktrace; in sqlite3MemMalloc()
27204 pHdr->nTitle = mem.nTitle; in sqlite3MemMalloc()
27207 pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1; in sqlite3MemMalloc()
27208 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); in sqlite3MemMalloc()
27211 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); in sqlite3MemMalloc()
27214 pHdr->nBacktrace = 0; in sqlite3MemMalloc()
27219 pHdr->iSize = nByte; in sqlite3MemMalloc()
27224 memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); in sqlite3MemMalloc()
27242 pBt -= pHdr->nBacktraceSlots; in sqlite3MemFree()
27244 if( pHdr->pPrev ){ in sqlite3MemFree()
27245 assert( pHdr->pPrev->pNext==pHdr ); in sqlite3MemFree()
27246 pHdr->pPrev->pNext = pHdr->pNext; in sqlite3MemFree()
27249 mem.pFirst = pHdr->pNext; in sqlite3MemFree()
27251 if( pHdr->pNext ){ in sqlite3MemFree()
27252 assert( pHdr->pNext->pPrev==pHdr ); in sqlite3MemFree()
27253 pHdr->pNext->pPrev = pHdr->pPrev; in sqlite3MemFree()
27256 mem.pLast = pHdr->pPrev; in sqlite3MemFree()
27259 z -= pHdr->nTitle; in sqlite3MemFree()
27260 adjustStats((int)pHdr->iSize, -1); in sqlite3MemFree()
27261 randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + in sqlite3MemFree()
27262 (int)pHdr->iSize + sizeof(int) + pHdr->nTitle); in sqlite3MemFree()
27280 assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ in sqlite3MemRealloc()
27284 memcpy(pNew, pPrior, (int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize)); in sqlite3MemRealloc()
27285 if( nByte>pOldHdr->iSize ){ in sqlite3MemRealloc()
27286 randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); in sqlite3MemRealloc()
27294 ** Populate the low-level memory allocation function pointers in
27318 assert( pHdr->iForeGuard==FOREGUARD ); in sqlite3MemdebugSetType()
27319 pHdr->eType = eType; in sqlite3MemdebugSetType()
27337 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugHasType()
27338 if( (pHdr->eType&eType)==0 ){ in sqlite3MemdebugHasType()
27359 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ in sqlite3MemdebugNoType()
27360 if( (pHdr->eType&eType)!=0 ){ in sqlite3MemdebugNoType()
27389 if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1; in sqlite3MemdebugSettitle()
27398 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ in sqlite3MemdebugSync()
27400 pBt -= pHdr->nBacktraceSlots; in sqlite3MemdebugSync()
27401 mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]); in sqlite3MemdebugSync()
27420 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ in sqlite3MemdebugDump()
27422 z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; in sqlite3MemdebugDump()
27424 pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); in sqlite3MemdebugDump()
27425 if( pHdr->nBacktrace ){ in sqlite3MemdebugDump()
27428 pBt -= pHdr->nBacktraceSlots; in sqlite3MemdebugDump()
27429 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); in sqlite3MemdebugDump()
27434 for(i=0; i<NCSIZE-1; i++){ in sqlite3MemdebugDump()
27440 if( mem.nAlloc[NCSIZE-1] ){ in sqlite3MemdebugDump()
27442 NCSIZE*8-8, mem.nAlloc[NCSIZE-1], in sqlite3MemdebugDump()
27443 mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]); in sqlite3MemdebugDump()
27495 ** mean that the library will use a memory-pool by default, just that
27536 ** two fields form a double-linked list of chunks of related sizes.
27573 ** True if we are evaluating an out-of-memory callback.
27601 u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
27634 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Unlink()
27636 size = mem3.aPool[i-1].u.hdr.size4x/4; in memsys3Unlink()
27637 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Unlink()
27640 memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]); in memsys3Unlink()
27669 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); in memsys3Link()
27670 size = mem3.aPool[i-1].u.hdr.size4x/4; in memsys3Link()
27671 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); in memsys3Link()
27674 memsys3LinkIntoList(i, &mem3.aiSmall[size-2]); in memsys3Link()
27713 ** size parameters for check-out and return a pointer to the
27720 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); in memsys3Checkout()
27721 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); in memsys3Checkout()
27722 x = mem3.aPool[i-1].u.hdr.size4x; in memsys3Checkout()
27723 mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2); in memsys3Checkout()
27724 mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock; in memsys3Checkout()
27725 mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2; in memsys3Checkout()
27737 if( nBlock>=mem3.szKeyBlk-1 ){ in memsys3FromKeyBlk()
27747 newi = mem3.iKeyBlk + mem3.szKeyBlk - nBlock; in memsys3FromKeyBlk()
27749 mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = nBlock; in memsys3FromKeyBlk()
27750 mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x |= 2; in memsys3FromKeyBlk()
27751 mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1; in memsys3FromKeyBlk()
27752 mem3.szKeyBlk -= nBlock; in memsys3FromKeyBlk()
27753 mem3.aPool[newi-1].u.hdr.prevSize = mem3.szKeyBlk; in memsys3FromKeyBlk()
27754 x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; in memsys3FromKeyBlk()
27755 mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; in memsys3FromKeyBlk()
27785 size = mem3.aPool[i-1].u.hdr.size4x; in memsys3Merge()
27789 assert( i > mem3.aPool[i-1].u.hdr.prevSize ); in memsys3Merge()
27790 prev = i - mem3.aPool[i-1].u.hdr.prevSize; in memsys3Merge()
27795 size = i + size/4 - prev; in memsys3Merge()
27796 x = mem3.aPool[prev-1].u.hdr.size4x & 2; in memsys3Merge()
27797 mem3.aPool[prev-1].u.hdr.size4x = size*4 | x; in memsys3Merge()
27798 mem3.aPool[prev+size-1].u.hdr.prevSize = size; in memsys3Merge()
27838 i = mem3.aiSmall[nBlock-2]; in memsys3MallocUnsafe()
27840 memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]); in memsys3MallocUnsafe()
27846 if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){ in memsys3MallocUnsafe()
27879 for(i=0; i<MX_SMALL-1; i++){ in memsys3MallocUnsafe()
27906 i = p - mem3.aPool; in memsys3FreeUnsafe()
27907 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); in memsys3FreeUnsafe()
27908 size = mem3.aPool[i-1].u.hdr.size4x/4; in memsys3FreeUnsafe()
27910 mem3.aPool[i-1].u.hdr.size4x &= ~1; in memsys3FreeUnsafe()
27911 mem3.aPool[i+size-1].u.hdr.prevSize = size; in memsys3FreeUnsafe()
27912 mem3.aPool[i+size-1].u.hdr.size4x &= ~2; in memsys3FreeUnsafe()
27917 while( (mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x&2)==0 ){ in memsys3FreeUnsafe()
27918 size = mem3.aPool[mem3.iKeyBlk-1].u.hdr.prevSize; in memsys3FreeUnsafe()
27919 mem3.iKeyBlk -= size; in memsys3FreeUnsafe()
27922 x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; in memsys3FreeUnsafe()
27923 mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; in memsys3FreeUnsafe()
27924 mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; in memsys3FreeUnsafe()
27926 x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; in memsys3FreeUnsafe()
27927 while( (mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x&1)==0 ){ in memsys3FreeUnsafe()
27929 mem3.szKeyBlk += mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x/4; in memsys3FreeUnsafe()
27930 mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; in memsys3FreeUnsafe()
27931 mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; in memsys3FreeUnsafe()
27938 ** size returned omits the 8-byte header overhead. This only
27945 assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); in memsys3Size()
27946 return (pBlock[-1].u.hdr.size4x&~3)*2 - 4; in memsys3Size()
27956 return ((n+11)&~7) - 4; in memsys3Roundup()
27996 if( nBytes<=nOld && nBytes>=nOld-128 ){ in memsys3Realloc()
28025 mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2; in memsys3Init()
28071 size = mem3.aPool[i-1].u.hdr.size4x; in sqlite3Memsys3Dump()
28077 if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){ in sqlite3Memsys3Dump()
28082 if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){ in sqlite3Memsys3Dump()
28088 fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8); in sqlite3Memsys3Dump()
28090 fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8, in sqlite3Memsys3Dump()
28094 for(i=0; i<MX_SMALL-1; i++){ in sqlite3Memsys3Dump()
28099 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); in sqlite3Memsys3Dump()
28108 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); in sqlite3Memsys3Dump()
28113 fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szKeyBlk*8); in sqlite3Memsys3Dump()
28114 fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnKeyBlk*8); in sqlite3Memsys3Dump()
28130 ** Populate the low-level memory allocation function pointers in
28191 ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
28200 ** N >= M*(1 + log2(n)/2) - n + 1
28229 ** mem5.szAtom is always at least 8 and 32-bit integers are used,
28264 u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
28295 ** structures, return a pointer to the idx-th such link.
28309 next = MEM5LINK(i)->next; in memsys5Unlink()
28310 prev = MEM5LINK(i)->prev; in memsys5Unlink()
28314 MEM5LINK(prev)->next = next; in memsys5Unlink()
28317 MEM5LINK(next)->prev = prev; in memsys5Unlink()
28332 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize]; in memsys5Link()
28333 MEM5LINK(i)->prev = -1; in memsys5Link()
28336 MEM5LINK(x)->prev = i; in memsys5Link()
28358 i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); in memsys5Size()
28413 iBin--; in memsys5MallocUnsafe()
28424 mem5.totalExcess += iFullSz - nByte; in memsys5MallocUnsafe()
28451 iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom); in memsys5FreeUnsafe()
28453 /* Check that the pointer pOld points to a valid, non-free block. */ in memsys5FreeUnsafe()
28455 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 ); in memsys5FreeUnsafe()
28460 assert( iBlock+size-1<(u32)mem5.nBlock ); in memsys5FreeUnsafe()
28463 mem5.aCtrl[iBlock+size-1] |= CTRL_FREE; in memsys5FreeUnsafe()
28468 mem5.currentCount--; in memsys5FreeUnsafe()
28469 mem5.currentOut -= size*mem5.szAtom; in memsys5FreeUnsafe()
28478 iBuddy = iBlock - size; in memsys5FreeUnsafe()
28540 ** memsys5Round(). Hence nBytes is always a non-negative power
28549 assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ in memsys5Realloc()
28572 ** 32-bit signed integer. Hence the largest allocation is 0x40000000
28592 ** Return the ceiling of the logarithm base 2 of iValue.
28594 ** Examples: memsys5Log(1) -> 0
28595 ** memsys5Log(2) -> 1
28596 ** memsys5Log(4) -> 2
28597 ** memsys5Log(5) -> 3
28598 ** memsys5Log(8) -> 3
28599 ** memsys5Log(9) -> 4
28603 for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++); in memsys5Log()
28617 int nMinLog; /* Log base 2 of minimum allocation size in bytes */ in memsys5Init()
28628 assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 ); in memsys5Init()
28646 mem5.aiFreelist[ii] = -1; in memsys5Init()
28650 for(ii=LOGMAX; ii>=0; ii--){ in memsys5Init()
28700 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){} in sqlite3Memsys5Dump()
28791 ** to the type of mutex requested - SQLITE_MUTEX_RECURSIVE, SQLITE_MUTEX_FAST
28802 #define SQLITE_MUTEX_WARNONCONTENTION (-1)
28812 return pGlobalMutexMethods->xMutexHeld(((CheckMutex*)p)->mutex); in checkMutexHeld()
28815 return pGlobalMutexMethods->xMutexNotheld(((CheckMutex*)p)->mutex); in checkMutexNotheld()
28846 p->iType = iType; in checkMutexAlloc()
28849 if( iType-2>=ArraySize(staticMutexes) ){ in checkMutexAlloc()
28854 p = &staticMutexes[iType-2]; in checkMutexAlloc()
28857 if( p->mutex==0 ){ in checkMutexAlloc()
28858 p->mutex = pGlobalMutexMethods->xMutexAlloc(iType); in checkMutexAlloc()
28859 if( p->mutex==0 ){ in checkMutexAlloc()
28879 if( ((CheckMutex*)p)->iType<2 ) in checkMutexFree()
28883 pGlobalMutexMethods->xMutexFree(pCheck->mutex); in checkMutexFree()
28898 if( pCheck->iType==SQLITE_MUTEX_WARNONCONTENTION ){ in checkMutexEnter()
28899 if( SQLITE_OK==pGlobalMutexMethods->xMutexTry(pCheck->mutex) ){ in checkMutexEnter()
28903 "illegal multi-threaded access to database connection" in checkMutexEnter()
28906 pGlobalMutexMethods->xMutexEnter(pCheck->mutex); in checkMutexEnter()
28914 return pGlobalMutexMethods->xMutexTry(pCheck->mutex); in checkMutexTry()
28922 pGlobalMutexMethods->xMutexLeave(pCheck->mutex); in checkMutexLeave()
28952 assert( pCheck->iType==SQLITE_MUTEX_RECURSIVE ); in sqlite3MutexWarnOnContention()
28953 pCheck->iType = SQLITE_MUTEX_WARNONCONTENTION; in sqlite3MutexWarnOnContention()
28981 pTo->xMutexInit = pFrom->xMutexInit; in sqlite3MutexInit()
28982 pTo->xMutexEnd = pFrom->xMutexEnd; in sqlite3MutexInit()
28983 pTo->xMutexFree = pFrom->xMutexFree; in sqlite3MutexInit()
28984 pTo->xMutexEnter = pFrom->xMutexEnter; in sqlite3MutexInit()
28985 pTo->xMutexTry = pFrom->xMutexTry; in sqlite3MutexInit()
28986 pTo->xMutexLeave = pFrom->xMutexLeave; in sqlite3MutexInit()
28987 pTo->xMutexHeld = pFrom->xMutexHeld; in sqlite3MutexInit()
28988 pTo->xMutexNotheld = pFrom->xMutexNotheld; in sqlite3MutexInit()
28990 pTo->xMutexAlloc = pFrom->xMutexAlloc; in sqlite3MutexInit()
29079 ** this function is a no-op.
29123 ** here are place-holders. Applications can substitute working
29124 ** mutex routines at start-time using the
29197 return p==0 || p->cnt>0; in debugMutexHeld()
29201 return p==0 || p->cnt==0; in debugMutexNotheld()
29216 static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1]; in debugMutexAlloc()
29223 pNew->id = id; in debugMutexAlloc()
29224 pNew->cnt = 0; in debugMutexAlloc()
29230 if( id-2<0 || id-2>=ArraySize(aStatic) ){ in debugMutexAlloc()
29235 pNew = &aStatic[id-2]; in debugMutexAlloc()
29236 pNew->id = id; in debugMutexAlloc()
29248 assert( p->cnt==0 ); in debugMutexFree()
29249 if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){ in debugMutexFree()
29271 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexEnter()
29272 p->cnt++; in debugMutexEnter()
29276 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexTry()
29277 p->cnt++; in debugMutexTry()
29290 p->cnt--; in debugMutexLeave()
29291 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); in debugMutexLeave()
29313 ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
29314 ** is used regardless of the run-time threadsafety setting.
29354 ** home-grown mutexes. Encapsulate these conditions into a single #define.
29397 ** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
29403 return (p->nRef!=0 && pthread_equal(p->owner, pthread_self())); in pthreadMutexHeld()
29406 return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0; in pthreadMutexNotheld()
29459 ** cases where it really needs one. If a faster non-recursive mutex
29500 pthread_mutex_init(&p->mutex, 0); in pthreadMutexAlloc()
29506 pthread_mutex_init(&p->mutex, &recursiveAttr); in pthreadMutexAlloc()
29510 p->id = SQLITE_MUTEX_RECURSIVE; in pthreadMutexAlloc()
29518 pthread_mutex_init(&p->mutex, 0); in pthreadMutexAlloc()
29520 p->id = SQLITE_MUTEX_FAST; in pthreadMutexAlloc()
29527 if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){ in pthreadMutexAlloc()
29532 p = &staticMutexes[iType-2]; in pthreadMutexAlloc()
29537 assert( p==0 || p->id==iType ); in pthreadMutexAlloc()
29549 assert( p->nRef==0 ); in pthreadMutexFree()
29551 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ) in pthreadMutexFree()
29554 pthread_mutex_destroy(&p->mutex); in pthreadMutexFree()
29576 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexEnter()
29581 ** is atomic - that it cannot be deceived into thinking self in pthreadMutexEnter()
29582 ** and p->owner are equal if p->owner changes between two values in pthreadMutexEnter()
29584 ** This implementation also assumes a coherent cache - that in pthreadMutexEnter()
29591 if( p->nRef>0 && pthread_equal(p->owner, self) ){ in pthreadMutexEnter()
29592 p->nRef++; in pthreadMutexEnter()
29594 pthread_mutex_lock(&p->mutex); in pthreadMutexEnter()
29595 assert( p->nRef==0 ); in pthreadMutexEnter()
29596 p->owner = self; in pthreadMutexEnter()
29597 p->nRef = 1; in pthreadMutexEnter()
29601 /* Use the built-in recursive mutexes if they are available. in pthreadMutexEnter()
29603 pthread_mutex_lock(&p->mutex); in pthreadMutexEnter()
29605 assert( p->nRef>0 || p->owner==0 ); in pthreadMutexEnter()
29606 p->owner = pthread_self(); in pthreadMutexEnter()
29607 p->nRef++; in pthreadMutexEnter()
29612 if( p->trace ){ in pthreadMutexEnter()
29613 printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexEnter()
29619 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); in pthreadMutexTry()
29624 ** is atomic - that it cannot be deceived into thinking self in pthreadMutexTry()
29625 ** and p->owner are equal if p->owner changes between two values in pthreadMutexTry()
29627 ** This implementation also assumes a coherent cache - that in pthreadMutexTry()
29634 if( p->nRef>0 && pthread_equal(p->owner, self) ){ in pthreadMutexTry()
29635 p->nRef++; in pthreadMutexTry()
29637 }else if( pthread_mutex_trylock(&p->mutex)==0 ){ in pthreadMutexTry()
29638 assert( p->nRef==0 ); in pthreadMutexTry()
29639 p->owner = self; in pthreadMutexTry()
29640 p->nRef = 1; in pthreadMutexTry()
29647 /* Use the built-in recursive mutexes if they are available. in pthreadMutexTry()
29649 if( pthread_mutex_trylock(&p->mutex)==0 ){ in pthreadMutexTry()
29651 p->owner = pthread_self(); in pthreadMutexTry()
29652 p->nRef++; in pthreadMutexTry()
29661 if( rc==SQLITE_OK && p->trace ){ in pthreadMutexTry()
29662 printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexTry()
29677 p->nRef--; in pthreadMutexLeave()
29678 if( p->nRef==0 ) p->owner = 0; in pthreadMutexLeave()
29680 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in pthreadMutexLeave()
29683 if( p->nRef==0 ){ in pthreadMutexLeave()
29684 pthread_mutex_unlock(&p->mutex); in pthreadMutexLeave()
29687 pthread_mutex_unlock(&p->mutex); in pthreadMutexLeave()
29691 if( p->trace ){ in pthreadMutexLeave()
29692 printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); in pthreadMutexLeave()
29797 ** Determine if we are dealing with Windows CE - which has a much reduced
29825 ** For some Windows sub-platforms, the _beginthreadex() / _endthreadex()
29880 return p->nRef!=0 && p->owner==GetCurrentThreadId(); in winMutexHeld()
29884 return p->nRef==0 || p->owner!=tid; in winMutexNotheld2()
29929 static int winMutex_isNt = -1; /* <0 means "need to query" */
30007 ** cases where it really needs one. If a faster non-recursive mutex
30033 p->id = iType; in winMutexAlloc()
30036 p->trace = 1; in winMutexAlloc()
30040 InitializeCriticalSectionEx(&p->mutex, 0, 0); in winMutexAlloc()
30042 InitializeCriticalSection(&p->mutex); in winMutexAlloc()
30049 if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){ in winMutexAlloc()
30054 p = &winMutex_staticMutexes[iType-2]; in winMutexAlloc()
30057 InterlockedCompareExchange(&p->trace, 1, 0); in winMutexAlloc()
30063 assert( p==0 || p->id==iType ); in winMutexAlloc()
30075 assert( p->nRef==0 && p->owner==0 ); in winMutexFree()
30076 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){ in winMutexFree()
30077 DeleteCriticalSection(&p->mutex); in winMutexFree()
30103 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); in winMutexEnter()
30108 EnterCriticalSection(&p->mutex); in winMutexEnter()
30110 assert( p->nRef>0 || p->owner==0 ); in winMutexEnter()
30111 p->owner = tid; in winMutexEnter()
30112 p->nRef++; in winMutexEnter()
30113 if( p->trace ){ in winMutexEnter()
30114 OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", in winMutexEnter()
30115 tid, p->id, p, p->trace, p->nRef)); in winMutexEnter()
30126 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); in winMutexTry()
30140 assert( winMutex_isNt>=-1 && winMutex_isNt<=1 ); in winMutexTry()
30145 if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){ in winMutexTry()
30147 p->owner = tid; in winMutexTry()
30148 p->nRef++; in winMutexTry()
30156 if( p->trace ){ in winMutexTry()
30157 OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n", in winMutexTry()
30158 tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc))); in winMutexTry()
30176 assert( p->nRef>0 ); in winMutexLeave()
30177 assert( p->owner==tid ); in winMutexLeave()
30178 p->nRef--; in winMutexLeave()
30179 if( p->nRef==0 ) p->owner = 0; in winMutexLeave()
30180 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); in winMutexLeave()
30183 LeaveCriticalSection(&p->mutex); in winMutexLeave()
30185 if( p->trace ){ in winMutexLeave()
30186 OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", in winMutexLeave()
30187 tid, p->id, p, p->trace, p->nRef)); in winMutexLeave()
30234 ** Attempt to release up to n bytes of non-essential memory currently
30235 ** held by SQLite. An example of non-essential memory is memory used to
30242 /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine in sqlite3_release_memory()
30243 ** is a no-op returning zero if SQLite is not compiled with in sqlite3_release_memory()
30285 ** no-op.
30300 ** Set the soft heap-size limit for the library. An argument of
30301 ** zero disables the limit. A negative argument is a no-op used to
30316 if( rc ) return -1; in sqlite3_soft_heap_limit64()
30331 excess = sqlite3_memory_used() - n; in sqlite3_soft_heap_limit64()
30341 ** Set the hard heap-size limit for the library. An argument of zero
30342 ** disables the hard heap limit. A negative argument is a no-op used
30356 if( rc ) return -1; in sqlite3_hard_heap_limit64()
30391 ** Return true if the heap is currently under memory pressure - in other
30441 ** This routine is called whenever an out-of-memory condition is seen,
30443 ** code debuggers when working on out-of-memory conditions, for example
30454 # define test_oom_breakpoint(X) /* No-op for production builds */
30467 /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal in mallocWithAlarm()
30477 if( nUsed >= mem0.alarmThreshold - nFull ){ in mallocWithAlarm()
30482 if( nUsed >= mem0.hardLimit - nFull ){ in mallocWithAlarm()
30514 ** This provides a 256-byte safety margin for defense against 32-bit
30543 assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */ in sqlite3Malloc()
30570 return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pTrueEnd); in isLookaside()
30586 return p<db->lookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL; in lookasideMallocSize()
30588 return db->lookaside.szTrue; in lookasideMallocSize()
30603 if( ((uptr)p)<(uptr)(db->lookaside.pTrueEnd) ){ in sqlite3DbMallocSize()
30605 if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ in sqlite3DbMallocSize()
30606 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocSize()
30610 if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ in sqlite3DbMallocSize()
30611 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocSize()
30612 return db->lookaside.szTrue; in sqlite3DbMallocSize()
30628 if( p==0 ) return; /* IMP: R-49053-54554 */ in sqlite3_free()
30644 ** *db->pnBytesFreed.
30647 *db->pnBytesFreed += sqlite3DbMallocSize(db,p); in measureAllocationSize()
30652 ** connection. Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op.
30653 ** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL.
30656 assert( db==0 || sqlite3_mutex_held(db->mutex) ); in sqlite3DbFreeNN()
30659 if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ in sqlite3DbFreeNN()
30661 if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ in sqlite3DbFreeNN()
30663 assert( db->pnBytesFreed==0 ); in sqlite3DbFreeNN()
30667 pBuf->pNext = db->lookaside.pSmallFree; in sqlite3DbFreeNN()
30668 db->lookaside.pSmallFree = pBuf; in sqlite3DbFreeNN()
30672 if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ in sqlite3DbFreeNN()
30674 assert( db->pnBytesFreed==0 ); in sqlite3DbFreeNN()
30676 memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ in sqlite3DbFreeNN()
30678 pBuf->pNext = db->lookaside.pFree; in sqlite3DbFreeNN()
30679 db->lookaside.pFree = pBuf; in sqlite3DbFreeNN()
30683 if( db->pnBytesFreed ){ in sqlite3DbFreeNN()
30696 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbNNFreeNN()
30698 if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ in sqlite3DbNNFreeNN()
30700 if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ in sqlite3DbNNFreeNN()
30702 assert( db->pnBytesFreed==0 ); in sqlite3DbNNFreeNN()
30706 pBuf->pNext = db->lookaside.pSmallFree; in sqlite3DbNNFreeNN()
30707 db->lookaside.pSmallFree = pBuf; in sqlite3DbNNFreeNN()
30711 if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ in sqlite3DbNNFreeNN()
30713 assert( db->pnBytesFreed==0 ); in sqlite3DbNNFreeNN()
30715 memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ in sqlite3DbNNFreeNN()
30717 pBuf->pNext = db->lookaside.pFree; in sqlite3DbNNFreeNN()
30718 db->lookaside.pFree = pBuf; in sqlite3DbNNFreeNN()
30722 if( db->pnBytesFreed ){ in sqlite3DbNNFreeNN()
30732 assert( db==0 || sqlite3_mutex_held(db->mutex) ); in sqlite3DbFree()
30745 return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */ in sqlite3Realloc()
30748 sqlite3_free(pOld); /* IMP: R-26507-47431 */ in sqlite3Realloc()
30756 /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second in sqlite3Realloc()
30766 nDiff = nNew - nOld; in sqlite3Realloc()
30768 mem0.alarmThreshold-nDiff ){ in sqlite3Realloc()
30770 if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){ in sqlite3Realloc()
30785 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); in sqlite3Realloc()
30791 assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ in sqlite3Realloc()
30803 if( n<0 ) n = 0; /* IMP: R-26507-47431 */ in sqlite3_realloc()
30847 (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP); in dbMallocRawFinish()
30856 ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
30863 ** int *a = (int*)sqlite3DbMallocRaw(db, 100);
30884 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocRawNN()
30885 assert( db->pnBytesFreed==0 ); in sqlite3DbMallocRawNN()
30886 if( n>db->lookaside.sz ){ in sqlite3DbMallocRawNN()
30887 if( !db->lookaside.bDisable ){ in sqlite3DbMallocRawNN()
30888 db->lookaside.anStat[1]++; in sqlite3DbMallocRawNN()
30889 }else if( db->mallocFailed ){ in sqlite3DbMallocRawNN()
30896 if( (pBuf = db->lookaside.pSmallFree)!=0 ){ in sqlite3DbMallocRawNN()
30897 db->lookaside.pSmallFree = pBuf->pNext; in sqlite3DbMallocRawNN()
30898 db->lookaside.anStat[0]++; in sqlite3DbMallocRawNN()
30900 }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){ in sqlite3DbMallocRawNN()
30901 db->lookaside.pSmallInit = pBuf->pNext; in sqlite3DbMallocRawNN()
30902 db->lookaside.anStat[0]++; in sqlite3DbMallocRawNN()
30907 if( (pBuf = db->lookaside.pFree)!=0 ){ in sqlite3DbMallocRawNN()
30908 db->lookaside.pFree = pBuf->pNext; in sqlite3DbMallocRawNN()
30909 db->lookaside.anStat[0]++; in sqlite3DbMallocRawNN()
30911 }else if( (pBuf = db->lookaside.pInit)!=0 ){ in sqlite3DbMallocRawNN()
30912 db->lookaside.pInit = pBuf->pNext; in sqlite3DbMallocRawNN()
30913 db->lookaside.anStat[0]++; in sqlite3DbMallocRawNN()
30916 db->lookaside.anStat[2]++; in sqlite3DbMallocRawNN()
30920 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbMallocRawNN()
30921 assert( db->pnBytesFreed==0 ); in sqlite3DbMallocRawNN()
30922 if( db->mallocFailed ){ in sqlite3DbMallocRawNN()
30939 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3DbRealloc()
30940 if( ((uptr)p)<(uptr)db->lookaside.pEnd ){ in sqlite3DbRealloc()
30942 if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){ in sqlite3DbRealloc()
30946 if( ((uptr)p)>=(uptr)db->lookaside.pStart ){ in sqlite3DbRealloc()
30947 if( n<=db->lookaside.szTrue ) return p; in sqlite3DbRealloc()
30956 if( db->mallocFailed==0 ){ in dbReallocFinish()
30972 (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP)); in dbReallocFinish()
31033 ** at least one non-space character */ in sqlite3DbSpanDup()
31037 n = (int)(zEnd - zStart); in sqlite3DbSpanDup()
31038 while( sqlite3Isspace(zStart[n-1]) ) n--; in sqlite3DbSpanDup()
31052 ** Call this routine to record the fact that an OOM (out-of-memory) error
31053 ** has happened. This routine will set db->mallocFailed, and also
31065 if( db->mallocFailed==0 && db->bBenignMalloc==0 ){ in sqlite3OomFault()
31066 db->mallocFailed = 1; in sqlite3OomFault()
31067 if( db->nVdbeExec>0 ){ in sqlite3OomFault()
31068 AtomicStore(&db->u1.isInterrupted, 1); in sqlite3OomFault()
31071 if( db->pParse ){ in sqlite3OomFault()
31073 sqlite3ErrorMsg(db->pParse, "out of memory"); in sqlite3OomFault()
31074 db->pParse->rc = SQLITE_NOMEM_BKPT; in sqlite3OomFault()
31075 for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){ in sqlite3OomFault()
31076 pParse->nErr++; in sqlite3OomFault()
31077 pParse->rc = SQLITE_NOMEM; in sqlite3OomFault()
31086 ** db->mallocFailed flag as necessary.
31092 if( db->mallocFailed && db->nVdbeExec==0 ){ in sqlite3OomClear()
31093 db->mallocFailed = 0; in sqlite3OomClear()
31094 AtomicStore(&db->u1.isInterrupted, 0); in sqlite3OomClear()
31095 assert( db->lookaside.bDisable>0 ); in sqlite3OomClear()
31104 if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){ in apiHandleError()
31109 return rc & db->errMask; in apiHandleError()
31121 ** If an OOM as occurred, then the connection error-code (the value
31126 ** Otherwise the read (and possible write) of db->mallocFailed in sqlite3ApiExit()
31130 assert( sqlite3_mutex_held(db->mutex) ); in sqlite3ApiExit()
31131 if( db->mallocFailed || rc ){ in sqlite3ApiExit()
31145 ** This file contains code for a set of "printf"-like routines. These
31156 #define etRADIX 0 /* non-decimal integer types. %x %o */
31172 #define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
31173 #define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
31180 ** An "etByte" is an 8-bit unsigned value.
31190 etByte base; /* The base for radix conversion */ member
31209 static const char aPrefix[] = "-x0\000X0";
31251 p->accError = eError; in sqlite3StrAccumSetError()
31252 if( p->mxAlloc ) sqlite3_str_reset(p); in sqlite3StrAccumSetError()
31253 if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError); in sqlite3StrAccumSetError()
31260 if( p->nArg<=p->nUsed ) return 0; in getIntArg()
31261 return sqlite3_value_int64(p->apArg[p->nUsed++]); in getIntArg()
31264 if( p->nArg<=p->nUsed ) return 0.0; in getDoubleArg()
31265 return sqlite3_value_double(p->apArg[p->nUsed++]); in getDoubleArg()
31268 if( p->nArg<=p->nUsed ) return 0; in getTextArg()
31269 return (char*)sqlite3_value_text(p->apArg[p->nUsed++]); in getTextArg()
31283 if( pAccum->accError ) return 0; in printfTempBuf()
31284 if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ in printfTempBuf()
31288 z = sqlite3DbMallocRaw(pAccum->db, n); in printfTempBuf()
31305 ** Hard limit on the precision of floating-point conversions.
31325 etByte flag_leftjustify; /* True if "-" flag is present */ in sqlite3_str_vappendf()
31335 char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ in sqlite3_str_vappendf()
31352 assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); in sqlite3_str_vappendf()
31355 if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){ in sqlite3_str_vappendf()
31369 sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt)); in sqlite3_str_vappendf()
31382 precision = -1; in sqlite3_str_vappendf()
31385 case '-': flag_leftjustify = 1; break; in sqlite3_str_vappendf()
31405 unsigned wx = c - '0'; in sqlite3_str_vappendf()
31407 wx = wx*10 + c - '0'; in sqlite3_str_vappendf()
31419 fmt--; in sqlite3_str_vappendf()
31431 width = width >= -2147483647 ? -width : 0; in sqlite3_str_vappendf()
31453 precision = precision >= -2147483647 ? -precision : -1; in sqlite3_str_vappendf()
31459 px = px*10 + c - '0'; in sqlite3_str_vappendf()
31471 --fmt; in sqlite3_str_vappendf()
31486 xtype = infop->type; in sqlite3_str_vappendf()
31497 ** flag_leftjustify TRUE if a '-' is present or if the in sqlite3_str_vappendf()
31502 ** always non-negative. Zero is the default. in sqlite3_str_vappendf()
31504 ** is -1. in sqlite3_str_vappendf()
31509 assert( precision>=(-1) ); in sqlite3_str_vappendf()
31520 if( infop->flags & FLAG_SIGNED ){ in sqlite3_str_vappendf()
31535 testcase( v==(-1) ); in sqlite3_str_vappendf()
31538 prefix = '-'; in sqlite3_str_vappendf()
31558 if( flag_zeropad && precision<width-(prefix!=0) ){ in sqlite3_str_vappendf()
31559 precision = width-(prefix!=0); in sqlite3_str_vappendf()
31561 if( precision<etBUFSIZE-10-etBUFSIZE/3 ){ in sqlite3_str_vappendf()
31572 bufpt = &zOut[nOut-1]; in sqlite3_str_vappendf()
31579 *(--bufpt) = zOrd[x*2+1]; in sqlite3_str_vappendf()
31580 *(--bufpt) = zOrd[x*2]; in sqlite3_str_vappendf()
31583 const char *cset = &aDigits[infop->charset]; in sqlite3_str_vappendf()
31584 u8 base = infop->base; in sqlite3_str_vappendf() local
31586 *(--bufpt) = cset[longvalue%base]; in sqlite3_str_vappendf()
31587 longvalue = longvalue/base; in sqlite3_str_vappendf()
31590 length = (int)(&zOut[nOut-1]-bufpt); in sqlite3_str_vappendf()
31592 *(--bufpt) = '0'; /* Zero pad */ in sqlite3_str_vappendf()
31596 int nn = (length - 1)/3; /* Number of "," to insert */ in sqlite3_str_vappendf()
31597 int ix = (length - 1)%3 + 1; in sqlite3_str_vappendf()
31598 bufpt -= nn; in sqlite3_str_vappendf()
31601 ix--; in sqlite3_str_vappendf()
31604 nn--; in sqlite3_str_vappendf()
31609 if( prefix ) *(--bufpt) = prefix; /* Add sign */ in sqlite3_str_vappendf()
31610 if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ in sqlite3_str_vappendf()
31613 pre = &aPrefix[infop->prefix]; in sqlite3_str_vappendf()
31614 for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; in sqlite3_str_vappendf()
31616 length = (int)(&zOut[nOut-1]-bufpt); in sqlite3_str_vappendf()
31637 iRound = -precision; in sqlite3_str_vappendf()
31655 memcpy(buf, "-Inf", 5); in sqlite3_str_vappendf()
31657 if( s.sign=='-' ){ in sqlite3_str_vappendf()
31658 /* no-op */ in sqlite3_str_vappendf()
31668 if( s.sign=='-' ){ in sqlite3_str_vappendf()
31669 prefix = '-'; in sqlite3_str_vappendf()
31674 exp = s.iDP-1; in sqlite3_str_vappendf()
31682 precision--; in sqlite3_str_vappendf()
31684 if( exp<-4 || exp>precision ){ in sqlite3_str_vappendf()
31687 precision = precision - exp; in sqlite3_str_vappendf()
31696 e2 = s.iDP - 1; in sqlite3_str_vappendf()
31719 for(; e2>=0; e2--){ in sqlite3_str_vappendf()
31730 for(e2++; e2<0 && precision>0; precision--, e2++){ in sqlite3_str_vappendf()
31734 while( (precision--)>0 ){ in sqlite3_str_vappendf()
31739 while( bufpt[-1]=='0' ) *(--bufpt) = 0; in sqlite3_str_vappendf()
31741 if( bufpt[-1]=='.' ){ in sqlite3_str_vappendf()
31745 *(--bufpt) = 0; in sqlite3_str_vappendf()
31751 exp = s.iDP - 1; in sqlite3_str_vappendf()
31752 *(bufpt++) = aDigits[infop->charset]; in sqlite3_str_vappendf()
31754 *(bufpt++) = '-'; exp = -exp; in sqlite3_str_vappendf()
31758 if( exp>=100 ){ in sqlite3_str_vappendf()
31759 *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */ in sqlite3_str_vappendf()
31760 exp %= 100; in sqlite3_str_vappendf()
31770 length = (int)(bufpt-zOut); in sqlite3_str_vappendf()
31777 int nPad = width - length; in sqlite3_str_vappendf()
31778 for(i=width; i>=nPad; i--){ in sqlite3_str_vappendf()
31779 bufpt[i] = bufpt[i-nPad]; in sqlite3_str_vappendf()
31782 while( nPad-- ) bufpt[i++] = '0'; in sqlite3_str_vappendf()
31789 *(va_arg(ap,int*)) = pAccum->nChar; in sqlite3_str_vappendf()
31836 width -= precision-1; in sqlite3_str_vappendf()
31838 sqlite3_str_appendchar(pAccum, width-1, ' '); in sqlite3_str_vappendf()
31842 precision--; in sqlite3_str_vappendf()
31845 if( nPrior > precision-1 ) nPrior = precision - 1; in sqlite3_str_vappendf()
31847 if( nCopyBytes + pAccum->nChar >= pAccum->nAlloc ){ in sqlite3_str_vappendf()
31850 if( pAccum->accError ) break; in sqlite3_str_vappendf()
31852 &pAccum->zText[pAccum->nChar-nCopyBytes], nCopyBytes); in sqlite3_str_vappendf()
31853 precision -= nPrior; in sqlite3_str_vappendf()
31871 if( pAccum->nChar==0 in sqlite3_str_vappendf()
31872 && pAccum->mxAlloc in sqlite3_str_vappendf()
31875 && pAccum->accError==0 in sqlite3_str_vappendf()
31880 assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); in sqlite3_str_vappendf()
31881 pAccum->zText = bufpt; in sqlite3_str_vappendf()
31882 pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt); in sqlite3_str_vappendf()
31883 pAccum->nChar = 0x7fffffff & (int)strlen(bufpt); in sqlite3_str_vappendf()
31884 pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED; in sqlite3_str_vappendf()
31895 while( precision-- > 0 && z[0] ){ in sqlite3_str_vappendf()
31898 length = (int)(z - (unsigned char*)bufpt); in sqlite3_str_vappendf()
31907 /* Adjust width to account for extra bytes in UTF-8 characters */ in sqlite3_str_vappendf()
31908 int ii = length - 1; in sqlite3_str_vappendf()
31909 while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++; in sqlite3_str_vappendf()
31934 for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){ in sqlite3_str_vappendf()
31961 if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; in sqlite3_str_vappendf()
31966 sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); in sqlite3_str_vappendf()
31967 sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); in sqlite3_str_vappendf()
31973 if( pToken && pToken->n ){ in sqlite3_str_vappendf()
31974 sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); in sqlite3_str_vappendf()
31975 sqlite3RecordErrorByteOffset(pAccum->db, pToken->z); in sqlite3_str_vappendf()
31983 if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; in sqlite3_str_vappendf()
31986 if( pItem->zAlias && !flag_altform2 ){ in sqlite3_str_vappendf()
31987 sqlite3_str_appendall(pAccum, pItem->zAlias); in sqlite3_str_vappendf()
31988 }else if( pItem->zName ){ in sqlite3_str_vappendf()
31989 if( pItem->zDatabase ){ in sqlite3_str_vappendf()
31990 sqlite3_str_appendall(pAccum, pItem->zDatabase); in sqlite3_str_vappendf()
31993 sqlite3_str_appendall(pAccum, pItem->zName); in sqlite3_str_vappendf()
31994 }else if( pItem->zAlias ){ in sqlite3_str_vappendf()
31995 sqlite3_str_appendall(pAccum, pItem->zAlias); in sqlite3_str_vappendf()
31997 Select *pSel = pItem->pSelect; in sqlite3_str_vappendf()
31998 assert( pSel!=0 ); /* Because of tag-20240424-1 */ in sqlite3_str_vappendf()
31999 if( pSel->selFlags & SF_NestedFrom ){ in sqlite3_str_vappendf()
32000 sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId); in sqlite3_str_vappendf()
32001 }else if( pSel->selFlags & SF_MultiValue ){ in sqlite3_str_vappendf()
32002 assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy ); in sqlite3_str_vappendf()
32003 sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE", in sqlite3_str_vappendf()
32004 pItem->u1.nRow); in sqlite3_str_vappendf()
32006 sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId); in sqlite3_str_vappendf()
32025 width -= length; in sqlite3_str_vappendf()
32035 sqlite3DbFree(pAccum->db, zExtra); in sqlite3_str_vappendf()
32054 if( db->errByteOffset!=(-2) ) return; in sqlite3RecordErrorByteOffset()
32055 pParse = db->pParse; in sqlite3RecordErrorByteOffset()
32057 zText =pParse->zTail; in sqlite3RecordErrorByteOffset()
32061 db->errByteOffset = (int)(z-zText); in sqlite3RecordErrorByteOffset()
32071 && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) in sqlite3RecordErrorOffsetOfExpr()
32073 pExpr = pExpr->pLeft; in sqlite3RecordErrorOffsetOfExpr()
32076 db->errByteOffset = pExpr->w.iOfst; in sqlite3RecordErrorOffsetOfExpr()
32088 assert( p->nChar+N >= p->nAlloc ); /* Only called if really needed */ in sqlite3StrAccumEnlarge()
32089 if( p->accError ){ in sqlite3StrAccumEnlarge()
32090 testcase(p->accError==SQLITE_TOOBIG); in sqlite3StrAccumEnlarge()
32091 testcase(p->accError==SQLITE_NOMEM); in sqlite3StrAccumEnlarge()
32094 if( p->mxAlloc==0 ){ in sqlite3StrAccumEnlarge()
32096 return p->nAlloc - p->nChar - 1; in sqlite3StrAccumEnlarge()
32098 char *zOld = isMalloced(p) ? p->zText : 0; in sqlite3StrAccumEnlarge()
32099 i64 szNew = p->nChar + N + 1; in sqlite3StrAccumEnlarge()
32100 if( szNew+p->nChar<=p->mxAlloc ){ in sqlite3StrAccumEnlarge()
32103 szNew += p->nChar; in sqlite3StrAccumEnlarge()
32105 if( szNew > p->mxAlloc ){ in sqlite3StrAccumEnlarge()
32110 p->nAlloc = (int)szNew; in sqlite3StrAccumEnlarge()
32112 if( p->db ){ in sqlite3StrAccumEnlarge()
32113 zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc); in sqlite3StrAccumEnlarge()
32115 zNew = sqlite3Realloc(zOld, p->nAlloc); in sqlite3StrAccumEnlarge()
32118 assert( p->zText!=0 || p->nChar==0 ); in sqlite3StrAccumEnlarge()
32119 if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar); in sqlite3StrAccumEnlarge()
32120 p->zText = zNew; in sqlite3StrAccumEnlarge()
32121 p->nAlloc = sqlite3DbMallocSize(p->db, zNew); in sqlite3StrAccumEnlarge()
32122 p->printfFlags |= SQLITE_PRINTF_MALLOCED; in sqlite3StrAccumEnlarge()
32137 testcase( p->nChar + (i64)N > 0x7fffffff ); in sqlite3_str_appendchar()
32138 if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){ in sqlite3_str_appendchar()
32141 while( (N--)>0 ) p->zText[p->nChar++] = c; in sqlite3_str_appendchar()
32148 ** This is a helper routine to sqlite3_str_append() that does special-case
32155 memcpy(&p->zText[p->nChar], z, N); in enlargeAndAppend()
32156 p->nChar += N; in enlargeAndAppend()
32166 assert( p->zText!=0 || p->nChar==0 || p->accError ); in sqlite3_str_append()
32168 assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 ); in sqlite3_str_append()
32169 if( p->nChar+N >= p->nAlloc ){ in sqlite3_str_append()
32172 assert( p->zText ); in sqlite3_str_append()
32173 p->nChar += N; in sqlite3_str_append()
32174 memcpy(&p->zText[p->nChar-N], z, N); in sqlite3_str_append()
32179 ** Append the complete text of zero-terminated string z[] to the p string.
32187 ** Finish off a string by making sure it is zero-terminated.
32193 assert( p->mxAlloc>0 && !isMalloced(p) ); in strAccumFinishRealloc()
32194 zText = sqlite3DbMallocRaw(p->db, p->nChar+1 ); in strAccumFinishRealloc()
32196 memcpy(zText, p->zText, p->nChar+1); in strAccumFinishRealloc()
32197 p->printfFlags |= SQLITE_PRINTF_MALLOCED; in strAccumFinishRealloc()
32201 p->zText = zText; in strAccumFinishRealloc()
32205 if( p->zText ){ in sqlite3StrAccumFinish()
32206 p->zText[p->nChar] = 0; in sqlite3StrAccumFinish()
32207 if( p->mxAlloc>0 && !isMalloced(p) ){ in sqlite3StrAccumFinish()
32211 return p->zText; in sqlite3StrAccumFinish()
32219 if( p->accError ){ in sqlite3ResultStrAccum()
32220 sqlite3_result_error_code(pCtx, p->accError); in sqlite3ResultStrAccum()
32223 sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC); in sqlite3ResultStrAccum()
32255 return p ? p->accError : SQLITE_NOMEM; in sqlite3_str_errcode()
32260 return p ? p->nChar : 0; in sqlite3_str_length()
32265 if( p==0 || p->nChar==0 ) return 0; in sqlite3_str_value()
32266 p->zText[p->nChar] = 0; in sqlite3_str_value()
32267 return p->zText; in sqlite3_str_value()
32275 sqlite3DbFree(p->db, p->zText); in sqlite3_str_reset()
32276 p->printfFlags &= ~SQLITE_PRINTF_MALLOCED; in sqlite3_str_reset()
32278 p->nAlloc = 0; in sqlite3_str_reset()
32279 p->nChar = 0; in sqlite3_str_reset()
32280 p->zText = 0; in sqlite3_str_reset()
32288 ** memory is used if not NULL. db->mallocFailed is set appropriately
32298 p->zText = zBase; in sqlite3StrAccumInit()
32299 p->db = db; in sqlite3StrAccumInit()
32300 p->nAlloc = n; in sqlite3StrAccumInit()
32301 p->mxAlloc = mx; in sqlite3StrAccumInit()
32302 p->nChar = 0; in sqlite3StrAccumInit()
32303 p->accError = 0; in sqlite3StrAccumInit()
32304 p->printfFlags = 0; in sqlite3StrAccumInit()
32312 db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH); in sqlite3_str_new()
32321 ** %-conversion extensions.
32329 db->aLimit[SQLITE_LIMIT_LENGTH]); in sqlite3VMPrintf()
32341 ** %-conversion extensions.
32354 ** %-conversion extensions.
32378 ** %-conversion extensions.
32442 ** stack space on small-stack systems when logging is disabled.
32504 ** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
32527 p--; in sqlite3RCStrRef()
32528 p->nRCRef++; in sqlite3RCStrRef()
32539 p--; in sqlite3RCStrUnref()
32540 assert( p->nRCRef>0 ); in sqlite3RCStrUnref()
32541 if( p->nRCRef>=2 ){ in sqlite3RCStrUnref()
32542 p->nRCRef--; in sqlite3RCStrUnref()
32560 p->nRCRef = 1; in sqlite3RCStrNew()
32572 p--; in sqlite3RCStrResize()
32573 assert( p->nRCRef==1 ); in sqlite3RCStrResize()
32586 ** 2015-06-08
32618 p->iLevel++; in sqlite3TreeViewPush()
32621 if( p->iLevel<(int)sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow; in sqlite3TreeViewPush()
32630 p->iLevel--; in sqlite3TreeViewPop()
32631 if( p->iLevel<0 ){ in sqlite3TreeViewPop()
32648 for(i=0; i<p->iLevel && i<(int)sizeof(p->bLine)-1; i++){ in sqlite3TreeViewLine()
32649 sqlite3_str_append(&acc, p->bLine[i] ? "| " : " ", 4); in sqlite3TreeViewLine()
32651 sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); in sqlite3TreeViewLine()
32687 int colMoreToFollow = i<(nCol - 1); in sqlite3TreeViewColumnList()
32702 printf(" X-%s", z); in sqlite3TreeViewColumnList()
32710 if( flg & COLFLAG_NOEXPAND ) printf(" NO-EXPAND"); in sqlite3TreeViewColumnList()
32721 ** Generate a human-readable description of a WITH clause.
32726 if( pWith->nCte==0 ) return; in sqlite3TreeViewWith()
32727 if( pWith->pOuter ){ in sqlite3TreeViewWith()
32728 sqlite3TreeViewLine(pView, "WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter); in sqlite3TreeViewWith()
32732 if( pWith->nCte>0 ){ in sqlite3TreeViewWith()
32734 for(i=0; i<pWith->nCte; i++){ in sqlite3TreeViewWith()
32737 const struct Cte *pCte = &pWith->a[i]; in sqlite3TreeViewWith()
32739 sqlite3_str_appendf(&x, "%s", pCte->zName); in sqlite3TreeViewWith()
32740 if( pCte->pCols && pCte->pCols->nExpr>0 ){ in sqlite3TreeViewWith()
32743 for(j=0; j<pCte->pCols->nExpr; j++){ in sqlite3TreeViewWith()
32744 sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName); in sqlite3TreeViewWith()
32749 if( pCte->eM10d!=M10d_Any ){ in sqlite3TreeViewWith()
32751 pCte->eM10d==M10d_No ? "NOT " : ""); in sqlite3TreeViewWith()
32753 if( pCte->pUse ){ in sqlite3TreeViewWith()
32754 sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse, in sqlite3TreeViewWith()
32755 pCte->pUse->nUse); in sqlite3TreeViewWith()
32758 sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1); in sqlite3TreeViewWith()
32759 sqlite3TreeViewSelect(pView, pCte->pSelect, 0); in sqlite3TreeViewWith()
32767 ** Generate a human-readable description of a SrcList object.
32772 for(i=0; i<pSrc->nSrc; i++){ in sqlite3TreeViewSrcList()
32773 const SrcItem *pItem = &pSrc->a[i]; in sqlite3TreeViewSrcList()
32779 sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem); in sqlite3TreeViewSrcList()
32780 if( pItem->pTab ){ in sqlite3TreeViewSrcList()
32782 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, in sqlite3TreeViewSrcList()
32783 pItem->colUsed, in sqlite3TreeViewSrcList()
32784 pItem->fg.rowidUsed ? "+rowid" : ""); in sqlite3TreeViewSrcList()
32786 if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==(JT_LEFT|JT_RIGHT) ){ in sqlite3TreeViewSrcList()
32787 sqlite3_str_appendf(&x, " FULL-OUTER-JOIN"); in sqlite3TreeViewSrcList()
32788 }else if( pItem->fg.jointype & JT_LEFT ){ in sqlite3TreeViewSrcList()
32789 sqlite3_str_appendf(&x, " LEFT-JOIN"); in sqlite3TreeViewSrcList()
32790 }else if( pItem->fg.jointype & JT_RIGHT ){ in sqlite3TreeViewSrcList()
32791 sqlite3_str_appendf(&x, " RIGHT-JOIN"); in sqlite3TreeViewSrcList()
32792 }else if( pItem->fg.jointype & JT_CROSS ){ in sqlite3TreeViewSrcList()
32793 sqlite3_str_appendf(&x, " CROSS-JOIN"); in sqlite3TreeViewSrcList()
32795 if( pItem->fg.jointype & JT_LTORJ ){ in sqlite3TreeViewSrcList()
32798 if( pItem->fg.fromDDL ){ in sqlite3TreeViewSrcList()
32801 if( pItem->fg.isCte ){ in sqlite3TreeViewSrcList()
32802 sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse); in sqlite3TreeViewSrcList()
32804 if( pItem->fg.isOn || (pItem->fg.isUsing==0 && pItem->u3.pOn!=0) ){ in sqlite3TreeViewSrcList()
32807 if( pItem->fg.isTabFunc ) sqlite3_str_appendf(&x, " isTabFunc"); in sqlite3TreeViewSrcList()
32808 if( pItem->fg.isCorrelated ) sqlite3_str_appendf(&x, " isCorrelated"); in sqlite3TreeViewSrcList()
32809 if( pItem->fg.isMaterialized ) sqlite3_str_appendf(&x, " isMaterialized"); in sqlite3TreeViewSrcList()
32810 if( pItem->fg.viaCoroutine ) sqlite3_str_appendf(&x, " viaCoroutine"); in sqlite3TreeViewSrcList()
32811 if( pItem->fg.notCte ) sqlite3_str_appendf(&x, " notCte"); in sqlite3TreeViewSrcList()
32812 if( pItem->fg.isNestedFrom ) sqlite3_str_appendf(&x, " isNestedFrom"); in sqlite3TreeViewSrcList()
32815 sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1); in sqlite3TreeViewSrcList()
32817 if( pItem->pSelect ) n++; in sqlite3TreeViewSrcList()
32818 if( pItem->fg.isTabFunc ) n++; in sqlite3TreeViewSrcList()
32819 if( pItem->fg.isUsing ) n++; in sqlite3TreeViewSrcList()
32820 if( pItem->fg.isUsing ){ in sqlite3TreeViewSrcList()
32821 sqlite3TreeViewIdList(pView, pItem->u3.pUsing, (--n)>0, "USING"); in sqlite3TreeViewSrcList()
32823 if( pItem->pSelect ){ in sqlite3TreeViewSrcList()
32824 sqlite3TreeViewPush(&pView, i+1<pSrc->nSrc); in sqlite3TreeViewSrcList()
32825 if( pItem->pTab ){ in sqlite3TreeViewSrcList()
32826 Table *pTab = pItem->pTab; in sqlite3TreeViewSrcList()
32827 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1); in sqlite3TreeViewSrcList()
32829 assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) ); in sqlite3TreeViewSrcList()
32830 sqlite3TreeViewSelect(pView, pItem->pSelect, (--n)>0); in sqlite3TreeViewSrcList()
32833 if( pItem->fg.isTabFunc ){ in sqlite3TreeViewSrcList()
32834 sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); in sqlite3TreeViewSrcList()
32841 ** Generate a human-readable description of a Select object.
32847 sqlite3TreeViewLine(pView, "nil-SELECT"); in sqlite3TreeViewSelect()
32851 if( p->pWith ){ in sqlite3TreeViewSelect()
32852 sqlite3TreeViewWith(pView, p->pWith, 1); in sqlite3TreeViewSelect()
32857 if( p->selFlags & SF_WhereBegin ){ in sqlite3TreeViewSelect()
32862 ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""), in sqlite3TreeViewSelect()
32863 ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), in sqlite3TreeViewSelect()
32864 p->selId, p, p->selFlags, in sqlite3TreeViewSelect()
32865 (int)p->nSelectRow in sqlite3TreeViewSelect()
32869 if( p->pPrior ){ in sqlite3TreeViewSelect()
32873 if( p->pSrc && p->pSrc->nSrc ) n++; in sqlite3TreeViewSelect()
32874 if( p->pWhere ) n++; in sqlite3TreeViewSelect()
32875 if( p->pGroupBy ) n++; in sqlite3TreeViewSelect()
32876 if( p->pHaving ) n++; in sqlite3TreeViewSelect()
32877 if( p->pOrderBy ) n++; in sqlite3TreeViewSelect()
32878 if( p->pLimit ) n++; in sqlite3TreeViewSelect()
32880 if( p->pWin ) n++; in sqlite3TreeViewSelect()
32881 if( p->pWinDefn ) n++; in sqlite3TreeViewSelect()
32884 if( p->pEList ){ in sqlite3TreeViewSelect()
32885 sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set"); in sqlite3TreeViewSelect()
32887 n--; in sqlite3TreeViewSelect()
32889 if( p->pWin ){ in sqlite3TreeViewSelect()
32891 sqlite3TreeViewPush(&pView, (n--)>0); in sqlite3TreeViewSelect()
32892 sqlite3TreeViewLine(pView, "window-functions"); in sqlite3TreeViewSelect()
32893 for(pX=p->pWin; pX; pX=pX->pNextWin){ in sqlite3TreeViewSelect()
32894 sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0); in sqlite3TreeViewSelect()
32899 if( p->pSrc && p->pSrc->nSrc ){ in sqlite3TreeViewSelect()
32900 sqlite3TreeViewPush(&pView, (n--)>0); in sqlite3TreeViewSelect()
32902 sqlite3TreeViewSrcList(pView, p->pSrc); in sqlite3TreeViewSelect()
32905 if( p->pWhere ){ in sqlite3TreeViewSelect()
32906 sqlite3TreeViewItem(pView, "WHERE", (n--)>0); in sqlite3TreeViewSelect()
32907 sqlite3TreeViewExpr(pView, p->pWhere, 0); in sqlite3TreeViewSelect()
32910 if( p->pGroupBy ){ in sqlite3TreeViewSelect()
32911 sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY"); in sqlite3TreeViewSelect()
32913 if( p->pHaving ){ in sqlite3TreeViewSelect()
32914 sqlite3TreeViewItem(pView, "HAVING", (n--)>0); in sqlite3TreeViewSelect()
32915 sqlite3TreeViewExpr(pView, p->pHaving, 0); in sqlite3TreeViewSelect()
32919 if( p->pWinDefn ){ in sqlite3TreeViewSelect()
32921 sqlite3TreeViewItem(pView, "WINDOW", (n--)>0); in sqlite3TreeViewSelect()
32922 for(pX=p->pWinDefn; pX; pX=pX->pNextWin){ in sqlite3TreeViewSelect()
32923 sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0); in sqlite3TreeViewSelect()
32928 if( p->pOrderBy ){ in sqlite3TreeViewSelect()
32929 sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY"); in sqlite3TreeViewSelect()
32931 if( p->pLimit ){ in sqlite3TreeViewSelect()
32932 sqlite3TreeViewItem(pView, "LIMIT", (n--)>0); in sqlite3TreeViewSelect()
32933 sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0); in sqlite3TreeViewSelect()
32934 if( p->pLimit->pRight ){ in sqlite3TreeViewSelect()
32936 sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0); in sqlite3TreeViewSelect()
32941 if( p->pPrior ){ in sqlite3TreeViewSelect()
32943 switch( p->op ){ in sqlite3TreeViewSelect()
32950 p = p->pPrior; in sqlite3TreeViewSelect()
32994 ** Generate a human-readable explanation for a Window object
32999 if( pWin->pFilter ){ in sqlite3TreeViewWindow()
33001 sqlite3TreeViewExpr(pView, pWin->pFilter, 0); in sqlite3TreeViewWindow()
33003 if( pWin->eFrmType==TK_FILTER ) return; in sqlite3TreeViewWindow()
33006 if( pWin->zName ){ in sqlite3TreeViewWindow()
33007 sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); in sqlite3TreeViewWindow()
33011 if( pWin->zBase ) nElement++; in sqlite3TreeViewWindow()
33012 if( pWin->pOrderBy ) nElement++; in sqlite3TreeViewWindow()
33013 if( pWin->eFrmType!=0 && pWin->eFrmType!=TK_FILTER ) nElement++; in sqlite3TreeViewWindow()
33014 if( pWin->eExclude ) nElement++; in sqlite3TreeViewWindow()
33015 if( pWin->zBase ){ in sqlite3TreeViewWindow()
33016 sqlite3TreeViewPush(&pView, (--nElement)>0); in sqlite3TreeViewWindow()
33017 sqlite3TreeViewLine(pView, "window: %s", pWin->zBase); in sqlite3TreeViewWindow()
33020 if( pWin->pPartition ){ in sqlite3TreeViewWindow()
33021 sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY"); in sqlite3TreeViewWindow()
33023 if( pWin->pOrderBy ){ in sqlite3TreeViewWindow()
33024 sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY"); in sqlite3TreeViewWindow()
33026 if( pWin->eFrmType!=0 && pWin->eFrmType!=TK_FILTER ){ in sqlite3TreeViewWindow()
33029 if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE"; in sqlite3TreeViewWindow()
33030 if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS"; in sqlite3TreeViewWindow()
33032 pWin->bImplicitFrame ? " (implied)" : ""); in sqlite3TreeViewWindow()
33033 sqlite3TreeViewItem(pView, zBuf, (--nElement)>0); in sqlite3TreeViewWindow()
33034 sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1); in sqlite3TreeViewWindow()
33035 sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0); in sqlite3TreeViewWindow()
33038 if( pWin->eExclude ){ in sqlite3TreeViewWindow()
33041 switch( pWin->eExclude ){ in sqlite3TreeViewWindow()
33047 sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude); in sqlite3TreeViewWindow()
33061 ** Generate a human-readable explanation for a Window Function object
33067 pWin->pWFunc->zName, pWin->pWFunc->nArg); in sqlite3TreeViewWinFunc()
33074 ** Generate a human-readable explanation of an expression tree.
33086 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){ in sqlite3TreeViewExpr()
33090 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); in sqlite3TreeViewExpr()
33092 sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
33095 sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
33103 if( pExpr->pAggInfo!=0 ){ in sqlite3TreeViewExpr()
33104 sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg); in sqlite3TreeViewExpr()
33110 switch( pExpr->op ){ in sqlite3TreeViewExpr()
33113 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
33117 if( pExpr->iTable<0 ){ in sqlite3TreeViewExpr()
33120 if( pExpr->op2 ){ in sqlite3TreeViewExpr()
33121 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
33126 pExpr->iColumn, zFlgs, zOp2); in sqlite3TreeViewExpr()
33130 pExpr->iTable, pExpr->iColumn, in sqlite3TreeViewExpr()
33131 pExpr->y.pTab, zFlgs); in sqlite3TreeViewExpr()
33134 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33139 if( pExpr->flags & EP_IntValue ){ in sqlite3TreeViewExpr()
33140 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); in sqlite3TreeViewExpr()
33142 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33149 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33155 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33170 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33177 pExpr->u.zToken, pExpr->iColumn); in sqlite3TreeViewExpr()
33181 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); in sqlite3TreeViewExpr()
33186 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); in sqlite3TreeViewExpr()
33193 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33194 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33231 "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE" in sqlite3TreeViewExpr()
33233 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); in sqlite3TreeViewExpr()
33234 assert( pExpr->pRight ); in sqlite3TreeViewExpr()
33235 assert( sqlite3ExprSkipCollateAndLikely(pExpr->pRight)->op in sqlite3TreeViewExpr()
33237 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); in sqlite3TreeViewExpr()
33244 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33245 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33252 ** up in the treeview output as "SOFT-COLLATE". Explicit COLLATE in sqlite3TreeViewExpr()
33257 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", in sqlite3TreeViewExpr()
33258 pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
33259 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33272 pFarg = pExpr->x.pList; in sqlite3TreeViewExpr()
33274 pWin = IsWindowFunc(pExpr) ? pExpr->y.pWin : 0; in sqlite3TreeViewExpr()
33280 if( pExpr->op==TK_AGG_FUNCTION ){ in sqlite3TreeViewExpr()
33282 pExpr->op2, pExpr->u.zToken, zFlgs, in sqlite3TreeViewExpr()
33283 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, in sqlite3TreeViewExpr()
33284 pExpr->iAgg, pExpr->pAggInfo); in sqlite3TreeViewExpr()
33285 }else if( pExpr->op2!=0 ){ in sqlite3TreeViewExpr()
33288 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
33290 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; in sqlite3TreeViewExpr()
33291 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; in sqlite3TreeViewExpr()
33292 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; in sqlite3TreeViewExpr()
33293 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; in sqlite3TreeViewExpr()
33295 pExpr->u.zToken, zFlgs, zOp2); in sqlite3TreeViewExpr()
33297 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
33300 sqlite3TreeViewExprList(pView, pFarg, pWin!=0 || pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33301 if( pExpr->pLeft ){ in sqlite3TreeViewExpr()
33302 Expr *pOB = pExpr->pLeft; in sqlite3TreeViewExpr()
33303 assert( pOB->op==TK_ORDER ); in sqlite3TreeViewExpr()
33305 sqlite3TreeViewExprList(pView, pOB->x.pList, pWin!=0, "ORDERBY"); in sqlite3TreeViewExpr()
33316 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY"); in sqlite3TreeViewExpr()
33322 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33323 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33328 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33329 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33335 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33336 if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable); in sqlite3TreeViewExpr()
33339 pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); in sqlite3TreeViewExpr()
33344 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33346 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33348 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33361 ** X is stored in pExpr->pLeft. in sqlite3TreeViewExpr()
33362 ** Y is stored in pExpr->pList->a[0].pExpr. in sqlite3TreeViewExpr()
33363 ** Z is stored in pExpr->pList->a[1].pExpr. in sqlite3TreeViewExpr()
33367 pX = pExpr->pLeft; in sqlite3TreeViewExpr()
33369 assert( pExpr->x.pList->nExpr==2 ); in sqlite3TreeViewExpr()
33370 pY = pExpr->x.pList->a[0].pExpr; in sqlite3TreeViewExpr()
33371 pZ = pExpr->x.pList->a[1].pExpr; in sqlite3TreeViewExpr()
33380 ** to a column in the new.* or old.* pseudo-tables available to in sqlite3TreeViewExpr()
33382 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn in sqlite3TreeViewExpr()
33383 ** is set to the column of the pseudo-table to read, or to -1 to in sqlite3TreeViewExpr()
33387 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); in sqlite3TreeViewExpr()
33392 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33394 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33400 switch( pExpr->affExpr ){ in sqlite3TreeViewExpr()
33407 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); in sqlite3TreeViewExpr()
33413 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
33414 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
33420 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); in sqlite3TreeViewExpr()
33425 sqlite3TreeViewLine(pView, "SELECT-COLUMN %d of [0..%d]%s", in sqlite3TreeViewExpr()
33426 pExpr->iColumn, pExpr->iTable-1, in sqlite3TreeViewExpr()
33427 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); in sqlite3TreeViewExpr()
33428 assert( ExprUseXSelect(pExpr->pLeft) ); in sqlite3TreeViewExpr()
33429 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); in sqlite3TreeViewExpr()
33433 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); in sqlite3TreeViewExpr()
33434 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33441 tmp.op = pExpr->op2; in sqlite3TreeViewExpr()
33446 if( pExpr->iColumn<=0 ){ in sqlite3TreeViewExpr()
33450 pExpr->iColumn-1); in sqlite3TreeViewExpr()
33455 sqlite3TreeViewLine(pView, "op=%d", pExpr->op); in sqlite3TreeViewExpr()
33461 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33462 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
33465 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33472 ** Generate a human-readable explanation of an expression list.
33485 for(i=0; i<pList->nExpr; i++){ in sqlite3TreeViewBareExprList()
33486 int j = pList->a[i].u.x.iOrderByCol; in sqlite3TreeViewBareExprList()
33487 char *zName = pList->a[i].zEName; in sqlite3TreeViewBareExprList()
33488 int moreToFollow = i<pList->nExpr - 1; in sqlite3TreeViewBareExprList()
33494 switch( pList->a[i].fg.eEName ){ in sqlite3TreeViewBareExprList()
33499 fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName); in sqlite3TreeViewBareExprList()
33500 if( pList->a[i].fg.bUsed ) fprintf(stdout, "(used) "); in sqlite3TreeViewBareExprList()
33501 if( pList->a[i].fg.bUsingTerm ) fprintf(stdout, "(USING-term) "); in sqlite3TreeViewBareExprList()
33502 if( pList->a[i].fg.bNoExpand ) fprintf(stdout, "(NoExpand) "); in sqlite3TreeViewBareExprList()
33515 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); in sqlite3TreeViewBareExprList()
33534 ** Generate a human-readable explanation of an id-list.
33547 for(i=0; i<pList->nId; i++){ in sqlite3TreeViewBareIdList()
33548 char *zName = pList->a[i].zName; in sqlite3TreeViewBareIdList()
33549 int moreToFollow = i<pList->nId - 1; in sqlite3TreeViewBareIdList()
33553 if( pList->eU4==EU4_NONE ){ in sqlite3TreeViewBareIdList()
33555 }else if( pList->eU4==EU4_IDX ){ in sqlite3TreeViewBareIdList()
33556 fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx); in sqlite3TreeViewBareIdList()
33558 assert( pList->eU4==EU4_EXPR ); in sqlite3TreeViewBareIdList()
33559 if( pList->a[i].u4.pExpr==0 ){ in sqlite3TreeViewBareIdList()
33563 sqlite3TreeViewPush(&pView, i<pList->nId-1); in sqlite3TreeViewBareIdList()
33564 sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0); in sqlite3TreeViewBareIdList()
33584 ** Generate a human-readable explanation of a list of Upsert objects
33595 sqlite3TreeViewPush(&pView, pUpsert->pNextUpsert!=0 || moreToFollow); in sqlite3TreeViewUpsert()
33597 pUpsert->isDoUpdate ? "UPDATE" : "NOTHING"); in sqlite3TreeViewUpsert()
33598 n = (pUpsert->pUpsertSet!=0) + (pUpsert->pUpsertWhere!=0); in sqlite3TreeViewUpsert()
33599 sqlite3TreeViewExprList(pView, pUpsert->pUpsertTarget, (n--)>0, "TARGET"); in sqlite3TreeViewUpsert()
33600 sqlite3TreeViewExprList(pView, pUpsert->pUpsertSet, (n--)>0, "SET"); in sqlite3TreeViewUpsert()
33601 if( pUpsert->pUpsertWhere ){ in sqlite3TreeViewUpsert()
33602 sqlite3TreeViewItem(pView, "WHERE", (n--)>0); in sqlite3TreeViewUpsert()
33603 sqlite3TreeViewExpr(pView, pUpsert->pUpsertWhere, 0); in sqlite3TreeViewUpsert()
33607 pUpsert = pUpsert->pNextUpsert; in sqlite3TreeViewUpsert()
33614 ** Generate a human-readable diagram of the data structure that go
33636 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewDelete()
33641 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewDelete()
33647 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewDelete()
33653 sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); in sqlite3TreeViewDelete()
33656 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewDelete()
33662 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); in sqlite3TreeViewDelete()
33670 ** Generate a human-readable diagram of the data structure that go
33703 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewInsert()
33708 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewInsert()
33714 sqlite3TreeViewIdList(pView, pColumnList, (--n)>0, "COLUMNS"); in sqlite3TreeViewInsert()
33717 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewInsert()
33718 sqlite3TreeViewLine(pView, "DATA-SOURCE"); in sqlite3TreeViewInsert()
33723 sqlite3TreeViewExprList(pView, pExprList, (--n)>0, "VALUES"); in sqlite3TreeViewInsert()
33726 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewInsert()
33732 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); in sqlite3TreeViewInsert()
33740 ** Generate a human-readable diagram of the data structure that go
33775 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewUpdate()
33780 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewUpdate()
33786 sqlite3TreeViewExprList(pView, pChanges, (--n)>0, "SET"); in sqlite3TreeViewUpdate()
33789 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewUpdate()
33795 sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); in sqlite3TreeViewUpdate()
33798 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewUpdate()
33804 sqlite3TreeViewPush(&pView, (--n)>0); in sqlite3TreeViewUpdate()
33810 sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); in sqlite3TreeViewUpdate()
33818 ** Show a human-readable graph of a TriggerStep
33829 moreToFollow || (showFullList && pStep->pNext!=0)); in sqlite3TreeViewTriggerStep()
33831 if( cnt++ && pStep->pNext==0 ){ in sqlite3TreeViewTriggerStep()
33835 sqlite3TreeViewLine(pView, "%s", pStep->zSpan ? pStep->zSpan : "RETURNING"); in sqlite3TreeViewTriggerStep()
33836 }while( showFullList && (pStep = pStep->pNext)!=0 ); in sqlite3TreeViewTriggerStep()
33841 ** Show a human-readable graph of a Trigger
33852 moreToFollow || (showFullList && pTrigger->pNext!=0)); in sqlite3TreeViewTrigger()
33854 if( cnt++ && pTrigger->pNext==0 ){ in sqlite3TreeViewTrigger()
33858 sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName); in sqlite3TreeViewTrigger()
33860 sqlite3TreeViewTriggerStep(pView, pTrigger->step_list, 0, 1); in sqlite3TreeViewTrigger()
33862 }while( showFullList && (pTrigger = pTrigger->pNext)!=0 ); in sqlite3TreeViewTrigger()
33869 ** These simplified versions of the tree-view routines omit unnecessary
33915 ** This file contains code to implement a pseudo-random number
33934 /* The RFC-7539 ChaCha20 block function
33936 #define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
33965 /* The "wsdPrng" macro will resolve to the pseudo-random number generator in sqlite3_randomness()
33967 ** we have to locate the state vector at run-time. In the more common in sqlite3_randomness()
34019 memcpy(zBuf, &wsdPrng.out[wsdPrng.n-N], N); in sqlite3_randomness()
34020 wsdPrng.n -= N; in sqlite3_randomness()
34025 N -= wsdPrng.n; in sqlite3_randomness()
34076 ** This file presents a simple cross-platform threading interface for
34089 ** single-threaded if desired.
34101 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
34124 /* This routine is never used in single-threaded mode */ in sqlite3ThreadCreate()
34131 p->xTask = xTask; in sqlite3ThreadCreate()
34132 p->pIn = pIn; in sqlite3ThreadCreate()
34140 rc = pthread_create(&p->tid, 0, xTask, pIn); in sqlite3ThreadCreate()
34143 p->done = 1; in sqlite3ThreadCreate()
34144 p->pOut = xTask(pIn); in sqlite3ThreadCreate()
34156 if( p->done ){ in sqlite3ThreadJoin()
34157 *ppOut = p->pOut; in sqlite3ThreadJoin()
34160 rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK; in sqlite3ThreadJoin()
34173 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
34199 assert( p->id==GetCurrentThreadId() ); in sqlite3ThreadProc()
34201 assert( p->xTask!=0 ); in sqlite3ThreadProc()
34202 p->pResult = p->xTask(p->pIn); in sqlite3ThreadProc()
34229 p->xTask = xTask; in sqlite3ThreadCreate()
34230 p->pIn = pIn; in sqlite3ThreadCreate()
34231 p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id); in sqlite3ThreadCreate()
34232 if( p->tid==0 ){ in sqlite3ThreadCreate()
34236 if( p->xTask==0 ){ in sqlite3ThreadCreate()
34237 p->id = GetCurrentThreadId(); in sqlite3ThreadCreate()
34238 p->pResult = xTask(pIn); in sqlite3ThreadCreate()
34253 if( p->xTask==0 ){ in sqlite3ThreadJoin()
34254 /* assert( p->id==GetCurrentThreadId() ); */ in sqlite3ThreadJoin()
34256 assert( p->tid==0 ); in sqlite3ThreadJoin()
34258 assert( p->id!=0 && p->id!=GetCurrentThreadId() ); in sqlite3ThreadJoin()
34259 rc = sqlite3Win32Wait((HANDLE)p->tid); in sqlite3ThreadJoin()
34261 bRc = CloseHandle((HANDLE)p->tid); in sqlite3ThreadJoin()
34264 if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult; in sqlite3ThreadJoin()
34273 /********************************* Single-Threaded **************************/
34302 p->xTask = xTask; in sqlite3ThreadCreate()
34303 p->pIn = pIn; in sqlite3ThreadCreate()
34305 p->xTask = 0; in sqlite3ThreadCreate()
34306 p->pResult = xTask(pIn); in sqlite3ThreadCreate()
34317 if( p->xTask ){ in sqlite3ThreadJoin()
34318 *ppOut = p->xTask(p->pIn); in sqlite3ThreadJoin()
34320 *ppOut = p->pResult; in sqlite3ThreadJoin()
34336 /****************************** End Single-Threaded *************************/
34352 ** This file contains routines used to translate between UTF-8,
34353 ** UTF-16, UTF-16BE, and UTF-16LE.
34355 ** Notes on UTF-8:
34357 ** Byte-0 Byte-1 Byte-2 Byte-3 Value
34364 ** Notes on UTF-16: (with wwww+1==uuuuu)
34366 ** Word-0 Word-1 Value
34372 ** 0xff 0xfe little-endian utf-16 follows
34373 ** 0xfe 0xff big-endian utf-16 follows
34390 ** a multi-byte UTF8 character.
34429 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
34430 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
34441 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
34442 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
34449 ** Translate a single UTF-8 character. Return the unicode value.
34456 ** Notes On Invalid UTF-8:
34458 ** * This routine never allows a 7-bit character (0x00 through 0x7f) to
34459 ** be encoded as a multi-byte character. Any multi-byte character that
34463 ** If a multi-byte character attempts to encode a value between
34467 ** byte of a character are interpreted as single-byte characters
34471 ** * This routine accepts over-length UTF8 encodings
34472 ** for unicode values 0x80 and greater. It does not change over-length
34478 c = sqlite3Utf8Trans1[c-0xc0]; \
34492 ** For this routine, we assume the UTF8 string is always zero-terminated. in sqlite3Utf8Read()
34496 c = sqlite3Utf8Trans1[c-0xc0]; in sqlite3Utf8Read()
34509 ** more than n characters from the buffer. z[] is not zero-terminated.
34529 c = sqlite3Utf8Trans1[c-0xc0]; in sqlite3Utf8ReadLimited()
34561 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); in sqlite3VdbeMemTranslate()
34562 assert( pMem->flags&MEM_Str ); in sqlite3VdbeMemTranslate()
34563 assert( pMem->enc!=desiredEnc ); in sqlite3VdbeMemTranslate()
34564 assert( pMem->enc!=0 ); in sqlite3VdbeMemTranslate()
34565 assert( pMem->n>=0 ); in sqlite3VdbeMemTranslate()
34577 /* If the translation is between UTF-16 little and big endian, then in sqlite3VdbeMemTranslate()
34581 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ in sqlite3VdbeMemTranslate()
34589 zIn = (u8*)pMem->z; in sqlite3VdbeMemTranslate()
34590 zTerm = &zIn[pMem->n&~1]; in sqlite3VdbeMemTranslate()
34597 pMem->enc = desiredEnc; in sqlite3VdbeMemTranslate()
34603 /* When converting from UTF-16, the maximum growth results from in sqlite3VdbeMemTranslate()
34604 ** translating a 2-byte character to a 4-byte UTF-8 character. in sqlite3VdbeMemTranslate()
34606 ** nul-terminator. in sqlite3VdbeMemTranslate()
34608 pMem->n &= ~1; in sqlite3VdbeMemTranslate()
34609 len = 2 * (sqlite3_int64)pMem->n + 1; in sqlite3VdbeMemTranslate()
34611 /* When converting from UTF-8 to UTF-16 the maximum growth is caused in sqlite3VdbeMemTranslate()
34612 ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16 in sqlite3VdbeMemTranslate()
34614 ** nul-terminator. in sqlite3VdbeMemTranslate()
34616 len = 2 * (sqlite3_int64)pMem->n + 2; in sqlite3VdbeMemTranslate()
34625 zIn = (u8*)pMem->z; in sqlite3VdbeMemTranslate()
34626 zTerm = &zIn[pMem->n]; in sqlite3VdbeMemTranslate()
34627 zOut = sqlite3DbMallocRaw(pMem->db, len); in sqlite3VdbeMemTranslate()
34633 if( pMem->enc==SQLITE_UTF8 ){ in sqlite3VdbeMemTranslate()
34635 /* UTF-8 -> UTF-16 Little-endian */ in sqlite3VdbeMemTranslate()
34642 /* UTF-8 -> UTF-16 Big-endian */ in sqlite3VdbeMemTranslate()
34648 pMem->n = (int)(z - zOut); in sqlite3VdbeMemTranslate()
34652 if( pMem->enc==SQLITE_UTF16LE ){ in sqlite3VdbeMemTranslate()
34653 /* UTF-16 Little-endian -> UTF-8 */ in sqlite3VdbeMemTranslate()
34665 zIn -= 2; in sqlite3VdbeMemTranslate()
34682 /* UTF-16 Big-endian -> UTF-8 */ in sqlite3VdbeMemTranslate()
34694 zIn -= 2; in sqlite3VdbeMemTranslate()
34711 pMem->n = (int)(z - zOut); in sqlite3VdbeMemTranslate()
34714 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); in sqlite3VdbeMemTranslate()
34716 c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype)); in sqlite3VdbeMemTranslate()
34718 pMem->flags = c; in sqlite3VdbeMemTranslate()
34719 pMem->enc = desiredEnc; in sqlite3VdbeMemTranslate()
34720 pMem->z = (char*)zOut; in sqlite3VdbeMemTranslate()
34721 pMem->zMalloc = pMem->z; in sqlite3VdbeMemTranslate()
34722 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); in sqlite3VdbeMemTranslate()
34740 ** This routine checks for a byte-order mark at the beginning of the
34741 ** UTF-16 string stored in *pMem. If one is present, it is removed and
34743 ** byte-swapping, it just sets Mem.enc appropriately.
34752 assert( pMem->n>=0 ); in sqlite3VdbeMemHandleBom()
34753 if( pMem->n>1 ){ in sqlite3VdbeMemHandleBom()
34754 u8 b1 = *(u8 *)pMem->z; in sqlite3VdbeMemHandleBom()
34755 u8 b2 = *(((u8 *)pMem->z) + 1); in sqlite3VdbeMemHandleBom()
34767 pMem->n -= 2; in sqlite3VdbeMemHandleBom()
34768 memmove(pMem->z, &pMem->z[2], pMem->n); in sqlite3VdbeMemHandleBom()
34769 pMem->z[pMem->n] = '\0'; in sqlite3VdbeMemHandleBom()
34770 pMem->z[pMem->n+1] = '\0'; in sqlite3VdbeMemHandleBom()
34771 pMem->flags |= MEM_Term; in sqlite3VdbeMemHandleBom()
34772 pMem->enc = bom; in sqlite3VdbeMemHandleBom()
34780 ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
34793 zTerm = (const u8*)(-1); in sqlite3Utf8CharLen()
34803 /* This test function is not currently used by the automated test-suite.
34808 ** Translate UTF-8 to UTF-8.
34810 ** This has the effect of making sure that the string is well-formed
34811 ** UTF-8. Miscoded characters are removed.
34813 ** The translation is done in-place and aborted if the output
34828 return (int)(zOut - zStart); in sqlite3Utf8To8()
34834 ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
34835 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
34846 if( db->mallocFailed ){ in sqlite3Utf16to8()
34850 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); in sqlite3Utf16to8()
34851 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); in sqlite3Utf16to8()
34852 assert( m.z || db->mallocFailed ); in sqlite3Utf16to8()
34857 ** zIn is a UTF-16 encoded unicode string at least nChar characters long.
34859 ** in pZ. nChar must be non-negative.
34873 return (int)(z-(unsigned char const *)zIn) in sqlite3Utf16ByteLen()
34874 - (SQLITE_UTF16NATIVE==SQLITE_UTF16LE); in sqlite3Utf16ByteLen()
34893 n = (int)(z-zBuf); in sqlite3UtfSelfTest()
34902 assert( (z-zBuf)==n ); in sqlite3UtfSelfTest()
34939 ** sqlite3FaultSim() function only returns non-zero during testing.
34941 ** During testing, if the test harness has set a fault-sim callback using
34943 ** each call to sqlite3FaultSim() is relayed to that application-supplied
34944 ** callback and the integer return value form the application-supplied
34982 ** Return true if the floating point value is NaN or +Inf or -Inf.
34995 ** lower 30 bits of a 32-bit signed integer.
35010 ** The column type is an extra string stored after the zero-terminator on
35014 if( pCol->colFlags & COLFLAG_HASTYPE ){ in sqlite3ColumnType()
35015 return pCol->zCnName + strlen(pCol->zCnName) + 1; in sqlite3ColumnType()
35016 }else if( pCol->eCType ){ in sqlite3ColumnType()
35017 assert( pCol->eCType<=SQLITE_N_STDTYPE ); in sqlite3ColumnType()
35018 return (char*)sqlite3StdType[pCol->eCType-1]; in sqlite3ColumnType()
35025 ** Helper function for sqlite3Error() - called rarely. Broken out into
35030 if( db->pErr ) sqlite3ValueSetNull(db->pErr); in sqlite3ErrorFinish()
35041 db->errCode = err_code; in sqlite3Error()
35042 if( err_code || db->pErr ){ in sqlite3Error()
35045 db->errByteOffset = -1; in sqlite3Error()
35055 db->errCode = SQLITE_OK; in sqlite3ErrorClear()
35056 db->errByteOffset = -1; in sqlite3ErrorClear()
35057 if( db->pErr ) sqlite3ValueSetNull(db->pErr); in sqlite3ErrorClear()
35071 for(ii=0; ii<db->nDb; ii++){ in sqlite3SystemError()
35072 if( db->aDb[ii].pBt ){ in sqlite3SystemError()
35073 iErr = sqlite3PagerWalSystemErrno(sqlite3BtreePager(db->aDb[ii].pBt)); in sqlite3SystemError()
35075 db->iSysErrno = iErr; in sqlite3SystemError()
35085 db->iSysErrno = sqlite3OsGetLastError(db->pVfs); in sqlite3SystemError()
35095 ** assumed to be encoded in UTF-8.
35103 db->errCode = err_code; in sqlite3ErrorWithMsg()
35107 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ in sqlite3ErrorWithMsg()
35113 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); in sqlite3ErrorWithMsg()
35121 sqlite3 *db = p->db; in sqlite3ProgressCheck()
35122 if( AtomicLoad(&db->u1.isInterrupted) ){ in sqlite3ProgressCheck()
35123 p->nErr++; in sqlite3ProgressCheck()
35124 p->rc = SQLITE_INTERRUPT; in sqlite3ProgressCheck()
35127 if( db->xProgress ){ in sqlite3ProgressCheck()
35128 if( p->rc==SQLITE_INTERRUPT ){ in sqlite3ProgressCheck()
35129 p->nProgressSteps = 0; in sqlite3ProgressCheck()
35130 }else if( (++p->nProgressSteps)>=db->nProgressOps ){ in sqlite3ProgressCheck()
35131 if( db->xProgress(db->pProgressArg) ){ in sqlite3ProgressCheck()
35132 p->nErr++; in sqlite3ProgressCheck()
35133 p->rc = SQLITE_INTERRUPT; in sqlite3ProgressCheck()
35135 p->nProgressSteps = 0; in sqlite3ProgressCheck()
35142 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
35154 sqlite3 *db = pParse->db; in sqlite3ErrorMsg()
35156 assert( db->pParse==pParse || db->pParse->pToplevel==pParse ); in sqlite3ErrorMsg()
35157 db->errByteOffset = -2; in sqlite3ErrorMsg()
35161 if( db->errByteOffset<-1 ) db->errByteOffset = -1; in sqlite3ErrorMsg()
35162 if( db->suppressErr ){ in sqlite3ErrorMsg()
35164 if( db->mallocFailed ){ in sqlite3ErrorMsg()
35165 pParse->nErr++; in sqlite3ErrorMsg()
35166 pParse->rc = SQLITE_NOMEM; in sqlite3ErrorMsg()
35169 pParse->nErr++; in sqlite3ErrorMsg()
35170 sqlite3DbFree(db, pParse->zErrMsg); in sqlite3ErrorMsg()
35171 pParse->zErrMsg = zMsg; in sqlite3ErrorMsg()
35172 pParse->rc = SQLITE_ERROR; in sqlite3ErrorMsg()
35173 pParse->pWith = 0; in sqlite3ErrorMsg()
35184 if( db==0 || (pParse = db->pParse)==0 ) return errCode; in sqlite3ErrorToParser()
35185 pParse->rc = errCode; in sqlite3ErrorToParser()
35186 pParse->nErr++; in sqlite3ErrorToParser()
35191 ** Convert an SQL-style quoted string into a normal string by removing
35192 ** the quote characters. The conversion is done in-place. If the
35194 ** is a no-op.
35196 ** The input string must be zero-terminated. A new zero-terminator
35199 ** The return value is -1 if no dequoting occurs or the length of the
35203 ** 2002-02-14: This routine is extended to remove MS-Access style
35204 ** brackets from around identifiers. For example: "[a-b-c]" becomes
35205 ** "a-b-c".
35231 assert( sqlite3Isquote(p->u.zToken[0]) ); in sqlite3DequoteExpr()
35232 p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; in sqlite3DequoteExpr()
35233 sqlite3Dequote(p->u.zToken); in sqlite3DequoteExpr()
35237 ** Expression p is a QNUMBER (quoted number). Dequote the value in p->u.zToken
35242 assert( p!=0 || pParse->db->mallocFailed ); in sqlite3DequoteNumber()
35244 const char *pIn = p->u.zToken; in sqlite3DequoteNumber()
35245 char *pOut = p->u.zToken; in sqlite3DequoteNumber()
35248 assert( p->op==TK_QNUMBER ); in sqlite3DequoteNumber()
35249 p->op = TK_INTEGER; in sqlite3DequoteNumber()
35253 if( *pIn=='e' || *pIn=='E' || *pIn=='.' ) p->op = TK_FLOAT; in sqlite3DequoteNumber()
35255 if( (bHex==0 && (!sqlite3Isdigit(pIn[-1]) || !sqlite3Isdigit(pIn[1]))) in sqlite3DequoteNumber()
35256 || (bHex==1 && (!sqlite3Isxdigit(pIn[-1]) || !sqlite3Isxdigit(pIn[1]))) in sqlite3DequoteNumber()
35258 sqlite3ErrorMsg(pParse, "unrecognized token: \"%s\"", p->u.zToken); in sqlite3DequoteNumber()
35262 if( bHex ) p->op = TK_INTEGER; in sqlite3DequoteNumber()
35264 /* tag-20240227-a: If after dequoting, the number is an integer that in sqlite3DequoteNumber()
35266 ** parts of the code expect this. See also tag-20240227-b. */ in sqlite3DequoteNumber()
35267 if( p->op==TK_INTEGER && sqlite3GetInt32(p->u.zToken, &iValue) ){ in sqlite3DequoteNumber()
35268 p->u.iValue = iValue; in sqlite3DequoteNumber()
35269 p->flags |= EP_IntValue; in sqlite3DequoteNumber()
35278 ** "abc" -> abc
35279 ** "ab""cd" -> (not possible because of the interior "")
35283 ** is always a no-op.
35287 if( p->n<2 ) return; in sqlite3DequoteToken()
35288 if( !sqlite3Isquote(p->z[0]) ) return; in sqlite3DequoteToken()
35289 for(i=1; i<p->n-1; i++){ in sqlite3DequoteToken()
35290 if( sqlite3Isquote(p->z[i]) ) return; in sqlite3DequoteToken()
35292 p->n -= 2; in sqlite3DequoteToken()
35293 p->z++; in sqlite3DequoteToken()
35300 p->z = z; in sqlite3TokenInit()
35301 p->n = sqlite3Strlen30(z); in sqlite3TokenInit()
35304 /* Convenient short-hand */
35311 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
35313 ** the contents of two buffers containing UTF-8 strings in a
35314 ** case-independent fashion, using the same definition of "case
35319 return zRight ? -1 : 0; in sqlite3_stricmp()
35336 c = (int)UpperToLower[c] - (int)UpperToLower[x]; in sqlite3StrICmp()
35347 return zRight ? -1 : 0; in sqlite3_strnicmp()
35353 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } in sqlite3_strnicmp()
35354 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; in sqlite3_strnicmp()
35358 ** Compute an 8-bit hash on a string that is insensitive to case differences
35370 /* Double-Double multiplication. (x[0],x[1]) *= (y,yy)
35373 ** T. J. Dekker, "A Floating-Point Technique for Extending the
35374 ** Available Precision". 1971-07-26.
35380 ** binary64 rather than be carried around in an extended-precision in dekkerMul2()
35391 tx = x[0] - hx; in dekkerMul2()
35395 ty = y - hy; in dekkerMul2()
35399 cc = p - c + q + tx*ty; in dekkerMul2()
35402 x[1] = c - x[0]; in dekkerMul2()
35411 ** uses the encoding enc. The string is not necessarily zero-terminated.
35419 ** -1 => Not a valid number, but has a valid prefix which
35424 ** [+-]digits[E[+-]digits]
35425 ** [+-]digits.[digits][E[+-]digits]
35426 ** [+-].digits[E[+-]digits]
35448 int eValid = 1; /* True exponent is either not used or is well-formed */ in sqlite3AtoF()
35450 int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */ in sqlite3AtoF()
35466 for(i=3-enc; i<length && z[i]==0; i+=2){} in sqlite3AtoF()
35467 if( i<length ) eType = -100; in sqlite3AtoF()
35477 if( *z=='-' ){ in sqlite3AtoF()
35478 sign = -1; in sqlite3AtoF()
35486 s = s*10 + (*z - '0'); in sqlite3AtoF()
35488 if( s>=((LARGEST_UINT64-9)/10) ){ in sqlite3AtoF()
35489 /* skip non-significant significand digits in sqlite3AtoF()
35503 if( s<((LARGEST_UINT64-9)/10) ){ in sqlite3AtoF()
35504 s = s*10 + (*z - '0'); in sqlite3AtoF()
35505 d--; in sqlite3AtoF()
35522 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/ in sqlite3AtoF()
35525 if( *z=='-' ){ in sqlite3AtoF()
35526 esign = -1; in sqlite3AtoF()
35533 e = e<10000 ? (e*10 + (*z - '0')) : 10000; in sqlite3AtoF()
35545 *pResult = sign<0 ? -0.0 : +0.0; in sqlite3AtoF()
35555 e--; in sqlite3AtoF()
35567 while( e>=100 ){ e-=100; r *= 1.0e+100L; } in sqlite3AtoF()
35568 while( e>=10 ){ e-=10; r *= 1.0e+10L; } in sqlite3AtoF()
35569 while( e>=1 ){ e-=1; r *= 1.0e+01L; } in sqlite3AtoF()
35571 while( e<=-100 ){ e+=100; r *= 1.0e-100L; } in sqlite3AtoF()
35572 while( e<=-10 ){ e+=10; r *= 1.0e-10L; } in sqlite3AtoF()
35573 while( e<=-1 ){ e+=1; r *= 1.0e-01L; } in sqlite3AtoF()
35593 rr[1] = s>=s2 ? (double)(s - s2) : -(double)(s2 - s); in sqlite3AtoF()
35595 while( e>=100 ){ in sqlite3AtoF()
35596 e -= 100; in sqlite3AtoF()
35597 dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83); in sqlite3AtoF()
35600 e -= 10; in sqlite3AtoF()
35604 e -= 1; in sqlite3AtoF()
35608 while( e<=-100 ){ in sqlite3AtoF()
35609 e += 100; in sqlite3AtoF()
35610 dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117); in sqlite3AtoF()
35612 while( e<=-10 ){ in sqlite3AtoF()
35614 dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27); in sqlite3AtoF()
35616 while( e<=-1 ){ in sqlite3AtoF()
35618 dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18); in sqlite3AtoF()
35624 if( sign<0 ) *pResult = -*pResult; in sqlite3AtoF()
35628 /* return true if number and no extra non-whitespace characters after */ in sqlite3AtoF()
35632 return -1; in sqlite3AtoF()
35645 ** Render an signed 64-bit integer as text. Store the result in zOut[] and
35657 x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v; in sqlite3Int64ToText()
35661 i = sizeof(zTemp)-2; in sqlite3Int64ToText()
35662 zTemp[sizeof(zTemp)-1] = 0; in sqlite3Int64ToText()
35663 while( 1 /*exit-by-break*/ ){ in sqlite3Int64ToText()
35667 i--; in sqlite3Int64ToText()
35669 if( v<0 ) zTemp[--i] = '-'; in sqlite3Int64ToText()
35670 memcpy(zOut, &zTemp[i], sizeof(zTemp)-i); in sqlite3Int64ToText()
35671 return sizeof(zTemp)-1-i; in sqlite3Int64ToText()
35675 ** Compare the 19-character string zNum against the text representation
35686 ** will return -8.
35694 c = (zNum[i*incr]-pow63[i])*10; in compare2pow63()
35697 c = zNum[18*incr] - '8'; in compare2pow63()
35698 testcase( c==(-1) ); in compare2pow63()
35706 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
35711 ** -1 Not even a prefix of the input text looks like an integer
35712 ** 0 Successful transformation. Fits in a 64-bit signed integer.
35713 ** 1 Excess non-space text after the integer value
35714 ** 2 Integer too large for a 64-bit signed integer or is malformed
35718 ** The string is not necessarily zero-terminated. The encoding is
35727 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ in sqlite3Atoi64()
35738 for(i=3-enc; i<length && zNum[i]==0; i+=2){} in sqlite3Atoi64()
35745 if( *zNum=='-' ){ in sqlite3Atoi64()
35755 u = u*10 + c - '0'; in sqlite3Atoi64()
35762 ** from clang and -fsanitize=undefined. This test and assignment make in sqlite3Atoi64()
35764 ** them, but we must appease the undefined-behavior pharisees. */ in sqlite3Atoi64()
35767 *pNum = -(i64)u; in sqlite3Atoi64()
35773 rc = -1; in sqlite3Atoi64()
35774 }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */ in sqlite3Atoi64()
35780 rc = 1; /* Extra non-space text after the integer */ in sqlite3Atoi64()
35791 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ in sqlite3Atoi64()
35805 assert( u-1==LARGEST_INT64 ); in sqlite3Atoi64()
35813 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
35814 ** into a 64-bit signed integer. This routine accepts hexadecimal literals,
35819 ** 0 Successful transformation. Fits in a 64-bit signed integer.
35821 ** 2 Integer too large for a 64-bit signed integer or is malformed
35836 if( k-i>16 ) return 2; in sqlite3DecOrHexToI64()
35842 int n = (int)(0x3fffffff&strspn(z,"+- \n\t0123456789")); in sqlite3DecOrHexToI64()
35849 ** If zNum represents an integer that will fit in 32-bits, then set
35854 ** Any non-numeric characters that following zNum are ignored.
35856 ** input number to be zero-terminated.
35862 if( zNum[0]=='-' ){ in sqlite3GetInt32()
35889 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ in sqlite3GetInt32()
35896 ** 2^31 -> 2147483648 in sqlite3GetInt32()
35902 testcase( v-neg==2147483647 ); in sqlite3GetInt32()
35903 if( v-neg>2147483647 ){ in sqlite3GetInt32()
35907 v = -v; in sqlite3GetInt32()
35914 ** Return a 32-bit integer value extracted from a string. If the
35924 ** Decode a floating-point value into an approximate decimal
35928 ** n is positive. Or round to -n signficant digits after the
35933 ** stored in p->z[] which is a often (but not always) a pointer
35934 ** into the middle of p->zBuf[]. There are p->n significant digits.
35935 ** The p->z[] array is *not* zero-terminated.
35941 p->isSpecial = 0; in sqlite3FpDecode()
35942 p->z = p->zBuf; in sqlite3FpDecode()
35947 p->sign = '-'; in sqlite3FpDecode()
35948 r = -r; in sqlite3FpDecode()
35950 p->sign = '+'; in sqlite3FpDecode()
35951 p->n = 1; in sqlite3FpDecode()
35952 p->iDP = 1; in sqlite3FpDecode()
35953 p->z = "0"; in sqlite3FpDecode()
35956 p->sign = '+'; in sqlite3FpDecode()
35961 p->isSpecial = 1 + (v!=0x7ff0000000000000LL); in sqlite3FpDecode()
35962 p->n = 0; in sqlite3FpDecode()
35963 p->iDP = 0; in sqlite3FpDecode()
35973 while( rr>=1.0e+119L ){ exp+=100; rr *= 1.0e-100L; } in sqlite3FpDecode()
35974 while( rr>=1.0e+29L ){ exp+=10; rr *= 1.0e-10L; } in sqlite3FpDecode()
35975 while( rr>=1.0e+19L ){ exp++; rr *= 1.0e-1L; } in sqlite3FpDecode()
35977 while( rr<1.0e-97L ){ exp-=100; rr *= 1.0e+100L; } in sqlite3FpDecode()
35978 while( rr<1.0e+07L ){ exp-=10; rr *= 1.0e+10L; } in sqlite3FpDecode()
35979 while( rr<1.0e+17L ){ exp--; rr *= 1.0e+1L; } in sqlite3FpDecode()
35983 /* If high-precision floating point is not available using "long double", in sqlite3FpDecode()
35984 ** then use Dekker-style double-double computation to increase the in sqlite3FpDecode()
35987 ** The error terms on constants like 1.0e+100 computed using the in sqlite3FpDecode()
35990 ** SELECT decimal_exp(decimal_sub('1.0e+100',decimal(1.0e+100))); in sqlite3FpDecode()
35997 exp += 100; in sqlite3FpDecode()
35998 dekkerMul2(rr, 1.0e-100, -1.99918998026028836196e-117); in sqlite3FpDecode()
36002 dekkerMul2(rr, 1.0e-10, -3.6432197315497741579e-27); in sqlite3FpDecode()
36006 dekkerMul2(rr, 1.0e-01, -5.5511151231257827021e-18); in sqlite3FpDecode()
36009 while( rr[0]<9.223372036854774784e-83 ){ in sqlite3FpDecode()
36010 exp -= 100; in sqlite3FpDecode()
36011 dekkerMul2(rr, 1.0e+100, -1.5902891109759918046e+83); in sqlite3FpDecode()
36014 exp -= 10; in sqlite3FpDecode()
36018 exp -= 1; in sqlite3FpDecode()
36022 v = rr[1]<0.0 ? (u64)rr[0]-(u64)(-rr[1]) : (u64)rr[0]+(u64)rr[1]; in sqlite3FpDecode()
36027 i = sizeof(p->zBuf)-1; in sqlite3FpDecode()
36029 while( v ){ p->zBuf[i--] = (v%10) + '0'; v /= 10; } in sqlite3FpDecode()
36030 assert( i>=0 && i<sizeof(p->zBuf)-1 ); in sqlite3FpDecode()
36031 p->n = sizeof(p->zBuf) - 1 - i; in sqlite3FpDecode()
36032 assert( p->n>0 ); in sqlite3FpDecode()
36033 assert( p->n<sizeof(p->zBuf) ); in sqlite3FpDecode()
36034 p->iDP = p->n + exp; in sqlite3FpDecode()
36036 iRound = p->iDP - iRound; in sqlite3FpDecode()
36037 if( iRound==0 && p->zBuf[i+1]>='5' ){ in sqlite3FpDecode()
36039 p->zBuf[i--] = '0'; in sqlite3FpDecode()
36040 p->n++; in sqlite3FpDecode()
36041 p->iDP++; in sqlite3FpDecode()
36044 if( iRound>0 && (iRound<p->n || p->n>mxRound) ){ in sqlite3FpDecode()
36045 char *z = &p->zBuf[i+1]; in sqlite3FpDecode()
36047 p->n = iRound; in sqlite3FpDecode()
36049 int j = iRound-1; in sqlite3FpDecode()
36050 while( 1 /*exit-by-break*/ ){ in sqlite3FpDecode()
36055 p->z[i--] = '1'; in sqlite3FpDecode()
36056 p->n++; in sqlite3FpDecode()
36057 p->iDP++; in sqlite3FpDecode()
36060 j--; in sqlite3FpDecode()
36065 p->z = &p->zBuf[i+1]; in sqlite3FpDecode()
36066 assert( i+p->n < sizeof(p->zBuf) ); in sqlite3FpDecode()
36067 while( ALWAYS(p->n>0) && p->z[p->n-1]=='0' ){ p->n--; } in sqlite3FpDecode()
36071 ** Try to convert z into an unsigned 32-bit integer. Return true on
36080 v = v*10 + z[i] - '0'; in sqlite3GetUInt32()
36089 ** The variable-length integer encoding is as follows:
36096 ** 7 bits - A
36097 ** 14 bits - BA
36098 ** 21 bits - BBA
36099 ** 28 bits - BBBA
36100 ** 35 bits - BBBBA
36101 ** 42 bits - BBBBBA
36102 ** 49 bits - BBBBBBA
36103 ** 56 bits - BBBBBBBA
36104 ** 64 bits - BBBBBBBBC
36108 ** Write a 64-bit variable-length integer to memory starting at p[0].
36112 ** A variable-length integer consists of the lower 7 bits of each byte
36123 for(i=7; i>=0; i--){ in putVarint64()
36136 for(i=0, j=n-1; j>=0; j--, i++){ in putVarint64()
36168 ** Read a 64-bit variable-length integer from memory starting at p[0].
36311 b = p[-4]; in sqlite3GetVarint()
36322 ** Read a 32-bit variable-length integer from memory starting at p[0].
36325 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
36329 ** single-byte case. All code should use the MACRO version as
36330 ** this function assumes the single-byte case has already been handled.
36336 /* Assume that the single-byte case has already been handled by in sqlite3GetVarint32()
36341 /* This is the two-byte case */ in sqlite3GetVarint32()
36346 /* This is the three-byte case */ in sqlite3GetVarint32()
36363 ** 64-bit integer.
36373 ** Read or write a four-byte big-endian integer value.
36440 n--; in sqlite3HexToBlob()
36483 eOpenState = db->eOpenState; in sqlite3SafetyCheckOk()
36496 eOpenState = db->eOpenState; in sqlite3SafetyCheckSickOrOk()
36509 ** Attempt to add, subtract, or multiply the 64-bit signed value iB against
36510 ** the other 64-bit signed integer at *pA and store the result in *pA.
36520 testcase( iB==-1 ); testcase( iB==0 ); in sqlite3AddInt64()
36522 testcase( iA>0 && LARGEST_INT64 - iA == iB ); in sqlite3AddInt64()
36523 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); in sqlite3AddInt64()
36524 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; in sqlite3AddInt64()
36526 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); in sqlite3AddInt64()
36527 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); in sqlite3AddInt64()
36528 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; in sqlite3AddInt64()
36540 testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); in sqlite3SubInt64()
36542 *pA -= iB; in sqlite3SubInt64()
36545 return sqlite3AddInt64(pA, -iB); in sqlite3SubInt64()
36563 if( -iA>LARGEST_INT64/-iB ) return 1; in sqlite3MulInt64()
36572 ** Compute the absolute value of a 32-bit signed integer, of possible. Or
36573 ** if the integer has a value of -2147483648, return +2147483647
36578 return -x; in sqlite3AbsInt32()
36583 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
36589 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
36594 ** test.db-journal => test.nal
36595 ** test.db-wal => test.wal
36596 ** test.db-shm => test.shm
36597 ** test.db-mj7f3319fa => test.9fa
36606 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} in sqlite3FileSuffix3()
36607 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); in sqlite3FileSuffix3()
36625 5, 5, 5, /* 12-14 */ in sqlite3LogEstAdd()
36626 4, 4, 4, 4, /* 15-18 */ in sqlite3LogEstAdd()
36627 3, 3, 3, 3, 3, 3, /* 19-24 */ in sqlite3LogEstAdd()
36628 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ in sqlite3LogEstAdd()
36633 return a+x[a-b]; in sqlite3LogEstAdd()
36637 return b+x[b-a]; in sqlite3LogEstAdd()
36650 while( x<8 ){ y -= 10; x <<= 1; } in sqlite3LogEst()
36653 int i = 60 - __builtin_clzll(x); in sqlite3LogEst()
36657 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/ in sqlite3LogEst()
36661 return a[x&7] + y - 10; in sqlite3LogEst()
36675 e = (a>>52) - 1022; in sqlite3LogEstFromDouble()
36686 if( n>=5 ) n -= 2; in sqlite3LogEstToInt()
36687 else if( n>=1 ) n -= 1; in sqlite3LogEstToInt()
36689 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x); in sqlite3LogEstToInt()
36696 ** db->mallocFailed flag is set.
36709 ** is always zero-terminated.
36796 ** High-resolution hardware timer used for debugging and testing only.
36815 ** This file contains inline asm code for retrieving "high-performance"
36822 ** The following routine only works on Pentium-class (or newer) processors.
36824 ** processor and returns that value. This can be used for high-res
36906 ** This is the implementation of generic hash-tables
36919 pNew->first = 0;
36920 pNew->count = 0;
36921 pNew->htsize = 0;
36922 pNew->ht = 0;
36933 elem = pH->first;
36934 pH->first = 0;
36935 sqlite3_free(pH->ht);
36936 pH->ht = 0;
36937 pH->htsize = 0;
36939 HashElem *next_elem = elem->next;
36943 pH->count = 0;
36952 while( (c = (unsigned char)*z++)!=0 ){ /*OPTIMIZATION-IF-TRUE*/
36955 ** (2**32)*golden_ratio, where golden_ratio = (sqrt(5) - 1)/2. */
36973 pHead = pEntry->count ? pEntry->chain : 0;
36974 pEntry->count++;
36975 pEntry->chain = pNew;
36980 pNew->next = pHead;
36981 pNew->prev = pHead->prev;
36982 if( pHead->prev ){ pHead->prev->next = pNew; }
36983 else { pH->first = pNew; }
36984 pHead->prev = pNew;
36986 pNew->next = pH->first;
36987 if( pH->first ){ pH->first->prev = pNew; }
36988 pNew->prev = 0;
36989 pH->first = pNew;
37008 if( new_size==pH->htsize ) return 0;
37024 sqlite3_free(pH->ht);
37025 pH->ht = new_ht;
37026 pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
37028 for(elem=pH->first, pH->first=0; elem; elem = next_elem){
37029 unsigned int h = strHash(elem->pKey) % new_size;
37030 next_elem = elem->next;
37051 if( pH->ht ){ /*OPTIMIZATION-IF-TRUE*/
37053 h = strHash(pKey) % pH->htsize;
37054 pEntry = &pH->ht[h];
37055 elem = pEntry->chain;
37056 count = pEntry->count;
37059 elem = pH->first;
37060 count = pH->count;
37065 if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
37068 elem = elem->next;
37069 count--;
37083 if( elem->prev ){
37084 elem->prev->next = elem->next;
37086 pH->first = elem->next;
37088 if( elem->next ){
37089 elem->next->prev = elem->prev;
37091 if( pH->ht ){
37092 pEntry = &pH->ht[h];
37093 if( pEntry->chain==elem ){
37094 pEntry->chain = elem->next;
37096 assert( pEntry->count>0 );
37097 pEntry->count--;
37100 pH->count--;
37101 if( pH->count==0 ){
37102 assert( pH->first==0 );
37103 assert( pH->count==0 );
37115 return findElementWithHash(pH, pKey, 0)->data;
37140 if( elem->data ){
37141 void *old_data = elem->data;
37145 elem->data = data;
37146 elem->pKey = pKey;
37153 new_elem->pKey = pKey;
37154 new_elem->data = data;
37155 pH->count++;
37156 if( pH->count>=10 && pH->count > 2*pH->htsize ){
37157 if( rehash(pH, pH->count*2) ){
37158 assert( pH->htsize>0 );
37159 h = strHash(pKey) % pH->htsize;
37162 insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem);
37239 /* 59 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
37240 /* 60 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
37241 /* 61 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"),
37270 /* 90 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"),
37280 /* 100 */ "SetCookie" OpHelp(""),
37287 /* 107 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"),
37304 /* 124 */ "SeekScan" OpHelp("Scan-ahead up to P1 rows"),
37340 /* 160 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
37378 ** 2022-09-06
37421 ** VFS - the database and the rollback journal.
37424 sqlite3_file base; /* IO methods */
37430 sqlite3_int64 szDb; /* Database file size. -1 means unknown */
37545 /* Forward declarations for the low-level storage engine
37561 sqlite3_snprintf(KVSTORAGE_KEY_SZ, zKeyOut, "kvvfs-%s-%s", zClass, zKeyIn);
37565 ** underlying key/value store to use - either "local" or "session".
37567 ** Both zKey and zData are zero-terminated pure text strings.
37581 SQLITE_KV_TRACE(("KVVFS-WRITE %-15s (%d) %.50s%s\n", zXKey,
37594 ** this routine is a no-op.
37600 SQLITE_KV_TRACE(("KVVFS-DELETE %-15s\n", zXKey));
37611 ** not counting the final zero terminator. Return -1 if the key does
37631 SQLITE_KV_TRACE(("KVVFS-READ %-15s (-1)\n", zXKey));
37632 return -1;
37638 SQLITE_KV_TRACE(("KVVFS-READ %-15s (%d)\n", zXKey,
37647 SQLITE_KV_TRACE(("KVVFS-READ %-15s (-1)\n", zXKey));
37648 return -1;
37650 sqlite3_int64 n = fread(zBuf, 1, nBuf-1, fd);
37653 SQLITE_KV_TRACE(("KVVFS-READ %-15s (%lld) %.50s%s\n", zXKey,
37680 ** for JavaScript-side implementations in WASM builds. In such builds
37709 ** ---------------
37711 ** * Non-zero bytes are encoded as upper-case hexadecimal
37713 ** * A sequence of one or more zero-bytes that are not at the
37714 ** beginning of the buffer are encoded as a little-endian
37715 ** base-26 number using a..z. "a" means 0. "b" means 1,
37719 ** of hexadecimal and base-26 numbers, it is always clear where
37731 /* A sequence of 1 or more zeros is stored as a little-endian
37732 ** base-26 number using a..z as the digits. So one zero is "b".
37738 i += k-1;
37750 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37751 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37752 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37753 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
37754 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37755 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37756 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37757 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37759 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37760 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37761 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37762 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37763 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37764 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37765 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
37766 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
37789 n += (c - 'a')*mult;
37793 if( j+n>nOut ) return -1;
37809 ** Decode a complete journal file. Allocate space in pFile->aJrnl
37810 ** and store the decoding there. Or leave pFile->aJrnl set to NULL
37813 ** The first few characters of the text encoding will be a little-endian
37814 ** base-26 number (digits a..z) that is the total number of bytes
37815 ** in the decoded journal file image. This base-26 number is followed
37817 ** separator is required to act as a terminator for the base-26 number.
37820 KVVfsFile *pFile, /* Store decoding in pFile->aJrnl */
37821 const char *zTxt, /* Text encoding. Zero-terminated */
37829 n += (zTxt[i] - 'a')*mult;
37832 sqlite3_free(pFile->aJrnl);
37833 pFile->aJrnl = sqlite3_malloc64( n );
37834 if( pFile->aJrnl==0 ){
37835 pFile->nJrnl = 0;
37838 pFile->nJrnl = n;
37839 n = kvvfsDecode(zTxt+i, pFile->aJrnl, pFile->nJrnl);
37840 if( n<pFile->nJrnl ){
37841 sqlite3_free(pFile->aJrnl);
37842 pFile->aJrnl = 0;
37843 pFile->nJrnl = 0;
37853 sqlite3KvvfsMethods.xRead(pFile->zClass, "sz", zData, sizeof(zData)-1);
37859 return sqlite3KvvfsMethods.xWrite(pFile->zClass, "sz", zData);
37865 ** Close an kvvfs-file.
37870 SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass,
37871 pFile->isJournal ? "journal" : "db"));
37872 sqlite3_free(pFile->aJrnl);
37873 sqlite3_free(pFile->aData);
37878 ** Read from the -journal file.
37887 assert( pFile->isJournal );
37888 SQLITE_KV_LOG(("xRead('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37889 if( pFile->aJrnl==0 ){
37890 int szTxt = kvstorageRead(pFile->zClass, "jrnl", 0, 0);
37897 kvstorageRead(pFile->zClass, "jrnl", aTxt, szTxt+1);
37900 if( pFile->aJrnl==0 ) return SQLITE_IOERR;
37902 if( iOfst+iAmt>pFile->nJrnl ){
37905 memcpy(zBuf, pFile->aJrnl+iOfst, iAmt);
37922 char *aData = pFile->aData;
37925 SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37930 if( (iAmt & (iAmt-1))!=0 || iAmt<512 || iAmt>65536 ){
37933 pFile->szPage = iAmt;
37939 got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey,
37940 aData, SQLITE_KVOS_SZ-1);
37948 n = kvvfsDecode(aData, &aData[2000], SQLITE_KVOS_SZ-2000);
37960 memset(zBuf+n, 0, iAmt-n);
37968 ** Write into the -journal file.
37978 SQLITE_KV_LOG(("xWrite('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37980 if( pFile->aJrnl==0 || pFile->nJrnl<iEnd ){
37981 char *aNew = sqlite3_realloc(pFile->aJrnl, iEnd);
37985 pFile->aJrnl = aNew;
37986 if( pFile->nJrnl<iOfst ){
37987 memset(pFile->aJrnl+pFile->nJrnl, 0, iOfst-pFile->nJrnl);
37989 pFile->nJrnl = iEnd;
37991 memcpy(pFile->aJrnl+iOfst, zBuf, iAmt);
38007 char *aData = pFile->aData;
38008 SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
38010 assert( (iAmt & (iAmt-1))==0 );
38011 assert( pFile->szPage<0 || pFile->szPage==iAmt );
38012 pFile->szPage = iAmt;
38016 if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){
38019 if( iOfst+iAmt > pFile->szDb ){
38020 pFile->szDb = iOfst + iAmt;
38026 ** Truncate an kvvfs-file.
38030 SQLITE_KV_LOG(("xTruncate('%s-journal',%lld)\n", pFile->zClass, size));
38032 sqlite3KvvfsMethods.xDelete(pFile->zClass, "jrnl");
38033 sqlite3_free(pFile->aJrnl);
38034 pFile->aJrnl = 0;
38035 pFile->nJrnl = 0;
38040 if( pFile->szDb>size
38041 && pFile->szPage>0
38042 && (size % pFile->szPage)==0
38046 SQLITE_KV_LOG(("xTruncate('%s-db',%lld)\n", pFile->zClass, size));
38047 pgno = 1 + size/pFile->szPage;
38048 pgnoMax = 2 + pFile->szDb/pFile->szPage;
38051 sqlite3KvvfsMethods.xDelete(pFile->zClass, zKey);
38054 pFile->szDb = size;
38061 ** Sync an kvvfs-file.
38067 SQLITE_KV_LOG(("xSync('%s-journal')\n", pFile->zClass));
38068 if( pFile->nJrnl<=0 ){
38071 zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 );
38075 n = pFile->nJrnl;
38082 kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]);
38083 i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut);
38092 ** Return the current file-size of an kvvfs-file.
38096 SQLITE_KV_LOG(("xFileSize('%s-journal')\n", pFile->zClass));
38097 *pSize = pFile->nJrnl;
38102 SQLITE_KV_LOG(("xFileSize('%s-db')\n", pFile->zClass));
38103 if( pFile->szDb>=0 ){
38104 *pSize = pFile->szDb;
38112 ** Lock an kvvfs-file.
38116 assert( !pFile->isJournal );
38117 SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock));
38120 pFile->szDb = kvvfsReadFileSize(pFile);
38126 ** Unlock an kvvfs-file.
38130 assert( !pFile->isJournal );
38131 SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock));
38133 pFile->szDb = -1;
38139 ** Check if another file-handle holds a RESERVED lock on an kvvfs-file.
38148 ** File control method. For custom operations on an kvvfs-file.
38159 SQLITE_KV_LOG(("xSync('%s-db')\n", pFile->zClass));
38160 if( pFile->szDb>0 && 0!=kvvfsWriteFileSize(pFile, pFile->szDb) ){
38169 ** Return the sector-size in bytes for an kvvfs-file.
38176 ** Return the device characteristic flags supported by an kvvfs-file.
38200 pFile->isJournal = 0;
38201 pFile->base.pMethods = &kvvfs_db_io_methods;
38203 if( strcmp(zName, "local-journal")==0
38204 || strcmp(zName, "session-journal")==0
38206 pFile->isJournal = 1;
38207 pFile->base.pMethods = &kvvfs_jrnl_io_methods;
38212 pFile->zClass = "session";
38214 pFile->zClass = "local";
38216 pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ);
38217 if( pFile->aData==0 ){
38220 pFile->aJrnl = 0;
38221 pFile->nJrnl = 0;
38222 pFile->szPage = -1;
38223 pFile->szDb = -1;
38229 ** ensure the file-system modifications are synced to disk before
38233 if( strcmp(zPath, "local-journal")==0 ){
38236 if( strcmp(zPath, "session-journal")==0 ){
38253 if( strcmp(zPath, "local-journal")==0 ){
38256 if( strcmp(zPath, "session-journal")==0 ){
38289 if( nOut<nPath+1 ) nPath = nOut - 1;
38341 ** This routine is called initialize the KV-vfs as the default VFS.
38371 ** This file contains the VFS implementation for unix-like operating systems
38377 ** use flock(), dot-files, various proprietary locking schemas, or simply
38387 ** * General-purpose declarations and utility functions.
38391 ** + for no-op locks
38392 ** + for dot-file locks
38400 ** * Locking primitives for the proxy uber-locking-method. (MacOSX only)
38413 ** 3. Dot-file locking,
38473 ** -DHAVE_GETHOSTUUID=0
38474 ** -DHAVE_GETHOSTUUID=1
38477 ** -DSQLITE_ENABLE_LOCKING_STYLE.
38515 ** If we are to be thread-safe, include the pthreads header.
38536 ** Maximum supported path-length.
38543 #define SQLITE_MAX_SYMLINKS 100
38555 # define SQLITE_DEFAULT_UNIX_VFS "unix-dotfile"
38556 /* ^^^ should SQLITE_DEFAULT_UNIX_VFS be "unix-none"? */
38595 typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
38624 UnixUnusedFd *pPreallocatedUnused; /* Pre-allocated UnixUnusedFd */
38651 ** transaction counter in bytes 24-27 of database files are updated
38716 ** The threadid macro resolves to the thread-id or to 0. Used for
38737 ** Explicitly call the 64-bit version of lseek() on Android. Otherwise, lseek()
38738 ** is the 32-bit version, even if _FILE_OFFSET_BITS=64 is defined.
38746 ** Linux-specific IOCTL magic numbers used for controlling F2FS
38764 ** which always has the same well-defined interface.
38775 ** Many system calls are accessed through pointer-to-functions so that
38804 ** DJGPP. But it is DOS - what did you expect?
38957 ** log if they come from non-root processes. So avoid calling fchown() if
39037 int i = -1;
39041 for(i=0; i<ArraySize(aSyscall)-1; i++){
39069 ** The m parameter will be non-zero only when creating -wal, -journal,
39070 ** and -shm files. We want those files to have *exactly* the same
39072 ** In that way, if a database file is -rw-rw-rw or -rw-rw-r-, and a
39097 fd = -1;
39162 ** integer lock-type.
39181 ** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
39182 ** command-line option on the compiler. This code is normally
39198 if( p->l_type==F_RDLCK ){
39200 }else if( p->l_type==F_WRLCK ){
39202 }else if( p->l_type==F_UNLCK ){
39207 assert( p->l_whence==SEEK_SET );
39211 threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
39212 (int)p->l_pid, s);
39213 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
39226 sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
39246 /* On Android, ftruncate() always uses 32-bit offsets, even if
39307 ** a performance-critical path, so it is sufficient to put these
39332 ** Changes are made in-place. Return the new name length.
39334 ** The original filename is in z[0..n-1]. Return the number of
39339 while( n>1 && z[n-1]=='/' ){ n--; }
39348 while( j>0 && z[j-1]!='/' ){ j--; }
39349 if( j>0 ){ j--; }
39380 pNew->zCanonicalName = (char*)&pNew[1];
39381 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
39382 n = vxworksSimplifyName(pNew->zCanonicalName, n);
39389 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
39390 if( pCandidate->nName==n
39391 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
39394 pCandidate->nRef++;
39401 pNew->nRef = 1;
39402 pNew->nName = n;
39403 pNew->pNext = vxworksFileList;
39415 assert( pId->nRef>0 );
39416 pId->nRef--;
39417 if( pId->nRef==0 ){
39419 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
39421 *pp = pId->pNext;
39479 ** file is unlocked. cnt==-1 means the file has an exclusive lock.
39507 ** on linux - with NPTL a lock created by thread A can override locks
39508 ** in thread B. But there is no way to know at compile-time which
39510 ** compile-time whether or not thread A can override locks on thread B.
39511 ** One has to do a run-time check to discover the behavior of the
39531 ** sizes ino_t at only 32-bits instead of 64-bits. (See
39532 ** https://android-review.googlesource.com/#/c/115351/3/dist/sqlite3.c)
39533 ** To work around this, always allocate 64-bits for the inode number.
39534 ** On small machines that only have 32-bit inodes, this wastes 4 bytes,
39601 assert( pFile->pInode );
39602 return sqlite3_mutex_held(pFile->pInode->pLockMutex);
39605 assert( pFile->pInode );
39606 return sqlite3_mutex_notheld(pFile->pInode->pLockMutex);
39612 ** This function - unixLogErrorAtLine(), is only ever called via the macro
39617 ** errno and, if possible, the human-readable equivalent from strerror() or
39623 ** failed (e.g. "unlink", "open") and the associated file-system path,
39637 ** the strerror() function to obtain the human-readable error message
39658 ** int-type return, depending on its version.
39664 strerror_r(iErrno, aErr, sizeof(aErr)-1);
39670 /* Non-threadsafe build, use strerror(). */
39676 "os_unix.c:%d: (%d) %s(%s) - %s",
39699 pFile ? pFile->zPath : 0, lineno);
39704 ** Set the pFile->lastErrno. Do this in a subroutine as that provides
39708 pFile->lastErrno = error;
39712 ** Close all file descriptors accumulated in the unixInodeInfo->pUnused list.
39715 unixInodeInfo *pInode = pFile->pInode;
39719 for(p=pInode->pUnused; p; p=pNext){
39720 pNext = p->pNext;
39721 robust_close(pFile, p->fd, __LINE__);
39724 pInode->pUnused = 0;
39734 unixInodeInfo *pInode = pFile->pInode;
39738 pInode->nRef--;
39739 if( pInode->nRef==0 ){
39740 assert( pInode->pShmNode==0 );
39741 sqlite3_mutex_enter(pInode->pLockMutex);
39743 sqlite3_mutex_leave(pInode->pLockMutex);
39744 if( pInode->pPrev ){
39745 assert( pInode->pPrev->pNext==pInode );
39746 pInode->pPrev->pNext = pInode->pNext;
39749 inodeList = pInode->pNext;
39751 if( pInode->pNext ){
39752 assert( pInode->pNext->pPrev==pInode );
39753 pInode->pNext->pPrev = pInode->pPrev;
39755 sqlite3_mutex_free(pInode->pLockMutex);
39777 struct stat statbuf; /* Low-level file information */
39782 /* Get low-level information about the file that we can used to
39785 fd = pFile->h;
39790 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
39797 ** incorrectly for zero-size files. See ticket #3260. To work
39806 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
39823 fileId.pId = pFile->pId;
39829 while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
39830 pInode = pInode->pNext;
39838 memcpy(&pInode->fileId, &fileId, sizeof(fileId));
39840 pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
39841 if( pInode->pLockMutex==0 ){
39846 pInode->nRef = 1;
39848 pInode->pNext = inodeList;
39849 pInode->pPrev = 0;
39850 if( inodeList ) inodeList->pPrev = pInode;
39853 pInode->nRef++;
39864 return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
39867 return pFile->pInode!=0 &&
39868 (osStat(pFile->zPath, &buf)!=0
39869 || (u64)buf.st_ino!=pFile->pInode->fileId.ino);
39888 if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;
39890 rc = osFstat(pFile->h, &buf);
39892 sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
39896 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
39900 sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
39904 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
39913 ** to a non-zero value otherwise *pResOut is set to zero. The return value
39924 assert( pFile->eFileLock<=SHARED_LOCK );
39925 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
39928 if( pFile->pInode->eFileLock>SHARED_LOCK ){
39935 if( !reserved && !pFile->pInode->bProcessLock ){
39941 if( osFcntl(pFile->h, F_GETLK, &lock) ){
39950 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
39951 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
39961 ** Set a posix-advisory-lock.
39965 ** which is a pointer to a unixFile. If the unixFile->iBusyTimeout
39970 ** If SQLITE_ENABLE_SETLK_TIMEOUT is not defined, then do a non-blocking
39981 int tm = pFile->iBusyTimeout;
39991 tm--;
39999 ** Attempt to set a system-lock on the file pFile. The lock is
40002 ** If the pFile was opened read/write from unix-excl, then the only lock
40005 ** operations become no-ops. Locking operations still happen internally,
40010 ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
40011 ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
40012 ** and is read-only.
40014 ** Zero is returned if the call completes successfully, or -1 if a call
40019 unixInodeInfo *pInode = pFile->pInode;
40021 assert( sqlite3_mutex_held(pInode->pLockMutex) );
40022 if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
40023 if( pInode->bProcessLock==0 ){
40025 assert( pInode->nLock==0 );
40030 rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
40032 pInode->bProcessLock = 1;
40033 pInode->nLock++;
40038 rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
40044 ** Lock the file with the lock specified by parameter eFileLock - one
40058 ** UNLOCKED -> SHARED
40059 ** SHARED -> RESERVED
40060 ** SHARED -> EXCLUSIVE
40061 ** RESERVED -> (PENDING) -> EXCLUSIVE
40062 ** PENDING -> EXCLUSIVE
40070 ** lock primitives (called read-locks and write-locks below, to avoid
40079 ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
40080 ** byte'. If this is successful, 'shared byte range' is read-locked
40083 ** and Windows95 lacks a shared-lock capability. So on Windows95, a
40085 ** Windows95 is now pretty much extinct, but this work-around for the
40086 ** lack of shared-locks on Windows95 lives on, for backwards
40090 ** A RESERVED lock is implemented by grabbing a write-lock on the
40095 ** a write-lock on the entire 'shared byte range'. Since all other locks
40096 ** require a read-lock on one of the bytes within this range, this ensures
40101 ** obtaining a write-lock on the 'pending byte'. This ensures that no new
40105 ** then re-attempt the EXCLUSIVE lock later on, after existing SHARED
40115 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
40116 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
40117 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
40124 if( pFile->eFileLock>=eFileLock ){
40125 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
40135 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
40137 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
40139 /* This mutex is needed because pFile->pInode is shared across threads
40141 pInode = pFile->pInode;
40142 sqlite3_mutex_enter(pInode->pLockMutex);
40147 if( (pFile->eFileLock!=pInode->eFileLock &&
40148 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
40159 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
40161 assert( pFile->eFileLock==0 );
40162 assert( pInode->nShared>0 );
40163 pFile->eFileLock = SHARED_LOCK;
40164 pInode->nShared++;
40165 pInode->nLock++;
40177 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK)
40189 pFile->eFileLock = PENDING_LOCK;
40190 pInode->eFileLock = PENDING_LOCK;
40199 assert( pInode->nShared==0 );
40200 assert( pInode->eFileLock==0 );
40203 /* Now get the read-lock */
40227 pFile->eFileLock = SHARED_LOCK;
40228 pInode->nLock++;
40229 pInode->nShared = 1;
40231 }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
40240 assert( 0!=pFile->eFileLock );
40263 /* Set up the transaction-counter change checking flags when
40269 && pFile->eFileLock<=SHARED_LOCK
40272 pFile->transCntrChng = 0;
40273 pFile->dbUpdate = 0;
40274 pFile->inNormalWrite = 1;
40279 pFile->eFileLock = eFileLock;
40280 pInode->eFileLock = eFileLock;
40284 sqlite3_mutex_leave(pInode->pLockMutex);
40285 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
40295 unixInodeInfo *pInode = pFile->pInode;
40296 UnixUnusedFd *p = pFile->pPreallocatedUnused;
40298 p->pNext = pInode->pUnused;
40299 pInode->pUnused = p;
40300 pFile->h = -1;
40301 pFile->pPreallocatedUnused = 0;
40309 ** the requested locking level, this routine is a no-op.
40324 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
40325 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
40329 if( pFile->eFileLock<=eFileLock ){
40332 pInode = pFile->pInode;
40333 sqlite3_mutex_enter(pInode->pLockMutex);
40334 assert( pInode->nShared!=0 );
40335 if( pFile->eFileLock>SHARED_LOCK ){
40336 assert( pInode->eFileLock==pFile->eFileLock );
40347 pFile->inNormalWrite = 0;
40351 ** before establishing the readlock - to avoid a race condition we downgrade
40367 off_t divSize = SHARED_SIZE - 1;
40373 if( unixFileLock(pFile, &lock)==(-1) ){
40383 if( unixFileLock(pFile, &lock)==(-1) ){
40394 lock.l_len = SHARED_SIZE-divSize;
40395 if( unixFileLock(pFile, &lock)==(-1) ){
40426 pInode->eFileLock = SHARED_LOCK;
40438 pInode->nShared--;
40439 if( pInode->nShared==0 ){
40444 pInode->eFileLock = NO_LOCK;
40448 pInode->eFileLock = NO_LOCK;
40449 pFile->eFileLock = NO_LOCK;
40457 pInode->nLock--;
40458 assert( pInode->nLock>=0 );
40459 if( pInode->nLock==0 ) closePendingFds(pFile);
40463 sqlite3_mutex_leave(pInode->pLockMutex);
40465 pFile->eFileLock = eFileLock;
40475 ** the requested locking level, this routine is a no-op.
40479 assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
40504 if( pFile->h>=0 ){
40505 robust_close(pFile, pFile->h, __LINE__);
40506 pFile->h = -1;
40509 if( pFile->pId ){
40510 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40511 osUnlink(pFile->pId->zCanonicalName);
40513 vxworksReleaseFileId(pFile->pId);
40514 pFile->pId = 0;
40518 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40519 osUnlink(pFile->zPath);
40520 sqlite3_free(*(char**)&pFile->zPath);
40521 pFile->zPath = 0;
40524 OSTRACE(("CLOSE %-3d\n", pFile->h));
40525 OpenCounter(-1);
40526 sqlite3_free(pFile->pPreallocatedUnused);
40537 unixInodeInfo *pInode = pFile->pInode;
40548 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
40549 sqlite3_mutex_enter(pInode->pLockMutex);
40550 if( pInode->nLock ){
40553 ** descriptor to pInode->pUnused list. It will be automatically closed
40558 sqlite3_mutex_leave(pInode->pLockMutex);
40560 assert( pFile->pShm==0 );
40570 ****************************** No-op Locking **********************************
40576 ** This locking mode is appropriate for use on read-only databases
40577 ** (ex: databases that are burned into CD-ROM, for example.) It can
40607 /******************* End of the no-op lock implementation *********************
40611 ************************* Begin dot-file Locking ******************************
40633 ** The file suffix added to the data base filename in order to create the
40641 ** to a non-zero value otherwise *pResOut is set to zero. The return value
40656 reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
40657 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
40663 ** Lock the file with the lock specified by parameter eFileLock - one
40677 ** UNLOCKED -> SHARED
40678 ** SHARED -> RESERVED
40679 ** SHARED -> (PENDING) -> EXCLUSIVE
40680 ** RESERVED -> (PENDING) -> EXCLUSIVE
40681 ** PENDING -> EXCLUSIVE
40691 char *zLockFile = (char *)pFile->lockingContext;
40698 if( pFile->eFileLock > NO_LOCK ){
40699 pFile->eFileLock = eFileLock;
40726 pFile->eFileLock = eFileLock;
40735 ** the requested locking level, this routine is a no-op.
40741 char *zLockFile = (char *)pFile->lockingContext;
40745 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
40746 pFile->eFileLock, osGetpid(0)));
40749 /* no-op if possible */
40750 if( pFile->eFileLock==eFileLock ){
40758 pFile->eFileLock = SHARED_LOCK;
40775 pFile->eFileLock = NO_LOCK;
40786 sqlite3_free(pFile->lockingContext);
40789 /****************** End of the dot-file lock implementation *******************
40797 ** flock() locking is like dot-file locking in that the various
40798 ** fine-grain locking levels supported by SQLite are collapsed into
40825 ** to a non-zero value otherwise *pResOut is set to zero. The return value
40838 if( pFile->eFileLock>SHARED_LOCK ){
40845 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
40848 lrc = robust_flock(pFile->h, LOCK_UN);
40867 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
40880 ** Lock the file with the lock specified by parameter eFileLock - one
40894 ** UNLOCKED -> SHARED
40895 ** SHARED -> RESERVED
40896 ** SHARED -> (PENDING) -> EXCLUSIVE
40897 ** RESERVED -> (PENDING) -> EXCLUSIVE
40898 ** PENDING -> EXCLUSIVE
40916 if (pFile->eFileLock > NO_LOCK) {
40917 pFile->eFileLock = eFileLock;
40923 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
40932 pFile->eFileLock = eFileLock;
40934 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
40950 ** the requested locking level, this routine is a no-op.
40956 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
40957 pFile->eFileLock, osGetpid(0)));
40960 /* no-op if possible */
40961 if( pFile->eFileLock==eFileLock ){
40967 pFile->eFileLock = eFileLock;
40972 if( robust_flock(pFile->h, LOCK_UN) ){
40978 pFile->eFileLock = NO_LOCK;
41002 ** Semaphore locking is like dot-lock and flock in that it really only
41012 ** to a non-zero value otherwise *pResOut is set to zero. The return value
41025 if( pFile->eFileLock>SHARED_LOCK ){
41031 sem_t *pSem = pFile->pInode->pSem;
41033 if( sem_trywait(pSem)==-1 ){
41040 reserved = (pFile->eFileLock < SHARED_LOCK);
41047 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
41054 ** Lock the file with the lock specified by parameter eFileLock - one
41068 ** UNLOCKED -> SHARED
41069 ** SHARED -> RESERVED
41070 ** SHARED -> (PENDING) -> EXCLUSIVE
41071 ** RESERVED -> (PENDING) -> EXCLUSIVE
41072 ** PENDING -> EXCLUSIVE
41084 sem_t *pSem = pFile->pInode->pSem;
41089 if (pFile->eFileLock > NO_LOCK) {
41090 pFile->eFileLock = eFileLock;
41096 if( sem_trywait(pSem)==-1 ){
41102 pFile->eFileLock = eFileLock;
41113 ** the requested locking level, this routine is a no-op.
41117 sem_t *pSem = pFile->pInode->pSem;
41121 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
41122 pFile->eFileLock, osGetpid(0)));
41125 /* no-op if possible */
41126 if( pFile->eFileLock==eFileLock ){
41132 pFile->eFileLock = eFileLock;
41137 if ( sem_post(pSem)==-1 ) {
41145 pFile->eFileLock = NO_LOCK;
41178 ** on Apple Macintosh computers - both OS9 and OSX.
41180 ** Third-party implementations of AFP are available. But this code here
41207 ** This is a utility for setting or clearing a bit-range lock on an
41226 pb.fd = pFile->h;
41229 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
41232 if ( err==-1 ) {
41255 ** to a non-zero value otherwise *pResOut is set to zero. The return value
41267 context = (afpLockingContext *) pFile->lockingContext;
41268 if( context->reserved ){
41272 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
41274 if( pFile->pInode->eFileLock>SHARED_LOCK ){
41282 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
41286 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
41296 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
41297 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
41304 ** Lock the file with the lock specified by parameter eFileLock - one
41318 ** UNLOCKED -> SHARED
41319 ** SHARED -> RESERVED
41320 ** SHARED -> (PENDING) -> EXCLUSIVE
41321 ** RESERVED -> (PENDING) -> EXCLUSIVE
41322 ** PENDING -> EXCLUSIVE
41330 unixInodeInfo *pInode = pFile->pInode;
41331 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
41334 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
41335 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
41336 azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0)));
41342 if( pFile->eFileLock>=eFileLock ){
41343 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
41353 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
41355 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
41357 /* This mutex is needed because pFile->pInode is shared across threads
41359 pInode = pFile->pInode;
41360 sqlite3_mutex_enter(pInode->pLockMutex);
41365 if( (pFile->eFileLock!=pInode->eFileLock &&
41366 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
41377 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
41379 assert( pFile->eFileLock==0 );
41380 assert( pInode->nShared>0 );
41381 pFile->eFileLock = SHARED_LOCK;
41382 pInode->nShared++;
41383 pInode->nLock++;
41392 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
41395 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
41409 assert( pInode->nShared==0 );
41410 assert( pInode->eFileLock==0 );
41413 /* Now get the read-lock SHARED_LOCK */
41416 pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
41417 lrc1 = afpSetLock(context->dbPath, pFile,
41418 SHARED_FIRST+pInode->sharedByte, 1, 1);
41420 lrc1Errno = pFile->lastErrno;
41423 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41435 pFile->eFileLock = SHARED_LOCK;
41436 pInode->nLock++;
41437 pInode->nShared = 1;
41439 }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
41449 assert( 0!=pFile->eFileLock );
41450 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
41452 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
41454 context->reserved = 1;
41463 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
41464 pInode->sharedByte, 1, 0)) ){
41467 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
41469 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
41470 SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
41488 pFile->eFileLock = eFileLock;
41489 pInode->eFileLock = eFileLock;
41491 pFile->eFileLock = PENDING_LOCK;
41492 pInode->eFileLock = PENDING_LOCK;
41496 sqlite3_mutex_leave(pInode->pLockMutex);
41497 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
41507 ** the requested locking level, this routine is a no-op.
41513 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
41517 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
41518 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
41522 if( pFile->eFileLock<=eFileLock ){
41525 pInode = pFile->pInode;
41526 sqlite3_mutex_enter(pInode->pLockMutex);
41527 assert( pInode->nShared!=0 );
41528 if( pFile->eFileLock>SHARED_LOCK ){
41529 assert( pInode->eFileLock==pFile->eFileLock );
41540 assert( pFile->inNormalWrite==0
41541 || pFile->dbUpdate==0
41542 || pFile->transCntrChng==1 );
41543 pFile->inNormalWrite = 0;
41546 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
41547 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
41548 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
41549 /* only re-establish the shared lock if necessary */
41550 int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
41551 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
41556 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
41557 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41559 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
41560 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
41562 context->reserved = 0;
41565 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
41566 pInode->eFileLock = SHARED_LOCK;
41575 unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
41576 pInode->nShared--;
41577 if( pInode->nShared==0 ){
41579 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
41582 pInode->eFileLock = NO_LOCK;
41583 pFile->eFileLock = NO_LOCK;
41587 pInode->nLock--;
41588 assert( pInode->nLock>=0 );
41589 if( pInode->nLock==0 ) closePendingFds(pFile);
41593 sqlite3_mutex_leave(pInode->pLockMutex);
41595 pFile->eFileLock = eFileLock;
41610 if( pFile->pInode ){
41611 unixInodeInfo *pInode = pFile->pInode;
41612 sqlite3_mutex_enter(pInode->pLockMutex);
41613 if( pInode->nLock ){
41616 ** descriptor to pInode->aPending. It will be automatically closed when
41621 sqlite3_mutex_leave(pInode->pLockMutex);
41624 sqlite3_free(pFile->lockingContext);
41634 ** is available. If you don't compile for a mac, then the "unix-afp"
41649 ** the requested locking level, this routine is a no-op.
41665 **************** Non-locking sqlite3_file methods *****************************
41689 assert( id->h>2 );
41692 got = osPread(id->h, pBuf, cnt, offset);
41693 SimulateIOError( got = -1 );
41695 got = osPread64(id->h, pBuf, cnt, offset);
41696 SimulateIOError( got = -1 );
41698 newOffset = lseek(id->h, offset, SEEK_SET);
41699 SimulateIOError( newOffset = -1 );
41702 return -1;
41704 got = osRead(id->h, pBuf, cnt);
41713 cnt -= got;
41720 OSTRACE(("READ %-3d %5d %7lld %llu\n",
41721 id->h, got+prior, offset-prior, TIMER_ELAPSED));
41742 /* If this is a database file (not a journal, super-journal or temp
41745 assert( pFile->pPreallocatedUnused==0
41754 if( offset<pFile->mmapSize ){
41755 if( offset+amt <= pFile->mmapSize ){
41756 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
41759 int nCopy = pFile->mmapSize - offset;
41760 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
41762 amt -= nCopy;
41772 /* pFile->lastErrno has been set by seekAndRead().
41779 switch( pFile->lastErrno ){
41793 /* Unread parts of the buffer must be zero-filled */
41794 memset(&((char*)pBuf)[got], 0, amt-got);
41800 ** Attempt to seek the file-descriptor passed as the first argument to
41802 ** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise,
41828 SimulateIOError( iSeek = -1 );
41830 rc = -1;
41838 OSTRACE(("WRITE %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED));
41846 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
41853 return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
41872 /* If this is a database file (not a journal, super-journal or temp
41875 assert( pFile->pPreallocatedUnused==0
41883 ** doing a hot-journal rollback or a write to some file other than a
41888 if( pFile->inNormalWrite ){
41889 pFile->dbUpdate = 1; /* The database has been modified */
41896 if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
41897 pFile->transCntrChng = 1; /* The transaction counter has changed */
41906 if( offset<pFile->mmapSize ){
41907 if( offset+amt <= pFile->mmapSize ){
41908 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
41911 int nCopy = pFile->mmapSize - offset;
41912 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
41914 amt -= nCopy;
41921 amt -= wrote;
41925 SimulateIOError(( wrote=(-1), amt=1 ));
41929 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
41954 ** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC
42024 ** no-op. But go ahead and call fstat() to validate the file
42057 if( rc==-1 && errno==ENOTSUP ){
42063 if( OS_VXWORKS && rc!= -1 ){
42076 ** The directory file descriptor is used for only one thing - to
42085 ** replace this routine with a harmless no-op. To make this routine
42086 ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
42094 int fd = -1;
42098 for(ii=(int)strlen(zDirname); ii>0 && zDirname[ii]!='/'; ii--);
42107 OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
42122 ** has been created by fsync-ing the directory that contains the file.
42127 ** will not roll back - possibly leading to database corruption.
42147 OSTRACE(("SYNC %-3d\n", pFile->h));
42148 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
42152 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
42156 ** is set. This is a one-time occurrence. Many systems (examples: AIX)
42159 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
42161 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
42163 rc = osOpenDirectory(pFile->zPath, &dirfd);
42171 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
42185 /* If the user has configured a chunk-size for this file, truncate the
42190 if( pFile->szChunk>0 ){
42191 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
42194 rc = robust_ftruncate(pFile->h, nByte);
42197 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
42201 ** doing a hot-journal rollback or a write to some file other than a
42204 ** when restoring a database using the backup API from a zero-length
42207 if( pFile->inNormalWrite && nByte==0 ){
42208 pFile->transCntrChng = 1;
42217 if( nByte<pFile->mmapSize ){
42218 pFile->mmapSize = nByte;
42233 rc = osFstat(((unixFile*)id)->h, &buf);
42241 /* When opening a zero-size database, the findInodeInfo() procedure
42243 ** in the OS-X msdos filesystem. In order to avoid problems with upper
42255 ** Handler for proxy-locking file-control verbs. Defined below in the
42263 ** file-control operation. Enlarge the database to nBytes in size
42264 ** (rounded up to the next chunk-size). If the database is already
42265 ** nBytes or larger, this routine is a no-op.
42268 if( pFile->szChunk>0 ){
42272 if( osFstat(pFile->h, &buf) ){
42276 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
42285 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
42292 ** at offset (nSize-1), to set the size of the file correctly.
42296 int nBlk = buf.st_blksize; /* File-system block size */
42300 iWrite = (buf.st_size/nBlk)*nBlk + nBlk - 1;
42303 for(/*no-op*/; iWrite<nSize+nBlk-1; iWrite+=nBlk ){
42304 if( iWrite>=nSize ) iWrite = nSize - 1;
42313 if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
42315 if( pFile->szChunk<=0 ){
42316 if( robust_ftruncate(pFile->h, nByte) ){
42318 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
42332 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
42334 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
42338 *pArg = (pFile->ctrlFlags & mask)!=0;
42340 pFile->ctrlFlags &= ~mask;
42342 pFile->ctrlFlags |= mask;
42360 int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
42364 int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
42368 int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
42374 *(int*)pArg = pFile->eFileLock;
42378 *(int*)pArg = pFile->lastErrno;
42382 pFile->szChunk = *(int *)pArg;
42401 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
42405 char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
42407 unixGetTempname(pFile->pVfs->mxPathname, zTFile);
42418 int iOld = pFile->iBusyTimeout;
42420 pFile->iBusyTimeout = *(int*)pArg;
42422 pFile->iBusyTimeout = !!(*(int*)pArg);
42440 ** 64-bit type. */
42445 *(i64*)pArg = pFile->mmapSizeMax;
42446 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
42447 pFile->mmapSizeMax = newLimit;
42448 if( pFile->mmapSize>0 ){
42450 rc = unixMapfile(pFile, -1);
42463 ((unixFile*)id)->dbUpdate = 0;
42487 ** If pFd->sectorSize is non-zero when this function is called, it is a
42488 ** no-op. Otherwise, the values of pFd->sectorSize and
42489 ** pFd->deviceCharacteristics are set according to the file-system
42497 assert( pFd->deviceCharacteristics==0 || pFd->sectorSize!=0 );
42498 if( pFd->sectorSize==0 ){
42504 res = osIoctl(pFd->h, F2FS_IOC_GET_FEATURES, &f);
42506 pFd->deviceCharacteristics = SQLITE_IOCAP_BATCH_ATOMIC;
42511 if( pFd->ctrlFlags & UNIXFILE_PSOW ){
42512 pFd->deviceCharacteristics |= SQLITE_IOCAP_POWERSAFE_OVERWRITE;
42515 pFd->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42522 if( pFile->sectorSize == 0 ){
42525 /* Set defaults for non-supported filesystems */
42526 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42527 pFile->deviceCharacteristics = 0;
42528 if( fstatvfs(pFile->h, &fsInfo) == -1 ) {
42533 pFile->sectorSize = fsInfo.f_bsize;
42534 pFile->deviceCharacteristics =
42542 pFile->sectorSize = fsInfo.f_bsize;
42543 pFile->deviceCharacteristics =
42545 (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) |
42552 pFile->sectorSize = fsInfo.f_bsize;
42553 pFile->deviceCharacteristics =
42561 pFile->sectorSize = fsInfo.f_bsize;
42562 pFile->deviceCharacteristics =
42564 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42569 pFile->sectorSize = fsInfo.f_bsize;
42570 pFile->deviceCharacteristics =
42572 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42577 pFile->deviceCharacteristics =
42586 if( pFile->sectorSize % 512 != 0 ){
42587 pFile->deviceCharacteristics = 0;
42588 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42599 ** if two files are created in the same file-system directory (i.e.
42606 return pFd->sectorSize;
42615 ** words, after a power-loss event, parts of the file that were never
42616 ** written might end up being altered.) However, non-PSOW behavior is very,
42619 ** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control
42625 return pFd->deviceCharacteristics;
42653 ** When multiple threads all reference the same wal-index, each thread
42655 ** of this unixShmNode object. In other words, each wal-index is opened
42670 ** The following fields are read-only after the object is created:
42682 ** locks are held by the process on this slot. If it is set to -1, then
42693 ** of mutexes - one for each locking slot. To read or write locking
42703 int szRegion; /* Size of shared-memory regions */
42705 u8 isReadonly; /* True if read-only */
42707 char **apRegion; /* Array of mapped shared-memory regions */
42713 int aLock[SQLITE_SHM_NLOCK]; /* # shared locks on slot, -1==excl lock */
42724 ** are read-only thereafter:
42729 ** All other fields are read/write. The unixShm.pShmNode->pShmMutex must
42735 u8 hasMutex; /* True if holding the unixShmNode->pShmMutex */
42749 ** wal-mode transactions in other processes on database file pFile. If
42758 if( pFile->pShm){
42759 unixShmNode *pShmNode = pFile->pShm->pShmNode;
42766 f.l_len = SQLITE_SHM_NLOCK - 3;
42768 sqlite3_mutex_enter(pShmNode->pShmMutex);
42769 if( osFcntl(pShmNode->hShm, F_GETLK, &f)<0 ){
42774 sqlite3_mutex_leave(pShmNode->pShmMutex);
42782 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
42784 ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
42793 unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */
42797 pShmNode = pFile->pInode->pShmNode;
42801 assert( pShmNode->nRef>=0 );
42806 assert( pShmNode->nRef>0 || unixMutexHeld() );
42807 assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) );
42811 for(ii=ofst-UNIX_SHM_BASE; ii<ofst-UNIX_SHM_BASE+n; ii++){
42812 assert( sqlite3_mutex_held(pShmNode->aMutex[ii]) );
42815 assert( sqlite3_mutex_held(pShmNode->pShmMutex) );
42816 assert( pShmNode->nRef>0 );
42827 if( pShmNode->hShm>=0 ){
42834 res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile);
42835 if( res==-1 ){
42837 rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
42846 OSTRACE(("SHM-LOCK "));
42849 OSTRACE(("unlock %d..%d ok\n", ofst, ofst+n-1));
42851 OSTRACE(("read-lock %d..%d ok\n", ofst, ofst+n-1));
42854 OSTRACE(("write-lock %d..%d ok\n", ofst, ofst+n-1));
42858 OSTRACE(("unlock %d..%d failed\n", ofst, ofst+n-1));
42860 OSTRACE(("read-lock %d..%d failed\n", ofst, ofst+n-1));
42863 OSTRACE(("write-lock %d..%d failed\n", ofst, ofst+n-1));
42874 ** current system page-size.
42877 ** to use 64KB pages - in this case each mapping must cover at least two
42883 assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */
42891 ** This is not a VFS shared-memory method; it is a utility function called
42892 ** by VFS shared-memory methods.
42895 unixShmNode *p = pFd->pInode->pShmNode;
42897 if( p && ALWAYS(p->nRef==0) ){
42900 assert( p->pInode==pFd->pInode );
42901 sqlite3_mutex_free(p->pShmMutex);
42904 sqlite3_mutex_free(p->aMutex[i]);
42907 for(i=0; i<p->nRegion; i+=nShmPerMap){
42908 if( p->hShm>=0 ){
42909 osMunmap(p->apRegion[i], p->szRegion);
42911 sqlite3_free(p->apRegion[i]);
42914 sqlite3_free(p->apRegion);
42915 if( p->hShm>=0 ){
42916 robust_close(pFd, p->hShm, __LINE__);
42917 p->hShm = -1;
42919 p->pInode->pShmNode = 0;
42931 ** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1.
42940 ** and proceed with opening the *-shm file.
42944 ** DMS byte and truncate the *-shm file to zero bytes in size. Then
42951 ** EXCLUSIVE failed just before truncating the *-shm file, then this
42952 ** process might open and use the *-shm file without truncating it.
42953 ** And if the *-shm file has been corrupted by a power failure or
42959 if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) {
42962 if( pShmNode->isReadonly ){
42963 pShmNode->isUnlocked = 1;
42969 ** *-shm file. And after it has done so, it will not release its
42973 int iSaveTimeout = pDbFd->iBusyTimeout;
42974 pDbFd->iBusyTimeout = 0;
42978 pDbFd->iBusyTimeout = iSaveTimeout;
42980 /* The first connection to attach must truncate the -shm file. We
42982 ** -shm header size) rather than 0 as a system debugging aid, to
42983 ** help detect if a -shm file truncation is legitimate or is the work
42985 if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){
42986 rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename);
43001 ** Open a shared-memory area associated with open database file pDbFd.
43004 ** The file used to implement shared-memory is in the same directory
43006 ** file with the "-shm" suffix added. For example, if the database file
43008 ** for shared memory will be called "/home/user1/config.db-shm".
43014 ** database to end up using different files for shared memory -
43015 ** meaning that their memory would not really be shared - resulting
43017 ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
43018 ** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
43022 ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
43025 ** When opening a new shared-memory file, if no other instances of that
43029 ** If the original database file (pDbFd) is using the "unix-excl" VFS
43047 assert( pDbFd->pShm==0 );
43054 pInode = pDbFd->pInode;
43055 pShmNode = pInode->pShmNode;
43059 const char *zBasePath = pDbFd->zPath;
43063 ** a new *-shm file is created, an attempt will be made to create it
43066 if( osFstat(pDbFd->h, &sStat) ){
43082 zShm = pShmNode->zFilename = (char*)&pShmNode[1];
43085 SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
43088 sqlite3_snprintf(nShmFilename, zShm, "%s-shm", zBasePath);
43089 sqlite3FileSuffix3(pDbFd->zPath, zShm);
43091 pShmNode->hShm = -1;
43092 pDbFd->pInode->pShmNode = pShmNode;
43093 pShmNode->pInode = pDbFd->pInode;
43095 pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
43096 if( pShmNode->pShmMutex==0 ){
43104 pShmNode->aMutex[ii] = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
43105 if( pShmNode->aMutex[ii]==0 ){
43114 if( pInode->bProcessLock==0 ){
43115 if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
43116 pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW,
43119 if( pShmNode->hShm<0 ){
43120 pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW,
43122 if( pShmNode->hShm<0 ){
43126 pShmNode->isReadonly = 1;
43133 robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid);
43141 p->pShmNode = pShmNode;
43143 p->id = pShmNode->nextShmId++;
43145 pShmNode->nRef++;
43146 pDbFd->pShm = p;
43153 ** at pShmNode->pFirst. This must be done while holding the
43154 ** pShmNode->pShmMutex.
43156 sqlite3_mutex_enter(pShmNode->pShmMutex);
43157 p->pNext = pShmNode->pFirst;
43158 pShmNode->pFirst = p;
43159 sqlite3_mutex_leave(pShmNode->pShmMutex);
43172 ** shared-memory associated with the database file fd. Shared-memory regions
43173 ** are numbered starting from zero. Each shared-memory region is szRegion
43178 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
43181 ** bExtend is non-zero and the requested shared-memory region has not yet
43184 ** If the shared-memory region has already been allocated or is allocated by
43203 /* If the shared-memory file has not yet been opened, open it now. */
43204 if( pDbFd->pShm==0 ){
43209 p = pDbFd->pShm;
43210 pShmNode = p->pShmNode;
43211 sqlite3_mutex_enter(pShmNode->pShmMutex);
43212 if( pShmNode->isUnlocked ){
43215 pShmNode->isUnlocked = 0;
43217 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
43218 assert( pShmNode->pInode==pDbFd->pInode );
43219 assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
43220 assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
43225 if( pShmNode->nRegion<nReqRegion ){
43230 pShmNode->szRegion = szRegion;
43232 if( pShmNode->hShm>=0 ){
43234 ** Check to see if it has been allocated (i.e. if the wal-index file is
43237 if( osFstat(pShmNode->hShm, &sStat) ){
43265 if( seekAndWriteFd(pShmNode->hShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){
43266 const char *zFile = pShmNode->zFilename;
43277 pShmNode->apRegion, nReqRegion*sizeof(char *)
43283 pShmNode->apRegion = apNew;
43284 while( pShmNode->nRegion<nReqRegion ){
43288 if( pShmNode->hShm>=0 ){
43290 pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
43291 MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion
43294 rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
43307 pShmNode->apRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i];
43309 pShmNode->nRegion += nShmPerMap;
43314 if( pShmNode->nRegion>iRegion ){
43315 *pp = pShmNode->apRegion[iRegion];
43319 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
43320 sqlite3_mutex_leave(pShmNode->pShmMutex);
43325 ** Check that the pShmNode->aLock[] array comports with the locking bitmasks
43340 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
43343 if( pX->exclMask & (1<<i) ){
43345 aLock[i] = -1;
43346 }else if( pX->sharedMask & (1<<i) ){
43353 assert( 0==memcmp(pShmNode->aLock, aLock, sizeof(aLock)) );
43354 return (memcmp(pShmNode->aLock, aLock, sizeof(aLock))==0);
43360 ** Change the lock state for a shared-memory segment.
43377 u16 mask = (1<<(ofst+n)) - (1<<ofst); /* Mask of locks to take or release */
43380 p = pDbFd->pShm;
43382 pShmNode = p->pShmNode;
43384 aLock = pShmNode->aLock;
43386 assert( pShmNode==pDbFd->pInode->pShmNode );
43387 assert( pShmNode->pInode==pDbFd->pInode );
43395 assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
43396 assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
43413 u16 lockMask = (p->exclMask|p->sharedMask);
43414 assert( (flags & SQLITE_SHM_UNLOCK) || pDbFd->iBusyTimeout==0 || (
43433 || 0==(p->exclMask & mask)
43435 if( ((flags & SQLITE_SHM_UNLOCK) && ((p->exclMask|p->sharedMask) & mask))
43436 || (flags==(SQLITE_SHM_SHARED|SQLITE_SHM_LOCK) && 0==(p->sharedMask & mask))
43449 ** case thread 2 does a non-blocking request for the WRITER lock. But -
43453 ** a lock on a read-locking slot at this point, this breaks the
43454 ** anti-deadlock rules (see above). */
43459 rc = sqlite3_mutex_try(pShmNode->aMutex[iMutex]);
43462 sqlite3_mutex_enter(pShmNode->aMutex[iMutex]);
43466 sqlite3_mutex_enter(pShmNode->pShmMutex);
43471 /* Case (a) - unlock. */
43473 assert( (p->exclMask & p->sharedMask)==0 );
43474 assert( !(flags & SQLITE_SHM_EXCLUSIVE) || (p->exclMask & mask)==mask );
43475 assert( !(flags & SQLITE_SHM_SHARED) || (p->sharedMask & mask)==mask );
43480 ** from the file-descriptor below. */
43486 aLock[ofst]--;
43487 p->sharedMask &= ~mask;
43495 p->sharedMask &= ~mask;
43496 p->exclMask &= ~mask;
43500 /* Case (b) - a shared lock. */
43511 p->sharedMask |= mask;
43515 /* Case (c) - an exclusive lock. */
43519 assert( (p->sharedMask & mask)==0 );
43520 assert( (p->exclMask & mask)==0 );
43532 ** also update the in-memory values. */
43536 p->exclMask |= mask;
43538 aLock[ii] = -1;
43549 for(iMutex--; iMutex>=ofst; iMutex--){
43550 sqlite3_mutex_leave(pShmNode->aMutex[iMutex]);
43553 sqlite3_mutex_leave(pShmNode->pShmMutex);
43557 OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
43558 p->id, osGetpid(0), p->sharedMask, p->exclMask));
43572 sqlite3MemoryBarrier(); /* compiler-defined memory barrier */
43573 assert( fd->pMethods->xLock==nolockLock
43581 ** Close a connection to shared-memory. Delete the underlying
43585 ** routine is a harmless no-op.
43589 int deleteFlag /* Delete shared-memory if true */
43592 unixShmNode *pShmNode; /* The underlying shared-memory file */
43597 p = pDbFd->pShm;
43599 pShmNode = p->pShmNode;
43601 assert( pShmNode==pDbFd->pInode->pShmNode );
43602 assert( pShmNode->pInode==pDbFd->pInode );
43606 sqlite3_mutex_enter(pShmNode->pShmMutex);
43607 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
43608 *pp = p->pNext;
43612 pDbFd->pShm = 0;
43613 sqlite3_mutex_leave(pShmNode->pShmMutex);
43615 /* If pShmNode->nRef has reached 0, then close the underlying
43616 ** shared-memory file, too */
43619 assert( pShmNode->nRef>0 );
43620 pShmNode->nRef--;
43621 if( pShmNode->nRef==0 ){
43622 if( deleteFlag && pShmNode->hShm>=0 ){
43623 osUnlink(pShmNode->zFilename);
43645 assert( pFd->nFetchOut==0 );
43646 if( pFd->pMapRegion ){
43647 osMunmap(pFd->pMapRegion, pFd->mmapSizeActual);
43648 pFd->pMapRegion = 0;
43649 pFd->mmapSize = 0;
43650 pFd->mmapSizeActual = 0;
43674 int h = pFd->h; /* File descriptor open on db file */
43675 u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */
43676 i64 nOrig = pFd->mmapSizeActual; /* Size of pOrig region in bytes */
43680 assert( pFd->nFetchOut==0 );
43681 assert( nNew>pFd->mmapSize );
43682 assert( nNew<=pFd->mmapSizeMax );
43684 assert( pFd->mmapSizeActual>=pFd->mmapSize );
43688 if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;
43693 i64 nReuse = pFd->mmapSize;
43696 i64 nReuse = (pFd->mmapSize & ~(szSyspage-1));
43702 osMunmap(pReq, nOrig-nReuse);
43709 pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
43712 osMunmap(pNew, nNew - nReuse);
43734 unixLogError(SQLITE_OK, zErr, pFd->zPath);
43739 pFd->mmapSizeMax = 0;
43741 pFd->pMapRegion = (void *)pNew;
43742 pFd->mmapSize = pFd->mmapSizeActual = nNew;
43746 ** Memory map or remap the file opened by file-descriptor pFd (if the file
43749 ** outstanding xFetch() references to it, this function is a no-op.
43751 ** If parameter nByte is non-negative, then it is the requested size of
43762 assert( nMap>=0 || pFd->nFetchOut==0 );
43763 assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
43764 if( pFd->nFetchOut>0 ) return SQLITE_OK;
43767 struct stat statbuf; /* Low-level file information */
43768 if( osFstat(pFd->h, &statbuf) ){
43773 if( nMap>pFd->mmapSizeMax ){
43774 nMap = pFd->mmapSizeMax;
43777 assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
43778 if( nMap!=pFd->mmapSize ){
43805 if( pFd->mmapSizeMax>0 ){
43811 if( pFd->pMapRegion==0 ){
43812 int rc = unixMapfile(pFd, -1);
43815 if( pFd->mmapSize >= (iOff+nAmt+nEofBuffer) ){
43816 *pp = &((u8 *)pFd->pMapRegion)[iOff];
43817 pFd->nFetchOut++;
43825 ** If the third argument is non-NULL, then this function releases a
43842 assert( (p==0)==(pFd->nFetchOut==0) );
43845 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
43848 pFd->nFetchOut--;
43853 assert( pFd->nFetchOut>=0 );
43871 ** of "finder" functions. A finder-function is used to locate the appropriate
43874 ** the correct finder-function for that VFS.
43877 ** object. The only interesting finder-function is autolockIoFinder, which
43881 ** For finder-function F, two objects are created:
43883 ** (1) The real finder-function named "FImpt()".
43890 ** directly at the finder-function since C90 rules prevent a void*
44007 ** The proxy locking method is a "super-method" in the sense that it
44009 ** it uses proxy, dot-file, AFP, and flock() locking methods on those
44078 if( statfs(filePath, &fsInfo) != -1 ){
44090 ** Test byte-range lock using fcntl(). If the call succeeds,
44091 ** assume that the file-system supports POSIX style locks.
44097 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44137 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
44175 assert( pNew->pInode==NULL );
44180 OSTRACE(("OPEN %-3d %s\n", h, zFilename));
44181 pNew->h = h;
44182 pNew->pVfs = pVfs;
44183 pNew->zPath = zFilename;
44184 pNew->ctrlFlags = (u8)ctrlFlags;
44186 pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
44190 pNew->ctrlFlags |= UNIXFILE_PSOW;
44192 if( strcmp(pVfs->zName,"unix-excl")==0 ){
44193 pNew->ctrlFlags |= UNIXFILE_EXCL;
44197 pNew->pId = vxworksFindFileId(zFilename);
44198 if( pNew->pId==0 ){
44207 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
44212 pNew->lockingContext = (void*)zFilename;
44222 rc = findInodeInfo(pNew, &pNew->pInode);
44235 ** handle h - as it is guaranteed that no posix locks will be released
44243 h = -1;
44254 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
44261 pCtx->dbPath = zFilename;
44262 pCtx->reserved = 0;
44265 rc = findInodeInfo(pNew, &pNew->pInode);
44267 sqlite3_free(pNew->lockingContext);
44269 h = -1;
44290 pNew->lockingContext = zLockFile;
44299 rc = findInodeInfo(pNew, &pNew->pInode);
44300 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
44301 char *zSemName = pNew->pInode->aSemName;
44304 pNew->pId->zCanonicalName);
44307 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
44308 if( pNew->pInode->pSem == SEM_FAILED ){
44310 pNew->pInode->aSemName[0] = '\0';
44321 h = -1;
44323 pNew->ctrlFlags |= UNIXFILE_DELETE;
44329 pId->pMethods = pLockingStyle;
44382 ** pVfs->mxPathname bytes.
44389 /* It's odd to simulate an io-error here, but really this is just
44390 ** using the io-error infrastructure to test that SQLite handles this
44405 zBuf[nBuf-2] = 0;
44408 if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ){
44420 ** Routine to transform a unixFile into a proxy-locking unixFile.
44421 ** Implementation in the proxy-lock division, but used by unixOpen()
44429 ** file (not a journal or super-journal file) identified by pathname
44435 ** other file descriptor open on the same file is holding a file-lock.
44441 ** such file descriptor is located, -1 is returned.
44459 ** ignored and -1 is returned. The caller will try to open a new file
44468 while( pInode && (pInode->fileId.dev!=sStat.st_dev
44469 || pInode->fileId.ino!=(u64)sStat.st_ino) ){
44470 pInode = pInode->pNext;
44474 assert( sqlite3_mutex_notheld(pInode->pLockMutex) );
44475 sqlite3_mutex_enter(pInode->pLockMutex);
44477 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
44480 *pp = pUnused->pNext;
44482 sqlite3_mutex_leave(pInode->pLockMutex);
44522 ** this function queries the file-system for the permissions on the
44551 ** "<path to db>-journal"
44552 ** "<path to db>-wal"
44553 ** "<path to db>-journalNN"
44554 ** "<path to db>-walNN"
44560 ** a '-' character. However in 8+3 filename mode, or if a corrupt
44561 ** rollback journal specifies a super-journal with a goofy name, then
44562 ** the '-' might be missing or the '-' might be the first character in
44565 nDb = sqlite3Strlen30(zPath) - 1;
44567 if( zPath[nDb]=='-' ){
44573 nDb--;
44602 ** ReadWrite() -> (READWRITE | CREATE)
44603 ** ReadOnly() -> (READONLY)
44604 ** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
44606 ** The old OpenExclusive() accepted a boolean argument - "delFlag". If
44620 int fd = -1; /* File descriptor returned by open() */
44639 /* If creating a super- or main-file journal, this function will open
44640 ** a file-descriptor on the directory too. The first time unixSync()
44667 /* The main DB, main journal, WAL file and super-journal are never
44674 /* Assert that the upper layer has set one of the "file-type" flags. */
44701 fd = pUnused->fd;
44708 p->pPreallocatedUnused = pUnused;
44710 /* Database filenames are double-zero terminated if they are not
44718 rc = unixGetTempname(pVfs->mxPathname, zTmpname);
44724 /* Generated temporary filenames are always double-zero terminated
44745 assert( !p->pPreallocatedUnused );
44750 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
44758 /* Failed to open the file for read/write access. Try read-only. */
44767 fd = pReadonly->fd;
44782 ** the case. The chown() system call will be a no-op if the current
44801 if( p->pPreallocatedUnused ){
44802 p->pPreallocatedUnused->fd = fd;
44803 p->pPreallocatedUnused->flags =
44822 p->openFlags = openFlags;
44827 if( fstatfs(fd, &fsInfo) == -1 ){
44833 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44836 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44852 if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
44857 ** never use proxy, NULL means use proxy for non-local files only. */
44870 ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
44888 sqlite3_free(p->pPreallocatedUnused);
44906 if( osUnlink(zPath)==(-1) ){
44975 int rc; /* Non-zero following any error */
44990 const char *zName, /* Name to append to pPath. Not zero-terminated */
44998 if( pPath->nUsed>1 ){
44999 assert( pPath->zOut[0]=='/' );
45000 while( pPath->zOut[--pPath->nUsed]!='/' ){}
45005 if( pPath->nUsed + nName + 2 >= pPath->nOut ){
45006 pPath->rc = SQLITE_ERROR;
45009 pPath->zOut[pPath->nUsed++] = '/';
45010 memcpy(&pPath->zOut[pPath->nUsed], zName, nName);
45011 pPath->nUsed += nName;
45013 if( pPath->rc==SQLITE_OK ){
45016 pPath->zOut[pPath->nUsed] = 0;
45017 zIn = pPath->zOut;
45020 pPath->rc = unixLogError(SQLITE_CANTOPEN_BKPT, "lstat", zIn);
45025 if( pPath->nSymlink++ > SQLITE_MAX_SYMLINK ){
45026 pPath->rc = SQLITE_CANTOPEN_BKPT;
45029 got = osReadlink(zIn, zLnk, sizeof(zLnk)-2);
45030 if( got<=0 || got>=(ssize_t)sizeof(zLnk)-2 ){
45031 pPath->rc = unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zIn);
45036 pPath->nUsed = 0;
45038 pPath->nUsed -= nName + 1;
45051 const char *zPath /* Path to append to pPath. Is zero-terminated */
45058 appendOnePathElement(pPath, &zPath[j], i-j);
45066 ** is stored as a nul-terminated string in the buffer pointed to by
45070 ** (in this case, MAX_PATHNAME bytes). The full-path is written to
45088 if( osGetcwd(zPwd, sizeof(zPwd)-2)==0 ){
45130 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
45133 ** use dlsym() with -pedantic-errors?
45141 ** This work-around is unlikely to work correctly on any system where
45170 ** errors. The reports issued by valgrind are incorrect - we would
45172 ** uninitialized space in zBuf - but valgrind errors tend to worry
45220 ** -DHAVE_NANOSLEEP=0 (perhaps in conjuction with -DHAVE_USLEEP if
45240 ** The following variable, if set to a non-zero value, is interpreted as
45304 ** low-level error message when operating-system problems come up
45323 ** Proxy locking is a "uber-locking-method" in this sense: It uses the
45325 ** meta-layer over top of the primitive locking implemented above. For
45328 ** been defined - so that the primitive locking methods are available
45333 ** The default locking schemes in SQLite use byte-range locks on the
45338 ** on AFP and SMB only exclusive byte-range locks are available via fsctl
45346 ** SHARED_RANGE 0x40000002 -> 0x40000200
45348 ** This works well on the local file system, but shows a nearly 100x
45350 ** the read cache when byte-range locks are present. Enabling the read
45353 ** close-to-open semantics for ensuring cache coherency
45357 ** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html].
45366 ** -----------------
45398 ** -----------------------
45408 ** The conch file - to use a proxy file, sqlite must first "hold the conch"
45409 ** by taking an sqlite-style shared lock on the conch file, reading the
45413 ** is patterned after the database file name as ".<databasename>-conch".
45421 ** The proxy file - a single-byte file used for all advisory file locks
45437 ** ---------------------
45441 ** Database files accessed on non-local file systems are
45486 int conchHeld; /* 1 if the conch is held, -1 if lockless */
45519 if( lPath[len-1]!='/' ){
45548 if( lockPath[i] == '/' && (i - start > 0) ){
45550 if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/')
45551 || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
45583 int fd = -1;
45592 ** 2. if that fails, and this is a lock file (not-conch), try creating
45594 ** 3. if that fails, try to open the file read-only
45599 fd = pUnused->fd;
45640 pNew->openFlags = openFlags;
45644 pUnused->fd = fd;
45645 pUnused->flags = openFlags;
45646 pNew->pPreallocatedUnused = pUnused;
45704 #define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */
45716 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45717 unixFile *conchFile = pCtx->conchFile;
45720 char *cPath = pCtx->conchFilePath;
45724 int fd = -1;
45725 int rc = -1;
45728 /* create a new path by replace the trailing '-conch' with '-break' */
45731 (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){
45736 readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
45757 robust_close(pFile, conchFile->h, __LINE__);
45758 conchFile->h = fd;
45759 conchFile->openFlags = O_RDWR | O_CREAT;
45776 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45777 unixFile *conchFile = pCtx->conchFile;
45784 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
45794 if( osFstat(conchFile->h, &buf) ){
45813 int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
45835 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
45838 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
45848 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
45854 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45856 if( pCtx->conchHeld!=0 ){
45859 unixFile *conchFile = pCtx->conchFile;
45872 OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h,
45873 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
45889 storeLastErrno(pFile, conchFile->lastErrno);
45901 ** retry with a new auto-generated path
45909 if( !pCtx->lockProxyPath ){
45910 /* for auto-named local lock file, just check the host ID and we'll
45914 size_t pathLen = (readLen - PROXY_PATHINDEX);
45917 pathLen=MAXPATHLEN-1;
45927 && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
45928 readLen-PROXY_PATHINDEX)
45936 if( (conchFile->openFlags&O_RDWR) == 0 ){
45942 if( !pCtx->lockProxyPath ){
45943 proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
45952 futimes(conchFile->h, NULL);
45954 if( conchFile->pInode && conchFile->pInode->nShared>1 ){
45970 if( pCtx->lockProxyPath!=NULL ){
45971 strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
45977 robust_ftruncate(conchFile->h, writeSize);
45979 full_fsync(conchFile->h,0,0);
45985 int err = osFstat(pFile->h, &buf);
45991 osFchmod(conchFile->h, cmode);
45994 rc = osFchmod(conchFile->h, cmode);
45995 }while( rc==(-1) && errno==EINTR );
46011 conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK);
46014 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
46015 if( rc==SQLITE_OK && pFile->openFlags ){
46017 if( pFile->h>=0 ){
46018 robust_close(pFile, pFile->h, __LINE__);
46020 pFile->h = -1;
46021 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
46024 pFile->h = fd;
46030 if( rc==SQLITE_OK && !pCtx->lockProxy ){
46031 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
46032 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
46035 ** so try again via auto-naming
46047 pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
46048 if( !pCtx->lockProxyPath ){
46054 pCtx->conchHeld = 1;
46056 if( pCtx->lockProxy->pMethod == &afpIoMethods ){
46058 afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
46059 afpCtx->dbPath = pCtx->lockProxyPath;
46062 conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
46064 OSTRACE(("TAKECONCH %d %s\n", conchFile->h,
46067 } while (1); /* in case we need to retry the :auto: lock file -
46080 pCtx = (proxyLockingContext *)pFile->lockingContext;
46081 conchFile = pCtx->conchFile;
46082 OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h,
46083 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
46085 if( pCtx->conchHeld>0 ){
46086 rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
46088 pCtx->conchHeld = 0;
46089 OSTRACE(("RELEASECONCH %d %s\n", conchFile->h,
46107 int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
46119 for( i=(len-1); i>=0; i-- ){
46131 /* append the "-conch" suffix to the file */
46132 memcpy(&conchPath[i+1], "-conch", 7);
46139 /* Takes a fully configured proxy locking-style unix file and switches
46143 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46144 char *oldPath = pCtx->lockProxyPath;
46147 if( pFile->eFileLock!=NO_LOCK ){
46156 unixFile *lockProxy = pCtx->lockProxy;
46157 pCtx->lockProxy=NULL;
46158 pCtx->conchHeld = 0;
46160 rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy);
46165 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
46180 if( pFile->pMethod == &afpIoMethods ){
46183 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
46184 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
46188 if( pFile->pMethod == &dotlockIoMethods ){
46191 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
46192 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
46195 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
46196 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
46206 ** ->lockingContext
46207 ** ->pMethod
46215 if( pFile->eFileLock!=NO_LOCK ){
46225 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
46234 rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
46236 rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
46237 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
46239 ** (c) the file system is read-only, then enable no-locking access.
46247 if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
46249 if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){
46254 pCtx->conchHeld = -1; /* read only FS/ lockless */
46260 pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
46264 pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
46265 if( pCtx->dbPath==NULL ){
46273 pCtx->oldLockingContext = pFile->lockingContext;
46274 pFile->lockingContext = pCtx;
46275 pCtx->pOldMethod = pFile->pMethod;
46276 pFile->pMethod = &proxyIoMethods;
46278 if( pCtx->conchFile ){
46279 pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
46280 sqlite3_free(pCtx->conchFile);
46282 sqlite3DbFree(0, pCtx->lockProxyPath);
46283 sqlite3_free(pCtx->conchFilePath);
46286 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
46300 if( pFile->pMethod == &proxyIoMethods ){
46301 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46303 if( pCtx->lockProxyPath ){
46304 *(const char **)pArg = pCtx->lockProxyPath;
46316 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
46319 /* turn off proxy locking - not supported. If support is added for
46325 /* turn off proxy locking - already off - NOOP */
46332 (proxyLockingContext*)pFile->lockingContext;
46334 || (pCtx->lockProxyPath &&
46335 !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
46358 ** above this point are all utilities. The lock-related methods of the
46359 ** proxy-locking sqlite3_io_method object follow.
46366 ** to a non-zero value otherwise *pResOut is set to zero. The return value
46373 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46374 if( pCtx->conchHeld>0 ){
46375 unixFile *proxy = pCtx->lockProxy;
46376 return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut);
46385 ** Lock the file with the lock specified by parameter eFileLock - one
46399 ** UNLOCKED -> SHARED
46400 ** SHARED -> RESERVED
46401 ** SHARED -> (PENDING) -> EXCLUSIVE
46402 ** RESERVED -> (PENDING) -> EXCLUSIVE
46403 ** PENDING -> EXCLUSIVE
46412 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46413 if( pCtx->conchHeld>0 ){
46414 unixFile *proxy = pCtx->lockProxy;
46415 rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock);
46416 pFile->eFileLock = proxy->eFileLock;
46430 ** the requested locking level, this routine is a no-op.
46436 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46437 if( pCtx->conchHeld>0 ){
46438 unixFile *proxy = pCtx->lockProxy;
46439 rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock);
46440 pFile->eFileLock = proxy->eFileLock;
46454 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46455 unixFile *lockProxy = pCtx->lockProxy;
46456 unixFile *conchFile = pCtx->conchFile;
46460 rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK);
46462 rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy);
46465 pCtx->lockProxy = 0;
46468 if( pCtx->conchHeld ){
46472 rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile);
46476 sqlite3DbFree(0, pCtx->lockProxyPath);
46477 sqlite3_free(pCtx->conchFilePath);
46478 sqlite3DbFree(0, pCtx->dbPath);
46480 pFile->lockingContext = pCtx->oldLockingContext;
46481 pFile->pMethod = pCtx->pOldMethod;
46483 return pFile->pMethod->xClose(id);
46503 ** This routine registers all VFS implementations for unix-like operating
46520 ** when compiling with -pedantic-errors on GCC.)
46523 ** finder-function. The finder-function returns a pointer to the
46526 ** macro for addition information on finder-functions.
46574 UNIXVFS("unix-none", nolockIoFinder ),
46575 UNIXVFS("unix-dotfile", dotlockIoFinder ),
46576 UNIXVFS("unix-excl", posixIoFinder ),
46578 UNIXVFS("unix-namedsem", semIoFinder ),
46581 UNIXVFS("unix-posix", posixIoFinder ),
46584 UNIXVFS("unix-flock", flockIoFinder ),
46587 UNIXVFS("unix-afp", afpIoFinder ),
46588 UNIXVFS("unix-nfs", nfsIoFinder ),
46589 UNIXVFS("unix-proxy", proxyIoFinder ),
46594 /* Double-check that the aSyscall[] array has been constructed
46620 ** READ-0 UNIX_SHM_BASE+3 123
46621 ** READ-1 UNIX_SHM_BASE+4 124
46622 ** READ-2 UNIX_SHM_BASE+5 125
46623 ** READ-3 UNIX_SHM_BASE+6 126
46624 ** READ-4 UNIX_SHM_BASE+7 127
46627 assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
46641 ** This routine is a no-op for unix.
46695 ** based on the sub-platform)?
46703 ** based on the sub-platform)?
46791 ** characters, so we allocate 4 bytes per character assuming worst-case of
46792 ** 4-bytes-per-character for UTF8.
46815 ** Returns non-zero if the character should be treated as a directory
46879 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
46892 typedef struct winShm winShm; /* A connection to shared-memory */
46893 typedef struct winShmNode winShmNode; /* A region of shared-memory */
46951 BOOL bNoLock; /* Non-zero if locking is disabled. */
46965 # define SQLITE_WIN32_DBG_BUF_SIZE ((int)(4096-sizeof(DWORD)))
46975 * If this is non-zero, an isolated heap will be created by the native Win32
46981 * WARNING: It is important to note that when this setting is non-zero and the
46993 * This is the maximum possible initial size of the Win32-specific heap, in
47001 * This is the extra space for the initial size of the Win32-specific heap,
47014 # define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \
47021 * Win32-specific heap. It cannot be negative.
47027 # define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE))
47033 * initial size of the Win32-specific heap to exceed the maximum amount
47042 * The initial size of the Win32-specific heap. This value may be zero.
47051 * The maximum size of the Win32-specific heap. This value may be zero.
47067 ** The winMemData structure stores information required by the Win32-specific
47151 ** Many system calls are accessed through pointer-to-functions so that
47768 ** NOTE: On some sub-platforms, the InterlockedCompareExchange "function"
47880 int i = -1;
47884 for(i=0; i<ArraySize(aSyscall)-1; i++){
47899 ** "pnLargest" argument, if non-zero, will be used to return the size of the
47989 int nMin = MIN(nBuf, (SQLITE_WIN32_DBG_BUF_SIZE - 1)); /* may be negative. */
47990 if( nMin<-1 ) nMin = -1; /* all negative values become -1. */
47991 assert( nMin==-1 || nMin==0 || nMin<SQLITE_WIN32_DBG_BUF_SIZE );
48057 ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
48085 ** NOTE: The WinRT sub-platform is always assumed to be based on the NT
48110 ** NOTE: All sub-platforms where the GetVersionEx[AW] functions are
48205 if( n==(SIZE_T)-1 ){
48227 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
48228 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
48231 if( !pWinMemData->hHeap ){
48239 pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS,
48241 if( !pWinMemData->hHeap ){
48248 pWinMemData->bOwned = TRUE;
48249 assert( pWinMemData->bOwned );
48252 pWinMemData->hHeap = osGetProcessHeap();
48253 if( !pWinMemData->hHeap ){
48258 pWinMemData->bOwned = FALSE;
48259 assert( !pWinMemData->bOwned );
48261 assert( pWinMemData->hHeap!=0 );
48262 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
48264 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
48276 assert( pWinMemData->magic1==WINMEM_MAGIC1 );
48277 assert( pWinMemData->magic2==WINMEM_MAGIC2 );
48279 if( pWinMemData->hHeap ){
48280 assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
48282 assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
48284 if( pWinMemData->bOwned ){
48285 if( !osHeapDestroy(pWinMemData->hHeap) ){
48287 osGetLastError(), (void*)pWinMemData->hHeap);
48289 pWinMemData->bOwned = FALSE;
48291 pWinMemData->hHeap = NULL;
48296 ** Populate the low-level memory allocation function pointers in
48323 ** Convert a UTF-8 string to Microsoft Unicode.
48331 nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0);
48339 nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, zWideText,
48349 ** Convert a Microsoft Unicode string to UTF-8.
48357 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, 0, 0, 0, 0);
48365 nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, zText, nByte,
48385 nByte = osMultiByteToWideChar(codepage, 0, zText, -1, NULL,
48394 nByte = osMultiByteToWideChar(codepage, 0, zText, -1, zMbcsText,
48404 ** Convert a Microsoft Unicode string to a multi-byte character string,
48414 nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, 0, 0, 0, 0);
48422 nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, zText,
48432 ** Convert a multi-byte character string to UTF-8.
48450 ** Convert a UTF-8 string to a multi-byte character string.
48565 ** it accepts a UTF-8 string.
48609 ** it accepts a UTF-16 string.
48642 ** is zero if the error message fits in the buffer, or non-zero
48722 ** This function - winLogErrorAtLine() - is only ever called via the macro
48727 ** error code and, if possible, the human-readable equivalent from
48733 ** failed and the associated file-system path, if any.
48753 "os_win.c:%d: (%lu) %s(%s) - %s",
48762 ** will be retried following a locking error - probably caused by
48779 ** non-zero if the error code is transient in nature and the operation
48867 y.tm_year = pTm.wYear - 1900;
48868 y.tm_mon = pTm.wMonth - 1;
48882 #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
48916 memset(&pFile->local, 0, sizeof(pFile->local));
48926 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
48927 if (!pFile->hMutex){
48928 pFile->lastErrno = osGetLastError();
48930 return winLogError(SQLITE_IOERR, pFile->lastErrno,
48935 winceMutexAcquire(pFile->hMutex);
48938 ** case-sensitive, take advantage of that by uppercasing the mutex name
48942 pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
48947 ** must be zero-initialized */
48956 if( pFile->hShared ){
48957 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
48960 if( !pFile->shared ){
48961 pFile->lastErrno = osGetLastError();
48962 winLogError(SQLITE_IOERR, pFile->lastErrno,
48965 osCloseHandle(pFile->hShared);
48966 pFile->hShared = NULL;
48971 if( pFile->hShared==NULL ){
48973 pFile->lastErrno = lastErrno;
48974 winLogError(SQLITE_IOERR, pFile->lastErrno,
48978 winceMutexRelease(pFile->hMutex);
48979 osCloseHandle(pFile->hMutex);
48980 pFile->hMutex = NULL;
48986 memset(pFile->shared, 0, sizeof(winceLock));
48989 winceMutexRelease(pFile->hMutex);
48997 if (pFile->hMutex){
48999 winceMutexAcquire(pFile->hMutex);
49003 if (pFile->local.nReaders){
49004 pFile->shared->nReaders --;
49006 if (pFile->local.bReserved){
49007 pFile->shared->bReserved = FALSE;
49009 if (pFile->local.bPending){
49010 pFile->shared->bPending = FALSE;
49012 if (pFile->local.bExclusive){
49013 pFile->shared->bExclusive = FALSE;
49016 /* De-reference and close our copy of the shared memory handle */
49017 osUnmapViewOfFile(pFile->shared);
49018 osCloseHandle(pFile->hShared);
49021 winceMutexRelease(pFile->hMutex);
49022 osCloseHandle(pFile->hMutex);
49023 pFile->hMutex = NULL;
49043 if (!pFile->hMutex) return TRUE;
49044 winceMutexAcquire(pFile->hMutex);
49049 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
49050 pFile->shared->bExclusive = TRUE;
49051 pFile->local.bExclusive = TRUE;
49056 /* Want a read-only lock? */
49059 if (pFile->shared->bExclusive == 0){
49060 pFile->local.nReaders ++;
49061 if (pFile->local.nReaders == 1){
49062 pFile->shared->nReaders ++;
49072 if (pFile->shared->bPending == 0) {
49073 pFile->shared->bPending = TRUE;
49074 pFile->local.bPending = TRUE;
49082 if (pFile->shared->bReserved == 0) {
49083 pFile->shared->bReserved = TRUE;
49084 pFile->local.bReserved = TRUE;
49089 winceMutexRelease(pFile->hMutex);
49109 if (!pFile->hMutex) return TRUE;
49110 winceMutexAcquire(pFile->hMutex);
49115 if (pFile->local.bExclusive){
49117 pFile->local.bExclusive = FALSE;
49118 pFile->shared->bExclusive = FALSE;
49123 else if (pFile->local.nReaders){
49126 pFile->local.nReaders --;
49127 if (pFile->local.nReaders == 0)
49129 pFile->shared->nReaders --;
49138 if (pFile->local.bPending){
49139 pFile->local.bPending = FALSE;
49140 pFile->shared->bPending = FALSE;
49147 if (pFile->local.bReserved) {
49148 pFile->local.bReserved = FALSE;
49149 pFile->shared->bReserved = FALSE;
49154 winceMutexRelease(pFile->hMutex);
49234 # define INVALID_SET_FILE_POINTER ((DWORD)-1)
49240 ** Otherwise, set pFile->lastErrno and return non-zero.
49249 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
49255 ** containing the lower 32-bits of the new file-offset. Or, if it fails,
49261 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
49265 pFile->lastErrno = lastErrno;
49266 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
49267 "winSeekFile", pFile->zPath);
49268 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49272 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49283 bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN);
49286 pFile->lastErrno = osGetLastError();
49287 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
49288 "winSeekFile", pFile->zPath);
49289 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49293 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49310 ** the close fails, we pause for 100 milliseconds and try again. As
49321 assert( pFile->pShm==0 );
49323 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
49325 osGetCurrentProcessId(), pFile, pFile->h));
49332 rc = osCloseHandle(pFile->h);
49334 }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (sqlite3_win32_sleep(100), 1) );
49338 winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData;
49339 if( pAppData==NULL || !pAppData->bNoLock ){
49343 if( pFile->zDeleteOnClose ){
49346 osDeleteFileW(pFile->zDeleteOnClose)==0
49347 && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
49350 sqlite3_win32_sleep(100); /* Wait a little before trying again */
49352 sqlite3_free(pFile->zDeleteOnClose);
49356 pFile->h = NULL;
49358 OpenCounter(-1);
49360 osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
49363 "winClose", pFile->zPath);
49390 pFile->h, pBuf, amt, offset, pFile->locktype));
49395 if( offset<pFile->mmapSize ){
49396 if( offset+amt <= pFile->mmapSize ){
49397 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
49398 OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49399 osGetCurrentProcessId(), pFile, pFile->h));
49402 int nCopy = (int)(pFile->mmapSize - offset);
49403 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
49405 amt -= nCopy;
49414 osGetCurrentProcessId(), pFile, pFile->h));
49417 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
49422 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
49427 pFile->lastErrno = lastErrno;
49429 osGetCurrentProcessId(), pFile, pFile->h));
49430 return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
49431 "winRead", pFile->zPath);
49435 /* Unread parts of the buffer must be zero-filled */
49436 memset(&((char*)pBuf)[nRead], 0, amt-nRead);
49438 osGetCurrentProcessId(), pFile, pFile->h));
49443 osGetCurrentProcessId(), pFile, pFile->h));
49468 pFile->h, pBuf, amt, offset, pFile->locktype));
49473 if( offset<pFile->mmapSize ){
49474 if( offset+amt <= pFile->mmapSize ){
49475 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
49476 OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49477 osGetCurrentProcessId(), pFile, pFile->h));
49480 int nCopy = (int)(pFile->mmapSize - offset);
49481 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
49483 amt -= nCopy;
49511 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
49513 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){
49529 nRem -= nWrite;
49532 pFile->lastErrno = lastErrno;
49538 if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
49539 || ( pFile->lastErrno==ERROR_DISK_FULL )){
49541 osGetCurrentProcessId(), pFile, pFile->h));
49542 return winLogError(SQLITE_FULL, pFile->lastErrno,
49543 "winWrite1", pFile->zPath);
49546 osGetCurrentProcessId(), pFile, pFile->h));
49547 return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
49548 "winWrite2", pFile->zPath);
49553 osGetCurrentProcessId(), pFile, pFile->h));
49566 if( pFile->nFetchOut>0 ){
49567 /* File truncation is a no-op if there are outstanding memory mapped
49573 ** No real harm comes of this - the database file is not corrupted,
49577 ** The only feasible work-around is to defer the truncation until after
49578 ** all references to memory-mapped content are closed. That is doable,
49581 ** now to simply make transactions a no-op if there are pending reads. We
49591 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
49593 /* If the user has configured a chunk-size for this file, truncate the
49598 if( pFile->szChunk>0 ){
49599 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
49603 if( pFile->pMapRegion ){
49604 oldMmapSize = pFile->mmapSize;
49611 /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
49613 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49614 "winTruncate1", pFile->zPath);
49615 }else if( 0==osSetEndOfFile(pFile->h) &&
49617 pFile->lastErrno = lastErrno;
49618 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49619 "winTruncate2", pFile->zPath);
49625 winMapfile(pFile, -1);
49633 osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
49679 osGetCurrentProcessId(), pFile, pFile->h, flags,
49680 pFile->locktype));
49692 ** no-op
49695 OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
49696 osGetCurrentProcessId(), pFile, pFile->h));
49700 if( pFile->pMapRegion ){
49701 if( osFlushViewOfFile(pFile->pMapRegion, 0) ){
49702 OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
49704 pFile, pFile->pMapRegion));
49706 pFile->lastErrno = osGetLastError();
49707 OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
49709 pFile, pFile->pMapRegion));
49710 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
49711 "winSync1", pFile->zPath);
49715 rc = osFlushFileBuffers(pFile->h);
49719 osGetCurrentProcessId(), pFile, pFile->h));
49722 pFile->lastErrno = osGetLastError();
49724 osGetCurrentProcessId(), pFile, pFile->h));
49725 return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
49726 "winSync2", pFile->zPath);
49741 OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
49746 if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo,
49750 pFile->lastErrno = osGetLastError();
49751 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49752 "winFileSize", pFile->zPath);
49761 lowerBits = osGetFileSize(pFile->h, &upperBits);
49765 pFile->lastErrno = lastErrno;
49766 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49767 "winFileSize", pFile->zPath);
49772 pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
49814 OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49821 res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0);
49823 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0,
49831 pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
49832 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49833 SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49837 pFile->lastErrno = osGetLastError();
49840 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
49850 OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49852 res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
49856 res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49860 pFile->lastErrno = lastErrno;
49861 winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
49862 "winUnlockReadLock", pFile->zPath);
49864 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
49869 ** Lock the file with the lock specified by parameter locktype - one
49883 ** UNLOCKED -> SHARED
49884 ** SHARED -> RESERVED
49885 ** SHARED -> (PENDING) -> EXCLUSIVE
49886 ** RESERVED -> (PENDING) -> EXCLUSIVE
49887 ** PENDING -> EXCLUSIVE
49897 int newLocktype; /* Set pFile->locktype to this value before exiting */
49904 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
49910 if( pFile->locktype>=locktype ){
49911 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
49915 /* Do not allow any kind of write-lock on a read-only database
49917 if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){
49923 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
49925 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
49931 newLocktype = pFile->locktype;
49932 if( pFile->locktype==NO_LOCK
49933 || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK)
49936 while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49939 ** around problems caused by indexing and/or anti-virus software on
49945 OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n",
49946 pFile->h, cnt, res));
49948 pFile->lastErrno = lastErrno;
49950 OSTRACE(("LOCK-FAIL file=%p, count=%d, rc=%s\n",
49951 pFile->h, cnt, sqlite3ErrName(rc)));
49965 assert( pFile->locktype==NO_LOCK );
49977 assert( pFile->locktype==SHARED_LOCK );
49978 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0);
49996 assert( pFile->locktype>=SHARED_LOCK );
49998 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
50012 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50021 pFile->lastErrno = lastErrno;
50023 OSTRACE(("LOCK-FAIL file=%p, wanted=%d, got=%d\n",
50024 pFile->h, locktype, newLocktype));
50026 pFile->locktype = (u8)newLocktype;
50028 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50035 ** non-zero, otherwise zero.
50042 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
50045 if( pFile->locktype>=RESERVED_LOCK ){
50047 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
50049 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0);
50051 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50054 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
50057 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n",
50058 pFile->h, pResOut, *pResOut));
50067 ** the requested locking level, this routine is a no-op.
50080 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
50081 type = pFile->locktype;
50083 winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
50088 "winUnlock", pFile->zPath);
50092 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50098 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50100 pFile->locktype = (u8)locktype;
50102 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50107 ****************************** No-op Locking **********************************
50113 ** This locking mode is appropriate for use on read-only databases
50114 ** (ex: databases that are burned into CD-ROM, for example.) It can
50141 /******************* End of the no-op lock implementation *********************
50146 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
50148 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
50152 *pArg = (pFile->ctrlFlags & mask)!=0;
50154 pFile->ctrlFlags &= ~mask;
50156 pFile->ctrlFlags |= mask;
50171 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
50174 *(int*)pArg = pFile->locktype;
50175 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50179 *(int*)pArg = (int)pFile->lastErrno;
50180 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50184 pFile->szChunk = *(int *)pArg;
50185 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50189 if( pFile->szChunk>0 ){
50200 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50203 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50208 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50213 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50217 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
50218 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50233 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50238 *phFile = pFile->h;
50239 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50245 HANDLE hOldFile = pFile->h;
50246 pFile->h = *phFile;
50249 hOldFile, pFile->h));
50255 int rc = winGetTempname(pFile->pVfs, &zTFile);
50259 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50272 ** least a 64-bit type. */
50277 *(i64*)pArg = pFile->mmapSizeMax;
50278 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
50279 pFile->mmapSizeMax = newLimit;
50280 if( pFile->mmapSize>0 ){
50282 rc = winMapfile(pFile, -1);
50285 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50290 OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
50300 ** if two files are created in the same file-system directory (i.e.
50315 ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
50357 ** log-summary, each thread has its own winFile object, but they all
50359 ** log-summary is opened only once per process.
50367 ** The following fields are read-only after the object is created:
50382 int szRegion; /* Size of shared-memory regions */
50384 u8 isReadonly; /* True if read-only */
50413 ** are read-only thereafter:
50418 ** All other fields are read/write. The winShm.pShmNode->mutex must be held
50445 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
50453 assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );
50455 OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n",
50456 pFile->hFile.h, lockType, ofst, nByte));
50458 /* Release/Acquire the system-level lock */
50460 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
50465 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
50471 pFile->lastErrno = osGetLastError();
50475 OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n",
50476 pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
50477 "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));
50489 ** This is not a VFS shared-memory method; it is a utility function called
50490 ** by VFS shared-memory methods.
50496 OSTRACE(("SHM-PURGE pid=%lu, deleteFlag=%d\n",
50500 if( p->nRef==0 ){
50502 if( p->mutex ){ sqlite3_mutex_free(p->mutex); }
50503 for(i=0; i<p->nRegion; i++){
50504 BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap);
50505 OSTRACE(("SHM-PURGE-UNMAP pid=%lu, region=%d, rc=%s\n",
50508 bRc = osCloseHandle(p->aRegion[i].hMap);
50509 OSTRACE(("SHM-PURGE-CLOSE pid=%lu, region=%d, rc=%s\n",
50513 if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){
50515 winClose((sqlite3_file *)&p->hFile);
50521 winDelete(pVfs, p->zFilename, 0);
50525 *pp = p->pNext;
50526 sqlite3_free(p->aRegion);
50529 pp = &p->pNext;
50541 ** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1.
50547 if( pShmNode->isReadonly ){
50548 pShmNode->isUnlocked = 1;
50551 }else if( winTruncate((sqlite3_file*)&pShmNode->hFile, 0) ){
50554 "winLockSharedMemory", pShmNode->zFilename);
50566 ** Open the shared-memory area associated with database file pDbFd.
50568 ** When opening a new shared-memory file, if no other instances of that
50579 assert( pDbFd->pShm==0 ); /* Not previously opened */
50586 nName = sqlite3Strlen30(pDbFd->zPath);
50592 pNew->zFilename = (char*)&pNew[1];
50593 sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
50594 sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
50600 for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
50604 if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
50614 ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
50615 pShmNode->pNext = winShmNodeList;
50619 pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
50620 if( pShmNode->mutex==0 ){
50626 if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
50631 rc = winOpen(pDbFd->pVfs, pShmNode->zFilename,
50632 (sqlite3_file*)&pShmNode->hFile,
50636 pShmNode->zFilename);
50639 if( outFlags==SQLITE_OPEN_READONLY ) pShmNode->isReadonly = 1;
50646 p->pShmNode = pShmNode;
50648 p->id = pShmNode->nextShmId++;
50650 pShmNode->nRef++;
50651 pDbFd->pShm = p;
50658 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
50661 sqlite3_mutex_enter(pShmNode->mutex);
50662 p->pNext = pShmNode->pFirst;
50663 pShmNode->pFirst = p;
50664 sqlite3_mutex_leave(pShmNode->mutex);
50670 winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */
50678 ** Close a connection to shared-memory. Delete the underlying
50685 winFile *pDbFd; /* Database holding shared-memory */
50687 winShmNode *pShmNode; /* The underlying shared-memory file */
50691 p = pDbFd->pShm;
50693 pShmNode = p->pShmNode;
50697 sqlite3_mutex_enter(pShmNode->mutex);
50698 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
50699 *pp = p->pNext;
50703 pDbFd->pShm = 0;
50704 sqlite3_mutex_leave(pShmNode->mutex);
50706 /* If pShmNode->nRef has reached 0, then close the underlying
50707 ** shared-memory file, too */
50709 assert( pShmNode->nRef>0 );
50710 pShmNode->nRef--;
50711 if( pShmNode->nRef==0 ){
50712 winShmPurge(pDbFd->pVfs, deleteFlag);
50720 ** Change the lock state for a shared-memory segment.
50729 winShm *p = pDbFd->pShm; /* The shared memory being locked */
50736 pShmNode = p->pShmNode;
50747 mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
50749 sqlite3_mutex_enter(pShmNode->mutex);
50754 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
50756 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
50757 allMask |= pX->sharedMask;
50760 /* Unlock the system-level locks */
50769 p->exclMask &= ~mask;
50770 p->sharedMask &= ~mask;
50779 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
50780 if( (pX->exclMask & mask)!=0 ){
50784 allShared |= pX->sharedMask;
50798 p->sharedMask |= mask;
50804 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
50805 if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
50817 assert( (p->sharedMask & mask)==0 );
50818 p->exclMask |= mask;
50822 sqlite3_mutex_leave(pShmNode->mutex);
50823 OSTRACE(("SHM-LOCK pid=%lu, id=%d, sharedMask=%03x, exclMask=%03x, rc=%s\n",
50824 osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask,
50839 sqlite3MemoryBarrier(); /* compiler-defined memory barrier */
50846 ** shared-memory associated with the database file fd. Shared-memory regions
50847 ** are numbered starting from zero. Each shared-memory region is szRegion
50852 ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
50855 ** isWrite is non-zero and the requested shared-memory region has not yet
50858 ** If the shared-memory region has already been allocated or is allocated by
50871 winShm *pShm = pDbFd->pShm;
50880 pShm = pDbFd->pShm;
50883 pShmNode = pShm->pShmNode;
50885 sqlite3_mutex_enter(pShmNode->mutex);
50886 if( pShmNode->isUnlocked ){
50889 pShmNode->isUnlocked = 0;
50891 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
50893 if( pShmNode->nRegion<=iRegion ){
50896 sqlite3_int64 sz; /* Current size of wal-index file */
50898 pShmNode->szRegion = szRegion;
50901 ** Check to see if it has been allocated (i.e. if the wal-index file is
50904 rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
50907 "winShmMap1", pDbFd->zPath);
50915 ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
50919 rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
50922 "winShmMap2", pDbFd->zPath);
50929 pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
50935 pShmNode->aRegion = apNew;
50937 if( pShmNode->isReadonly ){
50942 while( pShmNode->nRegion<=iRegion ){
50943 HANDLE hMap = NULL; /* file-mapping handle */
50947 hMap = osCreateFileMappingFromApp(pShmNode->hFile.h,
50951 hMap = osCreateFileMappingW(pShmNode->hFile.h,
50955 hMap = osCreateFileMappingA(pShmNode->hFile.h,
50959 OSTRACE(("SHM-MAP-CREATE pid=%lu, region=%d, size=%d, rc=%s\n",
50960 osGetCurrentProcessId(), pShmNode->nRegion, nByte,
50963 int iOffset = pShmNode->nRegion*szRegion;
50967 iOffset - iOffsetShift, szRegion + iOffsetShift
50971 0, iOffset - iOffsetShift, szRegion + iOffsetShift
50974 OSTRACE(("SHM-MAP-MAP pid=%lu, region=%d, offset=%d, size=%d, rc=%s\n",
50975 osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
50979 pShmNode->lastErrno = osGetLastError();
50980 rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno,
50981 "winShmMap3", pDbFd->zPath);
50986 pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
50987 pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
50988 pShmNode->nRegion++;
50993 if( pShmNode->nRegion>iRegion ){
50996 char *p = (char *)pShmNode->aRegion[iRegion].pMap;
51001 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
51002 sqlite3_mutex_leave(pShmNode->mutex);
51019 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, "
51021 osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
51022 pFile->mmapSize, pFile->mmapSizeMax));
51023 if( pFile->pMapRegion ){
51024 if( !osUnmapViewOfFile(pFile->pMapRegion) ){
51025 pFile->lastErrno = osGetLastError();
51026 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, "
51028 pFile->pMapRegion));
51029 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
51030 "winUnmapfile1", pFile->zPath);
51032 pFile->pMapRegion = 0;
51033 pFile->mmapSize = 0;
51035 if( pFile->hMap!=NULL ){
51036 if( !osCloseHandle(pFile->hMap) ){
51037 pFile->lastErrno = osGetLastError();
51038 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n",
51039 osGetCurrentProcessId(), pFile, pFile->hMap));
51040 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
51041 "winUnmapfile2", pFile->zPath);
51043 pFile->hMap = NULL;
51045 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
51051 ** Memory map or remap the file opened by file-descriptor pFd (if the file
51054 ** outstanding xFetch() references to it, this function is a no-op.
51056 ** If parameter nByte is non-negative, then it is the requested size of
51070 assert( nMap>=0 || pFd->nFetchOut==0 );
51071 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, size=%lld\n",
51074 if( pFd->nFetchOut>0 ) return SQLITE_OK;
51079 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_IOERR_FSTAT\n",
51084 if( nMap>pFd->mmapSizeMax ){
51085 nMap = pFd->mmapSizeMax;
51087 nMap &= ~(sqlite3_int64)(winSysInfo.dwPageSize - 1);
51089 if( nMap==0 && pFd->mmapSize>0 ){
51092 if( nMap!=pFd->mmapSize ){
51099 if( (pFd->ctrlFlags & WINFILE_RDONLY)==0 ){
51105 pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL);
51107 pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect,
51111 pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect,
51115 if( pFd->hMap==NULL ){
51116 pFd->lastErrno = osGetLastError();
51117 rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
51118 "winMapfile1", pFd->zPath);
51120 OSTRACE(("MAP-FILE-CREATE pid=%lu, pFile=%p, rc=%s\n",
51127 pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap);
51129 pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
51132 osCloseHandle(pFd->hMap);
51133 pFd->hMap = NULL;
51134 pFd->lastErrno = osGetLastError();
51135 rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
51136 "winMapfile2", pFd->zPath);
51138 OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n",
51142 pFd->pMapRegion = pNew;
51143 pFd->mmapSize = nMap;
51146 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
51174 if( pFd->mmapSizeMax>0 ){
51180 if( pFd->pMapRegion==0 ){
51181 int rc = winMapfile(pFd, -1);
51188 if( pFd->mmapSize >= (iOff+nAmt+nEofBuffer) ){
51189 assert( pFd->pMapRegion!=0 );
51190 *pp = &((u8 *)pFd->pMapRegion)[iOff];
51191 pFd->nFetchOut++;
51202 ** If the third argument is non-NULL, then this function releases a
51218 assert( (p==0)==(pFd->nFetchOut==0) );
51221 assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
51227 pFd->nFetchOut--;
51231 ** is unnecessary can be omitted - potentially improving
51236 assert( pFd->nFetchOut>=0 );
51324 ** supports for filenames into UTF-8. Space to hold the result is
51343 ** Convert a UTF-8 filename into whatever form the underlying
51363 ** This function returns non-zero if the specified UTF-8 string buffer
51371 if( winIsDirSep(zBuf[nLen-1]) ){
51411 /* It's odd to simulate an io-error here, but really this is just
51412 ** using the io-error infrastructure to test that SQLite handles this
51420 nMax = pVfs->mxPathname; nBuf = nMax + 2;
51423 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51431 nDir = nMax - (nPre + 15);
51436 if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){
51442 OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
51484 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51497 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51505 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_CONVPATH\n"));
51512 ** its name into UTF-8 (i.e. if it is UTF-16 right now).
51518 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51536 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51542 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
51554 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51564 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51569 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
51579 OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
51593 OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
51611 OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
51615 sqlite3_snprintf(nBuf-16-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX);
51623 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
51629 OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf));
51675 const char *zName, /* Name of the file (UTF-8) */
51692 const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
51734 /* The main DB, main journal, WAL file and super-journal are never
51741 /* Assert that the upper layer has set one of the "file-type" flags. */
51750 pFile->h = INVALID_HANDLE_VALUE;
51772 /* Database filenames are double-zero terminated if they are not
51918 pFile->lastErrno = lastErrno;
51919 winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
51936 pAppData = (winVfsAppData*)pVfs->pAppData;
51941 && ((pAppData==NULL) || !pAppData->bNoLock)
51947 OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc)));
51952 pFile->zDeleteOnClose = zConverted;
51960 id->pMethods = pAppData ? pAppData->pMethod : &winIoMethod;
51961 pFile->pVfs = pVfs;
51962 pFile->h = h;
51964 pFile->ctrlFlags |= WINFILE_RDONLY;
51969 pFile->ctrlFlags |= WINFILE_PSOW;
51971 pFile->lastErrno = NO_ERROR;
51972 pFile->zPath = zName;
51974 pFile->hMap = NULL;
51975 pFile->pMapRegion = 0;
51976 pFile->mmapSize = 0;
51977 pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
51992 ** problem, we delay 100 milliseconds and try to delete again. Up
52140 /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
52186 ** Returns non-zero if the specified path name starts with the "long path"
52197 ** Returns non-zero if the specified path name starts with a drive letter
52207 ** Returns non-zero if the specified path name should be used verbatim. If
52208 ** non-zero is returned from this function, the calling function must simply
52209 ** use the provided path name verbatim -OR- resolve it into a full path name
52245 ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
52271 assert( nFull>=pVfs->mxPathname );
52279 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
52285 CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){
52295 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
52301 char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
52307 zRelative, zOut, pVfs->mxPathname+1)<0 ){
52317 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8);
52336 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
52339 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative);
52345 /* It's odd to simulate an io-error here, but really this is just
52346 ** using the io-error infrastructure to test that SQLite handles this
52358 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
52419 sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
52450 int nFull = pVfs->mxPathname+1;
52525 for(j=0, k=p->i; j<sz; j++){
52526 p->a[k++] ^= x[j];
52527 if( k>=p->na ) k = 0;
52529 p->i = k;
52530 p->nXor += sz;
52601 ** The following variable, if set to a non-zero value, is interpreted as
52620 /* FILETIME structure is a 64-bit value representing the number of
52621 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
52628 /* 2^32 - to avoid use of LL and warnings in gcc */
52678 ** buffer with a nul-terminated UTF-8 encoded error message
52684 ** is zero if the error message fits in the buffer, or non-zero
52685 ** otherwise (if the message was truncated). If non-zero is returned,
52686 ** then it is not necessary to include the nul-terminator character
52743 "win32-longpath", /* zName */
52768 "win32-none", /* zName */
52793 "win32-longpath-none", /* zName */
52814 /* Double-check that the aSyscall[] array has been constructed
52867 ** 2016-09-07
52878 ** This file implements an in-memory VFS. A database is held as a contiguous
52894 /* Access to a lower-level VFS that (might) implement dynamic loading,
52897 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
52951 sqlite3_file base; /* IO methods */
52957 ** File-scope variables for holding the memdb files that are accessible
53061 sqlite3_mutex_enter(p->pMutex);
53064 sqlite3_mutex_leave(p->pMutex);
53071 ** Close an memdb-file.
53076 MemStore *p = ((MemFile*)pFile)->pStore;
53077 if( p->zFName ){
53086 if( p->nRef==1 ){
53087 memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore];
53100 p->nRef--;
53101 if( p->nRef<=0 ){
53102 if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){
53103 sqlite3_free(p->aData);
53106 sqlite3_mutex_free(p->pMutex);
53115 ** Read data from an memdb-file.
53123 MemStore *p = ((MemFile*)pFile)->pStore;
53125 if( iOfst+iAmt>p->sz ){
53127 if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
53131 memcpy(zBuf, p->aData+iOfst, iAmt);
53141 if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){
53144 if( newSz>p->szMax ){
53148 if( newSz>p->szMax ) newSz = p->szMax;
53149 pNew = sqlite3Realloc(p->aData, newSz);
53151 p->aData = pNew;
53152 p->szAlloc = newSz;
53157 ** Write data to an memdb-file.
53165 MemStore *p = ((MemFile*)pFile)->pStore;
53167 if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
53173 if( iOfst+iAmt>p->sz ){
53175 if( iOfst+iAmt>p->szAlloc
53181 if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
53182 p->sz = iOfst+iAmt;
53184 memcpy(p->aData+iOfst, z, iAmt);
53190 ** Truncate an memdb-file.
53197 MemStore *p = ((MemFile*)pFile)->pStore;
53200 if( size>p->sz ){
53204 p->sz = size;
53211 ** Sync an memdb-file.
53220 ** Return the current file-size of an memdb-file.
53223 MemStore *p = ((MemFile*)pFile)->pStore;
53225 *pSize = p->sz;
53231 ** Lock an memdb-file.
53235 MemStore *p = pThis->pStore;
53237 if( eLock<=pThis->eLock ) return SQLITE_OK;
53240 assert( p->nWrLock==0 || p->nWrLock==1 );
53241 assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 );
53242 assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 );
53244 if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
53249 assert( pThis->eLock==SQLITE_LOCK_NONE );
53250 if( p->nWrLock>0 ){
53253 p->nRdLock++;
53260 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
53261 if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){
53262 if( p->nWrLock>0 ){
53265 p->nWrLock = 1;
53273 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
53274 if( p->nRdLock>1 ){
53276 }else if( pThis->eLock==SQLITE_LOCK_SHARED ){
53277 p->nWrLock = 1;
53283 if( rc==SQLITE_OK ) pThis->eLock = eLock;
53289 ** Unlock an memdb-file.
53293 MemStore *p = pThis->pStore;
53294 if( eLock>=pThis->eLock ) return SQLITE_OK;
53299 if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){
53300 p->nWrLock--;
53303 if( pThis->eLock>SQLITE_LOCK_SHARED ){
53304 p->nWrLock--;
53306 p->nRdLock--;
53309 pThis->eLock = eLock;
53317 ** occur on an in-memory database.
53327 ** File control method. For custom operations on an memdb-file.
53330 MemStore *p = ((MemFile*)pFile)->pStore;
53334 *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
53339 if( iLimit<p->sz ){
53341 iLimit = p->szMax;
53343 iLimit = p->sz;
53346 p->szMax = iLimit;
53356 ** Return the sector-size in bytes for an memdb-file.
53364 ** Return the device characteristic flags supported by an memdb-file.
53374 /* Fetch a page of a memory-mapped file */
53381 MemStore *p = ((MemFile*)pFile)->pStore;
53383 if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){
53386 p->nMmap++;
53387 *pp = (void*)(p->aData + iOfst);
53393 /* Release a memory-mapped page */
53395 MemStore *p = ((MemFile*)pFile)->pStore;
53399 p->nMmap--;
53428 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
53450 p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE;
53451 p->szMax = sqlite3GlobalConfig.mxMemdbSize;
53452 p->zFName = (char*)&p[1];
53453 memcpy(p->zFName, zName, szName+1);
53454 p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
53455 if( p->pMutex==0 ){
53456 memdb_g.nMemStore--;
53461 p->nRef = 1;
53465 p->nRef++;
53474 p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
53475 p->szMax = sqlite3GlobalConfig.mxMemdbSize;
53477 pFile->pStore = p;
53481 pFd->pMethods = &memdb_io_methods;
53486 #if 0 /* Only used to delete rollback journals, super-journals, and WAL
53490 ** ensure the file-system modifications are synced to disk before
53537 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
53542 ** utf-8 string describing the most recent error encountered associated
53546 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
53553 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
53560 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
53568 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
53576 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
53584 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
53589 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
53592 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
53604 if( p->base.pMethods!=&memdb_io_methods ) return 0;
53605 pStore = p->pStore;
53607 if( pStore->zFName!=0 ) p = 0;
53638 if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
53641 if( piSize ) *piSize = -1;
53644 MemStore *pStore = p->pStore;
53645 assert( pStore->pMutex==0 );
53646 if( piSize ) *piSize = pStore->sz;
53648 pOut = pStore->aData;
53650 pOut = sqlite3_malloc64( pStore->sz );
53651 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
53655 pBt = db->aDb[iDb].pBt;
53659 rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
53686 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
53726 sqlite3_mutex_enter(db->mutex);
53727 if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
53738 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
53742 db->init.iDb = (u8)iDb;
53743 db->init.reopenMemdb = 1;
53745 db->init.reopenMemdb = 0;
53754 MemStore *pStore = p->pStore;
53755 pStore->aData = pData;
53757 pStore->sz = szDb;
53758 pStore->szAlloc = szBuf;
53759 pStore->szMax = szBuf;
53760 if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
53761 pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
53763 pStore->mFlags = mFlags;
53772 sqlite3_mutex_leave(db->mutex);
53791 sz = pLower->szOsFile;
53816 ** This file implements an object that represents a fixed-length
53820 ** journalled during a transaction, or which pages have the "dont-write"
53833 ** Test operations are about 100 times more common that set operations.
53849 (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
53866 ** sub-dividing and re-hashing. */
53871 ** no fewer collisions than the no-op *1. */
53891 ** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap
53900 u32 nSet; /* Number of bits that are set - only valid for aHash
53924 p->iSize = iSize;
53930 ** Check to see if the i-th bit is set. Return true or false.
53936 i--;
53937 if( i>=p->iSize ) return 0;
53938 while( p->iDivisor ){
53939 u32 bin = i/p->iDivisor;
53940 i = i%p->iDivisor;
53941 p = p->u.apSub[bin];
53946 if( p->iSize<=BITVEC_NBIT ){
53947 return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
53950 while( p->u.aHash[h] ){
53951 if( p->u.aHash[h]==i ) return 1;
53962 ** Set the i-th bit. Return 0 on success and an error code if
53965 ** This routine might cause sub-bitmaps to be allocated. Failing
53966 ** to get the memory needed to hold the sub-bitmap is the only
53977 assert( i<=p->iSize );
53978 i--;
53979 while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
53980 u32 bin = i/p->iDivisor;
53981 i = i%p->iDivisor;
53982 if( p->u.apSub[bin]==0 ){
53983 p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
53984 if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM_BKPT;
53986 p = p->u.apSub[bin];
53988 if( p->iSize<=BITVEC_NBIT ){
53989 p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
53995 /* worrying about sub-dividing and re-hashing. */
53996 if( !p->u.aHash[h] ){
53997 if (p->nSet<(BITVEC_NINT-1)) {
54006 if( p->u.aHash[h]==i ) return SQLITE_OK;
54009 } while( p->u.aHash[h] );
54014 if( p->nSet>=BITVEC_MXHASH ){
54017 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
54021 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
54022 memset(p->u.apSub, 0, sizeof(p->u.apSub));
54023 p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
54033 p->nSet++;
54034 p->u.aHash[h] = i;
54039 ** Clear the i-th bit.
54047 i--;
54048 while( p->iDivisor ){
54049 u32 bin = i/p->iDivisor;
54050 i = i%p->iDivisor;
54051 p = p->u.apSub[bin];
54056 if( p->iSize<=BITVEC_NBIT ){
54057 p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
54061 memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
54062 memset(p->u.aHash, 0, sizeof(p->u.aHash));
54063 p->nSet = 0;
54066 u32 h = BITVEC_HASH(aiValues[j]-1);
54067 p->nSet++;
54068 while( p->u.aHash[h] ){
54072 p->u.aHash[h] = aiValues[j];
54083 if( p->iDivisor ){
54086 sqlite3BitvecDestroy(p->u.apSub[i]);
54097 return p->iSize;
54139 ** If a memory allocation error occurs, return -1.
54144 int rc = -1;
54167 i = aOp[pc+2] - 1;
54179 if( (--aOp[pc+1]) > 0 ) nx = 0;
54195 ** match (rc==0). Change rc to non-zero if a discrepancy
54200 + (sqlite3BitvecSize(pBitvec) - sz);
54246 ** such that p was added to the list more recently than p->pDirtyNext.
54251 ** page to eject from the cache mid-transaction. It is better to eject
54294 pPg = (PgHdr*)pLower->pExtra;
54295 printf("%3d: nRef %2lld flgs %02x data ", i, pPg->nRef, pPg->flags);
54296 a = (unsigned char *)pLower->pBuf;
54307 if( pCache->pCache==0 ) return;
54311 pLower = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, i, 0);
54313 if( pLower && ((PgHdr*)pLower)->pPage==0 ){
54314 sqlite3GlobalConfig.pcache2.xUnpin(pCache->pCache, pLower, 0);
54331 for(p=pCache->pDirty; p; p=p->pDirtyNext){
54338 for(p=pCache->pDirty; p; p=p->pDirtyNext){
54361 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
54362 pCache = pPg->pCache;
54364 if( pPg->flags & PGHDR_CLEAN ){
54365 assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */
54368 assert( (pPg->flags & PGHDR_DIRTY)!=0 );/* If not CLEAN must be DIRTY */
54369 assert( pPg->pDirtyNext==0 || pPg->pDirtyNext->pDirtyPrev==pPg );
54370 assert( pPg->pDirtyPrev==0 || pPg->pDirtyPrev->pDirtyNext==pPg );
54371 assert( pPg->pDirtyPrev!=0 || pCache->pDirty==pPg );
54375 if( pPg->flags & PGHDR_WRITEABLE ){
54376 assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */
54414 PCache *p = pPage->pCache;
54418 pPage->pgno));
54420 assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
54421 assert( pPage->pDirtyPrev || pPage==p->pDirty );
54424 if( p->pSynced==pPage ){
54425 p->pSynced = pPage->pDirtyPrev;
54428 if( pPage->pDirtyNext ){
54429 pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
54431 assert( pPage==p->pDirtyTail );
54432 p->pDirtyTail = pPage->pDirtyPrev;
54434 if( pPage->pDirtyPrev ){
54435 pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
54441 assert( pPage==p->pDirty );
54442 p->pDirty = pPage->pDirtyNext;
54443 assert( p->bPurgeable || p->eCreate==2 );
54444 if( p->pDirty==0 ){ /*OPTIMIZATION-IF-TRUE*/
54445 assert( p->bPurgeable==0 || p->eCreate==1 );
54446 p->eCreate = 2;
54451 pPage->pDirtyPrev = 0;
54452 pPage->pDirtyNext = p->pDirty;
54453 if( pPage->pDirtyNext ){
54454 assert( pPage->pDirtyNext->pDirtyPrev==0 );
54455 pPage->pDirtyNext->pDirtyPrev = pPage;
54457 p->pDirtyTail = pPage;
54458 if( p->bPurgeable ){
54459 assert( p->eCreate==2 );
54460 p->eCreate = 1;
54463 p->pDirty = pPage;
54469 ** entries of the dirty-list for a page with NEED_SYNC clear anyway. */
54470 if( !p->pSynced
54471 && 0==(pPage->flags&PGHDR_NEED_SYNC) /*OPTIMIZATION-IF-FALSE*/
54473 p->pSynced = pPage;
54481 ** being used for an in-memory database, this function is a no-op.
54484 if( p->pCache->bPurgeable ){
54485 pcacheTrace(("%p.UNPIN %d\n", p->pCache, p->pgno));
54486 sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 0);
54487 pcacheDump(p->pCache);
54492 ** Compute the number of pages of cache requested. p->szCache is the
54496 if( p->szCache>=0 ){
54497 /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the
54499 return p->szCache;
54502 /* IMPLEMENTATION-OF: R-59858-46238 If the argument N is negative, then the
54506 n = ((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
54519 /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
54520 ** built-in default page cache is used instead of the application defined
54529 /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */
54560 p->szPage = 1;
54561 p->szExtra = szExtra;
54563 p->bPurgeable = bPurgeable;
54564 p->eCreate = 2;
54565 p->xStress = xStress;
54566 p->pStress = pStress;
54567 p->szCache = 100;
54568 p->szSpill = 1;
54578 assert( pCache->nRefSum==0 && pCache->pDirty==0 );
54579 if( pCache->szPage ){
54582 szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
54583 pCache->bPurgeable
54587 if( pCache->pCache ){
54588 sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
54590 pCache->pCache = pNew;
54591 pCache->szPage = szPage;
54630 assert( pCache->pCache!=0 );
54632 assert( pCache->eCreate==((pCache->bPurgeable && pCache->pDirty) ? 1 : 2) );
54641 eCreate = createFlag & pCache->eCreate;
54643 assert( createFlag==0 || pCache->eCreate==eCreate );
54644 assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) );
54645 pRes = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
54669 if( pCache->eCreate==2 ) return 0;
54671 if( sqlite3PcachePagecount(pCache)>pCache->szSpill ){
54672 /* Find a dirty page to write-out and recycle. First try to find a
54673 ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
54681 for(pPg=pCache->pSynced;
54682 pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
54683 pPg=pPg->pDirtyPrev
54685 pCache->pSynced = pPg;
54687 for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
54693 "spill page %d making room for %d - cache used: %d/%d",
54694 pPg->pgno, pgno,
54695 sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache),
54698 pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
54699 rc = pCache->xStress(pCache->pStress, pPg);
54706 *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
54726 pPgHdr = (PgHdr*)pPage->pExtra;
54727 assert( pPgHdr->pPage==0 );
54728 memset(&pPgHdr->pDirty, 0, sizeof(PgHdr) - offsetof(PgHdr,pDirty));
54729 pPgHdr->pPage = pPage;
54730 pPgHdr->pData = pPage->pBuf;
54731 pPgHdr->pExtra = (void *)&pPgHdr[1];
54732 memset(pPgHdr->pExtra, 0, 8);
54733 pPgHdr->pCache = pCache;
54734 pPgHdr->pgno = pgno;
54735 pPgHdr->flags = PGHDR_CLEAN;
54753 pPgHdr = (PgHdr *)pPage->pExtra;
54755 if( !pPgHdr->pPage ){
54758 pCache->nRefSum++;
54759 pPgHdr->nRef++;
54769 assert( p->nRef>0 );
54770 p->pCache->nRefSum--;
54771 if( (--p->nRef)==0 ){
54772 if( p->flags&PGHDR_CLEAN ){
54785 assert(p->nRef>0);
54787 p->nRef++;
54788 p->pCache->nRefSum++;
54797 assert( p->nRef==1 );
54799 if( p->flags&PGHDR_DIRTY ){
54802 p->pCache->nRefSum--;
54803 sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1);
54811 assert( p->nRef>0 );
54813 if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){ /*OPTIMIZATION-IF-FALSE*/
54814 p->flags &= ~PGHDR_DONT_WRITE;
54815 if( p->flags & PGHDR_CLEAN ){
54816 p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN);
54817 pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno));
54818 assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY );
54832 assert( (p->flags & PGHDR_DIRTY)!=0 );
54833 assert( (p->flags & PGHDR_CLEAN)==0 );
54835 p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
54836 p->flags |= PGHDR_CLEAN;
54837 pcacheTrace(("%p.CLEAN %d\n",p->pCache,p->pgno));
54839 if( p->nRef==0 ){
54849 pcacheTrace(("%p.CLEAN-ALL\n",pCache));
54850 while( (p = pCache->pDirty)!=0 ){
54860 pcacheTrace(("%p.CLEAR-WRITEABLE\n",pCache));
54861 for(p=pCache->pDirty; p; p=p->pDirtyNext){
54862 p->flags &= ~(PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
54864 pCache->pSynced = pCache->pDirtyTail;
54872 for(p=pCache->pDirty; p; p=p->pDirtyNext){
54873 p->flags &= ~PGHDR_NEED_SYNC;
54875 pCache->pSynced = pCache->pDirtyTail;
54882 PCache *pCache = p->pCache;
54884 assert( p->nRef>0 );
54887 pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
54888 pOther = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, newPgno, 0);
54890 PgHdr *pXPage = (PgHdr*)pOther->pExtra;
54891 assert( pXPage->nRef==0 );
54892 pXPage->nRef++;
54893 pCache->nRefSum++;
54896 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
54897 p->pgno = newPgno;
54898 if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
54914 if( pCache->pCache ){
54918 for(p=pCache->pDirty; p; p=pNext){
54919 pNext = p->pDirtyNext;
54924 assert( p->pgno>0 );
54925 if( p->pgno>pgno ){
54926 assert( p->flags&PGHDR_DIRTY );
54930 if( pgno==0 && pCache->nRefSum ){
54932 pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0);
54934 ** pCache->nRefSum>0 */
54935 memset(pPage1->pBuf, 0, pCache->szPage);
54939 sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
54947 assert( pCache->pCache!=0 );
54949 sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
54968 if( pA->pgno<pB->pgno ){
54969 pTail->pDirty = pA;
54971 pA = pA->pDirty;
54973 pTail->pDirty = pB;
54977 pTail->pDirty = pB;
54979 pB = pB->pDirty;
54981 pTail->pDirty = pA;
55006 pIn = p->pDirty;
55007 p->pDirty = 0;
55008 for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){
55017 if( NEVER(i==N_SORT_BUCKET-1) ){
55037 for(p=pCache->pDirty; p; p=p->pDirtyNext){
55038 p->pDirty = p->pDirtyNext;
55040 return pcacheSortDirtyList(pCache->pDirty);
55050 return pCache->nRefSum;
55057 return p->nRef;
55064 assert( pCache->pCache!=0 );
55065 return sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache);
55070 ** Get the suggested cache-size value.
55078 ** Set the suggested cache-size value.
55081 assert( pCache->pCache!=0 );
55082 pCache->szCache = mxPage;
55083 sqlite3GlobalConfig.pcache2.xCachesize(pCache->pCache,
55088 ** Set the suggested cache-spill value. Make no changes if if the
55089 ** argument is zero. Return the effective cache-spill size, which will
55094 assert( p->pCache!=0 );
55097 mxPage = (int)((-1024*(i64)mxPage)/(p->szPage+p->szExtra));
55099 p->szSpill = mxPage;
55102 if( res<p->szSpill ) res = p->szSpill;
55110 assert( pCache->pCache!=0 );
55111 sqlite3GlobalConfig.pcache2.xShrink(pCache->pCache);
55116 ** in the page-cache hierarchy.
55128 for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext) nDirty++;
55129 return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0;
55137 return (pCache->pDirty!=0);
55149 for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){
55177 ** -------------------------------------------------------------
55179 ** -------------------------------------------------------------
55195 ** size can vary according to architecture, compile-time options, and
55201 ** allocations. However, the btree layer needs a small (16-byte) overrun
55216 ** (1) The general-purpose memory allocator - sqlite3Malloc()
55217 ** (2) Global page-cache memory provided using sqlite3_config() with
55219 ** (3) PCache-local bulk allocation.
55221 ** The third case is a chunk of heap memory (defaulting to 100 pages worth)
55229 ** Or if N is negative, then -1024*N bytes of memory are allocated and used
55233 ** (3) is exhausted, subsequent allocations fail over to the general-purpose
55237 ** show that method (3) with N==100 provides about a 5% performance boost for
55249 ** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated
55259 ** but causes a 2-byte gap in the structure for most architectures (since
55260 ** pointers must be either 4 or 8-byte aligned). As this structure is located
55262 ** corrupt, code at the b-tree layer may overread the page buffer and
55268 ** The pLruNext and pLruPrev pointers form a double-linked circular list
55274 sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */
55289 #define PAGE_IS_PINNED(p) ((p)->pLruNext==0)
55290 #define PAGE_IS_UNPINNED(p) ((p)->pLruNext!=0)
55318 unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */
55324 ** open database file (including each in-memory database and each
55339 unsigned int *pnPurgeable; /* Pointer to pGroup->nPurgeable */
55357 PgHdr1 *pFree; /* List of unused pcache-local pages */
55358 void *pBulk; /* Bulk memory used by pcache-local */
55392 ** reading because (1) most platforms read a 32-bit integer atomically and
55409 # define pcache1EnterMutex(X) assert((X)->mutex==0)
55410 # define pcache1LeaveMutex(X) assert((X)->mutex==0)
55413 # define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex)
55414 # define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex)
55424 ** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE
55443 while( n-- ){
55445 p->pNext = pcache1.pFree;
55454 ** Try to initialize the pCache->pFree and pCache->pBulk fields. Return
55455 ** true if pCache->pFree ends up containing one or more free pages.
55462 if( pCache->nMax<3 ) return 0;
55465 szBulk = pCache->szAlloc * (i64)pcache1.nInitPage;
55467 szBulk = -1024 * (i64)pcache1.nInitPage;
55469 if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){
55470 szBulk = pCache->szAlloc*(i64)pCache->nMax;
55472 zBulk = pCache->pBulk = sqlite3Malloc( szBulk );
55475 int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc;
55477 PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage];
55478 pX->page.pBuf = zBulk;
55479 pX->page.pExtra = &pX[1];
55480 pX->isBulkLocal = 1;
55481 pX->isAnchor = 0;
55482 pX->pNext = pCache->pFree;
55483 pX->pLruPrev = 0; /* Initializing this saves a valgrind error */
55484 pCache->pFree = pX;
55485 zBulk += pCache->szAlloc;
55486 }while( --nBulk );
55488 return pCache->pFree!=0;
55507 pcache1.pFree = pcache1.pFree->pNext;
55508 pcache1.nFreeSlot--;
55545 pSlot->pNext = pcache1.pFree;
55592 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
55593 if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){
55594 assert( pCache->pFree!=0 );
55595 p = pCache->pFree;
55596 pCache->pFree = p->pNext;
55597 p->pNext = 0;
55604 assert( pCache->pGroup==&pcache1.grp );
55605 pcache1LeaveMutex(pCache->pGroup);
55608 pPg = pcache1Alloc(pCache->szAlloc);
55611 pcache1EnterMutex(pCache->pGroup);
55614 p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
55615 p->page.pBuf = pPg;
55616 p->page.pExtra = &p[1];
55617 p->isBulkLocal = 0;
55618 p->isAnchor = 0;
55619 p->pLruPrev = 0; /* Initializing this saves a valgrind error */
55621 (*pCache->pnPurgeable)++;
55631 pCache = p->pCache;
55632 assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
55633 if( p->isBulkLocal ){
55634 p->pNext = pCache->pFree;
55635 pCache->pFree = p;
55637 pcache1Free(p->page.pBuf);
55639 (*pCache->pnPurgeable)--;
55677 if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){
55698 assert( sqlite3_mutex_held(p->pGroup->mutex) );
55700 nNew = p->nHash*2;
55705 pcache1LeaveMutex(p->pGroup);
55706 if( p->nHash ){ sqlite3BeginBenignMalloc(); }
55708 if( p->nHash ){ sqlite3EndBenignMalloc(); }
55709 pcache1EnterMutex(p->pGroup);
55711 for(i=0; i<p->nHash; i++){
55713 PgHdr1 *pNext = p->apHash[i];
55715 unsigned int h = pPage->iKey % nNew;
55716 pNext = pPage->pNext;
55717 pPage->pNext = apNew[h];
55721 sqlite3_free(p->apHash);
55722 p->apHash = apNew;
55723 p->nHash = nNew;
55730 ** LRU list, then this function is a no-op.
55737 assert( pPage->pLruNext );
55738 assert( pPage->pLruPrev );
55739 assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) );
55740 pPage->pLruPrev->pLruNext = pPage->pLruNext;
55741 pPage->pLruNext->pLruPrev = pPage->pLruPrev;
55742 pPage->pLruNext = 0;
55743 /* pPage->pLruPrev = 0;
55745 assert( pPage->isAnchor==0 );
55746 assert( pPage->pCache->pGroup->lru.isAnchor==1 );
55747 pPage->pCache->nRecyclable--;
55761 PCache1 *pCache = pPage->pCache;
55764 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
55765 h = pPage->iKey % pCache->nHash;
55766 for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
55767 *pp = (*pp)->pNext;
55769 pCache->nPage--;
55778 PGroup *pGroup = pCache->pGroup;
55780 assert( sqlite3_mutex_held(pGroup->mutex) );
55781 while( pGroup->nPurgeable>pGroup->nMaxPage
55782 && (p=pGroup->lru.pLruPrev)->isAnchor==0
55784 assert( p->pCache->pGroup==pGroup );
55789 if( pCache->nPage==0 && pCache->pBulk ){
55790 sqlite3_free(pCache->pBulk);
55791 pCache->pBulk = pCache->pFree = 0;
55806 TESTONLY( int nPage = 0; ) /* To assert pCache->nPage is correct */
55808 assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
55809 assert( pCache->iMaxKey >= iLimit );
55810 assert( pCache->nHash > 0 );
55811 if( pCache->iMaxKey - iLimit < pCache->nHash ){
55816 h = iLimit % pCache->nHash;
55817 iStop = pCache->iMaxKey % pCache->nHash;
55818 TESTONLY( nPage = -10; ) /* Disable the pCache->nPage validity check */
55822 h = pCache->nHash/2;
55823 iStop = h - 1;
55828 assert( h<pCache->nHash );
55829 pp = &pCache->apHash[h];
55831 if( pPage->iKey>=iLimit ){
55832 pCache->nPage--;
55833 *pp = pPage->pNext;
55837 pp = &pPage->pNext;
55842 h = (h+1) % pCache->nHash;
55844 assert( nPage<0 || pCache->nPage==(unsigned)nPage );
55861 ** private PGroup (mode-1). pcache1.separateCache is false if the single
55862 ** PGroup in pcache1.grp is used for all page caches (mode-2).
55864 ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
55866 ** * Use a unified cache in single-threaded applications that have
55867 ** configured a start-time buffer for use as page-cache memory using
55868 ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL
55871 ** * Otherwise use separate caches (mode-1)
55925 assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
55933 pGroup->mxPinned = 10;
55938 if( pGroup->lru.isAnchor==0 ){
55939 pGroup->lru.isAnchor = 1;
55940 pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru;
55942 pCache->pGroup = pGroup;
55943 pCache->szPage = szPage;
55944 pCache->szExtra = szExtra;
55945 pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1));
55946 pCache->bPurgeable = (bPurgeable ? 1 : 0);
55949 pCache->nMin = 10;
55950 pGroup->nMinPage += pCache->nMin;
55951 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
55952 pCache->pnPurgeable = &pGroup->nPurgeable;
55954 pCache->pnPurgeable = &pCache->nPurgeableDummy;
55957 if( pCache->nHash==0 ){
55974 if( pCache->bPurgeable ){
55975 PGroup *pGroup = pCache->pGroup;
55978 if( n > 0x7fff0000 - pGroup->nMaxPage + pCache->nMax ){
55979 n = 0x7fff0000 - pGroup->nMaxPage + pCache->nMax;
55981 pGroup->nMaxPage += (n - pCache->nMax);
55982 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
55983 pCache->nMax = n;
55984 pCache->n90pct = pCache->nMax*9/10;
55997 if( pCache->bPurgeable ){
55998 PGroup *pGroup = pCache->pGroup;
56001 savedMaxPage = pGroup->nMaxPage;
56002 pGroup->nMaxPage = 0;
56004 pGroup->nMaxPage = savedMaxPage;
56015 pcache1EnterMutex(pCache->pGroup);
56016 n = pCache->nPage;
56017 pcache1LeaveMutex(pCache->pGroup);
56036 PGroup *pGroup = pCache->pGroup;
56040 assert( pCache->nPage >= pCache->nRecyclable );
56041 nPinned = pCache->nPage - pCache->nRecyclable;
56042 assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
56043 assert( pCache->n90pct == pCache->nMax*9/10 );
56045 nPinned>=pGroup->mxPinned
56046 || nPinned>=pCache->n90pct
56047 || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclable<nPinned)
56052 if( pCache->nPage>=pCache->nHash ) pcache1ResizeHash(pCache);
56053 assert( pCache->nHash>0 && pCache->apHash );
56056 if( pCache->bPurgeable
56057 && !pGroup->lru.pLruPrev->isAnchor
56058 && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache))
56061 pPage = pGroup->lru.pLruPrev;
56065 pOther = pPage->pCache;
56066 if( pOther->szAlloc != pCache->szAlloc ){
56070 pGroup->nPurgeable -= (pOther->bPurgeable - pCache->bPurgeable);
56082 unsigned int h = iKey % pCache->nHash;
56083 pCache->nPage++;
56084 pPage->iKey = iKey;
56085 pPage->pNext = pCache->apHash[h];
56086 pPage->pCache = pCache;
56087 pPage->pLruNext = 0;
56088 /* pPage->pLruPrev = 0;
56090 *(void **)pPage->page.pExtra = 0;
56091 pCache->apHash[h] = pPage;
56092 if( iKey>pCache->iMaxKey ){
56093 pCache->iMaxKey = iKey;
56109 ** For a non-purgeable cache (a cache used as the storage for an in-memory
56112 ** a non-purgeable cache.
56155 ** the common case where pGroup->mutex is NULL. The pcache1Fetch() wrapper
56167 pPage = pCache->apHash[iKey % pCache->nHash];
56168 while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; }
56196 pcache1EnterMutex(pCache->pGroup);
56198 assert( pPage==0 || pCache->iMaxKey>=iKey );
56199 pcache1LeaveMutex(pCache->pGroup);
56213 assert( pCache->bPurgeable || createFlag!=1 );
56214 assert( pCache->bPurgeable || pCache->nMin==0 );
56215 assert( pCache->bPurgeable==0 || pCache->nMin==10 );
56216 assert( pCache->nMin==0 || pCache->bPurgeable );
56217 assert( pCache->nHash>0 );
56219 if( pCache->pGroup->mutex ){
56241 PGroup *pGroup = pCache->pGroup;
56243 assert( pPage->pCache==pCache );
56249 assert( pPage->pLruNext==0 );
56252 if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){
56256 PgHdr1 **ppFirst = &pGroup->lru.pLruNext;
56257 pPage->pLruPrev = &pGroup->lru;
56258 (pPage->pLruNext = *ppFirst)->pLruPrev = pPage;
56260 pCache->nRecyclable++;
56263 pcache1LeaveMutex(pCache->pGroup);
56279 assert( pPage->iKey==iOld );
56280 assert( pPage->pCache==pCache );
56283 pcache1EnterMutex(pCache->pGroup);
56286 hOld = iOld%pCache->nHash;
56287 pp = &pCache->apHash[hOld];
56289 pp = &(*pp)->pNext;
56291 *pp = pPage->pNext;
56294 hNew = iNew%pCache->nHash;
56295 pPage->iKey = iNew;
56296 pPage->pNext = pCache->apHash[hNew];
56297 pCache->apHash[hNew] = pPage;
56298 if( iNew>pCache->iMaxKey ){
56299 pCache->iMaxKey = iNew;
56302 pcache1LeaveMutex(pCache->pGroup);
56314 pcache1EnterMutex(pCache->pGroup);
56315 if( iLimit<=pCache->iMaxKey ){
56317 pCache->iMaxKey = iLimit-1;
56319 pcache1LeaveMutex(pCache->pGroup);
56329 PGroup *pGroup = pCache->pGroup;
56330 assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
56332 if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0);
56333 assert( pGroup->nMaxPage >= pCache->nMax );
56334 pGroup->nMaxPage -= pCache->nMax;
56335 assert( pGroup->nMinPage >= pCache->nMin );
56336 pGroup->nMinPage -= pCache->nMin;
56337 pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
56340 sqlite3_free(pCache->pBulk);
56341 sqlite3_free(pCache->apHash);
56401 && p->isAnchor==0
56403 nFree += pcache1MemSize(p->page.pBuf);
56427 for(p=pcache1.grp.lru.pLruNext; p && !p->isAnchor; p=p->pLruNext){
56487 ** a non-zero batch number, it will see all prior INSERTs.
56515 ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))
56573 p->pChunk = 0;
56574 p->db = db;
56575 p->pEntry = 0;
56576 p->pLast = 0;
56577 p->pForest = 0;
56578 p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
56579 p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
56580 p->rsFlags = ROWSET_SORTED;
56581 p->iBatch = 0;
56594 for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
56595 pNextChunk = pChunk->pNextChunk;
56596 sqlite3DbFree(p->db, pChunk);
56598 p->pChunk = 0;
56599 p->nFresh = 0;
56600 p->pEntry = 0;
56601 p->pLast = 0;
56602 p->pForest = 0;
56603 p->rsFlags = ROWSET_SORTED;
56613 sqlite3DbFree(((RowSet*)pArg)->db, pArg);
56621 ** In an OOM situation, the RowSet.db->mallocFailed flag is set and this
56626 if( p->nFresh==0 ){ /*OPTIMIZATION-IF-FALSE*/
56630 pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
56634 pNew->pNextChunk = p->pChunk;
56635 p->pChunk = pNew;
56636 p->pFresh = pNew->aEntry;
56637 p->nFresh = ROWSET_ENTRY_PER_CHUNK;
56639 p->nFresh--;
56640 return p->pFresh++;
56654 assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );
56658 pEntry->v = rowid;
56659 pEntry->pRight = 0;
56660 pLast = p->pLast;
56662 if( rowid<=pLast->v ){ /*OPTIMIZATION-IF-FALSE*/
56665 p->rsFlags &= ~ROWSET_SORTED;
56667 pLast->pRight = pEntry;
56669 p->pEntry = pEntry;
56671 p->pLast = pEntry;
56690 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
56691 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
56692 if( pA->v<=pB->v ){
56693 if( pA->v<pB->v ) pTail = pTail->pRight = pA;
56694 pA = pA->pRight;
56696 pTail->pRight = pB;
56700 pTail = pTail->pRight = pB;
56701 pB = pB->pRight;
56703 pTail->pRight = pA;
56721 pNext = pIn->pRight;
56722 pIn->pRight = 0;
56750 if( pIn->pLeft ){
56752 rowSetTreeToList(pIn->pLeft, ppFirst, &p);
56753 p->pRight = pIn;
56757 if( pIn->pRight ){
56758 rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast);
56762 assert( (*ppLast)->pRight==0 );
56785 if( *ppList==0 ){ /*OPTIMIZATION-IF-TRUE*/
56789 if( iDepth>1 ){ /*OPTIMIZATION-IF-TRUE*/
56793 pLeft = rowSetNDeepTree(ppList, iDepth-1);
56795 if( p==0 ){ /*OPTIMIZATION-IF-FALSE*/
56800 p->pLeft = pLeft;
56801 *ppList = p->pRight;
56802 p->pRight = rowSetNDeepTree(ppList, iDepth-1);
56805 *ppList = p->pRight;
56806 p->pLeft = p->pRight = 0;
56822 pList = p->pRight;
56823 p->pLeft = p->pRight = 0;
56827 pList = p->pRight;
56828 p->pLeft = pLeft;
56829 p->pRight = rowSetNDeepTree(&pList, iDepth);
56849 assert( p->pForest==0 ); /* Cannot be used with sqlite3RowSetText() */
56852 if( (p->rsFlags & ROWSET_NEXT)==0 ){ /*OPTIMIZATION-IF-FALSE*/
56853 if( (p->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/
56854 p->pEntry = rowSetEntrySort(p->pEntry);
56856 p->rsFlags |= ROWSET_SORTED|ROWSET_NEXT;
56860 if( p->pEntry ){
56861 *pRowid = p->pEntry->v;
56862 p->pEntry = p->pEntry->pRight;
56863 if( p->pEntry==0 ){ /*OPTIMIZATION-IF-TRUE*/
56878 ** on pRowSet->pEntry, then sort those entries into the forest at
56879 ** pRowSet->pForest so that they can be tested.
56885 assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 );
56890 if( iBatch!=pRowSet->iBatch ){ /*OPTIMIZATION-IF-FALSE*/
56891 p = pRowSet->pEntry;
56893 struct RowSetEntry **ppPrevTree = &pRowSet->pForest;
56894 if( (pRowSet->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/
56898 for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){
56899 ppPrevTree = &pTree->pRight;
56900 if( pTree->pLeft==0 ){
56901 pTree->pLeft = rowSetListToTree(p);
56905 rowSetTreeToList(pTree->pLeft, &pAux, &pTail);
56906 pTree->pLeft = 0;
56913 pTree->v = 0;
56914 pTree->pRight = 0;
56915 pTree->pLeft = rowSetListToTree(p);
56918 pRowSet->pEntry = 0;
56919 pRowSet->pLast = 0;
56920 pRowSet->rsFlags |= ROWSET_SORTED;
56922 pRowSet->iBatch = iBatch;
56928 for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){
56929 p = pTree->pLeft;
56931 if( p->v<iRowid ){
56932 p = p->pRight;
56933 }else if( p->v>iRowid ){
56934 p = p->pLeft;
56980 ** This header file defines the interface to the write-ahead logging
57021 /* Connection to a write-ahead log (WAL) file.
57026 /* Open and close a connection to a write-ahead log. */
57034 ** snapshot is like a read-transaction. It is the state of the database
57043 /* Read a page from the write-ahead log, if it is present. */
57070 Wal *pWal, /* Write-ahead log connection */
57094 /* Return true if the argument is non-NULL and the WAL module is using
57095 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
57096 ** WAL module is using shared-memory, return false.
57110 ** stored in each frame (i.e. the db page-size when the WAL was created).
57176 ** first 100 bytes of the database file.
57181 ** (6) If a super-journal file is used, then all writes to the database file
57182 ** are synced prior to the super-journal being deleted.
57198 ** method is a no-op, but that does not change the fact the SQLite will
57209 ** (11) A database file is well-formed at the beginning and at the conclusion
57233 ** to print out file-descriptors.
57236 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
57239 #define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))
57247 ** OPEN <------+------+
57250 ** +---------> READER-------+ |
57253 ** |<-------WRITER_LOCKED------> ERROR
57256 ** |<------WRITER_CACHEMOD-------->|
57259 ** |<-------WRITER_DBMOD---------->|
57262 ** +<------WRITER_FINISHED-------->+
57267 ** OPEN -> READER [sqlite3PagerSharedLock]
57268 ** READER -> OPEN [pager_unlock]
57270 ** READER -> WRITER_LOCKED [sqlite3PagerBegin]
57271 ** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
57272 ** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
57273 ** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
57274 ** WRITER_*** -> READER [pager_end_transaction]
57276 ** WRITER_*** -> ERROR [pager_error]
57277 ** ERROR -> OPEN [pager_unlock]
57283 ** state - the file may or may not be locked and the database size is
57293 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
57294 ** was) in exclusive-locking mode, a user-level read transaction is
57298 ** it opens a read-transaction on the database and returns to state
57299 ** OPEN after the read-transaction is completed. However a connection
57301 ** this state even after the read-transaction is closed. The only way
57305 ** * A read transaction may be active (but a write-transaction cannot).
57307 ** * The dbSize variable may be trusted (even if a user-level read
57311 ** * Even if a read-transaction is not open, it is guaranteed that
57312 ** there is no hot-journal in the file-system.
57316 ** The pager moves to this state from READER when a write-transaction
57318 ** required to start a write-transaction are held, but no actual
57333 ** * If the connection is open in rollback-mode, a RESERVED or greater
57335 ** * If the connection is open in WAL-mode, a WAL write transaction
57374 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
57390 ** The ERROR state is entered when an IO or disk-full error (including
57392 ** difficult to be sure that the in-memory pager state (cache contents,
57393 ** db size etc.) are consistent with the contents of the file-system.
57395 ** Temporary pager files may enter the ERROR state, but in-memory pagers
57399 ** the contents of the page-cache may be left in an inconsistent state.
57411 ** page-cache and any other in-memory state at the same time. Everything
57412 ** is reloaded from disk (and, if necessary, hot-journal rollback performed)
57413 ** when a read-transaction is next opened on the pager (transitioning
57429 ** In other cases, the error is returned to the b-tree layer. The b-tree
57433 ** Condition (3) is necessary because it can be triggered by a read-only
57435 ** code were simply returned to the user, the b-tree layer would not
57437 ** read-only statement cannot leave the pager in an internally inconsistent
57443 ** * The pager is not an in-memory pager.
57453 ** state. There are two exceptions: immediately after exclusive-mode has
57469 ** following locking-states, according to the lock currently held on
57477 ** pagerUnlockDb() take a conservative approach - eLock is always updated
57488 ** from ERROR to OPEN state. At this point there may be a hot-journal file
57489 ** in the file-system that needs to be rolled back (as part of an OPEN->SHARED
57493 ** of hot-journal detection.
57499 ** a hot-journal may be mistaken for a journal being created by an active
57506 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
57507 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
57508 ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
57533 ** set to 0. If a journal-header is written into the main journal while
57536 ** journal before the journal-header. This is required during savepoint
57545 Pgno iSubRec; /* Index of first record in sub-journal */
57570 ** For a real on-disk database, the current lock held on the database file -
57573 ** For a temporary or in-memory database (neither of which require any
57585 ** This boolean variable is used to make sure that the change-counter
57586 ** (the 4-byte header field at byte offset 24 of the database file) is
57589 ** It is set to true when the change-counter field is updated, which
57594 ** updating the change-counter is omitted for the current transaction.
57597 ** need only update the change-counter once, for the first transaction
57603 ** (or may not) specify a super-journal name to be written into the
57606 ** Whether or not a journal file contains a super-journal pointer affects
57609 ** If a journal file does not contain a super-journal pointer, it is
57611 ** it does contain a super-journal pointer the journal file is finalized
57615 ** Journal files that contain super-journal pointers cannot be finalized
57616 ** simply by overwriting the first journal-header with zeroes, as the
57617 ** super-journal pointer could interfere with hot-journal rollback of any
57627 ** This variables control the behavior of cache-spills (calls made by
57629 ** to the file-system in order to free up memory).
57641 ** This flag is set by sqlite3PagerWrite() when the file-system sector-size
57642 ** is larger than the database page-size in order to prevent a journal sync
57647 ** This is a boolean variable. If true, then any required sub-journal
57648 ** is opened as an in-memory journal file. If false, then in-memory
57649 ** sub-journals are only used for in-memory pager files.
57652 ** write-transaction is opened.
57663 ** is not an integer multiple of the page-size, the value stored in
57664 ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
57666 ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
57669 ** During a write-transaction, if pages with page-numbers greater than
57680 ** Throughout a write-transaction, dbFileSize contains the size of
57682 ** write-transaction is first opened, and updated when VFS calls are made
57702 ** write-transaction is opened (at the same time as dbFileSize and
57705 ** size-hint passed to the method call. See pager_write_pagelist() for
57713 ** sub-codes.
57739 u8 readOnly; /* True for a read-only database */
57741 u8 memVfs; /* VFS-implemented memory database */
57754 u8 changeCountDone; /* Set after incrementing the change-counter */
57755 u8 setSuper; /* Super-jrnl name is written into jrnl */
57756 u8 doNotSpill; /* Do not spill the cache when non-zero */
57757 u8 subjInMemory; /* True to use in-memory sub-journals */
57765 int nRec; /* Pages journalled since last j-header written */
57766 u32 cksumInit; /* Quasi-random value added to every checksum */
57767 u32 nSubRec; /* Number of records written to sub-journal */
57771 sqlite3_file *sjfd; /* File descriptor for sub-journal */
57784 ** End of the routinely-changing class members
57787 u16 nExtra; /* Add this many bytes to each in-memory page */
57808 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
57809 char *zWal; /* File name for write-ahead log */
57826 ** a non-testing build. These variables are not thread-safe.
57845 ** written, semi-random garbage data might appear in the journal
57852 ** of a 32-bit checksum on each page of data. The checksum covers both
57853 ** the page number and the pPager->pageSize bytes of data for the page.
57854 ** This cksum is initialized to a 32-bit random value that appears in the
57870 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
57876 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
57879 ** The macro MEMDB is true if we are dealing with an in-memory database.
57887 # define MEMDB pPager->memDb
57892 ** interfaces to access the database using memory-mapped I/O.
57895 # define USEFETCH(x) ((x)->bUseFetch)
57902 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
57906 ** if( isOpen(pPager->jfd) ){ ...
57910 ** if( pPager->jfd->pMethods ){ ...
57912 #define isOpen(pFd) ((pFd)->pMethods!=0)
57917 ** by the b-tree layer. This is the case if:
57924 if( pPager->fd->pMethods==0 ) return 0;
57925 if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
57927 if( pPager->pWal ){
57929 (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
57938 # define pagerUseWal(x) ((x)->pWal!=0)
57960 assert( p->eState==PAGER_OPEN
57961 || p->eState==PAGER_READER
57962 || p->eState==PAGER_WRITER_LOCKED
57963 || p->eState==PAGER_WRITER_CACHEMOD
57964 || p->eState==PAGER_WRITER_DBMOD
57965 || p->eState==PAGER_WRITER_FINISHED
57966 || p->eState==PAGER_ERROR
57969 /* Regardless of the current state, a temp-file connection always behaves
57971 ** the change-counter field, so the changeCountDone flag is always set.
57973 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
57974 assert( p->tempFile==0 || pPager->changeCountDone );
57976 /* If the useJournal flag is clear, the journal-mode must be "OFF".
57977 ** And if the journal-mode is "OFF", the journal file must not be open.
57979 assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
57980 assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
57982 /* Check that MEMDB implies noSync. And an in-memory journal. Since
57983 ** this means an in-memory pager performs no IO at all, it cannot encounter
57985 ** a journal file. (although the in-memory journal implementation may
57987 ** is therefore not possible for an in-memory pager to enter the ERROR
57991 assert( !isOpen(p->fd) );
57992 assert( p->noSync );
57993 assert( p->journalMode==PAGER_JOURNALMODE_OFF
57994 || p->journalMode==PAGER_JOURNALMODE_MEMORY
57996 assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
58003 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
58004 assert( p->eLock!=PENDING_LOCK );
58006 switch( p->eState ){
58009 assert( pPager->errCode==SQLITE_OK );
58010 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
58014 assert( pPager->errCode==SQLITE_OK );
58015 assert( p->eLock!=UNKNOWN_LOCK );
58016 assert( p->eLock>=SHARED_LOCK );
58020 assert( p->eLock!=UNKNOWN_LOCK );
58021 assert( pPager->errCode==SQLITE_OK );
58023 assert( p->eLock>=RESERVED_LOCK );
58025 assert( pPager->dbSize==pPager->dbOrigSize );
58026 assert( pPager->dbOrigSize==pPager->dbFileSize );
58027 assert( pPager->dbOrigSize==pPager->dbHintSize );
58028 assert( pPager->setSuper==0 );
58032 assert( p->eLock!=UNKNOWN_LOCK );
58033 assert( pPager->errCode==SQLITE_OK );
58040 assert( p->eLock>=RESERVED_LOCK );
58041 assert( isOpen(p->jfd)
58042 || p->journalMode==PAGER_JOURNALMODE_OFF
58043 || p->journalMode==PAGER_JOURNALMODE_WAL
58046 assert( pPager->dbOrigSize==pPager->dbFileSize );
58047 assert( pPager->dbOrigSize==pPager->dbHintSize );
58051 assert( p->eLock==EXCLUSIVE_LOCK );
58052 assert( pPager->errCode==SQLITE_OK );
58054 assert( p->eLock>=EXCLUSIVE_LOCK );
58055 assert( isOpen(p->jfd)
58056 || p->journalMode==PAGER_JOURNALMODE_OFF
58057 || p->journalMode==PAGER_JOURNALMODE_WAL
58058 || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
58060 assert( pPager->dbOrigSize<=pPager->dbHintSize );
58064 assert( p->eLock==EXCLUSIVE_LOCK );
58065 assert( pPager->errCode==SQLITE_OK );
58067 assert( isOpen(p->jfd)
58068 || p->journalMode==PAGER_JOURNALMODE_OFF
58069 || p->journalMode==PAGER_JOURNALMODE_WAL
58070 || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
58079 assert( pPager->errCode!=SQLITE_OK );
58080 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
58113 , p->zFilename
58114 , p->eState==PAGER_OPEN ? "OPEN" :
58115 p->eState==PAGER_READER ? "READER" :
58116 p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
58117 p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
58118 p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
58119 p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
58120 p->eState==PAGER_ERROR ? "ERROR" : "?error?"
58121 , (int)p->errCode
58122 , p->eLock==NO_LOCK ? "NO_LOCK" :
58123 p->eLock==RESERVED_LOCK ? "RESERVED" :
58124 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
58125 p->eLock==SHARED_LOCK ? "SHARED" :
58126 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
58127 , p->exclusiveMode ? "exclusive" : "normal"
58128 , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
58129 p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
58130 p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
58131 p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
58132 p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
58133 p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
58134 , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
58135 , p->journalOff, p->journalHdr
58136 , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
58155 if( pPager->errCode ){
58156 pPager->xGet = getPageError;
58159 pPager->xGet = getPageMMap;
58162 pPager->xGet = getPageNormal;
58167 ** Return true if it is necessary to write page *pPg into the sub-journal.
58168 ** A page needs to be written into the sub-journal if there exists one
58171 ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
58172 ** * The bit corresponding to the page-number is not set in
58176 Pager *pPager = pPg->pPager;
58178 Pgno pgno = pPg->pgno;
58180 for(i=0; i<pPager->nSavepoint; i++){
58181 p = &pPager->aSavepoint[i];
58182 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
58183 for(i=i+1; i<pPager->nSavepoint; i++){
58184 pPager->aSavepoint[i].bTruncateOnRelease = 0;
58197 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
58202 ** Read a 32-bit integer from the given file descriptor. Store the integer
58206 ** All values are stored on disk as big-endian.
58218 ** Write a 32-bit integer into a string buffer in big-endian byte order.
58224 ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
58245 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
58248 if( isOpen(pPager->fd) ){
58249 assert( pPager->eLock>=eLock );
58250 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
58251 if( pPager->eLock!=UNKNOWN_LOCK ){
58252 pPager->eLock = (u8)eLock;
58256 pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */
58274 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
58275 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
58276 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
58277 pPager->eLock = (u8)eLock;
58285 ** This function determines whether or not the atomic-write or
58286 ** atomic-batch-write optimizations can be used with this pager. The
58287 ** atomic-write optimization can be used if:
58297 ** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
58298 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
58310 assert( isOpen(pPager->fd) );
58311 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
58317 if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
58318 return -1;
58324 int nSector = pPager->sectorSize;
58325 int szPage = pPager->pageSize;
58347 ** Return a 32-bit hash of the page data for pPage.
58358 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
58361 pPage->pageHash = pager_pagehash(pPage);
58367 ** that the page is either dirty or still matches the calculated page-hash.
58371 Pager *pPager = pPg->pPager;
58372 assert( pPager->eState!=PAGER_ERROR );
58373 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
58385 ** This function attempts to read a super-journal file name from the
58388 ** used to store a super-journal file name at the end of a journal file.
58392 ** enough space to write the super-journal name). If the super-journal
58394 ** nul-terminator), then this is handled as if no super-journal name
58397 ** If a super-journal file name is present at the end of the journal
58399 ** nul-terminator byte is appended to the buffer following the
58400 ** super-journal file name.
58402 ** If it is determined that no super-journal file name is present
58410 u32 len; /* Length in bytes of super-journal name */
58419 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
58421 || len>szJ-16
58423 || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
58424 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
58426 || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len))
58431 /* See if the checksum matches the super-journal name */
58433 cksum -= zSuper[u];
58437 ** containing the super-journal filename is corrupted. This means
58439 ** super-journal filename.
58451 ** following the value in pPager->journalOff, assuming a sector
58452 ** size of pPager->sectorSize bytes.
58457 ** ---------------------------------------
58460 ** 100 512
58466 i64 c = pPager->journalOff;
58468 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
58472 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
58479 ** This function is a no-op if the journal file has not been written to
58482 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
58484 ** zero the 28-byte header at the start of the journal file. In either case,
58485 ** if the pager is not in no-sync mode, sync the journal file immediately
58488 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
58499 assert( isOpen(pPager->jfd) );
58500 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
58501 if( pPager->journalOff ){
58502 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
58506 rc = sqlite3OsTruncate(pPager->jfd, 0);
58509 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
58511 if( rc==SQLITE_OK && !pPager->noSync ){
58512 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
58523 rc = sqlite3OsFileSize(pPager->jfd, &sz);
58525 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
58538 ** - 8 bytes: Magic identifying journal format.
58539 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
58540 ** - 4 bytes: Random number used for page hash.
58541 ** - 4 bytes: Initial database page count.
58542 ** - 4 bytes: Sector size used by the process that wrote this journal.
58543 ** - 4 bytes: Database page size.
58545 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
58549 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
58550 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
58554 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
58564 for(ii=0; ii<pPager->nSavepoint; ii++){
58565 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
58566 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
58570 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
58573 ** Write the nRec Field - the number of page records that follow this
58576 ** if in full-sync mode), the zero is overwritten with the true number
58586 ** * When the pager is in no-sync mode. Corruption can follow a
58592 assert( isOpen(pPager->fd) || pPager->noSync );
58593 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
58594 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
58604 /* The random check-hash initializer */
58605 if( pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
58606 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
58620 sqlite3OsFileSize(pPager->jfd, &sz);
58622 assert( pPager->journalOff==journalHdrOffset(pPager) );
58623 assert( sqlite3JournalIsInMemory(pPager->jfd) );
58626 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
58629 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
58631 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
58634 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
58642 nHeader-(sizeof(aJournalMagic)+20));
58653 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
58656 ** The loop is required here in case the sector-size is larger than the
58662 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
58663 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
58664 assert( pPager->journalHdr <= pPager->journalOff );
58665 pPager->journalOff += nHeader;
58675 ** pPager->journalOff. See comments above function writeJournalHdr() for
58680 ** database before the transaction began, in pages. Also, pPager->cksumInit
58699 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
58705 pPager->journalOff = journalHdrOffset(pPager);
58706 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
58709 iHdrOff = pPager->journalOff;
58716 if( isHot || iHdrOff!=pPager->journalHdr ){
58717 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
58726 /* Read the first three 32-bit fields of the journal header: The nRec
58727 ** field, the checksum-initializer and the database size at the start
58730 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
58731 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
58732 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
58737 if( pPager->journalOff==0 ){
58738 u32 iPageSize; /* Page-size field of journal header */
58739 u32 iSectorSize; /* Sector-size field of journal header */
58741 /* Read the page-size and sector-size journal header fields. */
58742 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
58743 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
58748 /* Versions of SQLite prior to 3.5.8 set the page-size field of the
58753 iPageSize = pPager->pageSize;
58756 /* Check that the values read from the page-size and sector-size fields
58763 || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
58765 /* If the either the page-size or sector-size in the journal-header is
58766 ** invalid, then the process that wrote the journal-header must have
58773 /* Update the page-size to match the value read from the journal.
58777 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
58780 /* Update the assumed sector-size to match the value used by
58786 pPager->sectorSize = iSectorSize;
58789 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
58795 ** Write the supplied super-journal name into the journal file for pager
58796 ** pPager at the current location. The super-journal name must be the last
58797 ** thing written to a journal file. If the pager is in full-sync mode, the
58802 ** + N bytes: super-journal filename in utf-8.
58803 ** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator).
58804 ** + 4 bytes: super-journal name checksum.
58807 ** The super-journal page checksum is the sum of the bytes in the super-journal
58808 ** name, where each byte is interpreted as a signed 8-bit integer.
58811 ** this call is a no-op.
58820 assert( pPager->setSuper==0 );
58824 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
58825 || !isOpen(pPager->jfd)
58829 pPager->setSuper = 1;
58830 assert( pPager->journalHdr <= pPager->journalOff );
58837 /* If in full-sync mode, advance to the next disk sector before writing
58838 ** the super-journal name. This is in case the previous page written to
58841 if( pPager->fullSync ){
58842 pPager->journalOff = journalHdrOffset(pPager);
58844 iHdrOff = pPager->journalOff;
58846 /* Write the super-journal data to the end of the journal file. If
58849 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_SJ_PGNO(pPager))))
58850 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
58851 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
58852 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
58853 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
58858 pPager->journalOff += (nSuper+20);
58860 /* If the pager is in persistent-journal mode, then the physical
58861 ** journal-file may extend past the end of the super-journal name
58863 ** dangerous because the code to rollback a hot-journal file
58864 ** will not be able to find the super-journal name to determine
58870 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
58871 && jrnlSize>pPager->journalOff
58873 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
58879 ** Discard the entire contents of the in-memory page-cache.
58882 pPager->iDataVersion++;
58883 sqlite3BackupRestart(pPager->pBackup);
58884 sqlite3PcacheClear(pPager->pPCache);
58888 ** Return the pPager->iDataVersion value
58891 return pPager->iDataVersion;
58896 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
58901 for(ii=0; ii<pPager->nSavepoint; ii++){
58902 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
58904 if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
58905 sqlite3OsClose(pPager->sjfd);
58907 sqlite3_free(pPager->aSavepoint);
58908 pPager->aSavepoint = 0;
58909 pPager->nSavepoint = 0;
58910 pPager->nSubRec = 0;
58922 for(ii=0; ii<pPager->nSavepoint; ii++){
58923 PagerSavepoint *p = &pPager->aSavepoint[ii];
58924 if( pgno<=p->nOrig ){
58925 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
58934 ** This function is a no-op if the pager is in exclusive mode and not
58938 ** If the pager is not in exclusive-access mode, the database file is
58939 ** completely unlocked. If the file is unlocked and the file-system does
58945 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
58946 ** or not, any journal file left in the file-system will be treated
58947 ** as a hot-journal and rolled back the next time a read-transaction
58952 assert( pPager->eState==PAGER_READER
58953 || pPager->eState==PAGER_OPEN
58954 || pPager->eState==PAGER_ERROR
58957 sqlite3BitvecDestroy(pPager->pInJournal);
58958 pPager->pInJournal = 0;
58962 assert( !isOpen(pPager->jfd) );
58963 sqlite3WalEndReadTransaction(pPager->pWal);
58964 pPager->eState = PAGER_OPEN;
58965 }else if( !pPager->exclusiveMode ){
58967 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
58981 || 1!=(pPager->journalMode & 5)
58983 sqlite3OsClose(pPager->jfd);
58992 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
58993 pPager->eLock = UNKNOWN_LOCK;
58997 ** without clearing the error code. This is intentional - the error
59000 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
59001 pPager->eState = PAGER_OPEN;
59007 ** normal and exclusive-locking mode.
59009 assert( pPager->errCode==SQLITE_OK || !MEMDB );
59010 if( pPager->errCode ){
59011 if( pPager->tempFile==0 ){
59013 pPager->changeCountDone = 0;
59014 pPager->eState = PAGER_OPEN;
59016 pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
59018 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
59019 pPager->errCode = SQLITE_OK;
59023 pPager->journalOff = 0;
59024 pPager->journalHdr = 0;
59025 pPager->setSuper = 0;
59032 ** the error-code about to be returned by a pager API function. The
59036 ** IOERR sub-codes, the pager enters the ERROR state and the error code
59040 ** The ERROR state indicates that the contents of the pager-cache
59042 ** the contents of the pager-cache. If a transaction was active when
59045 ** it were a hot-journal).
59051 pPager->errCode==SQLITE_FULL ||
59052 pPager->errCode==SQLITE_OK ||
59053 (pPager->errCode & 0xff)==SQLITE_IOERR
59056 pPager->errCode = rc;
59057 pPager->eState = PAGER_ERROR;
59073 ** * For non-TEMP databases, always sync to disk. This is necessary
59082 if( pPager->tempFile==0 ) return 1;
59084 if( !isOpen(pPager->fd) ) return 0;
59085 return (sqlite3PCachePercentDirty(pPager->pPCache)>=25);
59091 ** after rollback of a hot-journal, or if an error occurs while opening
59092 ** the journal file or writing the very first journal-header of a
59097 ** exclusive than a RESERVED lock, it is a no-op.
59103 ** transaction. Nor will it be considered to be a hot-journal by this
59106 ** the current journal-mode (Pager.journalMode value), as follows:
59110 ** in-memory journal.
59129 ** If running in non-exclusive rollback mode, the lock on the file is
59147 ** is no write-transaction active but a RESERVED or greater lock is
59150 ** 1. After a successful hot-journal rollback, it is called with
59155 ** read-transaction, this function is called with eState==PAGER_READER
59156 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
59159 assert( pPager->eState!=PAGER_ERROR );
59160 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
59165 assert( isOpen(pPager->jfd) || pPager->pInJournal==0
59166 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
59168 if( isOpen(pPager->jfd) ){
59172 if( sqlite3JournalIsInMemory(pPager->jfd) ){
59173 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
59174 sqlite3OsClose(pPager->jfd);
59175 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
59176 if( pPager->journalOff==0 ){
59179 rc = sqlite3OsTruncate(pPager->jfd, 0);
59180 if( rc==SQLITE_OK && pPager->fullSync ){
59186 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
59189 pPager->journalOff = 0;
59190 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
59191 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
59193 rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile);
59194 pPager->journalOff = 0;
59197 ** a hot-journal was just rolled back. In this case the journal
59199 ** the database file, it will do so using an in-memory journal.
59201 int bDelete = !pPager->tempFile;
59202 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
59203 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
59204 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
59205 || pPager->journalMode==PAGER_JOURNALMODE_WAL
59207 sqlite3OsClose(pPager->jfd);
59209 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
59215 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
59216 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
59219 p->pageHash = 0;
59225 sqlite3BitvecDestroy(pPager->pInJournal);
59226 pPager->pInJournal = 0;
59227 pPager->nRec = 0;
59230 sqlite3PcacheCleanAll(pPager->pPCache);
59232 sqlite3PcacheClearWritable(pPager->pPCache);
59234 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
59238 /* Drop the WAL write-lock, if any. Also, if the connection was in
59242 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
59244 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
59245 /* This branch is taken when committing a transaction in rollback-journal
59251 assert( pPager->eLock==EXCLUSIVE_LOCK );
59252 rc = pager_truncate(pPager, pPager->dbSize);
59256 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
59260 if( !pPager->exclusiveMode
59261 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
59265 pPager->eState = PAGER_READER;
59266 pPager->setSuper = 0;
59280 ** call to pager_unlock() will discard all in-memory pages, unlock
59282 ** means that there is a hot-journal left in the file-system, the next
59292 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
59294 if( pPager->eState>=PAGER_WRITER_LOCKED ){
59298 }else if( !pPager->exclusiveMode ){
59299 assert( pPager->eState==PAGER_READER );
59302 }else if( pPager->eState==PAGER_ERROR
59303 && pPager->journalMode==PAGER_JOURNALMODE_MEMORY
59304 && isOpen(pPager->jfd)
59306 /* Special case for a ROLLBACK due to I/O error with an in-memory
59309 int errCode = pPager->errCode;
59310 u8 eLock = pPager->eLock;
59311 pPager->eState = PAGER_OPEN;
59312 pPager->errCode = SQLITE_OK;
59313 pPager->eLock = EXCLUSIVE_LOCK;
59315 pPager->errCode = errCode;
59316 pPager->eLock = eLock;
59322 ** Parameter aData must point to a buffer of pPager->pageSize bytes
59324 ** page of data and the current value of pPager->cksumInit.
59327 ** random initial value (pPager->cksumInit) and every 200th byte
59328 ** of the page data, starting with byte offset (pPager->pageSize%200).
59329 ** Each byte is interpreted as an 8-bit unsigned integer.
59341 u32 cksum = pPager->cksumInit; /* Checksum value to return */
59342 int i = pPager->pageSize-200; /* Loop counter */
59345 i -= 200;
59352 ** from the sub-journal (if isMainJrnl==0) and playback that page.
59356 ** The main rollback journal uses checksums - the statement journal does
59359 ** If the page number of the page record read from the (sub-)journal file
59369 ** If the page record is successfully read from the (sub-)journal file
59371 ** while reading the record from the (sub-)journal file or while writing
59373 ** is successfully read from the (sub-)journal file but appears to be
59377 ** * If the record page-number is illegal (0 or PAGER_SJ_PGNO), or
59391 int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
59404 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
59405 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
59407 aData = pPager->pTmpSpace;
59413 ** a hot-journal rollback. If it is a hot-journal rollback, the pager
59414 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
59415 ** only reads from the main journal, not the sub-journal.
59417 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
59418 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
59420 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
59422 /* Read the page number and page data from the journal or sub-journal
59425 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
59428 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
59430 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
59441 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
59445 rc = read32bits(jfd, (*pOffset)-4, &cksum);
59461 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
59462 pPager->nReserve = ((u8*)aData)[20];
59469 ** An exception to the above rule: If the database is in no-sync mode
59479 ** a hot-journal rollback, it is guaranteed that the page-cache is empty
59496 ** 2008-04-14: When attempting to vacuum a corrupt database file, it
59506 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
59508 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
59509 (isMainJrnl?"main-journal":"sub-journal")
59512 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
59514 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
59516 if( isOpen(pPager->fd)
59517 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
59520 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
59521 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
59525 ** This is usually safe even for an encrypted database - as the data
59527 ** is if the data was just read from an in-memory sub-journal. In that
59530 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
59532 if( pgno>pPager->dbFileSize ){
59533 pPager->dbFileSize = pgno;
59535 if( pPager->pBackup ){
59536 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
59540 ** the database and the page is not in-memory, there is a potential
59541 ** problem. When the page is next fetched by the b-tree layer, it
59547 ** if the page is on the free-list at the start of the transaction, then
59550 ** The solution is to add an in-memory page to the cache containing
59551 ** the data just read from the sub-journal. Mark the page as dirty
59552 ** and if the pager requires a journal-sync, then mark the page as
59553 ** requiring a journal-sync before it is written.
59556 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
59557 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
59559 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
59560 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
59572 pData = pPg->pData;
59573 memcpy(pData, (u8*)aData, pPager->pageSize);
59574 pPager->xReiniter(pPg);
59584 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
59592 ** Parameter zSuper is the name of a super-journal file. A single journal
59593 ** file that referred to the super-journal file has just been rolled back.
59594 ** This routine checks if it is possible to delete the super-journal file,
59600 ** When a super-journal file is created, it is populated with the names
59601 ** of all of its child journals, one after another, formatted as utf-8
59603 ** nul-terminator byte (0x00). i.e. the entire contents of a super-journal
59606 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
59608 ** A super-journal file may only be deleted once all of its child
59611 ** This function reads the contents of the super-journal file into
59616 ** * if the child journal contains a reference to super-journal
59622 ** the file-system using sqlite3OsDelete().
59630 ** the entire contents of the super-journal file. This could be
59631 ** a couple of kilobytes or so - potentially larger than the page
59635 sqlite3_vfs *pVfs = pPager->pVfs;
59637 sqlite3_file *pSuper; /* Malloc'd super-journal file descriptor */
59638 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
59639 char *zSuperJournal = 0; /* Contents of super-journal file */
59640 i64 nSuperJournal; /* Size of super-journal file */
59642 char *zSuperPtr; /* Space to hold super-journal filename */
59647 ** If successful, open the super-journal file for reading.
59649 pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
59656 pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile);
59660 /* Load the entire super-journal file into space obtained from
59662 ** sufficient space (in zSuperPtr) to hold the names of super-journal
59663 ** files extracted from regular rollback-journals.
59667 nSuperPtr = pVfs->mxPathname+1;
59682 while( (zJournal-zSuperJournal)<nSuperJournal ){
59689 /* One of the journals pointed to by the super-journal exists.
59690 ** Open it and check if it points at the super-journal. If
59691 ** so, return without deleting the super-journal file.
59711 /* We have a match. Do not delete the super-journal file. */
59734 ** file in the file-system. This only happens when committing a transaction,
59735 ** or rolling back a transaction (including rolling back a hot-journal).
59738 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
59739 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
59754 assert( pPager->eState!=PAGER_ERROR );
59755 assert( pPager->eState!=PAGER_READER );
59759 if( isOpen(pPager->fd)
59760 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
59763 int szPage = pPager->pageSize;
59764 assert( pPager->eLock==EXCLUSIVE_LOCK );
59766 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
59770 rc = sqlite3OsTruncate(pPager->fd, newSize);
59772 char *pTmp = pPager->pTmpSpace;
59774 testcase( (newSize-szPage) == currentSize );
59775 testcase( (newSize-szPage) > currentSize );
59776 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &newSize);
59777 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
59780 pPager->dbFileSize = nPage;
59788 ** Return a sanitized version of the sector-size of OS file pFile. The
59807 ** super-journal pointers within created journal files.
59811 ** Otherwise, for non-temporary files, the effective sector size is
59818 ** pPager->sectorSize is to define the "blast radius" of bytes that
59826 assert( isOpen(pPager->fd) || pPager->tempFile );
59828 if( pPager->tempFile
59829 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
59835 pPager->sectorSize = 512;
59837 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
59848 ** (2) 4 byte big-endian integer which is the number of valid page records
59851 ** (3) 4 byte big-endian integer which is the initial value for the
59855 ** (5) 4 byte big-endian integer which is the sector size. The header
59857 ** (6) 4 byte big-endian integer which is the page size.
59861 ** + pPager->pageSize bytes of data.
59878 ** no-sync option for the journal. A power failure could lead to corruption
59882 ** If the file opened as the journal file is not a well-formed
59888 ** If an I/O or malloc() error occurs, the journal-file is not deleted
59899 sqlite3_vfs *pVfs = pPager->pVfs;
59906 char *zSuper = 0; /* Name of super-journal file if any */
59909 u32 savedPageSize = pPager->pageSize;
59914 assert( isOpen(pPager->jfd) );
59915 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
59920 /* Read the super-journal name from the journal, if it is present.
59921 ** If a super-journal file name is specified, but the file is not
59927 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
59931 zSuper = pPager->pTmpSpace;
59932 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
59940 pPager->journalOff = 0;
59962 ** working in no-sync mode. This means that the rest of the journal
59967 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
59968 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
59986 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
59987 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
59993 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
59998 pPager->dbSize = mxPg;
59999 if( pPager->mxPgno<mxPg ){
60000 pPager->mxPgno = mxPg;
60012 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
60017 pPager->journalOff = szJ;
60043 rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1);
60047 ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
60051 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
60055 ** malloc error that occurred after the change-counter was updated but
60056 ** before the transaction was committed, then the change-counter
60059 ** update the change-counter at all. This may lead to cache inconsistency
60063 pPager->changeCountDone = pPager->tempFile;
60066 /* Leave 4 bytes of space before the super-journal filename in memory.
60070 zSuper = &pPager->pTmpSpace[4];
60071 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
60075 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
60084 /* If there was a super-journal and this routine will return success,
60085 ** see if it is possible to delete the super-journal.
60087 assert( zSuper==&pPager->pTmpSpace[4] );
60088 memset(pPager->pTmpSpace, 0, 4);
60094 nPlayback, pPager->zJournal);
60109 ** pPg->pData. A shared lock or greater must be held on the database
60119 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
60125 assert( pPager->eState>=PAGER_READER && !MEMDB );
60126 assert( isOpen(pPager->fd) );
60129 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
60133 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
60137 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
60138 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
60144 if( pPg->pgno==1 ){
60151 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
60158 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
60160 u8 *dbFileVers = &((u8*)pPg->pData)[24];
60161 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
60165 PAGER_INCR(pPager->nRead);
60166 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
60168 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
60174 ** Update the value of the change-counter at offsets 24 and 92 in
60178 ** routine which only updates the change-counter if the update is actually
60179 ** needed, as determined by the pPager->changeCountDone state variable.
60186 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
60187 put32bits(((char*)pPg->pData)+24, change_counter);
60192 put32bits(((char*)pPg->pData)+92, change_counter);
60193 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
60222 pPager->xReiniter(pPg);
60236 sqlite3BackupRestart(pPager->pBackup);
60255 pPager->dbSize = pPager->dbOrigSize;
60256 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
60257 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60259 PgHdr *pNext = pList->pDirty;
60260 rc = pagerUndoCallback((void *)pPager, pList->pgno);
60286 assert( pPager->pWal );
60290 for(p=pList; p && p->pDirty; p=p->pDirty){
60291 assert( p->pgno < p->pDirty->pgno );
60295 assert( pList->pDirty==0 || isCommit );
60303 for(p=pList; (*ppNext = p)!=0; p=p->pDirty){
60304 if( p->pgno<=nTruncate ){
60305 ppNext = &p->pDirty;
60313 pPager->aStat[PAGER_STAT_WRITE] += nList;
60315 if( pList->pgno==1 ) pager_write_changecounter(pList);
60316 rc = sqlite3WalFrames(pPager->pWal,
60317 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
60319 if( rc==SQLITE_OK && pPager->pBackup ){
60320 for(p=pList; p; p=p->pDirty){
60321 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
60326 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60327 for(p=pList; p; p=p->pDirty){
60348 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
60355 sqlite3WalEndReadTransaction(pPager->pWal);
60357 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
60360 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
60379 /* Query the WAL sub-system for the database size. The WalDbsize()
60382 ** available from the WAL sub-system if the log file is empty or
60385 assert( pPager->eState==PAGER_OPEN );
60386 assert( pPager->eLock>=SHARED_LOCK );
60387 assert( isOpen(pPager->fd) );
60388 assert( pPager->tempFile==0 );
60389 nPage = sqlite3WalDbsize(pPager->pWal);
60392 ** WAL sub-system, determine the page count based on the size of
60394 ** integer multiple of the page-size, round up the result.
60396 if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
60398 int rc = sqlite3OsFileSize(pPager->fd, &n);
60402 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
60409 if( nPage>pPager->mxPgno ){
60410 pPager->mxPgno = (Pgno)nPage;
60419 ** Check if the *-wal file that corresponds to the database opened by pPager
60420 ** exists if the database is not empty, or verify that the *-wal file does
60423 ** If the database is not empty and the *-wal file exists, open the pager
60424 ** in WAL mode. If the database is empty or if no *-wal file exists and
60432 ** a WAL on a none-empty database, this ensures there is no race condition
60438 assert( pPager->eState==PAGER_OPEN );
60439 assert( pPager->eLock>=SHARED_LOCK );
60441 if( !pPager->tempFile ){
60444 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
60453 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
60455 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
60458 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
60459 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
60469 ** the entire super-journal file. The case pSavepoint==NULL occurs when
60473 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
60486 ** * Pages are then played back from the sub-journal file, starting
60500 ** (or transaction). No page with a page-number greater than this value
60505 i64 iHdrOff; /* End of first segment of main-journal records */
60509 assert( pPager->eState!=PAGER_ERROR );
60510 assert( pPager->eState>=PAGER_WRITER_LOCKED );
60514 pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
60523 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
60524 pPager->changeCountDone = pPager->tempFile;
60530 /* Use pPager->journalOff as the effective size of the main rollback
60533 ** past pPager->journalOff is off-limits to us.
60535 szJ = pPager->journalOff;
60541 ** greater than the current database size (pPager->dbSize) but those
60546 iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
60547 pPager->journalOff = pSavepoint->iOffset;
60548 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
60549 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
60553 pPager->journalOff = 0;
60558 ** of the main journal file. Continue to skip out-of-range pages and
60561 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
60569 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
60574 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
60576 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
60578 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
60579 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
60583 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
60585 /* Finally, rollback pages from the sub-journal. Page that were
60587 ** will be skipped. Out-of-range pages are also skipped.
60591 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
60594 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
60596 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
60597 assert( offset==(i64)ii*(4+pPager->pageSize) );
60605 pPager->journalOff = szJ;
60612 ** Change the maximum number of in-memory pages that are allowed
60616 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
60620 ** Change the maximum number of in-memory pages that are allowed
60624 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
60632 sqlite3_file *fd = pPager->fd;
60633 if( isOpen(fd) && fd->pMethods->iVersion>=3 ){
60635 sz = pPager->szMmap;
60636 pPager->bUseFetch = (sz>0);
60638 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
60647 pPager->szMmap = szMmap;
60655 sqlite3PcacheShrink(pPager->pPCache);
60677 ** database (with some additional information - the nRec field
60678 ** of the journal header - being written in between the two
60688 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
60699 ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
60714 if( pPager->tempFile ){
60715 pPager->noSync = 1;
60716 pPager->fullSync = 0;
60717 pPager->extraSync = 0;
60719 pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0;
60720 pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
60721 pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
60723 if( pPager->noSync ){
60724 pPager->syncFlags = 0;
60726 pPager->syncFlags = SQLITE_SYNC_FULL;
60728 pPager->syncFlags = SQLITE_SYNC_NORMAL;
60730 pPager->walSyncFlags = (pPager->syncFlags<<2);
60731 if( pPager->fullSync ){
60732 pPager->walSyncFlags |= pPager->syncFlags;
60734 if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){
60735 pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2);
60738 pPager->doNotSpill &= ~SPILLFLAG_OFF;
60740 pPager->doNotSpill |= SPILLFLAG_OFF;
60781 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
60789 ** The pager invokes the busy-handler if sqlite3OsLock() returns
60790 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
60794 ** (which occurs during hot-journal rollback). Summary:
60797 ** --------------------------------------------------------
60798 ** NO_LOCK -> SHARED_LOCK | Yes
60799 ** SHARED_LOCK -> RESERVED_LOCK | No
60800 ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
60801 ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
60803 ** If the busy-handler callback returns non-zero, the lock is
60809 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
60813 pPager->xBusyHandler = xBusyHandler;
60814 pPager->pBusyHandlerArg = pBusyHandlerArg;
60815 ap = (void **)&pPager->xBusyHandler;
60818 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
60826 ** is a no-op. The value returned is the error state error code (i.e.
60827 ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
60836 ** * the database is either not an in-memory database or it is
60837 ** an in-memory database that currently consists of zero pages.
60861 ** is a no-op for that case anyhow.
60866 if( (pPager->memDb==0 || pPager->dbSize==0)
60867 && sqlite3PcacheRefCount(pPager->pPCache)==0
60868 && pageSize && pageSize!=(u32)pPager->pageSize
60873 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
60874 rc = sqlite3OsFileSize(pPager->fd, &nByte);
60877 /* 8 bytes of zeroed overrun space is sufficient so that the b-tree
60889 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
60892 sqlite3PageFree(pPager->pTmpSpace);
60893 pPager->pTmpSpace = pNew;
60894 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
60895 pPager->pageSize = pageSize;
60896 pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1;
60902 *pPageSize = pPager->pageSize;
60904 if( nReserve<0 ) nReserve = pPager->nReserve;
60906 pPager->nReserve = (i16)nReserve;
60921 return pPager->pTmpSpace;
60933 pPager->mxPgno = mxPage;
60935 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
60936 /* assert( pPager->mxPgno>=pPager->dbSize ); */
60940 return pPager->mxPgno;
60948 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
60957 sqlite3_io_error_pending = -1;
60984 assert( isOpen(pPager->fd) || pPager->tempFile );
60992 if( isOpen(pPager->fd) ){
60994 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
61003 ** This function may only be called when a read-transaction is open on
61006 ** However, if the file is between 1 and <page-size> bytes in size, then
61010 assert( pPager->eState>=PAGER_READER );
61011 assert( pPager->eState!=PAGER_WRITER_FINISHED );
61012 *pnPage = (int)pPager->dbSize;
61018 ** a similar or greater lock is already held, this function is a no-op
61033 /* Check that this is either a no-op (because the requested lock is
61034 ** already held), or one of the transitions that the busy-handler
61038 assert( (pPager->eLock>=locktype)
61039 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
61040 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
61045 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
61051 ** following is true for all dirty pages currently in the page-cache:
61057 ** be necessary to write the current content out to the sub-journal.
61066 ** sub-journal rolled back the content could not be restored and the
61072 Pager *pPager = pPg->pPager;
61073 assert( pPg->flags&PGHDR_DIRTY );
61074 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
61075 Pgno pgno = pPg->pgno;
61077 for(i=0; i<pPg->pPager->nSavepoint; i++){
61078 PagerSavepoint *p = &pPager->aSavepoint[i];
61079 assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,pgno) );
61084 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
61091 ** Truncate the in-memory database file image to nPage pages. This
61102 assert( pPager->dbSize>=nPage || CORRUPT_DB );
61103 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
61104 pPager->dbSize = nPage;
61119 ** This function is called before attempting a hot-journal rollback. It
61120 ** syncs the journal file to disk, then sets pPager->journalHdr to the
61124 ** Syncing a hot-journal to disk before attempting to roll it back ensures
61125 ** that if a power-failure occurs during the rollback, the process that
61134 if( !pPager->noSync ){
61135 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
61138 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
61162 if( pPager->pMmapFreelist ){
61163 *ppPage = p = pPager->pMmapFreelist;
61164 pPager->pMmapFreelist = p->pDirty;
61165 p->pDirty = 0;
61166 assert( pPager->nExtra>=8 );
61167 memset(p->pExtra, 0, 8);
61169 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
61171 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
61174 p->pExtra = (void *)&p[1];
61175 p->flags = PGHDR_MMAP;
61176 p->nRef = 1;
61177 p->pPager = pPager;
61180 assert( p->pExtra==(void *)&p[1] );
61181 assert( p->pPage==0 );
61182 assert( p->flags==PGHDR_MMAP );
61183 assert( p->pPager==pPager );
61184 assert( p->nRef==1 );
61186 p->pgno = pgno;
61187 p->pData = pData;
61188 pPager->nMmapOut++;
61199 Pager *pPager = pPg->pPager;
61200 pPager->nMmapOut--;
61201 pPg->pDirty = pPager->pMmapFreelist;
61202 pPager->pMmapFreelist = pPg;
61204 assert( pPager->fd->pMethods->iVersion>=3 );
61205 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
61214 for(p=pPager->pMmapFreelist; p; p=pNext){
61215 pNext = p->pDirty;
61222 ** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error
61229 if( pPager->tempFile ) return SQLITE_OK;
61230 if( pPager->dbSize==0 ) return SQLITE_OK;
61231 assert( pPager->zFilename && pPager->zFilename[0] );
61232 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
61234 /* If the HAS_MOVED file-control is unimplemented, assume that the file
61260 u8 *pTmp = (u8*)pPager->pTmpSpace;
61266 /* pPager->errCode = 0; */
61267 pPager->exclusiveMode = 0;
61271 assert( db || pPager->pWal==0 );
61272 if( db && 0==(db->flags & SQLITE_NoCkptOnClose)
61277 sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
61278 pPager->pWal = 0;
61293 ** back or finalize it. The next database user will have to do hot-journal
61296 if( isOpen(pPager->jfd) ){
61305 sqlite3OsClose(pPager->jfd);
61306 sqlite3OsClose(pPager->fd);
61308 sqlite3PcacheClose(pPager->pPCache);
61309 assert( !pPager->aSavepoint && !pPager->pInJournal );
61310 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
61321 return pPg->pgno;
61335 ** disk and can be restored in the event of a hot-journal rollback.
61337 ** If the Pager.noSync flag is set, then this function is a no-op.
61338 ** Otherwise, the actions required depend on the journal-mode and the
61339 ** device characteristics of the file-system, as follows:
61341 ** * If the journal file is an in-memory journal file, no action need
61347 ** been written following it. If the pager is operating in full-sync
61353 ** Or, in pseudo-code:
61355 ** if( NOT <in-memory journal> ){
61357 ** if( <full-sync mode> ) xSync(<journal file>);
61370 assert( pPager->eState==PAGER_WRITER_CACHEMOD
61371 || pPager->eState==PAGER_WRITER_DBMOD
61379 if( !pPager->noSync ){
61380 assert( !pPager->tempFile );
61381 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
61382 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
61383 assert( isOpen(pPager->jfd) );
61387 ** that wrote to this database was operating in persistent-journal
61390 ** file happens to be a journal-header (written as part of the
61391 ** previous connection's transaction), and a crash or power-failure
61395 ** hot-journal rollback following recovery. It may roll back all
61397 ** out-of-date data that follows it. Database corruption.
61413 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
61416 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
61419 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
61426 ** full-synchronous mode, sync the journal first. This ensures that
61436 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
61439 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
61442 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
61444 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
61451 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
61452 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
61457 pPager->journalHdr = pPager->journalOff;
61459 pPager->nRec = 0;
61464 pPager->journalHdr = pPager->journalOff;
61472 sqlite3PcacheClearSyncFlags(pPager->pPCache);
61473 pPager->eState = PAGER_WRITER_DBMOD;
61481 ** in-memory pages in the list to the database file. The argument may
61483 ** a no-op.
61490 ** If the pager is a temp-file pager and the actual file-system file
61515 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
61516 assert( pPager->eLock==EXCLUSIVE_LOCK );
61517 assert( isOpen(pPager->fd) || pList->pDirty==0 );
61519 /* If the file is a temp-file has not yet been opened, open it now. It
61521 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
61523 if( !isOpen(pPager->fd) ){
61524 assert( pPager->tempFile && rc==SQLITE_OK );
61525 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
61531 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
61533 && pPager->dbHintSize<pPager->dbSize
61534 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
61536 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
61537 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
61538 pPager->dbHintSize = pPager->dbSize;
61542 Pgno pgno = pList->pgno;
61546 ** make the file smaller (presumably by auto-vacuum code). Do not write
61552 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
61553 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
61556 assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
61557 if( pList->pgno==1 ) pager_write_changecounter(pList);
61559 pData = pList->pData;
61562 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
61569 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
61571 if( pgno>pPager->dbFileSize ){
61572 pPager->dbFileSize = pgno;
61574 pPager->aStat[PAGER_STAT_WRITE]++;
61577 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
61587 pList = pList->pDirty;
61594 ** Ensure that the sub-journal file is open. If it is already open, this
61595 ** function is a no-op.
61603 if( !isOpen(pPager->sjfd) ){
61608 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
61609 nStmtSpill = -1;
61611 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
61617 ** Append a record of the current state of page pPg to the sub-journal.
61619 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
61623 ** error code if the attempt to write to the sub-journal fails, or
61629 Pager *pPager = pPg->pPager;
61630 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
61632 /* Open the sub-journal, if it has not already been opened */
61633 assert( pPager->useJournal );
61634 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
61635 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
61638 || pPg->pgno>pPager->dbOrigSize
61642 /* If the sub-journal was opened successfully (or was already open),
61645 void *pData = pPg->pData;
61646 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
61649 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
61650 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
61652 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
61657 pPager->nSubRec++;
61658 assert( pPager->nSavepoint>0 );
61659 rc = addToSavepointBitvecs(pPager, pPg->pgno);
61674 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
61694 assert( pPg->pPager==pPager );
61695 assert( pPg->flags&PGHDR_DIRTY );
61713 if( NEVER(pPager->errCode) ) return SQLITE_OK;
61714 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
61715 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
61716 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
61717 if( pPager->doNotSpill
61718 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
61719 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
61724 pPager->aStat[PAGER_STAT_SPILL]++;
61725 pPg->pDirty = 0;
61735 if( pPager->tempFile==0 ){
61736 rc = sqlite3JournalCreate(pPager->jfd);
61742 if( pPg->flags&PGHDR_NEED_SYNC
61743 || pPager->eState==PAGER_WRITER_CACHEMOD
61750 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
61757 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
61768 int rc = pPager->errCode;
61770 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
61773 PgHdr *pNext = pList->pDirty;
61774 if( pList->nRef==0 ){
61790 ** If zFilename is NULL then a randomly-named temporary file is created
61794 ** This can be used to implement an in-memory database.
61820 int nExtra, /* Extra bytes append to each in-memory page */
61828 int tempFile = 0; /* True for temp files (incl. in-memory files) */
61829 int memDb = 0; /* True if this is an in-memory file */
61831 int readOnly = 0; /* True if this is a read-only file */
61841 /* Figure out how much space is required for each journal file-handle
61842 ** (there are two of them, the main journal and the sub-journal). */
61866 nPathname = pVfs->mxPathname+1;
61888 nUriByte = (int)(&z[1] - zUri);
61890 if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
61892 ** the database being opened will be more than pVfs->mxPathname
61895 ** check for a hot-journal before reading.
61911 ** Database file handle (pVfs->szOsFile bytes)
61912 ** Sub-journal file handle (journalFileSize bytes)
61922 ** Some 3rd-party software, over which we have no control, depends on
61926 ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party
61929 ** filename format expected by 3rd-party software should be as follows:
61931 ** - Main Database Path
61932 ** - \0
61933 ** - Multiple URI components consisting of:
61934 ** - Key
61935 ** - \0
61936 ** - Value
61937 ** - \0
61938 ** - \0
61939 ** - Journal Path
61940 ** - \0
61941 ** - WAL Path (zWALName)
61942 ** - \0
61953 ROUND8(pVfs->szOsFile) + /* The main db file */
61971 pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize);
61972 pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile);
61973 pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
61974 pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
61975 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
61980 pPager->zFilename = (char*)pPtr;
61993 pPager->zJournal = (char*)pPtr;
61995 memcpy(pPtr, "-journal",8); pPtr += 8 + 1;
61997 sqlite3FileSuffix3(zFilename,pPager->zJournal);
61998 pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1);
62001 pPager->zJournal = 0;
62007 pPager->zWal = (char*)pPtr;
62009 memcpy(pPtr, "-wal", 4); pPtr += 4 + 1;
62011 sqlite3FileSuffix3(zFilename, pPager->zWal);
62012 pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
62015 pPager->zWal = 0;
62021 pPager->pVfs = pVfs;
62022 pPager->vfsFlags = vfsFlags;
62028 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
62030 pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
62042 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
62046 if( szPageDflt<pPager->sectorSize ){
62047 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
62050 szPageDflt = (u32)pPager->sectorSize;
62067 pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
62069 || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
62079 ** This branch is also run for an in-memory database. An in-memory
62080 ** database is the same as a temp-file that is never written out to
62081 ** disk and uses an in-memory rollback journal.
62087 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
62088 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
62089 pPager->noLock = 1; /* Do no locking */
62097 assert( pPager->memDb==0 );
62098 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
62107 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
62113 sqlite3OsClose(pPager->fd);
62114 sqlite3PageFree(pPager->pTmpSpace);
62119 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
62120 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
62122 pPager->useJournal = (u8)useJournal;
62123 /* pPager->stmtOpen = 0; */
62124 /* pPager->stmtInUse = 0; */
62125 /* pPager->nRef = 0; */
62126 /* pPager->stmtSize = 0; */
62127 /* pPager->stmtJSize = 0; */
62128 /* pPager->nPage = 0; */
62129 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
62130 /* pPager->state = PAGER_UNLOCK; */
62131 /* pPager->errMask = 0; */
62132 pPager->tempFile = (u8)tempFile;
62136 pPager->exclusiveMode = (u8)tempFile;
62137 pPager->changeCountDone = pPager->tempFile;
62138 pPager->memDb = (u8)memDb;
62139 pPager->readOnly = (u8)readOnly;
62140 assert( useJournal || pPager->tempFile );
62142 /* pPager->pFirst = 0; */
62143 /* pPager->pFirstSynced = 0; */
62144 /* pPager->pLast = 0; */
62145 pPager->nExtra = (u16)nExtra;
62146 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
62147 assert( isOpen(pPager->fd) || tempFile );
62150 pPager->journalMode = PAGER_JOURNALMODE_OFF;
62152 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
62154 /* pPager->xBusyHandler = 0; */
62155 /* pPager->pBusyHandlerArg = 0; */
62156 pPager->xReiniter = xReinit;
62158 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
62159 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
62173 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
62174 zName--;
62176 p = zName - 4 - sizeof(Pager*);
62179 return pPager->fd;
62186 ** the file-system for the given pager. A hot journal is one that
62187 ** needs to be played back. According to this function, a hot-journal
62201 ** This routine does not check if there is a super-journal filename
62202 ** at the end of the file. If there is, and that super-journal file
62204 ** case this routine will return a false-positive. The pager_playback()
62208 ** If a hot-journal file is found to exist, *pExists is set to 1 and
62209 ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
62211 ** to determine whether or not a hot-journal file exists, the IO error
62215 sqlite3_vfs * const pVfs = pPager->pVfs;
62218 int jrnlOpen = !!isOpen(pPager->jfd);
62220 assert( pPager->useJournal );
62221 assert( isOpen(pPager->fd) );
62222 assert( pPager->eState==PAGER_OPEN );
62224 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
62230 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
62240 ** in fact there is none. This results in a false-positive which will
62243 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
62247 assert( pPager->tempFile==0 );
62261 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
62262 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
62268 ** at least one non-zero bytes at the start of the journal file.
62274 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
62278 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
62283 sqlite3OsClose(pPager->jfd);
62310 ** has been successfully called. If a shared-lock is already held when
62311 ** this function is called, it is a no-op.
62318 ** the SHARED lock, the file-system is checked for a hot-journal,
62319 ** which is played back if present. Following any hot-journal
62321 ** the 'change-counter' field of the database file header and
62324 ** 2) If the pager is running in exclusive-mode, and there are currently
62331 ** occurs while locking the database, checking for a hot-journal file or
62337 /* This routine is only called from b-tree and only when there are no
62341 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
62343 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
62344 assert( pPager->errCode==SQLITE_OK );
62346 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
62347 int bHotJournal = 1; /* True if there exists a hot journal-file */
62350 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
62354 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
62361 if( pPager->eLock<=SHARED_LOCK ){
62368 if( pPager->readOnly ){
62378 ** hot-journal back.
62395 ** in exclusive-access mode the file descriptor will be kept open
62396 ** and possibly used for a transaction later on. Also, write-access
62403 ** may mean that the pager was in the error-state when this
62406 if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
62407 sqlite3_vfs * const pVfs = pPager->pVfs;
62410 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
62414 assert( !pPager->tempFile );
62415 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
62416 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62419 sqlite3OsClose(pPager->jfd);
62426 ** playing back the hot-journal so that we don't end up with
62432 if( isOpen(pPager->jfd) ){
62436 rc = pager_playback(pPager, !pPager->tempFile);
62437 pPager->eState = PAGER_OPEN;
62439 }else if( !pPager->exclusiveMode ){
62445 ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
62464 assert( pPager->eState==PAGER_OPEN );
62465 assert( (pPager->eLock==SHARED_LOCK)
62466 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
62470 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
62471 /* The shared-lock has just been acquired then check to
62475 ** single unnecessary sqlite3OsRead() call at the start-up.
62479 ** a 32-bit counter that is incremented with each change. The
62487 char dbFileVers[sizeof(pPager->dbFileVers)];
62490 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
62498 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
62508 sqlite3OsUnfetch(pPager->fd, 0, 0);
62513 /* If there is a WAL file in the file-system, open this database in WAL
62514 ** mode. Otherwise, the following function call is a no-op.
62518 assert( pPager->pWal==0 || rc==SQLITE_OK );
62527 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
62528 rc = pagerPagecount(pPager, &pPager->dbSize);
62535 assert( pPager->eState==PAGER_OPEN );
62537 pPager->eState = PAGER_READER;
62538 pPager->hasHeldSharedLock = 1;
62549 ** nothing to rollback, so this routine is a no-op.
62552 if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){
62553 assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
62566 ** getPageNormal() -- The normal getter
62567 ** getPageError() -- Used if the pager is in an error state
62568 ** getPageMmap() -- Used if memory-mapped I/O is enabled
62590 ** a) When reading a free-list leaf page from the database, and
62608 ** to find a page in the in-memory cache first. If the page is not already
62610 ** just returns 0. This routine acquires a read-lock the first time it
62626 assert( pPager->errCode==SQLITE_OK );
62627 assert( pPager->eState>=PAGER_READER );
62629 assert( pPager->hasHeldSharedLock==1 );
62632 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
62635 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
62642 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
62644 assert( pPg->pgno==pgno );
62645 assert( pPg->pPager==pPager || pPg->pPager==0 );
62648 if( pPg->pPager && !noContent ){
62652 pPager->aStat[PAGER_STAT_HIT]++;
62667 pPg->pPager = pPager;
62669 assert( !isOpen(pPager->fd) || !MEMDB );
62670 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
62671 if( pgno>pPager->mxPgno ){
62673 if( pgno<=pPager->dbSize ){
62680 /* Failure to set the bits in the InJournal bit-vectors is benign.
62687 if( pgno<=pPager->dbOrigSize ){
62688 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
62695 memset(pPg->pData, 0, pPager->pageSize);
62698 assert( pPg->pPager==pPager );
62699 pPager->aStat[PAGER_STAT_MISS]++;
62720 /* The page getter for when memory-mapped I/O is enabled */
62731 /* It is acceptable to use a read-only (mmap) page for any page except
62732 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
62734 ** temporary or in-memory database. */
62736 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
62748 assert( pPager->eState>=PAGER_READER );
62750 assert( pPager->hasHeldSharedLock==1 );
62751 assert( pPager->errCode==SQLITE_OK );
62754 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
62762 rc = sqlite3OsFetch(pPager->fd,
62763 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
62766 if( pPager->eState>PAGER_READER || pPager->tempFile ){
62772 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
62798 assert( pPager->errCode!=SQLITE_OK );
62800 return pPager->errCode;
62816 rc = pPager->xGet(pPager, pgno, ppPage, flags);
62823 /* Normal, high-speed version of sqlite3PagerGet() */
62824 return pPager->xGet(pPager, pgno, ppPage, flags);
62829 ** Acquire a page if it is already in the in-memory cache. Do
62843 assert( pPager->pPCache!=0 );
62844 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
62845 assert( pPage==0 || pPager->hasHeldSharedLock );
62847 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
62857 ** The assert() at tag-20230419-2 proves that this constraint is always
62865 TESTONLY( Pager *pPager = pPg->pPager; )
62867 if( pPg->flags & PGHDR_MMAP ){
62868 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
62874 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 ); /* tag-20230419-2 */
62882 assert( pPg->pgno==1 );
62883 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
62884 pPager = pPg->pPager;
62895 ** to the start of it. If there are active savepoints, open the sub-journal
62913 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
62915 assert( pPager->eState==PAGER_WRITER_LOCKED );
62917 assert( pPager->pInJournal==0 );
62919 /* If already in the error state, this function is a no-op. But on
62922 if( NEVER(pPager->errCode) ) return pPager->errCode;
62924 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
62925 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
62926 if( pPager->pInJournal==0 ){
62931 if( !isOpen(pPager->jfd) ){
62932 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
62933 sqlite3MemJournalOpen(pPager->jfd);
62938 if( pPager->tempFile ){
62952 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
62956 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62961 ** the sub-journal if necessary.
62965 pPager->nRec = 0;
62966 pPager->journalOff = 0;
62967 pPager->setSuper = 0;
62968 pPager->journalHdr = 0;
62974 sqlite3BitvecDestroy(pPager->pInJournal);
62975 pPager->pInJournal = 0;
62976 pPager->journalOff = 0;
62978 assert( pPager->eState==PAGER_WRITER_LOCKED );
62979 pPager->eState = PAGER_WRITER_CACHEMOD;
62986 ** Begin a write-transaction on the specified pager object. If a
62987 ** write-transaction has already been opened, this function is a no-op.
62994 ** If the subjInMemory argument is non-zero, then any sub-journal opened
62995 ** within this transaction will be opened as an in-memory file. This
62996 ** has no effect if the sub-journal is already opened (as it may be when
62998 ** sub-journal. If the subjInMemory argument is zero, then any required
62999 ** sub-journal is implemented in-memory if pPager is an in-memory database,
63005 if( pPager->errCode ) return pPager->errCode;
63006 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
63007 pPager->subjInMemory = (u8)subjInMemory;
63009 if( pPager->eState==PAGER_READER ){
63010 assert( pPager->pInJournal==0 );
63016 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
63021 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
63026 ** The busy-handler is not invoked if another connection already
63027 ** holds the write-lock. If possible, the upper layer will call it.
63029 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
63033 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
63048 ** transactions may copy data from the sub-journal into the database
63052 pPager->eState = PAGER_WRITER_LOCKED;
63053 pPager->dbHintSize = pPager->dbSize;
63054 pPager->dbFileSize = pPager->dbSize;
63055 pPager->dbOrigSize = pPager->dbSize;
63056 pPager->journalOff = 0;
63059 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
63060 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
63072 Pager *pPager = pPg->pPager;
63076 i64 iOff = pPager->journalOff;
63081 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
63083 assert( pPager->journalHdr<=pPager->journalOff );
63084 pData2 = pPg->pData;
63088 ** page in the block above, set the need-sync flag for the page.
63094 pPg->flags |= PGHDR_NEED_SYNC;
63096 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
63098 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
63100 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
63103 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
63104 pPager->journalOff, pPager->pageSize));
63107 PAGERID(pPager), pPg->pgno,
63108 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
63110 pPager->journalOff += 8 + pPager->pageSize;
63111 pPager->nRec++;
63112 assert( pPager->pInJournal!=0 );
63113 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
63116 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
63123 ** main journal or sub-journal as required. If the page is written into
63129 Pager *pPager = pPg->pPager;
63132 /* This routine is not called unless a write-transaction has already
63136 assert( pPager->eState==PAGER_WRITER_LOCKED
63137 || pPager->eState==PAGER_WRITER_CACHEMOD
63138 || pPager->eState==PAGER_WRITER_DBMOD
63141 assert( pPager->errCode==0 );
63142 assert( pPager->readOnly==0 );
63146 ** obtained the necessary locks to begin the write-transaction, but the
63154 if( pPager->eState==PAGER_WRITER_LOCKED ){
63158 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
63168 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
63169 if( pPager->pInJournal!=0
63170 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
63173 if( pPg->pgno<=pPager->dbOrigSize ){
63179 if( pPager->eState!=PAGER_WRITER_DBMOD ){
63180 pPg->flags |= PGHDR_NEED_SYNC;
63183 PAGERID(pPager), pPg->pgno,
63184 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
63188 /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
63193 pPg->flags |= PGHDR_WRITEABLE;
63198 if( pPager->nSavepoint>0 ){
63203 if( pPager->dbSize<pPg->pgno ){
63204 pPager->dbSize = pPg->pgno;
63227 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
63228 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
63235 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
63236 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
63238 /* This trick assumes that both the page-size and sector-size are
63242 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
63244 nPageCount = pPager->dbSize;
63245 if( pPg->pgno>nPageCount ){
63246 nPage = (pPg->pgno - pg1)+1;
63247 }else if( (pg1+nPagePerSector-1)>nPageCount ){
63248 nPage = nPageCount+1-pg1;
63253 assert(pg1<=pPg->pgno);
63254 assert((pg1+nPage)>pPg->pgno);
63259 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
63264 if( pPage->flags&PGHDR_NEED_SYNC ){
63271 if( pPage->flags&PGHDR_NEED_SYNC ){
63289 pPage->flags |= PGHDR_NEED_SYNC;
63295 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
63296 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
63308 ** fit on a single disk sector. In this case all co-resident pages
63315 Pager *pPager = pPg->pPager;
63316 assert( (pPg->flags & PGHDR_MMAP)==0 );
63317 assert( pPager->eState>=PAGER_WRITER_LOCKED );
63319 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
63320 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
63322 }else if( pPager->errCode ){
63323 return pPager->errCode;
63324 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
63325 assert( pPager->tempFile==0 );
63339 return pPg->flags & PGHDR_WRITEABLE;
63357 ** This optimization cannot be used with a temp-file, as the page may
63364 Pager *pPager = pPg->pPager;
63365 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
63366 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
63367 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
63368 pPg->flags |= PGHDR_DONT_WRITE;
63369 pPg->flags &= ~PGHDR_WRITEABLE;
63370 testcase( pPg->flags & PGHDR_NEED_SYNC );
63377 ** change-counter, stored as a 4-byte big-endian integer starting at
63381 ** But this only happens if the pPager->changeCountDone flag is false.
63391 ** The isDirectMode flag may only be non-zero if the library was compiled
63393 ** if isDirect is non-zero, then the database file is updated directly
63400 assert( pPager->eState==PAGER_WRITER_CACHEMOD
63401 || pPager->eState==PAGER_WRITER_DBMOD
63406 ** atomic-write optimization is enabled in this build, then isDirect
63410 ** The idea is that if the atomic-write optimization is not
63423 if( !pPager->changeCountDone && pPager->dbSize>0 ){
63426 assert( !pPager->tempFile && isOpen(pPager->fd) );
63433 ** operating in direct-mode, make page 1 writable. When not in
63435 ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
63448 assert( pPager->dbFileSize>0 );
63449 zBuf = pPgHdr->pData;
63451 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
63452 pPager->aStat[PAGER_STAT_WRITE]++;
63455 /* Update the pager's copy of the change-counter. Otherwise, the
63457 ** flushed (as the change-counter values will not match). */
63459 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
63460 pPager->changeCountDone = 1;
63463 pPager->changeCountDone = 1;
63474 ** Sync the database file to disk. This is a no-op for in-memory databases
63477 ** If successful, or if called on a pager for which it is a no-op, this
63483 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
63485 if( rc==SQLITE_OK && !pPager->noSync ){
63487 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
63493 ** This function may only be called while a write-transaction is active in
63494 ** rollback. If the connection is in WAL mode, this call is a no-op.
63504 int rc = pPager->errCode;
63507 assert( pPager->eState==PAGER_WRITER_CACHEMOD
63508 || pPager->eState==PAGER_WRITER_DBMOD
63509 || pPager->eState==PAGER_WRITER_LOCKED
63521 ** of a super-journal file that should be written into the individual
63523 ** super-journal (a single database transaction).
63527 ** * The database file change-counter is updated,
63528 ** * the journal is synced (unless the atomic-write optimization is used),
63535 ** delete the super-journal file if specified).
63540 ** If the final parameter - noSync - is true, then the database file itself
63547 const char *zSuper, /* If not NULL, the super-journal name */
63552 assert( pPager->eState==PAGER_WRITER_LOCKED
63553 || pPager->eState==PAGER_WRITER_CACHEMOD
63554 || pPager->eState==PAGER_WRITER_DBMOD
63555 || pPager->eState==PAGER_ERROR
63560 if( NEVER(pPager->errCode) ) return pPager->errCode;
63566 pPager->zFilename, zSuper, pPager->dbSize));
63569 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
63571 assert( MEMDB==0 || pPager->tempFile );
63572 assert( isOpen(pPager->fd) || pPager->tempFile );
63574 /* If this is an in-memory db, or no pages have been written to, or this
63575 ** function has already been called, it is mostly a no-op. However, any
63577 sqlite3BackupRestart(pPager->pBackup);
63582 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63585 ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
63588 pList->pDirty = 0;
63592 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
63596 sqlite3PcacheCleanAll(pPager->pPCache);
63599 /* The bBatch boolean is true if the batch-atomic-write commit method
63600 ** should be used. No rollback journal is created if batch-atomic-write
63604 sqlite3_file *fd = pPager->fd;
63607 && !pPager->noSync
63608 && sqlite3JournalIsInMemory(pPager->jfd);
63614 /* The following block updates the change-counter. Exactly how it
63615 ** does this depends on whether or not the atomic-update optimization
63619 ** * The file-system supports the atomic-write property for
63620 ** blocks of size page-size, and
63621 ** * This commit is not part of a multi-file transaction, and
63626 ** counter in 'indirect-mode'. If the optimization is compiled in but
63629 ** pager_incr_changecounter() to update the change-counter in indirect
63633 ** then call pager_incr_changecounter() to update the change-counter
63639 assert( isOpen(pPager->jfd)
63640 || pPager->journalMode==PAGER_JOURNALMODE_OFF
63641 || pPager->journalMode==PAGER_JOURNALMODE_WAL
63643 if( !zSuper && isOpen(pPager->jfd)
63644 && pPager->journalOff==jrnlBufferSize(pPager)
63645 && pPager->dbSize>=pPager->dbOrigSize
63646 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
63648 /* Update the db file change counter via the direct-write method. The
63649 ** following call will modify the in-memory representation of page 1
63651 ** directly to the database file. Because of the atomic-write
63652 ** property of the host file-system, this is safe.
63656 rc = sqlite3JournalCreate(pPager->jfd);
63665 rc = sqlite3JournalCreate(pPager->jfd);
63674 /* Write the super-journal name into the journal file. If a
63675 ** super-journal file name has already been written to the journal file,
63676 ** or if zSuper is NULL (no super-journal), then this call is a no-op.
63682 ** If the atomic-update optimization is being used, this sync will not
63685 ** Because the change-counter page was just modified, unless the
63686 ** atomic-update optimization is used it is almost certain that the
63690 ** xSync() call will be changed to a no-op by the OS anyhow.
63695 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63701 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbFileSize ){
63702 char *pTmp = pPager->pTmpSpace;
63703 int szPage = (int)pPager->pageSize;
63705 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage,
63706 ((i64)pPager->dbSize*pPager->pageSize)-szPage);
63717 rc = sqlite3JournalCreate(pPager->jfd);
63719 sqlite3OsClose(pPager->jfd);
63724 sqlite3OsClose(pPager->jfd);
63736 sqlite3PcacheCleanAll(pPager->pPCache);
63741 ** last page in the db image moved to the free-list. In this case the
63744 if( pPager->dbSize>pPager->dbFileSize ){
63745 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
63746 assert( pPager->eState==PAGER_WRITER_DBMOD );
63761 pPager->eState = PAGER_WRITER_FINISHED;
63770 ** synced to disk. The journal file still exists in the file-system
63772 ** be used as a hot-journal and the current transaction rolled back.
63776 ** for hot-journal rollback. Once this is done the transaction is
63788 if( NEVER(pPager->errCode) ) return pPager->errCode;
63789 pPager->iDataVersion++;
63791 assert( pPager->eState==PAGER_WRITER_LOCKED
63792 || pPager->eState==PAGER_WRITER_FINISHED
63793 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
63798 ** this transaction, the pager is running in exclusive-mode and is
63799 ** using persistent journals, then this function is a no-op.
63803 ** a hot-journal during hot-journal rollback, 0 changes will be made
63808 if( pPager->eState==PAGER_WRITER_LOCKED
63809 && pPager->exclusiveMode
63810 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
63812 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
63813 pPager->eState = PAGER_READER;
63818 rc = pager_end_transaction(pPager, pPager->setSuper, 1);
63824 ** transaction are reverted and the current write-transaction is closed.
63834 ** in-memory cache pages to the state they were in when the transaction
63843 ** In WAL mode, all cache-entries containing data modified within the
63845 ** their pre-transaction state by re-reading data from the database or
63852 /* PagerRollback() is a no-op if called in READER or OPEN state. If
63857 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
63858 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
63862 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
63863 rc2 = pager_end_transaction(pPager, pPager->setSuper, 0);
63865 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
63866 int eState = pPager->eState;
63873 pPager->errCode = SQLITE_ABORT;
63874 pPager->eState = PAGER_ERROR;
63882 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
63895 ** Return TRUE if the database file is opened read-only. Return FALSE
63899 return pPager->readOnly;
63907 return sqlite3PcacheRefCount(pPager->pPCache);
63916 int perPageSize = pPager->pageSize + pPager->nExtra
63918 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
63920 + pPager->pageSize;
63936 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
63937 a[1] = sqlite3PcachePagecount(pPager->pPCache);
63938 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
63939 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
63940 a[4] = pPager->eState;
63941 a[5] = pPager->errCode;
63942 a[6] = (int)pPager->aStat[PAGER_STAT_HIT] & 0x7fffffff;
63943 a[7] = (int)pPager->aStat[PAGER_STAT_MISS] & 0x7fffffff;
63944 a[8] = 0; /* Used to be pPager->nOvfl */
63945 a[9] = pPager->nRead;
63946 a[10] = (int)pPager->aStat[PAGER_STAT_WRITE] & 0x7fffffff;
63959 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
63975 eStat -= SQLITE_DBSTATUS_CACHE_HIT;
63976 *pnVal += pPager->aStat[eStat];
63978 pPager->aStat[eStat] = 0;
63983 ** Return true if this is an in-memory or temp-file backed pager.
63986 return pPager->tempFile || pPager->memVfs;
63993 ** equal to nSavepoint, then this function is a no-op.
63996 ** occurs while opening the sub-journal file, then an IO error code is
64001 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
64005 assert( pPager->eState>=PAGER_WRITER_LOCKED );
64007 assert( nSavepoint>nCurrent && pPager->useJournal );
64014 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
64019 memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
64020 pPager->aSavepoint = aNew;
64024 aNew[ii].nOrig = pPager->dbSize;
64025 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
64026 aNew[ii].iOffset = pPager->journalOff;
64030 aNew[ii].iSubRec = pPager->nSubRec;
64031 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
64037 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
64039 pPager->nSavepoint = ii+1;
64041 assert( pPager->nSavepoint==nSavepoint );
64046 assert( pPager->eState>=PAGER_WRITER_LOCKED );
64049 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
64069 ** (the first created). A value of (Pager.nSavepoint-1) means operate
64071 ** (Pager.nSavepoint-1), then this function is a no-op.
64088 int rc = pPager->errCode;
64097 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
64106 for(ii=nNew; ii<pPager->nSavepoint; ii++){
64107 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
64109 pPager->nSavepoint = nNew;
64111 /* Truncate the sub-journal so that it only includes the parts
64114 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
64115 if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){
64116 /* Only truncate if it is an in-memory sub-journal. */
64117 if( sqlite3JournalIsInMemory(pPager->sjfd) ){
64118 i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec;
64119 rc = sqlite3OsTruncate(pPager->sjfd, sz);
64122 pPager->nSubRec = pRel->iSubRec;
64126 ** If this is a temp-file, it is possible that the journal file has
64130 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
64131 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
64142 pPager->journalMode==PAGER_JOURNALMODE_OFF
64143 && pPager->eState>=PAGER_WRITER_CACHEMOD
64145 pPager->errCode = SQLITE_ABORT;
64146 pPager->eState = PAGER_ERROR;
64158 ** Except, if the pager is in-memory only, then return an empty string if
64162 ** shared cache, it uses nullIfMemDb==0 so that in-memory databases can
64163 ** participate in shared-cache.
64170 if( nullIfMemDb && (pPager->memDb || sqlite3IsMemdb(pPager->pVfs)) ){
64173 return pPager->zFilename;
64181 return pPager->pVfs;
64190 return pPager->fd;
64199 return pPager->jfd;
64201 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
64209 return pPager->zJournal;
64222 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
64230 ** If the fourth argument, isCommit, is non-zero, then this page is being
64240 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
64244 assert( pPg->nRef>0 );
64245 assert( pPager->eState==PAGER_WRITER_CACHEMOD
64246 || pPager->eState==PAGER_WRITER_DBMOD
64250 /* In order to be able to rollback, an in-memory database must journal
64253 assert( pPager->tempFile || !MEMDB );
64254 if( pPager->tempFile ){
64261 ** sub-journal now. This is required to handle the following scenario:
64269 ** If page X were not written to the sub-journal here, it would not
64273 ** subjournalPage() may need to allocate space to store pPg->pgno into
64277 if( (pPg->flags & PGHDR_DIRTY)!=0
64284 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
64285 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
64287 /* If the journal needs to be sync()ed before page pPg->pgno can
64288 ** be written to, store pPg->pgno in local variable needSyncPgno.
64291 ** the journal needs to be sync()ed before database page pPg->pgno
64294 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
64295 needSyncPgno = pPg->pgno;
64296 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
64297 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
64298 assert( pPg->flags&PGHDR_DIRTY );
64301 /* If the cache contains a page with page-number pgno, remove it
64306 pPg->flags &= ~PGHDR_NEED_SYNC;
64308 assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
64310 if( NEVER(pPgOld->nRef>1) ){
64314 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
64315 if( pPager->tempFile ){
64316 /* Do not discard pages from an in-memory database since we might
64318 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
64324 origPgno = pPg->pgno;
64328 /* For an in-memory database, make sure the original page continues
64332 if( pPager->tempFile && pPgOld ){
64338 /* If needSyncPgno is non-zero, then the journal file needs to be
64340 ** Currently, no such page exists in the page-cache and the
64342 ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
64345 ** If the attempt to load the page into the page-cache fails, (due
64355 if( needSyncPgno<=pPager->dbOrigSize ){
64356 assert( pPager->pTmpSpace!=0 );
64357 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
64361 pPgHdr->flags |= PGHDR_NEED_SYNC;
64377 assert( pPg->pgno!=iNew );
64378 pPg->flags = flags;
64386 assert( pPg->nRef>0 || pPg->pPager->memDb );
64387 return pPg->pData;
64395 return pPg->pExtra;
64399 ** Get/set the locking-mode for this pager. Parameter eMode must be one
64402 ** the locking-mode is set to the value specified.
64406 ** locking-mode.
64414 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
64415 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
64416 pPager->exclusiveMode = (u8)eMode;
64418 return (int)pPager->exclusiveMode;
64422 ** Set the journal-mode for this pager. Parameter eMode must be one of:
64434 ** * An in-memory database can only have its journal_mode set to _OFF
64439 ** The returned indicate the current (possibly updated) journal-mode.
64442 u8 eOld = pPager->journalMode; /* Prior journalmode */
64456 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
64458 /* Do allow the journalmode of an in-memory database to be set to
64471 assert( pPager->eState!=PAGER_ERROR );
64472 pPager->journalMode = (u8)eMode;
64485 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
64486 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
64495 sqlite3OsClose(pPager->jfd);
64496 if( pPager->eLock>=RESERVED_LOCK ){
64497 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
64500 int state = pPager->eState;
64505 if( pPager->eState==PAGER_READER ){
64510 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
64517 assert( state==pPager->eState );
64520 sqlite3OsClose(pPager->jfd);
64525 return (int)pPager->journalMode;
64532 return (int)pPager->journalMode;
64542 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
64543 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
64548 ** Get/set the size-limit used for persistent journal files.
64550 ** Setting the size limit to -1 means no limit is enforced.
64551 ** An attempt to set a limit smaller than -1 is a no-op.
64554 if( iLimit>=-1 ){
64555 pPager->journalSizeLimit = iLimit;
64556 sqlite3WalLimit(pPager->pWal, iLimit);
64558 return pPager->journalSizeLimit;
64562 ** Return a pointer to the pPager->pBackup variable. The backup module
64568 return &pPager->pBackup;
64573 ** Unless this is an in-memory or temporary database, clear the pager cache.
64576 assert( MEMDB==0 || pPager->tempFile );
64577 if( pPager->tempFile==0 ) pager_reset(pPager);
64598 if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){
64610 if( pPager->pWal ){
64611 rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
64612 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
64613 pPager->pBusyHandlerArg,
64614 pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
64622 return sqlite3WalCallback(pPager->pWal);
64627 ** primitives necessary for write-ahead logging.
64630 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
64631 if( pPager->noLock ) return 0;
64632 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
64643 assert( pPager->eLock>=SHARED_LOCK );
64644 eOrigLock = pPager->eLock;
64657 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
64658 ** lock on the database file and use heap-memory to store the wal-index
64659 ** in. Otherwise, use the normal shared-memory.
64664 assert( pPager->pWal==0 && pPager->tempFile==0 );
64665 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
64667 /* If the pager is already in exclusive-mode, the WAL module will use
64668 ** heap-memory for the wal-index instead of the VFS shared-memory
64672 if( pPager->exclusiveMode ){
64680 rc = sqlite3WalOpen(pPager->pVfs,
64681 pPager->fd, pPager->zWal, pPager->exclusiveMode,
64682 pPager->journalSizeLimit, &pPager->pWal
64696 ** file (not a temp file or an in-memory database), and the WAL file
64702 ** If the pager is open on a temp-file (or in-memory database), or if
64708 int *pbOpen /* OUT: Set to true if call is a no-op */
64713 assert( pPager->eState==PAGER_OPEN || pbOpen );
64714 assert( pPager->eState==PAGER_READER || !pbOpen );
64716 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
64718 if( !pPager->tempFile && !pPager->pWal ){
64722 sqlite3OsClose(pPager->jfd);
64726 pPager->journalMode = PAGER_JOURNALMODE_WAL;
64727 pPager->eState = PAGER_OPEN;
64748 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
64750 /* If the log file is not already open, but does exist in the file-system,
64754 if( !pPager->pWal ){
64759 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
64768 ** the database file, the log and log-summary files will be deleted.
64770 if( rc==SQLITE_OK && pPager->pWal ){
64773 rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
64774 pPager->pageSize, (u8*)pPager->pTmpSpace);
64775 pPager->pWal = 0;
64777 if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
64785 ** If pager pPager is a wal-mode database not in exclusive locking mode,
64792 if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){
64793 rc = sqlite3WalWriteLock(pPager->pWal, bLock);
64804 sqlite3WalDb(pPager->pWal, db);
64816 if( pPager->pWal ){
64817 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
64832 if( pPager->pWal ){
64833 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
64846 if( pPager->pWal ){
64847 rc = sqlite3WalSnapshotRecover(pPager->pWal);
64868 if( pPager->pWal ){
64869 rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
64881 assert( pPager->pWal );
64882 sqlite3WalSnapshotUnlock(pPager->pWal);
64890 ** A read-lock must be held on the pager when this function is called. If
64897 assert( pPager->eState>=PAGER_READER );
64898 return sqlite3WalFramesize(pPager->pWal);
64904 return sqlite3WalSystemErrno(pPager->pWal);
64924 ** This file contains the implementation of a write-ahead log (WAL) used in
64927 ** WRITE-AHEAD LOG (WAL) FILE FORMAT
64946 ** big-endian 32-bit unsigned integer values:
64952 ** 16: Salt-1, random integer incremented with each checkpoint
64953 ** 20: Salt-2, a different random integer changing with each ckpt
64954 ** 24: Checksum-1 (first part of checksum for first 24 bytes of header).
64955 ** 28: Checksum-2 (second part of checksum for first 24 bytes of header).
64957 ** Immediately following the wal-header are zero or more frames. Each
64958 ** frame consists of a 24-byte frame-header followed by a <page-size> bytes
64959 ** of page data. The frame-header is six big-endian 32-bit unsigned
64965 ** 8: Salt-1 (copied from the header)
64966 ** 12: Salt-2 (copied from the header)
64967 ** 16: Checksum-1.
64968 ** 20: Checksum-2.
64973 ** (1) The salt-1 and salt-2 values in the frame-header match
64974 ** salt values in the wal-header
64976 ** (2) The checksum values in the final 8 bytes of the frame-header
64981 ** The checksum is computed using 32-bit big-endian integers if the
64983 ** is computed using little-endian if the magic number is 0x377f0682.
64985 ** big-endian format regardless of which byte order is used to compute
64987 ** an even number of unsigned 32-bit integers: x[0] through x[N]. The
64990 ** for i from 0 to n-1 step 2:
64997 ** of the sequence being summed.) The s1 value spans all 32-bit
65000 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
65001 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
65002 ** The VFS.xSync operations serve as write barriers - all writes launched
65006 ** After each checkpoint, the salt-1 value is incremented and the salt-2
65035 ** data structure called the wal-index is maintained to expedite the
65038 ** WAL-INDEX FORMAT
65040 ** Conceptually, the wal-index is shared memory, though VFS implementations
65041 ** might choose to implement the wal-index using a mmapped file. Because
65042 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
65046 ** In the default unix and windows implementation, the wal-index is a mmapped
65047 ** file whose name is the database name with a "-shm" suffix added. For that
65048 ** reason, the wal-index is sometimes called the "shm" file.
65050 ** The wal-index is transient. After a crash, the wal-index can (and should
65052 ** to either truncate or zero the header of the wal-index when the last
65053 ** connection to it closes. Because the wal-index is transient, it can
65054 ** use an architecture-specific format; it does not have to be cross-platform.
65056 ** as big endian, the wal-index can store multi-byte values in the native
65059 ** The purpose of the wal-index is to answer this question quickly: Given
65064 ** The wal-index consists of a header region, followed by an one or
65067 ** The wal-index header contains the total number of frames within the WAL
65073 ** HASHTABLE_NPAGE are selected so that together the wal-index header and
65075 ** wal-index. The values are:
65080 ** Each index block contains two sections, a page-mapping that contains the
65081 ** database page number associated with each wal frame, and a hash-table
65083 ** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE
65084 ** for the first index block) 32-bit page numbers. The first entry in the
65085 ** first index-block contains the database page number corresponding to the
65090 ** The last index block in a wal-index usually contains less than the full
65091 ** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,
65093 ** allocated size of the page-mapping array - the page-mapping array merely
65097 ** can be found by scanning the page-mapping sections of each index block
65103 ** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.
65108 ** 1-based index of an entry in the mapping section of the same
65109 ** index block. Let K be the 1-based index of the largest entry in
65124 ** wrap-around.) Because the hash table is never more than half full,
65129 ** current index block. Otherwise the iMax-th mapping entry of the
65147 ** and to the wal-index) might be using a different value K1, where K1>K0.
65153 ** in the first place - which is what reader one wants. Meanwhile, the
65176 ** The maximum (and only) versions of the wal and wal-index formats
65180 ** values in the wal-header are correct and (b) the version field is not
65183 ** Similarly, if a client successfully reads a wal-index header (i.e. the
65185 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
65200 ** WalCkptInfo.aLock[] array in the wal-index header. In other words, all
65210 #define WAL_NREADER (SQLITE_SHM_NLOCK-3)
65220 ** The following object holds a copy of the wal-index header content.
65222 ** The actual header in the wal-index consists of two copies of this
65229 ** Or it can be 1 to represent a 65536-byte page. The latter case was
65233 u32 iVersion; /* Wal-index version */
65237 u8 bigEndCksum; /* True if checksums in WAL are big-endian */
65247 ** A copy of the following object occurs in the wal-index immediately
65270 ** holds read-lock K, then the value in aReadMark[K] is no greater than
65273 ** a special case; its value is never used and it exists as a place-holder
65302 ** We assume that 32-bit loads are atomic and so no locks are needed in
65315 ** This is a schematic view of the complete 136-byte header of the
65316 ** wal-index file (also known as the -shm file):
65318 ** +-----------------------------+
65320 ** +-----------------------------+ |
65322 ** +-----------------------------+ |
65324 ** +-------+-------+-------------+ |
65326 ** +-------+-------+-------------+ |
65328 ** +-----------------------------+ | WalIndexHdr object
65330 ** +-----------------------------+ |
65333 ** +-----------------------------+ |
65336 ** +-----------------------------+ |
65339 ** +-----------------------------+
65341 ** +-----------------------------+ |
65343 ** +-----------------------------+ |
65345 ** +-------+-------+-------------+ |
65347 ** +-------+-------+-------------+ | Second copy of the
65349 ** +-----------------------------+ |
65351 ** +-----------------------------+ |
65354 ** +-----------------------------+ |
65357 ** +-----------------------------+ |
65360 ** +-----------------------------+
65362 ** +-----------------------------+
65363 ** 100: | 5 read marks |
65368 ** +-------+-------+------+------+
65370 ** +-------+-------+------+------+ ) 8 lock bytes
65372 ** +-------+-------+------+------+
65374 ** +-----------------------------+
65376 ** +-----------------------------+
65381 ** only support mandatory file-locks, we do not read or write data
65394 ** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit
65395 ** big-endian format in the first 4 bytes of a WAL file.
65398 ** file are calculated by treating all data as an array of 32-bit
65399 ** big-endian words. Otherwise, they are calculated by interpreting
65400 ** all data as 32-bit little-endian words.
65405 ** Return the offset of frame iFrame in the write-ahead log file,
65407 ** is to the start of the write-ahead log frame-header.
65410 WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \
65414 ** An open write-ahead log file is represented by an instance of the
65425 volatile u32 **apWiData; /* Pointer to wal-index content in memory */
65427 i16 readLock; /* Which read lock is being held. -1 for none */
65429 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
65436 u8 bShmUnreliable; /* SHM content is read-only and unreliable */
65437 WalIndexHdr hdr; /* Wal-index header for current transaction */
65441 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
65476 ** Each page of the wal-index mapping contains a hash-table made up of
65490 ** walIteratorInit() - Create a new iterator,
65491 ** walIteratorNext() - Step an iterator,
65492 ** walIteratorFree() - Free an iterator.
65505 } aSegment[1]; /* One for every 32KB page in the wal-index */
65509 ** Define the parameters of the hash tables in the wal-index file. There
65510 ** is a hash-table following every HASHTABLE_NPAGE page numbers in the
65511 ** wal-index.
65513 ** Changing any of these constants will alter the wal-index format and
65521 ** The block of page numbers associated with the first hash-table in a
65522 ** wal-index is smaller than usual. This is so that there is a complete
65523 ** hash-table on each aligned 32KB page of the wal-index.
65525 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
65527 /* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */
65533 ** Structured Exception Handling (SEH) is a Windows-specific technique
65534 ** for catching exceptions raised while accessing memory-mapped files.
65536 ** The -DSQLITE_USE_SEH compile-time option means to use SEH to catch and
65537 ** deal with system-level errors that arise during WAL -shm file processing.
65538 ** Without this compile-time option, any system-level faults that appear
65539 ** while accessing the memory-mapped -shm file will cause a process-wide
65548 assert( walAssertLockmask(pWal) && pWal->nSehTry==0 ); \
65549 VVA_ONLY(pWal->nSehTry++);
65553 VVA_ONLY(pWal->nSehTry--); \
65554 assert( pWal->nSehTry==0 ); \
65557 /* Simulate a memory-mapping fault in the -shm file for testing purposes */
65563 ** indicates that the exception may have been caused by accessing the *-shm
65567 VVA_ONLY(pWal->nSehTry--);
65569 if( p && p->ExceptionRecord && p->ExceptionRecord->NumberParameters>=3 ){
65571 ** ExceptionInformation[] array is a read-write flag - 0 if the exception
65575 pWal->iSysErrno = (int)p->ExceptionRecord->ExceptionInformation[2];
65585 ** thrown by the system if the *-shm file mapping is accessed after it
65590 assert( pWal->nSehTry>0 );
65616 assert( (X==0 || Y==0) && pWal->pFree==X ); pWal->pFree = Y
65619 ** There are two ways to use this macro. To arrange for pWal->apWiData[iPg]
65628 #define SEH_SET_ON_ERROR(X,Y) pWal->iWiPg = X; pWal->pWiValue = Y
65631 # define SEH_TRY VVA_ONLY(pWal->nSehTry++);
65632 # define SEH_EXCEPT(X) VVA_ONLY(pWal->nSehTry--); assert( pWal->nSehTry==0 );
65633 # define SEH_INJECT_FAULT assert( pWal->nSehTry>0 );
65640 ** Obtain a pointer to the iPage'th page of the wal-index. The wal-index
65641 ** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are
65644 ** If the wal-index is currently smaller the iPage pages then the size
65645 ** of the wal-index might be increased, but only if it is safe to do
65646 ** so. It is safe to enlarge the wal-index if pWal->writeLock is true
65647 ** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE.
65651 ** (1) rc==SQLITE_OK and *ppPage==Requested-Wal-Index-Page
65655 ** Scenario (3) can only occur when pWal->writeLock is false and iPage==0
65664 /* Enlarge the pWal->apWiData[] array if required */
65665 if( pWal->nWiData<=iPage ){
65668 apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte);
65673 memset((void*)&apNew[pWal->nWiData], 0,
65674 sizeof(u32*)*(iPage+1-pWal->nWiData));
65675 pWal->apWiData = apNew;
65676 pWal->nWiData = iPage+1;
65680 assert( pWal->apWiData[iPage]==0 );
65681 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
65682 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
65683 if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
65685 rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
65686 pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
65688 assert( pWal->apWiData[iPage]!=0
65690 || (pWal->writeLock==0 && iPage==0) );
65691 testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
65695 pWal->readOnly |= WAL_SHM_RDONLY;
65702 *ppPage = pWal->apWiData[iPage];
65712 if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){
65719 ** Return a pointer to the WalCkptInfo structure in the wal-index.
65722 assert( pWal->nWiData>0 && pWal->apWiData[0] );
65724 return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
65728 ** Return a pointer to the WalIndexHdr structure in the wal-index.
65731 assert( pWal->nWiData>0 && pWal->apWiData[0] );
65733 return (volatile WalIndexHdr*)pWal->apWiData[0];
65737 ** The argument to this macro must be of type u32. On a little-endian
65739 ** the 4 bytes as a big-endian value. On a big-endian architecture, it
65741 ** of the input value as a little-endian integer.
65758 int nativeCksum, /* True for native byte-order, false for non-native */
65822 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
65823 sqlite3OsShmBarrier(pWal->pDbFd);
65828 ** Add the SQLITE_NO_TSAN as part of the return-type of a function
65830 ** might give false-positive TSAN warnings.
65832 ** See tag-20200519-1.
65841 ** Write the header information in pWal->hdr into the wal-index.
65843 ** The checksum on pWal->hdr is updated before it is written.
65849 assert( pWal->writeLock );
65850 pWal->hdr.isInit = 1;
65851 pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
65852 walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
65853 /* Possible TSAN false-positive. See tag-20200519-1 */
65854 memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
65856 memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
65861 ** supplied by the caller. A frame-header is made up of a series of
65862 ** 4-byte big-endian integers, as follows:
65867 ** 8: Salt-1 (copied from the wal-header)
65868 ** 12: Salt-2 (copied from the wal-header)
65869 ** 16: Checksum-1.
65870 ** 20: Checksum-2.
65873 Wal *pWal, /* The write-ahead log */
65875 u32 nTruncate, /* New db size (or 0 for non-commit frames) */
65879 int nativeCksum; /* True for native byte-order checksums */
65880 u32 *aCksum = pWal->hdr.aFrameCksum;
65884 if( pWal->iReCksum==0 ){
65885 memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
65887 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
65889 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
65904 Wal *pWal, /* The write-ahead log */
65910 int nativeCksum; /* True for native byte-order checksums */
65911 u32 *aCksum = pWal->hdr.aFrameCksum;
65915 /* A frame is only valid if the salt values in the frame-header
65916 ** match the salt values in the wal-header.
65918 if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
65930 ** all prior frames, the first 16 bytes of this frame-header,
65931 ** and the frame-data matches the checksum in the last 8
65932 ** bytes of this frame-header.
65934 nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
65936 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
65960 return "WRITE-LOCK";
65962 return "CKPT-LOCK";
65964 return "RECOVER-LOCK";
65967 sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
65968 lockIdx-WAL_READ_LOCK(0));
65977 ** A lock cannot be moved directly between shared and exclusive - it must go
65980 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
65984 if( pWal->exclusiveMode ) return SQLITE_OK;
65985 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
65987 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
65989 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
65991 if( rc==SQLITE_OK ) pWal->lockMask |= (1 << lockIdx);
65996 if( pWal->exclusiveMode ) return;
65997 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
66000 pWal->lockMask &= ~(1 << lockIdx);
66002 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
66006 if( pWal->exclusiveMode ) return SQLITE_OK;
66007 rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
66009 WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
66011 VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); )
66014 pWal->lockMask |= (((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
66020 if( pWal->exclusiveMode ) return;
66021 (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
66024 pWal->lockMask &= ~(((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
66026 WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,
66032 ** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances
66037 assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
66038 return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1);
66041 return (iPriorHash+1)&(HASHTABLE_NSLOT-1);
66046 ** of a page hash table in the wal-index. This becomes the return value
66051 volatile ht_slot *aHash; /* Start of the wal-index hash table */
66058 ** page iHash of the wal-index. The wal-index is broken into 32KB pages
66061 ** Set output variable pLoc->aHash to point to the start of the hash table
66062 ** in the wal-index file. Set pLoc->iZero to one less than the frame
66065 ** (pLoc->iZero+N) in the log.
66067 ** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the
66068 ** first frame indexed by the hash table, frame (pLoc->iZero).
66077 rc = walIndexPage(pWal, iHash, &pLoc->aPgno);
66080 if( pLoc->aPgno ){
66081 pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE];
66083 pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
66084 pLoc->iZero = 0;
66086 pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;
66095 ** Return the number of the wal-index page that contains the hash-table
66096 ** and page-number array that contain entries corresponding to WAL frame
66097 ** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages
66101 int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;
66119 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
66121 return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
66126 ** than pWal->hdr.mxFrame.
66128 ** This function is called whenever pWal->hdr.mxFrame is decreased due
66131 ** At most only the hash table containing pWal->hdr.mxFrame needs to be
66133 ** pWal->hdr.mxFrame advances to the point where those hash tables are
66142 assert( pWal->writeLock );
66143 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
66144 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
66145 testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
66147 if( pWal->hdr.mxFrame==0 ) return;
66149 /* Obtain pointers to the hash-table and page-number array containing
66150 ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
66151 ** that the page said hash-table and array reside on is already mapped.(1)
66153 assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
66154 assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
66155 i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
66156 if( NEVER(i) ) return; /* Defense-in-depth, in case (1) above is wrong */
66158 /* Zero all hash-table entries that correspond to frame numbers greater
66159 ** than pWal->hdr.mxFrame.
66161 iLimit = pWal->hdr.mxFrame - sLoc.iZero;
66170 ** frame numbers greater than pWal->hdr.mxFrame.
66172 nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit]);
66195 ** Set an entry in the wal-index that will map database page number
66200 WalHashLoc sLoc; /* Wal-index hash table location */
66204 /* Assuming the wal-index file was successfully mapped, populate the
66209 int idx; /* Value to write to hash-table slot */
66212 idx = iFrame - sLoc.iZero;
66215 /* If this is the first entry to be added to this hash-table, zero the
66219 int nByte = (int)((u8*)&sLoc.aHash[HASHTABLE_NSLOT] - (u8*)sLoc.aPgno);
66228 ** the hash-table before writing any new entries.
66230 if( sLoc.aPgno[idx-1] ){
66232 assert( !sLoc.aPgno[idx-1] );
66235 /* Write the aPgno[] array entry and the hash-table slot. */
66238 if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
66240 sLoc.aPgno[idx-1] = iPage;
66256 ** thing to check, so only do this occasionally - not on every
66278 ** Recover the wal-index by reading the write-ahead log file.
66281 ** wal-index to prevent other threads/processes from doing anything
66282 ** with the WAL or wal-index while recovery is running. The
66299 assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
66302 assert( pWal->writeLock );
66303 iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
66304 rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
66311 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
66313 rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
66320 u32 *aPrivate = 0; /* Heap copy of *-shm hash being populated */
66328 u32 iPg; /* Current 32KB wal-index page */
66332 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
66345 || szPage&(szPage-1)
66351 pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
66352 pWal->szPage = szPage;
66353 pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
66354 memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
66357 walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
66358 aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
66360 if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
66361 || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
66386 iLastFrame = (nSize - WAL_HDRSIZE) / szFrame;
66391 u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE);
66397 pWal->apWiData[iPg] = aPrivate;
66405 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
66412 /* If nTruncate is non-zero, this is a commit record. */
66414 pWal->hdr.mxFrame = iFrame;
66415 pWal->hdr.nPage = nTruncate;
66416 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
66419 aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
66420 aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
66423 pWal->apWiData[iPg] = aShare;
66436 memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr);
66467 pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
66468 pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
66471 /* Reset the checkpoint-header. This is safe because this thread is
66473 ** checkpointers. Then set the values of read-mark slots 1 through N.
66476 pInfo->nBackfill = 0;
66477 pInfo->nBackfillAttempted = pWal->hdr.mxFrame;
66478 pInfo->aReadMark[0] = 0;
66482 if( i==1 && pWal->hdr.mxFrame ){
66483 pInfo->aReadMark[i] = pWal->hdr.mxFrame;
66485 pInfo->aReadMark[i] = READMARK_NOT_USED;
66499 if( pWal->hdr.nPage ){
66502 pWal->hdr.mxFrame, pWal->zWalName
66509 walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
66514 ** Close an open wal-index.
66517 if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){
66519 for(i=0; i<pWal->nWiData; i++){
66520 sqlite3_free((void *)pWal->apWiData[i]);
66521 pWal->apWiData[i] = 0;
66524 if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
66525 sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
66536 ** client from unlinking the WAL or wal-index file. If another process
66545 sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */
66548 int bNoShm, /* True to run in heap-memory mode */
66560 ** of these constants would result in an incompatible on-disk format
66561 ** for the -shm file. Any change that causes one of these asserts to
66565 ** This table also serves as a helpful cross-reference when trying to
66566 ** interpret hex dumps of the -shm file.
66606 pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);
66611 pRet->pVfs = pVfs;
66612 pRet->pWalFd = (sqlite3_file *)&pRet[1];
66613 pRet->pDbFd = pDbFd;
66614 pRet->readLock = -1;
66615 pRet->mxWalSize = mxWalSize;
66616 pRet->zWalName = zWalName;
66617 pRet->syncHeader = 1;
66618 pRet->padToSectorBoundary = 1;
66619 pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
66621 /* Open file handle on the write-ahead log file. */
66623 rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
66625 pRet->readOnly = WAL_RDONLY;
66630 sqlite3OsClose(pRet->pWalFd);
66634 if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }
66636 pRet->padToSectorBoundary = 0;
66648 if( pWal ) pWal->mxWalSize = iLimit;
66670 iMin = p->iPrior;
66672 for(i=p->nSegment-1; i>=0; i--){
66673 struct WalSegment *pSegment = &p->aSegment[i];
66674 while( pSegment->iNext<pSegment->nEntry ){
66675 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
66679 *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];
66683 pSegment->iNext++;
66687 *piPage = p->iPrior = iRet;
66715 const u32 *aContent, /* Pages in wal - keys for the sort */
66779 ht_slot *aList; /* Pointer to sub-list content */
66787 struct Sublist aSub[13]; /* Array of sub-lists */
66791 assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
66800 assert( p->aList && p->nList<=(1<<iSub) );
66801 assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
66802 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
66813 assert( p->nList<=(1<<iSub) );
66814 assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
66815 walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
66825 assert( aContent[aList[i]] > aContent[aList[i-1]] );
66841 ** nBackfill or earlier may be included - excluding them is an optimization
66857 ht_slot *aTmp; /* Temp space used by merge-sort */
66863 assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
66864 iLast = pWal->hdr.mxFrame;
66869 + (nSegment-1)*sizeof(struct WalSegment)
66878 p->nSegment = nSegment;
66891 nEntry = (int)(iLast - sLoc.iZero);
66893 nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);
66895 aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];
66902 p->aSegment[i].iZero = sLoc.iZero;
66903 p->aSegment[i].nEntry = nEntry;
66904 p->aSegment[i].aIndex = aIndex;
66905 p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;
66926 pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&nMs
66934 ** with a busy-timeout. Return 1 if blocking locks are successfully enabled,
66939 if( pWal->db ){
66940 int tmout = pWal->db->busyTimeout;
66953 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout);
66967 assert( pWal->readLock<0 || bLock==0 );
66969 assert( pWal->db );
66973 pWal->writeLock = 1;
66977 }else if( pWal->writeLock ){
66979 pWal->writeLock = 0;
66988 pWal->db = db;
67002 ** busy-handler function. Invoke it and retry the lock until either the
67003 ** lock is successfully obtained or the busy-handler returns 0.
67026 ** The cache of the wal-index header must be valid to call this function.
67027 ** Return the page-size in bytes used by the database.
67030 return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
67039 ** file - there are no readers that may attempt to read a frame from
67042 ** This function updates the shared-memory structures so that the next
67047 ** new wal-index header. It should be passed a pseudo-random value (i.e.
67053 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
67054 pWal->nCkpt++;
67055 pWal->hdr.mxFrame = 0;
67057 memcpy(&pWal->hdr.aSalt[1], &salt1, 4);
67059 AtomicStore(&pInfo->nBackfill, 0);
67060 pInfo->nBackfillAttempted = 0;
67061 pInfo->aReadMark[1] = 0;
67062 for(i=2; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
67063 assert( pInfo->aReadMark[0]==0 );
67075 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
67081 ** in the WAL and can be recovered following a power-loss or hard reset.
67088 ** This routine uses and updates the nBackfill field of the wal-index header.
67107 int szPage; /* Database page-size */
67120 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
67122 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
67131 mxSafeFrame = pWal->hdr.mxFrame;
67132 mxPage = pWal->hdr.nPage;
67134 u32 y = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
67136 assert( y<=pWal->hdr.mxFrame );
67140 AtomicStore(pInfo->aReadMark+i, iMark); SEH_INJECT_FAULT;
67152 if( pInfo->nBackfill<mxSafeFrame ){
67153 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
67160 u32 nBackfill = pInfo->nBackfill;
67161 pInfo->nBackfillAttempted = mxSafeFrame; SEH_INJECT_FAULT;
67164 rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
67172 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0);
67173 rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
67175 if( (nSize+65536+(i64)pWal->hdr.mxFrame*szPage)<nReq ){
67178 ** maximum size of the pending-byte page (65536 bytes), then
67182 sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT,&nReq);
67193 if( AtomicLoad(&db->u1.isInterrupted) ){
67194 rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
67202 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
67204 iOffset = (iDbpage-1)*(i64)szPage;
67206 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
67209 sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0);
67213 if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
67214 i64 szDb = pWal->hdr.nPage*(i64)szPage;
67216 rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
67218 rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));
67222 AtomicStore(&pInfo->nBackfill, mxSafeFrame); SEH_INJECT_FAULT;
67243 assert( pWal->writeLock );
67245 if( pInfo->nBackfill<pWal->hdr.mxFrame ){
67250 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
67251 rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
67254 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as
67260 ** wal-index header in shared memory, as all subsequent reader or
67264 ** the wal-index header do not match the contents of the
67265 ** file-system. To avoid this, update the wal-index header to
67268 rc = sqlite3OsTruncate(pWal->pWalFd, 0);
67270 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
67289 rx = sqlite3OsFileSize(pWal->pWalFd, &sz);
67291 rx = sqlite3OsTruncate(pWal->pWalFd, nMax);
67295 sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
67302 ** an exception thrown by reading from the *-shm mapping after it has become
67317 ** 3) Set pWal->apWiData[pWal->iWiPg] to pWal->pWiValue if not NULL
67322 if( pWal->exclusiveMode==0 ){
67326 u32 mUnlock = pWal->lockMask & ~(
67327 (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
67328 | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
67329 | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
67336 sqlite3_free(pWal->pFree);
67337 pWal->pFree = 0;
67338 if( pWal->pWiValue ){
67339 pWal->apWiData[pWal->iWiPg] = pWal->pWiValue;
67340 pWal->pWiValue = 0;
67353 if( pWal->exclusiveMode==0 ){
67357 (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
67358 | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
67359 | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
67361 | (pWal->pSnapshot ? (pWal->lockMask & (1 << WAL_CKPT_LOCK)) : 0)
67364 assert( mExpect==pWal->lockMask );
67376 iRet = pWal->iSysErrno;
67377 pWal->iSysErrno = 0;
67398 int isDelete = 0; /* True to unlink wal and wal-index files */
67403 ** ordinary, rollback-mode locking methods, this guarantees that the
67406 ** the wal and wal-index files.
67411 && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
67413 if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
67414 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
67420 int bPersist = -1;
67422 pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
67426 ** fsynced (rc==SQLITE_OK) and if we are not in persistent-wal
67429 }else if( pWal->mxWalSize>=0 ){
67433 ** non-negative value (pWal->mxWalSize>=0). Note that we truncate
67442 sqlite3OsClose(pWal->pWalFd);
67445 sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
67449 sqlite3_free((void *)pWal->apWiData);
67456 ** Try to read the wal-index header. Return 0 on success and 1 if
67459 ** The wal-index is in shared memory. Another thread or process might
67466 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
67469 ** If the checksum cannot be verified return non-zero. If the header
67477 /* The first page of the wal-index must be mapped at this point. */
67478 assert( pWal->nWiData>0 && pWal->apWiData[0] );
67483 ** from the file. If this happens, return non-zero.
67485 ** tag-20200519-1:
67486 ** There are two copies of the header at the beginning of the wal-index.
67490 ** give false-positive warnings about these accesses because the tools do not
67491 ** account for the double-read and the memory barrier. The use of mutexes
67497 memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); /* Possible TSAN false-positive */
67505 return 1; /* Malformed header - probably all zeros */
67507 walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);
67512 if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
67514 memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
67515 pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
67516 testcase( pWal->szPage<=32768 );
67517 testcase( pWal->szPage>=65536 );
67528 #define WAL_RETRY (-1)
67531 ** Read the wal-index header from the wal-index and into pWal->hdr.
67532 ** If the wal-header appears to be corrupt, try to reconstruct the
67533 ** wal-index from the WAL before returning.
67535 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
67536 ** changed by this operation. If pWal->hdr is unchanged, set *pChanged
67539 ** If the wal-index header is successfully read, return SQLITE_OK.
67545 volatile u32 *page0; /* Chunk of wal-index containing header */
67547 /* Ensure that page 0 of the wal-index (the page that contains the
67548 ** wal-index header) is mapped. Return early if an error occurs here.
67555 /* The SQLITE_READONLY_CANTINIT return means that the shared-memory
67557 ** confirm that another write-capable connection has the shared-memory
67558 ** open, and hence the content of the shared-memory is unreliable,
67559 ** since the shared-memory might be inconsistent with the WAL file
67562 assert( pWal->writeLock==0 );
67563 assert( pWal->readOnly & WAL_SHM_RDONLY );
67564 pWal->bShmUnreliable = 1;
67565 pWal->exclusiveMode = WAL_HEAPMEMORY_MODE;
67568 return rc; /* Any other non-OK return is just an error */
67571 /* page0 can be NULL if the SHM is zero bytes in size and pWal->writeLock
67575 assert( page0!=0 || pWal->writeLock==0 );
67577 /* If the first page of the wal-index has been mapped, try to read the
67578 ** wal-index header immediately, without holding any lock. This usually
67579 ** works, but may fail if the wal-index header is corrupt or currently
67588 if( pWal->bShmUnreliable==0 && (pWal->readOnly & WAL_SHM_RDONLY) ){
67594 int bWriteLock = pWal->writeLock;
67598 pWal->writeLock = 1;
67602 /* If the wal-index header is still malformed even while holding
67612 pWal->writeLock = 0;
67620 ** sure the wal-index was not constructed with some future format that
67623 if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
67626 if( pWal->bShmUnreliable ){
67629 pWal->bShmUnreliable = 0;
67630 assert( pWal->nWiData>0 && pWal->apWiData[0]==0 );
67636 pWal->exclusiveMode = WAL_NORMAL_MODE;
67643 ** Open a transaction in a connection where the shared-memory is read-only
67644 ** and where we cannot verify that there is a separate write-capable connection
67645 ** on hand to keep the shared-memory up-to-date with the WAL file.
67647 ** This can happen, for example, when the shared-memory is implemented by
67648 ** memory-mapping a *-shm file, where a prior writer has shut down and
67649 ** left the *-shm file on disk, and now the present connection is trying
67650 ** to use that database but lacks write permission on the *-shm file.
67655 ** The *-wal file has been read and an appropriate wal-index has been
67656 ** constructed in pWal->apWiData[] using heap memory instead of shared
67663 ** WAL_RETRY, then the heap memory wal-index has been discarded and
67665 ** beginning (including attempting to map the *-shm file).
67678 u32 aSaveCksum[2]; /* Saved copy of pWal->hdr.aFrameCksum */
67680 assert( pWal->bShmUnreliable );
67681 assert( pWal->readOnly & WAL_SHM_RDONLY );
67682 assert( pWal->nWiData>0 && pWal->apWiData[0] );
67692 pWal->readLock = 0;
67694 /* Check to see if a separate writer has attached to the shared-memory area,
67695 ** thus making the shared-memory "reliable" again. Do this by invoking
67699 ** If the shared-memory is now "reliable" return WAL_RETRY, which will
67700 ** cause the heap-memory WAL-index to be discarded and the actual
67712 ** even if some external agent does a "chmod" to make the shared-memory
67716 rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy);
67717 assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */
67723 /* We reach this point only if the real shared-memory is still unreliable.
67724 ** Assume the in-memory WAL-index substitute is correct and load it
67725 ** into pWal->hdr.
67727 memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr));
67732 rc = sqlite3OsFileSize(pWal->pWalFd, &szWal);
67737 /* If the wal file is too small to contain a wal-header and the
67738 ** wal-index header has mxFrame==0, then it must be safe to proceed
67744 rc = (pWal->hdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY);
67749 rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
67753 if( memcmp(&pWal->hdr.aSalt, &aBuf[16], 8) ){
67755 ** Return WAL_RETRY which will cause the in-memory WAL-index to be
67762 assert( (pWal->szPage & (pWal->szPage-1))==0 );
67763 assert( pWal->szPage>=512 && pWal->szPage<=65536 );
67764 szFrame = pWal->szPage + WAL_FRAME_HDRSIZE;
67773 ** wal file since the heap-memory wal-index was created. If so, the
67774 ** heap-memory wal-index is discarded and WAL_RETRY returned to
67776 aSaveCksum[0] = pWal->hdr.aFrameCksum[0];
67777 aSaveCksum[1] = pWal->hdr.aFrameCksum[1];
67778 for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->szPage);
67786 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
67790 /* If nTruncate is non-zero, then a complete transaction has been
67798 pWal->hdr.aFrameCksum[0] = aSaveCksum[0];
67799 pWal->hdr.aFrameCksum[1] = aSaveCksum[1];
67805 for(i=0; i<pWal->nWiData; i++){
67806 sqlite3_free((void*)pWal->apWiData[i]);
67807 pWal->apWiData[i] = 0;
67809 pWal->bShmUnreliable = 0;
67829 ** it reaches WAL_RETRY_PROTOCOL_LIMIT - indicating that walTryBeginRead()
67830 ** has many times been invoked and failed with WAL_RETRY - walTryBeginRead()
67840 #define WAL_RETRY_PROTOCOL_LIMIT 100
67859 ** to make a copy of the wal-index header into pWal->hdr. If the
67860 ** wal-index header has changed, *pChanged is set to 1 (as an indication
67862 ** flushed.) When useWal==1, the wal-index header is assumed to already
67873 ** bad luck when there is lots of contention for the wal-index, but that
67877 ** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is
67878 ** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1)
67881 ** including frame number aReadMark[pWal->readLock]. The reader will
67882 ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0
67883 ** Or if pWal->readLock==0, then the reader will ignore the WAL
67886 ** this routine will always set pWal->readLock>0 on success.
67888 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
67898 volatile WalCkptInfo *pInfo; /* Checkpoint information in wal-index */
67908 assert( pWal->readLock<0 ); /* Not currently locked */
67911 assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 );
67919 ** paged out or take a page-fault that is time-consuming to resolve,
67927 ** so that on the 100th (and last) RETRY we delay for 323 milliseconds.
67935 VVA_ONLY( pWal->lockError = 1; )
67938 if( *pCnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39;
67940 /* In SQLITE_ENABLE_SETLK_TIMEOUT builds, configure the file-descriptor
67945 ** read-mark.
67956 sqlite3OsSleep(pWal->pVfs, nDelay);
67962 if( pWal->bShmUnreliable==0 ){
67981 if( pWal->apWiData[0]==0 ){
67986 ** code that determines whether or not the shared-memory region
68000 else if( pWal->bShmUnreliable ){
68005 assert( pWal->nWiData>0 );
68006 assert( pWal->apWiData[0]!=0 );
68009 if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
68011 && (pWal->pSnapshot==0 || pWal->hdr.mxFrame==0)
68020 if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
68037 pWal->readLock = 0;
68047 ** but not exceeding pWal->hdr.mxFrame and lock that entry.
68051 mxFrame = pWal->hdr.mxFrame;
68053 if( pWal->pSnapshot && pWal->pSnapshot->mxFrame<mxFrame ){
68054 mxFrame = pWal->pSnapshot->mxFrame;
68058 u32 thisMark = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
68065 if( (pWal->readOnly & WAL_SHM_RDONLY)==0
68071 AtomicStore(pInfo->aReadMark+i,mxFrame);
68082 assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
68100 /* Now that the read-lock has been obtained, check that neither the
68101 ** value in the aReadMark[] array or the contents of the wal-index
68104 ** It is necessary to check that the wal-index header did not change
68105 ** between the time it was read and when the shared-lock was obtained
68108 ** that occur later in the log than pWal->hdr.mxFrame may have been
68111 ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
68114 ** Before checking that the live wal-index header has not changed
68117 ** to read any frames earlier than minFrame from the wal file - they
68121 ** nBackfill and checking that the wal-header in shared-memory still
68122 ** matches the one cached in pWal->hdr, it is guaranteed that the
68123 ** checkpointer that set nBackfill was not working with a wal-index
68124 ** header newer than that cached in pWal->hdr. If it were, that could
68126 ** a version of page X that lies before pWal->minFrame (call that version
68129 ** frame pWal->hdr.mxFrame - then the client would incorrectly assume
68132 ** see any pages past pWal->hdr.mxFrame, this problem does not come up.
68134 pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1; SEH_INJECT_FAULT;
68136 if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark
68137 || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
68142 assert( mxReadMark<=pWal->hdr.mxFrame );
68143 pWal->readLock = (i16)mxI;
68154 void *pBuf1, /* Temp buffer pWal->szPage bytes in size */
68155 void *pBuf2 /* Temp buffer pWal->szPage bytes in size */
68157 int szPage = (int)pWal->szPage;
68161 rc = sqlite3OsFileSize(pWal->pDbFd, &szDb);
68164 u32 i = pInfo->nBackfillAttempted;
68165 for(i=pInfo->nBackfillAttempted; i>AtomicLoad(&pInfo->nBackfill); i--){
68173 assert( i - sLoc.iZero - 1 >=0 );
68174 pgno = sLoc.aPgno[i-sLoc.iZero-1];
68175 iDbOff = (i64)(pgno-1) * szPage;
68179 rc = sqlite3OsRead(pWal->pWalFd, pBuf1, szPage, iWalOff);
68182 rc = sqlite3OsRead(pWal->pDbFd, pBuf2, szPage, iDbOff);
68190 pInfo->nBackfillAttempted = i-1;
68205 ** This is only really safe if the file-system is such that any page
68219 assert( pWal->readLock>=0 );
68222 void *pBuf1 = sqlite3_malloc(pWal->szPage);
68223 void *pBuf2 = sqlite3_malloc(pWal->szPage);
68227 pWal->ckptLock = 1;
68232 pWal->ckptLock = 0;
68254 WalIndexHdr *pSnapshot = pWal->pSnapshot;
68257 assert( pWal->ckptLock==0 );
68258 assert( pWal->nSehTry>0 );
68262 if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
68270 ** has not yet set the pInfo->nBackfillAttempted variable to indicate
68273 ** before checking pInfo->nBackfillAttempted. */
68295 if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
68297 ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr
68298 ** is populated with the wal-index header corresponding to the head
68306 ** pSnapshot->mxFrame into the database file. Note that the
68311 assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 );
68312 assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame );
68316 ** frames beyond pSnapshot->mxFrame. If either of these conditions are
68317 ** true, return SQLITE_ERROR_SNAPSHOT. Otherwise, overwrite pWal->hdr
68320 if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
68321 && pSnapshot->mxFrame>=pInfo->nBackfillAttempted
68323 assert( pWal->readLock>0 );
68324 memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr));
68330 /* A client using a non-current snapshot may not ignore any frames
68336 pWal->minFrame = 1;
68357 ** it takes a snapshot of the state of the WAL and wal-index for the current
68359 ** Other threads might append new content to the WAL and wal-index but
68378 ** read-lock.
68382 if( pWal->readLock>=0 ){
68383 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
68384 pWal->readLock = -1;
68402 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
68407 assert( pWal->readLock>=0 || pWal->lockError );
68409 /* If the "last page" field of the wal-index header snapshot is 0, then
68411 ** in this case as an optimization. Likewise, if pWal->readLock==0,
68415 if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){
68425 ** that adds entries to the wal-index (and possibly to this hash
68429 ** read transaction was opened may have been written incorrectly -
68436 ** if we had exclusive access to the hash-table:
68439 ** This condition filters out normal hash-table collisions.
68443 ** table after the current read-transaction had started.
68445 iMinHash = walFramePage(pWal->minFrame);
68446 for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){
68462 if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
68466 if( (nCollide--)==0 ){
68477 ** of the wal-index file content. Make sure the results agree with the
68482 assert( pWal->bShmUnreliable || pWal->minFrame>0 );
68483 for(iTest=iLast; iTest>=pWal->minFrame && iTest>0; iTest--){
68534 sz = pWal->hdr.szPage;
68540 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
68547 if( pWal && ALWAYS(pWal->readLock>=0) ){
68548 return pWal->hdr.nPage;
68571 /* If the write-lock is already held, then it was obtained before the
68572 ** read-transaction was even opened, making this call a no-op.
68574 if( pWal->writeLock ){
68575 assert( !memcmp(&pWal->hdr,(void *)walIndexHdr(pWal),sizeof(WalIndexHdr)) );
68582 assert( pWal->readLock>=0 );
68583 assert( pWal->writeLock==0 && pWal->iReCksum==0 );
68585 if( pWal->readOnly ){
68596 pWal->writeLock = 1;
68603 if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
68611 pWal->writeLock = 0;
68621 if( pWal->writeLock ){
68623 pWal->writeLock = 0;
68624 pWal->iReCksum = 0;
68625 pWal->truncateOnCommit = 0;
68632 ** function moves the write-pointer back to the start of the transaction.
68644 if( ALWAYS(pWal->writeLock) ){
68645 Pgno iMax = pWal->hdr.mxFrame;
68649 /* Restore the clients cache of the wal-index header to the state it
68652 memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
68654 for(iFrame=pWal->hdr.mxFrame+1;
68660 ** (b) has an outstanding reference, then xUndo is either a no-op
68672 if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);
68686 assert( pWal->writeLock );
68687 aWalData[0] = pWal->hdr.mxFrame;
68688 aWalData[1] = pWal->hdr.aFrameCksum[0];
68689 aWalData[2] = pWal->hdr.aFrameCksum[1];
68690 aWalData[3] = pWal->nCkpt;
68702 assert( pWal->writeLock );
68703 assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
68705 if( aWalData[3]!=pWal->nCkpt ){
68706 /* This savepoint was opened immediately after the write-transaction
68711 aWalData[3] = pWal->nCkpt;
68714 if( aWalData[0]<pWal->hdr.mxFrame ){
68715 pWal->hdr.mxFrame = aWalData[0];
68716 pWal->hdr.aFrameCksum[0] = aWalData[1];
68717 pWal->hdr.aFrameCksum[1] = aWalData[2];
68732 ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
68736 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
68743 if( pWal->readLock==0 ){
68745 assert( pInfo->nBackfill==pWal->hdr.mxFrame );
68746 if( pInfo->nBackfill>0 ){
68749 rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
68754 ** wal-index header to reflect this.
68757 ** at this point. But updating the actual wal-index header is also
68761 walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
68767 pWal->readLock = -1;
68783 ** the next fsync should occur - passed from sqlite3WalFrames() into
68796 ** Do a sync when crossing the p->iSyncPoint boundary.
68809 if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
68810 int iFirstAmt = (int)(p->iSyncPoint - iOffset);
68811 rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
68814 iAmt -= iFirstAmt;
68816 assert( WAL_SYNC_FLAGS(p->syncFlags)!=0 );
68817 rc = sqlite3OsSync(p->pFd, WAL_SYNC_FLAGS(p->syncFlags));
68820 rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);
68835 u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */
68836 pData = pPage->pData;
68837 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
68841 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
68854 const int szPage = pWal->szPage;/* Database page size */
68857 u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-headers in */
68867 ** wal-file header. Otherwise, read them from the frame header of the
68869 assert( pWal->iReCksum>0 );
68870 if( pWal->iReCksum==1 ){
68873 iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16;
68875 rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
68876 pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf);
68877 pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]);
68879 iRead = pWal->iReCksum;
68880 pWal->iReCksum = 0;
68883 rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
68890 rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff);
68899 ** Write a set of frames to the log. The caller must hold the write-lock
68904 int szPage, /* Database page-size in bytes */
68922 assert( pWal->writeLock );
68929 { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
68931 pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
68936 if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){
68937 iFirst = pLive->mxFrame+1;
68941 ** log file, instead of appending to it at pWal->hdr.mxFrame.
68951 iFrame = pWal->hdr.mxFrame;
68953 u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */
68954 u32 aCksum[2]; /* Checksum for wal-header */
68959 sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
68960 if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);
68961 memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
68962 walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);
68966 pWal->szPage = szPage;
68967 pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;
68968 pWal->hdr.aFrameCksum[0] = aCksum[0];
68969 pWal->hdr.aFrameCksum[1] = aCksum[1];
68970 pWal->truncateOnCommit = 1;
68972 rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
68973 WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
68980 ** an out-of-order write following a WAL restart could result in
68985 if( pWal->syncHeader ){
68986 rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
68990 if( (int)pWal->szPage!=szPage ){
68996 w.pFd = pWal->pWalFd;
69004 for(p=pList; p; p=p->pDirty){
69009 ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that
69011 if( iFirst && (p->pDirty || isCommit==0) ){
69013 VVA_ONLY(rc =) walFindFrame(pWal, p->pgno, &iWrite);
69018 if( pWal->iReCksum==0 || iWrite<pWal->iReCksum ){
69019 pWal->iReCksum = iWrite;
69021 pData = p->pData;
69022 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
69024 p->flags &= ~PGHDR_WAL_APPEND;
69031 nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
69036 p->flags |= PGHDR_WAL_APPEND;
69040 if( isCommit && pWal->iReCksum ){
69061 if( pWal->padToSectorBoundary ){
69062 int sectorSize = sqlite3SectorSize(pWal->pWalFd);
69063 w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
69084 if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){
69085 i64 sz = pWal->mxWalSize;
69086 if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){
69090 pWal->truncateOnCommit = 0;
69093 /* Append data to the wal-index. It is not necessary to lock the
69094 ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index
69098 iFrame = pWal->hdr.mxFrame;
69099 for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
69100 if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue;
69102 rc = walIndexAppend(pWal, iFrame, p->pgno);
69107 nExtra--;
69108 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
69113 pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
69116 pWal->hdr.mxFrame = iFrame;
69118 pWal->hdr.iChange++;
69119 pWal->hdr.nPage = nTruncate;
69121 /* If this is a commit, update the wal-index header too. */
69124 pWal->iCallback = iFrame;
69133 ** Write a set of frames to the log. The caller must hold the write-lock
69141 int szPage, /* Database page-size in bytes */
69162 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
69178 int isChanged = 0; /* True if a new wal-index header is loaded */
69182 assert( pWal->ckptLock==0 );
69183 assert( pWal->writeLock==0 );
69185 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
69189 if( pWal->readOnly ) return SQLITE_READONLY;
69196 /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive
69198 ** EVIDENCE-OF: R-10421-19736 If any other process is running a
69201 ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured,
69208 pWal->ckptLock = 1;
69210 /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and
69214 ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained
69215 ** immediately, and a busy-handler is configured, it is invoked and the
69216 ** writer lock retried until either the busy-handler returns 0 or the
69222 pWal->writeLock = 1;
69232 /* Read the wal-index header. */
69235 /* For a passive checkpoint, do not re-enable blocking locks after
69236 ** reading the wal-index header. A passive checkpoint should not block
69238 ** attempt to obtain is a lock on a read-slot, and it should give up
69243 if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){
69244 sqlite3OsUnfetch(pWal->pDbFd, 0, 0);
69250 if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
69258 if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
69260 if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
69267 /* If a new wal-index header was loaded before the checkpoint was
69268 ** performed, then the pager-cache associated with pWal is now
69269 ** out of date. So zero the cached wal-index header to ensure that
69273 memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
69281 if( pWal->ckptLock ){
69283 pWal->ckptLock = 0;
69300 ret = pWal->iCallback;
69301 pWal->iCallback = 0;
69312 ** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL
69314 ** transition out of exclusive-mode is successful, return 1. This
69319 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
69321 ** WAL is already in exclusive-locking mode - meaning that this
69322 ** routine is a no-op. The pager must already hold the exclusive lock
69325 ** If op is negative, then do a dry-run of the op==1 case but do
69332 assert( pWal->writeLock==0 );
69333 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
69335 /* pWal->readLock is usually set, but might be -1 if there was a
69336 ** prior error while attempting to acquire are read-lock. This cannot
69339 ** upgrade to exclusive-mode following such an error.
69342 assert( pWal->readLock>=0 || pWal->lockError );
69344 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
69347 if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){
69348 pWal->exclusiveMode = WAL_NORMAL_MODE;
69349 if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
69350 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
69352 rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
69358 assert( pWal->exclusiveMode==WAL_NORMAL_MODE );
69359 assert( pWal->readLock>=0 );
69360 walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
69361 pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
69364 rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
69370 ** Return true if the argument is non-NULL and the WAL module is using
69371 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
69372 ** WAL module is using shared-memory, return false.
69375 return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );
69388 assert( pWal->readLock>=0 && pWal->writeLock==0 );
69390 if( memcmp(&pWal->hdr.aFrameCksum[0],aZero,16)==0 ){
69398 memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr));
69405 /* Try to open on pSnapshot when the next read-transaction starts
69411 pWal->pSnapshot = (WalIndexHdr*)pSnapshot;
69415 ** Return a +ve value if snapshot p1 is newer than p2. A -ve value if
69424 if( pHdr1->aSalt[0]<pHdr2->aSalt[0] ) return -1;
69425 if( pHdr1->aSalt[0]>pHdr2->aSalt[0] ) return +1;
69426 if( pHdr1->mxFrame<pHdr2->mxFrame ) return -1;
69427 if( pHdr1->mxFrame>pHdr2->mxFrame ) return +1;
69448 if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
69449 || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
69475 ** read-lock. This function returns the database page-size if it is known,
69479 assert( pWal==0 || pWal->readLock>=0 );
69480 return (pWal ? pWal->szPage : 0);
69487 return pWal->pWalFd;
69524 ** This file implements an external (disk-based) database using BTrees.
69528 ** "Sorting And Searching", pages 473-480. Addison-Wesley
69534 ** ----------------------------------------------------------------
69535 ** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) |
69536 ** ----------------------------------------------------------------
69541 ** on Ptr(N) and its subpages have values greater than Key(N-1). And
69563 ** page, or a pointer-map page.
69565 ** The first page is always a btree page. The first 100 bytes of the first
69582 ** 40 60 15 4-byte meta values passed to higher layers
69587 ** 52 4 Largest root-page (auto/incr_vacuum)
69588 ** 56 4 1=UTF-8 2=UTF16le 3=UTF16be
69591 ** 68 4 Application-ID
69593 ** 92 4 The version-valid-for number
69596 ** All of the integer values are big-endian (most significant byte first).
69604 ** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default
69615 ** payload fraction for a LEAFDATA tree is always 100% (or 255) and it
69619 ** cell pointer array, and the cell content area. Page 1 also has a 100-byte
69622 ** |----------------|
69623 ** | file header | 100 bytes. Page 1 only.
69624 ** |----------------|
69626 ** |----------------|
69630 ** |----------------|
69633 ** |----------------| ^ Grows upwards
69636 ** |----------------|
69655 ** The cell pointer array contains zero or more 2-byte numbers which are
69686 ** appears first. A variable-length integer may not be more than 9 bytes long.
69688 ** allows a 64-bit integer to be encoded in 9 bytes.
69711 ** filled with data (pagesize - 4 bytes). The last page can have as little
69734 #define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))
69741 #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
69752 ** You can change this value at compile-time by specifying a
69753 ** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The
69754 ** header must be exactly 16 bytes including the zero-terminator so
69766 ** first byte of on-disk image of every BTree page.
69776 ** is derived from the raw on-disk page content.
69783 ** stored in MemPage.pBt->mutex.
69787 u8 intKey; /* True if table b-trees. False for index b-trees */
69793 u8 hdrOffset; /* 100 for page 1. 0 otherwise */
69800 int nFree; /* Number of free bytes on the page. -1 for unknown */
69803 u16 aiOvfl[4]; /* Insert the i-th overflow cell before the aiOvfl-th
69804 ** non-overflow cell */
69808 u8 *aDataEnd; /* One byte past the end of the entire page - not just
69810 ** corruption-induced buffer overflow. */
69866 u32 iBDataVersion; /* Combines with pBt->pPager->iDataVersion */
69880 ** If the shared-data extension is enabled, there may be multiple users
69892 # error wrong numeric code for no-transaction
69895 # error wrong numeric code for read-transaction
69898 # error wrong numeric code for write-transaction
69921 ** If a BtShared client fails to obtain a write-lock on a database
69922 ** table (because there exists one or more read-locks on the table),
69923 ** the shared-cache enters 'pending-lock' state and isPending is
69926 ** The shared-cache leaves the 'pending lock' state when either of
69932 ** while in the 'pending-lock' state, no connection may start a new
69935 ** This feature is included to help prevent writer-starvation.
69944 u8 autoVacuum; /* True if auto-vacuum is enabled */
69945 u8 incrVacuum; /* True if incr-vacuum is enabled */
69949 u8 max1bytePayload; /* Maximum first byte of cell for a 1-byte payload */
69952 u16 maxLocal; /* Maximum local payload in non-LEAFDATA tables */
69953 u16 minLocal; /* Minimum local payload in non-LEAFDATA tables */
69962 sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */
69963 Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
69967 BtLock *pLock; /* List of locks held on this shared-btree struct */
69983 #define BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */
69985 #define BTS_PENDING 0x0080 /* Waiting for read-locks to clear */
69997 u16 nSize; /* Size of the cell content on the main b-tree page */
70001 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
70004 ** root-node and 3 for all other internal nodes.
70013 ** b-tree within a database file.
70023 ** found at self->pBt->mutex.
70031 ** SKIPNEXT sqlite3BtreeNext() is a no-op if skipNext>0 and
70032 ** sqlite3BtreePrevious() is no-op if skipNext<0.
70057 u8 curIntKey; /* Value of apPage[0]->intKey */
70059 u16 aiIdx[BTCURSOR_MAX_DEPTH-1]; /* Current index in apPage[i] */
70062 MemPage *apPage[BTCURSOR_MAX_DEPTH-1]; /* Stack of parents of current page */
70088 ** Cursor is valid except that the Cursor.skipNext field is non-zero
70090 ** operation should be a no-op.
70115 #define PENDING_BYTE_PAGE(pBt) ((Pgno)((PENDING_BYTE/((pBt)->pageSize))+1))
70118 ** These macros define the location of the pointer-map entry for a
70123 ** PTRMAP_PAGENO returns the database page number of the pointer-map
70127 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
70129 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
70133 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
70150 ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
70153 ** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number
70161 ** overflow pages. The page-number identifies the previous
70164 ** PTRMAP_BTREE: The database page is a non-root btree page. The page number
70177 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
70178 assert( p->pBt->inTransaction>=p->inTrans );
70183 ** if the database supports auto-vacuum or not. Because it is used
70189 #define ISAUTOVACUUM(pBt) (pBt->autoVacuum)
70200 ** the database. As the integrity-check proceeds, for each page used in
70201 ** the database the corresponding bit is set. This allows integrity-check to
70208 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
70220 u32 *heap; /* Min-heap used for analyzing cell coverage */
70226 ** Routines to read or write a two- and four-byte big-endian integer values.
70235 ** two-byte aligned address. get2byteAligned() is only used for accessing the
70254 ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
70256 ** p->locked boolean to true.
70259 assert( p->locked==0 );
70260 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
70261 assert( sqlite3_mutex_held(p->db->mutex) );
70263 sqlite3_mutex_enter(p->pBt->mutex);
70264 p->pBt->db = p->db;
70265 p->locked = 1;
70269 ** Release the BtShared mutex associated with B-Tree handle p and
70270 ** clear the p->locked boolean.
70273 BtShared *pBt = p->pBt;
70274 assert( p->locked==1 );
70275 assert( sqlite3_mutex_held(pBt->mutex) );
70276 assert( sqlite3_mutex_held(p->db->mutex) );
70277 assert( p->db==pBt->db );
70279 sqlite3_mutex_leave(pBt->mutex);
70280 p->locked = 0;
70290 ** and this routine is a no-op. The underlying mutex is non-recursive.
70295 ** by all database connections. The p->pNext is a list of other
70298 ** p, then first unlock all of the others on p->pNext, then wait
70307 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
70308 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
70309 assert( p->pNext==0 || p->pNext->db==p->db );
70310 assert( p->pPrev==0 || p->pPrev->db==p->db );
70311 assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
70314 assert( !p->locked || p->wantToLock>0 );
70315 assert( p->sharable || p->wantToLock==0 );
70318 assert( sqlite3_mutex_held(p->db->mutex) );
70322 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
70324 if( !p->sharable ) return;
70325 p->wantToLock++;
70326 if( p->locked ) return;
70343 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
70344 p->pBt->db = p->db;
70345 p->locked = 1;
70354 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
70355 assert( pLater->sharable );
70356 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
70357 assert( !pLater->locked || pLater->wantToLock>0 );
70358 if( pLater->locked ){
70363 for(pLater=p->pNext; pLater; pLater=pLater->pNext){
70364 if( pLater->wantToLock ){
70375 assert( sqlite3_mutex_held(p->db->mutex) );
70376 if( p->sharable ){
70377 assert( p->wantToLock>0 );
70378 p->wantToLock--;
70379 if( p->wantToLock==0 ){
70388 ** B-Tree is not marked as sharable.
70393 assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
70394 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
70395 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
70396 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
70398 return (p->sharable==0 || p->locked);
70410 ** There is a corresponding leave-all procedures.
70421 assert( sqlite3_mutex_held(db->mutex) );
70422 for(i=0; i<db->nDb; i++){
70423 p = db->aDb[i].pBt;
70424 if( p && p->sharable ){
70429 db->noSharedCache = skipOk;
70432 if( db->noSharedCache==0 ) btreeEnterAll(db);
70437 assert( sqlite3_mutex_held(db->mutex) );
70438 for(i=0; i<db->nDb; i++){
70439 p = db->aDb[i].pBt;
70444 if( db->noSharedCache==0 ) btreeLeaveAll(db);
70456 if( !sqlite3_mutex_held(db->mutex) ){
70459 for(i=0; i<db->nDb; i++){
70461 p = db->aDb[i].pBt;
70462 if( p && p->sharable &&
70463 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
70474 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
70478 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
70486 if( db->pVfs==0 && db->nDb==0 ) return 1;
70488 assert( iDb>=0 && iDb<db->nDb );
70489 if( !sqlite3_mutex_held(db->mutex) ) return 0;
70491 p = db->aDb[iDb].pBt;
70493 return p->sharable==0 || p->locked==1;
70501 ** these two routines, all mutex operations are no-ops in that case and
70505 ** the ones below, are no-ops and are null #defines in btree.h.
70509 p->pBt->db = p->db;
70513 for(i=0; i<db->nDb; i++){
70514 Btree *p = db->aDb[i].pBt;
70516 p->pBt->db = p->db;
70531 sqlite3BtreeEnter(pCur->pBtree);
70535 sqlite3BtreeLeave(pCur->pBtree);
70555 ** This file implements an external (disk-based) database using BTrees.
70579 ** Extract a 2-byte big-endian integer from an array of unsigned bytes.
70584 ** is empty, the offset should be 65536, but the 2-byte value stores zero.
70587 #define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)
70600 ** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum);
70645 ** shared-cache table level locks. If the library is compiled with the
70646 ** shared-cache feature disabled, then there is only ever one user
70648 ** So define the lock related functions as no-ops.
70663 u64 n = pBt->nSeek;
70664 pBt->nSeek = 0;
70675 ** normally produced as a side-effect of SQLITE_CORRUPT_BKPT is augmented
70683 p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
70694 # define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)
70697 /* Default value for SHARED_LOCK_TRACE macro if shared-cache is disabled
70701 #define SHARED_LOCK_TRACE(X,MSG,TAB,TYPE) /*no-op*/
70706 /* ^---- Change to 1 and recompile to enable shared-lock tracing
70709 ** Print all shared-cache locks on a BtShared. Debugging use only.
70719 printf("%s-%p %u%s:", zMsg, pBt, iRoot, eLockType==READ_LOCK?"R":"W");
70721 printf("%s-%p:", zMsg, pBt);
70723 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
70724 printf(" %p/%u%s", pLock->pBtree, pLock->iTable,
70725 pLock->eLock==READ_LOCK ? "R" : "W");
70726 while( pLock->pNext && pLock->pBtree==pLock->pNext->pBtree ){
70727 pLock = pLock->pNext;
70728 printf(",%u%s", pLock->iTable, pLock->eLock==READ_LOCK ? "R" : "W");
70736 #endif /* Shared-lock tracing */
70745 ** For example, when writing to a table with root-page iRoot via
70758 ** hold a write-lock on the schema table (root page 1). This is also
70763 Pgno iRoot, /* Root page of b-tree */
70764 int isIndex, /* True if iRoot is the root of an index b-tree */
70767 Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
70772 ** and has the read-uncommitted flag set, then no lock is required.
70775 if( (pBtree->sharable==0)
70776 || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommit))
70783 ** the correct locks are held. So do not bother - just return true.
70786 if( isIndex && (!pSchema || (pSchema->schemaFlags&DB_SchemaLoaded)==0) ){
70790 /* Figure out the root-page that the lock should be held on. For table
70791 ** b-trees, this is just the root page of the b-tree being read or
70792 ** written. For index b-trees, it is the root page of the associated
70797 for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){
70799 if( pIdx->tnum==iRoot ){
70806 iTab = pIdx->pTable->tnum;
70814 SHARED_LOCK_TRACE(pBtree->pBt,"hasLock",iRoot,eLockType);
70816 /* Search for the required lock. Either a write-lock on root-page iTab, a
70817 ** write-lock on the schema table, or (if the client is reading) a
70818 ** read-lock on iTab will suffice. Return 1 if any of these are found. */
70819 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
70820 if( pLock->pBtree==pBtree
70821 && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
70822 && pLock->eLock>=eLockType
70844 ** read-uncommitted flag set, then it is OK for the other object to
70854 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
70855 if( p->pgnoRoot==iRoot
70856 && p->pBtree!=pBtree
70857 && 0==(p->pBtree->db->flags & SQLITE_ReadUncommit)
70868 ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
70873 BtShared *pBt = p->pBt;
70878 assert( p->db!=0 );
70879 assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 );
70881 /* If requesting a write-lock, then the Btree must have an open write
70885 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
70886 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
70888 /* This routine is a no-op if the shared-cache is not enabled */
70889 if( !p->sharable ){
70896 if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
70897 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
70901 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70902 /* The condition (pIter->eLock!=eLock) in the following if(...)
70905 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
70911 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
70912 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
70913 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
70914 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
70916 assert( p==pBt->pWriter );
70917 pBt->btsFlags |= BTS_PENDING;
70928 ** Add a lock on the table with root-page iTable to the shared-btree used
70945 BtShared *pBt = p->pBt;
70953 assert( p->db!=0 );
70955 /* A connection with the read-uncommitted flag set will never try to
70956 ** obtain a read-lock using this function. The only read-lock obtained
70957 ** by a connection in read-uncommitted mode is on the sqlite_schema
70959 assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK );
70961 /* This function should only be called on a sharable b-tree after it
70962 ** has been determined that no other b-tree holds a conflicting lock. */
70963 assert( p->sharable );
70967 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70968 if( pIter->iTable==iTable && pIter->pBtree==p ){
70982 pLock->iTable = iTable;
70983 pLock->pBtree = p;
70984 pLock->pNext = pBt->pLock;
70985 pBt->pLock = pLock;
70989 ** and the requested lock. This means if a write-lock was already held
70990 ** and a read-lock requested, we don't incorrectly downgrade the lock.
70993 if( eLock>pLock->eLock ){
70994 pLock->eLock = eLock;
71011 BtShared *pBt = p->pBt;
71012 BtLock **ppIter = &pBt->pLock;
71015 assert( p->sharable || 0==*ppIter );
71016 assert( p->inTrans>0 );
71022 assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
71023 assert( pLock->pBtree->inTrans>=pLock->eLock );
71024 if( pLock->pBtree==p ){
71025 *ppIter = pLock->pNext;
71026 assert( pLock->iTable!=1 || pLock==&p->lock );
71027 if( pLock->iTable!=1 ){
71031 ppIter = &pLock->pNext;
71035 assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
71036 if( pBt->pWriter==p ){
71037 pBt->pWriter = 0;
71038 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
71039 }else if( pBt->nTransaction==2 ){
71049 pBt->btsFlags &= ~BTS_PENDING;
71054 ** This function changes all write-locks held by Btree p into read-locks.
71057 BtShared *pBt = p->pBt;
71061 if( pBt->pWriter==p ){
71063 pBt->pWriter = 0;
71064 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
71065 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
71066 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
71067 pLock->eLock = READ_LOCK;
71085 return sqlite3_mutex_held(p->pBt->mutex);
71089 ** database connetion. This is important in shared-cache mode. If the database
71090 ** connection pointers get out-of-sync, it is possible for routines like
71093 ** statements only and for the purpose of double-checking that the btree code
71094 ** does keep the database connection pointers up-to-date.
71098 return (p->pBtree->db==p->pBt->db);
71106 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
71109 ** Invalidate the overflow page-list cache for all cursors opened
71114 assert( sqlite3_mutex_held(pBt->mutex) );
71115 for(p=pBt->pCursor; p; p=p->pNext){
71128 ** cursors open on any row within the table with root-page pgnoRoot.
71141 assert( pBtree->hasIncrblobCur );
71143 pBtree->hasIncrblobCur = 0;
71144 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
71145 if( (p->curFlags & BTCF_Incrblob)!=0 ){
71146 pBtree->hasIncrblobCur = 1;
71147 if( p->pgnoRoot==pgnoRoot && (isClearTable || p->info.nKey==iRow) ){
71148 p->eState = CURSOR_INVALID;
71161 ** when a page that previously contained data becomes a free-list leaf
71166 ** free-list leaf pages:
71169 ** a free-list leaf page, the page is not written to the database
71170 ** (as free-list leaf pages contain no meaningful data). Sometimes
71174 ** 2) When a free-list leaf page is reused, its content is not read
71180 ** a page is moved to the free-list and then reused within the same
71182 ** it is moved to the free-list and it is also not journalled when it
71183 ** is extracted from the free-list and reused, then the original data
71188 ** moved to become a free-list leaf page, the corresponding bit is
71189 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
71196 if( !pBt->pHasContent ){
71197 assert( pgno<=pBt->nPage );
71198 pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
71199 if( !pBt->pHasContent ){
71203 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
71204 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
71212 ** This function is called when a free-list leaf page is removed from the
71213 ** free-list for reuse. It returns false if it is safe to retrieve the
71214 ** page from the pager layer with the 'no-content' flag set. True otherwise.
71217 Bitvec *p = pBt->pHasContent;
71223 ** invoked at the conclusion of each write-transaction.
71226 sqlite3BitvecDestroy(pBt->pHasContent);
71227 pBt->pHasContent = 0;
71235 if( pCur->iPage>=0 ){
71236 for(i=0; i<pCur->iPage; i++){
71237 releasePageNotNull(pCur->apPage[i]);
71239 releasePageNotNull(pCur->pPage);
71240 pCur->iPage = -1;
71247 ** function saves the current cursor key in variables pCur->nKey and
71248 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
71252 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
71253 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
71254 ** set to point to a malloced buffer pCur->nKey bytes in size containing
71259 assert( CURSOR_VALID==pCur->eState );
71260 assert( 0==pCur->pKey );
71263 if( pCur->curIntKey ){
71265 pCur->nKey = sqlite3BtreeIntegerKey(pCur);
71270 ** up to the size of 1 varint plus 1 8-byte value when the cursor
71274 pCur->nKey = sqlite3BtreePayloadSize(pCur);
71275 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
71277 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
71279 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
71280 pCur->pKey = pKey;
71288 assert( !pCur->curIntKey || !pCur->pKey );
71302 assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
71303 assert( 0==pCur->pKey );
71306 if( pCur->curFlags & BTCF_Pinned ){
71309 if( pCur->eState==CURSOR_SKIPNEXT ){
71310 pCur->eState = CURSOR_VALID;
71312 pCur->skipNext = 0;
71318 pCur->eState = CURSOR_REQUIRESEEK;
71321 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
71330 ** the table with root-page iRoot. "Saving the cursor position" means that
71341 ** If pExpect!=NULL and if no other cursors are found on the same root-page,
71351 assert( sqlite3_mutex_held(pBt->mutex) );
71352 assert( pExcept==0 || pExcept->pBt==pBt );
71353 for(p=pBt->pCursor; p; p=p->pNext){
71354 if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break;
71357 if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple;
71372 if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){
71373 if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
71379 testcase( p->iPage>=0 );
71383 p = p->pNext;
71393 sqlite3_free(pCur->pKey);
71394 pCur->pKey = 0;
71395 pCur->eState = CURSOR_INVALID;
71414 KeyInfo *pKeyInfo = pCur->pKeyInfo;
71419 if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
71424 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
71443 assert( pCur->eState>=CURSOR_REQUIRESEEK );
71444 if( pCur->eState==CURSOR_FAULT ){
71445 return pCur->skipNext;
71447 pCur->eState = CURSOR_INVALID;
71451 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
71454 sqlite3_free(pCur->pKey);
71455 pCur->pKey = 0;
71456 assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
71457 if( skipNext ) pCur->skipNext = skipNext;
71458 if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
71459 pCur->eState = CURSOR_SKIPNEXT;
71466 (p->eState>=CURSOR_REQUIRESEEK ? \
71486 assert( sizeof(pCur->eState)==1 );
71518 assert( pCur->eState!=CURSOR_VALID );
71524 if( pCur->eState!=CURSOR_VALID ){
71565 pCur->hints = x;
71572 ** number for the pointer-map page that contains the entry for the
71582 assert( sqlite3_mutex_held(pBt->mutex) );
71584 nPagesPerMapPage = (pBt->usableSize/5)+1;
71585 iPtrMap = (pgno-2)/nPagesPerMapPage;
71599 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
71600 ** a no-op. If an error occurs, the appropriate error code is written
71612 assert( sqlite3_mutex_held(pBt->mutex) );
71613 /* The super-journal page number must never be used as a pointer map page */
71616 assert( pBt->autoVacuum );
71622 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
71639 assert( offset <= (int)pBt->usableSize-5 );
71643 TRACE(("PTRMAP_UPDATE: %u->(%u,%u)\n", key, eType, parent));
71669 assert( sqlite3_mutex_held(pBt->mutex) );
71672 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
71683 assert( offset <= (int)pBt->usableSize-5 );
71705 ** 4-byte child pointer found on interior pages, if there is one.
71710 ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
71712 ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
71718 ** on a single B-tree page. Make necessary adjustments to the CellInfo
71739 minLocal = pPage->minLocal;
71740 maxLocal = pPage->maxLocal;
71741 surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4);
71745 pInfo->nLocal = (u16)surplus;
71747 pInfo->nLocal = (u16)minLocal;
71749 pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4;
71758 maxLocal = pPage->maxLocal;
71764 minLocal = pPage->minLocal;
71765 surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize-4);
71789 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
71790 assert( pPage->leaf==0 );
71791 assert( pPage->childPtrSize==4 );
71795 pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey);
71796 pInfo->nPayload = 0;
71797 pInfo->nLocal = 0;
71798 pInfo->pPayload = 0;
71810 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
71811 assert( pPage->leaf==0 || pPage->leaf==1 );
71812 assert( pPage->intKeyLeaf );
71813 assert( pPage->childPtrSize==0 );
71834 ** pIter += getVarint(pIter, (u64*)&pInfo->nKey);
71837 ** This routine is a high-runner.
71871 pInfo->nKey = *(i64*)&iKey;
71872 pInfo->nPayload = nPayload;
71873 pInfo->pPayload = pIter;
71874 testcase( nPayload==pPage->maxLocal );
71875 testcase( nPayload==(u32)pPage->maxLocal+1 );
71876 if( nPayload<=pPage->maxLocal ){
71880 pInfo->nSize = nPayload + (u16)(pIter - pCell);
71881 if( pInfo->nSize<4 ) pInfo->nSize = 4;
71882 pInfo->nLocal = (u16)nPayload;
71895 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
71896 assert( pPage->leaf==0 || pPage->leaf==1 );
71897 assert( pPage->intKeyLeaf==0 );
71898 pIter = pCell + pPage->childPtrSize;
71908 pInfo->nKey = nPayload;
71909 pInfo->nPayload = nPayload;
71910 pInfo->pPayload = pIter;
71911 testcase( nPayload==pPage->maxLocal );
71912 testcase( nPayload==(u32)pPage->maxLocal+1 );
71913 if( nPayload<=pPage->maxLocal ){
71917 pInfo->nSize = nPayload + (u16)(pIter - pCell);
71918 if( pInfo->nSize<4 ) pInfo->nSize = 4;
71919 pInfo->nLocal = (u16)nPayload;
71929 pPage->xParseCell(pPage, findCell(pPage, iCell), pInfo);
71937 ** data area of the btree-page. The return number includes the cell
71957 pPage->xParseCell(pPage, pCell, &debuginfo);
71960 assert( pPage->childPtrSize==4 );
71970 testcase( nSize==pPage->maxLocal );
71971 testcase( nSize==(u32)pPage->maxLocal+1 );
71972 if( nSize<=pPage->maxLocal ){
71973 nSize += (u32)(pIter - pCell);
71976 int minLocal = pPage->minLocal;
71977 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
71978 testcase( nSize==pPage->maxLocal );
71979 testcase( nSize==(u32)pPage->maxLocal+1 );
71980 if( nSize>pPage->maxLocal ){
71983 nSize += 4 + (u16)(pIter - pCell);
71999 pPage->xParseCell(pPage, pCell, &debuginfo);
72002 assert( pPage->childPtrSize==0 );
72012 testcase( nSize==pPage->maxLocal );
72013 testcase( nSize==(u32)pPage->maxLocal+1 );
72014 if( nSize<=pPage->maxLocal ){
72015 nSize += (u32)(pIter - pCell);
72018 int minLocal = pPage->minLocal;
72019 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
72020 testcase( nSize==pPage->maxLocal );
72021 testcase( nSize==(u32)pPage->maxLocal+1 );
72022 if( nSize>pPage->maxLocal ){
72025 nSize += 4 + (u16)(pIter - pCell);
72040 pPage->xParseCell(pPage, pCell, &debuginfo);
72045 assert( pPage->childPtrSize==4 );
72048 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
72049 return (u16)(pIter - pCell);
72062 pPage->xParseCell(pPage, pCell, &debuginfo);
72074 /* pIter now points at the 64-bit integer key value, a variable length
72085 testcase( nSize==pPage->maxLocal );
72086 testcase( nSize==(u32)pPage->maxLocal+1 );
72087 if( nSize<=pPage->maxLocal ){
72088 nSize += (u32)(pIter - pCell);
72091 int minLocal = pPage->minLocal;
72092 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
72093 testcase( nSize==pPage->maxLocal );
72094 testcase( nSize==(u32)pPage->maxLocal+1 );
72095 if( nSize>pPage->maxLocal ){
72098 nSize += 4 + (u16)(pIter - pCell);
72109 return pPage->xCellSize(pPage, findCell(pPage, iCell));
72117 ** pointer to an overflow page, insert an entry into the pointer-map for
72124 pPage->xParseCell(pPage, pCell, &info);
72127 if( SQLITE_OVERFLOW(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
72132 ovfl = get4byte(&pCell[info.nSize-4]);
72133 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
72141 ** page so that there are no free-blocks on the free-block list.
72146 ** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
72147 ** b-tree page so that there are no freeblocks or fragment bytes, all
72153 int pc; /* Address of the i-th cell */
72167 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
72168 assert( pPage->pBt!=0 );
72169 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
72170 assert( pPage->nOverflow==0 );
72171 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72172 data = pPage->aData;
72173 hdr = pPage->hdrOffset;
72174 cellOffset = pPage->cellOffset;
72175 nCell = pPage->nCell;
72178 usableSize = pPage->pBt->usableSize;
72183 ** offsets to each pointer in the cell-pointer array than it is to
72187 if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
72190 if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
72204 memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
72211 assert( cbrk+(iFree-top) <= usableSize );
72212 memmove(&data[cbrk], &data[top], iFree-top);
72224 iCellLast = usableSize - 4;
72227 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
72231 u8 *pAddr; /* The i-th cell pointer */
72243 size = pPage->xCellSize(pPage, &src[pc]);
72244 cbrk -= size;
72258 assert( pPage->nFree>=0 );
72259 if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
72266 memset(&data[iCellFirst], 0, cbrk-iCellFirst);
72267 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
72272 ** Search the free-list on page pPg for space to store a cell nByte bytes in
72274 ** from the free-list.
72276 ** If no suitable space can be found on the free-list, return NULL.
72286 const int hdr = pPg->hdrOffset; /* Offset to page header */
72287 u8 * const aData = pPg->aData; /* Page data */
72292 int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */
72297 /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
72298 ** freeblock form a big-endian integer which is the size of the freeblock
72299 ** in bytes, including the 4-byte header. */
72302 if( (x = size - nByte)>=0 ){
72306 /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total
72310 /* Remove the slot from the free-list. Update the number of
72320 /* The slot remains on the free-list. Reduce its size to account
72337 if( pc>maxPC+nByte-4 ){
72345 ** Allocate nByte bytes of space from within the B-Tree page passed
72346 ** as the first argument. Write into *pIdx the index into pPage->aData[]
72358 const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */
72359 u8 * const data = pPage->aData; /* Local cache of pPage->aData */
72365 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
72366 assert( pPage->pBt );
72367 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72369 assert( pPage->nFree>=nByte );
72370 assert( pPage->nOverflow==0 );
72371 assert( nByte < (int)(pPage->pBt->usableSize-8) );
72373 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
72374 gap = pPage->cellOffset + 2*pPage->nCell;
72376 /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size
72379 ** However, that integer is too large to be stored in a 2-byte unsigned
72384 if( top==0 && pPage->pBt->usableSize==65536 ){
72389 }else if( top>(int)pPage->pBt->usableSize ){
72404 assert( pSpace+nByte<=data+pPage->pBt->usableSize );
72405 *pIdx = g2 = (int)(pSpace-data);
72421 assert( pPage->nCell>0 || CORRUPT_DB );
72422 assert( pPage->nFree>=0 );
72423 rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
72436 top -= nByte;
72438 assert( top+nByte <= (int)pPage->pBt->usableSize );
72444 ** Return a section of the pPage->aData to the freelist.
72445 ** The first byte of the new free block is pPage->aData[iStart]
72459 u8 hdr; /* Page header size. 0 or 100 */
72464 unsigned char *data = pPage->aData; /* Page content */
72467 assert( pPage->pBt!=0 );
72468 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
72469 assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize );
72470 assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize );
72471 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72473 assert( CORRUPT_DB || iStart<=pPage->pBt->usableSize-4 );
72478 hdr = pPage->hdrOffset;
72485 if( iFreeBlk==0 ) break; /* TH3: corrupt082.100 */
72490 if( iFreeBlk>pPage->pBt->usableSize-4 ){ /* TH3: corrupt081.100 */
72502 nFrag = iFreeBlk - iEnd;
72505 if( iEnd > pPage->pBt->usableSize ){
72508 iSize = iEnd - iStart;
72520 nFrag += iStart - iPtrEnd;
72521 iSize = iEnd - iPtr;
72526 data[hdr+7] -= nFrag;
72530 if( pPage->pBt->btsFlags & BTS_FAST_SECURE ){
72549 pPage->nFree += iOrigSize;
72566 BtShared *pBt; /* A copy of pPage->pBt */
72568 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
72569 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72570 pBt = pPage->pBt;
72571 pPage->max1bytePayload = pBt->max1bytePayload;
72573 pPage->childPtrSize = 0;
72574 pPage->leaf = 1;
72576 pPage->intKeyLeaf = 1;
72577 pPage->xCellSize = cellSizePtrTableLeaf;
72578 pPage->xParseCell = btreeParseCellPtr;
72579 pPage->intKey = 1;
72580 pPage->maxLocal = pBt->maxLeaf;
72581 pPage->minLocal = pBt->minLeaf;
72583 pPage->intKey = 0;
72584 pPage->intKeyLeaf = 0;
72585 pPage->xCellSize = cellSizePtrIdxLeaf;
72586 pPage->xParseCell = btreeParseCellPtrIndex;
72587 pPage->maxLocal = pBt->maxLocal;
72588 pPage->minLocal = pBt->minLocal;
72590 pPage->intKey = 0;
72591 pPage->intKeyLeaf = 0;
72592 pPage->xCellSize = cellSizePtrIdxLeaf;
72593 pPage->xParseCell = btreeParseCellPtrIndex;
72597 pPage->childPtrSize = 4;
72598 pPage->leaf = 0;
72600 pPage->intKey = 0;
72601 pPage->intKeyLeaf = 0;
72602 pPage->xCellSize = cellSizePtr;
72603 pPage->xParseCell = btreeParseCellPtrIndex;
72604 pPage->maxLocal = pBt->maxLocal;
72605 pPage->minLocal = pBt->minLocal;
72607 pPage->intKeyLeaf = 0;
72608 pPage->xCellSize = cellSizePtrNoPayload;
72609 pPage->xParseCell = btreeParseCellPtrNoPayload;
72610 pPage->intKey = 1;
72611 pPage->maxLocal = pBt->maxLeaf;
72612 pPage->minLocal = pBt->minLeaf;
72614 pPage->intKey = 0;
72615 pPage->intKeyLeaf = 0;
72616 pPage->xCellSize = cellSizePtr;
72617 pPage->xParseCell = btreeParseCellPtrIndex;
72626 ** in the pPage->nFree field.
72629 int pc; /* Address of a freeblock within pPage->aData[] */
72631 u8 *data; /* Equal to pPage->aData */
72638 assert( pPage->pBt!=0 );
72639 assert( pPage->pBt->db!=0 );
72640 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72641 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
72642 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
72643 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
72644 assert( pPage->isInit==1 );
72645 assert( pPage->nFree<0 );
72647 usableSize = pPage->pBt->usableSize;
72648 hdr = pPage->hdrOffset;
72649 data = pPage->aData;
72650 /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
72654 iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell;
72655 iCellLast = usableSize - 4;
72658 ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the
72662 nFree = data[hdr+7] + top; /* Init nFree to non-freeblock free space */
72666 /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
72693 ** of the cell-content area plus the number of free bytes within
72694 ** the cell-content area. If this is greater than the usable-size
72696 ** serves to verify that the offset to the start of the cell-content
72702 pPage->nFree = (u16)(nFree - iCellFirst);
72715 int pc; /* Address of a freeblock within pPage->aData[] */
72716 u8 *data; /* Equal to pPage->aData */
72720 iCellFirst = pPage->cellOffset + 2*pPage->nCell;
72721 usableSize = pPage->pBt->usableSize;
72722 iCellLast = usableSize - 4;
72723 data = pPage->aData;
72724 cellOffset = pPage->cellOffset;
72725 if( !pPage->leaf ) iCellLast--;
72726 for(i=0; i<pPage->nCell; i++){
72733 sz = pPage->xCellSize(pPage, &data[pc]);
72746 ** not contain a well-formed database page, then return
72748 ** guarantee that the page is well-formed. It only shows that
72752 u8 *data; /* Equal to pPage->aData */
72755 assert( pPage->pBt!=0 );
72756 assert( pPage->pBt->db!=0 );
72757 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72758 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
72759 assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
72760 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
72761 assert( pPage->isInit==0 );
72763 pBt = pPage->pBt;
72764 data = pPage->aData + pPage->hdrOffset;
72765 /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
72766 ** the b-tree page type. */
72770 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
72771 pPage->maskPage = (u16)(pBt->pageSize - 1);
72772 pPage->nOverflow = 0;
72773 pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize;
72774 pPage->aCellIdx = data + pPage->childPtrSize + 8;
72775 pPage->aDataEnd = pPage->aData + pBt->pageSize;
72776 pPage->aDataOfst = pPage->aData + pPage->childPtrSize;
72777 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
72779 pPage->nCell = get2byte(&data[3]);
72780 if( pPage->nCell>MX_CELL(pBt) ){
72784 testcase( pPage->nCell==MX_CELL(pBt) );
72785 /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
72789 assert( pPage->nCell>0
72790 || get2byteNotZero(&data[5])==(int)pBt->usableSize
72792 pPage->nFree = -1; /* Indicate that this value is yet uncomputed */
72793 pPage->isInit = 1;
72794 if( pBt->db->flags & SQLITE_CellSizeCk ){
72805 unsigned char *data = pPage->aData;
72806 BtShared *pBt = pPage->pBt;
72807 u8 hdr = pPage->hdrOffset;
72810 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno || CORRUPT_DB );
72811 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
72812 assert( sqlite3PagerGetData(pPage->pDbPage) == data );
72813 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
72814 assert( sqlite3_mutex_held(pBt->mutex) );
72815 if( pBt->btsFlags & BTS_FAST_SECURE ){
72816 memset(&data[hdr], 0, pBt->usableSize - hdr);
72822 put2byte(&data[hdr+5], pBt->usableSize);
72823 pPage->nFree = (u16)(pBt->usableSize - first);
72825 pPage->cellOffset = first;
72826 pPage->aDataEnd = &data[pBt->pageSize];
72827 pPage->aCellIdx = &data[first];
72828 pPage->aDataOfst = &data[pPage->childPtrSize];
72829 pPage->nOverflow = 0;
72830 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
72831 pPage->maskPage = (u16)(pBt->pageSize - 1);
72832 pPage->nCell = 0;
72833 pPage->isInit = 1;
72843 if( pgno!=pPage->pgno ){
72844 pPage->aData = sqlite3PagerGetData(pDbPage);
72845 pPage->pDbPage = pDbPage;
72846 pPage->pBt = pBt;
72847 pPage->pgno = pgno;
72848 pPage->hdrOffset = pgno==1 ? 100 : 0;
72850 assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
72875 assert( sqlite3_mutex_held(pBt->mutex) );
72876 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
72889 assert( sqlite3_mutex_held(pBt->mutex) );
72890 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
72899 ** error, return ((unsigned int)-1).
72902 return pBt->nPage;
72906 return btreePagecount(p->pBt);
72916 int bReadOnly /* True for a read-only page */
72921 assert( sqlite3_mutex_held(pBt->mutex) );
72927 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
72933 if( pPage->isInit==0 ){
72942 assert( pPage->pgno==pgno || CORRUPT_DB );
72943 assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
72955 assert( pPage->aData );
72956 assert( pPage->pBt );
72957 assert( pPage->pDbPage!=0 );
72958 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
72959 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
72960 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72961 sqlite3PagerUnrefNotNull(pPage->pDbPage);
72968 assert( pPage->aData );
72969 assert( pPage->pBt );
72970 assert( pPage->pDbPage!=0 );
72971 assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
72972 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
72973 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
72974 sqlite3PagerUnrefPageOne(pPage->pDbPage);
72994 if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
72999 (*ppPage)->isInit = 0;
73019 if( pPage->isInit ){
73020 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
73021 pPage->isInit = 0;
73028 ** the call for every page that comes in for re-initializing. */
73039 assert( pBt->db );
73040 assert( sqlite3_mutex_held(pBt->db->mutex) );
73041 return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
73049 ** be exclusively in memory, or it might use a disk-based memory cache.
73053 ** If zFilename is ":memory:" then an in-memory database is created
73066 sqlite3_vfs *pVfs, /* VFS to use for this b-tree */
73078 unsigned char zDbHeader[100]; /* Database header content */
73083 /* Set the variable isMemdb to true for an in-memory database, or
73084 ** false for a file-based database.
73096 assert( sqlite3_mutex_held(db->mutex) );
73115 p->inTrans = TRANS_NONE;
73116 p->db = db;
73118 p->lock.pBtree = p;
73119 p->lock.iTable = 1;
73130 int nFullPathname = pVfs->mxPathname+1;
73134 p->sharable = 1;
73160 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
73161 assert( pBt->nRef>0 );
73162 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
73163 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
73165 for(iDb=db->nDb-1; iDb>=0; iDb--){
73166 Btree *pExisting = db->aDb[iDb].pBt;
73167 if( pExisting && pExisting->pBt==pBt ){
73175 p->pBt = pBt;
73176 pBt->nRef++;
73190 p->sharable = 1;
73207 /* Suppress false-positive compiler warning from PVS-Studio */
73215 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
73218 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
73219 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
73224 pBt->openFlags = (u8)flags;
73225 pBt->db = db;
73226 sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
73227 p->pBt = pBt;
73229 pBt->pCursor = 0;
73230 pBt->pPage1 = 0;
73231 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
73233 pBt->btsFlags |= BTS_SECURE_DELETE;
73235 pBt->btsFlags |= BTS_OVERWRITE;
73237 /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
73238 ** determined by the 2-byte integer located at an offset of 16 bytes from
73240 pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
73241 if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
73242 || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
73243 pBt->pageSize = 0;
73245 /* If the magic name ":memory:" will create an in-memory database, then
73246 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
73249 ** regular file-name. In this case the auto-vacuum applies as per normal.
73252 pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
73253 pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
73258 /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is
73259 ** determined by the one-byte unsigned integer found at an offset of 20
73262 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
73264 pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
73265 pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
73268 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
73270 pBt->usableSize = pBt->pageSize - nReserve;
73271 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
73276 pBt->nRef = 1;
73277 if( p->sharable ){
73281 pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
73282 if( pBt->mutex==0 ){
73288 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
73300 if( p->sharable ){
73303 for(i=0; i<db->nDb; i++){
73304 if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
73305 while( pSib->pPrev ){ pSib = pSib->pPrev; }
73306 if( (uptr)p->pBt<(uptr)pSib->pBt ){
73307 p->pNext = pSib;
73308 p->pPrev = 0;
73309 pSib->pPrev = p;
73311 while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){
73312 pSib = pSib->pNext;
73314 p->pNext = pSib->pNext;
73315 p->pPrev = pSib;
73316 if( p->pNext ){
73317 p->pNext->pPrev = p;
73319 pSib->pNext = p;
73330 if( pBt && pBt->pPager ){
73331 sqlite3PagerClose(pBt->pPager, 0);
73339 /* If the B-Tree was successfully opened, set the pager-cache size to the
73340 ** default value. Except, when opening on an existing shared pager-cache,
73341 ** do not change the pager-cache size.
73347 pFile = sqlite3PagerFile(pBt->pPager);
73348 if( pFile->pMethods ){
73349 sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
73372 assert( sqlite3_mutex_notheld(pBt->mutex) );
73375 pBt->nRef--;
73376 if( pBt->nRef<=0 ){
73378 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
73381 while( ALWAYS(pList) && pList->pNext!=pBt ){
73382 pList=pList->pNext;
73385 pList->pNext = pBt->pNext;
73389 sqlite3_mutex_free(pBt->mutex);
73401 ** Make sure pBt->pTmpSpace points to an allocation of
73402 ** MX_CELL_SIZE(pBt) bytes with a 4-byte prefix for a left-child
73407 assert( pBt->pTmpSpace==0 );
73410 assert( pBt->pCursor!=0 && (pBt->pCursor->curFlags & BTCF_WriteFlag)!=0 );
73411 pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
73412 if( pBt->pTmpSpace==0 ){
73413 BtCursor *pCur = pBt->pCursor;
73414 pBt->pCursor = pCur->pNext; /* Unlink the cursor */
73419 /* One of the uses of pBt->pTmpSpace is to format cells before
73432 ** left-child pointer to the beginning of a cell.
73434 memset(pBt->pTmpSpace, 0, 8);
73435 pBt->pTmpSpace += 4;
73440 ** Free the pBt->pTmpSpace allocation
73443 if( pBt->pTmpSpace ){
73444 pBt->pTmpSpace -= 4;
73445 sqlite3PageFree(pBt->pTmpSpace);
73446 pBt->pTmpSpace = 0;
73454 BtShared *pBt = p->pBt;
73457 assert( sqlite3_mutex_held(p->db->mutex) );
73463 BtCursor *pCur = pBt->pCursor;
73466 pCur = pCur->pNext;
73467 assert( pTmp->pBtree!=p );
73474 ** The call to sqlite3BtreeRollback() drops any table-locks held by
73480 /* If there are still other outstanding references to the shared-btree
73482 ** up the shared-btree.
73484 assert( p->wantToLock==0 && p->locked==0 );
73485 if( !p->sharable || removeFromSharingList(pBt) ){
73491 assert( !pBt->pCursor );
73492 sqlite3PagerClose(pBt->pPager, p->db);
73493 if( pBt->xFreeSchema && pBt->pSchema ){
73494 pBt->xFreeSchema(pBt->pSchema);
73496 sqlite3DbFree(0, pBt->pSchema);
73502 assert( p->wantToLock==0 );
73503 assert( p->locked==0 );
73504 if( p->pPrev ) p->pPrev->pNext = p->pNext;
73505 if( p->pNext ) p->pNext->pPrev = p->pPrev;
73520 BtShared *pBt = p->pBt;
73521 assert( sqlite3_mutex_held(p->db->mutex) );
73523 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
73539 BtShared *pBt = p->pBt;
73541 assert( sqlite3_mutex_held(p->db->mutex) );
73543 res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
73554 BtShared *pBt = p->pBt;
73555 assert( sqlite3_mutex_held(p->db->mutex) );
73557 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
73568 ** is a very low but non-zero probability of damage. Level 3 reduces the
73576 BtShared *pBt = p->pBt;
73577 assert( sqlite3_mutex_held(p->db->mutex) );
73579 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
73608 BtShared *pBt = p->pBt;
73611 pBt->nReserveWanted = nReserve;
73612 x = pBt->pageSize - pBt->usableSize;
73614 if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
73620 ((pageSize-1)&pageSize)==0 ){
73622 assert( !pBt->pCursor );
73624 pBt->pageSize = (u32)pageSize;
73627 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
73628 pBt->usableSize = pBt->pageSize - (u16)nReserve;
73629 if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
73638 return p->pBt->pageSize;
73643 ** may only be called if it is guaranteed that the b-tree mutex is already
73647 ** known that the shared b-tree mutex is held, but the mutex on the
73654 assert( sqlite3_mutex_held(p->pBt->mutex) );
73655 n = p->pBt->pageSize - p->pBt->usableSize;
73666 ** The amount of reserve can only grow - never shrink.
73671 n1 = (int)p->pBt->nReserveWanted;
73686 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
73697 ** newFlag==(-1) No changes
73702 ** freelist leaf pages are not written back to the database. Thus in-page
73716 p->pBt->btsFlags &= ~BTS_FAST_SECURE;
73717 p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag;
73719 b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE;
73725 ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
73726 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
73727 ** is disabled. The default value for the auto-vacuum property is
73734 BtShared *pBt = p->pBt;
73739 if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
73742 pBt->autoVacuum = av ?1:0;
73743 pBt->incrVacuum = av==2 ?1:0;
73751 ** Return the value of the 'auto-vacuum' property. If auto-vacuum is
73761 (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
73762 (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
73771 ** If the user has not set the safety-level for this database connection
73772 ** using "PRAGMA synchronous", and if the safety-level is not already
73781 if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){
73782 while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; }
73783 if( pDb->bSyncSet==0
73784 && pDb->safety_level!=safety_level
73785 && pDb!=&db->aDb[1]
73787 pDb->safety_level = safety_level;
73788 sqlite3PagerSetFlags(pBt->pPager,
73789 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK));
73806 ** well-formed database file, then SQLITE_CORRUPT is returned.
73816 assert( sqlite3_mutex_held(pBt->mutex) );
73817 assert( pBt->pPage1==0 );
73818 rc = sqlite3PagerSharedLock(pBt->pPager);
73826 nPage = get4byte(28+(u8*)pPage1->aData);
73827 sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
73828 if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
73831 if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){
73837 u8 *page1 = pPage1->aData;
73839 /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins
73848 pBt->btsFlags |= BTS_READ_ONLY;
73855 pBt->btsFlags |= BTS_READ_ONLY;
73866 ** may not be the latest version - there may be a newer one in the log
73869 if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
73871 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
73887 /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload
73893 if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
73896 /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
73897 ** determined by the 2-byte integer located at an offset of 16 bytes from
73900 /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two
73902 if( ((pageSize-1)&pageSize)!=0
73909 /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte
73913 ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is
73914 ** determined by the one-byte unsigned integer found at an offset of 20
73916 usableSize = pageSize - page1[20];
73917 if( (u32)pageSize!=pBt->pageSize ){
73919 ** of BtShared.pageSize, we have discovered that the page-size is
73920 ** actually pageSize. Unlock the database, leave pBt->pPage1 at
73922 ** again with the correct page-size.
73925 pBt->usableSize = usableSize;
73926 pBt->pageSize = pageSize;
73927 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
73929 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
73930 pageSize-usableSize);
73934 if( sqlite3WritableSchema(pBt->db)==0 ){
73941 /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to
73947 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
73948 pBt->pageSize = pageSize;
73949 pBt->usableSize = usableSize;
73951 pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
73952 pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
73958 ** cells can will fit on one page. We assume a 10-byte page header.
73960 ** 2-byte pointer to the cell
73961 ** 4-byte child pointer
73962 ** 9-byte nKey value
73963 ** 4-byte nData value
73964 ** 4-byte overflow page pointer
73965 ** So a cell consists of a 2-byte pointer, a header which is as much as
73969 pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
73970 pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
73971 pBt->maxLeaf = (u16)(pBt->usableSize - 35);
73972 pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
73973 if( pBt->maxLocal>127 ){
73974 pBt->max1bytePayload = 127;
73976 pBt->max1bytePayload = (u8)pBt->maxLocal;
73978 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
73979 pBt->pPage1 = pPage1;
73980 pBt->nPage = nPage;
73985 pBt->pPage1 = 0;
74005 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
74006 if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0)
74007 && pCur->eState!=CURSOR_FAULT ) r++;
74019 ** If there is a transaction in progress, this routine is a no-op.
74022 assert( sqlite3_mutex_held(pBt->mutex) );
74023 assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
74024 if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
74025 MemPage *pPage1 = pBt->pPage1;
74026 assert( pPage1->aData );
74027 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
74028 pBt->pPage1 = 0;
74043 assert( sqlite3_mutex_held(pBt->mutex) );
74044 if( pBt->nPage>0 ){
74047 pP1 = pBt->pPage1;
74049 data = pP1->aData;
74050 rc = sqlite3PagerWrite(pP1->pDbPage);
74054 data[16] = (u8)((pBt->pageSize>>8)&0xff);
74055 data[17] = (u8)((pBt->pageSize>>16)&0xff);
74058 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
74059 data[20] = (u8)(pBt->pageSize - pBt->usableSize);
74063 memset(&data[24], 0, 100-24);
74065 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
74067 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
74068 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
74069 put4byte(&data[36 + 4*4], pBt->autoVacuum);
74070 put4byte(&data[36 + 7*4], pBt->incrVacuum);
74072 pBt->nPage = 1;
74085 p->pBt->nPage = 0;
74086 rc = newDatabase(p->pBt);
74092 ** Attempt to start a new transaction. A write-transaction
74093 ** is started if the second argument is nonzero, otherwise a read-
74097 ** upgraded to exclusive by calling this routine a second time - the
74100 ** A write-transaction must be started before attempting any
74114 ** if there is one. But if there was previously a read-lock, do not
74115 ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
74116 ** returned when there is already a read-lock in order to avoid a deadlock.
74131 BtShared *pBt = p->pBt;
74132 Pager *pPager = pBt->pPager;
74138 /* If the btree is already in a write-transaction, or it
74139 ** is already in a read-transaction and a read-transaction
74140 ** is requested, this is a no-op.
74142 if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
74145 assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
74147 if( (p->db->flags & SQLITE_ResetDatabase)
74150 pBt->btsFlags &= ~BTS_READ_ONLY;
74153 /* Write transactions are not possible on a read-only database */
74154 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
74163 ** on this shared-btree structure and a second write transaction is
74166 if( (wrflag && pBt->inTransaction==TRANS_WRITE)
74167 || (pBt->btsFlags & BTS_PENDING)!=0
74169 pBlock = pBt->pWriter->db;
74172 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
74173 if( pIter->pBtree!=p ){
74174 pBlock = pIter->pBtree->db;
74180 sqlite3ConnectionBlocked(p->db, pBlock);
74187 /* Any read-only or read-write transaction implies a read-lock on
74188 ** page 1. So if some other shared-cache client already has a write-lock
74193 pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
74194 if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
74196 sqlite3PagerWalDb(pPager, p->db);
74201 if( pBt->pPage1==0 && wrflag ){
74202 assert( pBt->inTransaction==TRANS_NONE );
74208 /* Call lockBtree() until either pBt->pPage1 is populated or
74210 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
74211 ** reading page 1 it discovers that the page-size of the database
74212 ** file is not pBt->pageSize. In this case lockBtree() will update
74213 ** pBt->pageSize to the page-size of the file on disk.
74215 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
74218 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
74221 rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db));
74224 }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){
74237 }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
74245 if( p->inTrans==TRANS_NONE ){
74246 pBt->nTransaction++;
74248 if( p->sharable ){
74249 assert( p->lock.pBtree==p && p->lock.iTable==1 );
74250 p->lock.eLock = READ_LOCK;
74251 p->lock.pNext = pBt->pLock;
74252 pBt->pLock = &p->lock;
74256 p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
74257 if( p->inTrans>pBt->inTransaction ){
74258 pBt->inTransaction = p->inTrans;
74261 MemPage *pPage1 = pBt->pPage1;
74263 assert( !pBt->pWriter );
74264 pBt->pWriter = p;
74265 pBt->btsFlags &= ~BTS_EXCLUSIVE;
74266 if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
74269 /* If the db-size header field is incorrect (as it may be if an old
74272 ** re-read the database size from page 1 if a savepoint or transaction
74275 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
74276 rc = sqlite3PagerWrite(pPage1->pDbPage);
74278 put4byte(&pPage1->aData[28], pBt->nPage);
74287 *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
74292 ** the sub-journal is not already open, then it will be opened here.
74294 rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint);
74304 if( p->sharable
74305 || p->inTrans==TRANS_NONE
74306 || (p->inTrans==TRANS_READ && wrflag!=0)
74310 pBt = p->pBt;
74312 *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
74317 ** the sub-journal is not already open, then it will be opened here.
74319 return sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
74328 ** Set the pointer-map entries for all children of page pPage. Also, if
74336 BtShared *pBt = pPage->pBt;
74337 Pgno pgno = pPage->pgno;
74339 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
74340 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
74342 nCell = pPage->nCell;
74349 if( !pPage->leaf ){
74355 if( !pPage->leaf ){
74356 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74368 ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
74371 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
74374 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
74378 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
74379 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
74382 if( get4byte(pPage->aData)!=iFrom ){
74385 put4byte(pPage->aData, iTo);
74391 rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
74393 nCell = pPage->nCell;
74399 pPage->xParseCell(pPage, pCell, &info);
74401 if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
74404 if( iFrom==get4byte(pCell+info.nSize-4) ){
74405 put4byte(pCell+info.nSize-4, iTo);
74410 if( pCell+4 > pPage->aData+pPage->pBt->usableSize ){
74422 get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
74425 put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
74437 ** the journal needs to be sync()ed before database page pDbPage->pgno
74445 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
74450 Pgno iDbPage = pDbPage->pgno;
74451 Pager *pPager = pBt->pPager;
74456 assert( sqlite3_mutex_held(pBt->mutex) );
74457 assert( pDbPage->pBt==pBt );
74463 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
74467 pDbPage->pgno = iFreePage;
74469 /* If pDbPage was a btree-page, then it may have child pages and/or cells
74483 Pgno nextOvfl = get4byte(pDbPage->aData);
74501 rc = sqlite3PagerWrite(pPtrPage->pDbPage);
74519 ** Perform a single step of an incremental-vacuum. If successful, return
74524 ** More specifically, this function attempts to re-organize the database so
74530 ** If the bCommit parameter is non-zero, this function assumes that the
74532 ** or an error. bCommit is passed true for an auto-vacuum-on-commit
74536 Pgno nFreeList; /* Number of pages still on the free-list */
74539 assert( sqlite3_mutex_held(pBt->mutex) );
74546 nFreeList = get4byte(&pBt->pPage1->aData[36]);
74561 /* Remove the page from the files free-list. This is not required
74562 ** if bCommit is non-zero. In that case, the free-list will be
74590 ** looping until a free-page located within the first nFin pages
74623 iLastPg--;
74625 pBt->bDoTruncate = 1;
74626 pBt->nPage = iLastPg;
74632 ** The database opened by the first argument is an auto-vacuum database
74634 ** size of the database in pages following an auto-vacuum operation.
74641 nEntry = pBt->usableSize/5;
74642 nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
74643 nFin = nOrig - nFree - nPtrmap;
74645 nFin--;
74648 nFin--;
74655 ** A write-transaction must be opened before calling this function.
74664 BtShared *pBt = p->pBt;
74667 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
74668 if( !pBt->autoVacuum ){
74672 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
74684 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
74685 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
74697 ** is committed for an auto-vacuum database.
74707 pBt = p->pBt;
74708 pPager = pBt->pPager;
74711 assert( sqlite3_mutex_held(pBt->mutex) );
74713 assert(pBt->autoVacuum);
74714 if( !pBt->incrVacuum ){
74724 ** is either a pointer-map page or the pending-byte page. If one
74730 nFree = get4byte(&pBt->pPage1->aData[36]);
74731 db = p->db;
74732 if( db->xAutovacPages ){
74734 for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
74735 if( db->aDb[iDb].pBt==p ) break;
74737 nVac = db->xAutovacPages(
74738 db->pAutovacPagesArg,
74739 db->aDb[iDb].zDbSName,
74742 pBt->pageSize
74758 for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
74762 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
74764 put4byte(&pBt->pPage1->aData[32], 0);
74765 put4byte(&pBt->pPage1->aData[36], 0);
74767 put4byte(&pBt->pPage1->aData[28], nFin);
74768 pBt->bDoTruncate = 1;
74769 pBt->nPage = nFin;
74785 ** This routine does the first phase of a two-phase commit. This routine
74797 ** This call is a no-op if no write-transaction is currently active on pBt.
74800 ** the name of a super-journal file that should be written into the
74801 ** individual journal file, or is NULL, indicating no super-journal file
74804 ** When this is called, the super-journal should already have been
74808 ** the write-transaction for this database file is to delete the journal.
74812 if( p->inTrans==TRANS_WRITE ){
74813 BtShared *pBt = p->pBt;
74816 if( pBt->autoVacuum ){
74823 if( pBt->bDoTruncate ){
74824 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
74827 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zSuperJrnl, 0);
74838 BtShared *pBt = p->pBt;
74839 sqlite3 *db = p->db;
74843 pBt->bDoTruncate = 0;
74845 if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
74847 ** handle, downgrade to a read-only transaction. The other statements
74850 p->inTrans = TRANS_READ;
74856 if( p->inTrans!=TRANS_NONE ){
74858 pBt->nTransaction--;
74859 if( 0==pBt->nTransaction ){
74860 pBt->inTransaction = TRANS_NONE;
74866 p->inTrans = TRANS_NONE;
74876 ** This routine implements the second phase of a 2-phase commit. The
74888 ** is non-zero then this b-tree transaction is part of a multi-file
74890 ** (by deleting a super-journal file) and the caller will ignore this
74892 ** reset the b-tree objects internal state to indicate that the write
74901 if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
74905 /* If the handle has a write-transaction open, commit the shared-btrees
74908 if( p->inTrans==TRANS_WRITE ){
74910 BtShared *pBt = p->pBt;
74911 assert( pBt->inTransaction==TRANS_WRITE );
74912 assert( pBt->nTransaction>0 );
74913 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
74918 p->iBDataVersion--; /* Compensate for pPager->iDataVersion++; */
74919 pBt->inTransaction = TRANS_READ;
74953 ** flag is true, then only write-cursors need be tripped - read-only
74957 ** rolled back modified the database schema. In this case b-tree root
74962 ** saving the current position of a read-only cursor, all cursors,
74963 ** including all read-cursors are tripped.
74975 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
74976 if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
74977 if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
74986 p->eState = CURSOR_FAULT;
74987 p->skipNext = errCode;
74997 ** Set the pBt->nPage field correctly, according to the current
74998 ** state of the database. Assume pBt->pPage1 is valid.
75001 int nPage = get4byte(&pPage1->aData[28]);
75003 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
75004 testcase( pBt->nPage!=(u32)nPage );
75005 pBt->nPage = nPage;
75021 BtShared *pBt = p->pBt;
75040 if( p->inTrans==TRANS_WRITE ){
75043 assert( TRANS_WRITE==pBt->inTransaction );
75044 rc2 = sqlite3PagerRollback(pBt->pPager);
75049 /* The rollback may have destroyed the pPage1->aData value. So
75051 ** sure pPage1->aData is set correctly. */
75057 pBt->inTransaction = TRANS_READ;
75077 ** A statement sub-transaction is implemented as an anonymous savepoint. The
75079 ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
75080 ** are no active savepoints and no other statement-transactions open,
75086 BtShared *pBt = p->pBt;
75088 assert( p->inTrans==TRANS_WRITE );
75089 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
75091 assert( iStatement>p->db->nSavepoint );
75092 assert( pBt->inTransaction==TRANS_WRITE );
75098 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
75110 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
75117 if( p && p->inTrans==TRANS_WRITE ){
75118 BtShared *pBt = p->pBt;
75120 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
75126 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
75129 if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
75130 pBt->nPage = 0;
75133 btreeSetNPage(pBt, pBt->pPage1);
75135 /* pBt->nPage might be zero if the database was corrupt when
75137 assert( CORRUPT_DB || pBt->nPage>0 );
75146 ** iTable. If a read-only cursor is requested, it is assumed that
75147 ** the caller already has at least a read-only transaction open
75148 ** on the database already. If a write-cursor is requested, then
75165 ** 3: The database must be writable (not on read-only media)
75176 ** operations on this cursor can be no-ops and all READ operations can
75177 ** return a null row (2-bytes: 0x01 0x00).
75180 ** root page of a b-tree. If it is not, then the cursor acquired
75189 int wrFlag, /* 1 to write. 0 read-only */
75193 BtShared *pBt = p->pBt; /* Shared b-tree handle */
75203 ** b-tree database, the connection is holding the required table locks,
75211 assert( p->inTrans>TRANS_NONE );
75212 assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
75213 assert( pBt->pPage1 && pBt->pPage1->aData );
75214 assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 );
75227 pCur->pgnoRoot = iTable;
75228 pCur->iPage = -1;
75229 pCur->pKeyInfo = pKeyInfo;
75230 pCur->pBtree = p;
75231 pCur->pBt = pBt;
75232 pCur->curFlags = 0;
75235 for(pX=pBt->pCursor; pX; pX=pX->pNext){
75236 if( pX->pgnoRoot==iTable ){
75237 pX->curFlags |= BTCF_Multiple;
75238 pCur->curFlags = BTCF_Multiple;
75241 pCur->eState = CURSOR_INVALID;
75242 pCur->pNext = pBt->pCursor;
75243 pBt->pCursor = pCur;
75245 pCur->curFlags |= BTCF_WriteFlag;
75246 pCur->curPagerFlags = 0;
75247 if( pBt->pTmpSpace==0 ) return allocateTempSpace(pBt);
75249 pCur->curPagerFlags = PAGER_GET_READONLY;
75256 int wrFlag, /* 1 to write. 0 read-only */
75269 int wrFlag, /* 1 to write. 0 read-only */
75273 if( p->sharable ){
75285 ** to users so they cannot do the sizeof() themselves - they must call
75298 ** of run-time by skipping the initialization of those elements.
75309 Btree *pBtree = pCur->pBtree;
75311 BtShared *pBt = pCur->pBt;
75313 assert( pBt->pCursor!=0 );
75314 if( pBt->pCursor==pCur ){
75315 pBt->pCursor = pCur->pNext;
75317 BtCursor *pPrev = pBt->pCursor;
75319 if( pPrev->pNext==pCur ){
75320 pPrev->pNext = pCur->pNext;
75323 pPrev = pPrev->pNext;
75328 sqlite3_free(pCur->aOverflow);
75329 sqlite3_free(pCur->pKey);
75330 if( (pBt->openFlags & BTREE_SINGLE) && pBt->pCursor==0 ){
75333 assert( pBtree->sharable==0 );
75338 pCur->pBtree = 0;
75353 if( a->nKey!=b->nKey ) return 0;
75354 if( a->pPayload!=b->pPayload ) return 0;
75355 if( a->nPayload!=b->nPayload ) return 0;
75356 if( a->nLocal!=b->nLocal ) return 0;
75357 if( a->nSize!=b->nSize ) return 0;
75363 btreeParseCell(pCur->pPage, pCur->ix, &info);
75364 assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
75370 if( pCur->info.nSize==0 ){
75371 pCur->curFlags |= BTCF_ValidNKey;
75372 btreeParseCell(pCur->pPage,pCur->ix,&pCur->info);
75381 ** that is currently pointing to a row in a (non-empty) table.
75385 return pCur && pCur->eState==CURSOR_VALID;
75390 return pCur->eState==CURSOR_VALID;
75401 assert( pCur->eState==CURSOR_VALID );
75402 assert( pCur->curIntKey );
75404 return pCur->info.nKey;
75411 assert( (pCur->curFlags & BTCF_Pinned)==0 );
75412 pCur->curFlags |= BTCF_Pinned;
75415 assert( (pCur->curFlags & BTCF_Pinned)!=0 );
75416 pCur->curFlags &= ~BTCF_Pinned;
75425 assert( pCur->eState==CURSOR_VALID );
75427 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
75428 (i64)(pCur->info.pPayload - pCur->pPage->aData);
75436 ** The caller must guarantee that the cursor is pointing to a non-NULL
75442 assert( pCur->eState==CURSOR_VALID );
75444 return pCur->info.nPayload;
75462 assert( pCur->eState==CURSOR_VALID );
75463 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
75469 ** linked list of overflow pages. If possible, it uses the auto-vacuum
75470 ** pointer-map data instead of reading the content of page ovfl to do so.
75482 ** the pointer-map was used to obtain the value for *pPgnoNext), then
75495 assert( sqlite3_mutex_held(pBt->mutex) );
75500 ** autovacuum pointer-map pages. Guess that the next page in
75505 if( pBt->autoVacuum ){
75529 next = get4byte(pPage->aData);
75557 int eOp, /* 0 -> copy from page, 1 -> copy to page */
75590 ** the overflow page-list cache array (BtCursor.aOverflow).
75594 ** Once an overflow page-list cache has been allocated, it must be
75596 ** the cursor is moved to a different row. Additionally, in auto-vacuum
75597 ** mode, the following events may invalidate an overflow page-list cache.
75608 int eOp /* zero to read. non-zero to write. */
75613 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
75614 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
75621 assert( pCur->eState==CURSOR_VALID );
75622 if( pCur->ix>=pPage->nCell ){
75628 aPayload = pCur->info.pPayload;
75629 assert( offset+amt <= pCur->info.nPayload );
75631 assert( aPayload > pPage->aData );
75632 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
75635 ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
75642 if( offset<pCur->info.nLocal ){
75644 if( a+offset>pCur->info.nLocal ){
75645 a = pCur->info.nLocal - offset;
75647 rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
75650 amt -= a;
75652 offset -= pCur->info.nLocal;
75657 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
75660 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
75669 if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
75670 int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
75671 if( pCur->aOverflow==0
75672 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
75678 aNew = (Pgno*)sqlite3Realloc(pCur->aOverflow, nOvfl*2*sizeof(Pgno));
75683 pCur->aOverflow = aNew;
75686 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
75687 pCur->curFlags |= BTCF_ValidOvfl;
75690 assert( pCur->aOverflow[0]==nextPage
75691 || pCur->aOverflow[0]==0
75693 assert( pCur->aOverflow[0]!=0 || pCur->aOverflow[offset/ovflSize]==0 );
75695 /* If the overflow page-list cache has been allocated and the
75699 if( pCur->aOverflow[offset/ovflSize] ){
75701 nextPage = pCur->aOverflow[iIdx];
75708 /* If required, populate the overflow page-list cache. */
75709 if( nextPage > pBt->nPage ) return SQLITE_CORRUPT_BKPT;
75710 assert( pCur->aOverflow[iIdx]==0
75711 || pCur->aOverflow[iIdx]==nextPage
75713 pCur->aOverflow[iIdx] = nextPage;
75719 ** page-list cache, if any, then fall back to the getOverflowPage()
75722 assert( pCur->curFlags & BTCF_ValidOvfl );
75723 assert( pCur->pBtree->db==pBt->db );
75724 if( pCur->aOverflow[iIdx+1] ){
75725 nextPage = pCur->aOverflow[iIdx+1];
75729 offset -= ovflSize;
75736 a = ovflSize - offset;
75744 ** 3) there are no dirty pages in the page-cache
75745 ** 4) the database is file-backed, and
75750 ** output buffer, bypassing the page-cache altogether. This speeds
75755 && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */
75756 && &pBuf[-4]>=pBufStart /* (6) */
75758 sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
75760 u8 *aWrite = &pBuf[-4];
75763 rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
75771 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,
75782 amt -= a;
75803 ** pCur can be pointing to either a table or an index b-tree.
75805 ** pCur is pointing to an index b-tree then the key section is read.
75817 assert( pCur->eState==CURSOR_VALID );
75818 assert( pCur->iPage>=0 && pCur->pPage );
75835 if ( pCur->eState==CURSOR_INVALID ){
75843 if( pCur->eState==CURSOR_VALID ){
75855 ** the key if index btrees (pPage->intKey==0) and is the data for
75856 ** table btrees (pPage->intKey==1). The number of bytes of available
75876 assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
75877 assert( pCur->eState==CURSOR_VALID );
75878 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
75880 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
75881 assert( pCur->info.nSize>0 );
75882 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
75883 assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
75884 amt = pCur->info.nLocal;
75885 if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
75889 amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
75892 return (void*)pCur->info.pPayload;
75899 ** b-tree page. Write the number of available bytes into *pAmt.
75919 ** This function returns SQLITE_CORRUPT if the page-header flags field of
75921 ** if an intkey page appears to be the parent of a non-intkey page, or
75922 ** vice-versa).
75927 assert( pCur->eState==CURSOR_VALID );
75928 assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
75929 assert( pCur->iPage>=0 );
75930 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
75933 pCur->info.nSize = 0;
75934 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
75935 pCur->aiIdx[pCur->iPage] = pCur->ix;
75936 pCur->apPage[pCur->iPage] = pCur->pPage;
75937 pCur->ix = 0;
75938 pCur->iPage++;
75939 rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
75940 assert( pCur->pPage!=0 || rc!=SQLITE_OK );
75942 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
75944 releasePage(pCur->pPage);
75948 pCur->pPage = pCur->apPage[--pCur->iPage];
75955 ** Page pParent is an internal (non-leaf) tree page. This function
75956 ** asserts that page number iChild is the left-child if the iIdx'th
75958 ** cells in pParent, that page number iChild is the right-child of
75964 assert( iIdx<=pParent->nCell );
75965 if( iIdx==pParent->nCell ){
75966 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
75978 ** pCur->idx is set to the cell index that contains the pointer
75980 ** right-most child page then pCur->idx is set to one more than
75986 assert( pCur->eState==CURSOR_VALID );
75987 assert( pCur->iPage>0 );
75988 assert( pCur->pPage );
75990 pCur->apPage[pCur->iPage-1],
75991 pCur->aiIdx[pCur->iPage-1],
75992 pCur->pPage->pgno
75994 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
75995 pCur->info.nSize = 0;
75996 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
75997 pCur->ix = pCur->aiIdx[pCur->iPage-1];
75998 pLeaf = pCur->pPage;
75999 pCur->pPage = pCur->apPage[--pCur->iPage];
76004 ** Move the cursor to point to the root page of its b-tree structure.
76011 ** If the b-tree structure is empty, the cursor state is set to
76017 ** page-header flags indicate that the [virtual] root-page is the expected
76018 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
76020 ** indicating a table b-tree, or if the caller did specify a KeyInfo
76022 ** b-tree).
76032 assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 );
76033 assert( pCur->pgnoRoot>0 || pCur->iPage<0 );
76035 if( pCur->iPage>=0 ){
76036 if( pCur->iPage ){
76037 releasePageNotNull(pCur->pPage);
76038 while( --pCur->iPage ){
76039 releasePageNotNull(pCur->apPage[pCur->iPage]);
76041 pRoot = pCur->pPage = pCur->apPage[0];
76044 }else if( pCur->pgnoRoot==0 ){
76045 pCur->eState = CURSOR_INVALID;
76048 assert( pCur->iPage==(-1) );
76049 if( pCur->eState>=CURSOR_REQUIRESEEK ){
76050 if( pCur->eState==CURSOR_FAULT ){
76051 assert( pCur->skipNext!=SQLITE_OK );
76052 return pCur->skipNext;
76056 rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage,
76057 pCur->curPagerFlags);
76059 pCur->eState = CURSOR_INVALID;
76062 pCur->iPage = 0;
76063 pCur->curIntKey = pCur->pPage->intKey;
76065 pRoot = pCur->pPage;
76066 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
76068 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
76069 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
76070 ** NULL, the caller expects a table b-tree. If this is not the case,
76075 ** if pCur->iPage>=0). But this is not so if the database is corrupted
76076 ** in such a way that page pRoot is linked into a second b-tree table
76078 assert( pRoot->intKey==1 || pRoot->intKey==0 );
76079 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
76080 return SQLITE_CORRUPT_PAGE(pCur->pPage);
76084 pCur->ix = 0;
76085 pCur->info.nSize = 0;
76086 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl);
76088 if( pRoot->nCell>0 ){
76089 pCur->eState = CURSOR_VALID;
76090 }else if( !pRoot->leaf ){
76092 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
76093 subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
76094 pCur->eState = CURSOR_VALID;
76097 pCur->eState = CURSOR_INVALID;
76104 ** Move the cursor down to the left-most leaf entry beneath the
76107 ** The left-most leaf is the one with the smallest key - the first
76116 assert( pCur->eState==CURSOR_VALID );
76117 while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
76118 assert( pCur->ix<pPage->nCell );
76119 pgno = get4byte(findCell(pPage, pCur->ix));
76126 ** Move the cursor down to the right-most leaf entry beneath the
76129 ** finds the left-most entry beneath the *entry* whereas moveToRightmost()
76130 ** finds the right-most entry beneath the *page*.
76132 ** The right-most entry is the one with the largest key - the last
76141 assert( pCur->eState==CURSOR_VALID );
76142 while( !(pPage = pCur->pPage)->leaf ){
76143 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
76144 pCur->ix = pPage->nCell;
76148 pCur->ix = pPage->nCell-1;
76149 assert( pCur->info.nSize==0 );
76150 assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
76162 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76165 assert( pCur->pPage->nCell>0 );
76169 assert( pCur->pgnoRoot==0 || (pCur->pPage!=0 && pCur->pPage->nCell==0) );
76186 for(ii=0; ii<pCur->iPage; ii++){
76187 if( pCur->aiIdx[ii]!=pCur->apPage[ii]->nCell ) return 0;
76189 return pCur->ix==pCur->pPage->nCell-1 && pCur->pPage->leaf!=0;
76200 assert( pCur->eState==CURSOR_VALID );
76204 pCur->curFlags |= BTCF_AtLast;
76206 pCur->curFlags &= ~BTCF_AtLast;
76209 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76217 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76219 /* If the cursor already points to the last entry, this is a no-op. */
76220 if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){
76260 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76262 assert( pCur->pKeyInfo==0 );
76263 assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
76267 if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
76268 if( pCur->info.nKey==intKey ){
76272 if( pCur->info.nKey<intKey ){
76273 if( (pCur->curFlags & BTCF_AtLast)!=0 ){
76275 *pRes = -1;
76282 if( pCur->info.nKey+1==intKey ){
76287 if( pCur->info.nKey==intKey ){
76298 pCur->pBtree->nSeek++; /* Performance measurement during testing */
76304 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76305 *pRes = -1;
76310 assert( pCur->pPage );
76311 assert( pCur->pPage->isInit );
76312 assert( pCur->eState==CURSOR_VALID );
76313 assert( pCur->pPage->nCell > 0 );
76314 assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
76315 assert( pCur->curIntKey );
76320 MemPage *pPage = pCur->pPage;
76323 /* pPage->nCell must be greater than zero. If this is the root-page
76325 ** not run. If this is not the root-page, then the moveToChild() routine
76327 ** be the right kind (index or table) of b-tree page. Otherwise
76329 assert( pPage->nCell>0 );
76330 assert( pPage->intKey );
76332 upr = pPage->nCell-1;
76334 idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */
76338 if( pPage->intKeyLeaf ){
76340 if( pCell>=pPage->aDataEnd ){
76348 if( lwr>upr ){ c = -1; break; }
76350 upr = idx-1;
76354 pCur->ix = (u16)idx;
76355 if( !pPage->leaf ){
76359 pCur->curFlags |= BTCF_ValidNKey;
76360 pCur->info.nKey = nCellKey;
76361 pCur->info.nSize = 0;
76369 assert( lwr==upr+1 || !pPage->leaf );
76370 assert( pPage->isInit );
76371 if( pPage->leaf ){
76372 assert( pCur->ix<pCur->pPage->nCell );
76373 pCur->ix = (u16)idx;
76379 if( lwr>=pPage->nCell ){
76380 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
76384 pCur->ix = (u16)lwr;
76389 pCur->info.nSize = 0;
76390 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76395 ** Compare the "idx"-th cell on the page the cursor pCur is currently
76416 MemPage *pPage = pCur->pPage;
76422 if( nCell<=pPage->max1bytePayload ){
76423 /* This branch runs if the record-size field of the cell is a
76425 ** b-tree page. */
76426 testcase( pCell+nCell+1==pPage->aDataEnd );
76429 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
76431 /* The record-size field is a 2 byte varint and the record
76432 ** fits entirely on the main b-tree page. */
76433 testcase( pCell+nCell+2==pPage->aDataEnd );
76444 ** Return true (non-zero) if pCur is current pointing to the last
76449 assert( pCur->eState==CURSOR_VALID );
76450 for(i=0; i<pCur->iPage; i++){
76451 MemPage *pPage = pCur->apPage[i];
76452 if( pCur->aiIdx[i]<pPage->nCell ) return 0;
76480 ** The pIdxKey->eqSeen field is set to 1 if there
76492 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76494 assert( pCur->pKeyInfo!=0 );
76497 pCur->pBtree->nSeek++; /* Performance measurement during testing */
76501 pIdxKey->errCode = 0;
76502 assert( pIdxKey->default_rc==1
76503 || pIdxKey->default_rc==0
76504 || pIdxKey->default_rc==-1
76519 if( pCur->eState==CURSOR_VALID
76520 && pCur->pPage->leaf
76524 if( pCur->ix==pCur->pPage->nCell-1
76525 && (c = indexCellCompare(pCur, pCur->ix, pIdxKey, xRecordCompare))<=0
76526 && pIdxKey->errCode==SQLITE_OK
76531 if( pCur->iPage>0
76533 && pIdxKey->errCode==SQLITE_OK
76535 pCur->curFlags &= ~BTCF_ValidOvfl;
76536 if( !pCur->pPage->isInit ){
76541 pIdxKey->errCode = SQLITE_OK;
76547 assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
76548 *pRes = -1;
76555 assert( pCur->pPage );
76556 assert( pCur->pPage->isInit );
76557 assert( pCur->eState==CURSOR_VALID );
76558 assert( pCur->pPage->nCell > 0 );
76559 assert( pCur->curIntKey==0 );
76564 MemPage *pPage = pCur->pPage;
76567 /* pPage->nCell must be greater than zero. If this is the root-page
76569 ** not run. If this is not the root-page, then the moveToChild() routine
76571 ** be the right kind (index or table) of b-tree page. Otherwise
76573 assert( pPage->nCell>0 );
76574 assert( pPage->intKey==0 );
76576 upr = pPage->nCell-1;
76582 /* The maximum supported page-size is 65536 bytes. This means that
76583 ** the maximum number of record bytes stored on an index B-Tree
76584 ** page is less than 16384 bytes and may be stored as a 2-byte
76587 ** stored entirely within the b-tree page by inspecting the first
76591 if( nCell<=pPage->max1bytePayload ){
76592 /* This branch runs if the record-size field of the cell is a
76594 ** b-tree page. */
76595 testcase( pCell+nCell+1==pPage->aDataEnd );
76598 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
76600 /* The record-size field is a 2 byte varint and the record
76601 ** fits entirely on the main b-tree page. */
76602 testcase( pCell+nCell+2==pPage->aDataEnd );
76615 u8 * const pCellBody = pCell - pPage->childPtrSize;
76617 pPage->xParseCell(pPage, pCellBody, &pCur->info);
76618 nCell = (int)pCur->info.nKey;
76623 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
76632 pCur->ix = (u16)idx;
76635 pCur->curFlags &= ~BTCF_ValidOvfl;
76644 (pIdxKey->errCode!=SQLITE_CORRUPT || c==0)
76645 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
76650 upr = idx-1;
76655 pCur->ix = (u16)idx;
76656 if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT;
76663 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
76664 assert( pPage->isInit );
76665 if( pPage->leaf ){
76666 assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
76667 pCur->ix = (u16)idx;
76672 if( lwr>=pPage->nCell ){
76673 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
76678 /* This block is similar to an in-lined version of:
76680 ** pCur->ix = (u16)lwr;
76684 pCur->info.nSize = 0;
76685 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
76686 if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
76689 pCur->aiIdx[pCur->iPage] = (u16)lwr;
76690 pCur->apPage[pCur->iPage] = pCur->pPage;
76691 pCur->ix = 0;
76692 pCur->iPage++;
76693 rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
76695 && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
76697 releasePage(pCur->pPage);
76701 pCur->pPage = pCur->apPage[--pCur->iPage];
76705 ***** End of in-lined moveToChild() call */
76708 pCur->info.nSize = 0;
76709 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76726 return (CURSOR_VALID!=pCur->eState);
76739 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
76744 if( pCur->eState!=CURSOR_VALID ) return 0;
76745 if( NEVER(pCur->pPage->leaf==0) ) return -1;
76747 n = pCur->pPage->nCell;
76748 for(i=0; i<pCur->iPage; i++){
76749 n *= pCur->apPage[i]->nCell;
76780 if( pCur->eState!=CURSOR_VALID ){
76781 assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
76786 if( CURSOR_INVALID==pCur->eState ){
76789 if( pCur->eState==CURSOR_SKIPNEXT ){
76790 pCur->eState = CURSOR_VALID;
76791 if( pCur->skipNext>0 ) return SQLITE_OK;
76795 pPage = pCur->pPage;
76796 idx = ++pCur->ix;
76797 if( sqlite3FaultSim(412) ) pPage->isInit = 0;
76798 if( !pPage->isInit ){
76802 if( idx>=pPage->nCell ){
76803 if( !pPage->leaf ){
76804 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
76809 if( pCur->iPage==0 ){
76810 pCur->eState = CURSOR_INVALID;
76814 pPage = pCur->pPage;
76815 }while( pCur->ix>=pPage->nCell );
76816 if( pPage->intKey ){
76822 if( pPage->leaf ){
76833 pCur->info.nSize = 0;
76834 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
76835 if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur);
76836 pPage = pCur->pPage;
76837 if( (++pCur->ix)>=pPage->nCell ){
76838 pCur->ix--;
76841 if( pPage->leaf ){
76873 assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
76874 assert( pCur->info.nSize==0 );
76875 if( pCur->eState!=CURSOR_VALID ){
76880 if( CURSOR_INVALID==pCur->eState ){
76883 if( CURSOR_SKIPNEXT==pCur->eState ){
76884 pCur->eState = CURSOR_VALID;
76885 if( pCur->skipNext<0 ) return SQLITE_OK;
76889 pPage = pCur->pPage;
76890 if( sqlite3FaultSim(412) ) pPage->isInit = 0;
76891 if( !pPage->isInit ){
76894 if( !pPage->leaf ){
76895 int idx = pCur->ix;
76900 while( pCur->ix==0 ){
76901 if( pCur->iPage==0 ){
76902 pCur->eState = CURSOR_INVALID;
76907 assert( pCur->info.nSize==0 );
76908 assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );
76910 pCur->ix--;
76911 pPage = pCur->pPage;
76912 if( pPage->intKey && !pPage->leaf ){
76924 pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
76925 pCur->info.nSize = 0;
76926 if( pCur->eState!=CURSOR_VALID
76927 || pCur->ix==0
76928 || pCur->pPage->leaf==0
76932 pCur->ix--;
76953 ** anywhere on the free-list, then it is guaranteed to be returned. If
76973 assert( sqlite3_mutex_held(pBt->mutex) );
76974 assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
76975 pPage1 = pBt->pPage1;
76977 /* EVIDENCE-OF: R-21003-45125 The 4-byte big-endian integer at offset 36
76979 n = get4byte(&pPage1->aData[36]);
76980 testcase( n==mxPage-1 );
76987 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
76990 /* If eMode==BTALLOC_EXACT and a query of the pointer-map
76991 ** shows that the page 'nearby' is somewhere on the free-list, then
76992 ** the entire-list will be searched for that page.
76999 assert( pBt->autoVacuum );
77011 /* Decrement the free-list count by 1. Set iTrunk to the index of the
77012 ** first free-list trunk page. iPrevTrunk is initially 1.
77014 rc = sqlite3PagerWrite(pPage1->pDbPage);
77016 put4byte(&pPage1->aData[36], n-1);
77019 ** is not true. Otherwise, it runs once for each trunk-page on the
77020 ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT)
77026 /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page
77029 iTrunk = get4byte(&pPrevTrunk->aData[0]);
77031 /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32
77034 iTrunk = get4byte(&pPage1->aData[32]);
77038 rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1);
77047 assert( pTrunk->aData!=0 );
77048 /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page
77050 k = get4byte(&pTrunk->aData[4]);
77056 rc = sqlite3PagerWrite(pTrunk->pDbPage);
77061 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
77064 TRACE(("ALLOCATE: %u trunk - %u free pages left\n", *pPgno, n-1));
77065 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
77079 rc = sqlite3PagerWrite(pTrunk->pDbPage);
77085 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
77087 rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
77091 memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
77095 ** pointers to free-list leaves. The first leaf becomes a trunk
77099 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
77109 rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
77114 memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
77115 put4byte(&pNewTrunk->aData[4], k-1);
77116 memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
77119 assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
77120 put4byte(&pPage1->aData[32], iNewTrunk);
77122 rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
77126 put4byte(&pPrevTrunk->aData[0], iNewTrunk);
77130 TRACE(("ALLOCATE: %u trunk - %u free pages left\n", *pPgno, n-1));
77136 unsigned char *aData = pTrunk->aData;
77150 dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
77152 int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
77177 *pPgno, closest+1, k, pTrunk->pgno, n-1));
77178 rc = sqlite3PagerWrite(pTrunk->pDbPage);
77180 if( closest<k-1 ){
77183 put4byte(&aData[4], k-1);
77187 rc = sqlite3PagerWrite((*ppPage)->pDbPage);
77204 ** pager layer with the 'no-content' flag set. This prevents the pager
77206 ** current transaction has already run one or more incremental-vacuum
77209 ** not set the no-content flag. This causes the pager to load and journal
77214 ** file on disk. So the effects of disabling the no-content optimization
77218 int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0;
77220 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
77222 pBt->nPage++;
77223 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
77226 if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
77227 /* If *pPgno refers to a pointer-map page, allocate two new pages
77229 ** becomes a new pointer-map page, the second is used by the caller.
77232 TRACE(("ALLOCATE: %u from end of file (pointer-map page)\n", pBt->nPage));
77233 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
77234 rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent);
77236 rc = sqlite3PagerWrite(pPg->pDbPage);
77240 pBt->nPage++;
77241 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
77244 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
77245 *pPgno = pBt->nPage;
77250 rc = sqlite3PagerWrite((*ppPage)->pDbPage);
77263 assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 );
77264 assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 );
77269 ** This function is used to add page iPage to the database file free-list.
77270 ** It is assumed that the page is not already a part of the free-list.
77281 MemPage *pTrunk = 0; /* Free-list trunk page */
77282 Pgno iTrunk = 0; /* Page number of free-list trunk page */
77283 MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
77286 u32 nFree; /* Initial number of pages on free-list */
77288 assert( sqlite3_mutex_held(pBt->mutex) );
77290 assert( !pMemPage || pMemPage->pgno==iPage );
77292 if( iPage<2 || iPage>pBt->nPage ){
77297 sqlite3PagerRef(pPage->pDbPage);
77303 rc = sqlite3PagerWrite(pPage1->pDbPage);
77305 nFree = get4byte(&pPage1->aData[36]);
77306 put4byte(&pPage1->aData[36], nFree+1);
77308 if( pBt->btsFlags & BTS_SECURE_DELETE ){
77313 || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0)
77317 memset(pPage->aData, 0, pPage->pBt->pageSize);
77320 /* If the database supports auto-vacuum, write an entry in the pointer-map
77328 /* Now manipulate the actual database free-list structure. There are two
77329 ** possibilities. If the free-list is currently empty, or if the first
77330 ** trunk page in the free-list is full, then this page will become a
77331 ** new free-list trunk page. Otherwise, it will become a leaf of the
77332 ** first trunk page in the current free-list. This block tests if it
77333 ** is possible to add the page as a new free-list leaf.
77338 iTrunk = get4byte(&pPage1->aData[32]);
77348 nLeaf = get4byte(&pTrunk->aData[4]);
77349 assert( pBt->usableSize>32 );
77350 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
77354 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
77359 ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
77362 ** usableSize/4 - 8 entries will be reported as corrupt. In order
77364 ** we will continue to restrict the number of entries to usableSize/4 - 8
77367 ** to read "usableSize/4-2" instead of "usableSize/4-8".
77369 ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still
77374 rc = sqlite3PagerWrite(pTrunk->pDbPage);
77376 put4byte(&pTrunk->aData[4], nLeaf+1);
77377 put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
77378 if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
77379 sqlite3PagerDontWrite(pPage->pDbPage);
77383 TRACE(("FREE-PAGE: %u leaf on trunk page %u\n",pPage->pgno,pTrunk->pgno));
77389 ** the page being freed as a leaf page of the first trunk in the free-list.
77390 ** Possibly because the free-list is empty, or possibly because the
77391 ** first trunk in the free-list is full. Either way, the page being freed
77392 ** will become the new first trunk page in the free-list.
77397 rc = sqlite3PagerWrite(pPage->pDbPage);
77401 put4byte(pPage->aData, iTrunk);
77402 put4byte(&pPage->aData[4], 0);
77403 put4byte(&pPage1->aData[32], iPage);
77404 TRACE(("FREE-PAGE: %u new trunk page replacing %u\n", pPage->pgno, iTrunk));
77408 pPage->isInit = 0;
77416 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
77434 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
77435 assert( pInfo->nLocal!=pInfo->nPayload );
77436 testcase( pCell + pInfo->nSize == pPage->aDataEnd );
77437 testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
77438 if( pCell + pInfo->nSize > pPage->aDataEnd ){
77442 ovflPgno = get4byte(pCell + pInfo->nSize - 4);
77443 pBt = pPage->pBt;
77444 assert( pBt->usableSize > 4 );
77445 ovflPageSize = pBt->usableSize - 4;
77446 nOvfl = (pInfo->nPayload - pInfo->nLocal + ovflPageSize - 1)/ovflPageSize;
77448 (CORRUPT_DB && (pInfo->nPayload + ovflPageSize)<ovflPageSize)
77450 while( nOvfl-- ){
77465 && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1
77472 ** freePage2() may zero the page contents if secure-delete mode is
77483 sqlite3PagerUnref(pOvfl->pDbPage);
77498 pPage->xParseCell(pPage, pCell, &sInfo); \
77513 ** Note that pCell does not necessary need to point to the pPage->aData
77515 ** be constructed in this temporary area then copied into pPage->aData
77535 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
77539 assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
77540 || sqlite3PagerIswriteable(pPage->pDbPage) );
77543 nHeader = pPage->childPtrSize;
77544 if( pPage->intKey ){
77545 nPayload = pX->nData + pX->nZero;
77546 pSrc = pX->pData;
77547 nSrc = pX->nData;
77548 assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */
77550 nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey);
77552 assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
77553 nSrc = nPayload = (int)pX->nKey;
77554 pSrc = pX->pKey;
77560 if( nPayload<=pPage->maxLocal ){
77574 memset(pPayload+nSrc, 0, nPayload-nSrc);
77581 mn = pPage->minLocal;
77582 n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4);
77583 testcase( n==pPage->maxLocal );
77584 testcase( n==pPage->maxLocal+1 );
77585 if( n > pPage->maxLocal ) n = mn;
77591 pBt = pPage->pBt;
77608 pPage->xParseCell(pPage, pCell, &info);
77609 assert( nHeader==(int)(info.pPayload - pCell) );
77610 assert( info.nKey==pX->nKey );
77623 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
77627 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
77628 || sqlite3PagerIswriteable(pPage->pDbPage) );
77638 nPayload -= n;
77642 nSrc -= n;
77643 spaceLeft -= n;
77647 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
77648 if( pBt->autoVacuum ){
77658 /* If the database supports auto-vacuum, and the second or subsequent
77659 ** overflow page is being allocated, add an entry to the pointer-map
77663 ** to the pointer-map. If we write nothing to this pointer-map slot,
77668 if( pBt->autoVacuum && rc==SQLITE_OK ){
77683 assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
77687 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
77688 || sqlite3PagerIswriteable(pPage->pDbPage) );
77693 pPrior = pOvfl->aData;
77695 pPayload = &pOvfl->aData[4];
77696 spaceLeft = pBt->usableSize - 4;
77704 ** Remove the i-th cell from pPage. This routine effects pPage only.
77713 u8 *data; /* pPage->aData */
77716 int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */
77720 assert( idx<pPage->nCell );
77722 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
77723 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
77724 assert( pPage->nFree>=0 );
77725 data = pPage->aData;
77726 ptr = &pPage->aCellIdx[2*idx];
77727 assert( pPage->pBt->usableSize > (u32)(ptr-data) );
77729 hdr = pPage->hdrOffset;
77731 testcase( pc+sz==pPage->pBt->usableSize );
77732 if( pc+sz > pPage->pBt->usableSize ){
77741 pPage->nCell--;
77742 if( pPage->nCell==0 ){
77745 put2byte(&data[hdr+5], pPage->pBt->usableSize);
77746 pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset
77747 - pPage->childPtrSize - 8;
77749 memmove(ptr, ptr+2, 2*(pPage->nCell - idx));
77750 put2byte(&data[hdr+3], pPage->nCell);
77751 pPage->nFree += 2;
77762 ** in pPage->apOvfl[] and make it point to the cell content (either
77764 ** Allocating a new entry in pPage->aCell[] implies that
77765 ** pPage->nOverflow is incremented.
77777 int i, /* New cell becomes the i-th cell of the page */
77781 Pgno iChild /* If non-zero, replace first 4 bytes with this value */
77786 u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */
77788 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
77789 assert( MX_CELL(pPage->pBt)<=10921 );
77790 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
77791 assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) );
77792 assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
77793 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
77794 assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB );
77795 assert( pPage->nFree>=0 );
77797 if( pPage->nOverflow || sz+2>pPage->nFree ){
77803 j = pPage->nOverflow++;
77804 /* Comparison against ArraySize-1 since we hold back one extra slot
77807 assert( j < ArraySize(pPage->apOvfl)-1 );
77808 pPage->apOvfl[j] = pCell;
77809 pPage->aiOvfl[j] = (u16)i;
77816 assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
77817 assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */
77819 int rc = sqlite3PagerWrite(pPage->pDbPage);
77823 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
77824 data = pPage->aData;
77825 assert( &data[pPage->cellOffset]==pPage->aCellIdx );
77831 assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB );
77832 assert( idx+sz <= (int)pPage->pBt->usableSize );
77833 pPage->nFree -= (u16)(2 + sz);
77839 memcpy(&data[idx+4], pCell+4, sz-4);
77841 pIns = pPage->aCellIdx + i*2;
77842 memmove(pIns+2, pIns, 2*(pPage->nCell - i));
77844 pPage->nCell++;
77846 if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++;
77847 assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );
77849 if( pPage->pBt->autoVacuum ){
77874 int i, /* New cell becomes the i-th cell of the page */
77881 u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */
77883 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
77884 assert( MX_CELL(pPage->pBt)<=10921 );
77885 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
77886 assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) );
77887 assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
77888 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
77889 assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB );
77890 assert( pPage->nFree>=0 );
77891 assert( pPage->nOverflow==0 );
77892 if( sz+2>pPage->nFree ){
77893 j = pPage->nOverflow++;
77894 /* Comparison against ArraySize-1 since we hold back one extra slot
77897 assert( j < ArraySize(pPage->apOvfl)-1 );
77898 pPage->apOvfl[j] = pCell;
77899 pPage->aiOvfl[j] = (u16)i;
77906 assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
77907 assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */
77909 int rc = sqlite3PagerWrite(pPage->pDbPage);
77913 assert( sqlite3PagerIswriteable(pPage->pDbPage) );
77914 data = pPage->aData;
77915 assert( &data[pPage->cellOffset]==pPage->aCellIdx );
77921 assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB );
77922 assert( idx+sz <= (int)pPage->pBt->usableSize );
77923 pPage->nFree -= (u16)(2 + sz);
77925 pIns = pPage->aCellIdx + i*2;
77926 memmove(pIns+2, pIns, 2*(pPage->nCell - i));
77928 pPage->nCell++;
77930 if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++;
77931 assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );
77933 if( pPage->pBt->autoVacuum ){
77959 ** tunable - as if you could change them and recompile and it would all work.
77974 ** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
77986 ** -----------
77988 ** -----------
77991 ** --------- --------- ---------
77992 ** |Child-1| |Child-2| |Child-3|
77993 ** --------- --------- ---------
77997 ** 1. All cells from Child-1 in order
77999 ** 3. All cells from Child-2 in order
78001 ** 5. All cells from Child-3 in order
78003 ** For a table-btree (with rowids) the items 2 and 4 are empty because
78007 ** for Child-1, the Parent, Child-2, the Parent (again), and Child-3,
78011 ** ixNx[0] = Number of cells in Child-1.
78012 ** ixNx[1] = Number of cells in Child-1 plus 1 for first divider.
78013 ** ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider.
78014 ** ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells
78017 ** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2]
78020 ** ixNx[0] = Number of cells in Child-1.
78021 ** ixNx[1] = Number of cells in Child-1 and Child-2.
78040 ** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been
78044 MemPage *pRef = p->pRef;
78045 u16 *szCell = p->szCell;
78046 assert( idx>=0 && idx+N<=p->nCell );
78048 assert( p->apCell[idx]!=0 );
78050 szCell[idx] = pRef->xCellSize(pRef, p->apCell[idx]);
78053 szCell[idx]==pRef->xCellSize(pRef, p->apCell[idx]) );
78056 N--;
78064 assert( N>=0 && N<p->nCell );
78065 assert( p->szCell[N]==0 );
78066 p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]);
78067 return p->szCell[N];
78070 assert( N>=0 && N<p->nCell );
78071 if( p->szCell[N] ) return p->szCell[N];
78076 ** Array apCell[] contains pointers to nCell b-tree page cells. The
78094 const int hdr = pPg->hdrOffset; /* Offset of header on pPg */
78095 u8 * const aData = pPg->aData; /* Pointer to data for pPg */
78096 const int usableSize = pPg->pBt->usableSize;
78101 u8 *pCellptr = pPg->aCellIdx;
78102 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
78104 int k; /* Current slot in pCArray->apEnd[] */
78105 u8 *pSrcEnd; /* Current pCArray->apEnd[k] value */
78111 memcpy(&pTmp[j], &aData[j], usableSize - j);
78113 for(k=0; ALWAYS(k<NB*2) && pCArray->ixNx[k]<=i; k++){}
78114 pSrcEnd = pCArray->apEnd[k];
78118 u8 *pCell = pCArray->apCell[i];
78119 u16 sz = pCArray->szCell[i];
78123 pCell = &pTmp[pCell - aData];
78130 pData -= sz;
78131 put2byte(pCellptr, (pData - aData));
78135 assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
78138 if( pCArray->ixNx[k]<=i ){
78140 pSrcEnd = pCArray->apEnd[k];
78144 /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
78145 pPg->nCell = nCell;
78146 pPg->nOverflow = 0;
78149 put2byte(&aData[hdr+3], pPg->nCell);
78150 put2byte(&aData[hdr+5], pData - aData);
78156 ** The pCArray objects contains pointers to b-tree cells and the cell sizes.
78159 ** will fit), non-zero is returned. Otherwise, if the cells are added
78162 ** Argument pCellptr points to the first entry in the cell-pointer array
78164 ** page body, a 16-bit offset is written to pCellptr. And so on, for each
78166 ** that it is safe to overwrite this part of the cell-pointer array.
78174 ** end of the space required by this page for the cell-pointer area (for
78175 ** all cells - not just those inserted by the current call). If the content
78177 ** cells in apCell[], then the cells do not fit and non-zero is returned.
78181 u8 *pBegin, /* End of cell-pointer array */
78182 u8 **ppData, /* IN/OUT: Page content-area pointer */
78183 u8 *pCellptr, /* Pointer to cell-pointer area */
78188 int i = iFirst; /* Loop counter - cell index to insert */
78189 u8 *aData = pPg->aData; /* Complete page */
78192 int k; /* Current slot in pCArray->apEnd[] */
78194 assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */
78196 for(k=0; ALWAYS(k<NB*2) && pCArray->ixNx[k]<=i ; k++){}
78197 pEnd = pCArray->apEnd[k];
78201 assert( pCArray->szCell[i]!=0 );
78202 sz = pCArray->szCell[i];
78204 if( (pData - pBegin)<sz ) return 1;
78205 pData -= sz;
78208 /* pSlot and pCArray->apCell[i] will never overlap on a well-formed
78211 assert( (pSlot+sz)<=pCArray->apCell[i]
78212 || pSlot>=(pCArray->apCell[i]+sz)
78214 if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd
78215 && (uptr)(pCArray->apCell[i])<(uptr)pEnd
78221 memmove(pSlot, pCArray->apCell[i], sz);
78222 put2byte(pCellptr, (pSlot - aData));
78226 if( pCArray->ixNx[k]<=i ){
78228 pEnd = pCArray->apEnd[k];
78236 ** The pCArray object contains pointers to b-tree cells and their sizes.
78239 ** that is currently stored within the body of pPg to the pPg free-list.
78240 ** The cell-pointers and other fields of the page are not updated.
78242 ** This function returns the total number of cells added to the free-list.
78250 u8 * const aData = pPg->aData;
78251 u8 * const pEnd = &aData[pPg->pBt->usableSize];
78252 u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
78261 u8 *pCell = pCArray->apCell[i];
78269 sz = pCArray->szCell[i]; assert( sz>0 );
78270 iOfst = (u16)(pCell - aData);
78284 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
78297 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
78304 ** balanced. The current page, pPg, has pPg->nCell cells starting with
78305 ** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells
78311 ** The pPg->nFree field is invalid when this function returns. It is the
78321 u8 * const aData = pPg->aData;
78322 const int hdr = pPg->hdrOffset;
78323 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
78324 int nCell = pPg->nCell; /* Cells stored on pPg */
78328 int iOldEnd = iOld + pPg->nCell + pPg->nOverflow;
78332 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
78333 memcpy(pTmp, aData, pPg->pBt->usableSize);
78339 int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
78341 memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2);
78342 nCell -= nShift;
78345 int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray);
78347 nCell -= nTail;
78352 if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail;
78356 int nAdd = MIN(nNew,iOld-iNew);
78357 assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
78359 pCellptr = pPg->aCellIdx;
78369 for(i=0; i<pPg->nOverflow; i++){
78370 int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
78372 pCellptr = &pPg->aCellIdx[iCell * 2];
78374 memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2);
78387 pCellptr = &pPg->aCellIdx[nCell*2];
78390 iNew+nCell, nNew-nCell, pCArray
78393 pPg->nCell = nNew;
78394 pPg->nOverflow = 0;
78396 put2byte(&aData[hdr+3], pPg->nCell);
78397 put2byte(&aData[hdr+5], pData - aData);
78401 u8 *pCell = pCArray->apCell[i+iNew];
78402 int iOff = get2byteAligned(&pPg->aCellIdx[i*2]);
78403 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
78404 pCell = &pTmp[pCell - aData];
78407 pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) );
78423 ** a new entry is being inserted on the extreme right-end of the
78427 ** Instead of trying to balance the 3 right-most leaf pages, just add
78428 ** a new page to the right-hand side and put the one new entry in
78434 ** pPage is the leaf page which is the right-most page in the tree.
78436 ** which is also the right-most entry on the page.
78445 BtShared *const pBt = pPage->pBt; /* B-Tree Database */
78450 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
78451 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
78452 assert( pPage->nOverflow==1 );
78454 if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT; /* dbfuzz001.test */
78455 assert( pPage->nFree>=0 );
78456 assert( pParent->nFree>=0 );
78458 /* Allocate a new page. This page will become the right-sibling of
78467 u8 *pCell = pPage->apOvfl[0];
78468 u16 szCell = pPage->xCellSize(pPage, pCell);
78472 assert( sqlite3PagerIswriteable(pNew->pDbPage) );
78473 assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
78479 b.apEnd[0] = pPage->aDataEnd;
78486 pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
78488 /* If this is an auto-vacuum database, update the pointer map
78498 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
78499 if( szCell>pNew->minLocal ){
78505 ** consists of a 4-byte page number (the page number of pPage) and
78509 ** To find the largest key value on pPage, first find the right-most
78511 ** record-length (a variable length integer at most 32-bits in size)
78513 ** The first of the while(...) loops below skips over the record-length
78517 pCell = findCell(pPage, pPage->nCell-1);
78525 rc = insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
78526 0, pPage->pgno);
78529 /* Set the right-child pointer of pParent to point to the new page. */
78530 put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
78544 ** for setting pointer-map entries.
78552 BtShared *pBt = pPage->pBt;
78553 assert( pPage->isInit );
78555 for(j=0; j<pPage->nCell; j++){
78560 pPage->xParseCell(pPage, z, &info);
78562 Pgno ovfl = get4byte(&z[info.nSize-4]);
78564 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
78566 if( !pPage->leaf ){
78569 assert( n==pPage->pgno && e==PTRMAP_BTREE );
78572 if( !pPage->leaf ){
78573 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
78575 assert( n==pPage->pgno && e==PTRMAP_BTREE );
78583 ** This function is used to copy the contents of the b-tree node stored
78585 ** the pointer-map entries for each child page are updated so that the
78601 BtShared * const pBt = pFrom->pBt;
78602 u8 * const aFrom = pFrom->aData;
78603 u8 * const aTo = pTo->aData;
78604 int const iFromHdr = pFrom->hdrOffset;
78605 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
78610 assert( pFrom->isInit );
78611 assert( pFrom->nFree>=iToHdr );
78612 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
78614 /* Copy the b-tree node content from page pFrom to page pTo. */
78616 memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
78617 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
78624 pTo->isInit = 0;
78632 /* If this is an auto-vacuum database, update the pointer-map entries
78633 ** for any b-tree or overflow pages that pTo now contains the pointers to.
78675 ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large
78684 u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */
78685 int isRoot, /* True if pParent is a root-page */
78693 int nxDiv; /* Next divider slot in pParent->aCell[] */
78698 int pageFlags; /* Value of pPage->aData[0] */
78704 u8 *pRight; /* Location in parent of right-sibling pointer */
78705 u8 *apDiv[NB-1]; /* Divider cells in pParent */
78706 int cntNew[NB+2]; /* Index in b.paCell[] of cell after i-th page */
78708 int szNew[NB+2]; /* Combined size of cells placed on i-th page */
78717 pBt = pParent->pBt;
78718 assert( sqlite3_mutex_held(pBt->mutex) );
78719 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
78726 assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
78727 assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx );
78732 assert( pParent->nFree>=0 );
78745 i = pParent->nOverflow + pParent->nCell;
78753 nxDiv = i-2+bBulk;
78755 nxDiv = iParentIdx-1;
78757 i = 2-bBulk;
78760 if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
78761 pRight = &pParent->aData[pParent->hdrOffset+8];
78763 pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
78774 if( apOld[i]->nFree<0 ){
78781 nMaxCells += apOld[i]->nCell + ArraySize(pParent->apOvfl);
78782 if( (i--)==0 ) break;
78784 if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){
78785 apDiv[i] = pParent->apOvfl[0];
78787 szNew[i] = pParent->xCellSize(pParent, apDiv[i]);
78788 pParent->nOverflow = 0;
78790 apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow);
78792 szNew[i] = pParent->xCellSize(pParent, apDiv[i]);
78801 ** But not if we are in secure-delete mode. In secure-delete mode,
78806 if( pBt->btsFlags & BTS_FAST_SECURE ){
78811 iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
78812 if( (iOff+szNew[i])<=(int)pBt->usableSize ){
78814 apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
78817 dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc);
78821 /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
78831 + pBt->pageSize; /* aSpace1 */
78833 assert( szScratch<=7*(int)pBt->pageSize );
78860 leafCorrection = b.pRef->leaf*4;
78861 leafData = b.pRef->intKeyLeaf;
78864 int limit = pOld->nCell;
78865 u8 *aData = pOld->aData;
78866 u16 maskPage = pOld->maskPage;
78867 u8 *piCell = aData + pOld->cellOffset;
78871 /* Verify that all sibling pages are of the same "type" (table-leaf,
78872 ** table-interior, index-leaf, or index-interior).
78874 if( pOld->aData[0]!=apOld[0]->aData[0] ){
78896 memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
78897 if( pOld->nOverflow>0 ){
78898 if( NEVER(limit<pOld->aiOvfl[0]) ){
78902 limit = pOld->aiOvfl[0];
78908 for(k=0; k<pOld->nOverflow; k++){
78909 assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */
78910 b.apCell[b.nCell] = pOld->apOvfl[k];
78914 piEnd = aData + pOld->cellOffset + 2*pOld->nCell;
78921 assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) );
78924 if( i<nOld-1 && !leafData){
78931 assert( sz<=pBt->maxLocal+23 );
78932 assert( iSpace1 <= (int)pBt->pageSize );
78936 b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection;
78937 if( !pOld->leaf ){
78939 assert( pOld->hdrOffset==0 || CORRUPT_DB );
78942 memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
78949 assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB );
78961 ** size of all cells on the i-th page and cntNew[] which is the index
78968 ** szNew[i]: Spaced used on the i-th sibling page.
78970 ** the right of the i-th sibling page.
78974 usableSpace = pBt->usableSize - 12 + leafCorrection;
78977 b.apEnd[k] = p->aDataEnd;
78979 if( k && b.ixNx[k]==b.ixNx[k-1] ){
78980 k--; /* Omit b.ixNx[] entry for child pages with no cells */
78984 b.apEnd[k] = pParent->aDataEnd;
78987 assert( p->nFree>=0 );
78988 szNew[i] = usableSpace - p->nFree;
78989 for(j=0; j<p->nOverflow; j++){
78990 szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);
79001 szNew[k-1] = 0;
79002 cntNew[k-1] = b.nCell;
79004 sz = 2 + cachedCellSize(&b, cntNew[i]-1);
79005 szNew[i] -= sz;
79014 cntNew[i]--;
79028 szNew[i+1] -= sz;
79032 }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){
79041 ** always nearly full, while the right-most sibling might be nearly empty.
79046 ** be so out of balance as to be illegal. For example, the right-most
79049 for(i=k-1; i>0; i--){
79051 int szLeft = szNew[i-1]; /* Size of sibling on the left */
79052 int r; /* Index of right-most cell in left sibling */
79055 r = cntNew[i-1] - 1;
79056 d = r + 1 - leafData;
79065 && (bBulk || szRight+szD+2 > szLeft-(szR+(i==k-1?0:2)))){
79069 szLeft -= szR + 2;
79070 cntNew[i-1] = r;
79071 r--;
79072 d--;
79075 szNew[i-1] = szLeft;
79076 if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){
79082 /* Sanity check: For a non-corrupt database file one of the following
79089 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
79091 apOld[0]->pgno, apOld[0]->nCell,
79092 nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0,
79093 nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0
79099 pageFlags = apOld[0]->aData[0];
79105 rc = sqlite3PagerWrite(pNew->pDbPage);
79107 if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv))
79122 /* Set the pointer-map entry for the new sibling page. */
79124 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
79145 aPgno[i] = apNew[i]->pgno;
79146 assert( apNew[i]->pDbPage->flags & PGHDR_WRITEABLE );
79147 assert( apNew[i]->pDbPage->flags & PGHDR_DIRTY );
79149 for(i=0; i<nNew-1; i++){
79152 if( apNew[j]->pgno < apNew[iB]->pgno ) iB = j;
79161 Pgno pgnoA = apNew[i]->pgno;
79162 Pgno pgnoB = apNew[iB]->pgno;
79163 Pgno pgnoTemp = (PENDING_BYTE/pBt->pageSize)+1;
79164 u16 fgA = apNew[i]->pDbPage->flags;
79165 u16 fgB = apNew[iB]->pDbPage->flags;
79166 sqlite3PagerRekey(apNew[i]->pDbPage, pgnoTemp, fgB);
79167 sqlite3PagerRekey(apNew[iB]->pDbPage, pgnoA, fgA);
79168 sqlite3PagerRekey(apNew[i]->pDbPage, pgnoB, fgB);
79169 apNew[i]->pgno = pgnoB;
79170 apNew[iB]->pgno = pgnoA;
79176 apNew[0]->pgno, szNew[0], cntNew[0],
79177 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
79178 nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0,
79179 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
79180 nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0,
79181 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
79182 nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0,
79183 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
79184 nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0
79187 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
79189 assert( apNew[nNew-1]!=0 );
79190 put4byte(pRight, apNew[nNew-1]->pgno);
79192 /* If the sibling pages are not leaves, ensure that the right-child pointer
79193 ** of the right-most new sibling page is set to the value that was
79194 ** originally in the same field of the right-most old sibling page. */
79196 MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1];
79197 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
79212 ** associated with the right-child of each sibling may also need to be
79219 int cntOldNext = pNew->nCell + pNew->nOverflow;
79230 cntOldNext += pOld->nCell + pOld->nOverflow + !leafData;
79244 || pNew->pgno!=aPgno[iOld]
79245 || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
79248 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
79250 if( cachedCellSize(&b,i)>pNew->minLocal ){
79259 for(i=0; i<nNew-1; i++){
79272 if( !pNew->leaf ){
79273 memcpy(&pNew->aData[8], pCell, 4);
79275 /* If the tree is a leaf-data tree, and the siblings are leaves,
79277 ** cell consists of the integer key for the right-most cell of
79278 ** the sibling-page assembled above only.
79281 j--;
79282 pNew->xParseCell(pNew, b.apCell[j], &info);
79287 pCell -= 4;
79288 /* Obscure case for non-leaf-data trees: If the cell at pCell was
79295 ** This can only happen for b-trees used to evaluate "IN (SELECT ...)"
79301 sz = pParent->xCellSize(pParent, pCell);
79305 assert( sz<=pBt->maxLocal+23 );
79306 assert( iOvflSpace <= (int)pBt->pageSize );
79313 rc = insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno);
79315 assert( sqlite3PagerIswriteable(pParent->pDbPage) );
79322 ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1])
79324 ** the left-hand sibling apNew[iPg-1] has been updated.
79328 ** the right-hand sibling apNew[iPg+1] has been updated.
79332 ** The iPg value in the following loop starts at nNew-1 goes down
79333 ** to 0, then back up to nNew-1 again, thus making two passes over
79340 for(i=1-nNew; i<nNew; i++){
79341 int iPg = i<0 ? -i : i;
79347 || cntOld[iPg-1]>=cntNew[iPg-1] /* Condition (1) is true */
79354 ** only after iPg-1 has already been updated. */
79355 assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] );
79365 iOld = iPg<nOld ? (cntOld[iPg-1] + !leafData) : b.nCell;
79366 iNew = cntNew[iPg-1] + !leafData;
79367 nNewCell = cntNew[iPg] - iNew;
79373 apNew[iPg]->nFree = usableSpace-szNew[iPg];
79374 assert( apNew[iPg]->nOverflow==0 );
79375 assert( apNew[iPg]->nCell==nNewCell );
79385 if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
79386 /* The root page of the b-tree now contains no cells. The only sibling
79387 ** page is the right-child of the parent. Copy the contents of the
79389 ** b-tree structure by one. This is described as the "balance-shallower"
79390 ** sub-algorithm in some documentation.
79392 ** If this is an auto-vacuum database, the call to copyNodeContent()
79393 ** sets all pointer-map entries corresponding to database image pages
79402 rc = defragmentPage(apNew[0], -1);
79404 assert( apNew[0]->nFree ==
79405 (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset
79406 - apNew[0]->nCell*2)
79412 /* Fix the pointer map entries associated with the right-child of each
79416 u32 key = get4byte(&apNew[i]->aData[8]);
79417 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
79421 assert( pParent->isInit );
79432 if( ISAUTOVACUUM(pBt) && rc==SQLITE_OK && apNew[0]->isInit ){
79459 ** This function is called when the root page of a b-tree structure is
79464 ** page is then overwritten to make it an empty page with the right-child
79467 ** Before returning, all pointer-map entries corresponding to pages
79468 ** that the new child-page now contains pointers to are updated. The
79469 ** entry corresponding to the new right-child pointer of the root
79481 BtShared *pBt = pRoot->pBt; /* The BTree */
79483 assert( pRoot->nOverflow>0 );
79484 assert( sqlite3_mutex_held(pBt->mutex) );
79486 /* Make pRoot, the root page of the b-tree, writable. Allocate a new
79487 ** page that will become the new right-child of pPage. Copy the contents
79490 rc = sqlite3PagerWrite(pRoot->pDbPage);
79492 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
79495 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
79503 assert( sqlite3PagerIswriteable(pChild->pDbPage) );
79504 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
79505 assert( pChild->nCell==pRoot->nCell || CORRUPT_DB );
79507 TRACE(("BALANCE: copy root %u into %u\n", pRoot->pgno, pChild->pgno));
79510 memcpy(pChild->aiOvfl, pRoot->aiOvfl,
79511 pRoot->nOverflow*sizeof(pRoot->aiOvfl[0]));
79512 memcpy(pChild->apOvfl, pRoot->apOvfl,
79513 pRoot->nOverflow*sizeof(pRoot->apOvfl[0]));
79514 pChild->nOverflow = pRoot->nOverflow;
79516 /* Zero the contents of pRoot. Then install pChild as the right-child. */
79517 zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
79518 put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
79526 ** on the same B-tree as pCur.
79529 ** pointing to the same b-tree. If an insert occurs on one SQL table
79531 ** table linked to the same b-tree. If the secondary insert causes a
79537 for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){
79539 && pOther->eState==CURSOR_VALID
79540 && pOther->pPage==pCur->pPage
79542 return SQLITE_CORRUPT_PAGE(pCur->pPage);
79568 MemPage *pPage = pCur->pPage;
79570 if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break;
79571 if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
79577 }else if( (iPage = pCur->iPage)==0 ){
79578 if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){
79579 /* The root page of the b-tree is overfull. In this case call the
79580 ** balance_deeper() function to create a new child for the root-page
79581 ** and copy the current contents of the root-page to it. The
79582 ** next iteration of the do-loop will balance the child page.
79586 rc = balance_deeper(pPage, &pCur->apPage[1]);
79588 pCur->iPage = 1;
79589 pCur->ix = 0;
79590 pCur->aiIdx[0] = 0;
79591 pCur->apPage[0] = pPage;
79592 pCur->pPage = pCur->apPage[1];
79593 assert( pCur->pPage->nOverflow );
79598 }else if( sqlite3PagerPageRefcount(pPage->pDbPage)>1 ){
79604 MemPage * const pParent = pCur->apPage[iPage-1];
79605 int const iIdx = pCur->aiIdx[iPage-1];
79607 rc = sqlite3PagerWrite(pParent->pDbPage);
79608 if( rc==SQLITE_OK && pParent->nFree<0 ){
79613 if( pPage->intKeyLeaf
79614 && pPage->nOverflow==1
79615 && pPage->aiOvfl[0]==pPage->nCell
79616 && pParent->pgno!=1
79617 && pParent->nCell==iIdx
79622 ** happens, the next iteration of the do-loop will balance pParent
79641 ** become overfull or underfull. The next iteration of the do-loop
79646 ** A subsequent iteration of the do-loop will deal with this by
79648 ** but it doesn't deal with overflow cells - just moves them to a
79655 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
79657 pCur->hints&BTREE_BULKLOAD);
79673 pPage->nOverflow = 0;
79675 /* The next iteration of the do-loop balances the parent page. */
79677 pCur->iPage--;
79678 assert( pCur->iPage>=0 );
79679 pCur->pPage = pCur->apPage[pCur->iPage];
79699 int nData = pX->nData - iOffset;
79705 int rc = sqlite3PagerWrite(pPage->pDbPage);
79707 memset(pDest + i, 0, iAmt - i);
79714 iAmt-nData);
79718 if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
79719 int rc = sqlite3PagerWrite(pPage->pDbPage);
79725 memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt);
79740 int iOffset; /* Next byte of pX->pData to write */
79741 int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */
79743 MemPage *pPage = pCur->pPage; /* Page being written */
79748 assert( pCur->info.nLocal<nTotal ); /* pCur is an overflow cell */
79751 rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
79752 0, pCur->info.nLocal);
79756 iOffset = pCur->info.nLocal;
79759 ovflPgno = get4byte(pCur->info.pPayload + iOffset);
79760 pBt = pPage->pBt;
79761 ovflPageSize = pBt->usableSize - 4;
79765 if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){
79769 ovflPgno = get4byte(pPage->aData);
79771 ovflPageSize = nTotal - iOffset;
79773 rc = btreeOverwriteContent(pPage, pPage->aData+4, pX,
79776 sqlite3PagerUnref(pPage->pDbPage);
79788 int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */
79789 MemPage *pPage = pCur->pPage; /* Page being written */
79791 if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
79792 || pCur->info.pPayload < pPage->aData + pPage->cellOffset
79796 if( pCur->info.nLocal==nTotal ){
79798 return btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
79799 0, pCur->info.nLocal);
79822 ** If the seekResult parameter is non-zero, then a successful call to
79833 ** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked
79834 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
79844 int loc = seekResult; /* -1: before desired location +1: after */
79848 Btree *p = pCur->pBtree;
79853 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
79857 ** In some cases, the call to btreeMoveto() below is a no-op. For
79858 ** example, when inserting data into a table with auto-generated integer
79861 ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
79866 if( pCur->curFlags & BTCF_Multiple ){
79867 rc = saveAllCursors(p->pBt, pCur->pgnoRoot, pCur);
79869 if( loc && pCur->iPage<0 ){
79875 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
79882 if( pCur->eState>=CURSOR_REQUIRESEEK ){
79883 testcase( pCur->eState==CURSOR_REQUIRESEEK );
79884 testcase( pCur->eState==CURSOR_FAULT );
79890 assert( (pCur->curFlags & BTCF_WriteFlag)!=0
79891 && p->pBt->inTransaction==TRANS_WRITE
79892 && (p->pBt->btsFlags & BTS_READ_ONLY)==0 );
79893 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
79896 ** expecting an index b-tree, then the caller should be inserting blob
79900 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
79902 if( pCur->pKeyInfo==0 ){
79903 assert( pX->pKey==0 );
79904 /* If this is an insert into a table b-tree, invalidate any incrblob
79906 if( p->hasIncrblobCur ){
79907 invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
79915 assert( pCur->curFlags & BTCF_ValidNKey );
79916 assert( pX->nKey==pCur->info.nKey );
79925 if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
79928 assert( pX->nData>=0 && pX->nZero>=0 );
79929 if( pCur->info.nSize!=0
79930 && pCur->info.nPayload==(u32)pX->nData+pX->nZero
79941 rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
79959 if( pX->nMem ){
79961 r.pKeyInfo = pCur->pKeyInfo;
79962 r.aMem = pX->aMem;
79963 r.nField = pX->nMem;
79968 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
79980 if( pCur->info.nKey==pX->nKey ){
79982 x2.pData = pX->pKey;
79983 x2.nData = pX->nKey;
79989 assert( pCur->eState==CURSOR_VALID
79990 || (pCur->eState==CURSOR_INVALID && loc) || CORRUPT_DB );
79992 pPage = pCur->pPage;
79993 assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
79994 assert( pPage->leaf || !pPage->intKey );
79995 if( pPage->nFree<0 ){
79996 if( NEVER(pCur->eState>CURSOR_INVALID) ){
79997 /* ^^^^^--- due to the moveToRoot() call above */
80006 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
80008 assert( pPage->isInit || CORRUPT_DB );
80009 newCell = p->pBt->pTmpSpace;
80014 szNew = p->pBt->nPreformatSize;
80019 if( ISAUTOVACUUM(p->pBt) && szNew>pPage->maxLocal ){
80021 pPage->xParseCell(pPage, newCell, &info);
80023 Pgno ovfl = get4byte(&newCell[szNew-4]);
80024 ptrmapPut(p->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);
80032 assert( szNew==pPage->xCellSize(pPage, newCell) );
80033 assert( szNew <= MX_CELL_SIZE(p->pBt) );
80034 idx = pCur->ix;
80035 pCur->info.nSize = 0;
80039 if( idx>=pPage->nCell ){
80042 rc = sqlite3PagerWrite(pPage->pDbPage);
80047 if( !pPage->leaf ){
80051 testcase( pCur->curFlags & BTCF_ValidOvfl );
80054 && (!ISAUTOVACUUM(p->pBt) || szNew<pPage->minLocal)
80064 ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry. */
80066 if( oldCell < pPage->aData+pPage->hdrOffset+10 ){
80069 if( oldCell+szNew > pPage->aDataEnd ){
80077 }else if( loc<0 && pPage->nCell>0 ){
80078 assert( pPage->leaf );
80079 idx = ++pCur->ix;
80080 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
80082 assert( pPage->leaf );
80085 assert( pPage->nOverflow==0 || rc==SQLITE_OK );
80086 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
80100 ** multiple records into an intkey b-tree using a single cursor (as can
80103 ** the b-tree if possible. If the cursor is left pointing to the last
80108 if( pPage->nOverflow ){
80110 pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
80117 pCur->pPage->nOverflow = 0;
80118 pCur->eState = CURSOR_INVALID;
80121 if( pCur->pKeyInfo ){
80122 assert( pCur->pKey==0 );
80123 pCur->pKey = sqlite3Malloc( pX->nKey );
80124 if( pCur->pKey==0 ){
80127 memcpy(pCur->pKey, pX->pKey, pX->nKey);
80130 pCur->eState = CURSOR_REQUIRESEEK;
80131 pCur->nKey = pX->nKey;
80134 assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );
80156 BtShared *pBt = pDest->pBt;
80157 u8 *aOut = pBt->pTmpSpace; /* Pointer to next output buffer */
80163 if( pSrc->info.nPayload<0x80 ){
80164 *(aOut++) = pSrc->info.nPayload;
80166 aOut += sqlite3PutVarint(aOut, pSrc->info.nPayload);
80168 if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey);
80169 nIn = pSrc->info.nLocal;
80170 aIn = pSrc->info.pPayload;
80171 if( aIn+nIn>pSrc->pPage->aDataEnd ){
80172 return SQLITE_CORRUPT_PAGE(pSrc->pPage);
80174 nRem = pSrc->info.nPayload;
80175 if( nIn==nRem && nIn<pDest->pPage->maxLocal ){
80177 pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace);
80181 Pager *pSrcPager = pSrc->pBt->pPager;
80188 nOut = btreePayloadToLocal(pDest->pPage, pSrc->info.nPayload);
80189 pBt->nPreformatSize = nOut + (aOut - pBt->pTmpSpace);
80190 if( nOut<pSrc->info.nPayload ){
80192 pBt->nPreformatSize += 4;
80196 if( aIn+nIn+4>pSrc->pPage->aDataEnd ){
80197 return SQLITE_CORRUPT_PAGE(pSrc->pPage);
80199 ovflIn = get4byte(&pSrc->info.pPayload[nIn]);
80203 nRem -= nOut;
80209 nOut -= nCopy;
80210 nIn -= nCopy;
80222 nIn = pSrc->pBt->usableSize - 4;
80233 ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);
80238 pPgnoOut = pPageOut->aData;
80241 nOut = MIN(pBt->usableSize - 4, nRem);
80265 ** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag.
80270 Btree *p = pCur->pBtree;
80271 BtShared *pBt = p->pBt;
80281 assert( pBt->inTransaction==TRANS_WRITE );
80282 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
80283 assert( pCur->curFlags & BTCF_WriteFlag );
80284 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
80285 assert( !hasReadConflicts(p, pCur->pgnoRoot) );
80287 if( pCur->eState!=CURSOR_VALID ){
80288 if( pCur->eState>=CURSOR_REQUIRESEEK ){
80290 assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
80291 if( rc || pCur->eState!=CURSOR_VALID ) return rc;
80293 return SQLITE_CORRUPT_PGNO(pCur->pgnoRoot);
80296 assert( pCur->eState==CURSOR_VALID );
80298 iCellDepth = pCur->iPage;
80299 iCellIdx = pCur->ix;
80300 pPage = pCur->pPage;
80301 if( pPage->nCell<=iCellIdx ){
80305 if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){
80308 if( pCell<&pPage->aCellIdx[pPage->nCell] ){
80314 ** will cause a b-tree rebalance, then this is done by saving the cursor
80330 if( !pPage->leaf
80331 || (pPage->nFree+pPage->xCellSize(pPage,pCell)+2) >
80332 (int)(pBt->usableSize*2/3)
80333 || pPage->nCell==1 /* See dbfuzz001.test for a test case */
80335 /* A b-tree rebalance will be required after deleting this entry.
80349 ** sub-tree headed by the child page of the cell being deleted. This makes
80351 if( !pPage->leaf ){
80359 if( pCur->curFlags & BTCF_Multiple ){
80360 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
80364 /* If this is a delete operation to remove a row from a table b-tree,
80366 if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
80367 invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
80373 rc = sqlite3PagerWrite(pPage->pDbPage);
80380 ** is currently pointing to the largest entry in the sub-tree headed
80381 ** by the child-page of the cell that was just deleted from an internal
80384 if( !pPage->leaf ){
80385 MemPage *pLeaf = pCur->pPage;
80390 if( pLeaf->nFree<0 ){
80394 if( iCellDepth<pCur->iPage-1 ){
80395 n = pCur->apPage[iCellDepth+1]->pgno;
80397 n = pCur->pPage->pgno;
80399 pCell = findCell(pLeaf, pLeaf->nCell-1);
80400 if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_PAGE(pLeaf);
80401 nCell = pLeaf->xCellSize(pLeaf, pCell);
80403 pTmp = pBt->pTmpSpace;
80405 rc = sqlite3PagerWrite(pLeaf->pDbPage);
80407 rc = insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n);
80409 dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
80428 assert( pCur->pPage->nOverflow==0 );
80429 assert( pCur->pPage->nFree>=0 );
80430 if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){
80432 ** then balance() will always be a no-op. No need to invoke it. */
80437 if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
80438 releasePageNotNull(pCur->pPage);
80439 pCur->iPage--;
80440 while( pCur->iPage>iCellDepth ){
80441 releasePage(pCur->apPage[pCur->iPage--]);
80443 pCur->pPage = pCur->apPage[pCur->iPage];
80449 assert( (pCur->iPage==iCellDepth || CORRUPT_DB) );
80450 assert( pPage==pCur->pPage || CORRUPT_DB );
80451 assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell );
80452 pCur->eState = CURSOR_SKIPNEXT;
80453 if( iCellIdx>=pPage->nCell ){
80454 pCur->skipNext = -1;
80455 pCur->ix = pPage->nCell-1;
80457 pCur->skipNext = 1;
80463 pCur->eState = CURSOR_REQUIRESEEK;
80483 BtShared *pBt = p->pBt;
80487 int ptfFlags; /* Page-type flags for the root page of new table */
80490 assert( pBt->inTransaction==TRANS_WRITE );
80491 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
80499 if( pBt->autoVacuum ){
80500 Pgno pgnoMove; /* Move a page here to make room for the root-page */
80505 ** out to be an overflow page, delete all overflow page-map caches
80511 ** root page of the new table should go. meta[3] is the largest root-page
80512 ** created so far, so the new root-page is (meta[3]+1).
80520 /* The new root-page may not be allocated on a pointer-map page, or the
80539 /* pgnoRoot is the page that will be used for the root-page of
80583 rc = sqlite3PagerWrite(pRoot->pDbPage);
80592 /* Update the pointer-map and meta-data with the new root-page number. */
80603 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
80615 assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
80622 sqlite3PagerUnref(pRoot->pDbPage);
80623 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
80652 assert( sqlite3_mutex_held(pBt->mutex) );
80658 if( (pBt->openFlags & BTREE_SINGLE)==0
80659 && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
80664 hdr = pPage->hdrOffset;
80665 for(i=0; i<pPage->nCell; i++){
80667 if( !pPage->leaf ){
80674 if( !pPage->leaf ){
80675 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
80677 if( pPage->intKey ) pnChange = 0;
80680 testcase( !pPage->intKey );
80681 *pnChange += pPage->nCell;
80685 }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
80686 zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
80708 BtShared *pBt = p->pBt;
80710 assert( p->inTrans==TRANS_WRITE );
80716 ** is the root of a table b-tree - if it is not, the following call is
80717 ** a no-op). */
80718 if( p->hasIncrblobCur ){
80733 return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0);
80759 BtShared *pBt = p->pBt;
80762 assert( p->inTrans==TRANS_WRITE );
80782 if( pBt->autoVacuum ){
80787 /* If the table being dropped is the table with the largest root-page
80796 /* The table being dropped does not have the largest root-page
80798 ** gap left by the deleted root-page.
80821 /* Set the new 'max-root-page' value in the database header. This
80823 ** be a root-page number, less one again if that is the
80826 maxRootPgno--;
80829 maxRootPgno--;
80851 ** This function may only be called if the b-tree connection already
80854 ** Read the meta-information out of a database file. Meta[0]
80857 ** is read-only, the others are read/write.
80871 BtShared *pBt = p->pBt;
80874 assert( p->inTrans>TRANS_NONE );
80876 assert( pBt->pPage1 );
80880 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion;
80882 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
80885 /* If auto-vacuum is disabled in this build and this is an auto-vacuum
80886 ** database, mark the database as read-only. */
80889 pBt->btsFlags |= BTS_READ_ONLY;
80897 ** Write meta-information back into the database. Meta[0] is
80898 ** read-only and may not be written.
80901 BtShared *pBt = p->pBt;
80906 assert( p->inTrans==TRANS_WRITE );
80907 assert( pBt->pPage1!=0 );
80908 pP1 = pBt->pPage1->aData;
80909 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
80914 assert( pBt->autoVacuum || iMeta==0 );
80916 pBt->incrVacuum = (u8)iMeta;
80925 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
80926 ** number of entries in the b-tree and write the result to *pnEntry.
80943 ** page in the B-Tree structure (not including overflow pages).
80945 while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){
80947 MemPage *pPage; /* Current page of the b-tree */
80949 /* If this is a leaf page or the tree is not an int-key tree, then
80953 pPage = pCur->pPage;
80954 if( pPage->leaf || !pPage->intKey ){
80955 nEntry += pPage->nCell;
80961 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
80963 ** to visit is the right-child of its parent.
80968 if( pPage->leaf ){
80970 if( pCur->iPage==0 ){
80971 /* All pages of the b-tree have been visited. Return successfully. */
80976 }while ( pCur->ix>=pCur->pPage->nCell );
80978 pCur->ix++;
80979 pPage = pCur->pPage;
80983 ** points at. This is the right-child if (iIdx==pPage->nCell).
80985 iIdx = pCur->ix;
80986 if( iIdx==pPage->nCell ){
80987 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
81002 return p->pBt->pPager;
81010 pCheck->rc = SQLITE_NOMEM;
81011 pCheck->mxErr = 0; /* Causes integrity_check processing to stop */
81012 if( pCheck->nErr==0 ) pCheck->nErr++;
81020 sqlite3 *db = pCheck->db;
81021 if( AtomicLoad(&db->u1.isInterrupted) ){
81022 pCheck->rc = SQLITE_INTERRUPT;
81023 pCheck->nErr++;
81024 pCheck->mxErr = 0;
81027 if( db->xProgress ){
81028 assert( db->nProgressOps>0 );
81029 pCheck->nStep++;
81030 if( (pCheck->nStep % db->nProgressOps)==0
81031 && db->xProgress(db->pProgressArg)
81033 pCheck->rc = SQLITE_INTERRUPT;
81034 pCheck->nErr++;
81035 pCheck->mxErr = 0;
81051 if( !pCheck->mxErr ) return;
81052 pCheck->mxErr--;
81053 pCheck->nErr++;
81055 if( pCheck->errMsg.nChar ){
81056 sqlite3_str_append(&pCheck->errMsg, "\n", 1);
81058 if( pCheck->zPfx ){
81059 sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx,
81060 pCheck->v0, pCheck->v1, pCheck->v2);
81062 sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap);
81064 if( pCheck->errMsg.accError==SQLITE_NOMEM ){
81073 ** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that
81077 assert( pCheck->aPgRef!=0 );
81078 assert( iPg<=pCheck->nCkPage && sizeof(pCheck->aPgRef[0])==1 );
81079 return (pCheck->aPgRef[iPg/8] & (1 << (iPg & 0x07)));
81086 assert( pCheck->aPgRef!=0 );
81087 assert( iPg<=pCheck->nCkPage && sizeof(pCheck->aPgRef[0])==1 );
81088 pCheck->aPgRef[iPg/8] |= (1 << (iPg & 0x07));
81094 ** reference to the page, add an error message to pCheck->zErrMsg.
81101 if( iPage>pCheck->nCkPage || iPage==0 ){
81115 ** Check that the entry in the pointer-map for page iChild maps to
81129 rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
81156 int nErrAtStart = pCheck->nErr;
81157 while( iPage!=0 && pCheck->mxErr ){
81161 N--;
81162 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
81170 if( pCheck->pBt->autoVacuum ){
81174 if( n>pCheck->pBt->usableSize/4-2 ){
81177 N--;
81182 if( pCheck->pBt->autoVacuum ){
81188 N -= n;
81193 /* If this database supports auto-vacuum and iPage is not the last
81194 ** page in this overflow list, check that the pointer-map entry for
81197 if( pCheck->pBt->autoVacuum && N>0 ){
81206 if( N && nErrAtStart==pCheck->nErr ){
81210 expected-N, expected);
81216 ** An implementation of a min-heap.
81226 ** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto
81255 aHeap[0]--;
81292 int depth = -1, d2; /* Depth of a subtree */
81308 u32 *heap = 0; /* Min-heap used for checking cell coverage */
81309 u32 x, prev = 0; /* Next and previous entry on the min-heap */
81310 const char *saved_zPfx = pCheck->zPfx;
81311 int saved_v1 = pCheck->v1;
81312 int saved_v2 = pCheck->v2;
81318 if( pCheck->mxErr==0 ) goto end_of_check;
81319 pBt = pCheck->pBt;
81320 usableSize = pBt->usableSize;
81323 pCheck->zPfx = "Tree %u page %u: ";
81324 pCheck->v1 = iPage;
81328 if( rc==SQLITE_IOERR_NOMEM ) pCheck->rc = SQLITE_NOMEM;
81334 savedIsInit = pPage->isInit;
81335 pPage->isInit = 0;
81347 data = pPage->aData;
81348 hdr = pPage->hdrOffset;
81351 pCheck->zPfx = "Tree %u page %u cell %u: ";
81355 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
81358 assert( pPage->nCell==nCell );
81359 if( pPage->leaf || pPage->intKey==0 ){
81360 pCheck->nRow += nCell;
81363 /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page
81364 ** immediately follows the b-tree page header. */
81365 cellStart = hdr + 12 - 4*pPage->leaf;
81366 assert( pPage->aCellIdx==&data[cellStart] );
81367 pCellIdx = &data[cellStart + 2*(nCell-1)];
81369 if( !pPage->leaf ){
81370 /* Analyze the right-child page of internal pages */
81373 if( pBt->autoVacuum ){
81374 pCheck->zPfx = "Tree %u page %u right child: ";
81383 heap = pCheck->heap;
81387 /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte
81389 for(i=nCell-1; i>=0 && pCheck->mxErr; i--){
81393 pCheck->v2 = i;
81396 pCellIdx -= 2;
81397 if( pc<contentOffset || pc>usableSize-4 ){
81399 pc, contentOffset, usableSize-4);
81404 pPage->xParseCell(pPage, pCell, &info);
81412 if( pPage->intKey ){
81424 assert( pc + info.nSize - 4 <= usableSize );
81425 nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4);
81426 pgnoOvfl = get4byte(&pCell[info.nSize - 4]);
81428 if( pBt->autoVacuum ){
81435 if( !pPage->leaf ){
81439 if( pBt->autoVacuum ){
81450 /* Populate the coverage-checking heap for leaf pages */
81451 btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1));
81458 pCheck->zPfx = 0;
81459 if( doCoverageCheck && pCheck->mxErr>0 ){
81460 /* For leaf pages, the min-heap has already been initialized and the
81463 if( !pPage->leaf ){
81464 heap = pCheck->heap;
81466 for(i=nCell-1; i>=0; i--){
81469 size = pPage->xCellSize(pPage, &data[pc]);
81470 btreeHeapInsert(heap, (pc<<16)|(pc+size-1));
81474 /* Add the freeblocks to the min-heap
81476 ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header
81483 assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
81486 btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1));
81487 /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
81488 ** big-endian integer which is the offset in the b-tree page of the next
81492 /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
81495 assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
81498 /* Analyze the min-heap looking for overlap between cells and/or
81501 ** Each min-heap entry is of the form: (start_address<<16)|end_address.
81506 ** The loop below pulls entries from the min-heap in order and compares
81512 prev = contentOffset - 1; /* Implied first min-heap entry */
81519 nFrag += (x>>16) - (prev&0xffff) - 1;
81523 nFrag += usableSize - (prev&0xffff) - 1;
81524 /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
81525 ** is stored in the fifth field of the b-tree page header.
81526 ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the
81537 if( !doCoverageCheck ) pPage->isInit = savedIsInit;
81539 pCheck->zPfx = saved_zPfx;
81540 pCheck->v1 = saved_v1;
81541 pCheck->v2 = saved_v2;
81552 ** A read-only or read-write transaction must be opened before calling
81557 ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
81561 ** root pages is incomplete. This is a "partial integrity-check". This
81581 BtShared *pBt = p->pBt;
81582 u64 savedDbFlags = pBt->db->flags;
81583 char zErr[100];
81599 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
81600 VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
81605 sCheck.pPager = pBt->pPager;
81619 sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
81632 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
81633 get4byte(&pBt->pPage1->aData[36]));
81641 if( pBt->autoVacuum ){
81645 mxInHdr = get4byte(&pBt->pPage1->aData[52]);
81652 }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){
81659 testcase( pBt->db->flags & SQLITE_CellSizeCk );
81660 pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
81666 if( pBt->autoVacuum && aRoot[i]>1 && !bPartial ){
81675 pBt->db->flags = savedDbFlags;
81686 /* If the database supports auto-vacuum, make sure no tables contain
81687 ** references to pointer-map pages.
81690 (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
81694 (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
81714 assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
81722 ** an empty string if the database is in-memory or a TEMP database.
81728 assert( p->pBt->pPager!=0 );
81729 return sqlite3PagerFilename(p->pBt->pPager, 1);
81741 assert( p->pBt->pPager!=0 );
81742 return sqlite3PagerJournalname(p->pBt->pPager);
81750 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
81751 return p ? p->inTrans : 0;
81759 ** transaction on the shared-cache the argument Btree is connected to.
81766 BtShared *pBt = p->pBt;
81768 if( pBt->inTransaction!=TRANS_NONE ){
81771 rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt);
81784 assert( sqlite3_mutex_held(p->db->mutex) );
81785 return p->nBackup!=0;
81790 ** a single shared-btree. The memory is used by client code for its own
81791 ** purposes (for example, to store a high-level schema associated with
81792 ** the shared-btree). The btree layer manages reference counting issues.
81794 ** The first time this is called on a shared-btree, nBytes bytes of memory
81803 ** Just before the shared-btree is closed, the function passed as the
81809 BtShared *pBt = p->pBt;
81811 if( !pBt->pSchema && nBytes ){
81812 pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
81813 pBt->xFreeSchema = xFree;
81816 return pBt->pSchema;
81826 assert( sqlite3_mutex_held(p->db->mutex) );
81843 assert( p->inTrans!=TRANS_NONE );
81844 if( p->sharable ){
81874 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
81875 assert( pCsr->curFlags & BTCF_Incrblob );
81881 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
81882 if( pCsr->eState!=CURSOR_VALID ){
81888 ** version of the b-tree page modified by the accessPayload call below.
81894 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
81900 ** (c) the connection holds a write-lock on the table (if required),
81901 ** (d) there are no conflicting read-locks, and
81904 if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
81907 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
81908 && pCsr->pBt->inTransaction==TRANS_WRITE );
81909 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
81910 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
81911 assert( pCsr->pPage->intKey );
81920 pCur->curFlags |= BTCF_Incrblob;
81921 pCur->pBtree->hasIncrblobCur = 1;
81931 BtShared *pBt = pBtree->pBt;
81939 pBt->btsFlags &= ~BTS_NO_WAL;
81940 if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
81944 u8 *aData = pBt->pPage1->aData;
81948 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
81957 pBt->btsFlags &= ~BTS_NO_WAL;
81966 return (pCsr->hints & mask)!=0;
81970 ** Return true if the given Btree is read-only.
81973 return (p->pBt->btsFlags & BTS_READ_ONLY)!=0;
81982 ** If no transaction is active and the database is not a temp-db, clear
81983 ** the in-memory pager cache.
81986 BtShared *pBt = p->pBt;
81987 if( pBt->inTransaction==TRANS_NONE ){
81988 sqlite3PagerClearCache(pBt->pPager);
81997 return p->sharable;
82006 testcase( p->sharable );
82007 return p->pBt->nRef;
82035 Btree *pDest; /* Destination b-tree file */
82037 int bDestLocked; /* True once a write-transaction is open on pDest */
82041 Btree *pSrc; /* Source b-tree file */
82059 ** structure may be accessed via two groups of thread-safe entry points:
82073 ** backup_pagecount() are not thread-safe functions. If they are called
82081 ** Non-sharable Btrees (in-memory databases for example), do not have
82117 return pDb->aDb[i].pBt;
82126 rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),0,0);
82131 ** Check that there is no open read-transaction on the b-tree passed as the
82133 ** is an open read-transaction, return SQLITE_ERROR and leave an error
82175 sqlite3_mutex_enter(pSrcDb->mutex);
82176 sqlite3_mutex_enter(pDestDb->mutex);
82185 ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
82196 p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
82197 p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
82198 p->pDestDb = pDestDb;
82199 p->pSrcDb = pSrcDb;
82200 p->iNext = 1;
82201 p->isAttached = 0;
82203 if( 0==p->pSrc || 0==p->pDest
82204 || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
82216 p->pSrc->nBackup++;
82219 sqlite3_mutex_leave(pDestDb->mutex);
82220 sqlite3_mutex_leave(pSrcDb->mutex);
82244 Pager * const pDestPager = sqlite3BtreePager(p->pDest);
82245 const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc);
82246 int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest);
82252 assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 );
82253 assert( p->bDestLocked );
82254 assert( !isFatalError(p->rc) );
82255 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
82263 for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
82266 if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
82284 sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc));
82296 ** this function is a no-op.
82316 assert( sqlite3BtreeHoldsMutex(p->pSrc) );
82317 pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
82318 p->pNext = *pp;
82320 p->isAttached = 1;
82324 ** Copy nPage pages from the source b-tree to the destination.
82335 sqlite3_mutex_enter(p->pSrcDb->mutex);
82336 sqlite3BtreeEnter(p->pSrc);
82337 if( p->pDestDb ){
82338 sqlite3_mutex_enter(p->pDestDb->mutex);
82341 rc = p->rc;
82343 Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
82344 Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
82346 int nSrcPage = -1; /* Size of source db in pages */
82349 /* If the source pager is currently in a write-transaction, return
82352 if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
82358 /* If there is no open read-transaction on the source database, open
82362 if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){
82363 rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0);
82373 if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){
82378 if( SQLITE_OK==rc && p->bDestLocked==0
82379 && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
82380 (int*)&p->iDestSchema))
82382 p->bDestLocked = 1;
82387 pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
82388 pgszDest = sqlite3BtreeGetPageSize(p->pDest);
82389 destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
82397 /* Now that there is a read-lock on the source database, query the
82400 nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
82402 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
82403 const Pgno iSrcPg = p->iNext; /* Source page number */
82404 if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
82412 p->iNext++;
82415 p->nPagecount = nSrcPage;
82416 p->nRemaining = nSrcPage+1-p->iNext;
82417 if( p->iNext>(Pgno)nSrcPage ){
82419 }else if( !p->isAttached ){
82425 ** is to make sure that the schema-version really does change in
82431 rc = sqlite3BtreeNewDb(p->pDest);
82435 rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
82438 if( p->pDestDb ){
82439 sqlite3ResetAllSchemasOfConnection(p->pDestDb);
82442 rc = sqlite3BtreeSetVersion(p->pDest, 2);
82459 assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
82460 assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
82463 nDestTruncate = (nSrcPage+ratio-1)/ratio;
82464 if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
82465 nDestTruncate--;
82473 /* If the source page-size is smaller than the destination page-size,
82479 ** pending-byte page in the source database may need to be
82492 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
82504 if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
82548 && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
82558 ** "committing" a read-only transaction cannot fail.
82562 TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
82563 TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
82570 p->rc = rc;
82572 if( p->pDestDb ){
82573 sqlite3_mutex_leave(p->pDestDb->mutex);
82575 sqlite3BtreeLeave(p->pSrc);
82576 sqlite3_mutex_leave(p->pSrcDb->mutex);
82590 pSrcDb = p->pSrcDb;
82591 sqlite3_mutex_enter(pSrcDb->mutex);
82592 sqlite3BtreeEnter(p->pSrc);
82593 if( p->pDestDb ){
82594 sqlite3_mutex_enter(p->pDestDb->mutex);
82598 if( p->pDestDb ){
82599 p->pSrc->nBackup--;
82601 if( p->isAttached ){
82602 pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
82605 pp = &(*pp)->pNext;
82608 *pp = p->pNext;
82612 sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
82615 rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
82616 if( p->pDestDb ){
82617 sqlite3Error(p->pDestDb, rc);
82620 sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
82622 sqlite3BtreeLeave(p->pSrc);
82623 if( p->pDestDb ){
82624 /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
82644 return p->nRemaining;
82658 return p->nPagecount;
82680 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
82681 if( !isFatalError(p->rc) && iPage<p->iNext ){
82687 assert( p->pDestDb );
82688 sqlite3_mutex_enter(p->pDestDb->mutex);
82690 sqlite3_mutex_leave(p->pDestDb->mutex);
82693 p->rc = rc;
82696 }while( (p = p->pNext)!=0 );
82715 for(p=pBackup; p; p=p->pNext){
82716 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
82717 p->iNext = 1;
82739 if( pFd->pMethods ){
82752 b.pSrcDb = pFrom->db;
82761 ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
82768 pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
82806 #define ISPOWEROF2(X) (((X)&((X)-1))==0)
82819 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
82825 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
82828 assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) );
82830 if( p->flags & MEM_Null ){
82832 assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 );
82839 if( (p->flags & (MEM_Term|MEM_Subtype))==(MEM_Term|MEM_Subtype) ){
82842 assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
82843 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
82844 ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 );
82847 assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind
82855 assert( (p->flags & MEM_Cleared)==0 );
82859 assert( p->szMalloc==0
82860 || (p->flags==MEM_Undefined
82861 && p->szMalloc<=sqlite3DbMallocSize(p->db,p->zMalloc))
82862 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc));
82872 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
82874 ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) +
82875 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
82876 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
82877 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
82890 assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
82892 if( p->flags & MEM_Int ){
82894 /* Work-around for GCC bug
82897 assert( (p->flags&MEM_Int)*2==sizeof(x) );
82898 memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2);
82899 p->n = sqlite3Int64ToText(x, zBuf);
82901 p->n = sqlite3Int64ToText(p->u.i, zBuf);
82906 (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r);
82909 p->n = acc.nChar;
82926 ** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for
82938 char zBuf[100];
82941 if( (p->flags & MEM_Str)==0 ) return 1;
82942 if( p->db && p->db->mallocFailed ) return 1;
82943 if( p->flags & MEM_Term ){
82944 /* Insure that the string is properly zero-terminated. Pay particular
82945 ** attention to the case where p->n is odd */
82946 if( p->szMalloc>0 && p->z==p->zMalloc ){
82947 assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 );
82948 assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 );
82950 assert( p->z[p->n]==0 );
82951 assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 );
82952 assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );
82954 if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1;
82957 z = p->z;
82960 if( p->enc!=SQLITE_UTF8 ){
82962 if( p->enc==SQLITE_UTF16BE ) z++;
82979 ** routine is a no-op.
82993 if( !(pMem->flags&MEM_Str) ){
82994 pMem->enc = desiredEnc;
82997 if( pMem->enc==desiredEnc ){
83000 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83010 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
83011 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
83017 ** Make sure pMem->z points to a writable allocation of at least n bytes.
83020 ** pMem->z into the new allocation. pMem must be either a string or
83022 ** in pMem->z is discarded.
83027 testcase( pMem->db==0 );
83031 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
83032 testcase( bPreserve && pMem->z==0 );
83034 assert( pMem->szMalloc==0
83035 || (pMem->flags==MEM_Undefined
83036 && pMem->szMalloc<=sqlite3DbMallocSize(pMem->db,pMem->zMalloc))
83037 || pMem->szMalloc==sqlite3DbMallocSize(pMem->db,pMem->zMalloc));
83038 if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
83039 if( pMem->db ){
83040 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
83042 pMem->zMalloc = sqlite3Realloc(pMem->z, n);
83043 if( pMem->zMalloc==0 ) sqlite3_free(pMem->z);
83044 pMem->z = pMem->zMalloc;
83048 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
83049 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
83051 if( pMem->zMalloc==0 ){
83053 pMem->z = 0;
83054 pMem->szMalloc = 0;
83057 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
83060 if( bPreserve && pMem->z ){
83061 assert( pMem->z!=pMem->zMalloc );
83062 memcpy(pMem->zMalloc, pMem->z, pMem->n);
83064 if( (pMem->flags&MEM_Dyn)!=0 ){
83065 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
83066 pMem->xDel((void *)(pMem->z));
83069 pMem->z = pMem->zMalloc;
83070 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
83075 ** Change the pMem->zMalloc allocation to be at least szNew bytes.
83076 ** If pMem->zMalloc already meets or exceeds the requested size, this
83077 ** routine is a no-op.
83080 ** The pMem->xDel destructor is called, if it exists. Though MEM_Str
83089 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
83090 if( pMem->szMalloc<szNew ){
83093 assert( (pMem->flags & MEM_Dyn)==0 );
83094 pMem->z = pMem->zMalloc;
83095 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
83100 ** If pMem is already a string, detect if it is a zero-terminated
83104 ** this routine is a no-op.
83107 if( (pMem->flags & (MEM_Str|MEM_Term|MEM_Ephem|MEM_Static))!=MEM_Str ){
83111 if( pMem->enc!=SQLITE_UTF8 ) return;
83112 if( NEVER(pMem->z==0) ) return;
83113 if( pMem->flags & MEM_Dyn ){
83114 if( pMem->xDel==sqlite3_free
83115 && sqlite3_msize(pMem->z) >= (u64)(pMem->n+1)
83117 pMem->z[pMem->n] = 0;
83118 pMem->flags |= MEM_Term;
83121 if( pMem->xDel==sqlite3RCStrUnref ){
83122 /* Blindly assume that all RCStr objects are zero-terminated */
83123 pMem->flags |= MEM_Term;
83126 }else if( pMem->szMalloc >= pMem->n+1 ){
83127 pMem->z[pMem->n] = 0;
83128 pMem->flags |= MEM_Term;
83138 ** to be a double-zero byte at an even byte boundary in order to
83143 if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
83146 pMem->z[pMem->n] = 0;
83147 pMem->z[pMem->n+1] = 0;
83148 pMem->z[pMem->n+2] = 0;
83149 pMem->flags |= MEM_Term;
83161 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83163 if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
83165 if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
83170 pMem->flags &= ~MEM_Ephem;
83172 pMem->pScopyFrom = 0;
83179 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
83186 assert( pMem->flags & MEM_Zero );
83187 assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
83190 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83193 nByte = pMem->n + pMem->u.nZero;
83195 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
83201 assert( pMem->z!=0 );
83202 assert( sqlite3DbMallocSize(pMem->db,pMem->z) >= nByte );
83204 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
83205 pMem->n += pMem->u.nZero;
83206 pMem->flags &= ~(MEM_Zero|MEM_Term);
83216 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83217 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
83218 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
83219 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
83244 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83245 assert( !(pMem->flags&MEM_Zero) );
83246 assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
83247 assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
83253 pMem->enc = 0;
83257 vdbeMemRenderNum(nByte, pMem->z, pMem);
83258 assert( pMem->z!=0 );
83259 assert( pMem->n==(int)sqlite3Strlen30NN(pMem->z) );
83260 pMem->enc = SQLITE_UTF8;
83261 pMem->flags |= MEM_Str|MEM_Term;
83262 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
83280 assert( pMem->db!=0 );
83281 assert( pFunc->xFinalize!=0 );
83282 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
83283 assert( sqlite3_mutex_held(pMem->db->mutex) );
83287 t.db = pMem->db;
83292 pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
83293 assert( (pMem->flags & MEM_Dyn)==0 );
83294 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
83311 assert( pFunc->xValue!=0 );
83312 assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
83313 assert( pAccum->db!=0 );
83314 assert( sqlite3_mutex_held(pAccum->db->mutex) );
83320 ctx.enc = ENC(pAccum->db);
83321 pFunc->xValue(&ctx);
83336 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
83338 if( p->flags&MEM_Agg ){
83339 sqlite3VdbeMemFinalize(p, p->u.pDef);
83340 assert( (p->flags & MEM_Agg)==0 );
83341 testcase( p->flags & MEM_Dyn );
83343 if( p->flags&MEM_Dyn ){
83344 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
83345 p->xDel((void *)p->z);
83347 p->flags = MEM_Null;
83352 ** by p->xDel and memory in p->zMalloc.
83362 if( p->szMalloc ){
83363 sqlite3DbFreeNN(p->db, p->zMalloc);
83364 p->szMalloc = 0;
83366 p->z = 0;
83381 if( VdbeMemDynamic(p) || p->szMalloc ){
83391 if( p->szMalloc ) vdbeMemClear(p);
83398 ** a floating-point then the value returned is the integer part.
83401 ** an SQL-NULL value, return 0.
83407 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
83413 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83415 flags = pMem->flags;
83418 return pMem->u.i;
83420 return sqlite3RealToI64(pMem->u.r);
83421 }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
83437 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
83442 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83444 if( pMem->flags & MEM_Real ){
83445 return pMem->u.r;
83446 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
83447 testcase( pMem->flags & MEM_IntReal );
83448 return (double)pMem->u.i;
83449 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
83462 testcase( pMem->flags & MEM_IntReal );
83463 if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0;
83464 if( pMem->flags & MEM_Null ) return ifNull;
83474 assert( pMem->flags & (MEM_Real|MEM_IntReal) );
83476 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83479 if( pMem->flags & MEM_IntReal ){
83482 i64 ix = sqlite3RealToI64(pMem->u.r);
83486 ** (1) the round-trip conversion real->int->real is a no-op, and
83494 if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
83495 pMem->u.i = ix;
83506 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83510 pMem->u.i = sqlite3VdbeIntValue(pMem);
83521 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83524 pMem->u.r = sqlite3VdbeRealValue(pMem);
83534 ** For some versions of GCC on 32-bit machines, if you do the more obvious
83536 ** though the r1 and (double)i values are bit-for-bit the same.
83542 && i >= -2251799813685248LL && i < 2251799813685248LL);
83550 if( r<-9223372036854774784.0 ) return SMALLEST_INT64;
83565 testcase( pMem->flags & MEM_Int );
83566 testcase( pMem->flags & MEM_Real );
83567 testcase( pMem->flags & MEM_IntReal );
83568 testcase( pMem->flags & MEM_Null );
83569 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
83572 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
83573 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83574 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
83575 if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
83576 || sqlite3RealSameAsInt(pMem->u.r, (ix = sqlite3RealToI64(pMem->u.r)))
83578 pMem->u.i = ix;
83584 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
83585 pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
83597 if( pMem->flags & MEM_Null ) return SQLITE_OK;
83600 if( (pMem->flags & MEM_Blob)==0 ){
83602 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
83603 if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
83605 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
83625 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
83627 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
83628 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero);
83629 if( encoding!=SQLITE_UTF8 ) pMem->n &= ~1;
83645 pMem->flags = flags;
83646 pMem->db = db;
83647 pMem->szMalloc = 0;
83667 pMem->flags = MEM_Null;
83681 pMem->flags = MEM_Blob|MEM_Zero;
83682 pMem->n = 0;
83684 pMem->u.nZero = n;
83685 pMem->enc = SQLITE_UTF8;
83686 pMem->z = 0;
83694 assert( pMem->z!=0 );
83695 assert( sqlite3DbMallocSize(pMem->db, pMem->z)>=nByte );
83696 memset(pMem->z, 0, nByte);
83697 pMem->n = n>0?n:0;
83698 pMem->flags = MEM_Blob;
83699 pMem->enc = SQLITE_UTF8;
83707 ** a 64-bit integer.
83711 pMem->u.i = val;
83712 pMem->flags = MEM_Int;
83723 pMem->u.i = val;
83724 pMem->flags = MEM_Int;
83735 /* A no-op destructor */
83748 assert( pMem->flags==MEM_Null );
83750 pMem->u.zPType = zPType ? zPType : "";
83751 pMem->z = pPtr;
83752 pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term;
83753 pMem->eSubtype = 'p';
83754 pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor;
83765 pMem->u.r = val;
83766 pMem->flags = MEM_Real;
83777 return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn)
83778 && pMem->xDel==sqlite3RowSetDelete;
83790 sqlite3 *db = pMem->db;
83797 pMem->z = (char*)p;
83798 pMem->flags = MEM_Blob|MEM_Dyn;
83799 pMem->xDel = sqlite3RowSetDelete;
83805 ** too large - whose size exceeds SQLITE_MAX_LENGTH.
83808 assert( p->db!=0 );
83809 if( p->flags & (MEM_Str|MEM_Blob) ){
83810 int n = p->n;
83811 if( p->flags & MEM_Zero ){
83812 n += p->u.nZero;
83814 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
83825 ** This is used for testing and debugging only - to help ensure that shallow
83831 for(i=1, pX=pVdbe->aMem+1; i<pVdbe->nMem; i++, pX++){
83832 if( pX->pScopyFrom==pMem ){
83834 if( pVdbe->db->flags & SQLITE_VdbeTrace ){
83836 (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem));
83844 mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
83845 assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i );
83848 ** undefined so that we can quickly detect the shallow-copy error */
83849 pX->flags = MEM_Undefined;
83850 pX->pScopyFrom = 0;
83853 pMem->pScopyFrom = 0;
83859 ** pTo are freed. The pFrom->z field is not duplicated. If
83860 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
83870 assert( pTo->db==pFrom->db );
83873 if( (pFrom->flags&MEM_Static)==0 ){
83874 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
83876 pTo->flags |= srcType;
83890 pTo->flags &= ~MEM_Dyn;
83891 if( pTo->flags&(MEM_Str|MEM_Blob) ){
83892 if( 0==(pFrom->flags&MEM_Static) ){
83893 pTo->flags |= MEM_Ephem;
83908 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
83909 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
83910 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
83914 pFrom->flags = MEM_Null;
83915 pFrom->szMalloc = 0;
83938 ** non-negative for blobs.
83947 i64 nByte = n; /* New value for pMem->n */
83949 u16 flags; /* New value for pMem->flags */
83952 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83962 if( pMem->db ){
83963 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
83984 sqlite3DbFree(pMem->db, (void*)z);
83990 return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
84008 memcpy(pMem->z, z, nAlloc);
84011 pMem->z = (char *)z;
84013 pMem->zMalloc = pMem->z;
84014 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
84016 pMem->xDel = xDel;
84021 pMem->n = (int)(nByte & 0x7fffffff);
84022 pMem->flags = flags;
84023 pMem->enc = enc;
84042 ** pMem->zMalloc to hold the content from the btree, if possible. New
84043 ** pMem->zMalloc space will be allocated if necessary. The calling routine
84057 pMem->flags = MEM_Null;
84062 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
84064 pMem->z[amt] = 0; /* Overrun area used when reading malformed records */
84065 pMem->flags = MEM_Blob;
84066 pMem->n = (int)amt;
84087 pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
84088 assert( pMem->z!=0 );
84091 pMem->flags = MEM_Blob|MEM_Ephem;
84092 pMem->n = (int)amt;
84103 ** to a zero-terminated version of that string.
84107 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
84110 assert( (pVal->flags & (MEM_Null))==0 );
84111 if( pVal->flags & (MEM_Blob|MEM_Str) ){
84113 pVal->flags |= MEM_Str;
84114 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
84117 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
84118 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
84123 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
84126 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
84128 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
84129 || pVal->db->mallocFailed );
84130 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
84132 return pVal->z;
84144 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
84150 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
84153 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
84155 return pVal->z;
84157 if( pVal->flags&MEM_Null ){
84167 ** that third-party extensions can get access to it?
84171 && ALWAYS((pVal->flags & (MEM_Str|MEM_Blob))!=0)
84172 && (pVal->flags & MEM_Dyn)!=0
84173 && pVal->xDel==xFree
84187 p->flags = MEM_Null;
84188 p->db = db;
84209 ** Otherwise, if the second argument is non-zero, then this function is
84218 UnpackedRecord *pRec = p->ppRec[0];
84221 Index *pIdx = p->pIdx; /* Index being probed */
84224 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
84229 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
84230 if( pRec->pKeyInfo ){
84231 assert( pRec->pKeyInfo->nAllField==nCol );
84232 assert( pRec->pKeyInfo->enc==ENC(db) );
84233 pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
84235 pRec->aMem[i].flags = MEM_Null;
84236 pRec->aMem[i].db = db;
84244 p->ppRec[0] = pRec;
84247 pRec->nField = p->iVal+1;
84248 sqlite3VdbeMemSetNull(&pRec->aMem[p->iVal]);
84249 return &pRec->aMem[p->iVal];
84296 assert( (p->flags & EP_TokenOnly)==0 );
84298 pList = p->x.pList;
84299 if( pList ) nVal = pList->nExpr;
84301 pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
84306 if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
84307 || (pFunc->funcFlags & (SQLITE_FUNC_NEEDCOLL|SQLITE_FUNC_RUNONLY))!=0
84319 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
84334 pFunc->xSFunc(&ctx, nVal, apVal);
84337 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
84344 pCtx->pParse->nErr++;
84351 pCtx->pParse->rc = rc;
84393 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
84394 if( op==TK_REGISTER ) op = pExpr->op2;
84400 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
84405 aff = sqlite3AffinityType(pExpr->u.zToken,0);
84406 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
84412 /* zero-blobs only come from functions, not literal values. And
84423 ** case when the value is -9223372036854775808. Except - do not do this
84426 Expr *pLeft = pExpr->pLeft;
84427 if( (pLeft->op==TK_INTEGER || pLeft->op==TK_FLOAT) ){
84429 || pLeft->u.zToken[0]!='0' || (pLeft->u.zToken[1] & ~0x20)!='X'
84432 op = pExpr->op;
84433 negInt = -1;
84434 zNeg = "-";
84443 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
84446 if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
84449 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
84451 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
84456 assert( pVal && pVal->z && pVal->flags==(MEM_Str|MEM_Term) );
84457 sqlite3AtoF(pVal->z, &pVal->u.r, pVal->n, SQLITE_UTF8);
84458 pVal->flags = MEM_Real;
84460 /* This case is required by -9223372036854775808 and other strings
84468 assert( (pVal->flags & MEM_IntReal)==0 );
84469 if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
84470 testcase( pVal->flags & MEM_Int );
84471 testcase( pVal->flags & MEM_Real );
84472 pVal->flags &= ~MEM_Str;
84478 /* This branch happens for multiple negative signs. Ex: -(-5) */
84479 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
84483 if( pVal->flags & MEM_Real ){
84484 pVal->u.r = -pVal->u.r;
84485 }else if( pVal->u.i==SMALLEST_INT64 ){
84487 pVal->u.r = -(double)SMALLEST_INT64;
84489 pVal->u.r = LARGEST_INT64;
84493 pVal->u.i = -pVal->u.i;
84506 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
84507 assert( pExpr->u.zToken[1]=='\'' );
84510 zVal = &pExpr->u.zToken[2];
84511 nVal = sqlite3Strlen30(zVal)-1;
84526 pVal->flags = MEM_Int;
84527 pVal->u.i = pExpr->u.zToken[4]==0;
84537 if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) )
84598 sqlite3 *db = pParse->db;
84603 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
84609 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
84611 int iBindVar = pExpr->iColumn;
84612 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
84613 if( (v = pParse->pReprepare)!=0 ){
84616 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
84618 pVal->db = pParse->db;
84625 assert( pVal==0 || pVal->db==db );
84676 if( pExpr==0 || pExpr->op!=TK_SELECT ){
84687 u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
84719 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
84761 sqlite3VdbeSerialGet(&a[iField-szField], t, pMem);
84762 pMem->enc = ENC(db);
84774 int nCol = pRec->pKeyInfo->nAllField;
84775 Mem *aMem = pRec->aMem;
84780 sqlite3KeyInfoUnref(pRec->pKeyInfo);
84805 sqlite3DbFreeNN(((Mem*)v)->db, v);
84814 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
84818 assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
84819 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
84820 return p->n;
84822 if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){
84823 return p->n;
84825 if( (p->flags & MEM_Blob)!=0 ){
84826 if( p->flags & MEM_Zero ){
84827 return p->n + p->u.nZero;
84829 return p->n;
84832 if( p->flags & MEM_Null ) return 0;
84863 sqlite3 *db = pParse->db;
84867 memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp));
84868 p->db = db;
84869 if( db->pVdbe ){
84870 db->pVdbe->ppVPrev = &p->pVNext;
84872 p->pVNext = db->pVdbe;
84873 p->ppVPrev = &db->pVdbe;
84874 db->pVdbe = p;
84875 assert( p->eVdbeState==VDBE_INIT_STATE );
84876 p->pParse = pParse;
84877 pParse->pVdbe = p;
84878 assert( pParse->aLabel==0 );
84879 assert( pParse->nLabel==0 );
84880 assert( p->nOpAlloc==0 );
84881 assert( pParse->szOpAlloc==0 );
84890 return p->pParse;
84898 sqlite3DbFree(p->db, p->zErrMsg);
84900 p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
84909 p->prepFlags = prepFlags;
84911 p->expmask = 0;
84913 assert( p->zSql==0 );
84914 p->zSql = sqlite3DbStrNDup(p->db, z, n);
84919 ** Add a new element to the Vdbe->pDblStr list.
84925 sizeof(*pStr)+n+1-sizeof(pStr->z));
84927 pStr->pNextStr = p->pDblStr;
84928 p->pDblStr = pStr;
84929 memcpy(pStr->z, z, n+1);
84937 ** zId of length nId is a double-quoted identifier. Check to see if
84942 const char *zId /* The double-quoted identifier, already dequoted */
84946 if( pVdbe->pDblStr==0 ) return 0;
84947 for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){
84948 if( strcmp(zId, pStr->z)==0 ) return 1;
84955 ** Swap byte-code between two VDBE structures.
84967 assert( pA->db==pB->db );
84971 pTmp = pA->pVNext;
84972 pA->pVNext = pB->pVNext;
84973 pB->pVNext = pTmp;
84974 ppTmp = pA->ppVPrev;
84975 pA->ppVPrev = pB->ppVPrev;
84976 pB->ppVPrev = ppTmp;
84977 zTmp = pA->zSql;
84978 pA->zSql = pB->zSql;
84979 pB->zSql = zTmp;
84981 zTmp = pA->zNormSql;
84982 pA->zNormSql = pB->zNormSql;
84983 pB->zNormSql = zTmp;
84985 pB->expmask = pA->expmask;
84986 pB->prepFlags = pA->prepFlags;
84987 memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter));
84988 pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++;
84996 ** If an out-of-memory error occurs while resizing the array, return
85003 Parse *p = v->pParse;
85005 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
85013 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
85014 : (sqlite3_int64)v->nOpAlloc+nOp);
85016 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
85022 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
85023 sqlite3OomFault(p->db);
85028 assert( nNew>=(v->nOpAlloc+nOp) );
85029 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
85031 p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
85032 v->nOpAlloc = p->szOpAlloc/sizeof(Op);
85033 v->aOp = pNew;
85065 assert( p->nOpAlloc<=p->nOp );
85067 assert( p->nOpAlloc>p->nOp );
85079 if( p->db->mallocFailed==0 ){
85080 VdbeOp *pOp = &p->aOp[addr];
85081 pOp->p4type = P4_INT32;
85082 pOp->p4.i = p4;
85113 i = p->nOp;
85114 assert( p->eVdbeState==VDBE_INIT_STATE );
85116 if( p->nOpAlloc<=i ){
85119 assert( p->aOp!=0 );
85120 p->nOp++;
85121 pOp = &p->aOp[i];
85123 pOp->opcode = (u8)op;
85124 pOp->p5 = 0;
85125 pOp->p1 = p1;
85126 pOp->p2 = p2;
85127 pOp->p3 = p3;
85128 pOp->p4.p = 0;
85129 pOp->p4type = P4_NOTUSED;
85134 pOp->zComment = 0;
85137 pOp->nExec = 0;
85138 pOp->nCycle = 0;
85141 if( p->db->flags & SQLITE_VdbeAddopTrace ){
85142 sqlite3VdbePrintOp(0, i, &p->aOp[i]);
85143 test_addop_breakpoint(i, &p->aOp[i]);
85147 pOp->iSrcLine = 0;
85165 i = p->nOp;
85166 if( p->nOpAlloc<=i ){
85169 p->nOp++;
85170 pOp = &p->aOp[i];
85172 pOp->opcode = (u8)op;
85173 pOp->p5 = 0;
85174 pOp->p1 = p1;
85175 pOp->p2 = p2;
85176 pOp->p3 = p3;
85177 pOp->p4.i = p4;
85178 pOp->p4type = P4_INT32;
85183 pOp->zComment = 0;
85186 pOp->nExec = 0;
85187 pOp->nCycle = 0;
85190 if( p->db->flags & SQLITE_VdbeAddopTrace ){
85191 sqlite3VdbePrintOp(0, i, &p->aOp[i]);
85192 test_addop_breakpoint(i, &p->aOp[i]);
85196 pOp->iSrcLine = 0;
85284 Vdbe *v = pParse->pVdbe;
85289 nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
85290 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
85292 assert( pParse->db->mallocFailed );
85293 freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
85296 pCtx->pOut = 0;
85297 pCtx->pFunc = (FuncDef*)pFunc;
85298 pCtx->pVdbe = 0;
85299 pCtx->isError = 0;
85300 pCtx->argc = nArg;
85301 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
85334 if( pParse->addrExplain==0 ) return 0;
85335 pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
85336 return pOp->p2;
85361 if( pParse->explain==2 || IS_STMT_SCANSTATUS(pParse->db) )
85369 zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
85371 v = pParse->pVdbe;
85372 iThis = v->nOp;
85373 addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
85375 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z);
85377 pParse->addrExplain = iThis;
85379 sqlite3VdbeScanStatus(v, iThis, -1, -1, 0, 0);
85389 pParse->addrExplain = sqlite3VdbeExplainParent(pParse);
85405 for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
85406 sqlite3MayAbort(p->pParse);
85409 /* Insert the end of a co-routine
85415 ** co-routine has its own independent set of registers, because co-routines
85417 ** that could cause problems if two or more co-routines are using the same
85420 v->pParse->nTempReg = 0;
85421 v->pParse->nRangeReg = 0;
85433 ** always negative and P2 values are suppose to be non-negative.
85440 ** Parse.aLabel[x] Stores the address that the x-th label resolves
85442 ** labels stores -1, but that is not required.
85450 return --pParse->nLabel;
85459 int nNewSize = 10 - p->nLabel;
85460 p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
85461 nNewSize*sizeof(p->aLabel[0]));
85462 if( p->aLabel==0 ){
85463 p->nLabelAlloc = 0;
85467 for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;
85469 if( nNewSize>=100 && (nNewSize/100)>(p->nLabelAlloc/100) ){
85472 p->nLabelAlloc = nNewSize;
85473 p->aLabel[j] = v->nOp;
85477 Parse *p = v->pParse;
85479 assert( v->eVdbeState==VDBE_INIT_STATE );
85480 assert( j<-p->nLabel );
85483 if( p->db->flags & SQLITE_VdbeAddopTrace ){
85484 printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
85487 if( p->nLabelAlloc + p->nLabel < 0 ){
85490 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
85491 p->aLabel[j] = v->nOp;
85507 for(i=1; ALWAYS(i<p->nOp); i++){
85508 if( ALWAYS(p->aOp[i].opcode==OP_Expire) ){
85509 p->aOp[1].opcode = OP_Noop;
85519 ** in a Vdbe main program and each of the sub-programs (triggers) it may
85530 ** sqlite3DbFree(v->db, sIter.apSub);
85539 int iSub; /* 0 = main program, 1 = first sub-program etc. */
85542 Vdbe *v = p->v;
85547 if( p->iSub<=p->nSub ){
85549 if( p->iSub==0 ){
85550 aOp = v->aOp;
85551 nOp = v->nOp;
85553 aOp = p->apSub[p->iSub-1]->aOp;
85554 nOp = p->apSub[p->iSub-1]->nOp;
85556 assert( p->iAddr<nOp );
85558 pRet = &aOp[p->iAddr];
85559 p->iAddr++;
85560 if( p->iAddr==nOp ){
85561 p->iSub++;
85562 p->iAddr = 0;
85565 if( pRet->p4type==P4_SUBPROGRAM ){
85566 int nByte = (p->nSub+1)*sizeof(SubProgram*);
85568 for(j=0; j<p->nSub; j++){
85569 if( p->apSub[j]==pRet->p4.pProgram ) break;
85571 if( j==p->nSub ){
85572 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
85573 if( !p->apSub ){
85576 p->apSub[p->nSub++] = pRet->p4.pProgram;
85589 ** sub-programs contains any of the following:
85606 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
85622 int opcode = pOp->opcode;
85629 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
85634 if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1;
85638 ** where a "DELETE FROM tbl" has a statement-journal but does not
85639 ** require one. This is not so bad - it is an inefficiency, not a bug. */
85640 if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1;
85645 if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
85650 sqlite3DbFree(v->db, sIter.apSub);
85657 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
85661 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
85670 || (pC->eCurType!=CURTYPE_SORTER
85671 && pC->eCurType!=CURTYPE_PSEUDO
85672 && !pC->isEphemeral)
85674 p->nWrite++;
85685 assert( p->nWrite==0 || p->usesStmtJournal );
85713 Parse *pParse = p->pParse;
85714 int *aLabel = pParse->aLabel;
85716 assert( pParse->db->mallocFailed==0 ); /* tag-20230419-1 */
85717 p->readOnly = 1;
85718 p->bIsReader = 0;
85719 pOp = &p->aOp[p->nOp-1];
85720 assert( p->aOp[0].opcode==OP_Init );
85728 if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){
85731 switch( pOp->opcode ){
85733 if( pOp->p2!=0 ) p->readOnly = 0;
85738 p->bIsReader = 1;
85746 p->readOnly = 0;
85747 p->bIsReader = 1;
85751 assert( pOp->p2>=0 );
85756 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
85761 assert( (pOp - p->aOp) >= 3 );
85762 assert( pOp[-1].opcode==OP_Integer );
85763 n = pOp[-1].p1;
85770 if( pOp->p2<0 ){
85772 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
85773 ** have non-negative values for P2. */
85774 assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
85775 assert( ADDR(pOp->p2)<-pParse->nLabel );
85776 assert( aLabel!=0 ); /* True because of tag-20230419-1 */
85777 pOp->p2 = aLabel[ADDR(pOp->p2)];
85782 assert( pOp->p2>0
85783 || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP0)!=0 );
85786 assert( pOp->p2<p->nOp
85787 || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)==0 );
85792 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
85793 ** have non-negative values for P2. */
85794 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
85796 assert( pOp>p->aOp );
85797 pOp--;
85801 sqlite3DbNNFreeNN(p->db, pParse->aLabel);
85802 pParse->aLabel = 0;
85804 pParse->nLabel = 0;
85806 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
85831 Vdbe *v, /* The byte-code program under construction */
85841 pParse = v->pParse;
85843 if( pParse->nErr ) return;
85845 assert( iLast<v->nOp );
85846 pOp = &v->aOp[iFirst];
85848 if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ){
85849 int iDest = pOp->p2; /* Jump destination */
85851 if( pOp->opcode==OP_Gosub ) continue;
85852 if( pOp->p3==20230325 && pOp->opcode==OP_NotNull ){
85853 /* This is a deliberately taken illegal branch. tag-20230325-2 */
85859 if( j>=-pParse->nLabel || pParse->aLabel[j]<0 ){
85862 iDest = pParse->aLabel[j];
85866 for(; j<v->nOp; j++){
85867 VdbeOp *pX = &v->aOp[j];
85868 if( pX->opcode==OP_Return ){
85869 if( pX->p1==iRetReg ) break;
85872 if( pX->opcode==OP_Noop ) continue;
85873 if( pX->opcode==OP_Explain ) continue;
85901 assert( p->eVdbeState==VDBE_INIT_STATE );
85902 return p->nOp;
85911 ** sqlite3VdbeAddOpList() will always be non-NULL.
85915 assert( p->nOp + N <= p->nOpAlloc );
85929 for(i=0; i<p->nOp; i++){
85930 assert( p->aOp[i].opcode!=OP_ResultRow );
85958 VdbeOp *aOp = p->aOp;
85959 assert( aOp && !p->db->mallocFailed );
85962 assert( DbMaskAllZero(p->btreeMask) );
85965 *pnOp = p->nOp;
85966 p->aOp = 0;
85974 ** Non-zero P2 arguments to jump instructions are automatically adjusted
85981 int iLineno /* Source-file line number of first opcode */
85986 assert( p->eVdbeState==VDBE_INIT_STATE );
85987 if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
85990 pFirst = pOut = &p->aOp[p->nOp];
85992 pOut->opcode = aOp->opcode;
85993 pOut->p1 = aOp->p1;
85994 pOut->p2 = aOp->p2;
85995 assert( aOp->p2>=0 );
85996 if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
85997 pOut->p2 += p->nOp;
85999 pOut->p3 = aOp->p3;
86000 pOut->p4type = P4_NOTUSED;
86001 pOut->p4.p = 0;
86002 pOut->p5 = 0;
86004 pOut->zComment = 0;
86007 pOut->iSrcLine = iLineno+i;
86012 if( p->db->flags & SQLITE_VdbeAddopTrace ){
86013 sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);
86017 p->nOp += nOp;
86033 if( IS_STMT_SCANSTATUS(p->db) ){
86034 sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus);
86036 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
86038 ScanStatus *pNew = &aNew[p->nScan++];
86040 pNew->addrExplain = addrExplain;
86041 pNew->addrLoop = addrLoop;
86042 pNew->addrVisit = addrVisit;
86043 pNew->nEst = nEst;
86044 pNew->zName = sqlite3DbStrDup(p->db, zName);
86045 p->aScan = aNew;
86063 if( IS_STMT_SCANSTATUS(p->db) ){
86066 for(ii=p->nScan-1; ii>=0; ii--){
86067 pScan = &p->aScan[ii];
86068 if( pScan->addrExplain==addrExplain ) break;
86072 if( addrEnd<0 ) addrEnd = sqlite3VdbeCurrentAddr(p)-1;
86073 for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){
86074 if( pScan->aAddrRange[ii]==0 ){
86075 pScan->aAddrRange[ii] = addrStart;
86076 pScan->aAddrRange[ii+1] = addrEnd;
86095 if( IS_STMT_SCANSTATUS(p->db) ){
86098 for(ii=p->nScan-1; ii>=0; ii--){
86099 pScan = &p->aScan[ii];
86100 if( pScan->addrExplain==addrExplain ) break;
86104 if( addrLoop>0 ) pScan->addrLoop = addrLoop;
86105 if( addrVisit>0 ) pScan->addrVisit = addrVisit;
86118 sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode;
86122 sqlite3VdbeGetOp(p,addr)->p1 = val;
86125 assert( addr>=0 || p->db->mallocFailed );
86126 sqlite3VdbeGetOp(p,addr)->p2 = val;
86130 sqlite3VdbeGetOp(p,addr)->p3 = val;
86133 assert( p->nOp>0 || p->db->mallocFailed );
86134 if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5;
86144 if( pOp->p3==iDest && pOp->opcode==OP_Column ){
86145 pOp->p5 |= OPFLAG_TYPEOFARG;
86154 sqlite3VdbeChangeP2(p, addr, p->nOp);
86160 ** the previous opcode (and is thus a no-op) then simply back up
86165 ** strives to omit useless byte-code like this:
86171 if( addr==p->nOp-1 ){
86172 assert( p->aOp[addr].opcode==OP_Once
86173 || p->aOp[addr].opcode==OP_If
86174 || p->aOp[addr].opcode==OP_FkIfZero );
86175 assert( p->aOp[addr].p4type==0 );
86177 sqlite3VdbeGetLastOp(p)->iSrcLine = 0; /* Erase VdbeCoverage() macros */
86179 p->nOp--;
86181 sqlite3VdbeChangeP2(p, addr, p->nOp);
86192 if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){
86201 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
86206 freeEphemeralFunction(db, p->pFunc);
86224 if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
86238 if( db->pnBytesFreed==0 ){
86246 if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
86250 if( db->pnBytesFreed==0 ) sqlite3DeleteTable(db, (Table*)p4);
86265 Op *pOp = &aOp[nOp-1];
86267 if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
86269 sqlite3DbFree(db, pOp->zComment);
86272 pOp--;
86280 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
86284 p->pNext = pVdbe->pProgram;
86285 pVdbe->pProgram = p;
86292 return pVdbe->pProgram!=0;
86300 if( p->db->mallocFailed ) return 0;
86301 assert( addr>=0 && addr<p->nOp );
86302 pOp = &p->aOp[addr];
86303 freeP4(p->db, pOp->p4type, pOp->p4.p);
86304 pOp->p4type = P4_NOTUSED;
86305 pOp->p4.z = 0;
86306 pOp->opcode = OP_Noop;
86315 if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){
86316 return sqlite3VdbeChangeToNoop(p, p->nOp-1);
86334 if( N==0 || OptimizationDisabled(pParse->db, SQLITE_ReleaseReg) ) return;
86335 assert( pParse->pVdbe );
86337 assert( iFirst+N-1<=pParse->nMem );
86342 N--;
86344 while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){
86345 mask &= ~MASKBIT32(N-1);
86346 N--;
86350 sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask);
86351 if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1);
86379 if( pOp->p4type ){
86380 assert( pOp->p4type > P4_FREE_IF_LE );
86381 pOp->p4type = 0;
86382 pOp->p4.p = 0;
86385 sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
86388 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
86389 pOp->p4type = P4_DYNAMIC;
86396 db = p->db;
86397 assert( p->eVdbeState==VDBE_INIT_STATE );
86398 assert( p->aOp!=0 || db->mallocFailed );
86399 if( db->mallocFailed ){
86403 assert( p->nOp>0 );
86404 assert( addr<p->nOp );
86406 addr = p->nOp - 1;
86408 pOp = &p->aOp[addr];
86409 if( n>=0 || pOp->p4type ){
86416 pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
86417 pOp->p4type = P4_INT32;
86420 pOp->p4.p = (void*)zP4;
86421 pOp->p4type = (signed char)n;
86428 ** to the value defined by the arguments. This is a high-speed
86439 if( p->db->mallocFailed ){
86440 freeP4(p->db, n, pP4);
86443 assert( p->nOp>0 );
86444 pOp = &p->aOp[p->nOp-1];
86445 assert( pOp->p4type==P4_NOTUSED );
86446 pOp->p4type = n;
86447 pOp->p4.p = pP4;
86456 Vdbe *v = pParse->pVdbe;
86467 ** insert a No-op and add the comment to that new instruction. This
86472 assert( p->nOp>0 || p->aOp==0 );
86473 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->pParse->nErr>0 );
86474 if( p->nOp ){
86475 assert( p->aOp );
86476 sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
86477 p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
86504 sqlite3VdbeGetLastOp(v)->iSrcLine = iLine;
86509 ** Return the opcode for a given address. The address must be non-negative.
86525 assert( p->eVdbeState==VDBE_INIT_STATE );
86526 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
86527 if( p->db->mallocFailed ){
86530 return &p->aOp[addr];
86537 return sqlite3VdbeGetOp(p, p->nOp - 1);
86546 if( c=='1' ) return pOp->p1;
86547 if( c=='2' ) return pOp->p2;
86548 if( c=='3' ) return pOp->p3;
86549 if( c=='4' ) return pOp->p4.i;
86550 return pOp->p5;
86561 ** "PX" -> "r[X]"
86562 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
86563 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
86564 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
86567 sqlite3 *db, /* Optional - Oom error reporting only */
86579 zOpName = sqlite3OpcodeName(pOp->opcode);
86595 if( pOp->zComment && pOp->zComment[0] ){
86596 sqlite3_str_appendall(&x, pOp->zComment);
86613 sqlite3_str_appendf(&x, "%d..%d", v1, v1+v2-1);
86616 sqlite3_context *pCtx = pOp->p4.pCtx;
86617 if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){
86619 }else if( pCtx->argc>1 ){
86620 sqlite3_str_appendf(&x, "%d..%d", v1, v1+pCtx->argc-1);
86623 x.nChar -= 2;
86629 if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
86638 if( !seenCom && pOp->zComment ){
86639 sqlite3_str_appendf(&x, "; %s", pOp->zComment);
86641 }else if( pOp->zComment ){
86642 sqlite3_str_appendall(&x, pOp->zComment);
86658 switch( pExpr->op ){
86661 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
86664 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
86670 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
86674 if( pExpr->iColumn<0 ){
86677 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
86715 displayP4Expr(p, pExpr->pLeft);
86716 if( pExpr->pRight ){
86718 displayP4Expr(p, pExpr->pRight);
86736 switch( pOp->p4type ){
86739 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
86740 assert( pKeyInfo->aSortFlags!=0 );
86741 sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
86742 for(j=0; j<pKeyInfo->nKeyField; j++){
86743 CollSeq *pColl = pKeyInfo->aColl[j];
86744 const char *zColl = pColl ? pColl->zName : "";
86747 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
86748 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
86756 displayP4Expr(&x, pOp->p4.pExpr);
86762 CollSeq *pColl = pOp->p4.pColl;
86763 assert( pColl->enc<4 );
86764 sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
86765 encnames[pColl->enc]);
86769 FuncDef *pDef = pOp->p4.pFunc;
86770 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
86774 FuncDef *pDef = pOp->p4.pCtx->pFunc;
86775 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
86779 sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
86783 sqlite3_str_appendf(&x, "%d", pOp->p4.i);
86787 sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
86791 Mem *pMem = pOp->p4.pMem;
86792 if( pMem->flags & MEM_Str ){
86793 zP4 = pMem->z;
86794 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
86795 sqlite3_str_appendf(&x, "%lld", pMem->u.i);
86796 }else if( pMem->flags & MEM_Real ){
86797 sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
86798 }else if( pMem->flags & MEM_Null ){
86801 assert( pMem->flags & MEM_Blob );
86808 sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
86815 u32 *ai = pOp->p4.ai;
86829 zP4 = pOp->p4.pTab->zName;
86833 zP4 = pOp->p4.z;
86845 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
86849 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
86850 ** p->btreeMask of databases that will require a lock.
86853 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
86854 assert( i<(int)sizeof(p->btreeMask)*8 );
86855 DbMaskSet(p->btreeMask, i);
86856 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
86857 DbMaskSet(p->lockMask, i);
86863 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
86867 ** that the correct busy-handler callback is invoked if required.
86869 ** If SQLite is not threadsafe but does support shared-cache mode, then
86874 ** If SQLite is not threadsafe and does not support shared-cache mode, this
86875 ** function is a no-op.
86877 ** The p->btreeMask field is a bitmask of all btrees that the prepared
86878 ** statement p will ever use. Let N be the number of bits in p->btreeMask
86888 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
86889 db = p->db;
86890 aDb = db->aDb;
86891 nDb = db->nDb;
86893 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
86909 db = p->db;
86910 aDb = db->aDb;
86911 nDb = db->nDb;
86913 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
86919 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
86932 static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
86946 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3,
86947 zP4 ? zP4 : "", pOp->p5,
86960 ** This is a high-runner, so only those fields that really do need to
86975 p->flags = flags;
86976 p->db = db;
86977 p->szMalloc = 0;
86979 p->pScopyFrom = 0;
86982 }while( (--N)>0 );
86997 sqlite3 *db = p->db;
86998 if( db->pnBytesFreed ){
87000 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
87014 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
87015 ** sqlite3MemRelease() were called from here. With -O2, this jumps
87020 testcase( p->flags & MEM_Agg );
87021 testcase( p->flags & MEM_Dyn );
87022 if( p->flags&(MEM_Agg|MEM_Dyn) ){
87023 testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel );
87025 p->flags = MEM_Undefined;
87026 }else if( p->szMalloc ){
87027 sqlite3DbNNFreeNN(db, p->zMalloc);
87028 p->szMalloc = 0;
87029 p->flags = MEM_Undefined;
87033 p->flags = MEM_Undefined;
87048 if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0;
87064 pFrame->pParent = pFrame->v->pDelFrame;
87065 pFrame->v->pDelFrame = pFrame;
87085 int nSub = 0; /* Number of sub-vdbes seen so far */
87086 SubProgram **apSub = 0; /* Array of sub-vdbes */
87097 ** encountered, but p->pc will eventually catch up to nRow.
87099 nRow = p->nOp;
87101 if( pSub->flags&MEM_Blob ){
87104 nSub = pSub->n/sizeof(Vdbe*);
87105 apSub = (SubProgram **)pSub->z;
87108 nRow += apSub[i]->nOp;
87115 p->rc = SQLITE_OK;
87119 if( i<p->nOp ){
87122 aOp = p->aOp;
87127 i -= p->nOp;
87130 for(j=0; i>=apSub[j]->nOp; j++){
87131 i -= apSub[j]->nOp;
87132 assert( i<apSub[j]->nOp || j+1<nSub );
87134 aOp = apSub[j]->aOp;
87139 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
87149 p->rc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0);
87150 if( p->rc!=SQLITE_OK ){
87154 apSub = (SubProgram **)pSub->z;
87157 pSub->n = nSub*sizeof(SubProgram*);
87158 nRow += aOp[i].p4.pProgram->nOp;
87165 if( pOp->opcode==OP_OpenRead ) break;
87166 if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break;
87167 if( pOp->opcode==OP_ReopenIdx ) break;
87191 VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
87193 for(i=0; i<p->nChildCsr; i++){
87194 if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]);
87196 releaseMemArray(aMem, p->nChildMem);
87197 sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
87198 sqlite3DbFree(p->v->db, p);
87209 ** When p->explain==1, each instruction is listed. When
87210 ** p->explain==2, only OP_Explain instructions are listed and these
87211 ** are shown in a different format. p->explain==2 is used to implement
87213 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
87217 ** When p->explain==1, first the main program is listed, then each of
87224 sqlite3 *db = p->db; /* The database connection */
87227 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
87228 int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0);
87232 assert( p->explain );
87233 assert( p->eVdbeState==VDBE_RUN_STATE );
87234 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
87238 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
87242 if( p->rc==SQLITE_NOMEM ){
87254 assert( p->nMem>9 );
87255 pSub = &p->aMem[9];
87261 rc = sqlite3VdbeNextOpcode(p, pSub, p->explain==2, &p->pc, &i, &aOp);
87265 if( AtomicLoad(&db->u1.isInterrupted) ){
87266 p->rc = SQLITE_INTERRUPT;
87268 sqlite3VdbeError(p, sqlite3ErrStr(p->rc));
87271 if( p->explain==2 ){
87272 sqlite3VdbeMemSetInt64(pMem, pOp->p1);
87273 sqlite3VdbeMemSetInt64(pMem+1, pOp->p2);
87274 sqlite3VdbeMemSetInt64(pMem+2, pOp->p3);
87275 sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free);
87276 assert( p->nResColumn==4 );
87279 sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode),
87280 -1, SQLITE_UTF8, SQLITE_STATIC);
87281 sqlite3VdbeMemSetInt64(pMem+2, pOp->p1);
87282 sqlite3VdbeMemSetInt64(pMem+3, pOp->p2);
87283 sqlite3VdbeMemSetInt64(pMem+4, pOp->p3);
87285 sqlite3VdbeMemSetInt64(pMem+6, pOp->p5);
87289 sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free);
87294 sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free);
87295 assert( p->nResColumn==8 );
87297 p->pResultRow = pMem;
87298 if( db->mallocFailed ){
87299 p->rc = SQLITE_NOMEM;
87302 p->rc = SQLITE_OK;
87317 if( p->zSql ){
87318 z = p->zSql;
87319 }else if( p->nOp>=1 ){
87320 const VdbeOp *pOp = &p->aOp[0];
87321 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
87322 z = pOp->p4.z;
87335 int nOp = p->nOp;
87339 pOp = &p->aOp[0];
87340 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
87343 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
87347 if( z[i-1]!=' ' ){
87370 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
87389 assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
87392 if( nByte <= p->nFree ){
87393 p->nFree -= nByte;
87394 pBuf = &p->pSpace[p->nFree];
87396 p->nNeeded += nByte;
87412 assert( p->eVdbeState==VDBE_INIT_STATE
87413 || p->eVdbeState==VDBE_READY_STATE
87414 || p->eVdbeState==VDBE_HALT_STATE );
87418 assert( p->nOp>0 );
87420 p->eVdbeState = VDBE_READY_STATE;
87423 for(i=0; i<p->nMem; i++){
87424 assert( p->aMem[i].db==p->db );
87427 p->pc = -1;
87428 p->rc = SQLITE_OK;
87429 p->errorAction = OE_Abort;
87430 p->nChange = 0;
87431 p->cacheCtr = 1;
87432 p->minWriteFileFormat = 255;
87433 p->iStatement = 0;
87434 p->nFkConstraint = 0;
87436 for(i=0; i<p->nOp; i++){
87437 p->aOp[i].nExec = 0;
87438 p->aOp[i].nCycle = 0;
87474 assert( p->nOp>0 );
87476 assert( p->eVdbeState==VDBE_INIT_STATE );
87477 assert( pParse==p->pParse );
87478 p->pVList = pParse->pVList;
87479 pParse->pVList = 0;
87480 db = p->db;
87481 assert( db->mallocFailed==0 );
87482 nVar = pParse->nVar;
87483 nMem = pParse->nMem;
87484 nCursor = pParse->nTab;
87485 nArg = pParse->nMaxArg;
87499 n = ROUND8P(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
87500 x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */
87502 x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */
87507 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
87508 if( pParse->explain ){
87510 p->explain = pParse->explain;
87511 p->nResColumn = 12 - 4*p->explain;
87513 p->expired = 0;
87521 ** This two-pass approach that reuses as much memory as possible from
87526 p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem));
87527 p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
87528 p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
87529 p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
87531 x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
87533 if( !db->mallocFailed ){
87534 p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
87535 p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
87536 p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
87537 p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
87541 if( db->mallocFailed ){
87542 p->nVar = 0;
87543 p->nCursor = 0;
87544 p->nMem = 0;
87546 p->nCursor = nCursor;
87547 p->nVar = (ynVar)nVar;
87548 initMemArray(p->aVar, nVar, db, MEM_Null);
87549 p->nMem = nMem;
87550 initMemArray(p->aMem, nMem, db, MEM_Undefined);
87551 memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));
87564 VdbeTxtBlbCache *pCache = pCx->pCache;
87565 assert( pCx->colCache );
87566 pCx->colCache = 0;
87567 pCx->pCache = 0;
87568 if( pCache->pCValue ){
87569 sqlite3RCStrUnref(pCache->pCValue);
87570 pCache->pCValue = 0;
87572 sqlite3DbFree(p->db, pCache);
87576 if( pCx->colCache ){
87580 switch( pCx->eCurType ){
87582 sqlite3VdbeSorterClose(p->db, pCx);
87586 assert( pCx->uc.pCursor!=0 );
87587 sqlite3BtreeCloseCursor(pCx->uc.pCursor);
87592 sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
87593 const sqlite3_module *pModule = pVCur->pVtab->pModule;
87594 assert( pVCur->pVtab->nRef>0 );
87595 pVCur->pVtab->nRef--;
87596 pModule->xClose(pVCur);
87608 for(i=0; i<p->nCursor; i++){
87609 VdbeCursor *pC = p->apCsr[i];
87612 p->apCsr[i] = 0;
87619 ** is used, for example, when a trigger sub-program is halted to restore
87623 Vdbe *v = pFrame->v;
87625 v->aOp = pFrame->aOp;
87626 v->nOp = pFrame->nOp;
87627 v->aMem = pFrame->aMem;
87628 v->nMem = pFrame->nMem;
87629 v->apCsr = pFrame->apCsr;
87630 v->nCursor = pFrame->nCursor;
87631 v->db->lastRowid = pFrame->lastRowid;
87632 v->nChange = pFrame->nChange;
87633 v->db->nChange = pFrame->nDbChange;
87634 sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
87635 v->pAuxData = pFrame->pAuxData;
87636 pFrame->pAuxData = 0;
87637 return pFrame->pc;
87649 if( p->pFrame ){
87651 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
87653 p->pFrame = 0;
87654 p->nFrame = 0;
87656 assert( p->nFrame==0 );
87658 releaseMemArray(p->aMem, p->nMem);
87659 while( p->pDelFrame ){
87660 VdbeFrame *pDel = p->pDelFrame;
87661 p->pDelFrame = pDel->pParent;
87666 if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0);
87667 assert( p->pAuxData==0 );
87678 sqlite3 *db = p->db;
87680 if( p->nResAlloc ){
87681 releaseMemArray(p->aColName, p->nResAlloc*COLNAME_N);
87682 sqlite3DbFree(db, p->aColName);
87685 p->nResColumn = p->nResAlloc = (u16)nResColumn;
87686 p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n );
87687 if( p->aColName==0 ) return;
87688 initMemArray(p->aColName, n, db, MEM_Null);
87710 assert( idx<p->nResAlloc );
87712 if( p->db->mallocFailed ){
87716 assert( p->aColName!=0 );
87717 pColName = &(p->aColName[idx+var*p->nResAlloc]);
87718 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
87719 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
87726 ** write-transaction spanning more than one database file, this routine
87727 ** takes care of the super-journal trickery.
87731 int nTrans = 0; /* Number of databases with an active write-transaction
87732 ** that are candidates for a two-phase commit using a
87733 ** super-journal */
87746 ** be done before determining whether a super-journal file is
87755 ** one database file has an open write transaction, a super-journal
87758 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87759 Btree *pBt = db->aDb[i].pBt;
87761 /* Whether or not a database might need a super-journal depends upon
87763 ** journal modes use a super-journal and which do not */
87776 if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF
87791 /* If there are any write-transactions at all, invoke the commit hook */
87792 if( needXcommit && db->xCommitCallback ){
87793 rc = db->xCommitCallback(db->pCommitArg);
87799 /* The simple case - no more than one database file (not counting the
87801 ** super-journal.
87805 ** that case we do not support atomic multi-file commits, so use the
87808 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
87811 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87812 Btree *pBt = db->aDb[i].pBt;
87823 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87824 Btree *pBt = db->aDb[i].pBt;
87834 /* The complex case - There is a multi-file write-transaction active.
87835 ** This requires a super-journal file to ensure the transaction is
87840 sqlite3_vfs *pVfs = db->pVfs;
87841 char *zSuper = 0; /* File-name for the super-journal */
87842 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
87849 /* Select a super-journal file name */
87857 if( retryCount>100 ){
87867 sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X",
87869 /* The antipenultimate character of the super-journal name must
87871 assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' );
87876 /* Open the super-journal. */
87883 sqlite3DbFree(db, zSuper-4);
87888 ** super-journal file. If an error occurs at this point close
87889 ** and delete the super-journal file. All the individual journal files
87890 ** still have 'null' as the super-journal pointer, so they will roll
87893 for(i=0; i<db->nDb; i++){
87894 Btree *pBt = db->aDb[i].pBt;
87906 sqlite3DbFree(db, zSuper-4);
87912 /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device
87920 sqlite3DbFree(db, zSuper-4);
87925 ** sets the super-journal pointer in each individual journal. If
87926 ** an error occurs here, do not delete the super-journal file.
87930 ** super-journal file will be orphaned. But we cannot delete it,
87931 ** in case the super-journal file name was written into the journal
87934 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
87935 Btree *pBt = db->aDb[i].pBt;
87943 sqlite3DbFree(db, zSuper-4);
87947 /* Delete the super-journal file. This commits the transaction. After
87952 sqlite3DbFree(db, zSuper-4);
87967 for(i=0; i<db->nDb; i++){
87968 Btree *pBt = db->aDb[i].pBt;
87987 ** This is an internal self-check only - it is not an essential processing
87990 ** This is a no-op if NDEBUG is defined.
87998 p = db->pVdbe;
88002 if( p->readOnly==0 ) nWrite++;
88003 if( p->bIsReader ) nRead++;
88005 p = p->pVNext;
88007 assert( cnt==db->nVdbeActive );
88008 assert( nWrite==db->nVdbeWrite );
88009 assert( nRead==db->nVdbeRead );
88016 ** If the Vdbe passed as the first argument opened a statement-transaction,
88026 sqlite3 *const db = p->db;
88029 const int iSavepoint = p->iStatement-1;
88032 assert( db->nStatement>0 );
88033 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
88035 for(i=0; i<db->nDb; i++){
88037 Btree *pBt = db->aDb[i].pBt;
88050 db->nStatement--;
88051 p->iStatement = 0;
88066 db->nDeferredCons = p->nStmtDefCons;
88067 db->nDeferredImmCons = p->nStmtDefImmCons;
88072 if( p->db->nStatement && p->iStatement ){
88091 sqlite3 *db = p->db;
88092 if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0)
88093 || (!deferred && p->nFkConstraint>0)
88095 p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
88096 p->errorAction = OE_Abort;
88098 if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ) return SQLITE_ERROR;
88120 sqlite3 *db = p->db;
88138 assert( p->eVdbeState==VDBE_RUN_STATE );
88139 if( db->mallocFailed ){
88140 p->rc = SQLITE_NOMEM_BKPT;
88147 if( p->bIsReader ){
88148 int mrc; /* Primary error code from p->rc */
88156 if( p->rc ){
88157 mrc = p->rc & 0xff;
88166 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
88171 ** Even if the statement is read-only, it is important to perform
88173 ** occurred while writing to the journal, sub-journal or database
88178 if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
88179 if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
88187 db->autoCommit = 1;
88188 p->nChange = 0;
88194 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
88198 /* If the auto-commit flag is set and this is the only active writer
88205 && db->autoCommit
88206 && db->nVdbeWrite==(p->readOnly==0)
88208 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
88211 if( NEVER(p->readOnly) ){
88216 }else if( db->flags & SQLITE_CorruptRdOnly ){
88218 db->flags &= ~SQLITE_CorruptRdOnly;
88220 /* The auto-commit flag is true, the vdbe program was successful
88226 if( rc==SQLITE_BUSY && p->readOnly ){
88231 p->rc = rc;
88233 p->nChange = 0;
88235 db->nDeferredCons = 0;
88236 db->nDeferredImmCons = 0;
88237 db->flags &= ~(u64)SQLITE_DeferFKs;
88240 }else if( p->rc==SQLITE_SCHEMA && db->nVdbeActive>1 ){
88241 p->nChange = 0;
88244 p->nChange = 0;
88246 db->nStatement = 0;
88248 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
88250 }else if( p->errorAction==OE_Abort ){
88255 db->autoCommit = 1;
88256 p->nChange = 0;
88260 /* If eStatementOp is non-zero, then a statement transaction needs to
88269 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
88270 p->rc = rc;
88271 sqlite3DbFree(db, p->zErrMsg);
88272 p->zErrMsg = 0;
88276 db->autoCommit = 1;
88277 p->nChange = 0;
88282 ** has been rolled back, update the database connection change-counter.
88284 if( p->changeCntOn ){
88286 sqlite3VdbeSetChanges(db, p->nChange);
88290 p->nChange = 0;
88298 db->nVdbeActive--;
88299 if( !p->readOnly ) db->nVdbeWrite--;
88300 if( p->bIsReader ) db->nVdbeRead--;
88301 assert( db->nVdbeActive>=db->nVdbeRead );
88302 assert( db->nVdbeRead>=db->nVdbeWrite );
88303 assert( db->nVdbeWrite>=0 );
88304 p->eVdbeState = VDBE_HALT_STATE;
88306 if( db->mallocFailed ){
88307 p->rc = SQLITE_NOMEM_BKPT;
88310 /* If the auto-commit flag is set to true, then any locks that were held
88312 ** to invoke any required unlock-notify callbacks.
88314 if( db->autoCommit ){
88318 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
88319 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
88325 ** in p->rc. This routine sets that result back to SQLITE_OK.
88328 p->rc = SQLITE_OK;
88340 sqlite3 *db = p->db;
88341 int rc = p->rc;
88342 if( p->zErrMsg ){
88343 db->bBenignMalloc++;
88345 if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
88346 sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
88348 db->bBenignMalloc--;
88349 }else if( db->pErr ){
88350 sqlite3ValueSetNull(db->pErr);
88352 db->errCode = rc;
88353 db->errByteOffset = -1;
88363 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
88364 char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql);
88365 assert( v->db->init.busy==0 );
88368 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
88370 sqlite3DbFree(v->db, zExpanded);
88395 db = p->db;
88401 if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p);
88408 if( p->pc>=0 ){
88410 if( db->pErr || p->zErrMsg ){
88413 db->errCode = p->rc;
88422 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
88423 if( p->aMem ){
88424 for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
88427 if( p->zErrMsg ){
88428 sqlite3DbFree(db, p->zErrMsg);
88429 p->zErrMsg = 0;
88431 p->pResultRow = 0;
88433 p->nWrite = 0;
88442 fprintf(out, "---- ");
88443 for(i=0; i<p->nOp; i++){
88444 fprintf(out, "%02x", p->aOp[i].opcode);
88447 if( p->zSql ){
88449 fprintf(out, "-- ");
88450 for(i=0; (c = p->zSql[i])!=0; i++){
88451 if( pc=='\n' ) fprintf(out, "-- ");
88457 for(i=0; i<p->nOp; i++){
88458 char zHdr[100];
88459 i64 cnt = p->aOp[i].nExec;
88460 i64 cycles = p->aOp[i].nCycle;
88467 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
88473 return p->rc & db->errMask;
88485 if( p->eVdbeState>=VDBE_READY_STATE ){
88487 assert( (rc & p->db->errMask)==rc );
88513 || (pAux->iAuxOp==iOp
88514 && pAux->iAuxArg>=0
88515 && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
88517 testcase( pAux->iAuxArg==31 );
88518 if( pAux->xDeleteAux ){
88519 pAux->xDeleteAux(pAux->pAux);
88521 *pp = pAux->pNextAux;
88524 pp= &pAux->pNextAux;
88540 assert( p->db==0 || p->db==db );
88541 if( p->aColName ){
88542 releaseMemArray(p->aColName, p->nResAlloc*COLNAME_N);
88543 sqlite3DbNNFreeNN(db, p->aColName);
88545 for(pSub=p->pProgram; pSub; pSub=pNext){
88546 pNext = pSub->pNext;
88547 vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
88550 if( p->eVdbeState!=VDBE_INIT_STATE ){
88551 releaseMemArray(p->aVar, p->nVar);
88552 if( p->pVList ) sqlite3DbNNFreeNN(db, p->pVList);
88553 if( p->pFree ) sqlite3DbNNFreeNN(db, p->pFree);
88555 vdbeFreeOpArray(db, p->aOp, p->nOp);
88556 if( p->zSql ) sqlite3DbNNFreeNN(db, p->zSql);
88558 sqlite3DbFree(db, p->zNormSql);
88561 for(pThis=p->pDblStr; pThis; pThis=pNxt){
88562 pNxt = pThis->pNextStr;
88570 for(i=0; i<p->nScan; i++){
88571 sqlite3DbFree(db, p->aScan[i].zName);
88573 sqlite3DbFree(db, p->aScan);
88585 db = p->db;
88587 assert( sqlite3_mutex_held(db->mutex) );
88589 if( db->pnBytesFreed==0 ){
88590 assert( p->ppVPrev!=0 );
88591 *p->ppVPrev = p->pVNext;
88592 if( p->pVNext ){
88593 p->pVNext->ppVPrev = p->ppVPrev;
88609 assert( p->deferredMoveto );
88610 assert( p->isTable );
88611 assert( p->eCurType==CURTYPE_BTREE );
88612 rc = sqlite3BtreeTableMoveto(p->uc.pCursor, p->movetoTarget, 0, &res);
88618 p->deferredMoveto = 0;
88619 p->cacheStatus = CACHE_STALE;
88632 assert( p->eCurType==CURTYPE_BTREE );
88633 assert( p->uc.pCursor!=0 );
88634 assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) );
88635 rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow);
88636 p->cacheStatus = CACHE_STALE;
88637 if( isDifferentRow ) p->nullRow = 1;
88646 assert( p->eCurType==CURTYPE_BTREE || IsNullCursor(p) );
88647 if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
88659 ** sqlite3VdbeSerialPut() <--- in-lined into OP_MakeRecord as of 2022-04-02
88664 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
88671 ** serial-type and data blob separately.
88676 ** -------------- --------------- ---------------
88688 ** N>=12 and even (N-12)/2 BLOB
88689 ** N>=13 and odd (N-13)/2 text
88697 ** Return the serial-type for the value stored in pMem.
88701 ** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord
88702 ** opcode in the byte-code engine. But by moving this routine in-line, we
88708 int flags = pMem->flags;
88718 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
88719 i64 i = pMem->u.i;
88744 ** as an integer, then we might as well make it an 8-byte floating
88746 pMem->u.r = (double)pMem->u.i;
88747 pMem->flags &= ~MEM_IntReal;
88748 pMem->flags |= MEM_Real;
88757 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
88758 assert( pMem->n>=0 );
88759 n = (u32)pMem->n;
88761 n += pMem->u.nZero;
88783 /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
88789 ** Return the length of the data corresponding to the supplied serial-type.
88793 return (serial_type-12)/2;
88796 || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 );
88806 ** If we are on an architecture with mixed-endian floating
88810 ** For most architectures, this is a no-op.
88812 ** (later): It is reported to me that the mixed-endian problem
88814 ** that early versions of GCC stored the two words of a 64-bit
88822 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
88826 ** (2007-08-30) Frank van Vugt has studied this problem closely
88829 ** emulation that uses only 32-bit mantissas instead of a full
88830 ** 48-bits as required by the IEEE standard. (This is the
88833 ** the necessary byte swapping is carried out using a 64-bit integer
88834 ** rather than a 64-bit float. Frank assures us that the code here
88857 ** big-endian integer. Return the equivalent native integer
88883 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
88884 ** twos-complement integer. */
88885 pMem->u.i = *(i64*)&x;
88886 pMem->flags = MEM_Int;
88887 testcase( pMem->u.i<0 );
88889 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
88894 ** defined that 64-bit floating point values really are mixed
88903 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
88905 memcpy(&pMem->u.r, &x, sizeof(x));
88906 pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
88916 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
88918 memcpy(&pMem->u.r, &x, sizeof(x));
88920 pMem->flags = MEM_Null;
88923 pMem->flags = MEM_Real;
88933 ** UPDATE no-change flag set */
88934 pMem->flags = MEM_Null|MEM_Zero;
88935 pMem->n = 0;
88936 pMem->u.nZero = 0;
88941 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
88942 pMem->flags = MEM_Null;
88946 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
88948 pMem->u.i = ONE_BYTE_INT(buf);
88949 pMem->flags = MEM_Int;
88950 testcase( pMem->u.i<0 );
88953 case 2: { /* 2-byte signed integer */
88954 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
88955 ** twos-complement integer. */
88956 pMem->u.i = TWO_BYTE_INT(buf);
88957 pMem->flags = MEM_Int;
88958 testcase( pMem->u.i<0 );
88961 case 3: { /* 3-byte signed integer */
88962 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
88963 ** twos-complement integer. */
88964 pMem->u.i = THREE_BYTE_INT(buf);
88965 pMem->flags = MEM_Int;
88966 testcase( pMem->u.i<0 );
88969 case 4: { /* 4-byte signed integer */
88970 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
88971 ** twos-complement integer. */
88972 pMem->u.i = FOUR_BYTE_INT(buf);
88974 /* Work around a sign-extension bug in the HP compiler for HP/UX */
88975 if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL;
88977 pMem->flags = MEM_Int;
88978 testcase( pMem->u.i<0 );
88981 case 5: { /* 6-byte signed integer */
88982 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
88983 ** twos-complement integer. */
88984 pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
88985 pMem->flags = MEM_Int;
88986 testcase( pMem->u.i<0 );
88989 case 6: /* 8-byte signed integer */
88998 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
88999 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
89000 pMem->u.i = serial_type-8;
89001 pMem->flags = MEM_Int;
89005 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
89007 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
89008 ** (N-13)/2 bytes in length. */
89010 pMem->z = (char *)buf;
89011 pMem->n = (serial_type-12)/2;
89012 pMem->flags = aFlag[serial_type&1];
89037 nByte = ROUND8P(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
89038 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
89040 p->aMem = (Mem*)&((char*)p)[ROUND8P(sizeof(UnpackedRecord))];
89041 assert( pKeyInfo->aSortFlags!=0 );
89042 p->pKeyInfo = pKeyInfo;
89043 p->nField = pKeyInfo->nKeyField + 1;
89048 ** Given the nKey-byte encoding of a record in pKey[], populate the
89063 Mem *pMem = p->aMem;
89065 p->default_rc = 0;
89074 pMem->enc = pKeyInfo->enc;
89075 pMem->db = pKeyInfo->db;
89076 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
89077 pMem->szMalloc = 0;
89078 pMem->z = 0;
89082 if( (++u)>=p->nField ) break;
89089 sqlite3VdbeMemSetNull(pMem-1);
89091 assert( u<=pKeyInfo->nKeyField + 1 );
89092 p->nField = u;
89121 pKeyInfo = pPKey2->pKeyInfo;
89122 if( pKeyInfo->db==0 ) return 1;
89123 mem1.enc = pKeyInfo->enc;
89124 mem1.db = pKeyInfo->db;
89140 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
89141 assert( pKeyInfo->aSortFlags!=0 );
89142 assert( pKeyInfo->nKeyField>0 );
89178 rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i],
89179 pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
89182 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
89183 && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null))
89185 rc = -rc;
89187 if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){
89188 rc = -rc; /* Invert the result for DESC sort order. */
89193 }while( idx1<szHdr1 && i<pPKey2->nField );
89204 rc = pPKey2->default_rc;
89211 if( pKeyInfo->db->mallocFailed ) return 1;
89220 ** limit given by pKeyInfo->nAllField.
89222 ** If this constraint is not satisfied, it means that the high-speed
89246 assert( nField <= pKeyInfo->nAllField );
89256 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
89264 if( pMem1->enc==pColl->enc ){
89267 return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
89273 sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
89274 sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
89277 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
89278 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
89283 rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2);
89293 ** with MEM_Zero. Return true if it could be a zero-blob.
89310 int n1 = pB1->n;
89311 int n2 = pB2->n;
89313 /* It is possible to have a Blob value that has some non-zero content
89317 assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
89318 assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
89320 if( (pB1->flags|pB2->flags) & MEM_Zero ){
89321 if( pB1->flags & pB2->flags & MEM_Zero ){
89322 return pB1->u.nZero - pB2->u.nZero;
89323 }else if( pB1->flags & MEM_Zero ){
89324 if( !isAllZero(pB2->z, pB2->n) ) return -1;
89325 return pB1->u.nZero - n2;
89327 if( !isAllZero(pB1->z, pB1->n) ) return +1;
89328 return n1 - pB2->u.nZero;
89331 c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1);
89333 return n1 - n2;
89347 ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point
89362 return (x<r) ? -1 : (x>r);
89365 if( r<-9223372036854775808.0 ) return +1;
89366 if( r>=9223372036854775808.0 ) return -1;
89368 if( i<y ) return -1;
89373 return (((double)i)<r) ? -1 : (((double)i)>r);
89390 f1 = pMem1->flags;
89391 f2 = pMem2->flags;
89399 return (f2&MEM_Null) - (f1&MEM_Null);
89411 if( pMem1->u.i < pMem2->u.i ) return -1;
89412 if( pMem1->u.i > pMem2->u.i ) return +1;
89416 if( pMem1->u.r < pMem2->u.r ) return -1;
89417 if( pMem1->u.r > pMem2->u.r ) return +1;
89424 return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r);
89426 if( pMem1->u.i < pMem2->u.i ) return -1;
89427 if( pMem1->u.i > pMem2->u.i ) return +1;
89430 return -1;
89437 return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r);
89439 return -1;
89453 return -1;
89456 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
89457 assert( pMem1->enc==SQLITE_UTF8 ||
89458 pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
89464 assert( !pColl || pColl->xCmp );
89479 ** The first argument passed to this function is a serial-type that
89480 ** corresponds to an integer - all values between 1 and 9 inclusive
89516 return (serial_type - 8);
89528 ** If argument bSkip is non-zero, it is assumed that the caller has already
89532 ** fields that appear in both keys are equal, then pPKey2->default_rc is
89535 ** If database corruption is discovered, set pPKey2->errCode to
89537 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
89538 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
89550 Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */
89579 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
89584 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
89586 assert( pPKey2->pKeyInfo->aSortFlags!=0 );
89587 assert( pPKey2->pKeyInfo->nKeyField>0 );
89589 while( 1 /*exit-by-break*/ ){
89593 if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
89594 testcase( pRhs->flags & MEM_Int );
89595 testcase( pRhs->flags & MEM_IntReal );
89599 rc = serial_type==10 ? -1 : +1;
89601 rc = -1;
89604 rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
89607 i64 rhs = pRhs->u.i;
89609 rc = -1;
89617 else if( pRhs->flags & MEM_Real ){
89624 rc = serial_type==10 ? -1 : +1;
89626 rc = -1;
89630 rc = -1; /* mem1 is a NaN */
89631 }else if( mem1.u.r<pRhs->u.r ){
89632 rc = -1;
89633 }else if( mem1.u.r>pRhs->u.r ){
89640 rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
89646 else if( pRhs->flags & MEM_Str ){
89650 rc = -1;
89654 mem1.n = (serial_type - 12) / 2;
89658 || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
89660 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
89662 }else if( pKeyInfo->aColl[i] ){
89663 mem1.enc = pKeyInfo->enc;
89664 mem1.db = pKeyInfo->db;
89668 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
89671 int nCmp = MIN(mem1.n, pRhs->n);
89672 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
89673 if( rc==0 ) rc = mem1.n - pRhs->n;
89679 else if( pRhs->flags & MEM_Blob ){
89680 assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
89684 rc = -1;
89686 int nStr = (serial_type - 12) / 2;
89690 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
89692 }else if( pRhs->flags & MEM_Zero ){
89696 rc = nStr - pRhs->u.nZero;
89699 int nCmp = MIN(nStr, pRhs->n);
89700 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
89701 if( rc==0 ) rc = nStr - pRhs->n;
89720 int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
89724 !=(serial_type==0 || (pRhs->flags&MEM_Null)))
89726 rc = -rc;
89735 if( i==pPKey2->nField ) break;
89741 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
89755 || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc)
89756 || pPKey2->pKeyInfo->db->mallocFailed
89758 pPKey2->eqSeen = 1;
89759 return pPKey2->default_rc;
89772 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
89790 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
89793 case 1: { /* 1-byte signed integer */
89798 case 2: { /* 2-byte signed integer */
89803 case 3: { /* 3-byte signed integer */
89808 case 4: { /* 4-byte signed integer */
89814 case 5: { /* 6-byte signed integer */
89819 case 6: { /* 8-byte signed integer */
89846 assert( pPKey2->u.i == pPKey2->aMem[0].u.i );
89847 v = pPKey2->u.i;
89849 res = pPKey2->r1;
89851 res = pPKey2->r2;
89852 }else if( pPKey2->nField>1 ){
89858 ** fields. Return pPKey2->default_rc in this case. */
89859 res = pPKey2->default_rc;
89860 pPKey2->eqSeen = 1;
89870 ** uses the collation sequence BINARY and (c) that the size-of-header varint
89881 assert( pPKey2->aMem[0].flags & MEM_Str );
89882 assert( pPKey2->aMem[0].n == pPKey2->n );
89883 assert( pPKey2->aMem[0].z == pPKey2->u.z );
89884 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
89894 res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */
89896 res = pPKey2->r2; /* (pKey1/nKey1) is a blob */
89902 nStr = (serial_type-12) / 2;
89904 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
89907 nCmp = MIN( pPKey2->n, nStr );
89908 res = memcmp(&aKey1[szHdr], pPKey2->u.z, nCmp);
89911 res = pPKey2->r2;
89913 res = pPKey2->r1;
89915 res = nStr - pPKey2->n;
89917 if( pPKey2->nField>1 ){
89920 res = pPKey2->default_rc;
89921 pPKey2->eqSeen = 1;
89924 res = pPKey2->r2;
89926 res = pPKey2->r1;
89933 || pPKey2->pKeyInfo->db->mallocFailed
89945 ** that the size-of-header varint that occurs at the start of each record
89957 if( p->pKeyInfo->nAllField<=13 ){
89958 int flags = p->aMem[0].flags;
89959 if( p->pKeyInfo->aSortFlags[0] ){
89960 if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
89963 p->r1 = 1;
89964 p->r2 = -1;
89966 p->r1 = -1;
89967 p->r2 = 1;
89970 p->u.i = p->aMem[0].u.i;
89977 && p->pKeyInfo->aColl[0]==0
89980 p->u.z = p->aMem[0].z;
89981 p->n = p->aMem[0].n;
90006 ** than 2GiB are support - anything large must be database corruption.
90008 ** this code can safely assume that nCellKey is 32-bits
90031 /* The last field of the index should be an integer - the ROWID.
90033 getVarint32NR((u8*)&m.z[szHdr-1], typeRowid);
90052 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
90087 assert( pC->eCurType==CURTYPE_BTREE );
90088 pCur = pC->uc.pCursor;
90112 assert( sqlite3_mutex_held(db->mutex) );
90113 db->nChange = nChange;
90114 db->nTotalChange += nChange;
90122 v->changeCntOn = 1;
90131 ** programs obsolete. Removing user-defined functions or collating
90145 for(p = db->pVdbe; p; p=p->pVNext){
90146 p->expired = iCode+1;
90154 return v->db;
90161 return v->prepFlags;
90175 Mem *pMem = &v->aVar[iVar-1];
90176 assert( (v->db->flags & SQLITE_EnableQPSG)==0
90177 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
90178 if( 0==(pMem->flags & MEM_Null) ){
90179 sqlite3_value *pRet = sqlite3ValueNew(v->db);
90192 ** to sqlite3_reoptimize() that re-preparing the statement may result
90197 assert( (v->db->flags & SQLITE_EnableQPSG)==0
90198 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
90200 v->expmask |= 0x80000000;
90202 v->expmask |= ((u32)1 << (iVar-1));
90211 ** throw an error if it is given inputs that would make it non-deterministic.
90212 ** This routine is invoked by date/time functions that use non-deterministic
90218 if( pCtx->pVdbe==0 ) return 1;
90220 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
90221 if( pOp->opcode==OP_PureFunc ){
90224 if( pOp->p5 & NC_IsCheck ){
90226 }else if( pOp->p5 & NC_GenCol ){
90231 zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s",
90232 pCtx->pFunc->zName, zContext);
90233 sqlite3_result_error(pCtx, zMsg, -1);
90244 ** byte-code register values correctly initialized.
90247 if( pExpr->op==TK_REGISTER ){
90248 assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 );
90261 if( pVtab->zErrMsg ){
90262 sqlite3 *db = p->db;
90263 sqlite3DbFree(db, p->zErrMsg);
90264 p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
90265 sqlite3_free(pVtab->zErrMsg);
90266 pVtab->zErrMsg = 0;
90275 ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord
90286 Mem *pMem = &p->aMem[i];
90287 if( pMem->zMalloc ) sqlite3VdbeMemReleaseMalloc(pMem);
90296 ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call,
90302 Vdbe *v, /* Vdbe pre-update hook is invoked by */
90311 sqlite3 *db = v->db;
90314 const char *zTbl = pTab->zName;
90318 if( pTab->tabFlags & TF_WithoutRowid ){
90319 nRealCol = sqlite3PrimaryKeyIndex(pTab)->nColumn;
90320 }else if( pTab->tabFlags & TF_HasVirtual ){
90321 nRealCol = pTab->nNVCol;
90323 nRealCol = pTab->nCol;
90327 assert( db->pPreUpdate==0 );
90334 iKey2 = v->aMem[iReg].u.i;
90341 assert( pCsr->eCurType==CURTYPE_BTREE );
90342 assert( pCsr->nField==nRealCol
90343 || (pCsr->nField==nRealCol+1 && op==SQLITE_DELETE && iReg==-1)
90352 preupdate.keyinfo.nKeyField = pTab->nCol;
90359 db->pPreUpdate = &preupdate;
90360 db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2);
90361 db->pPreUpdate = 0;
90367 for(i=0; i<pCsr->nField; i++){
90398 ** Return TRUE (non-zero) of the statement supplied as an argument needs
90407 return p==0 || p->expired;
90417 if( p->db==0 ){
90441 assert( p->startTime>0 );
90442 assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
90443 assert( db->init.busy==0 );
90444 assert( p->zSql!=0 );
90445 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
90446 iElapse = (iNow - p->startTime)*1000000;
90448 if( db->xProfile ){
90449 db->xProfile(db->pProfileArg, p->zSql, iElapse);
90452 if( db->mTrace & SQLITE_TRACE_PROFILE ){
90453 db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
90455 p->startTime = 0;
90462 if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); }
90464 # define checkProfileCallback(DB,P) /*no-op*/
90479 /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
90480 ** pointer is a harmless no-op. */
90484 sqlite3 *db = v->db;
90486 sqlite3_mutex_enter(db->mutex);
90488 assert( v->eVdbeState>=VDBE_READY_STATE );
90511 sqlite3 *db = v->db;
90512 sqlite3_mutex_enter(db->mutex);
90516 assert( (rc & (db->errMask))==rc );
90518 sqlite3_mutex_leave(db->mutex);
90539 mutex = p->db->mutex;
90542 for(i=0; i<p->nVar; i++){
90543 sqlite3VdbeMemRelease(&p->aVar[i]);
90544 p->aVar[i].flags = MEM_Null;
90546 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
90547 if( p->expmask ){
90548 p->expired = 1;
90561 if( p->flags & (MEM_Blob|MEM_Str) ){
90563 assert( p->flags==MEM_Null && p->z==0 );
90566 p->flags |= MEM_Blob;
90567 return p->n ? p->z : 0;
90589 return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
90593 if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
90596 && p->eSubtype=='p'
90597 && strcmp(p->u.zPType, zPType)==0
90599 return (void*)p->z;
90618 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
90619 ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
90692 if( pVal->flags & MEM_Null ){
90694 }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
90696 }else if( pVal->flags & MEM_Int ){
90698 }else if( pVal->flags & MEM_Str ){
90701 assert( eType == aType[pVal->flags&MEM_AffMask] );
90704 return aType[pVal->flags&MEM_AffMask];
90707 return pVal->enc;
90712 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
90717 return (pVal->flags&MEM_FromBind)!=0;
90729 pNew->flags &= ~MEM_Dyn;
90730 pNew->db = 0;
90731 if( pNew->flags&(MEM_Str|MEM_Blob) ){
90732 pNew->flags &= ~(MEM_Static|MEM_Dyn);
90733 pNew->flags |= MEM_Ephem;
90738 }else if( pNew->flags & MEM_Null ){
90740 pNew->flags &= ~(MEM_Term|MEM_Subtype);
90754 ** The following routines are used by user-defined functions to specify
90771 Mem *pOut = pCtx->pOut;
90784 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
90825 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90841 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90852 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90853 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
90859 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90860 pCtx->isError = SQLITE_ERROR;
90861 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
90868 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90869 pCtx->isError = SQLITE_ERROR;
90870 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
90877 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90878 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
90884 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90885 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
90891 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90892 sqlite3VdbeMemSetNull(pCtx->pOut);
90907 pOut = pCtx->pOut;
90908 assert( sqlite3_mutex_held(pOut->db->mutex) );
90910 pOut->flags = MEM_Null;
90919 if( pCtx->pFunc!=0
90920 && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
90925 pCtx->pFunc->zName);
90926 sqlite3_result_error(pCtx, zErr, -1);
90930 pOut = pCtx->pOut;
90931 assert( sqlite3_mutex_held(pOut->db->mutex) );
90932 pOut->eSubtype = eSubtype & 0xff;
90933 pOut->flags |= MEM_Subtype;
90947 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90963 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90973 sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
90983 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90992 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91001 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91015 pOut = pCtx->pOut;
91016 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91018 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
91032 pOut = pCtx->pOut;
91033 assert( sqlite3_mutex_held(pOut->db->mutex) );
91034 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
91039 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91042 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91049 pCtx->isError = errCode ? errCode : -1;
91051 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
91053 if( pCtx->pOut->flags & MEM_Null ){
91054 setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
91064 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91065 pCtx->isError = SQLITE_TOOBIG;
91066 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
91075 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91076 sqlite3VdbeMemSetNull(pCtx->pOut);
91077 pCtx->isError = SQLITE_NOMEM_BKPT;
91078 sqlite3OomFault(pCtx->pOut->db);
91084 ** test-control.
91087 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91088 if( pCtx->pOut->flags & MEM_Int ){
91089 pCtx->pOut->flags &= ~MEM_Int;
91090 pCtx->pOut->flags |= MEM_IntReal;
91104 for(i=0; i<db->nDb; i++){
91105 Btree *pBt = db->aDb[i].pBt;
91111 if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){
91112 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry);
91135 db = p->db;
91136 if( p->eVdbeState!=VDBE_RUN_STATE ){
91138 if( p->eVdbeState==VDBE_READY_STATE ){
91139 if( p->expired ){
91140 p->rc = SQLITE_SCHEMA;
91142 if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
91144 ** error has occurred, then return the error code in p->rc to the
91157 if( db->nVdbeActive==0 ){
91158 AtomicStore(&db->u1.isInterrupted, 0);
91161 assert( db->nVdbeWrite>0 || db->autoCommit==0
91162 || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
91166 if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
91167 && !db->init.busy && p->zSql ){
91168 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
91170 assert( p->startTime==0 );
91174 db->nVdbeActive++;
91175 if( p->readOnly==0 ) db->nVdbeWrite++;
91176 if( p->bIsReader ) db->nVdbeRead++;
91177 p->pc = 0;
91178 p->eVdbeState = VDBE_RUN_STATE;
91181 if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){
91186 ** This "automatic-reset" change is not technically an incompatibility,
91192 ** returns, and those were broken by the automatic-reset change. As a
91193 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
91199 if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
91207 assert( p->eVdbeState==VDBE_READY_STATE );
91213 p->rcApp = SQLITE_OK;
91216 if( p->explain ){
91221 db->nVdbeExec++;
91223 db->nVdbeExec--;
91227 assert( p->rc==SQLITE_OK );
91228 assert( db->mallocFailed==0 );
91229 db->errCode = SQLITE_ROW;
91236 p->pResultRow = 0;
91237 if( rc==SQLITE_DONE && db->autoCommit ){
91238 assert( p->rc==SQLITE_OK );
91239 p->rc = doWalCallbacks(db);
91240 if( p->rc!=SQLITE_OK ){
91243 }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
91245 ** error has occurred, then return the error code in p->rc to the
91252 db->errCode = rc;
91253 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
91254 p->rc = SQLITE_NOMEM_BKPT;
91255 if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc;
91260 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0
91264 return (rc&db->errMask);
91268 ** This is the top-level implementation of sqlite3_step(). Call
91281 db = v->db;
91282 sqlite3_mutex_enter(db->mutex);
91285 int savedPc = v->pc;
91296 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
91297 sqlite3DbFree(db, v->zErrMsg);
91298 if( !db->mallocFailed ){
91299 v->zErrMsg = sqlite3DbStrDup(db, zErr);
91300 v->rc = rc = sqlite3ApiExit(db, rc);
91302 v->zErrMsg = 0;
91303 v->rc = rc = SQLITE_NOMEM_BKPT;
91312 ** SQLITE_SCHEMA. tag-20220401a */
91313 v->minWriteFileFormat = 254;
91315 assert( v->expired==0 );
91317 sqlite3_mutex_leave(db->mutex);
91330 assert( p && p->pFunc );
91331 return p->pFunc->pUserData;
91338 ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
91348 assert( p && p->pOut );
91350 return p->pOut->db;
91364 ** performance by substituting a NULL result, or some other light-weight
91373 return sqlite3_value_nochange(p->pOut);
91401 if( (pVal->flags & MEM_Dyn)==0 || pVal->xDel!=sqlite3VdbeValueListFree ){
91404 assert( (pVal->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
91406 assert( pVal->eSubtype=='p' );
91407 assert( pVal->u.zPType!=0 && strcmp(pVal->u.zPType,"ValueList")==0 );
91408 pRhs = (ValueList*)pVal->z;
91411 rc = sqlite3BtreeNext(pRhs->pCsr, 0);
91414 rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
91415 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
91416 if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE;
91422 sz = sqlite3BtreePayloadSize(pRhs->pCsr);
91423 rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem);
91427 sqlite3_value *pOut = pRhs->pOut;
91430 pOut->enc = ENC(pOut->db);
91431 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
91468 sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
91469 assert( p->pVdbe!=0 );
91472 sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
91475 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
91483 ** its pMem->z element.
91486 Mem *pMem = p->pMem;
91487 assert( (pMem->flags & MEM_Agg)==0 );
91490 pMem->z = 0;
91493 pMem->flags = MEM_Agg;
91494 pMem->u.pDef = p->pFunc;
91495 if( pMem->z ){
91496 memset(pMem->z, 0, nByte);
91499 return (void*)pMem->z;
91508 assert( p && p->pFunc && p->pFunc->xFinalize );
91509 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
91511 if( (p->pMem->flags & MEM_Agg)==0 ){
91514 return (void*)p->pMem->z;
91520 ** the user-function defined by pCtx.
91522 ** The left-most argument is 0.
91534 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91536 if( pCtx->pVdbe==0 ) return 0;
91538 assert( pCtx->pVdbe!=0 );
91540 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
91541 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
91542 return pAuxData->pAux;
91550 ** argument to the user-function defined by pCtx. Any previous value is
91553 ** The left-most argument is 0.
91571 pVdbe= pCtx->pVdbe;
91572 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91579 for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
91580 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
91585 pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
91587 pAuxData->iAuxOp = pCtx->iOp;
91588 pAuxData->iAuxArg = iArg;
91589 pAuxData->pNextAux = pVdbe->pAuxData;
91590 pVdbe->pAuxData = pAuxData;
91591 if( pCtx->isError==0 ) pCtx->isError = -1;
91592 }else if( pAuxData->xDeleteAux ){
91593 pAuxData->xDeleteAux(pAuxData->pAux);
91596 pAuxData->pAux = pAux;
91597 pAuxData->xDeleteAux = xDelete;
91617 assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
91618 return p->pMem->n;
91628 return pVm->nResColumn;
91637 if( pVm==0 || pVm->pResultRow==0 ) return 0;
91638 return pVm->nResColumn;
91647 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
91648 ** instead of an 8-byte one. This all works fine, except that when
91650 ** that a Mem structure is located on an 8-byte boundary. To prevent
91652 ** using gcc, we force nullMem to be 8-byte aligned using the magical
91690 assert( pVm->db );
91691 sqlite3_mutex_enter(pVm->db->mutex);
91692 if( pVm->pResultRow!=0 && i<pVm->nResColumn && i>=0 ){
91693 pOut = &pVm->pResultRow[i];
91695 sqlite3Error(pVm->db, SQLITE_RANGE);
91728 assert( p->db!=0 );
91729 assert( sqlite3_mutex_held(p->db->mutex) );
91730 p->rc = sqlite3ApiExit(p->db, p->rc);
91731 sqlite3_mutex_leave(p->db->mutex);
91781 if( pOut->flags&MEM_Static ){
91782 pOut->flags &= ~MEM_Static;
91783 pOut->flags |= MEM_Ephem;
91828 ** Convert the N-th element of pStmt->pColName[] into a string using
91862 db = p->db;
91864 sqlite3_mutex_enter(db->mutex);
91866 if( p->explain ){
91868 n = p->explain==1 ? 8 : 4;
91871 int i = iExplainColNames16[N + 8*p->explain - 8];
91874 ret = (void*)azExplainColNames8[N + 8*p->explain - 8];
91878 n = p->nResColumn;
91880 u8 prior_mallocFailed = db->mallocFailed;
91884 ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
91888 ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
91893 assert( db->mallocFailed==0 || db->mallocFailed==1 );
91894 if( db->mallocFailed > prior_mallocFailed ){
91900 sqlite3_mutex_leave(db->mutex);
91998 ** The error code stored in database p->db is overwritten with the return
92006 sqlite3_mutex_enter(p->db->mutex);
92007 if( p->eVdbeState!=VDBE_READY_STATE ){
92008 sqlite3Error(p->db, SQLITE_MISUSE_BKPT);
92009 sqlite3_mutex_leave(p->db->mutex);
92011 "bind on a busy prepared statement: [%s]", p->zSql);
92014 if( i>=(unsigned int)p->nVar ){
92015 sqlite3Error(p->db, SQLITE_RANGE);
92016 sqlite3_mutex_leave(p->db->mutex);
92019 pVar = &p->aVar[i];
92021 pVar->flags = MEM_Null;
92022 p->db->errCode = SQLITE_OK;
92027 ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host
92033 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
92034 if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){
92035 p->expired = 1;
92055 rc = vdbeUnbind(p, (u32)(i-1));
92058 pVar = &p->aVar[i-1];
92061 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
92064 sqlite3Error(p->db, rc);
92065 rc = sqlite3ApiExit(p->db, rc);
92068 sqlite3_mutex_leave(p->db->mutex);
92104 rc = vdbeUnbind(p, (u32)(i-1));
92106 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
92107 sqlite3_mutex_leave(p->db->mutex);
92117 rc = vdbeUnbind(p, (u32)(i-1));
92119 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
92120 sqlite3_mutex_leave(p->db->mutex);
92127 rc = vdbeUnbind(p, (u32)(i-1));
92129 sqlite3_mutex_leave(p->db->mutex);
92142 rc = vdbeUnbind(p, (u32)(i-1));
92144 sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);
92145 sqlite3_mutex_leave(p->db->mutex);
92190 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
92194 assert( pValue->flags & (MEM_Real|MEM_IntReal) );
92196 (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i
92201 if( pValue->flags & MEM_Zero ){
92202 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
92204 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
92209 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
92210 pValue->enc);
92223 rc = vdbeUnbind(p, (u32)(i-1));
92226 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
92228 rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
92230 sqlite3_mutex_leave(p->db->mutex);
92240 sqlite3_mutex_enter(p->db->mutex);
92241 if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
92247 rc = sqlite3ApiExit(p->db, rc);
92248 sqlite3_mutex_leave(p->db->mutex);
92258 return p ? p->nVar : 0;
92265 ** The result is always UTF-8.
92270 return sqlite3VListNumToName(p->pVList, i);
92280 return sqlite3VListNameToNum(p->pVList, zName, nName);
92293 assert( pTo->db==pFrom->db );
92294 assert( pTo->nVar==pFrom->nVar );
92295 sqlite3_mutex_enter(pTo->db->mutex);
92296 for(i=0; i<pFrom->nVar; i++){
92297 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
92299 sqlite3_mutex_leave(pTo->db->mutex);
92319 if( pFrom->nVar!=pTo->nVar ){
92322 assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
92323 if( pTo->expmask ){
92324 pTo->expired = 1;
92326 assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
92327 if( pFrom->expmask ){
92328 pFrom->expired = 1;
92341 return pStmt ? ((Vdbe*)pStmt)->db : 0;
92349 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
92357 return pStmt ? ((Vdbe*)pStmt)->explain : 0;
92369 sqlite3_mutex_enter(v->db->mutex);
92370 if( ((int)v->explain)==eMode ){
92374 }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
92376 }else if( v->eVdbeState!=VDBE_READY_STATE ){
92378 }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
92380 v->explain = eMode;
92383 v->explain = eMode;
92385 v->haveEqpOps = eMode==2;
92387 if( v->explain ){
92388 v->nResColumn = 12 - 4*v->explain;
92390 v->nResColumn = v->nResAlloc;
92392 sqlite3_mutex_leave(v->db->mutex);
92401 return v!=0 && v->eVdbeState==VDBE_RUN_STATE;
92418 sqlite3_mutex_enter(pDb->mutex);
92420 pNext = (sqlite3_stmt*)pDb->pVdbe;
92422 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext;
92424 sqlite3_mutex_leave(pDb->mutex);
92436 || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
92443 sqlite3 *db = pVdbe->db;
92444 sqlite3_mutex_enter(db->mutex);
92446 db->pnBytesFreed = (int*)&v;
92447 assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );
92448 db->lookaside.pEnd = db->lookaside.pStart;
92450 db->pnBytesFreed = 0;
92451 db->lookaside.pEnd = db->lookaside.pTrueEnd;
92452 sqlite3_mutex_leave(db->mutex);
92454 v = pVdbe->aCounter[op];
92455 if( resetFlag ) pVdbe->aCounter[op] = 0;
92465 return p ? p->zSql : 0;
92485 sqlite3_mutex_enter(p->db->mutex);
92487 sqlite3_mutex_leave(p->db->mutex);
92500 if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){
92501 sqlite3_mutex_enter(p->db->mutex);
92502 p->zNormSql = sqlite3Normalize(p, p->zSql);
92503 sqlite3_mutex_leave(p->db->mutex);
92505 return p->zNormSql;
92524 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1));
92531 ** This function is called from within a pre-update callback to retrieve
92544 p = db->pPreUpdate;
92546 ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */
92547 if( !p || p->op==SQLITE_INSERT ){
92551 if( p->pPk ){
92552 iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
92554 if( iIdx>=p->pCsr->nField || iIdx<0 ){
92560 if( p->pUnpacked==0 ){
92564 assert( p->pCsr->eCurType==CURTYPE_BTREE );
92565 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
92568 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
92570 p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec);
92571 if( !p->pUnpacked ) rc = SQLITE_NOMEM;
92577 p->aRecord = aRec;
92580 pMem = *ppValue = &p->pUnpacked->aMem[iIdx];
92581 if( iIdx==p->pTab->iPKey ){
92582 sqlite3VdbeMemSetInt64(pMem, p->iKey1);
92583 }else if( iIdx>=p->pUnpacked->nField ){
92585 }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
92586 if( pMem->flags & (MEM_Int|MEM_IntReal) ){
92587 testcase( pMem->flags & MEM_Int );
92588 testcase( pMem->flags & MEM_IntReal );
92601 ** This function is called from within a pre-update callback to retrieve
92607 p = db!=0 ? db->pPreUpdate : 0;
92609 p = db->pPreUpdate;
92611 return (p ? p->keyinfo.nKeyField : 0);
92617 ** This function is designed to be called from within a pre-update callback
92621 ** on the stack (1 for a top-level trigger, 2 for a trigger fired by a
92622 ** top-level trigger etc.).
92630 p = db!=0 ? db->pPreUpdate : 0;
92632 p = db->pPreUpdate;
92634 return (p ? p->v->nFrame : 0);
92640 ** This function is designed to be called from within a pre-update callback
92646 p = db!=0 ? db->pPreUpdate : 0;
92648 p = db->pPreUpdate;
92650 return (p ? p->iBlobWrite : -1);
92656 ** This function is called from within a pre-update callback to retrieve
92669 p = db->pPreUpdate;
92670 if( !p || p->op==SQLITE_DELETE ){
92674 if( p->pPk && p->op!=SQLITE_UPDATE ){
92675 iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
92677 if( iIdx>=p->pCsr->nField || iIdx<0 ){
92682 if( p->op==SQLITE_INSERT ){
92683 /* For an INSERT, memory cell p->iNewReg contains the serialized record
92685 UnpackedRecord *pUnpack = p->pNewUnpacked;
92687 Mem *pData = &p->v->aMem[p->iNewReg];
92690 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
92695 p->pNewUnpacked = pUnpack;
92697 pMem = &pUnpack->aMem[iIdx];
92698 if( iIdx==p->pTab->iPKey ){
92699 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
92700 }else if( iIdx>=pUnpack->nField ){
92704 /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required
92709 assert( p->op==SQLITE_UPDATE );
92710 if( !p->aNew ){
92711 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
92712 if( !p->aNew ){
92717 assert( iIdx>=0 && iIdx<p->pCsr->nField );
92718 pMem = &p->aNew[iIdx];
92719 if( pMem->flags==0 ){
92720 if( iIdx==p->pTab->iPKey ){
92721 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
92723 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]);
92760 aOp = p->aOp;
92761 nOp = p->nOp;
92762 if( p->pFrame ){
92764 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
92765 aOp = pFrame->aOp;
92766 nOp = pFrame->nOp;
92786 for(idx=0; idx<p->nScan; idx++){
92787 pScan = &p->aScan[idx];
92788 if( pScan->zName ){
92789 iScan--;
92794 if( idx>=p->nScan ) return 1;
92795 assert( pScan==0 || pScan==&p->aScan[idx] );
92796 pScan = &p->aScan[idx];
92800 if( pScan->addrLoop>0 ){
92801 *(sqlite3_int64*)pOut = aOp[pScan->addrLoop].nExec;
92803 *(sqlite3_int64*)pOut = -1;
92808 if( pScan->addrVisit>0 ){
92809 *(sqlite3_int64*)pOut = aOp[pScan->addrVisit].nExec;
92811 *(sqlite3_int64*)pOut = -1;
92817 LogEst x = pScan->nEst;
92818 while( x<100 ){
92826 *(const char**)pOut = pScan->zName;
92830 if( pScan->addrExplain ){
92831 *(const char**)pOut = aOp[ pScan->addrExplain ].p4.z;
92838 if( pScan->addrExplain ){
92839 *(int*)pOut = aOp[ pScan->addrExplain ].p1;
92841 *(int*)pOut = -1;
92846 if( pScan->addrExplain ){
92847 *(int*)pOut = aOp[ pScan->addrExplain ].p2;
92849 *(int*)pOut = -1;
92855 if( pScan->aAddrRange[0]==0 ){
92856 res = -1;
92859 for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){
92860 int iIns = pScan->aAddrRange[ii];
92861 int iEnd = pScan->aAddrRange[ii+1];
92872 if( pOp->p1!=iEnd ) continue;
92873 if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){
92909 for(ii=0; p!=0 && ii<p->nOp; ii++){
92910 Op *pOp = &p->aOp[ii];
92911 pOp->nExec = 0;
92912 pOp->nCycle = 0;
92934 ** The Vdbe parse-tree explainer is also found here.
92942 ** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of
92967 ** This function returns a pointer to a nul-terminated string in memory
92971 ** then the returned string holds a copy of zRawSql with "-- " prepended
92977 ** with large (multi-megabyte) strings and blobs.
92987 ** parameter index is known, locate the value in p->aVar[]. Then render
93006 db = p->db;
93007 sqlite3StrAccumInit(&out, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
93008 if( db->nVdbeExec>1 ){
93012 sqlite3_str_append(&out, "-- ", 3);
93013 assert( (zRawSql - zStart) > 0 );
93014 sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart));
93016 }else if( p->nVar==0 ){
93045 assert( idx>0 && idx<=p->nVar );
93046 pVar = &p->aVar[idx-1];
93047 if( pVar->flags & MEM_Null ){
93049 }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){
93050 sqlite3_str_appendf(&out, "%lld", pVar->u.i);
93051 }else if( pVar->flags & MEM_Real ){
93052 sqlite3_str_appendf(&out, "%!.15g", pVar->u.r);
93053 }else if( pVar->flags & MEM_Str ){
93060 sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
93068 nOut = pVar->n;
93072 while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
93075 sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
93077 if( nOut<pVar->n ){
93078 sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
93084 }else if( pVar->flags & MEM_Zero ){
93085 sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero);
93088 assert( pVar->flags & MEM_Blob );
93090 nOut = pVar->n;
93095 sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
93099 if( nOut<pVar->n ){
93100 sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
93189 ** use this information to make sure that the zero-blob functionality
93196 if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
93197 sqlite3_max_blobsize = p->n;
93207 # define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback)
93209 # define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback)
93265 ** M: 2 - two-way branch (I=0: fall-thru 1: jump )
93266 ** 3 - two-way + NULL (I=0: fall-thru 1: jump 2: NULL )
93267 ** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3)
93269 ** In other words, if M is 2, then I is either 0 (for fall-through) or
93271 ** ordinary fall-through, I is 1 if the branch was taken, and I is 2
93282 ** always taken, the flags should be 0x05 since the fall-through and
93284 ** flags should be 0x06 since only the fall-through approach is allowed.
93287 ** interested in equal or not-equal. In other words, I==0 and I==2
93292 ** should be no-ops except for special builds used to measure test coverage.
93297 # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
93301 assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */
93313 ** iSrcLine - the line number of the VdbeCoverage() macro, with
93315 ** I - Mask of bits 0x07 indicating which cases are are
93317 ** fall-thru, 0x02 means taken, 0x04 means NULL. Any
93322 ** M - Type of jump. Same as M argument above
93347 if( ((P)->flags&MEM_Ephem)!=0 \
93351 #define isSorter(x) ((x)->eCurType==CURTYPE_SORTER)
93378 ** the top of the register space. Cursor 1 is at Mem[p->nMem-1].
93379 ** Cursor 2 is at Mem[p->nMem-2]. And so forth.
93381 Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
93389 assert( iCur>=0 && iCur<p->nCursor );
93390 if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
93391 sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]);
93392 p->apCsr[iCur] = 0;
93397 ** in pMem->zMalloc. But for the special case of the aMem[] entries used
93398 ** to hold cursors, it is faster to in-line the logic. */
93399 assert( pMem->flags==MEM_Undefined );
93400 assert( (pMem->flags & MEM_Dyn)==0 );
93401 assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc );
93402 if( pMem->szMalloc<nByte ){
93403 if( pMem->szMalloc>0 ){
93404 sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
93406 pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte);
93407 if( pMem->zMalloc==0 ){
93408 pMem->szMalloc = 0;
93411 pMem->szMalloc = nByte;
93414 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc;
93416 pCx->eCurType = eCurType;
93417 pCx->nField = nField;
93418 pCx->aOffset = &pCx->aType[nField];
93420 pCx->uc.pCursor = (BtCursor*)
93421 &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
93422 sqlite3BtreeCursorZero(pCx->uc.pCursor);
93440 return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
93460 u8 enc = pRec->enc;
93462 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
93463 rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
93465 if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
93466 pRec->flags |= MEM_Int;
93468 pRec->u.r = rValue;
93469 pRec->flags |= MEM_Real;
93472 /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the
93475 ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */
93476 pRec->flags &= ~MEM_Str;
93486 ** floating-point representation if an integer representation
93500 ** No-op. pRec is unchanged.
93510 if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
93511 if( (pRec->flags & (MEM_Real|MEM_IntReal))==0 ){
93512 if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
93523 if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
93524 if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
93525 testcase( pRec->flags & MEM_Int );
93526 testcase( pRec->flags & MEM_Real );
93527 testcase( pRec->flags & MEM_IntReal );
93531 pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal);
93566 ** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields
93572 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
93573 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
93575 pMem->u.i = 0;
93578 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
93580 if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
93581 pMem->u.i = ix;
93586 }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
93587 pMem->u.i = ix;
93597 ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
93598 ** But it does set pMem->u.r and pMem->u.i appropriately.
93601 assert( (pMem->flags & MEM_Null)==0
93602 || pMem->db==0 || pMem->db->mallocFailed );
93603 if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){
93604 testcase( pMem->flags & MEM_Int );
93605 testcase( pMem->flags & MEM_Real );
93606 testcase( pMem->flags & MEM_IntReal );
93607 return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null);
93609 assert( pMem->flags & (MEM_Str|MEM_Blob) );
93610 testcase( pMem->flags & MEM_Str );
93611 testcase( pMem->flags & MEM_Blob );
93622 int f = pMem->flags;
93640 for(i=0; i<25 && i<pMem->n; i++){
93641 sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF));
93644 for(i=0; i<25 && i<pMem->n; i++){
93645 char z = pMem->z[i];
93650 sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero);
93667 sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n);
93668 for(j=0; j<25 && j<pMem->n; j++){
93669 c = pMem->z[j];
93672 sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
93674 sqlite3_str_appendf(pStr, "(0-term)");
93685 if( p->flags & MEM_Undefined ){
93687 }else if( p->flags & MEM_Null ){
93688 printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL");
93689 }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
93690 printf(" si:%lld", p->u.i);
93691 }else if( (p->flags & (MEM_IntReal))!=0 ){
93692 printf(" ir:%lld", p->u.i);
93693 }else if( p->flags & MEM_Int ){
93694 printf(" i:%lld", p->u.i);
93696 }else if( p->flags & MEM_Real ){
93697 printf(" r:%.17g", p->u.r);
93708 if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
93713 if( p->pScopyFrom ){
93714 printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
93733 for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i);
93739 # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
93748 ** the number of non-transaction savepoints currently in the
93758 for(p=db->pSavepoint; p; p=p->pNext) n++;
93759 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
93765 ** Return the register of pOp->p2 after first preparing it to be
93770 pOut->flags = MEM_Int;
93775 assert( pOp->p2>0 );
93776 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
93777 pOut = &p->aMem[pOp->p2];
93779 if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
93782 pOut->flags = MEM_Int;
93788 ** Compute a bloom filter hash using pOp->p4.i registers from aMem[] beginning
93789 ** with pOp->p3. Return the hash.
93795 assert( pOp->p4type==P4_INT32 );
93796 for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){
93798 if( p->flags & (MEM_Int|MEM_IntReal) ){
93799 h += p->u.i;
93800 }else if( p->flags & MEM_Real ){
93802 }else if( p->flags & (MEM_Str|MEM_Blob) ){
93806 h += 4093 + (p->flags & (MEM_Str|MEM_Blob));
93823 int t, /* The serial-type code for the column value */
93830 sqlite3 *db = pDest->db;
93831 int encoding = pDest->enc;
93833 assert( pC->eCurType==CURTYPE_BTREE );
93834 if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) return SQLITE_TOOBIG;
93835 if( len > 4000 && pC->pKeyInfo==0 ){
93842 ** Only do this on table-btrees so that writes to index-btrees do not
93848 if( pC->colCache==0 ){
93849 pC->pCache = sqlite3DbMallocZero(db, sizeof(VdbeTxtBlbCache) );
93850 if( pC->pCache==0 ) return SQLITE_NOMEM;
93851 pC->colCache = 1;
93853 pCache = pC->pCache;
93854 if( pCache->pCValue==0
93855 || pCache->iCol!=iCol
93856 || pCache->cacheStatus!=cacheStatus
93857 || pCache->colCacheCtr!=colCacheCtr
93858 || pCache->iOffset!=sqlite3BtreeOffset(pC->uc.pCursor)
93860 if( pCache->pCValue ) sqlite3RCStrUnref(pCache->pCValue);
93861 pBuf = pCache->pCValue = sqlite3RCStrNew( len+3 );
93863 rc = sqlite3BtreePayload(pC->uc.pCursor, iOffset, len, pBuf);
93868 pCache->iCol = iCol;
93869 pCache->cacheStatus = cacheStatus;
93870 pCache->colCacheCtr = colCacheCtr;
93871 pCache->iOffset = sqlite3BtreeOffset(pC->uc.pCursor);
93873 pBuf = pCache->pCValue;
93880 pDest->flags |= MEM_Term;
93886 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, iOffset, len, pDest);
93888 sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
93890 pDest->z[len] = 0;
93891 pDest->flags |= MEM_Term;
93894 pDest->flags &= ~MEM_Ephem;
93910 return azTypes[sqlite3_value_type(pMem)-1];
93920 Op *aOp = p->aOp; /* Copy of p->aOp */
93928 sqlite3 *db = p->db; /* The database */
93936 Mem *aMem = p->aMem; /* Copy of p->aMem */
93948 assert( p->eVdbeState==VDBE_RUN_STATE ); /* sqlite3_step() verifies this */
93949 if( DbMaskNonZero(p->lockMask) ){
93953 if( db->xProgress ){
93954 u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
93955 assert( 0 < db->nProgressOps );
93956 nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
93961 if( p->rc==SQLITE_NOMEM ){
93966 assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
93967 testcase( p->rc!=SQLITE_OK );
93968 p->rc = SQLITE_OK;
93969 assert( p->bIsReader || p->readOnly!=0 );
93970 p->iCurrentTime = 0;
93971 assert( p->explain==0 );
93972 db->busyHandler.nBusy = 0;
93973 if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
93977 if( p->pc==0
93978 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
93983 if( p->db->flags & SQLITE_VdbeListing ){
93985 for(i=0; i<p->nOp; i++){
93989 if( p->db->flags & SQLITE_VdbeEQP ){
93990 for(i=0; i<p->nOp; i++){
93998 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
94002 for(pOp=&aOp[p->pc]; 1; pOp++){
94007 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
94011 pOp->nExec++;
94012 pnCycle = &pOp->nCycle;
94013 if( sqlite3NProfileCnt==0 ) *pnCycle -= sqlite3Hwtime();
94016 pOp->nExec++;
94017 pnCycle = &pOp->nCycle;
94018 *pnCycle -= sqlite3Hwtime();
94025 if( db->flags & SQLITE_VdbeTrace ){
94026 sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
94027 test_trace_breakpoint((int)(pOp - aOp),pOp,p);
94037 sqlite3_interrupt_count--;
94047 u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
94049 assert( pOp->p1>0 );
94050 assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
94051 assert( memIsValid(&aMem[pOp->p1]) );
94052 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
94053 REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
94056 assert( pOp->p2>0 );
94057 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
94058 assert( memIsValid(&aMem[pOp->p2]) );
94059 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
94060 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
94063 assert( pOp->p3>0 );
94064 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
94065 assert( memIsValid(&aMem[pOp->p3]) );
94066 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
94067 REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
94070 assert( pOp->p2>0 );
94071 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
94072 memAboutToChange(p, &aMem[pOp->p2]);
94075 assert( pOp->p3>0 );
94076 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
94077 memAboutToChange(p, &aMem[pOp->p3]);
94085 switch( pOp->opcode ){
94092 ** the switch statement will break with convention and be flush-left. Another
94130 ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
94140 if( pOp->p5 ){
94141 assert( pOp->p2 < (int)(pOp - aOp) );
94142 assert( pOp->p2 > 1 );
94143 pOp = &aOp[pOp->p2 - 2];
94150 pOp = &aOp[pOp->p2 - 1];
94161 ** faster according to "valgrind --tool=cachegrind" */
94163 if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
94168 ** If the progress callback returns non-zero, exit the virtual machine with
94171 while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
94172 assert( db->nProgressOps!=0 );
94173 nProgressLimit += db->nProgressOps;
94174 if( db->xProgress(db->pProgressArg) ){
94191 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
94192 pIn1 = &aMem[pOp->p1];
94195 pIn1->flags = MEM_Int;
94196 pIn1->u.i = (int)(pOp-aOp);
94197 REGISTER_TRACE(pOp->p1, pIn1);
94208 ** OP_Return becomes a no-op. If P3 is 0, then register P1 must hold an
94215 ** P2 is not used by the byte-code engine. However, if P2 is positive
94220 ** value is a byte-code indentation hint. See tag-20220407a in
94224 pIn1 = &aMem[pOp->p1];
94225 if( pIn1->flags & MEM_Int ){
94226 if( pOp->p3 ){ VdbeBranchTaken(1, 2); }
94227 pOp = &aOp[pIn1->u.i];
94228 }else if( ALWAYS(pOp->p3) ){
94246 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
94247 assert( pOp->p2>=0 && pOp->p2<p->nOp );
94248 assert( pOp->p3>=0 && pOp->p3<p->nOp );
94249 pOut = &aMem[pOp->p1];
94251 pOut->u.i = pOp->p3 - 1;
94252 pOut->flags = MEM_Int;
94253 if( pOp->p2==0 ) break;
94258 assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */
94259 assert( pOp->p2<p->nOp ); /* Jumps must be in range */
94260 pOp = &aOp[pOp->p2 - 1];
94276 pIn1 = &aMem[pOp->p1];
94277 assert( pIn1->flags==MEM_Int );
94278 assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
94279 pCaller = &aOp[pIn1->u.i];
94280 assert( pCaller->opcode==OP_Yield );
94281 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
94282 pIn1->u.i = (int)(pOp - p->aOp) - 1;
94283 pOp = &aOp[pCaller->p2 - 1];
94302 pIn1 = &aMem[pOp->p1];
94304 pIn1->flags = MEM_Int;
94305 pcDest = (int)pIn1->u.i;
94306 pIn1->u.i = (int)(pOp - aOp);
94307 REGISTER_TRACE(pOp->p1, pIn1);
94317 ** value in register P3 is not NULL, then this routine is a no-op.
94321 pIn3 = &aMem[pOp->p3];
94323 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
94325 if( (pIn3->flags & MEM_Null)==0 ) break;
94365 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
94371 assert( pOp->p1!=SQLITE_INTERNAL );
94373 if( p->pFrame && pOp->p1==SQLITE_OK ){
94374 /* Halt the sub-program. Return control to the parent frame. */
94375 pFrame = p->pFrame;
94376 p->pFrame = pFrame->pParent;
94377 p->nFrame--;
94378 sqlite3VdbeSetChanges(db, p->nChange);
94380 if( pOp->p2==OE_Ignore ){
94381 /* Instruction pcx is the OP_Program that invoked the sub-program
94383 ** instruction is set to OE_Ignore, then the sub-program is throwing
94386 pcx = p->aOp[pcx].p2-1;
94388 aOp = p->aOp;
94389 aMem = p->aMem;
94393 p->rc = pOp->p1;
94394 p->errorAction = (u8)pOp->p2;
94395 assert( pOp->p5<=4 );
94396 if( p->rc ){
94397 if( pOp->p5 ){
94400 testcase( pOp->p5==1 );
94401 testcase( pOp->p5==2 );
94402 testcase( pOp->p5==3 );
94403 testcase( pOp->p5==4 );
94404 sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
94405 if( pOp->p4.z ){
94406 p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
94409 sqlite3VdbeError(p, "%s", pOp->p4.z);
94411 pcx = (int)(pOp - aOp);
94412 sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
94417 p->rc = SQLITE_BUSY;
94419 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
94420 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
94421 rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
94429 ** The 32-bit integer value P1 is written into register P2.
94433 pOut->u.i = pOp->p1;
94440 ** P4 is a pointer to a 64-bit integer value.
94445 assert( pOp->p4.pI64!=0 );
94446 pOut->u.i = *pOp->p4.pI64;
94454 ** P4 is a pointer to a 64-bit floating point value.
94459 pOut->flags = MEM_Real;
94460 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
94461 pOut->u.r = *pOp->p4.pReal;
94469 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
94475 assert( pOp->p4.z!=0 );
94477 pOp->p1 = sqlite3Strlen30(pOp->p4.z);
94481 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
94485 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
94487 pOut->szMalloc = 0;
94488 pOut->flags |= MEM_Static;
94489 if( pOp->p4type==P4_DYNAMIC ){
94490 sqlite3DbFree(db, pOp->p4.z);
94492 pOp->p4type = P4_DYNAMIC;
94493 pOp->p4.z = pOut->z;
94494 pOp->p1 = pOut->n;
94497 if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
94500 pOp->opcode = OP_String;
94519 assert( pOp->p4.z!=0 );
94521 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
94522 pOut->z = pOp->p4.z;
94523 pOut->n = pOp->p1;
94524 pOut->enc = encoding;
94527 if( pOp->p3>0 ){
94528 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
94529 pIn3 = &aMem[pOp->p3];
94530 assert( pIn3->flags & MEM_Int );
94531 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
94540 ** Mark the beginning of a subroutine that can be entered in-line
94544 ** If the subroutine is entered in-line, then the OP_Return will simply
94550 ** a no-op that simply falls through to the next instruction (assuming that
94552 ** entered in-line, then the OP_Return will cause in-line execution to
94567 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
94576 cnt = pOp->p3-pOp->p2;
94577 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
94578 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
94579 pOut->n = 0;
94581 pOut->uTemp = 0;
94587 pOut->flags = nullFlag;
94588 pOut->n = 0;
94589 cnt--;
94603 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
94604 pOut = &aMem[pOp->p1];
94605 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
94614 ** a zero-filled blob that is P1 bytes long in P2.
94617 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
94619 if( pOp->p4.z==0 ){
94620 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
94623 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
94625 pOut->enc = encoding;
94638 assert( pOp->p1>0 && pOp->p1<=p->nVar );
94639 pVar = &p->aVar[pOp->p1 - 1];
94643 pOut = &aMem[pOp->p2];
94646 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
94647 pOut->flags |= MEM_Static|MEM_FromBind;
94655 ** Move the P3 values in register P1..P1+P3-1 over into
94656 ** registers P2..P2+P3-1. Registers P1..P1+P3-1 are
94658 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error
94666 n = pOp->p3;
94667 p1 = pOp->p1;
94668 p2 = pOp->p2;
94675 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
94676 assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
94681 pIn1->pScopyFrom = 0;
94683 for(i=1; i<p->nMem; i++){
94694 }while( --n );
94714 n = pOp->p3;
94715 pIn1 = &aMem[pOp->p1];
94716 pOut = &aMem[pOp->p2];
94722 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
94723 pOut->flags &= ~MEM_Subtype;
94726 pOut->pScopyFrom = 0;
94728 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
94729 if( (n--)==0 ) break;
94750 pIn1 = &aMem[pOp->p1];
94751 pOut = &aMem[pOp->p2];
94755 pOut->pScopyFrom = pIn1;
94756 pOut->mScopyFlags = pIn1->flags;
94770 pIn1 = &aMem[pOp->p1];
94771 assert( (pIn1->flags & MEM_Int)!=0 );
94772 pOut = &aMem[pOp->p2];
94773 sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
94781 ** constraint violations, this is a no-op.
94798 ** The registers P1 through P1+P2-1 contain a single row of
94801 ** structure to provide access to the r(P1)..r(P1+P2-1) values as
94805 assert( p->nResColumn==pOp->p2 );
94806 assert( pOp->p1>0 || CORRUPT_DB );
94807 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
94809 p->cacheCtr = (p->cacheCtr + 2)|1;
94810 p->pResultRow = &aMem[pOp->p1];
94813 Mem *pMem = p->pResultRow;
94815 for(i=0; i<pOp->p2; i++){
94817 REGISTER_TRACE(pOp->p1+i, &pMem[i]);
94827 if( db->mallocFailed ) goto no_mem;
94828 if( db->mTrace & SQLITE_TRACE_ROW ){
94829 db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
94831 p->pc = (int)(pOp - aOp) + 1;
94854 pIn1 = &aMem[pOp->p1];
94855 pIn2 = &aMem[pOp->p2];
94856 pOut = &aMem[pOp->p3];
94859 flags1 = pIn1->flags;
94861 testcase( pIn2->flags & MEM_Null );
94862 if( (flags1 | pIn2->flags) & MEM_Null ){
94868 flags1 = pIn1->flags & ~MEM_Str;
94871 flags1 = pIn1->flags & ~MEM_Str;
94873 flags2 = pIn2->flags;
94876 flags2 = pIn2->flags & ~MEM_Str;
94879 flags2 = pIn2->flags & ~MEM_Str;
94881 nByte = pIn1->n + pIn2->n;
94882 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
94890 memcpy(pOut->z, pIn2->z, pIn2->n);
94891 assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
94892 pIn2->flags = flags2;
94894 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
94895 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
94896 pIn1->flags = flags1;
94898 pOut->z[nByte]=0;
94899 pOut->z[nByte+1] = 0;
94900 pOut->flags |= MEM_Term;
94901 pOut->n = (int)nByte;
94902 pOut->enc = encoding;
94923 ** Synopsis: r[P3]=r[P2]-r[P1]
94957 pIn1 = &aMem[pOp->p1];
94958 type1 = pIn1->flags;
94959 pIn2 = &aMem[pOp->p2];
94960 type2 = pIn2->flags;
94961 pOut = &aMem[pOp->p3];
94964 iA = pIn1->u.i;
94965 iB = pIn2->u.i;
94966 switch( pOp->opcode ){
94972 if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
94978 if( iA==-1 ) iA = 1;
94983 pOut->u.i = iB;
94994 switch( pOp->opcode ){
94996 case OP_Subtract: rB -= rA; break;
95008 if( iA==-1 ) iA = 1;
95014 pOut->u.i = rB;
95020 pOut->u.r = rB;
95035 ** be returned. This is used by the built-in min(), max() and nullif()
95044 ** publicly. Only built-in functions have access to this feature.
95047 assert( pOp->p4type==P4_COLLSEQ );
95048 if( pOp->p1 ){
95049 sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
95057 ** Take the bit-wise AND of the values in register P1 and P2 and
95064 ** Take the bit-wise OR of the values in register P1 and P2 and
95093 pIn1 = &aMem[pOp->p1];
95094 pIn2 = &aMem[pOp->p2];
95095 pOut = &aMem[pOp->p3];
95096 if( (pIn1->flags | pIn2->flags) & MEM_Null ){
95102 op = pOp->opcode;
95113 op = 2*OP_ShiftLeft + 1 - op;
95114 iB = iB>(-64) ? -iB : 64;
95118 iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
95125 /* Sign-extend on a right shift of a negative number */
95126 if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
95131 pOut->u.i = iA;
95145 pIn1 = &aMem[pOp->p1];
95148 *(u64*)&pIn1->u.i += (u64)pOp->p2;
95160 pIn1 = &aMem[pOp->p1];
95161 if( (pIn1->flags & MEM_Int)==0 ){
95163 if( (pIn1->flags & MEM_Int)==0 ){
95165 if( pOp->p2==0 ){
95189 pIn1 = &aMem[pOp->p1];
95190 if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
95191 testcase( pIn1->flags & MEM_Int );
95192 testcase( pIn1->flags & MEM_IntReal );
95194 REGISTER_TRACE(pOp->p1, pIn1);
95217 assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
95218 testcase( pOp->p2==SQLITE_AFF_TEXT );
95219 testcase( pOp->p2==SQLITE_AFF_BLOB );
95220 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
95221 testcase( pOp->p2==SQLITE_AFF_INTEGER );
95222 testcase( pOp->p2==SQLITE_AFF_REAL );
95223 pIn1 = &aMem[pOp->p1];
95227 rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
95230 REGISTER_TRACE(pOp->p1, pIn1);
95241 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
95285 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
95335 u16 flags1; /* Copy of initial value of pIn1->flags */
95336 u16 flags3; /* Copy of initial value of pIn3->flags */
95338 pIn1 = &aMem[pOp->p1];
95339 pIn3 = &aMem[pOp->p3];
95340 flags1 = pIn1->flags;
95341 flags3 = pIn3->flags;
95344 if( pIn3->u.i > pIn1->u.i ){
95345 if( sqlite3aGTb[pOp->opcode] ){
95346 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95351 }else if( pIn3->u.i < pIn1->u.i ){
95352 if( sqlite3aLTb[pOp->opcode] ){
95353 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95356 iCompare = -1;
95359 if( sqlite3aEQb[pOp->opcode] ){
95360 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95366 VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95371 if( pOp->p5 & SQLITE_NULLEQ ){
95377 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
95378 testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
95384 res = ((flags3 & MEM_Null) ? -1 : +1); /* Operands are not equal */
95392 if( pOp->p5 & SQLITE_JUMPIFNULL ){
95400 /* Neither operand is NULL and we couldn't do the special high-speed
95401 ** integer comparison case. So do a general-case comparison. */
95402 affinity = pOp->p5 & SQLITE_AFF_MASK;
95407 assert( flags3==pIn3->flags || CORRUPT_DB );
95408 flags3 = pIn3->flags;
95416 pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
95418 testcase( pIn1->flags & MEM_Int );
95419 testcase( pIn1->flags & MEM_Real );
95420 testcase( pIn1->flags & MEM_IntReal );
95422 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
95423 flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
95427 pIn3->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
95429 testcase( pIn3->flags & MEM_Int );
95430 testcase( pIn3->flags & MEM_Real );
95431 testcase( pIn3->flags & MEM_IntReal );
95433 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
95434 flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
95437 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
95438 res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
95450 res2 = sqlite3aLTb[pOp->opcode];
95452 res2 = sqlite3aEQb[pOp->opcode];
95454 res2 = sqlite3aGTb[pOp->opcode];
95460 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
95461 pIn3->flags = flags3;
95462 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
95463 pIn1->flags = flags1;
95465 VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
95487 /* Verify the preconditions of this opcode - that it follows an OP_Lt or
95490 for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
95515 assert( pOp->p4type==P4_INTARRAY );
95516 assert( pOp->p4.ai );
95523 ** Synopsis: r[P1@P3] <-> r[P2@P3]
95525 ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
95526 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
95555 if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
95559 assert( pOp[-1].opcode==OP_Permutation );
95560 assert( pOp[-1].p4type==P4_INTARRAY );
95561 aPermute = pOp[-1].p4.ai + 1;
95564 n = pOp->p3;
95565 pKeyInfo = pOp->p4.pKeyInfo;
95568 p1 = pOp->p1;
95569 p2 = pOp->p2;
95574 assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
95575 assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
95577 assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
95578 assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
95587 assert( i<pKeyInfo->nKeyField );
95588 pColl = pKeyInfo->aColl[i];
95589 bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
95593 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
95596 iCompare = -iCompare;
95598 if( bRev ) iCompare = -iCompare;
95615 assert( pOp>aOp && pOp[-1].opcode==OP_Compare );
95618 VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
95620 VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
95622 VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
95652 v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
95653 v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
95654 if( pOp->opcode==OP_And ){
95661 pOut = &aMem[pOp->p3];
95665 pOut->u.i = v1;
95692 assert( pOp->p4type==P4_INT32 );
95693 assert( pOp->p4.i==0 || pOp->p4.i==1 );
95694 assert( pOp->p3==0 || pOp->p3==1 );
95695 sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
95696 sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
95708 pIn1 = &aMem[pOp->p1];
95709 pOut = &aMem[pOp->p2];
95710 if( (pIn1->flags & MEM_Null)==0 ){
95722 ** ones-complement of the P1 value into register P2. If P1 holds
95726 pIn1 = &aMem[pOp->p1];
95727 pOut = &aMem[pOp->p2];
95729 if( (pIn1->flags & MEM_Null)==0 ){
95730 pOut->flags = MEM_Int;
95731 pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
95739 ** encountered on each invocation of the byte-code program. Jump to P2
95742 ** Top-level programs determine first invocation by comparing the P1
95750 ** because the self-altering code trick does not work for recursive
95755 assert( p->aOp[0].opcode==OP_Init );
95756 if( p->pFrame ){
95757 iAddr = (int)(pOp - p->aOp);
95758 if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
95762 p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
95764 if( p->aOp[0].p1==pOp->p1 ){
95770 pOp->p1 = p->aOp[0].p1;
95777 ** is considered true if it is numeric and non-zero. If the value
95778 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
95782 c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
95792 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
95796 c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
95808 pIn1 = &aMem[pOp->p1];
95809 VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
95810 if( (pIn1->flags & MEM_Null)!=0 ){
95829 ** If P1 is -1, then P3 is a register number and the datatype is taken
95852 assert( pOp->p1>=(-1) && pOp->p1<p->nCursor );
95853 assert( pOp->p1>=0 || (pOp->p3>=0 && pOp->p3<=(p->nMem+1 - p->nCursor)) );
95854 if( pOp->p1>=0 ){
95855 pC = p->apCsr[pOp->p1];
95857 assert( pOp->p3>=0 );
95858 if( pOp->p3<pC->nHdrParsed ){
95859 serialType = pC->aType[pOp->p3];
95886 typeMask = 1 << (pOp->p4.i - 1);
95894 assert( memIsValid(&aMem[pOp->p3]) );
95895 typeMask = 1 << (sqlite3_value_type((sqlite3_value*)&aMem[pOp->p3])-1);
95902 VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2);
95903 if( typeMask & pOp->p5 ){
95917 if( (aMem[pOp->p1].flags & MEM_Null)!=0
95918 || (aMem[pOp->p3].flags & MEM_Null)!=0
95920 sqlite3VdbeMemSetNull(aMem + pOp->p2);
95922 sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0);
95933 pIn1 = &aMem[pOp->p1];
95934 VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
95935 if( (pIn1->flags & MEM_Null)==0 ){
95949 ** If P1 is not an open cursor, then this opcode is a no-op.
95953 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
95954 pC = p->apCsr[pOp->p1];
95955 if( pC && pC->nullRow ){
95956 sqlite3VdbeMemSetNull(aMem + pOp->p3);
95976 ** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option.
95980 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
95981 pC = p->apCsr[pOp->p1];
95982 pOut = &p->aMem[pOp->p3];
95983 if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){
95986 if( pC->deferredMoveto ){
95990 if( sqlite3BtreeEof(pC->uc.pCursor) ){
95993 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
96005 ** information about the format of the data.) Extract the P2-th column
96025 BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */
96026 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
96034 u64 offset64; /* 64-bit offset */
96038 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
96039 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
96040 pC = p->apCsr[pOp->p1];
96041 p2 = (u32)pOp->p2;
96045 assert( p2<(u32)pC->nField
96046 || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) );
96047 aOffset = pC->aOffset;
96048 assert( aOffset==pC->aType+pC->nField );
96049 assert( pC->eCurType!=CURTYPE_VTAB );
96050 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
96051 assert( pC->eCurType!=CURTYPE_SORTER );
96053 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
96054 if( pC->nullRow ){
96055 if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){
96056 /* For the special case of as pseudo-cursor, the seekResult field
96058 pReg = &aMem[pC->seekResult];
96059 assert( pReg->flags & MEM_Blob );
96061 pC->payloadSize = pC->szRow = pReg->n;
96062 pC->aRow = (u8*)pReg->z;
96064 pDest = &aMem[pOp->p3];
96070 pCrsr = pC->uc.pCursor;
96071 if( pC->deferredMoveto ){
96073 assert( !pC->isEphemeral );
96074 if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){
96075 pC = pC->pAltCursor;
96076 p2 = iMap - 1;
96086 assert( pC->eCurType==CURTYPE_BTREE );
96089 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
96090 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
96091 assert( pC->szRow<=pC->payloadSize );
96092 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
96094 pC->cacheStatus = p->cacheCtr;
96095 if( (aOffset[0] = pC->aRow[0])<0x80 ){
96096 pC->iHdrOffset = 1;
96098 pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset);
96100 pC->nHdrParsed = 0;
96102 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
96103 /* pC->aRow does not have to hold the entire row, but it does at least
96104 ** need to cover the header of the record. If pC->aRow does not contain
96107 pC->aRow = 0;
96108 pC->szRow = 0;
96116 ** 3-byte type for each of the maximum of 32768 columns plus three
96119 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
96124 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
96136 zData = pC->aRow;
96137 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
96141 }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){
96148 ** parsed and valid information is in aOffset[] and pC->aType[].
96150 if( pC->nHdrParsed<=p2 ){
96152 ** to extract additional fields up through the p2+1-th field
96154 if( pC->iHdrOffset<aOffset[0] ){
96156 if( pC->aRow==0 ){
96158 rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
96162 zData = pC->aRow;
96165 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
96167 i = pC->nHdrParsed;
96169 zHdr = zData + pC->iHdrOffset;
96173 if( (pC->aType[i] = t = zHdr[0])<0x80 ){
96178 pC->aType[i] = t;
96189 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
96190 || (offset64 > pC->payloadSize)
96196 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
96201 pC->nHdrParsed = i;
96202 pC->iHdrOffset = (u32)(zHdr - zData);
96203 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
96212 if( pC->nHdrParsed<=p2 ){
96213 pDest = &aMem[pOp->p3];
96215 if( pOp->p4type==P4_MEM ){
96216 sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
96223 t = pC->aType[p2];
96226 /* Extract the content for the p2+1-th column. Control can only
96227 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
96230 assert( p2<pC->nHdrParsed );
96232 pDest = &aMem[pOp->p3];
96238 assert( t==pC->aType[p2] );
96239 if( pC->szRow>=aOffset[p2+1] ){
96241 ** page - where the content is not on an overflow page */
96242 zData = pC->aRow + aOffset[p2];
96247 ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent
96251 pDest->n = len = (t-12)/2;
96252 pDest->enc = encoding;
96253 if( pDest->szMalloc < len+2 ){
96254 if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big;
96255 pDest->flags = MEM_Null;
96258 pDest->z = pDest->zMalloc;
96260 memcpy(pDest->z, zData, len);
96261 pDest->z[len] = 0;
96262 pDest->z[len+1] = 0;
96263 pDest->flags = aFlag[t&1];
96267 pDest->enc = encoding;
96268 assert( pDest->db==db );
96270 if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
96293 p->cacheCtr, colCacheCtr, pDest);
96304 REGISTER_TRACE(pOp->p3, pDest);
96309 pOp = &aOp[aOp[0].p3-1];
96329 ** is zero. When P3 is non-zero, no type checking occurs for
96336 ** <li> P2 should be the number of non-virtual columns in the
96348 assert( pOp->p4type==P4_TABLE );
96349 pTab = pOp->p4.pTab;
96350 assert( pTab->tabFlags & TF_Strict );
96351 assert( pTab->nNVCol==pOp->p2 );
96352 aCol = pTab->aCol;
96353 pIn1 = &aMem[pOp->p1];
96354 for(i=0; i<pTab->nCol; i++){
96357 if( pOp->p3 ){ pIn1++; continue; }
96359 assert( pIn1 < &aMem[pOp->p1+pOp->p2] );
96361 if( (pIn1->flags & MEM_Null)==0 ){
96364 if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error;
96369 if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error;
96373 if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error;
96377 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real );
96378 assert( (pIn1->flags & MEM_IntReal)==0 );
96379 if( pIn1->flags & MEM_Int ){
96382 ** so that we keep the high-resolution integer value but know that
96384 testcase( pIn1->u.i==140737488355328LL );
96385 testcase( pIn1->u.i==140737488355327LL );
96386 testcase( pIn1->u.i==-140737488355328LL );
96387 testcase( pIn1->u.i==-140737488355329LL );
96388 if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){
96389 pIn1->flags |= MEM_IntReal;
96390 pIn1->flags &= ~MEM_Int;
96392 pIn1->u.r = (double)pIn1->u.i;
96393 pIn1->flags |= MEM_Real;
96394 pIn1->flags &= ~MEM_Int;
96396 }else if( (pIn1->flags & (MEM_Real|MEM_IntReal))==0 ){
96407 REGISTER_TRACE((int)(pIn1-aMem), pIn1);
96410 assert( pIn1 == &aMem[pOp->p1+pOp->p2] );
96415 vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1],
96416 pTab->zName, aCol[i].zCnName);
96426 ** P4 is a string that is P2 characters long. The N-th character of the
96427 ** string indicates the column affinity that should be used for the N-th
96433 zAffinity = pOp->p4.z;
96435 assert( pOp->p2>0 );
96436 assert( zAffinity[pOp->p2]==0 );
96437 pIn1 = &aMem[pOp->p1];
96438 while( 1 /*exit-by-break*/ ){
96439 assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
96442 if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
96445 ** so that we keep the high-resolution integer value but know that
96447 testcase( pIn1->u.i==140737488355328LL );
96448 testcase( pIn1->u.i==140737488355327LL );
96449 testcase( pIn1->u.i==-140737488355328LL );
96450 testcase( pIn1->u.i==-140737488355329LL );
96451 if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){
96452 pIn1->flags |= MEM_IntReal;
96453 pIn1->flags &= ~MEM_Int;
96455 pIn1->u.r = (double)pIn1->u.i;
96456 pIn1->flags |= MEM_Real;
96457 pIn1->flags &= ~(MEM_Int|MEM_Str);
96460 REGISTER_TRACE((int)(pIn1-aMem), pIn1);
96475 ** P4 may be a string that is P2 characters long. The N-th character of the
96476 ** string indicates the column affinity that should be used for the N-th
96485 ** compile-time option is enabled:
96488 ** of the right-most table that can be null-trimmed.
96492 ** accept no-change records with serial_type 10. This value is
96514 ** ------------------------------------------------------------------------
96515 ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
96516 ** ------------------------------------------------------------------------
96523 ** hdr-size field is also a varint which is the offset from the beginning
96529 nField = pOp->p1;
96530 zAffinity = pOp->p4.z;
96531 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
96533 nField = pOp->p2;
96534 pLast = &pData0[nField-1];
96537 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
96538 pOut = &aMem[pOp->p3];
96548 if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
96549 pRec->flags |= MEM_IntReal;
96550 pRec->flags &= ~(MEM_Int);
96552 REGISTER_TRACE((int)(pRec-aMem), pRec);
96562 ** have a non-NULL default value. Also, the record must be left with
96564 ** index of the right-most column with a non-NULL default value */
96565 if( pOp->p5 ){
96566 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
96567 pLast--;
96568 nField--;
96575 ** the Mem.uTemp field of each term should hold the serial-type that will
96579 ** --------------- ---------------
96581 ** 1 1-byte signed integer
96582 ** 2 2-byte signed integer
96583 ** 3 3-byte signed integer
96584 ** 4 4-byte signed integer
96585 ** 5 6-byte signed integer
96586 ** 6 8-byte signed integer
96602 if( pRec->flags & MEM_Null ){
96603 if( pRec->flags & MEM_Zero ){
96607 ** Give such values a special internal-use-only serial-type of 10
96611 assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
96613 pRec->uTemp = 10;
96615 pRec->uTemp = 0;
96618 }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){
96620 i64 i = pRec->u.i;
96622 testcase( pRec->flags & MEM_Int );
96623 testcase( pRec->flags & MEM_IntReal );
96636 if( (i&1)==i && p->minWriteFileFormat>=4 ){
96637 pRec->uTemp = 8+(u32)uu;
96640 pRec->uTemp = 1;
96644 pRec->uTemp = 2;
96647 pRec->uTemp = 3;
96650 pRec->uTemp = 4;
96653 pRec->uTemp = 5;
96656 if( pRec->flags & MEM_IntReal ){
96658 ** as an integer, then we might as well make it an 8-byte floating
96660 pRec->u.r = (double)pRec->u.i;
96661 pRec->flags &= ~MEM_IntReal;
96662 pRec->flags |= MEM_Real;
96663 pRec->uTemp = 7;
96665 pRec->uTemp = 6;
96668 }else if( pRec->flags & MEM_Real ){
96671 pRec->uTemp = 7;
96673 assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) );
96674 assert( pRec->n>=0 );
96675 len = (u32)pRec->n;
96676 serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0);
96677 if( pRec->flags & MEM_Zero ){
96678 serial_type += pRec->u.nZero*2;
96681 len += pRec->u.nZero;
96683 nZero += pRec->u.nZero;
96688 pRec->uTemp = serial_type;
96691 pRec--;
96694 /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
96712 ** the new record. The output register (pOp->p3) is not allowed to
96716 if( nByte+nZero<=pOut->szMalloc ){
96719 pOut->z = pOut->zMalloc;
96723 if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
96730 pOut->n = (int)nByte;
96731 pOut->flags = MEM_Blob;
96733 pOut->u.nZero = nZero;
96734 pOut->flags |= MEM_Zero;
96737 zHdr = (u8 *)pOut->z;
96748 while( 1 /*exit-by-break*/ ){
96749 serial_type = pRec->uTemp;
96750 /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
96752 ** EVIDENCE-OF: R-64536-51728 The values for each column in the record
96761 assert( sizeof(v)==sizeof(pRec->u.r) );
96762 memcpy(&v, &pRec->u.r, sizeof(v));
96765 v = pRec->u.i;
96788 if( serial_type>=14 && pRec->n>0 ){
96789 assert( pRec->z!=0 );
96790 memcpy(zPayload, pRec->z, pRec->n);
96791 zPayload += pRec->n;
96795 if( pRec->n ){
96796 assert( pRec->z!=0 );
96797 memcpy(zPayload, pRec->z, pRec->n);
96798 zPayload += pRec->n;
96804 assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
96805 assert( nByte==(int)(zPayload - (u8*)pOut->z) );
96807 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
96808 REGISTER_TRACE(pOp->p3, pOut);
96819 ** every btree page of the table. But if P3 is non-zero, an estimate
96826 assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
96827 pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
96829 if( pOp->p3 ){
96837 pOut->u.i = nEntry;
96858 p1 = pOp->p1;
96859 zName = pOp->p4.z;
96864 assert( db->pSavepoint==0 || db->autoCommit==0 );
96866 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
96868 assert( p->bIsReader );
96871 if( db->nVdbeWrite>0 ){
96875 sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
96884 ** that the db->aVTrans[] array is empty. */
96885 assert( db->autoCommit==0 || db->nVTrans==0 );
96887 db->nStatement+db->nSavepoint);
96894 pNew->zName = (char *)&pNew[1];
96895 memcpy(pNew->zName, zName, nName+1);
96899 if( db->autoCommit ){
96900 db->autoCommit = 0;
96901 db->isTransactionSavepoint = 1;
96903 db->nSavepoint++;
96907 pNew->pNext = db->pSavepoint;
96908 db->pSavepoint = pNew;
96909 pNew->nDeferredCons = db->nDeferredCons;
96910 pNew->nDeferredImmCons = db->nDeferredImmCons;
96920 pSavepoint = db->pSavepoint;
96921 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
96922 pSavepoint = pSavepoint->pNext
96929 }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
96933 sqlite3VdbeError(p, "cannot release savepoint - "
96942 int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
96947 db->autoCommit = 1;
96949 p->pc = (int)(pOp - aOp);
96950 db->autoCommit = 0;
96951 p->rc = rc = SQLITE_BUSY;
96954 rc = p->rc;
96956 db->autoCommit = 0;
96958 db->isTransactionSavepoint = 0;
96962 iSavepoint = db->nSavepoint - iSavepoint - 1;
96964 isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0;
96965 for(ii=0; ii<db->nDb; ii++){
96966 rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
96975 for(ii=0; ii<db->nDb; ii++){
96976 rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
96984 db->mDbFlags |= DBFLAG_SchemaChange;
96991 while( db->pSavepoint!=pSavepoint ){
96992 pTmp = db->pSavepoint;
96993 db->pSavepoint = pTmp->pNext;
96995 db->nSavepoint--;
97003 assert( pSavepoint==db->pSavepoint );
97004 db->pSavepoint = pSavepoint->pNext;
97007 db->nSavepoint--;
97011 db->nDeferredCons = pSavepoint->nDeferredCons;
97012 db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
97022 if( p->eVdbeState==VDBE_HALT_STATE ){
97031 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
97042 desiredAutoCommit = pOp->p1;
97043 iRollback = pOp->p2;
97046 assert( db->nVdbeActive>0 ); /* At least this one VM is active */
97047 assert( p->bIsReader );
97049 if( desiredAutoCommit!=db->autoCommit ){
97053 db->autoCommit = 1;
97054 }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
97058 sqlite3VdbeError(p, "cannot commit transaction - "
97065 db->autoCommit = (u8)desiredAutoCommit;
97068 p->pc = (int)(pOp - aOp);
97069 db->autoCommit = (u8)(1-desiredAutoCommit);
97070 p->rc = rc = SQLITE_BUSY;
97074 if( p->rc==SQLITE_OK ){
97083 (iRollback)?"cannot rollback - no transaction is active":
97084 "cannot commit - no transaction is active"));
97096 ** If P2 is non-zero, then a write-transaction is started, or if a
97097 ** read-transaction is already active, it is upgraded to a write-transaction.
97098 ** If P2 is zero, then a read-transaction is started. If P2 is 2 or more
97106 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
97132 assert( p->bIsReader );
97133 assert( p->readOnly==0 || pOp->p2==0 );
97134 assert( pOp->p2>=0 && pOp->p2<=2 );
97135 assert( pOp->p1>=0 && pOp->p1<db->nDb );
97136 assert( DbMaskTest(p->btreeMask, pOp->p1) );
97138 if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){
97139 if( db->flags & SQLITE_QueryOnly ){
97149 pDb = &db->aDb[pOp->p1];
97150 pBt = pDb->pBt;
97153 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
97158 p->pc = (int)(pOp - aOp);
97159 p->rc = rc;
97165 if( p->usesStmtJournal
97166 && pOp->p2
97167 && (db->autoCommit==0 || db->nVdbeRead>1)
97170 if( p->iStatement==0 ){
97171 assert( db->nStatement>=0 && db->nSavepoint>=0 );
97172 db->nStatement++;
97173 p->iStatement = db->nSavepoint + db->nStatement;
97176 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
97178 rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
97184 p->nStmtDefCons = db->nDeferredCons;
97185 p->nStmtDefImmCons = db->nDeferredImmCons;
97188 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
97190 && pOp->p5
97191 && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i)
97194 ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
97198 sqlite3DbFree(db, p->zErrMsg);
97199 p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
97200 /* If the schema-cookie from the database file matches the cookie
97201 ** stored with the in-memory representation of the schema, do
97204 ** If virtual-tables are in use, this is not just an optimization.
97205 ** Often, v-tables store their data in other SQLite tables, which
97206 ** are queried from within xNext() and other v-table methods using
97207 ** prepared queries. If such a query is out-of-date, we do not want to
97209 ** v-table would have to be ready for the sqlite3_vtab structure itself
97211 ** a v-table method.
97213 if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
97214 sqlite3ResetOneSchema(db, pOp->p1);
97216 p->expired = 1;
97222 p->changeCntOn = 0;
97236 ** There must be a read-lock on the database (either a transaction
97245 assert( p->bIsReader );
97246 iDb = pOp->p1;
97247 iCookie = pOp->p3;
97248 assert( pOp->p3<SQLITE_N_BTREE_META );
97249 assert( iDb>=0 && iDb<db->nDb );
97250 assert( db->aDb[iDb].pBt!=0 );
97251 assert( DbMaskTest(p->btreeMask, iDb) );
97253 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
97255 pOut->u.i = iMeta;
97270 ** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement
97278 assert( pOp->p2<SQLITE_N_BTREE_META );
97279 assert( pOp->p1>=0 && pOp->p1<db->nDb );
97280 assert( DbMaskTest(p->btreeMask, pOp->p1) );
97281 assert( p->readOnly==0 );
97282 pDb = &db->aDb[pOp->p1];
97283 assert( pDb->pBt!=0 );
97284 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
97286 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
97287 if( pOp->p2==BTREE_SCHEMA_VERSION ){
97289 *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5;
97290 db->mDbFlags |= DBFLAG_SchemaChange;
97291 sqlite3FkClearTriggerCache(db, pOp->p1);
97292 }else if( pOp->p2==BTREE_FILE_FORMAT ){
97294 pDb->pSchema->file_format = pOp->p3;
97296 if( pOp->p1==1 ){
97300 p->expired = 0;
97309 ** Open a read-only cursor for the database table whose root page is
97326 ** object, then table being opened must be an [index b-tree] where the
97328 ** sequence of that index b-tree. Otherwise, if P4 is an integer
97329 ** value, then the table being opened must be a [table b-tree] with a
97339 ** b-tree and if it is this opcode becomes a no-op. In other words,
97361 ** OPFLAG_P2ISREG bit is set in P5 - see below).
97365 ** object, then table being opened must be an [index b-tree] where the
97367 ** sequence of that index b-tree. Otherwise, if P4 is an integer
97368 ** value, then the table being opened must be a [table b-tree] with a
97400 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
97401 assert( pOp->p4type==P4_KEYINFO );
97402 pCur = p->apCsr[pOp->p1];
97403 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
97404 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
97405 assert( pCur->eCurType==CURTYPE_BTREE );
97406 sqlite3BtreeClearCursor(pCur->uc.pCursor);
97414 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
97415 assert( p->bIsReader );
97416 assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
97417 || p->readOnly==0 );
97419 if( p->expired==1 ){
97426 p2 = (u32)pOp->p2;
97427 iDb = pOp->p3;
97428 assert( iDb>=0 && iDb<db->nDb );
97429 assert( DbMaskTest(p->btreeMask, iDb) );
97430 pDb = &db->aDb[iDb];
97431 pX = pDb->pBt;
97433 if( pOp->opcode==OP_OpenWrite ){
97435 wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
97437 if( pDb->pSchema->file_format < p->minWriteFileFormat ){
97438 p->minWriteFileFormat = pDb->pSchema->file_format;
97443 if( pOp->p5 & OPFLAG_P2ISREG ){
97445 assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
97446 assert( pOp->opcode==OP_OpenWrite );
97449 assert( (pIn2->flags & MEM_Int)!=0 );
97451 p2 = (int)pIn2->u.i;
97458 if( pOp->p4type==P4_KEYINFO ){
97459 pKeyInfo = pOp->p4.pKeyInfo;
97460 assert( pKeyInfo->enc==ENC(db) );
97461 assert( pKeyInfo->db==db );
97462 nField = pKeyInfo->nAllField;
97463 }else if( pOp->p4type==P4_INT32 ){
97464 nField = pOp->p4.i;
97466 assert( pOp->p1>=0 );
97469 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
97471 pCur->iDb = iDb;
97472 pCur->nullRow = 1;
97473 pCur->isOrdered = 1;
97474 pCur->pgnoRoot = p2;
97476 pCur->wrFlag = wrFlag;
97478 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
97479 pCur->pKeyInfo = pKeyInfo;
97481 ** SQLite used to check if the root-page flags were sane at this point
97484 pCur->isTable = pOp->p4type!=P4_KEYINFO;
97489 testcase( pOp->p5 & OPFLAG_BULKCSR );
97490 testcase( pOp->p2 & OPFLAG_SEEKEQ );
97491 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
97492 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
97503 ** Duplicate ephemeral cursors are used for self-joins of materialized views.
97509 pOrig = p->apCsr[pOp->p2];
97511 assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */
97513 pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE);
97515 pCx->nullRow = 1;
97516 pCx->isEphemeral = 1;
97517 pCx->pKeyInfo = pOrig->pKeyInfo;
97518 pCx->isTable = pOrig->isTable;
97519 pCx->pgnoRoot = pOrig->pgnoRoot;
97520 pCx->isOrdered = pOrig->isOrdered;
97521 pCx->ub.pBtx = pOrig->ub.pBtx;
97522 pCx->noReuse = 1;
97523 pOrig->noReuse = 1;
97524 rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR,
97525 pCx->pKeyInfo, pCx->uc.pCursor);
97539 ** the main database is read-only. The ephemeral
97556 ** can be used as zero-length data for OP_Insert. This is an optimization
97578 assert( pOp->p1>=0 );
97579 assert( pOp->p2>=0 );
97580 if( pOp->p3>0 ){
97583 assert( pOp->p2==0 ); /* Only used when number of columns is zero */
97584 assert( pOp->opcode==OP_OpenEphemeral );
97585 assert( aMem[pOp->p3].flags & MEM_Null );
97586 aMem[pOp->p3].n = 0;
97587 aMem[pOp->p3].z = "";
97589 pCx = p->apCsr[pOp->p1];
97590 if( pCx && !pCx->noReuse && ALWAYS(pOp->p2<=pCx->nField) ){
97594 assert( pCx->isEphemeral );
97595 pCx->seqCount = 0;
97596 pCx->cacheStatus = CACHE_STALE;
97597 rc = sqlite3BtreeClearTable(pCx->ub.pBtx, pCx->pgnoRoot, 0);
97599 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE);
97601 pCx->isEphemeral = 1;
97602 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx,
97603 BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
97606 rc = sqlite3BtreeBeginTrans(pCx->ub.pBtx, 1, 0);
97611 ** automatically created table with root-page 1 (an BLOB_INTKEY table).
97613 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
97614 assert( pOp->p4type==P4_KEYINFO );
97615 rc = sqlite3BtreeCreateTable(pCx->ub.pBtx, &pCx->pgnoRoot,
97616 BTREE_BLOBKEY | pOp->p5);
97618 assert( pCx->pgnoRoot==SCHEMA_ROOT+1 );
97619 assert( pKeyInfo->db==db );
97620 assert( pKeyInfo->enc==ENC(db) );
97621 rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR,
97622 pKeyInfo, pCx->uc.pCursor);
97624 pCx->isTable = 0;
97626 pCx->pgnoRoot = SCHEMA_ROOT;
97627 rc = sqlite3BtreeCursor(pCx->ub.pBtx, SCHEMA_ROOT, BTREE_WRCSR,
97628 0, pCx->uc.pCursor);
97629 pCx->isTable = 1;
97632 pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
97634 sqlite3BtreeClose(pCx->ub.pBtx);
97639 pCx->nullRow = 1;
97647 ** tables using an external merge-sort algorithm.
97649 ** If argument P3 is non-zero, then it indicates that the sorter may
97656 assert( pOp->p1>=0 );
97657 assert( pOp->p2>=0 );
97658 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER);
97660 pCx->pKeyInfo = pOp->p4.pKeyInfo;
97661 assert( pCx->pKeyInfo->db==db );
97662 assert( pCx->pKeyInfo->enc==ENC(db) );
97663 rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
97677 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97678 pC = p->apCsr[pOp->p1];
97680 if( (pC->seqCount++)==0 ){
97694 ** A pseudo-table created by this opcode is used to hold a single
97697 ** is the only cursor opcode that works with a pseudo-table.
97700 ** the pseudo-table. If P2 is 0 or negative then the pseudo-cursor
97706 assert( pOp->p1>=0 );
97707 assert( pOp->p3>=0 );
97708 pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO);
97710 pCx->nullRow = 1;
97711 pCx->seekResult = pOp->p2;
97712 pCx->isTable = 1;
97713 /* Give this pseudo-cursor a fake BtCursor pointer so that pCx
97715 ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto()
97717 pCx->uc.pCursor = sqlite3BtreeFakeValidCursor();
97718 assert( pOp->p5==0 );
97725 ** currently open, this instruction is a no-op.
97728 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97729 sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
97730 p->apCsr[pOp->p1] = 0;
97739 ** table or index for cursor P1 are used. P4 is a 64-bit integer
97742 ** by the cursor. The high-order bit is set if any column after
97747 pC = p->apCsr[pOp->p1];
97748 assert( pC->eCurType==CURTYPE_BTREE );
97749 pC->maskUsed = *(u64*)pOp->p4.pI64;
97757 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
97784 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
97802 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
97820 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
97856 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
97857 assert( pOp->p2!=0 );
97858 pC = p->apCsr[pOp->p1];
97860 assert( pC->eCurType==CURTYPE_BTREE );
97864 assert( pC->isOrdered );
97865 assert( pC->uc.pCursor!=0 );
97866 oc = pOp->opcode;
97868 pC->nullRow = 0;
97870 pC->seekOp = pOp->opcode;
97873 pC->deferredMoveto = 0;
97874 pC->cacheStatus = CACHE_STALE;
97875 if( pC->isTable ){
97878 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
97884 pIn3 = &aMem[pOp->p3];
97885 flags3 = pIn3->flags;
97890 newType = pIn3->flags; /* Record the type after applying numeric affinity */
97891 pIn3->flags = flags3; /* But convert the type back to its original */
97902 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
97907 c = sqlite3IntFloatCompare(iKey, pIn3->u.r);
97913 ** (x > 4.9) -> (x >= 5)
97914 ** (x <= 4.9) -> (x < 5)
97917 assert( OP_SeekGE==(OP_SeekGT-1) );
97918 assert( OP_SeekLT==(OP_SeekLE-1) );
97920 if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
97932 rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
97933 pC->movetoTarget = iKey; /* Used by OP_Delete */
97943 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
97945 assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
97947 assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT );
97948 assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT );
97955 nField = pOp->p4.i;
97956 assert( pOp->p4type==P4_INT32 );
97958 r.pKeyInfo = pC->pKeyInfo;
97963 ** r.default_rc = -1;
97968 r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
97969 assert( oc!=OP_SeekGT || r.default_rc==-1 );
97970 assert( oc!=OP_SeekLE || r.default_rc==-1 );
97974 r.aMem = &aMem[pOp->p3];
97980 if( i>0 ) REGISTER_TRACE(pOp->p3+i, &r.aMem[i]);
97985 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res);
98000 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
98016 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
98029 res = sqlite3BtreeEof(pC->uc.pCursor);
98033 assert( pOp->p2>0 );
98046 ** Synopsis: Scan-ahead up to P1 rows
98058 ** This opcode helps to optimize IN operators on a multi-column index
98061 ** of the b-tree instead. A correct answer is obtained if this opcode
98062 ** is omitted or is a no-op.
98069 ** then this opcode is a no-op and control passes through into the OP_SeekGE.
98081 ** This.P5 is true (non-zero) then a jump is made to This.P2. The P5==0
98121 /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the
98124 assert( pOp->p2>=(int)(pOp-aOp)+2 );
98126 if( pOp->p5==0 ){
98128 assert( pOp[1].p1==aOp[pOp->p2-1].p1 );
98129 assert( pOp[1].p2==aOp[pOp->p2-1].p2 );
98130 assert( pOp[1].p3==aOp[pOp->p2-1].p3 );
98131 assert( aOp[pOp->p2-1].opcode==OP_IdxGT
98132 || aOp[pOp->p2-1].opcode==OP_IdxGE );
98133 testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
98136 assert( pOp->p2==(int)(pOp-aOp)+2 );
98137 assert( aOp[pOp->p2-1].opcode==OP_SeekGE );
98141 assert( pOp->p1>0 );
98142 pC = p->apCsr[pOp[1].p1];
98144 assert( pC->eCurType==CURTYPE_BTREE );
98145 assert( !pC->isTable );
98146 if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){
98148 if( db->flags&SQLITE_VdbeTrace ){
98149 printf("... cursor not valid - fall through\n");
98154 nStep = pOp->p1;
98156 r.pKeyInfo = pC->pKeyInfo;
98173 if( res>0 && pOp->p5==0 ){
98177 if( db->flags&SQLITE_VdbeTrace ){
98178 printf("... %d steps and then skip\n", pOp->p1 - nStep);
98188 if( db->flags&SQLITE_VdbeTrace ){
98189 printf("... %d steps and then success\n", pOp->p1 - nStep);
98198 if( db->flags&SQLITE_VdbeTrace ){
98199 printf("... fall through after %d steps\n", pOp->p1);
98205 nStep--;
98206 pC->cacheStatus = CACHE_STALE;
98207 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
98232 ** early, thus saving work. This is part of the IN-early-out optimization.
98234 ** P1 must be a valid b-tree cursor.
98238 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98239 pC = p->apCsr[pOp->p1];
98241 assert( pOp->p3>=pOp->p2 );
98242 if( pC->seekHit<pOp->p2 ){
98244 if( db->flags&SQLITE_VdbeTrace ){
98245 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
98248 pC->seekHit = pOp->p2;
98249 }else if( pC->seekHit>pOp->p3 ){
98251 if( db->flags&SQLITE_VdbeTrace ){
98252 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
98255 pC->seekHit = pOp->p3;
98269 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98270 pCur = p->apCsr[pOp->p1];
98271 VdbeBranchTaken(pCur==0 || pCur->nullRow, 2);
98272 if( pCur==0 || pCur->nullRow ){
98333 ** This opcode is used in IN clause processing for a multi-column key.
98335 ** left-most element, and if there are no matches on the most recent
98354 ** record are not-NULL then a check is done to determine if any row in the
98370 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98371 pC = p->apCsr[pOp->p1];
98374 if( db->flags&SQLITE_VdbeTrace ){
98375 printf("seekHit is %d\n", pC->seekHit);
98378 if( pC->seekHit>=pOp->p4.i ) break;
98392 if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
98395 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98396 assert( pOp->p4type==P4_INT32 );
98397 pC = p->apCsr[pOp->p1];
98400 pC->seekOp = pOp->opcode;
98402 r.aMem = &aMem[pOp->p3];
98403 assert( pC->eCurType==CURTYPE_BTREE );
98404 assert( pC->uc.pCursor!=0 );
98405 assert( pC->isTable==0 );
98406 r.nField = (u16)pOp->p4.i;
98409 r.pKeyInfo = pC->pKeyInfo;
98415 if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
98418 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult);
98421 assert( r.aMem->flags & MEM_Blob );
98422 assert( pOp->opcode!=OP_NoConflict );
98426 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
98428 sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
98429 pIdxKey->default_rc = 0;
98430 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult);
98436 alreadyExists = (pC->seekResult==0);
98437 pC->nullRow = 1-alreadyExists;
98438 pC->deferredMoveto = 0;
98439 pC->cacheStatus = CACHE_STALE;
98440 if( pOp->opcode==OP_Found ){
98448 if( pOp->opcode==OP_NoConflict ){
98460 if( pOp->opcode==OP_IfNoHope ){
98461 pC->seekHit = pOp->p4.i;
98483 ** (with arbitrary multi-value keys).
98502 ** P3 register to contain a non-integer value, in which case the jump is
98506 ** (with arbitrary multi-value keys).
98520 pIn3 = &aMem[pOp->p3];
98521 testcase( pIn3->flags & MEM_Int );
98522 testcase( pIn3->flags & MEM_IntReal );
98523 testcase( pIn3->flags & MEM_Real );
98524 testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
98525 if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
98526 /* If pIn3->u.i does not contain an integer, compute iKey as the
98540 pIn3 = &aMem[pOp->p3];
98541 assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
98542 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98543 iKey = pIn3->u.i;
98545 pC = p->apCsr[pOp->p1];
98548 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
98550 assert( pC->isTable );
98551 assert( pC->eCurType==CURTYPE_BTREE );
98552 pCrsr = pC->uc.pCursor;
98557 pC->movetoTarget = iKey; /* Used by OP_Delete */
98558 pC->nullRow = 0;
98559 pC->cacheStatus = CACHE_STALE;
98560 pC->deferredMoveto = 0;
98562 pC->seekResult = res;
98565 if( pOp->p2==0 ){
98584 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98585 assert( p->apCsr[pOp->p1]!=0 );
98586 assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
98588 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
98621 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98622 pC = p->apCsr[pOp->p1];
98624 assert( pC->isTable );
98625 assert( pC->eCurType==CURTYPE_BTREE );
98626 assert( pC->uc.pCursor!=0 );
98629 ** thing) is obtained in a two-step algorithm.
98639 ** and try again, up to 100 times.
98641 assert( pC->isTable );
98653 if( !pC->useRandomRowid ){
98654 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
98659 v = 1; /* IMP: R-61914-48074 */
98661 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
98662 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98664 pC->useRandomRowid = 1;
98666 v++; /* IMP: R-29538-34987 */
98672 if( pOp->p3 ){
98674 assert( pOp->p3>0 );
98675 if( p->pFrame ){
98676 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
98678 assert( pOp->p3<=pFrame->nMem );
98679 pMem = &pFrame->aMem[pOp->p3];
98682 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
98683 pMem = &aMem[pOp->p3];
98688 REGISTER_TRACE(pOp->p3, pMem);
98690 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
98691 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
98692 rc = SQLITE_FULL; /* IMP: R-17817-00630 */
98695 if( v<pMem->u.i+1 ){
98696 v = pMem->u.i + 1;
98698 pMem->u.i = v;
98701 if( pC->useRandomRowid ){
98702 /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
98706 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
98712 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
98715 && (++cnt<100));
98718 rc = SQLITE_FULL; /* IMP: R-38219-53002 */
98721 assert( v>0 ); /* EV: R-40812-03570 */
98723 pC->deferredMoveto = 0;
98724 pC->cacheStatus = CACHE_STALE;
98726 pOut->u.i = v;
98755 ** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked
98758 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
98759 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
98772 const char *zDb; /* database name - used by the update hook */
98773 Table *pTab; /* Table structure - used by update and pre-update hooks */
98776 pData = &aMem[pOp->p2];
98777 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98779 pC = p->apCsr[pOp->p1];
98781 assert( pC->eCurType==CURTYPE_BTREE );
98782 assert( pC->deferredMoveto==0 );
98783 assert( pC->uc.pCursor!=0 );
98784 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
98785 assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
98786 REGISTER_TRACE(pOp->p2, pData);
98789 pKey = &aMem[pOp->p3];
98790 assert( pKey->flags & MEM_Int );
98792 REGISTER_TRACE(pOp->p3, pKey);
98793 x.nKey = pKey->u.i;
98795 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
98796 assert( pC->iDb>=0 );
98797 zDb = db->aDb[pC->iDb].zDbSName;
98798 pTab = pOp->p4.pTab;
98799 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
98806 /* Invoke the pre-update hook, if any */
98808 if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
98809 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
98811 if( db->xUpdateCallback==0 || pTab->aCol==0 ){
98812 /* Prevent post-update hook from running in cases when it should not */
98816 if( pOp->p5 & OPFLAG_ISNOOP ) break;
98819 assert( (pOp->p5 & OPFLAG_LASTROWID)==0 || (pOp->p5 & OPFLAG_NCHANGE)!=0 );
98820 if( pOp->p5 & OPFLAG_NCHANGE ){
98821 p->nChange++;
98822 if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
98824 assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 );
98825 x.pData = pData->z;
98826 x.nData = pData->n;
98827 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
98828 if( pData->flags & MEM_Zero ){
98829 x.nZero = pData->u.nZero;
98835 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
98836 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
98839 pC->deferredMoveto = 0;
98840 pC->cacheStatus = CACHE_STALE;
98843 /* Invoke the update-hook if required. */
98846 assert( db->xUpdateCallback!=0 );
98847 assert( pTab->aCol!=0 );
98848 db->xUpdateCallback(db->pUpdateArg,
98849 (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
98850 zDb, pTab->zName, x.nKey);
98858 ** of table - intkey or index. This opcode is used as part of copying
98871 assert( pOp[1].opcode==OP_Insert || pOp->p3==0 );
98872 assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 );
98874 pDest = p->apCsr[pOp->p1];
98875 pSrc = p->apCsr[pOp->p2];
98876 iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0;
98877 rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey);
98889 ** the next Next instruction will be a no-op. As a result, in this case
98904 ** pre-update-hook for deletes is run, but the btree is otherwise unchanged.
98908 ** P1 must not be pseudo-table. It has to be a real table with
98912 ** the update or pre-update hook, or both, may be invoked. The P1 cursor must
98914 ** this case. Specifically, if one is configured, the pre-update hook is
98915 ** invoked if P4 is not NULL. The update-hook is invoked if one is configured,
98928 opflags = pOp->p2;
98929 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
98930 pC = p->apCsr[pOp->p1];
98932 assert( pC->eCurType==CURTYPE_BTREE );
98933 assert( pC->uc.pCursor!=0 );
98934 assert( pC->deferredMoveto==0 );
98938 if( pOp->p4type==P4_TABLE
98939 && HasRowid(pOp->p4.pTab)
98940 && pOp->p5==0
98941 && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
98944 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
98946 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98947 assert( CORRUPT_DB || pC->movetoTarget==iKey );
98951 /* If the update-hook or pre-update-hook will be invoked, set zDb to
98956 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
98957 assert( pC->iDb>=0 );
98958 assert( pOp->p4.pTab!=0 );
98959 zDb = db->aDb[pC->iDb].zDbSName;
98960 pTab = pOp->p4.pTab;
98961 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
98962 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98970 /* Invoke the pre-update-hook if required. */
98971 assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
98972 if( db->xPreUpdateCallback && pTab ){
98975 || (aMem[pOp->p3].flags & MEM_Int)
98979 zDb, pTab, pC->movetoTarget,
98980 pOp->p3, -1
98987 assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
98992 if( p->pFrame==0 ){
98993 if( pC->isEphemeral==0
98994 && (pOp->p5 & OPFLAG_AUXDELETE)==0
98995 && (pC->wrFlag & OPFLAG_FORDELETE)==0
98999 if( pOp->p2 & OPFLAG_NCHANGE ){
99000 nExtraDelete--;
99005 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
99006 pC->cacheStatus = CACHE_STALE;
99008 pC->seekResult = 0;
99011 /* Invoke the update-hook if required. */
99013 p->nChange++;
99014 if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){
99015 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
99016 pC->movetoTarget);
99017 assert( pC->iDb>=0 );
99031 sqlite3VdbeSetChanges(db, p->nChange);
99032 p->nChange = 0;
99056 pC = p->apCsr[pOp->p1];
99058 assert( pOp->p4type==P4_INT32 );
99059 pIn3 = &aMem[pOp->p3];
99060 nKeyCol = pOp->p4.i;
99076 ** a register that is the source for a pseudo-table cursor created using
99077 ** OpenPseudo. That pseudo-table cursor is the one that is identified by
99084 pOut = &aMem[pOp->p2];
99085 pC = p->apCsr[pOp->p1];
99088 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
99089 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99091 p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
99108 ** of a real table, not a pseudo-table.
99112 ** register will be invalidated as soon as the cursor moves - including
99130 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99131 pC = p->apCsr[pOp->p1];
99133 assert( pC->eCurType==CURTYPE_BTREE );
99135 assert( pC->nullRow==0 );
99136 assert( pC->uc.pCursor!=0 );
99137 pCrsr = pC->uc.pCursor;
99147 assert( pC->deferredMoveto==0 );
99151 if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
99157 if( !pOp->p3 ) Deephemeralize(pOut);
99159 REGISTER_TRACE(pOp->p2, pOut);
99180 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99181 pC = p->apCsr[pOp->p1];
99183 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
99184 if( pC->nullRow ){
99185 pOut->flags = MEM_Null;
99187 }else if( pC->deferredMoveto ){
99188 v = pC->movetoTarget;
99190 }else if( pC->eCurType==CURTYPE_VTAB ){
99191 assert( pC->uc.pVCur!=0 );
99192 pVtab = pC->uc.pVCur->pVtab;
99193 pModule = pVtab->pModule;
99194 assert( pModule->xRowid );
99195 rc = pModule->xRowid(pC->uc.pVCur, &v);
99200 assert( pC->eCurType==CURTYPE_BTREE );
99201 assert( pC->uc.pCursor!=0 );
99204 if( pC->nullRow ){
99205 pOut->flags = MEM_Null;
99208 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
99210 pOut->u.i = v;
99221 ** pseudo-cursor that always returns NULL for every column.
99226 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99227 pC = p->apCsr[pOp->p1];
99230 ** pseudo-cursor that always gives null rows. */
99231 pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
99233 pC->seekResult = 0;
99234 pC->isTable = 1;
99235 pC->noReuse = 1;
99236 pC->uc.pCursor = sqlite3BtreeFakeValidCursor();
99238 pC->nullRow = 1;
99239 pC->cacheStatus = CACHE_STALE;
99240 if( pC->eCurType==CURTYPE_BTREE ){
99241 assert( pC->uc.pCursor!=0 );
99242 sqlite3BtreeClearCursor(pC->uc.pCursor);
99245 if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
99278 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99279 pC = p->apCsr[pOp->p1];
99281 assert( pC->eCurType==CURTYPE_BTREE );
99282 pCrsr = pC->uc.pCursor;
99286 pC->seekOp = pOp->opcode;
99288 if( pOp->opcode==OP_SeekEnd ){
99289 assert( pOp->p2==0 );
99290 pC->seekResult = -1;
99296 pC->nullRow = (u8)res;
99297 pC->deferredMoveto = 0;
99298 pC->cacheStatus = CACHE_STALE;
99300 if( pOp->p2>0 ){
99310 ** with cursor P1 and let X be 10*log2(N) if N is positive or -1
99321 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99322 assert( pOp->p4type==P4_INT32 );
99323 assert( pOp->p3>=-1 && pOp->p3<=640*2 );
99324 assert( pOp->p4.i>=-1 && pOp->p4.i<=640*2 );
99325 pC = p->apCsr[pOp->p1];
99327 pCrsr = pC->uc.pCursor;
99332 sz = -1; /* -Infinity encoding */
99338 res = sz>=pOp->p3 && sz<=pOp->p4.i;
99370 sqlite3_search_count--;
99372 p->aCounter[SQLITE_STMTSTATUS_SORT]++;
99396 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99397 assert( pOp->p5==0 );
99398 assert( pOp->p2>=0 && pOp->p2<p->nOp );
99400 pC = p->apCsr[pOp->p1];
99402 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
99405 pC->seekOp = OP_Rewind;
99410 assert( pC->eCurType==CURTYPE_BTREE );
99411 pCrsr = pC->uc.pCursor;
99414 pC->deferredMoveto = 0;
99415 pC->cacheStatus = CACHE_STALE;
99418 pC->nullRow = (u8)res;
99419 if( pOp->p2>0 ){
99437 ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have
99446 ** number P5-1 in the prepared statement is incremented.
99462 ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is
99471 ** number P5-1 in the prepared statement is incremented.
99483 pC = p->apCsr[pOp->p1];
99489 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99490 assert( pOp->p5==0
99491 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
99492 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
99493 pC = p->apCsr[pOp->p1];
99495 assert( pC->deferredMoveto==0 );
99496 assert( pC->eCurType==CURTYPE_BTREE );
99497 assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
99498 || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope
99499 || pC->seekOp==OP_NullRow);
99500 rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
99504 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99505 assert( pOp->p5==0
99506 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
99507 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
99508 pC = p->apCsr[pOp->p1];
99510 assert( pC->deferredMoveto==0 );
99511 assert( pC->eCurType==CURTYPE_BTREE );
99512 assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
99513 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
99514 || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
99515 || pC->seekOp==OP_IfNoHope);
99516 rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
99519 pC->cacheStatus = CACHE_STALE;
99522 pC->nullRow = 0;
99523 p->aCounter[pOp->p5]++;
99531 pC->nullRow = 1;
99547 ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
99567 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99568 pC = p->apCsr[pOp->p1];
99572 pIn2 = &aMem[pOp->p2];
99573 assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
99574 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
99575 assert( pC->eCurType==CURTYPE_BTREE );
99576 assert( pC->isTable==0 );
99579 x.nKey = pIn2->n;
99580 x.pKey = pIn2->z;
99581 x.aMem = aMem + pOp->p3;
99582 x.nMem = (u16)pOp->p4.i;
99583 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
99584 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
99585 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
99587 assert( pC->deferredMoveto==0 );
99588 pC->cacheStatus = CACHE_STALE;
99603 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99604 pC = p->apCsr[pOp->p1];
99608 pIn2 = &aMem[pOp->p2];
99609 assert( pIn2->flags & MEM_Blob );
99610 assert( pC->isTable==0 );
99631 ** this (self-correcting and non-critical) error if in writable_schema mode.
99639 assert( pOp->p3>0 );
99640 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
99641 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99642 pC = p->apCsr[pOp->p1];
99644 assert( pC->eCurType==CURTYPE_BTREE );
99646 pCrsr = pC->uc.pCursor;
99648 r.pKeyInfo = pC->pKeyInfo;
99649 r.nField = (u16)pOp->p3;
99651 r.aMem = &aMem[pOp->p2];
99657 }else if( pOp->p5 && !sqlite3WritableSchema(db) ){
99661 assert( pC->deferredMoveto==0 );
99662 pC->cacheStatus = CACHE_STALE;
99663 pC->seekResult = 0;
99680 ** is non-zero, then reading column a(i)-1 from cursor P3 is
99701 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99702 pC = p->apCsr[pOp->p1];
99704 assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) );
99705 assert( pC->uc.pCursor!=0 );
99706 assert( pC->isTable==0 || IsNullCursor(pC) );
99707 assert( pC->deferredMoveto==0 );
99708 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
99719 if( !pC->nullRow ){
99721 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
99725 if( pOp->opcode==OP_DeferredSeek ){
99726 assert( pOp->p3>=0 && pOp->p3<p->nCursor );
99727 pTabCur = p->apCsr[pOp->p3];
99729 assert( pTabCur->eCurType==CURTYPE_BTREE );
99730 assert( pTabCur->uc.pCursor!=0 );
99731 assert( pTabCur->isTable );
99732 pTabCur->nullRow = 0;
99733 pTabCur->movetoTarget = rowid;
99734 pTabCur->deferredMoveto = 1;
99735 pTabCur->cacheStatus = CACHE_STALE;
99736 assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
99737 assert( !pTabCur->isEphemeral );
99738 pTabCur->ub.aAltMap = pOp->p4.ai;
99739 assert( !pC->isEphemeral );
99740 pTabCur->pAltCursor = pC;
99743 pOut->u.i = rowid;
99746 assert( pOp->opcode==OP_IdxRowid );
99747 sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
99756 ** already occurred, this instruction is a no-op.
99761 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99762 pC = p->apCsr[pOp->p1];
99763 if( pC->deferredMoveto ){
99822 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99823 pC = p->apCsr[pOp->p1];
99825 assert( pC->isOrdered );
99826 assert( pC->eCurType==CURTYPE_BTREE );
99827 assert( pC->uc.pCursor!=0);
99828 assert( pC->deferredMoveto==0 );
99829 assert( pOp->p4type==P4_INT32 );
99830 r.pKeyInfo = pC->pKeyInfo;
99831 r.nField = (u16)pOp->p4.i;
99832 if( pOp->opcode<OP_IdxLT ){
99833 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
99834 r.default_rc = -1;
99836 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
99839 r.aMem = &aMem[pOp->p3];
99845 REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
99856 assert( pC->eCurType==CURTYPE_BTREE );
99857 pCur = pC->uc.pCursor;
99875 if( (pOp->opcode&1)==(OP_IdxLT&1) ){
99876 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
99877 res = -res;
99879 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
99900 ** value of the root page that moved - its value before the move occurred -
99911 ** and non-autovacuum modes.
99920 assert( p->readOnly==0 );
99921 assert( pOp->p1>1 );
99923 pOut->flags = MEM_Null;
99924 if( db->nVdbeRead > db->nVDestroy+1 ){
99926 p->errorAction = OE_Abort;
99929 iDb = pOp->p3;
99930 assert( DbMaskTest(p->btreeMask, iDb) );
99932 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
99933 pOut->flags = MEM_Int;
99934 pOut->u.i = iMoved;
99938 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
99958 ** If the P3 value is non-zero, then the row change count is incremented
99970 assert( p->readOnly==0 );
99971 assert( DbMaskTest(p->btreeMask, pOp->p2) );
99972 rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);
99973 if( pOp->p3 ){
99974 p->nChange += nChange;
99975 if( pOp->p3>0 ){
99976 assert( memIsValid(&aMem[pOp->p3]) );
99977 memAboutToChange(p, &aMem[pOp->p3]);
99978 aMem[pOp->p3].u.i += nChange;
99996 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
99997 pC = p->apCsr[pOp->p1];
100000 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
100002 assert( pC->eCurType==CURTYPE_BTREE );
100003 assert( pC->isEphemeral );
100004 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
100013 ** Allocate a new b-tree in the main database file if P1==0 or in the
100017 ** The root page number of the new b-tree is stored in register P2.
100026 assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
100027 assert( pOp->p1>=0 && pOp->p1<db->nDb );
100028 assert( DbMaskTest(p->btreeMask, pOp->p1) );
100029 assert( p->readOnly==0 );
100030 pDb = &db->aDb[pOp->p1];
100031 assert( pDb->pBt!=0 );
100032 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
100034 pOut->u.i = pgno;
100047 ** 0x0002 Set db->nAnalysisLimit to P2 while the statements in
100060 db->nSqlExec++;
100063 xAuth = db->xAuth;
100065 mTrace = db->mTrace;
100066 savedAnalysisLimit = db->nAnalysisLimit;
100067 if( pOp->p1 & 0x0001 ){
100069 db->xAuth = 0;
100071 db->mTrace = 0;
100073 if( pOp->p1 & 0x0002 ){
100074 db->nAnalysisLimit = pOp->p2;
100076 rc = sqlite3_exec(db, pOp->p4.z, 0, 0, &zErr);
100077 db->nSqlExec--;
100079 db->xAuth = xAuth;
100081 db->mTrace = mTrace;
100082 db->nAnalysisLimit = savedAnalysisLimit;
100099 ** then runs the new virtual machine. It is thus a re-entrant opcode.
100112 for(iDb=0; iDb<db->nDb; iDb++){
100113 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
100117 iDb = pOp->p1;
100118 assert( iDb>=0 && iDb<db->nDb );
100120 || db->mallocFailed
100121 || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) );
100124 if( pOp->p4.z==0 ){
100125 sqlite3SchemaClear(db->aDb[iDb].pSchema);
100126 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
100127 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
100128 db->mDbFlags |= DBFLAG_SchemaChange;
100129 p->expired = 0;
100136 initData.pzErrMsg = &p->zErrMsg;
100138 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
100141 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
100145 assert( db->init.busy==0 );
100146 db->init.busy = 1;
100149 assert( !db->mallocFailed );
100153 /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse
100159 db->init.busy = 0;
100180 assert( pOp->p1>=0 && pOp->p1<db->nDb );
100181 rc = sqlite3AnalysisLoad(db, pOp->p1);
100189 ** Remove the internal (in-memory) data structures that describe
100197 sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
100203 ** Remove the internal (in-memory) data structures that describe
100211 sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
100217 ** Remove the internal (in-memory) data structures that describe
100225 sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
100257 assert( p->bIsReader );
100258 assert( pOp->p4type==P4_INTARRAY );
100259 nRoot = pOp->p2;
100260 aRoot = pOp->p4.ai;
100264 assert( pOp->p1>0 && (pOp->p1+1)<=(p->nMem+1 - p->nCursor) );
100265 pnErr = &aMem[pOp->p1];
100266 assert( (pnErr->flags & MEM_Int)!=0 );
100267 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
100268 pIn1 = &aMem[pOp->p1+1];
100269 assert( pOp->p5<db->nDb );
100270 assert( DbMaskTest(p->btreeMask, pOp->p5) );
100271 rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1],
100272 &aMem[pOp->p3], nRoot, (int)pnErr->u.i+1, &nErr, &z);
100280 pnErr->u.i -= nErr-1;
100281 sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
100298 pIn1 = &aMem[pOp->p1];
100299 pIn2 = &aMem[pOp->p2];
100300 assert( (pIn2->flags & MEM_Int)!=0 );
100301 if( (pIn1->flags & MEM_Blob)==0 ){
100305 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
100320 pIn1 = &aMem[pOp->p1];
100321 assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
100322 if( (pIn1->flags & MEM_Blob)==0
100323 || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
100332 sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
100340 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
100349 ** must have P4==0, the final set must have P4==-1, and for all other sets
100354 ** (b) when P4==-1 there is no need to insert the value, as it will
100364 pIn1 = &aMem[pOp->p1];
100365 pIn3 = &aMem[pOp->p3];
100366 iSet = pOp->p4.i;
100367 assert( pIn3->flags&MEM_Int );
100372 if( (pIn1->flags & MEM_Blob)==0 ){
100376 assert( pOp->p4type==P4_INT32 );
100377 assert( iSet==-1 || iSet>=0 );
100379 exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
100384 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
100397 ** cell in an array of values used as arguments to the sub-program. P2
100398 ** contains the address to jump to if the sub-program throws an IGNORE
100403 ** memory required by the sub-vdbe at runtime.
100407 ** If P5 is non-zero, then recursive program invocation is enabled.
100410 int nMem; /* Number of memory registers for sub-program */
100411 int nByte; /* Bytes of runtime space required for sub-program */
100416 SubProgram *pProgram; /* Sub-program to execute */
100419 pProgram = pOp->p4.pProgram;
100420 pRt = &aMem[pOp->p3];
100421 assert( pProgram->nOp>0 );
100424 ** disabled for backwards compatibility (p5 is set if this sub-program
100434 if( pOp->p5 ){
100435 t = pProgram->token;
100436 for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
100440 if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
100450 if( (pRt->flags&MEM_Blob)==0 ){
100456 nMem = pProgram->nMem + pProgram->nCsr;
100458 if( pProgram->nCsr==0 ) nMem++;
100461 + pProgram->nCsr * sizeof(VdbeCursor*)
100462 + (pProgram->nOp + 7)/8;
100468 pRt->flags = MEM_Blob|MEM_Dyn;
100469 pRt->z = (char*)pFrame;
100470 pRt->n = nByte;
100471 pRt->xDel = sqlite3VdbeFrameMemDel;
100473 pFrame->v = p;
100474 pFrame->nChildMem = nMem;
100475 pFrame->nChildCsr = pProgram->nCsr;
100476 pFrame->pc = (int)(pOp - aOp);
100477 pFrame->aMem = p->aMem;
100478 pFrame->nMem = p->nMem;
100479 pFrame->apCsr = p->apCsr;
100480 pFrame->nCursor = p->nCursor;
100481 pFrame->aOp = p->aOp;
100482 pFrame->nOp = p->nOp;
100483 pFrame->token = pProgram->token;
100485 pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
100488 pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
100490 pMem->flags = MEM_Undefined;
100491 pMem->db = db;
100494 pFrame = (VdbeFrame*)pRt->z;
100495 assert( pRt->xDel==sqlite3VdbeFrameMemDel );
100496 assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
100497 || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
100498 assert( pProgram->nCsr==pFrame->nChildCsr );
100499 assert( (int)(pOp - aOp)==pFrame->pc );
100502 p->nFrame++;
100503 pFrame->pParent = p->pFrame;
100504 pFrame->lastRowid = db->lastRowid;
100505 pFrame->nChange = p->nChange;
100506 pFrame->nDbChange = p->db->nChange;
100507 assert( pFrame->pAuxData==0 );
100508 pFrame->pAuxData = p->pAuxData;
100509 p->pAuxData = 0;
100510 p->nChange = 0;
100511 p->pFrame = pFrame;
100512 p->aMem = aMem = VdbeFrameMem(pFrame);
100513 p->nMem = pFrame->nChildMem;
100514 p->nCursor = (u16)pFrame->nChildCsr;
100515 p->apCsr = (VdbeCursor **)&aMem[p->nMem];
100516 pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
100517 memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
100518 p->aOp = aOp = pProgram->aOp;
100519 p->nOp = pProgram->nOp;
100525 for(i=0; i<p->nMem; i++){
100526 aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */
100531 pOp = &aOp[-1];
100537 ** This opcode is only ever present in sub-programs called via the
100551 pFrame = p->pFrame;
100552 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
100564 ** If P1 is non-zero, the database constraint counter is incremented
100569 if( db->flags & SQLITE_DeferFKs ){
100570 db->nDeferredImmCons += pOp->p2;
100571 }else if( pOp->p1 ){
100572 db->nDeferredCons += pOp->p2;
100574 p->nFkConstraint += pOp->p2;
100582 ** This opcode tests if a foreign key constraint-counter is currently zero.
100586 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
100588 ** zero, the jump is taken if the statement constraint-counter is zero
100592 if( pOp->p1 ){
100593 VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
100594 if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
100596 VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
100597 if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
100609 ** within a sub-program). Set the value of register P1 to the maximum of
100617 if( p->pFrame ){
100618 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
100619 pIn1 = &pFrame->aMem[pOp->p1];
100621 pIn1 = &aMem[pOp->p1];
100625 pIn2 = &aMem[pOp->p2];
100627 if( pIn1->u.i<pIn2->u.i){
100628 pIn1->u.i = pIn2->u.i;
100635 ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
100645 pIn1 = &aMem[pOp->p1];
100646 assert( pIn1->flags&MEM_Int );
100647 VdbeBranchTaken( pIn1->u.i>0, 2);
100648 if( pIn1->u.i>0 ){
100649 pIn1->u.i -= pOp->p3;
100656 ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
100669 ** and r[P2] is set to -1.
100675 pIn1 = &aMem[pOp->p1];
100676 pIn3 = &aMem[pOp->p3];
100678 assert( pIn1->flags & MEM_Int );
100679 assert( pIn3->flags & MEM_Int );
100680 x = pIn1->u.i;
100681 if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){
100689 pOut->u.i = -1;
100691 pOut->u.i = x;
100697 ** Synopsis: if r[P1]!=0 then r[P1]--, goto P2
100701 ** If it is non-zero (negative or positive) and then also jump to P2.
100705 pIn1 = &aMem[pOp->p1];
100706 assert( pIn1->flags&MEM_Int );
100707 VdbeBranchTaken(pIn1->u.i<0, 2);
100708 if( pIn1->u.i ){
100709 if( pIn1->u.i>0 ) pIn1->u.i--;
100716 ** Synopsis: if (--r[P1])==0 goto P2
100722 pIn1 = &aMem[pOp->p1];
100723 assert( pIn1->flags&MEM_Int );
100724 if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--;
100725 VdbeBranchTaken(pIn1->u.i==0, 2);
100726 if( pIn1->u.i==0 ) goto jump_to_p2;
100775 assert( pOp->p4type==P4_FUNCDEF );
100776 n = pOp->p5;
100777 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
100778 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
100779 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
100781 (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
100783 pCtx->pMem = 0;
100784 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
100785 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
100786 pCtx->pFunc = pOp->p4.pFunc;
100787 pCtx->iOp = (int)(pOp - aOp);
100788 pCtx->pVdbe = p;
100789 pCtx->skipFlag = 0;
100790 pCtx->isError = 0;
100791 pCtx->enc = encoding;
100792 pCtx->argc = n;
100793 pOp->p4type = P4_FUNCCTX;
100794 pOp->p4.pCtx = pCtx;
100797 assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
100799 pOp->opcode = OP_AggStep1;
100808 assert( pOp->p4type==P4_FUNCCTX );
100809 pCtx = pOp->p4.pCtx;
100810 pMem = &aMem[pOp->p3];
100813 if( pOp->p1 ){
100816 assert( pMem->uTemp==0x1122e0e3 );
100819 pMem->uTemp = 0x1122e0e3;
100827 if( pCtx->pMem != pMem ){
100828 pCtx->pMem = pMem;
100829 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
100833 for(i=0; i<pCtx->argc; i++){
100834 assert( memIsValid(pCtx->argv[i]) );
100835 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
100839 pMem->n++;
100840 assert( pCtx->pOut->flags==MEM_Null );
100841 assert( pCtx->isError==0 );
100842 assert( pCtx->skipFlag==0 );
100844 if( pOp->p1 ){
100845 (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
100848 (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
100850 if( pCtx->isError ){
100851 if( pCtx->isError>0 ){
100852 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
100853 rc = pCtx->isError;
100855 if( pCtx->skipFlag ){
100856 assert( pOp[-1].opcode==OP_CollSeq );
100857 i = pOp[-1].p1;
100859 pCtx->skipFlag = 0;
100861 sqlite3VdbeMemRelease(pCtx->pOut);
100862 pCtx->pOut->flags = MEM_Null;
100863 pCtx->isError = 0;
100866 assert( pCtx->pOut->flags==MEM_Null );
100867 assert( pCtx->skipFlag==0 );
100900 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
100901 assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
100902 pMem = &aMem[pOp->p1];
100903 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
100905 if( pOp->p3 ){
100906 memAboutToChange(p, &aMem[pOp->p3]);
100907 rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
100908 pMem = &aMem[pOp->p3];
100912 rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
100921 REGISTER_TRACE((int)(pMem-aMem), pMem);
100928 ** Checkpoint database P1. This is a no-op if P1 is not currently in
100935 ** mem[P3+2] are initialized to -1.
100942 assert( p->readOnly==0 );
100944 aRes[1] = aRes[2] = -1;
100945 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
100946 || pOp->p2==SQLITE_CHECKPOINT_FULL
100947 || pOp->p2==SQLITE_CHECKPOINT_RESTART
100948 || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
100950 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
100956 for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
100973 ** Write a string containing the final journal-mode to register P2.
100985 eNew = pOp->p3;
100994 assert( pOp->p1>=0 && pOp->p1<db->nDb );
100995 assert( p->readOnly==0 );
100997 pBt = db->aDb[pOp->p1].pBt;
101012 || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
101020 if( !db->autoCommit || db->nVdbeRead>1 ){
101031 ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
101059 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
101060 pOut->z = (char *)sqlite3JournalModename(eNew);
101061 pOut->n = sqlite3Strlen30(pOut->z);
101062 pOut->enc = SQLITE_UTF8;
101080 assert( p->readOnly==0 );
101081 rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
101082 pOp->p2 ? &aMem[pOp->p2] : 0);
101098 assert( pOp->p1>=0 && pOp->p1<db->nDb );
101099 assert( DbMaskTest(p->btreeMask, pOp->p1) );
101100 assert( p->readOnly==0 );
101101 pBt = db->aDb[pOp->p1].pBt;
101120 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
101130 assert( pOp->p2==0 || pOp->p2==1 );
101131 if( !pOp->p1 ){
101132 sqlite3ExpirePreparedStatements(db, pOp->p2);
101134 p->expired = pOp->p2+1;
101146 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
101147 pC = p->apCsr[pOp->p1];
101149 assert( pC->eCurType==CURTYPE_BTREE );
101150 sqlite3BtreeCursorPin(pC->uc.pCursor);
101161 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
101162 pC = p->apCsr[pOp->p1];
101164 assert( pC->eCurType==CURTYPE_BTREE );
101165 sqlite3BtreeCursorUnpin(pC->uc.pCursor);
101174 ** the shared-cache feature is enabled.
101180 ** P2 contains the root-page of the table to lock.
101186 u8 isWriteLock = (u8)pOp->p3;
101187 if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
101188 int p1 = pOp->p1;
101189 assert( p1>=0 && p1<db->nDb );
101190 assert( DbMaskTest(p->btreeMask, p1) );
101192 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
101195 const char *z = pOp->p4.z;
101217 pVTab = pOp->p4.pVtab;
101219 if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
101239 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
101240 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
101241 rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
101244 assert( zTab || db->mallocFailed );
101246 rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
101261 db->nVDestroy++;
101262 rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
101263 db->nVDestroy--;
101264 assert( p->errorAction==OE_Abort && p->usesStmtJournal );
101283 assert( p->bIsReader );
101286 pVtab = pOp->p4.pVtab->pVtab;
101287 if( pVtab==0 || NEVER(pVtab->pModule==0) ){
101291 pModule = pVtab->pModule;
101292 rc = pModule->xOpen(pVtab, &pVCur);
101296 /* Initialize sqlite3_vtab_cursor base class */
101297 pVCur->pVtab = pVtab;
101300 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
101302 pCur->uc.pVCur = pVCur;
101303 pVtab->nRef++;
101305 assert( db->mallocFailed );
101306 pModule->xClose(pVCur);
101329 pOut = &aMem[pOp->p2];
101331 assert( pOp->p4type==P4_TABLEREF );
101332 pTab = pOp->p4.pTab;
101334 assert( pTab->nTabRef>0 );
101336 if( pTab->u.vtab.p==0 ) break;
101337 pVtab = pTab->u.vtab.p->pVtab;
101339 pModule = pVtab->pModule;
101341 assert( pModule->iVersion>=4 );
101342 assert( pModule->xIntegrity!=0 );
101343 sqlite3VtabLock(pTab->u.vtab.p);
101344 assert( pOp->p1>=0 && pOp->p1<db->nDb );
101345 rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
101346 pOp->p3, &zErr);
101347 sqlite3VtabUnlock(pTab->u.vtab.p);
101353 sqlite3VdbeMemSetStr(pOut, zErr, -1, SQLITE_UTF8, sqlite3_free);
101374 pC = p->apCsr[pOp->p1];
101377 pRhs->pCsr = pC->uc.pCursor;
101378 pRhs->pOut = &aMem[pOp->p3];
101380 pOut->flags = MEM_Null;
101420 pQuery = &aMem[pOp->p3];
101422 pCur = p->apCsr[pOp->p1];
101424 REGISTER_TRACE(pOp->p3, pQuery);
101426 assert( pCur->eCurType==CURTYPE_VTAB );
101427 pVCur = pCur->uc.pVCur;
101428 pVtab = pVCur->pVtab;
101429 pModule = pVtab->pModule;
101432 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
101433 nArg = (int)pArgc->u.i;
101434 iQuery = (int)pQuery->u.i;
101437 apArg = p->apArg;
101441 rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
101444 res = pModule->xEof(pVCur);
101445 pCur->nullRow = 0;
101456 ** Store in register P3 the value of the P2-th column of
101457 ** the current row of the virtual-table of cursor P1.
101474 VdbeCursor *pCur = p->apCsr[pOp->p1];
101476 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
101477 pDest = &aMem[pOp->p3];
101479 if( pCur->nullRow ){
101483 assert( pCur->eCurType==CURTYPE_VTAB );
101484 pVtab = pCur->uc.pVCur->pVtab;
101485 pModule = pVtab->pModule;
101486 assert( pModule->xColumn );
101493 assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
101494 if( pOp->p5 & OPFLAG_NOCHNG ){
101496 pDest->flags = MEM_Null|MEM_Zero;
101497 pDest->u.nZero = 0;
101501 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
101508 REGISTER_TRACE(pOp->p3, pDest);
101529 pCur = p->apCsr[pOp->p1];
101531 assert( pCur->eCurType==CURTYPE_VTAB );
101532 if( pCur->nullRow ){
101535 pVtab = pCur->uc.pVCur->pVtab;
101536 pModule = pVtab->pModule;
101537 assert( pModule->xNext );
101545 rc = pModule->xNext(pCur->uc.pVCur);
101548 res = pModule->xEof(pCur->uc.pVCur);
101570 isLegacy = (db->flags & SQLITE_LegacyAlter);
101571 db->flags |= SQLITE_LegacyAlter;
101572 pVtab = pOp->p4.pVtab->pVtab;
101573 pName = &aMem[pOp->p1];
101574 assert( pVtab->pModule->xRename );
101576 assert( p->readOnly==0 );
101577 REGISTER_TRACE(pOp->p1, pName);
101578 assert( pName->flags & MEM_Str );
101579 testcase( pName->enc==SQLITE_UTF8 );
101580 testcase( pName->enc==SQLITE_UTF16BE );
101581 testcase( pName->enc==SQLITE_UTF16LE );
101584 rc = pVtab->pModule->xRename(pVtab, pName->z);
101585 if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
101587 p->expired = 0;
101600 ** invocation. The value in register (P3+P2-1) corresponds to the
101630 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
101631 || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
101633 assert( p->readOnly==0 );
101634 if( db->mallocFailed ) goto no_mem;
101636 pVtab = pOp->p4.pVtab->pVtab;
101637 if( pVtab==0 || NEVER(pVtab->pModule==0) ){
101641 pModule = pVtab->pModule;
101642 nArg = pOp->p2;
101643 assert( pOp->p4type==P4_VTAB );
101644 if( ALWAYS(pModule->xUpdate) ){
101645 u8 vtabOnConflict = db->vtabOnConflict;
101646 apArg = p->apArg;
101647 pX = &aMem[pOp->p3];
101654 db->vtabOnConflict = pOp->p5;
101655 rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
101656 db->vtabOnConflict = vtabOnConflict;
101658 if( rc==SQLITE_OK && pOp->p1 ){
101659 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
101660 db->lastRowid = rowid;
101662 if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
101663 if( pOp->p5==OE_Ignore ){
101666 p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
101669 p->nChange++;
101684 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
101704 pBt = db->aDb[pOp->p1].pBt;
101706 if( pOp->p3 ){
101708 if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
101710 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
101725 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
101744 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
101753 ** purely non-deterministic. Some built-in date/time functions can be
101754 ** either deterministic of non-deterministic, depending on their arguments.
101755 ** When those function are used in a non-deterministic way, they will check
101766 assert( pOp->p4type==P4_FUNCCTX );
101767 pCtx = pOp->p4.pCtx;
101773 pOut = &aMem[pOp->p3];
101774 if( pCtx->pOut != pOut ){
101775 pCtx->pVdbe = p;
101776 pCtx->pOut = pOut;
101777 pCtx->enc = encoding;
101778 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
101780 assert( pCtx->pVdbe==p );
101784 for(i=0; i<pCtx->argc; i++){
101785 assert( memIsValid(pCtx->argv[i]) );
101786 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
101790 assert( pCtx->isError==0 );
101791 (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
101794 if( pCtx->isError ){
101795 if( pCtx->isError>0 ){
101797 rc = pCtx->isError;
101799 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
101800 pCtx->isError = 0;
101804 assert( (pOut->flags&MEM_Str)==0
101805 || pOut->enc==encoding
101806 || db->mallocFailed );
101809 REGISTER_TRACE(pOp->p3, pOut);
101820 pIn1 = &aMem[pOp->p1];
101821 pIn1->flags &= ~MEM_Subtype;
101832 pIn1 = &aMem[pOp->p1];
101833 pOut = &aMem[pOp->p2];
101834 if( pIn1->flags & MEM_Subtype ){
101835 sqlite3VdbeMemSetInt64(pOut, pIn1->eSubtype);
101849 pIn1 = &aMem[pOp->p1];
101850 pOut = &aMem[pOp->p2];
101851 if( pIn1->flags & MEM_Null ){
101852 pOut->flags &= ~MEM_Subtype;
101854 assert( pIn1->flags & MEM_Int );
101855 pOut->flags |= MEM_Subtype;
101856 pOut->eSubtype = (u8)(pIn1->u.i & 0xff);
101870 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
101871 pIn1 = &aMem[pOp->p1];
101872 assert( pIn1->flags & MEM_Blob );
101873 assert( pIn1->n>0 );
101876 if( db->flags&SQLITE_VdbeTrace ){
101878 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
101881 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
101884 h %= (pIn1->n*8);
101885 pIn1->z[h/8] |= 1<<(h&7);
101901 ** false positive - if the jump is taken when it should fall through.
101906 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
101907 pIn1 = &aMem[pOp->p1];
101908 assert( (pIn1->flags & MEM_Blob)!=0 );
101909 assert( pIn1->n >= 1 );
101912 if( db->flags&SQLITE_VdbeTrace ){
101914 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
101917 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
101920 h %= (pIn1->n*8);
101921 if( (pIn1->z[h/8] & (1<<(h&7)))==0 ){
101923 p->aCounter[SQLITE_STMTSTATUS_FILTER_HIT]++;
101926 p->aCounter[SQLITE_STMTSTATUS_FILTER_MISS]++;
101946 ** the UTF-8 string contained in P4 is emitted on the trace callback.
101965 ** The "--" string is broken up to prevent false-positives with srcck1.c.
101968 ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that
101970 ** using the X argument when X begins with "--" and invoking
101973 assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
101976 assert( pOp==p->aOp || pOp->opcode==OP_Trace );
101979 if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
101980 && p->minWriteFileFormat!=254 /* tag-20220401a */
101981 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
101984 if( db->mTrace & SQLITE_TRACE_LEGACY ){
101986 db->trace.xLegacy(db->pTraceArg, z);
101990 if( db->nVdbeExec>1 ){
101991 char *z = sqlite3MPrintf(db, "-- %s", zTrace);
101992 (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
101995 (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
101999 zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
102002 for(j=0; j<db->nDb; j++){
102003 if( DbMaskTest(p->btreeMask, j)==0 ) continue;
102004 sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace);
102009 if( (db->flags & SQLITE_SqlTrace)!=0
102010 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
102012 sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
102016 assert( pOp->p2>0 );
102017 if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
102018 if( pOp->opcode==OP_Trace ) break;
102019 for(i=1; i<p->nOp; i++){
102020 if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0;
102022 pOp->p1 = 0;
102024 pOp->p1++;
102025 p->aCounter[SQLITE_STMTSTATUS_RUN]++;
102035 ** expression refer to columns in the b-tree to which cursor P1 is pointing.
102040 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
102041 assert( pOp->p4type==P4_EXPR );
102042 pC = p->apCsr[pOp->p1];
102044 assert( pC->eCurType==CURTYPE_BTREE );
102045 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
102046 pOp->p4.pExpr, aMem);
102103 assert( pOp->p1>0 );
102104 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
102105 pMem = &aMem[pOp->p1];
102106 constMask = pOp->p3;
102107 for(i=0; i<pOp->p2; i++, pMem++){
102109 pMem->pScopyFrom = 0;
102110 if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
102126 ** the same as a no-op. This opcodesnever appears in a real VM program.
102129 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
102136 ** by 6 spaces. But the left-most 6 spaces have been removed to improve the
102158 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
102161 if( db->flags & SQLITE_VdbeTrace ){
102162 u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode];
102165 registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
102168 registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]);
102185 if( db->mallocFailed ){
102192 if( db->flags & SQLITE_VdbeTrace ){
102193 const char *zTrace = p->zSql;
102200 printf("ABORT-due-to-error (rc=%d): %s\n", rc, zTrace);
102203 if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
102206 p->rc = rc;
102210 (int)(pOp - aOp), p->zSql, p->zErrMsg);
102211 if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p);
102213 if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){
102214 db->flags |= SQLITE_CorruptRdOnly;
102218 sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
102238 while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
102239 nProgressLimit += db->nProgressOps;
102240 if( db->xProgress(db->pProgressArg) ){
102247 p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
102248 if( DbMaskNonZero(p->lockMask) ){
102252 || sqlite3_strlike("DELETE%",p->zSql,0)!=0
102276 assert( AtomicLoad(&db->u1.isInterrupted) );
102322 ** the b-tree cursor associated with blob handle p to point to row iRow.
102333 ** If an error does occur, then the b-tree cursor is closed. All subsequent
102340 Vdbe *v = (Vdbe *)p->pStmt;
102345 sqlite3VdbeMemSetInt64(&v->aMem[1], iRow);
102351 if( v->pc>4 ){
102352 v->pc = 4;
102353 assert( v->aOp[v->pc].opcode==OP_NotExists );
102356 rc = sqlite3_step(p->pStmt);
102359 VdbeCursor *pC = v->apCsr[0];
102362 assert( pC->eCurType==CURTYPE_BTREE );
102363 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
102364 testcase( pC->nHdrParsed==p->iCol );
102365 testcase( pC->nHdrParsed==p->iCol+1 );
102367 zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
102371 sqlite3_finalize(p->pStmt);
102372 p->pStmt = 0;
102374 p->iOffset = pC->aType[p->iCol + pC->nField];
102375 p->nByte = sqlite3VdbeSerialTypeLen(type);
102376 p->pCsr = pC->uc.pCursor;
102377 sqlite3BtreeIncrblobCursor(p->pCsr);
102383 }else if( p->pStmt ){
102384 rc = sqlite3_finalize(p->pStmt);
102385 p->pStmt = 0;
102387 zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
102390 zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
102410 int wrFlag, /* True -> read/write access, false -> read-only */
102414 int iCol; /* Index of zColumn in row-record */
102434 sqlite3_mutex_enter(db->mutex);
102469 pBlob->pTab = pTab;
102470 pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
102473 for(iCol=0; iCol<pTab->nCol; iCol++) {
102474 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
102478 if( iCol==pTab->nCol ){
102493 if( db->flags&SQLITE_ForeignKeys ){
102500 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
102502 for(j=0; j<pFKey->nCol; j++){
102503 if( pFKey->aCol[j].iFrom==iCol ){
102510 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
102512 for(j=0; j<pIdx->nKeyCol; j++){
102514 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
102528 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse);
102529 assert( pBlob->pStmt || db->mallocFailed );
102530 if( pBlob->pStmt ){
102534 ** of writing code to use the b-tree layer directly is that the
102539 ** Code external to the Vdbe then "borrows" the b-tree cursor and
102544 ** which closes the b-tree cursor and (possibly) commits the
102557 Vdbe *v = (Vdbe *)pBlob->pStmt;
102558 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
102562 pTab->pSchema->schema_cookie,
102563 pTab->pSchema->iGeneration);
102565 assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
102571 if( db->mallocFailed==0 ){
102578 aOp[0].p2 = pTab->tnum;
102580 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
102582 if( db->mallocFailed==0 ){
102586 ** parameter of the other to pTab->tnum. */
102588 aOp[1].p2 = pTab->tnum;
102599 aOp[1].p4.i = pTab->nCol+1;
102600 aOp[3].p2 = pTab->nCol;
102609 pBlob->iCol = iCol;
102610 pBlob->db = db;
102612 if( db->mallocFailed ){
102621 if( rc==SQLITE_OK && db->mallocFailed==0 ){
102624 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
102631 sqlite3_mutex_leave(db->mutex);
102645 sqlite3_stmt *pStmt = p->pStmt;
102646 db = p->db;
102647 sqlite3_mutex_enter(db->mutex);
102649 sqlite3_mutex_leave(db->mutex);
102673 db = p->db;
102674 sqlite3_mutex_enter(db->mutex);
102675 v = (Vdbe*)p->pStmt;
102677 if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
102681 /* If there is no statement handle, then the blob-handle has
102687 ** returned, clean-up the statement handle.
102689 assert( db == v->db );
102690 sqlite3BtreeEnterCursor(p->pCsr);
102693 if( xCall==sqlite3BtreePutData && db->xPreUpdateCallback ){
102694 /* If a pre-update hook is registered and this is a write cursor,
102697 ** TODO: The preupdate-hook is passed SQLITE_DELETE, even though this
102704 ** using the incremental-blob API, this works. For the sessions module
102708 iKey = sqlite3BtreeIntegerKey(p->pCsr);
102709 assert( v->apCsr[0]!=0 );
102710 assert( v->apCsr[0]->eCurType==CURTYPE_BTREE );
102712 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
102717 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
102718 sqlite3BtreeLeaveCursor(p->pCsr);
102721 p->pStmt = 0;
102723 v->rc = rc;
102728 sqlite3_mutex_leave(db->mutex);
102754 return (p && p->pStmt) ? p->nByte : 0;
102773 db = p->db;
102774 sqlite3_mutex_enter(db->mutex);
102776 if( p->pStmt==0 ){
102777 /* If there is no statement handle, then the blob-handle has
102783 ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
102793 assert( rc==SQLITE_OK || p->pStmt==0 );
102794 sqlite3_mutex_leave(db->mutex);
102803 ** 2011-07-09
102818 ** The VdbeSorter object implements a multi-threaded external merge sort
102822 ** Here is the (internal, non-API) interface between this module and the
102875 ** an in-memory merge sort. In this case, no temporary files are required
102882 ** A PMA created at this point is known as a "level-0 PMA". Higher levels
102883 ** of PMAs may be created by merging existing PMAs together - for example
102884 ** merging two or more level-0 PMAs together creates a level-1 PMA.
102888 ** page-cache of the main database. Specifically, the threshold is set to
102892 ** If the sorter is running in single-threaded mode, then all PMAs generated
102894 ** multi-threaded mode then up to (N+1) temporary files may be opened, where
102901 ** The sorter is running in multi-threaded mode if (a) the library was built
102902 ** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater
102911 ** sorter is running in single-threaded mode, then these PMAs are merged
102916 ** Or, if running in multi-threaded mode, then a background thread is
102926 ** Rewind() is called, then a hierarchy of incremental-merges is used.
102932 ** If running in multi-threaded mode and there are more than
102945 ** characteristics of the sorter in multi-threaded mode.
102952 ** Hard-coded maximum amount of data to accumulate in memory before flushing
102965 typedef struct SortSubtask SortSubtask; /* A sub-task in the sort process */
102967 typedef struct SorterList SorterList; /* In-memory list of records */
102980 ** An in-memory list of objects to be sorted.
102989 u8 *aMemory; /* If non-NULL, bulk memory to hold pList */
103012 ** comparing aReadr[2*i-N] and aReadr[2*i-N+1]. Whichever key is smaller, the
103026 ** aReadr[0] -> Banana
103027 ** aReadr[1] -> Feijoa
103028 ** aReadr[2] -> Elderberry
103029 ** aReadr[3] -> Currant
103030 ** aReadr[4] -> Grapefruit
103031 ** aReadr[5] -> Apple
103032 ** aReadr[6] -> Durian
103033 ** aReadr[7] -> EOF
103042 ** aReadr[5] -> Eggplant
103047 ** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader
103070 ** single-threaded operation, there is exactly one instance of this object
103071 ** and for multi-threaded operation there are two or more instances.
103082 ** 1. When flushing the contents of memory to a level-0 PMA on disk, to
103100 VdbeSorter *pSorter; /* Sorter that owns this sub-task */
103104 SorterFile file; /* Temp file for level-0 PMAs */
103128 SorterList list; /* List of in-memory records */
103171 ** There are two types of IncrMerger object - single (bUseThread==0) and
103172 ** multi-threaded (bUseThread==1).
103174 ** A multi-threaded IncrMerger object uses two temporary files - aFile[0]
103189 ** A single-threaded IncrMerger does not open any temporary files of its
103191 ** at offset iStartOff of file pTask->file2. And instead of using a
103193 ** threaded IncrMerger the allocate part of pTask->file2 is "refilled" with
103211 ** size. But I/O is more efficient if it occurs in page-sized blocks where
103213 ** the PMA so that aligned, page-size blocks are written.
103216 int eFWErr; /* Non-zero if in an error state */
103230 ** by this module. If using a separate allocation for each in-memory record
103238 ** has finished passing records to the sorter, or when the in-memory buffer
103271 sqlite3_free(pReadr->aAlloc);
103272 sqlite3_free(pReadr->aBuffer);
103273 if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
103274 vdbeIncrFree(pReadr->pIncr);
103295 if( p->aMap ){
103296 *ppOut = &p->aMap[p->iReadOff];
103297 p->iReadOff += nByte;
103301 assert( p->aBuffer );
103304 ** p->nBuffer bytes of data from the file into it. Or, if there are less
103305 ** than p->nBuffer bytes remaining in the PMA, read all remaining data. */
103306 iBuf = p->iReadOff % p->nBuffer;
103312 if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){
103313 nRead = p->nBuffer;
103315 nRead = (int)(p->iEof - p->iReadOff);
103320 rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff);
103324 nAvail = p->nBuffer - iBuf;
103327 /* The requested data is available in the in-memory buffer. In this
103330 *ppOut = &p->aBuffer[iBuf];
103331 p->iReadOff += nByte;
103333 /* The requested data is not all available in the in-memory buffer.
103334 ** In this case, allocate space at p->aAlloc[] to copy the requested
103335 ** range into. Then return a copy of pointer p->aAlloc to the caller. */
103338 /* Extend the p->aAlloc[] allocation if required. */
103339 if( p->nAlloc<nByte ){
103341 sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
103343 aNew = sqlite3Realloc(p->aAlloc, nNew);
103345 p->nAlloc = nNew;
103346 p->aAlloc = aNew;
103350 ** p->aAlloc[]. */
103351 memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail);
103352 p->iReadOff += nAvail;
103353 nRem = nByte - nAvail;
103355 /* The following loop copies up to p->nBuffer bytes per iteration into
103356 ** the p->aAlloc[] buffer. */
103363 if( nRem>p->nBuffer ) nCopy = p->nBuffer;
103366 assert( aNext!=p->aAlloc );
103367 memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
103368 nRem -= nCopy;
103371 *ppOut = p->aAlloc;
103384 if( p->aMap ){
103385 p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut);
103387 iBuf = p->iReadOff % p->nBuffer;
103388 if( iBuf && (p->nBuffer-iBuf)>=9 ){
103389 p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut);
103416 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
103417 sqlite3_file *pFd = pFile->pFd;
103418 if( pFd->pMethods->iVersion>=3 ){
103419 rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp);
103439 assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 );
103442 if( pReadr->aMap ){
103443 sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
103444 pReadr->aMap = 0;
103446 pReadr->iReadOff = iOff;
103447 pReadr->iEof = pFile->iEof;
103448 pReadr->pFd = pFile->pFd;
103450 rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
103451 if( rc==SQLITE_OK && pReadr->aMap==0 ){
103452 int pgsz = pTask->pSorter->pgsz;
103453 int iBuf = pReadr->iReadOff % pgsz;
103454 if( pReadr->aBuffer==0 ){
103455 pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz);
103456 if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM_BKPT;
103457 pReadr->nBuffer = pgsz;
103460 int nRead = pgsz - iBuf;
103461 if( (pReadr->iReadOff + nRead) > pReadr->iEof ){
103462 nRead = (int)(pReadr->iEof - pReadr->iReadOff);
103465 pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff
103483 if( pReadr->iReadOff>=pReadr->iEof ){
103484 IncrMerger *pIncr = pReadr->pIncr;
103488 if( rc==SQLITE_OK && pIncr->bEof==0 ){
103490 pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff
103508 pReadr->nKey = (int)nRec;
103509 rc = vdbePmaReadBlob(pReadr, (int)nRec, &pReadr->aKey);
103518 ** starting at offset iStart and ending at offset iEof-1. This function
103534 assert( pFile->iEof>iStart );
103535 assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 );
103536 assert( pReadr->aBuffer==0 );
103537 assert( pReadr->aMap==0 );
103543 pReadr->iEof = pReadr->iReadOff + nByte;
103560 int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */
103564 UnpackedRecord *r2 = pTask->pUnpacked;
103566 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
103574 ** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences
103578 ** it is assumed that (pTask->pUnpacked) contains the unpacked version
103579 ** of key2. If it is false, (pTask->pUnpacked) is populated with the unpacked
103582 ** If an OOM error is encountered, (pTask->pUnpacked->error_rc) is set
103587 int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */
103591 UnpackedRecord *r2 = pTask->pUnpacked;
103593 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
103606 int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */
103621 res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2);
103623 res = n1 - n2;
103627 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
103633 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
103634 if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
103635 res = res * -1;
103648 int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */
103670 if( (res = v1[i] - v2[i])!=0 ){
103672 res = v1[0] & 0x80 ? -1 : +1;
103678 res = s1 - s2;
103683 res = -1;
103685 res = s1 - s2;
103690 if( *v1 & 0x80 ) res = -1;
103697 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
103702 }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
103703 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
103704 res = res * -1;
103713 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
103716 ** is non-zero and the sorter is able to guarantee a stable sort, nField
103724 ** The sorter can guarantee a stable sort when running in single-threaded
103725 ** mode, but not in multi-threaded mode.
103737 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
103738 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
103752 nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS];
103760 nWorker = SORTER_MAX_MERGE_COUNT-1;
103764 assert( pCsr->pKeyInfo );
103765 assert( !pCsr->isEphemeral );
103766 assert( pCsr->eCurType==CURTYPE_SORTER );
103767 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
103771 pCsr->uc.pSorter = pSorter;
103775 Btree *pBt = db->aDb[0].pBt;
103776 pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
103777 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
103778 pKeyInfo->db = 0;
103780 pKeyInfo->nKeyField = nField;
103783 pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(pBt);
103785 pSorter->nTask = nWorker + 1;
103786 pSorter->iPrev = (u8)(nWorker - 1);
103787 pSorter->bUseThreads = (pSorter->nTask>1);
103788 pSorter->db = db;
103789 for(i=0; i<pSorter->nTask; i++){
103790 SortSubtask *pTask = &pSorter->aTask[i];
103791 pTask->pSorter = pSorter;
103797 pSorter->mnPmaSize = szPma * pgsz;
103799 mxCache = db->aDb[0].pSchema->cache_size;
103801 /* A negative cache-size value C indicates that the cache is abs(C)
103803 mxCache = mxCache * -1024;
103808 pSorter->mxPmaSize = MAX(pSorter->mnPmaSize, (int)mxCache);
103813 assert( pSorter->iMemory==0 );
103814 pSorter->nMemory = pgsz;
103815 pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz);
103816 if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT;
103820 if( pKeyInfo->nAllField<13
103821 && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
103822 && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0
103824 pSorter->typeMask = SORTER_TYPE_INTEGER | SORTER_TYPE_TEXT;
103839 pNext = p->u.pNext;
103849 sqlite3DbFree(db, pTask->pUnpacked);
103851 /* pTask->list.aMemory can only be non-zero if it was handed memory
103853 if( pTask->list.aMemory ){
103854 sqlite3_free(pTask->list.aMemory);
103858 assert( pTask->list.aMemory==0 );
103859 vdbeSorterRecordFree(0, pTask->list.pList);
103861 if( pTask->file.pFd ){
103862 sqlite3OsCloseFree(pTask->file.pFd);
103864 if( pTask->file2.pFd ){
103865 sqlite3OsCloseFree(pTask->file2.pFd);
103873 int iTask = (pTask - pTask->pSorter->aTask);
103874 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
103888 int iTask = (pTask - pTask->pSorter->aTask);
103889 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
103899 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
103912 ** Join thread pTask->thread.
103916 if( pTask->pThread ){
103918 int bDone = pTask->bDone;
103922 (void)sqlite3ThreadJoin(pTask->pThread, &pRet);
103925 assert( pTask->bDone==1 );
103926 pTask->bDone = 0;
103927 pTask->pThread = 0;
103940 assert( pTask->pThread==0 && pTask->bDone==0 );
103941 return sqlite3ThreadCreate(&pTask->pThread, xTask, pIn);
103946 ** level-0 PMAs.
103955 ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread
103958 ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */
103959 for(i=pSorter->nTask-1; i>=0; i--){
103960 SortSubtask *pTask = &pSorter->aTask[i];
103988 pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
103990 pNew->nTree = N;
103991 pNew->pTask = 0;
103992 pNew->aReadr = (PmaReader*)&pNew[1];
103993 pNew->aTree = (int*)&pNew->aReadr[N];
104004 for(i=0; i<pMerger->nTree; i++){
104005 vdbePmaReaderClear(&pMerger->aReadr[i]);
104018 if( pIncr->bUseThread ){
104019 vdbeSorterJoinThread(pIncr->pTask);
104020 if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd);
104021 if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd);
104024 vdbeMergeEngineFree(pIncr->pMerger);
104035 assert( pSorter->bUseThreads || pSorter->pReader==0 );
104037 if( pSorter->pReader ){
104038 vdbePmaReaderClear(pSorter->pReader);
104039 sqlite3DbFree(db, pSorter->pReader);
104040 pSorter->pReader = 0;
104043 vdbeMergeEngineFree(pSorter->pMerger);
104044 pSorter->pMerger = 0;
104045 for(i=0; i<pSorter->nTask; i++){
104046 SortSubtask *pTask = &pSorter->aTask[i];
104048 pTask->pSorter = pSorter;
104050 if( pSorter->list.aMemory==0 ){
104051 vdbeSorterRecordFree(0, pSorter->list.pList);
104053 pSorter->list.pList = 0;
104054 pSorter->list.szPMA = 0;
104055 pSorter->bUsePMA = 0;
104056 pSorter->iMemory = 0;
104057 pSorter->mxKeysize = 0;
104058 sqlite3DbFree(db, pSorter->pUnpacked);
104059 pSorter->pUnpacked = 0;
104067 assert( pCsr->eCurType==CURTYPE_SORTER );
104068 pSorter = pCsr->uc.pSorter;
104071 sqlite3_free(pSorter->list.aMemory);
104073 pCsr->uc.pSorter = 0;
104079 ** The first argument is a file-handle open on a temporary file. The file
104088 if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){
104102 ** Allocate space for a file-handle and open a temporary file. If successful,
104103 ** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK.
104113 rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
104130 ** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or
104134 if( pTask->pUnpacked==0 ){
104135 pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
104136 if( pTask->pUnpacked==0 ) return SQLITE_NOMEM_BKPT;
104137 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
104138 pTask->pUnpacked->errCode = 0;
104159 res = pTask->xCompare(
104160 pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
104165 pp = &p1->u.pNext;
104166 p1 = p1->u.pNext;
104173 pp = &p2->u.pNext;
104174 p2 = p2->u.pNext;
104190 if( p->typeMask==SORTER_TYPE_INTEGER ){
104192 }else if( p->typeMask==SORTER_TYPE_TEXT ){
104199 ** Sort the linked list of records headed at pTask->pList. Return
104212 p = pList->pList;
104213 pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);
104218 if( pList->aMemory ){
104219 if( (u8*)p==pList->aMemory ){
104222 assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
104223 pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
104226 pNext = p->u.pNext;
104229 p->u.pNext = 0;
104243 pList->pList = p;
104245 assert( pTask->pUnpacked->errCode==SQLITE_OK
104246 || pTask->pUnpacked->errCode==SQLITE_NOMEM
104248 return pTask->pUnpacked->errCode;
104252 ** Initialize a PMA-writer object.
104261 p->aBuffer = (u8*)sqlite3Malloc(nBuf);
104262 if( !p->aBuffer ){
104263 p->eFWErr = SQLITE_NOMEM_BKPT;
104265 p->iBufEnd = p->iBufStart = (iStart % nBuf);
104266 p->iWriteOff = iStart - p->iBufStart;
104267 p->nBuffer = nBuf;
104268 p->pFd = pFd;
104278 while( nRem>0 && p->eFWErr==0 ){
104280 if( nCopy>(p->nBuffer - p->iBufEnd) ){
104281 nCopy = p->nBuffer - p->iBufEnd;
104284 memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
104285 p->iBufEnd += nCopy;
104286 if( p->iBufEnd==p->nBuffer ){
104287 p->eFWErr = sqlite3OsWrite(p->pFd,
104288 &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
104289 p->iWriteOff + p->iBufStart
104291 p->iBufStart = p->iBufEnd = 0;
104292 p->iWriteOff += p->nBuffer;
104294 assert( p->iBufEnd<p->nBuffer );
104296 nRem -= nCopy;
104301 ** Flush any buffered data to disk and clean up the PMA-writer object.
104302 ** The results of using the PMA-writer after this call are undefined.
104311 if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){
104312 p->eFWErr = sqlite3OsWrite(p->pFd,
104313 &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
104314 p->iWriteOff + p->iBufStart
104317 *piEof = (p->iWriteOff + p->iBufEnd);
104318 sqlite3_free(p->aBuffer);
104319 rc = p->eFWErr;
104336 ** Write the current contents of in-memory linked-list pList to a level-0
104337 ** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if
104345 ** * One or more records packed end-to-end in order of ascending keys.
104350 sqlite3 *db = pTask->pSorter->db;
104355 /* Set iSz to the expected size of file pTask->file after writing the PMA.
104357 i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof;
104362 assert( pList->szPMA>0 );
104365 if( pTask->file.pFd==0 ){
104366 rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd);
104367 assert( rc!=SQLITE_OK || pTask->file.pFd );
104368 assert( pTask->file.iEof==0 );
104369 assert( pTask->nPMA==0 );
104374 vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9);
104386 vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz,
104387 pTask->file.iEof);
104388 pTask->nPMA++;
104389 vdbePmaWriteVarint(&writer, pList->szPMA);
104390 for(p=pList->pList; p; p=pNext){
104391 pNext = p->u.pNext;
104392 vdbePmaWriteVarint(&writer, p->nVal);
104393 vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal);
104394 if( pList->aMemory==0 ) sqlite3_free(p);
104396 pList->pList = p;
104397 rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof);
104401 assert( rc!=SQLITE_OK || pList->pList==0 );
104402 assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
104418 int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */
104419 SortSubtask *pTask = pMerger->pTask;
104422 rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]);
104433 pReadr1 = &pMerger->aReadr[(iPrev & 0xFFFE)];
104434 pReadr2 = &pMerger->aReadr[(iPrev | 0x0001)];
104436 for(i=(pMerger->nTree+iPrev)/2; i>0; i=i/2){
104439 if( pReadr1->pFd==0 ){
104441 }else if( pReadr2->pFd==0 ){
104442 iRes = -1;
104444 iRes = pTask->xCompare(pTask, &bCached,
104445 pReadr1->aKey, pReadr1->nKey, pReadr2->aKey, pReadr2->nKey
104451 ** case there is no cache of pReadr2 in pTask->pUnpacked, so set
104456 ** was actually called above, then pTask->pUnpacked now contains
104465 pMerger->aTree[i] = (int)(pReadr1 - pMerger->aReadr);
104466 pReadr2 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ];
104469 if( pReadr1->pFd ) bCached = 0;
104470 pMerger->aTree[i] = (int)(pReadr2 - pMerger->aReadr);
104471 pReadr1 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ];
104474 *pbEof = (pMerger->aReadr[pMerger->aTree[1]].pFd==0);
104477 return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc);
104482 ** The main routine for background threads that write level-0 PMAs.
104487 assert( pTask->bDone==0 );
104488 rc = vdbeSorterListToPMA(pTask, &pTask->list);
104489 pTask->bDone = 1;
104500 pSorter->bUsePMA = 1;
104501 return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list);
104506 int nWorker = (pSorter->nTask-1);
104510 pSorter->bUsePMA = 1;
104512 /* Select a sub-task to sort and flush the current list of in-memory
104513 ** records to disk. If the sorter is running in multi-threaded mode,
104514 ** round-robin between the first (pSorter->nTask-1) tasks. Except, if
104515 ** the background thread from a sub-tasks previous turn is still running,
104516 ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
104517 ** fall back to using the final sub-task. The first (pSorter->nTask-1)
104518 ** sub-tasks are preferred as they use background threads - the final
104519 ** sub-task uses the main thread. */
104521 int iTest = (pSorter->iPrev + i + 1) % nWorker;
104522 pTask = &pSorter->aTask[iTest];
104523 if( pTask->bDone ){
104526 if( rc!=SQLITE_OK || pTask->pThread==0 ) break;
104532 rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list);
104539 assert( pTask->pThread==0 && pTask->bDone==0 );
104540 assert( pTask->list.pList==0 );
104541 assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
104543 aMem = pTask->list.aMemory;
104545 pSorter->iPrev = (u8)(pTask - pSorter->aTask);
104546 pTask->list = pSorter->list;
104547 pSorter->list.pList = 0;
104548 pSorter->list.szPMA = 0;
104550 pSorter->list.aMemory = aMem;
104551 pSorter->nMemory = sqlite3MallocSize(aMem);
104552 }else if( pSorter->list.aMemory ){
104553 pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory);
104554 if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT;
104580 assert( pCsr->eCurType==CURTYPE_SORTER );
104581 pSorter = pCsr->uc.pSorter;
104582 getVarint32NR((const u8*)&pVal->z[1], t);
104584 pSorter->typeMask &= SORTER_TYPE_INTEGER;
104586 pSorter->typeMask &= SORTER_TYPE_TEXT;
104588 pSorter->typeMask = 0;
104596 ** If using the single large allocation mode (pSorter->aMemory!=0), then
104603 ** * The total memory allocated for the in-memory list is greater
104604 ** than (page-size * cache-size), or
104606 ** * The total memory allocated for the in-memory list is greater
104607 ** than (page-size * 10) and sqlite3HeapNearlyFull() returns true.
104609 nReq = pVal->n + sizeof(SorterRecord);
104610 nPMA = pVal->n + sqlite3VarintLen(pVal->n);
104611 if( pSorter->mxPmaSize ){
104612 if( pSorter->list.aMemory ){
104613 bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize;
104616 (pSorter->list.szPMA > pSorter->mxPmaSize)
104617 || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull())
104622 pSorter->list.szPMA = 0;
104623 pSorter->iMemory = 0;
104624 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
104628 pSorter->list.szPMA += nPMA;
104629 if( nPMA>pSorter->mxKeysize ){
104630 pSorter->mxKeysize = nPMA;
104633 if( pSorter->list.aMemory ){
104634 int nMin = pSorter->iMemory + nReq;
104636 if( nMin>pSorter->nMemory ){
104638 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
104639 int iListOff = -1;
104640 if( pSorter->list.pList ){
104641 iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
104644 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
104646 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
104649 pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
104651 pSorter->list.aMemory = aNew;
104652 pSorter->nMemory = nNew;
104655 pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
104656 pSorter->iMemory += ROUND8(nReq);
104657 if( pSorter->list.pList ){
104658 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
104665 pNew->u.pNext = pSorter->list.pList;
104668 memcpy(SRVAL(pNew), pVal->z, pVal->n);
104669 pNew->nVal = pVal->n;
104670 pSorter->list.pList = pNew;
104676 ** Read keys from pIncr->pMerger and populate pIncr->aFile[1]. The format
104678 ** except that the number-of-bytes varint is omitted from the start.
104683 i64 iStart = pIncr->iStartOff;
104684 SorterFile *pOut = &pIncr->aFile[1];
104685 SortSubtask *pTask = pIncr->pTask;
104686 MergeEngine *pMerger = pIncr->pMerger;
104688 assert( pIncr->bEof==0 );
104692 vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
104695 PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ];
104696 int nKey = pReader->nKey;
104701 if( pReader->pFd==0 ) break;
104702 if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break;
104706 vdbePmaWriteBlob(&writer, pReader->aKey, nKey);
104707 assert( pIncr->pMerger->pTask==pTask );
104708 rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy);
104711 rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
104720 ** multi-threaded IncrMerger objects.
104725 pIncr->pTask->bDone = 1;
104734 assert( pIncr->bUseThread );
104735 return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p);
104745 ** For single-threaded objects, this is accomplished by literally reading
104746 ** keys from pIncr->pMerger and repopulating aFile[0].
104748 ** For multi-threaded objects, all that is required is to wait until the
104760 if( pIncr->bUseThread ){
104761 rc = vdbeSorterJoinThread(pIncr->pTask);
104764 SorterFile f0 = pIncr->aFile[0];
104765 pIncr->aFile[0] = pIncr->aFile[1];
104766 pIncr->aFile[1] = f0;
104770 if( pIncr->aFile[0].iEof==pIncr->iStartOff ){
104771 pIncr->bEof = 1;
104780 pIncr->aFile[0] = pIncr->aFile[1];
104781 if( pIncr->aFile[0].iEof==pIncr->iStartOff ){
104782 pIncr->bEof = 1;
104802 (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr)));
104804 pIncr->pMerger = pMerger;
104805 pIncr->pTask = pTask;
104806 pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2);
104807 pTask->file2.iEof += pIncr->mxSz;
104818 ** Set the "use-threads" flag on object pIncr.
104821 pIncr->bUseThread = 1;
104822 pIncr->pTask->file2.iEof -= pIncr->mxSz;
104829 ** Recompute pMerger->aTree[iOut] by comparing the next keys on the
104835 int iOut /* Store the result in pMerger->aTree[iOut] */
104843 assert( iOut<pMerger->nTree && iOut>0 );
104845 if( iOut>=(pMerger->nTree/2) ){
104846 i1 = (iOut - pMerger->nTree/2) * 2;
104849 i1 = pMerger->aTree[iOut*2];
104850 i2 = pMerger->aTree[iOut*2+1];
104853 p1 = &pMerger->aReadr[i1];
104854 p2 = &pMerger->aReadr[i2];
104856 if( p1->pFd==0 ){
104858 }else if( p2->pFd==0 ){
104861 SortSubtask *pTask = pMerger->pTask;
104864 assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */
104865 res = pTask->xCompare(
104866 pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey
104875 pMerger->aTree[iOut] = iRes;
104882 ** Only INCRINIT_NORMAL is valid in single-threaded builds (when
104928 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
104932 assert( pMerger->pTask==0 );
104933 pMerger->pTask = pTask;
104935 nTree = pMerger->nTree;
104940 ** However, in the INCRINIT_ROOT case, if PmaReader aReadr[nTask-1] is
104943 ** on this PmaReader before any of the multi-threaded PmaReaders takes
104944 ** better advantage of multi-processor hardware. */
104945 rc = vdbePmaReaderNext(&pMerger->aReadr[nTree-i-1]);
104947 rc = vdbePmaReaderIncrInit(&pMerger->aReadr[i], INCRINIT_NORMAL);
104952 for(i=pMerger->nTree-1; i>0; i--){
104955 return pTask->pUnpacked->errCode;
104960 ** incremental-reader (pReadr->pIncr!=0). This function serves to open
104962 ** object at (pReadr->pIncr).
104965 ** in the sub-tree headed by pReadr are also initialized. Data is then
104970 ** to be a multi-threaded PmaReader and this function is being called in a
104971 ** background thread. In this case all PmaReaders in the sub-tree are
104979 ** to block on thread (pTask->thread) before accessing aFile[1]. But, since
104980 ** this entire function is being run by thread (pTask->thread), that will
104984 ** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all
104985 ** child-trees have already been initialized using IncrInit(INCRINIT_TASK).
104993 IncrMerger *pIncr = pReadr->pIncr;
104994 SortSubtask *pTask = pIncr->pTask;
104995 sqlite3 *db = pTask->pSorter->db;
104997 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
105000 rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode);
105002 /* Set up the required files for pIncr. A multi-threaded IncrMerge object
105003 ** requires two temp files to itself, whereas a single-threaded object
105004 ** only requires a region of pTask->file2. */
105006 int mxSz = pIncr->mxSz;
105008 if( pIncr->bUseThread ){
105009 rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd);
105011 rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd);
105015 /*if( !pIncr->bUseThread )*/{
105016 if( pTask->file2.pFd==0 ){
105017 assert( pTask->file2.iEof>0 );
105018 rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd);
105019 pTask->file2.iEof = 0;
105022 pIncr->aFile[1].pFd = pTask->file2.pFd;
105023 pIncr->iStartOff = pTask->file2.iEof;
105024 pTask->file2.iEof += mxSz;
105030 if( rc==SQLITE_OK && pIncr->bUseThread ){
105032 ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object,
105034 ** pIncr->pTask->thread.
105063 pReader->pIncr->pTask->bDone = 1;
105069 ** If the PmaReader passed as the first argument is not an incremental-reader
105070 ** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes
105074 ** If the IncrMerger object is multi-threaded (IncrMerger.bUseThread==1),
105080 IncrMerger *pIncr = pReadr->pIncr; /* Incremental merger */
105084 assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK );
105085 if( pIncr->bUseThread ){
105087 rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
105098 ** Allocate a new MergeEngine object to merge the contents of nPMA level-0
105099 ** PMAs from pTask->file. If no error occurs, set *ppOut to point to
105104 ** first PMA to read from pTask->file. Assuming no error occurs, it is
105112 i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */
105113 MergeEngine **ppOut /* OUT: New merge-engine */
105125 PmaReader *pReadr = &pNew->aReadr[i];
105126 rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy);
105127 iOff = pReadr->iEof;
105144 ** nPMA<=16 -> TreeDepth() == 0
105145 ** nPMA<=256 -> TreeDepth() == 1
105146 ** nPMA<=65536 -> TreeDepth() == 2
105159 ** pRoot is the root of an incremental merge-tree with depth nDepth (according
105187 PmaReader *pReadr = &p->aReadr[iIter];
105189 if( pReadr->pIncr==0 ){
105194 rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
105198 p = pReadr->pIncr->pMerger;
105204 p->aReadr[iSeq % SORTER_MAX_MERGE_COUNT].pIncr = pIncr;
105213 ** that has already written two or more level-0 PMAs to one or more temp
105231 /* If the sorter uses more than one task, then create the top-level
105233 ** one PmaReader per sub-task. */
105234 assert( pSorter->bUseThreads || pSorter->nTask==1 );
105235 if( pSorter->nTask>1 ){
105236 pMain = vdbeMergeEngineNew(pSorter->nTask);
105241 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
105242 SortSubtask *pTask = &pSorter->aTask[iTask];
105243 assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 );
105244 if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){
105246 int nDepth = vdbeSorterTreeDepth(pTask->nPMA);
105249 if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){
105250 rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot);
105256 for(i=0; i<pTask->nPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){
105257 MergeEngine *pMerger = 0; /* New level-0 PMA merger */
105258 int nReader; /* Number of level-0 PMAs to merge */
105260 nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT);
105271 rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr);
105296 ** (for multi-threaded sorters) so that it can be used to iterate through
105303 SortSubtask *pTask0 = &pSorter->aTask[0];
105306 sqlite3 *db = pTask0->pSorter->db;
105309 for(i=0; i<pSorter->nTask; i++){
105310 pSorter->aTask[i].xCompare = xCompare;
105317 assert( pSorter->bUseThreads==0 || pSorter->nTask>1 );
105318 if( pSorter->bUseThreads ){
105321 SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1];
105325 pSorter->pReader = pReadr;
105329 rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr);
105331 vdbeIncrMergerSetThreads(pReadr->pIncr);
105332 for(iTask=0; iTask<(pSorter->nTask-1); iTask++){
105334 if( (pIncr = pMain->aReadr[iTask].pIncr) ){
105336 assert( pIncr->pTask!=pLast );
105339 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
105344 ** b) If it is using task (nTask-1), it is configured to run
105345 ** in single-threaded mode. This is important, as the
105349 PmaReader *p = &pMain->aReadr[iTask];
105350 assert( p->pIncr==0 || (
105351 (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */
105352 && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */
105366 pSorter->pMerger = pMain;
105387 assert( pCsr->eCurType==CURTYPE_SORTER );
105388 pSorter = pCsr->uc.pSorter;
105393 ** from the in-memory list. */
105394 if( pSorter->bUsePMA==0 ){
105395 if( pSorter->list.pList ){
105397 rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list);
105404 /* Write the current in-memory list to a PMA. When the VdbeSorterWrite()
105408 assert( pSorter->list.pList );
105418 assert( pSorter->pReader==0 );
105439 assert( pCsr->eCurType==CURTYPE_SORTER );
105440 pSorter = pCsr->uc.pSorter;
105441 assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
105442 if( pSorter->bUsePMA ){
105443 assert( pSorter->pReader==0 || pSorter->pMerger==0 );
105444 assert( pSorter->bUseThreads==0 || pSorter->pReader );
105445 assert( pSorter->bUseThreads==1 || pSorter->pMerger );
105447 if( pSorter->bUseThreads ){
105448 rc = vdbePmaReaderNext(pSorter->pReader);
105449 if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE;
105452 /*if( !pSorter->bUseThreads )*/ {
105454 assert( pSorter->pMerger!=0 );
105455 assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
105456 rc = vdbeMergeEngineStep(pSorter->pMerger, &res);
105460 SorterRecord *pFree = pSorter->list.pList;
105461 pSorter->list.pList = pFree->u.pNext;
105462 pFree->u.pNext = 0;
105463 if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree);
105464 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
105478 if( pSorter->bUsePMA ){
105481 if( pSorter->bUseThreads ){
105482 pReader = pSorter->pReader;
105485 /*if( !pSorter->bUseThreads )*/{
105486 pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]];
105488 *pnKey = pReader->nKey;
105489 pKey = pReader->aKey;
105491 *pnKey = pSorter->list.pList->nVal;
105492 pKey = SRVAL(pSorter->list.pList);
105504 assert( pCsr->eCurType==CURTYPE_SORTER );
105505 pSorter = pCsr->uc.pSorter;
105510 pOut->n = nKey;
105512 memcpy(pOut->z, pKey, nKey);
105545 assert( pCsr->eCurType==CURTYPE_SORTER );
105546 pSorter = pCsr->uc.pSorter;
105547 r2 = pSorter->pUnpacked;
105548 pKeyInfo = pCsr->pKeyInfo;
105550 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
105552 r2->nField = nKeyCol;
105554 assert( r2->nField==nKeyCol );
105559 if( r2->aMem[i].flags & MEM_Null ){
105560 *pRes = -1;
105565 *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
105572 ** 2020-03-23
105583 ** This file implements virtual-tables for examining the bytecode content
105590 /* An instance of the bytecode() table-valued function.
105594 sqlite3_vtab base; /* Base class - must be first */
105603 sqlite3_vtab_cursor base; /* Base class - must be first */
105618 ** Create a new bytecode() table-valued function.
105667 pNew->db = db;
105668 pNew->bTablesUsed = isTabUsed*2;
105691 sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1);
105692 *ppCursor = &pCur->base;
105700 sqlite3_free(pCur->zP4);
105701 pCur->zP4 = 0;
105702 sqlite3VdbeMemRelease(&pCur->sub);
105703 sqlite3VdbeMemSetNull(&pCur->sub);
105704 if( pCur->needFinalize ){
105705 sqlite3_finalize(pCur->pStmt);
105707 pCur->pStmt = 0;
105708 pCur->needFinalize = 0;
105709 pCur->zType = 0;
105710 pCur->zSchema = 0;
105711 pCur->zName = 0;
105730 bytecodevtab *pTab = (bytecodevtab*)cur->pVtab;
105732 if( pCur->zP4 ){
105733 sqlite3_free(pCur->zP4);
105734 pCur->zP4 = 0;
105736 if( pCur->zName ){
105737 pCur->zName = 0;
105738 pCur->zType = 0;
105739 pCur->zSchema = 0;
105742 (Vdbe*)pCur->pStmt,
105743 pCur->showSubprograms ? &pCur->sub : 0,
105744 pTab->bTablesUsed,
105745 &pCur->iRowid,
105746 &pCur->iAddr,
105747 &pCur->aOp);
105749 sqlite3VdbeMemSetNull(&pCur->sub);
105750 pCur->aOp = 0;
105761 return pCur->aOp==0;
105774 bytecodevtab *pVTab = (bytecodevtab*)cur->pVtab;
105775 Op *pOp = pCur->aOp + pCur->iAddr;
105776 if( pVTab->bTablesUsed ){
105780 if( i<=2 && pCur->zType==0 ){
105783 int iDb = pOp->p3;
105784 Pgno iRoot = (Pgno)pOp->p2;
105785 sqlite3 *db = pVTab->db;
105786 pSchema = db->aDb[iDb].pSchema;
105787 pCur->zSchema = db->aDb[iDb].zDbSName;
105788 for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
105790 if( !IsVirtual(pTab) && pTab->tnum==iRoot ){
105791 pCur->zName = pTab->zName;
105792 pCur->zType = "table";
105796 if( pCur->zName==0 ){
105797 for(k=sqliteHashFirst(&pSchema->idxHash); k; k=sqliteHashNext(k)){
105799 if( pIdx->tnum==iRoot ){
105800 pCur->zName = pIdx->zName;
105801 pCur->zType = "index";
105811 sqlite3_result_int(ctx, pCur->iAddr);
105814 sqlite3_result_text(ctx, (char*)sqlite3OpcodeName(pOp->opcode),
105815 -1, SQLITE_STATIC);
105818 sqlite3_result_int(ctx, pOp->p1);
105821 sqlite3_result_int(ctx, pOp->p2);
105824 sqlite3_result_int(ctx, pOp->p3);
105828 if( pCur->zP4==0 ){
105829 pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp);
105832 sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC);
105835 char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4);
105836 sqlite3_result_text(ctx, zCom, -1, sqlite3_free);
105841 sqlite3_result_int(ctx, pOp->p5);
105844 Op *aOp = pCur->aOp;
105846 assert( aOp[0].p4.z==0 || strncmp(aOp[0].p4.z,"-" "- ",3)==0 );
105847 if( pCur->iRowid==pCur->iAddr+1 ){
105850 sqlite3_result_text(ctx, aOp[0].p4.z+3, -1, SQLITE_STATIC);
105859 sqlite3_result_int64(ctx, pOp->nExec);
105862 sqlite3_result_int64(ctx, pOp->nCycle);
105872 sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC);
105875 sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC);
105878 sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
105881 sqlite3_result_int(ctx, pOp->opcode==OP_OpenWrite);
105893 *pRowid = pCur->iRowid;
105909 bytecodevtab *pVTab = (bytecodevtab *)pVtabCursor->pVtab;
105914 pCur->iRowid = 0;
105915 pCur->iAddr = 0;
105916 pCur->showSubprograms = idxNum==0;
105923 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
105924 pCur->needFinalize = 1;
105927 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
105929 if( pCur->pStmt==0 ){
105930 pVTab->base.zErrMsg = sqlite3_mprintf(
105932 pVTab->bTablesUsed ? "tables_used" : "bytecode"
105954 int iBaseCol = pVTab->bTablesUsed ? 4 : 10;
105955 pIdxInfo->estimatedCost = (double)100;
105956 pIdxInfo->estimatedRows = 100;
105957 pIdxInfo->idxNum = 0;
105958 for(i=0, p=pIdxInfo->aConstraint; i<pIdxInfo->nConstraint; i++, p++){
105959 if( p->usable==0 ) continue;
105960 if( p->op==SQLITE_INDEX_CONSTRAINT_EQ && p->iColumn==iBaseCol+1 ){
105962 pIdxInfo->aConstraintUsage[i].omit = 1;
105963 pIdxInfo->aConstraintUsage[i].argvIndex = 1;
105965 if( p->op==SQLITE_INDEX_CONSTRAINT_ISNULL && p->iColumn==iBaseCol ){
105966 pIdxInfo->aConstraintUsage[i].omit = 1;
105967 pIdxInfo->idxNum = 1;
106032 ** This file contains code use to implement an in-memory rollback journal.
106033 ** The in-memory rollback journal is used to journal transactions for
106036 ** Update: The in-memory journal is also used to temporarily cache
106037 ** smaller journals that are not critical for power-loss recovery.
106055 ** The zChunk array is always at least 8 bytes in size - usually much more.
106072 #define fileChunkSize(nChunkSize) (sizeof(FileChunk) + ((nChunkSize)-8))
106084 ** This structure is a subclass of sqlite3_file. Each open memory-journal
106089 int nChunkSize; /* In-memory chunk-size */
106092 FileChunk *pFirst; /* Head of in-memory chunk-list */
106102 ** Read data from the in-memory journal file. This is the implementation
106117 if( (iAmt+iOfst)>p->endpoint.iOffset ){
106120 assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 );
106121 if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
106123 for(pChunk=p->pFirst;
106124 ALWAYS(pChunk) && (iOff+p->nChunkSize)<=iOfst;
106125 pChunk=pChunk->pNext
106127 iOff += p->nChunkSize;
106130 pChunk = p->readpoint.pChunk;
106134 iChunkOffset = (int)(iOfst%p->nChunkSize);
106136 int iSpace = p->nChunkSize - iChunkOffset;
106137 int nCopy = MIN(nRead, (p->nChunkSize - iChunkOffset));
106138 memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy);
106140 nRead -= iSpace;
106142 } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
106143 p->readpoint.iOffset = pChunk ? iOfst+iAmt : 0;
106144 p->readpoint.pChunk = pChunk;
106156 pNext = pIter->pNext;
106175 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
106177 nChunk = copy.endpoint.iOffset - iOff;
106179 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
106184 /* No error has occurred. Free the in-memory buffers. */
106190 ** the original before returning. This way, SQLite uses the in-memory
106191 ** journal data to roll back changes made to the internal page-cache
106218 if( p->nSpill>0 && (iAmt+iOfst)>p->nSpill ){
106228 /* An in-memory journal file should only ever be appended to. Random
106230 ** the in-memory journal is being used by a connection using the
106231 ** atomic-write optimization. In this case the first 28 bytes of the
106233 assert( iOfst<=p->endpoint.iOffset );
106234 if( iOfst>0 && iOfst!=p->endpoint.iOffset ){
106237 if( iOfst==0 && p->pFirst ){
106238 assert( p->nChunkSize>iAmt );
106239 memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
106242 FileChunk *pChunk = p->endpoint.pChunk;
106243 int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize);
106244 int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset);
106249 FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
106253 pNew->pNext = 0;
106255 assert( p->pFirst );
106256 pChunk->pNext = pNew;
106258 assert( !p->pFirst );
106259 p->pFirst = pNew;
106261 pChunk = p->endpoint.pChunk = pNew;
106265 memcpy((u8*)pChunk->zChunk + iChunkOffset, zWrite, iSpace);
106267 nWrite -= iSpace;
106268 p->endpoint.iOffset += iSpace;
106277 ** Truncate the in-memory file.
106281 assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 );
106282 if( size<p->endpoint.iOffset ){
106285 memjrnlFreeChunks(p->pFirst);
106286 p->pFirst = 0;
106288 i64 iOff = p->nChunkSize;
106289 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
106290 iOff += p->nChunkSize;
106293 memjrnlFreeChunks(pIter->pNext);
106294 pIter->pNext = 0;
106298 p->endpoint.pChunk = pIter;
106299 p->endpoint.iOffset = size;
106300 p->readpoint.pChunk = 0;
106301 p->readpoint.iOffset = 0;
106311 memjrnlFreeChunks(p->pFirst);
106319 ** syncing an in-memory journal is a no-op.
106331 *pSize = (sqlite_int64) p->endpoint.iOffset;
106366 ** all content is always stored in main-memory. Finally, if nSpill is a
106367 ** positive value, then the journal file is initially created in-memory
106383 /* Zero the file-handle object. If nSpill was passed zero, initialize
106386 ** made on the journal file-handle. */
106393 p->nChunkSize = nSpill;
106395 p->nChunkSize = 8 + MEMJOURNAL_DFLT_FILECHUNKSIZE - sizeof(FileChunk);
106396 assert( MEMJOURNAL_DFLT_FILECHUNKSIZE==fileChunkSize(p->nChunkSize) );
106399 pJfd->pMethods = (const sqlite3_io_methods*)&MemJournalMethods;
106400 p->nSpill = nSpill;
106401 p->flags = flags;
106402 p->zJournal = zName;
106403 p->pVfs = pVfs;
106408 ** Open an in-memory journal file.
106411 sqlite3JournalOpen(0, 0, pJfd, 0, -1);
106418 ** in-memory-only journal file (i.e. is one that was opened with a +ve
106425 if( pJfd->pMethods==&MemJournalMethods && (
106427 p->nSpill>0
106432 NEVER(p->nSpill>0)
106435 || (p->flags & SQLITE_OPEN_MAIN_JOURNAL)
106445 ** The file-handle passed as the only argument is open on a journal file.
106450 return p->pMethods==&MemJournalMethods;
106455 ** pVfs to create the underlying on-disk files.
106458 return MAX(pVfs->szOsFile, (int)sizeof(MemJournal));
106489 for(pWin=pList; pWin; pWin=pWin->pNextWin){
106491 rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy);
106493 rc = sqlite3WalkExprList(pWalker, pWin->pPartition);
106495 rc = sqlite3WalkExpr(pWalker, pWin->pFilter);
106497 rc = sqlite3WalkExpr(pWalker, pWin->pStart);
106499 rc = sqlite3WalkExpr(pWalker, pWin->pEnd);
106521 ** return from the top-level walk call.
106531 rc = pWalker->xExprCallback(pWalker, pExpr);
106534 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
106535 if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
106538 if( pExpr->pRight ){
106540 pExpr = pExpr->pRight;
106544 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
106546 if( pExpr->x.pList ){
106547 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
106551 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
106572 for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
106573 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
106580 ** This is a no-op callback for Walker->xSelectCallback2. If this
106581 ** callback is set, then the Select->pWinDefn list is traversed.
106586 /* No-op */
106596 if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
106597 if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
106598 if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
106599 if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
106600 if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
106601 if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
106603 if( p->pWinDefn ){
106605 if( pWalker->xSelectCallback2==sqlite3WalkWinDefnDummyCallback
106606 || ((pParse = pWalker->pParse)!=0 && IN_RENAME_OBJECT)
106608 || pWalker->xSelectCallback2==sqlite3SelectPopWith
106613 int rc = walkWindowList(pWalker, p->pWinDefn, 0);
106633 pSrc = p->pSrc;
106635 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
106636 if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){
106639 if( pItem->fg.isTabFunc
106640 && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg)
106652 ** on the compound select chain, p->pPrior.
106657 ** but only if both xSelectCallback and xSelectCallback2 are both non-NULL
106664 ** is a no-op returning WRC_Continue.
106669 if( pWalker->xSelectCallback==0 ) return WRC_Continue;
106671 rc = pWalker->xSelectCallback(pWalker, p);
106678 if( pWalker->xSelectCallback2 ){
106679 pWalker->xSelectCallback2(pWalker, p);
106681 p = p->pPrior;
106691 pWalker->walkerDepth++;
106696 pWalker->walkerDepth--;
106701 ** No-op routine for the parse-tree walker.
106715 ** No-op routine for the parse-tree walker for SELECT statements.
106755 ** is a helper function - a callback for the tree walker.
106760 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
106774 ** Turn the pExpr expression into an alias for the iCol-th column of the
106795 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
106799 Expr *pOrig; /* The iCol-th column of the result set */
106803 assert( iCol>=0 && iCol<pEList->nExpr );
106804 pOrig = pEList->a[iCol].pExpr;
106807 if( pExpr->pAggInfo ) return;
106808 db = pParse->db;
106810 if( db->mallocFailed ){
106816 if( pExpr->op==TK_COLLATE ){
106818 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
106824 if( ALWAYS(pExpr->y.pWin!=0) ){
106825 pExpr->y.pWin->pOwner = pExpr;
106835 ** and mark the expression-list item by setting ExprList.a[].fg.eEName
106838 ** Check to see if the zSpan/eEName of the expression-list item passed to this
106845 ** and setting zSpan to "DATABASE.TABLE.<rowid-alias>". This type of pItem
106858 int eEName = pItem->fg.eEName;
106863 zSpan = pItem->zEName;
106883 ** Return TRUE if the double-quoted string mis-feature should be supported.
106886 if( db->init.busy ) return 1; /* Always support for legacy schemas */
106887 if( pTopNC->ncFlags & NC_IsDDL ){
106889 if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
106892 return (db->flags & SQLITE_DqsDDL)!=0;
106895 return (db->flags & SQLITE_DqsDML)!=0;
106900 ** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
106907 n = pExpr->iColumn;
106909 pExTab = pExpr->y.pTab;
106911 assert( n < pExTab->nCol );
106912 if( (pExTab->tabFlags & TF_HasGenerated)!=0
106913 && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
106915 testcase( pExTab->nCol==BMS-1 );
106916 testcase( pExTab->nCol==BMS );
106917 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
106919 testcase( n==BMS-1 );
106921 if( n>=BMS ) n = BMS-1;
106938 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
106940 pNew->iTable = pMatch->iCursor;
106941 pNew->iColumn = iColumn;
106942 pNew->y.pTab = pMatch->pTab;
106943 assert( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 );
106950 ** Return TRUE (non-zero) if zTab is a valid name for the schema table pTab.
106955 const char *zDb /* non-NULL if a database qualifier is present */
106959 assert( pTab->tnum==1 );
106961 zLegacy = pTab->zName;
106981 ** pExpr->iDb Set the index in db->aDb[] of the database X
106983 ** pExpr->iTable Set to the cursor number for the table obtained
106985 ** pExpr->y.pTab Points to the Table structure of X.Y (even if
106987 ** pExpr->iColumn Set to the column number within the table.
106988 ** pExpr->op Set to TK_COLUMN.
106989 ** pExpr->pLeft Any expression this points to is deleted
106990 ** pExpr->pRight Any expression this points to is deleted.
107014 sqlite3 *db = pParse->db; /* The database connection */
107019 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
107023 const char *zCol = pRight->u.zToken;
107030 /* Initialize the node to no-match */
107031 pExpr->iTable = -1;
107039 testcase( pNC->ncFlags & NC_PartIdx );
107040 testcase( pNC->ncFlags & NC_IsCheck );
107041 if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
107048 for(i=0; i<db->nDb; i++){
107049 assert( db->aDb[i].zDbSName );
107050 if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){
107051 pSchema = db->aDb[i].pSchema;
107055 if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){
107058 pSchema = db->aDb[0].pSchema;
107059 zDb = db->aDb[0].zDbSName;
107064 /* Start at the inner-most context and move outward until a match is found */
107068 SrcList *pSrcList = pNC->pSrcList;
107071 for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
107073 pTab = pItem->pTab;
107074 assert( pTab!=0 && pTab->zName!=0 );
107075 assert( pTab->nCol>0 || pParse->nErr );
107076 assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
107077 if( pItem->fg.isNestedFrom ){
107082 ** This pItem -------------^
107085 assert( pItem->pSelect!=0 );
107086 pEList = pItem->pSelect->pEList;
107088 assert( pEList->nExpr==pTab->nCol );
107089 for(j=0; j<pEList->nExpr; j++){
107091 if( !sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb, &bRowid) ){
107096 if( pItem->fg.isUsing==0
107097 || sqlite3IdListIndex(pItem->u3.pUsing, zCol)<0
107105 if( (pItem->fg.jointype & JT_RIGHT)==0 ){
107106 /* An INNER or LEFT JOIN. Use the left-most table */
107109 if( (pItem->fg.jointype & JT_LEFT)==0 ){
107110 /* A RIGHT JOIN. Use the right-most table */
107116 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107128 pExpr->iColumn = j;
107129 pEList->a[j].fg.bUsed = 1;
107131 /* rowid cannot be part of a USING clause - assert() this. */
107132 assert( bRowid==0 || pEList->a[j].fg.bUsingTerm==0 );
107133 if( pEList->a[j].fg.bUsingTerm ) break;
107140 if( pTab->pSchema!=pSchema ) continue;
107143 if( pItem->zAlias!=0 ){
107144 if( sqlite3StrICmp(zTab, pItem->zAlias)!=0 ){
107147 }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){
107148 if( pTab->tnum!=1 ) continue;
107152 if( IN_RENAME_OBJECT && pItem->zAlias ){
107153 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
107157 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
107158 if( pCol->hName==hCol
107159 && sqlite3StrICmp(pCol->zCnName, zCol)==0
107162 if( pItem->fg.isUsing==0
107163 || sqlite3IdListIndex(pItem->u3.pUsing, zCol)<0
107171 if( (pItem->fg.jointype & JT_RIGHT)==0 ){
107172 /* An INNER or LEFT JOIN. Use the left-most table */
107175 if( (pItem->fg.jointype & JT_LEFT)==0 ){
107176 /* A RIGHT JOIN. Use the right-most table */
107182 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107187 /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
107188 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
107189 if( pItem->fg.isNestedFrom ){
107204 ** non-VIEW candidate plus multiple VIEW candidates. In other
107205 ** words non-VIEW candidate terms take precedence over VIEWs.
107210 && ALWAYS(pMatch->pTab!=0)
107211 && (pMatch->pTab->tabFlags & TF_Ephemeral)!=0
107212 && (pTab->tabFlags & TF_Ephemeral)==0)
107220 /* The (much more common) non-SQLITE_ALLOW_ROWID_IN_VIEW case is
107222 ** always be a non-VIEW
107230 pExpr->iTable = pMatch->iCursor;
107232 pExpr->y.pTab = pMatch->pTab;
107233 if( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 ){
107236 pSchema = pExpr->y.pTab->pSchema;
107249 if( pParse->pTriggerTab!=0 ){
107250 int op = pParse->eTriggerOp;
107252 if( pParse->bReturning ){
107253 if( (pNC->ncFlags & NC_UBaseReg)!=0
107255 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0
107256 || isValidSchemaTableName(zTab, pParse->pTriggerTab, 0))
107258 pExpr->iTable = op!=TK_DELETE;
107259 pTab = pParse->pTriggerTab;
107262 pExpr->iTable = 1;
107263 pTab = pParse->pTriggerTab;
107265 pExpr->iTable = 0;
107266 pTab = pParse->pTriggerTab;
107271 if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
107272 Upsert *pUpsert = pNC->uNC.pUpsert;
107274 pTab = pUpsert->pUpsertSrc->a[0].pTab;
107275 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
107283 pSchema = pTab->pSchema;
107285 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
107286 if( pCol->hName==hCol
107287 && sqlite3StrICmp(pCol->zCnName, zCol)==0
107289 if( iCol==pTab->iPKey ){
107290 iCol = -1;
107295 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
107296 /* IMP: R-51414-32910 */
107297 iCol = -1;
107299 if( iCol<pTab->nCol ){
107303 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
107304 testcase( iCol==(-1) );
107307 pExpr->iColumn = iCol;
107308 pExpr->y.pTab = pTab;
107311 pExpr->iTable = pNC->uNC.pUpsert->regData +
107319 pExpr->y.pTab = pTab;
107320 if( pParse->bReturning ){
107322 pExpr->op2 = TK_COLUMN;
107323 pExpr->iColumn = iCol;
107324 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
107327 pExpr->iColumn = (i16)iCol;
107331 pExpr->affExpr = SQLITE_AFF_INTEGER;
107332 }else if( pExpr->iTable==0 ){
107335 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107339 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107355 && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
107357 && ALWAYS(VisibleRowid(pMatch->pTab) || pMatch->fg.isNestedFrom)
107361 if( pMatch->pTab!=0 && IsView(pMatch->pTab) ){
107365 if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
107366 pExpr->affExpr = SQLITE_AFF_INTEGER;
107371 ** might refer to an result-set alias. This happens, for example, when
107381 ** The ability to use an output result-set column in the WHERE, GROUP BY,
107388 && (pNC->ncFlags & NC_UEList)!=0
107391 pEList = pNC->uNC.pEList;
107393 for(j=0; j<pEList->nExpr; j++){
107394 char *zAs = pEList->a[j].zEName;
107395 if( pEList->a[j].fg.eEName==ENAME_NAME
107399 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
107400 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
107401 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
107402 pOrig = pEList->a[j].pExpr;
107403 if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
107408 && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
107433 pNC = pNC->pNext;
107440 ** supplied) and the value of Z is enclosed in double-quotes, then
107445 ** Because no reference was made to outer contexts, the pNC->nRef
107449 assert( pExpr->op==TK_ID );
107453 /* If a double-quoted identifier does not match any known column name,
107457 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
107468 "double-quoted string literal: \"%w\"", zCol);
107470 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
107472 pExpr->op = TK_STRING;
107473 memset(&pExpr->y, 0, sizeof(pExpr->y));
107493 if( pFJMatch->nExpr==cnt-1 ){
107497 sqlite3ExprDelete(db, pExpr->pLeft);
107498 pExpr->pLeft = 0;
107499 sqlite3ExprDelete(db, pExpr->pRight);
107500 pExpr->pRight = 0;
107502 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107503 pExpr->op = TK_FUNCTION;
107504 pExpr->u.zToken = "coalesce";
107505 pExpr->x.pList = pFJMatch;
107519 sqlite3ErrorMsg(pParse, "%s: \"%s\" - should this be a"
107520 " string literal in single-quotes?",
107525 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
107526 pParse->checkSchema = 1;
107527 pTopNC->nNcErr++;
107534 sqlite3ExprDelete(db, pExpr->pLeft);
107535 pExpr->pLeft = 0;
107536 sqlite3ExprDelete(db, pExpr->pRight);
107537 pExpr->pRight = 0;
107556 if( pExpr->iColumn>=0 ){
107557 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
107559 pMatch->fg.rowidUsed = 1;
107563 pExpr->op = eNewExprOp;
107568 if( pParse->db->xAuth
107569 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
107571 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
107578 pTopNC->nRef++;
107580 pTopNC = pTopNC->pNext;
107595 SrcItem *pItem = &pSrc->a[iSrc];
107598 pTab = p->y.pTab = pItem->pTab;
107599 p->iTable = pItem->iCursor;
107600 if( p->y.pTab->iPKey==iCol ){
107601 p->iColumn = -1;
107603 p->iColumn = (ynVar)iCol;
107604 if( (pTab->tabFlags & TF_HasGenerated)!=0
107605 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
107607 testcase( pTab->nCol==63 );
107608 testcase( pTab->nCol==64 );
107609 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
107612 testcase( iCol==BMS-1 );
107613 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
107622 ** pNC->ncFlags values determined by validMask.
107644 if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions";
107646 else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
107649 else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
107652 if( pExpr ) pExpr->op = TK_NULL;
107653 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
107657 if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E,R);
107661 ** Return 1024 times this value. Or return -1 if p is not a floating point
107665 double r = -1.0;
107666 if( p->op!=TK_FLOAT ) return -1;
107668 sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
107670 if( r>1.0 ) return -1;
107689 pNC = pWalker->u.pNC;
107691 pParse = pNC->pParse;
107692 assert( pParse==pWalker->pParse );
107695 if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
107696 SrcList *pSrcList = pNC->pSrcList;
107698 for(i=0; i<pNC->pSrcList->nSrc; i++){
107699 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
107703 switch( pExpr->op ){
107711 SrcList *pSrcList = pNC->pSrcList;
107713 assert( pSrcList && pSrcList->nSrc>=1 );
107714 pItem = pSrcList->a;
107715 pExpr->op = TK_COLUMN;
107717 pExpr->y.pTab = pItem->pTab;
107718 pExpr->iTable = pItem->iCursor;
107719 pExpr->iColumn--;
107720 pExpr->affExpr = SQLITE_AFF_INTEGER;
107726 ** "expr IS NOT NULL" --> "TRUE"
107727 ** "expr IS NULL" --> "FALSE"
107732 ** If this optimization occurs, also restore the NameContext ref-counts
107738 ** 2024-03-28: Beware of aggregates. A bare column of aggregated table
107756 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
107757 anRef[i] = p->nRef;
107759 sqlite3WalkExpr(pWalker, pExpr->pLeft);
107761 if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
107766 for(i=0, p=pNC; p; p=p->pNext, i++){
107767 if( (p->ncFlags & NC_Where)==0 ){
107777 pExpr->op==TK_NOTNULL
107782 pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
107783 pExpr->flags |= EP_IntValue;
107784 pExpr->op = TK_INTEGER;
107785 for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
107786 p->nRef = anRef[i];
107788 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
107789 pExpr->pLeft = 0;
107798 ** be one call to lookupName(). Then the compiler will in-line
107807 if( pExpr->op==TK_ID ){
107813 Expr *pLeft = pExpr->pLeft;
107814 testcase( pNC->ncFlags & NC_IdxExpr );
107815 testcase( pNC->ncFlags & NC_GenCol );
107818 pRight = pExpr->pRight;
107819 if( pRight->op==TK_ID ){
107822 assert( pRight->op==TK_DOT );
107824 zDb = pLeft->u.zToken;
107825 pLeft = pRight->pLeft;
107826 pRight = pRight->pRight;
107829 zTable = pLeft->u.zToken;
107833 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
107842 ExprList *pList = pExpr->x.pList; /* The argument list */
107843 int n = pList ? pList->nExpr : 0; /* Number of arguments */
107849 u8 enc = ENC(pParse->db); /* The database encoding */
107850 int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
107852 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
107855 assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
107856 zId = pExpr->u.zToken;
107857 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
107859 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
107866 is_agg = pDef->xFinalize!=0;
107867 if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
107870 pExpr->iTable = exprProbability(pList->a[1].pExpr);
107871 if( pExpr->iTable<0 ){
107875 pNC->nNcErr++;
107878 /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
107880 ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
107881 ** short-hand for likelihood(X,0.0625).
107882 ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
107884 ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
107887 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
107892 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
107897 pNC->nNcErr++;
107899 pExpr->op = TK_NULL;
107904 if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
107911 if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
107912 /* Clearly non-deterministic functions like random(), but also
107918 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
107922 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
107923 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
107925 if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
107926 && pParse->nested==0
107927 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
107929 /* Internal-use-only functions are disallowed unless the
107931 ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
107936 if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
107945 assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
107946 || (pDef->xValue==0 && pDef->xInverse==0)
107947 || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
107949 if( pDef && pDef->xValue==0 && pWin ){
107953 pNC->nNcErr++;
107955 (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
107956 || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
107957 || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
107960 if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
107966 pNC->nNcErr++;
107970 if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
107972 pNC->nNcErr++;
107976 else if( no_such_func && pParse->db->init.busy==0
107978 && pParse->explain==0
107982 pNC->nNcErr++;
107986 pNC->nNcErr++;
107991 "FILTER may not be used with non-aggregate %#T()",
107994 pNC->nNcErr++;
107997 else if( is_agg==0 && pExpr->pLeft ){
107999 pNC->nNcErr++;
108006 pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
108008 pNC->ncFlags &= ~NC_AllowAgg;
108012 else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
108017 if( pExpr->pLeft ){
108018 assert( pExpr->pLeft->op==TK_ORDER );
108019 assert( ExprUseXList(pExpr->pLeft) );
108020 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
108024 Select *pSel = pNC->pWinSelect;
108025 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
108027 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
108028 if( pParse->db->mallocFailed ) break;
108030 sqlite3WalkExprList(pWalker, pWin->pPartition);
108031 sqlite3WalkExprList(pWalker, pWin->pOrderBy);
108032 sqlite3WalkExpr(pWalker, pWin->pFilter);
108034 pNC->ncFlags |= NC_HasWin;
108039 pExpr->op = TK_AGG_FUNCTION;
108040 pExpr->op2 = 0;
108043 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
108048 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
108050 pExpr->op2 += (1 + pNC2->nNestedSelect);
108051 pNC2 = pNC2->pNext;
108055 pExpr->op2 += pNC2->nNestedSelect;
108058 testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
108059 testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 );
108060 pNC2->ncFlags |= NC_HasAgg
108061 | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER)
108065 pNC->ncFlags |= savedAllowFlags;
108067 /* FIX ME: Compute pExpr->affinity based on the expected return
108074 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
108077 testcase( pExpr->op==TK_IN );
108079 int nRef = pNC->nRef;
108080 testcase( pNC->ncFlags & NC_IsCheck );
108081 testcase( pNC->ncFlags & NC_PartIdx );
108082 testcase( pNC->ncFlags & NC_IdxExpr );
108083 testcase( pNC->ncFlags & NC_GenCol );
108084 assert( pExpr->x.pSelect );
108085 if( pNC->ncFlags & NC_SelfRef ){
108088 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
108090 assert( pNC->nRef>=nRef );
108091 if( nRef!=pNC->nRef ){
108093 pExpr->x.pSelect->selFlags |= SF_Correlated;
108095 pNC->ncFlags |= NC_Subquery;
108100 testcase( pNC->ncFlags & NC_IsCheck );
108101 testcase( pNC->ncFlags & NC_PartIdx );
108102 testcase( pNC->ncFlags & NC_IdxExpr );
108103 testcase( pNC->ncFlags & NC_GenCol );
108110 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
108114 if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
108117 if( pRight->op==TK_TRUEFALSE ){
108118 pExpr->op2 = pExpr->op;
108119 pExpr->op = TK_TRUTH;
108133 if( pParse->db->mallocFailed ) break;
108134 assert( pExpr->pLeft!=0 );
108135 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
108136 if( pExpr->op==TK_BETWEEN ){
108138 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
108140 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
108143 assert( pExpr->pRight!=0 );
108144 nRight = sqlite3ExprVectorSize(pExpr->pRight);
108147 testcase( pExpr->op==TK_EQ );
108148 testcase( pExpr->op==TK_NE );
108149 testcase( pExpr->op==TK_LT );
108150 testcase( pExpr->op==TK_LE );
108151 testcase( pExpr->op==TK_GT );
108152 testcase( pExpr->op==TK_GE );
108153 testcase( pExpr->op==TK_IS );
108154 testcase( pExpr->op==TK_ISNOT );
108155 testcase( pExpr->op==TK_BETWEEN );
108157 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
108162 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
108163 return pParse->nErr ? WRC_Abort : WRC_Continue;
108170 ** to the AS-name of one of the terms of the expression list. If it is,
108187 if( pE->op==TK_ID ){
108190 zCol = pE->u.zToken;
108191 for(i=0; i<pEList->nExpr; i++){
108192 if( pEList->a[i].fg.eEName==ENAME_NAME
108193 && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
108211 ** Attempt to match pE against result set columns in the left-most
108213 ** as an indication to the caller that it should sort by the i-th column.
108214 ** The left-most column is 1. In other words, the value returned is the
108218 ** If there is no match, return 0. Return -1 if an error occurs.
108230 u8 savedSuppErr; /* Saved value of db->suppressErr */
108233 pEList = pSelect->pEList;
108239 nc.pSrcList = pSelect->pSrc;
108243 db = pParse->db;
108244 savedSuppErr = db->suppressErr;
108245 db->suppressErr = 1;
108247 db->suppressErr = savedSuppErr;
108251 ** in the result set. Return an 1-based index of the matching
108252 ** result-set entry.
108254 for(i=0; i<pEList->nExpr; i++){
108255 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
108265 ** Generate an ORDER BY or GROUP BY term out-of-range error.
108270 int i, /* The index (1-based) of the term out of range */
108275 "%r %s BY term out of range - should be "
108277 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
108289 ** beginning with the left-most SELECT and working toward the right.
108305 pOrderBy = pSelect->pOrderBy;
108307 db = pParse->db;
108308 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
108312 for(i=0; i<pOrderBy->nExpr; i++){
108313 pOrderBy->a[i].fg.done = 0;
108315 pSelect->pNext = 0;
108316 while( pSelect->pPrior ){
108317 pSelect->pPrior->pNext = pSelect;
108318 pSelect = pSelect->pPrior;
108323 pEList = pSelect->pEList;
108325 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
108326 int iCol = -1;
108328 if( pItem->fg.done ) continue;
108329 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
108332 if( iCol<=0 || iCol>pEList->nExpr ){
108333 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE);
108351 if( !db->mallocFailed ){
108367 pNew->flags |= EP_IntValue;
108368 pNew->u.iValue = iCol;
108369 if( pItem->pExpr==pE ){
108370 pItem->pExpr = pNew;
108372 Expr *pParent = pItem->pExpr;
108373 assert( pParent->op==TK_COLLATE );
108374 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
108375 assert( pParent->pLeft==pE );
108376 pParent->pLeft = pNew;
108379 pItem->u.x.iOrderByCol = (u16)iCol;
108381 pItem->fg.done = 1;
108386 pSelect = pSelect->pNext;
108388 for(i=0; i<pOrderBy->nExpr; i++){
108389 if( pOrderBy->a[i].fg.done==0 ){
108406 ** return non-zero. Return zero if no errors are seen.
108415 sqlite3 *db = pParse->db;
108419 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
108420 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
108424 pEList = pSelect->pEList;
108426 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
108427 if( pItem->u.x.iOrderByCol ){
108428 if( pItem->u.x.iOrderByCol>pEList->nExpr ){
108429 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr, 0);
108432 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
108445 Window *pWin = pExpr->y.pWin;
108456 if( pSelect->pWin ){
108474 ** If the order-by term is an integer I between 1 and N (where N is the
108476 ** in the resolution is a copy of the I-th result-set expression. If
108477 ** the order-by term is an identifier that corresponds to the AS-name of
108478 ** a result-set expression, then the term resolves to a copy of the
108479 ** result-set expression. Otherwise, the expression is resolved in
108480 ** the usual way - using sqlite3ResolveExprNames().
108499 nResult = pSelect->pEList->nExpr;
108500 pParse = pNC->pParse;
108501 for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
108502 Expr *pE = pItem->pExpr;
108506 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
108508 /* If an AS-name match is found, mark this ORDER BY column as being
108509 ** a copy of the iCol-th result-set column. The subsequent call to
108511 ** copy of the iCol-th result-set expression. */
108512 pItem->u.x.iOrderByCol = (u16)iCol;
108519 ** order-by term to a copy of the result-set expression */
108524 pItem->u.x.iOrderByCol = (u16)iCol;
108529 pItem->u.x.iOrderByCol = 0;
108533 for(j=0; j<pSelect->pEList->nExpr; j++){
108534 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
108539 pItem->u.x.iOrderByCol = j+1;
108557 Select *pLeftmost; /* Left-most of SELECT of a compound */
108562 if( p->selFlags & SF_Resolved ){
108565 pOuterNC = pWalker->u.pNC;
108566 pParse = pWalker->pParse;
108567 db = pParse->db;
108577 if( (p->selFlags & SF_Expanded)==0 ){
108579 return pParse->nErr ? WRC_Abort : WRC_Prune;
108582 isCompound = p->pPrior!=0;
108586 assert( (p->selFlags & SF_Expanded)!=0 );
108587 assert( (p->selFlags & SF_Resolved)==0 );
108588 p->selFlags |= SF_Resolved;
108596 if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
108602 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
108603 ** as if it were part of the sub-query, not the parent. This block
108604 ** moves the pOrderBy down to the sub-query. It will be moved back
108606 if( p->selFlags & SF_Converted ){
108607 Select *pSub = p->pSrc->a[0].pSelect;
108608 assert( p->pSrc->nSrc==1 && p->pOrderBy );
108609 assert( pSub->pPrior && pSub->pOrderBy==0 );
108610 pSub->pOrderBy = p->pOrderBy;
108611 p->pOrderBy = 0;
108616 if( pOuterNC ) pOuterNC->nNestedSelect++;
108617 for(i=0; i<p->pSrc->nSrc; i++){
108618 SrcItem *pItem = &p->pSrc->a[i];
108619 assert( pItem->zName!=0 || pItem->pSelect!=0 );/* Test of tag-20240424-1*/
108620 if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
108621 int nRef = pOuterNC ? pOuterNC->nRef : 0;
108622 const char *zSavedContext = pParse->zAuthContext;
108624 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
108625 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
108626 pParse->zAuthContext = zSavedContext;
108627 if( pParse->nErr ) return WRC_Abort;
108628 assert( db->mallocFailed==0 );
108631 ** expressions in the sub-select were resolved, the sub-select
108637 assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef );
108638 pItem->fg.isCorrelated = (pOuterNC->nRef>nRef);
108642 if( pOuterNC && ALWAYS(pOuterNC->nNestedSelect>0) ){
108643 pOuterNC->nNestedSelect--;
108646 /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
108647 ** resolve the result-set expression list.
108650 sNC.pSrcList = p->pSrc;
108654 if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
108657 /* If there are no aggregate functions in the result-set, and no GROUP BY
108660 assert( (p->selFlags & SF_Aggregate)==0 );
108661 pGroupBy = p->pGroupBy;
108665 p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg));
108670 /* Add the output column list to the name-context before parsing the
108676 ** re-evaluated for each reference to it.
108679 sNC.uNC.pEList = p->pEList;
108681 if( p->pHaving ){
108682 if( (p->selFlags & SF_Aggregate)==0 ){
108683 sqlite3ErrorMsg(pParse, "HAVING clause on a non-aggregate query");
108686 if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
108689 if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
108692 /* Resolve names in table-valued-function arguments */
108693 for(i=0; i<p->pSrc->nSrc; i++){
108694 SrcItem *pItem = &p->pSrc->a[i];
108695 if( pItem->fg.isTabFunc
108696 && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
108705 for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
108706 if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
108707 || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
108722 ** the sub-query back to the parent query. At this point each term
108726 if( p->selFlags & SF_Converted ){
108727 Select *pSub = p->pSrc->a[0].pSelect;
108728 p->pOrderBy = pSub->pOrderBy;
108729 pSub->pOrderBy = 0;
108734 ** below, after all of the result-sets for all of the elements of
108737 ** If there is an ORDER BY clause on a term of a compound-select other
108738 ** than the right-most term, then that is a syntax error. But the error
108742 if( p->pOrderBy!=0
108743 && isCompound<=nCompound /* Defer right-most ORDER BY of a compound */
108744 && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
108748 if( db->mallocFailed ){
108759 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
108762 for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
108763 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
108773 if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
108774 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
108780 p = p->pPrior;
108796 ** table columns and result-set columns. At the same time, do error
108804 ** the symbolic name assigned to an ATTACH-ed database.
108815 ** Expr.iColumn The column index in X.Y. -1 for the rowid.
108819 ** To resolve result-set references, look for expression nodes of the
108820 ** form Z (with no X and Y prefix) where the Z matches the right-hand
108821 ** size of an AS clause in the result-set of a SELECT. The Z expression
108822 ** is replaced by a copy of the left-hand side of the result-set expression.
108823 ** Table-name and function resolution occurs on the substituted expression
108850 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
108851 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
108852 w.pParse = pNC->pParse;
108854 w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep;
108858 w.pParse->nHeight += pExpr->nHeight;
108859 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
108866 w.pParse->nHeight -= pExpr->nHeight;
108870 testcase( pNC->ncFlags & NC_HasAgg );
108871 testcase( pNC->ncFlags & NC_HasWin );
108872 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108873 pNC->ncFlags |= savedHasAgg;
108874 return pNC->nNcErr>0 || w.pParse->nErr>0;
108893 w.pParse = pNC->pParse;
108898 savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
108899 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
108900 for(i=0; i<pList->nExpr; i++){
108901 Expr *pExpr = pList->a[i].pExpr;
108904 w.pParse->nHeight += pExpr->nHeight;
108905 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
108911 w.pParse->nHeight -= pExpr->nHeight;
108915 testcase( pNC->ncFlags & NC_HasAgg );
108916 testcase( pNC->ncFlags & NC_HasWin );
108917 if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){
108918 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108919 savedHasAgg |= pNC->ncFlags &
108921 pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
108923 if( w.pParse->nErr>0 ) return SQLITE_ERROR;
108925 pNC->ncFlags |= savedHasAgg;
108931 ** descendants of the SELECT, including compounds off of p->pPrior,
108962 ** ------------
108970 ** nodes of the expression is set to -1 and the Expr.iColumn value is
108982 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
108983 NameContext sNC; /* Name context for pParse->pNewTable */
108993 sSrc.a[0].zName = pTab->zName;
108995 sSrc.a[0].iCursor = -1;
108996 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
108997 /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
109036 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
109037 return pTab->aCol[iCol].affinity;
109044 ** or a sub-select with a column as the return value, then the
109058 op = pExpr->op;
109059 while( 1 /* exit-by-break */ ){
109060 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
109062 assert( pExpr->y.pTab!=0 );
109063 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
109067 assert( pExpr->x.pSelect!=0 );
109068 assert( pExpr->x.pSelect->pEList!=0 );
109069 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
109070 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
109075 return sqlite3AffinityType(pExpr->u.zToken, 0);
109079 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
109080 assert( pExpr->iColumn < pExpr->iTable );
109081 assert( pExpr->iColumn >= 0 );
109082 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
109084 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
109089 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
109092 assert( pExpr->op==TK_COLLATE
109093 || pExpr->op==TK_IF_NULL_ROW
109094 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
109095 pExpr = pExpr->pLeft;
109096 op = pExpr->op;
109099 if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break;
109101 return pExpr->affExpr;
109116 switch( pExpr->op ){
109120 pExpr = pExpr->pLeft;
109155 ExprList *pList = pExpr->x.pList;
109157 assert( pList->nExpr > 0);
109158 for(ii=1; ii<pList->nExpr; ii+=2){
109159 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
109161 if( pList->nExpr % 2 ){
109162 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
109179 ** If a memory allocation error occurs, that fact is recorded in pParse->db
109188 if( pCollName->n>0 ){
109189 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
109191 pNew->pLeft = pExpr;
109192 pNew->flags |= EP_Collate|EP_Skip;
109214 assert( pExpr->op==TK_COLLATE );
109215 pExpr = pExpr->pLeft;
109229 assert( pExpr->x.pList->nExpr>0 );
109230 assert( pExpr->op==TK_FUNCTION );
109231 pExpr = pExpr->x.pList->a[0].pExpr;
109232 }else if( pExpr->op==TK_COLLATE ){
109233 pExpr = pExpr->pLeft;
109256 sqlite3 *db = pParse->db;
109260 int op = p->op;
109261 if( op==TK_REGISTER ) op = p->op2;
109262 if( (op==TK_AGG_COLUMN && p->y.pTab!=0)
109267 assert( p->y.pTab!=0 );
109268 if( (j = p->iColumn)>=0 ){
109269 const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]);
109275 p = p->pLeft;
109280 p = p->x.pList->a[0].pExpr;
109285 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
109288 if( p->flags & EP_Collate ){
109289 if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
109290 p = p->pLeft;
109292 Expr *pNext = p->pRight;
109294 assert( !ExprUseXList(p) || p->x.pList==0 || p->pRight==0 );
109295 if( ExprUseXList(p) && p->x.pList!=0 && !db->mallocFailed ){
109297 for(i=0; i<p->x.pList->nExpr; i++){
109298 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
109299 pNext = p->x.pList->a[i].pExpr;
109328 if( p==0 ) p = pParse->db->pDfltColl;
109339 return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0;
109371 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
109372 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
109373 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
109374 assert( pExpr->pLeft );
109375 aff = sqlite3ExprAffinity(pExpr->pLeft);
109376 if( pExpr->pRight ){
109377 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
109379 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
109436 if( pLeft->flags & EP_Collate ){
109438 }else if( pRight && (pRight->flags & EP_Collate)!=0 ){
109459 return sqlite3BinaryCompareCollSeq(pParse, p->pRight, p->pLeft);
109461 return sqlite3BinaryCompareCollSeq(pParse, p->pLeft, p->pRight);
109482 if( pParse->nErr ) return 0;
109489 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
109491 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
109511 ** is a sub-select, return the number of columns in the sub-select. For
109515 u8 op = pExpr->op;
109516 if( op==TK_REGISTER ) op = pExpr->op2;
109519 return pExpr->x.pList->nExpr;
109522 return pExpr->x.pSelect->pEList->nExpr;
109529 ** Return a pointer to a subexpression of pVector that is the i-th
109539 ** just the expression for the i-th term of the result set, and may
109544 assert( i<sqlite3ExprVectorSize(pVector) || pVector->op==TK_ERROR );
109546 assert( pVector->op2==0 || pVector->op==TK_REGISTER );
109547 if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){
109549 return pVector->x.pSelect->pEList->a[i].pExpr;
109552 return pVector->x.pList->a[i].pExpr;
109561 ** the iField-th column of the vector expression pVector.
109581 Expr *pVector, /* The vector. List of expressions or a sub-SELECT */
109586 if( pVector->op==TK_SELECT ){
109594 ** pLeft->iTable: First in an array of register holding result, or 0
109607 pRet->iTable = nField;
109608 pRet->iColumn = iField;
109609 pRet->pLeft = pVector;
109612 if( pVector->op==TK_VECTOR ){
109615 ppVector = &pVector->x.pList->a[iField].pExpr;
109623 pRet = sqlite3ExprDup(pParse->db, pVector, 0);
109631 ** sub-select returns more than one column, the first in an array
109639 if( pExpr->op==TK_SELECT ){
109647 ** Argument pVector points to a vector expression - either a TK_VECTOR
109655 ** containing the results of the sub-select.
109672 u8 op = pVector->op;
109676 return pVector->iTable+iField;
109680 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
109685 *ppExpr = pVector->x.pList->a[iField].pExpr;
109698 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
109699 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
109700 ** otherwise: op==pExpr->op and p5==0
109709 Vdbe *v = pParse->pVdbe;
109710 Expr *pLeft = pExpr->pLeft;
109711 Expr *pRight = pExpr->pRight;
109722 if( pParse->nErr ) return;
109727 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
109728 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
109729 || pExpr->op==TK_LT || pExpr->op==TK_GT
109730 || pExpr->op==TK_LE || pExpr->op==TK_GE
109732 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
109733 || (pExpr->op==TK_ISNOT && op==TK_NE) );
109734 assert( p5==0 || pExpr->op!=op );
109735 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
109763 if( (opx==TK_LT || opx==TK_GT) && i<nLeft-1 ){
109773 if( i==nLeft-1 ){
109781 if( i==nLeft-2 ) opx = op;
109799 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
109820 if( p->nHeight>*pnHeight ){
109821 *pnHeight = p->nHeight;
109828 for(i=0; i<p->nExpr; i++){
109829 heightOfExpr(p->a[i].pExpr, pnHeight);
109835 for(p=pSelect; p; p=p->pPrior){
109836 heightOfExpr(p->pWhere, pnHeight);
109837 heightOfExpr(p->pHaving, pnHeight);
109838 heightOfExpr(p->pLimit, pnHeight);
109839 heightOfExprList(p->pEList, pnHeight);
109840 heightOfExprList(p->pGroupBy, pnHeight);
109841 heightOfExprList(p->pOrderBy, pnHeight);
109856 int nHeight = p->pLeft ? p->pLeft->nHeight : 0;
109857 if( NEVER(p->pRight) && p->pRight->nHeight>nHeight ){
109858 nHeight = p->pRight->nHeight;
109861 heightOfSelect(p->x.pSelect, &nHeight);
109862 }else if( p->x.pList ){
109863 heightOfExprList(p->x.pList, &nHeight);
109864 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
109866 p->nHeight = nHeight + 1;
109878 if( pParse->nErr ) return;
109880 sqlite3ExprCheckHeight(pParse, p->nHeight);
109898 if( pParse->nErr ) return;
109899 if( p && ExprUseXList(p) && p->x.pList ){
109900 p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
109912 pExpr->w.iOfst = iOfst;
109926 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
109929 ** Special case (tag-20240227-a): If op==TK_INTEGER and pToken points to
109930 ** a string that can be translated into a 32-bit integer, then the token is
109934 ** See also tag-20240227-b.
109948 if( op!=TK_INTEGER || pToken->z==0
109949 || sqlite3GetInt32(pToken->z, &iValue)==0 ){
109950 nExtra = pToken->n+1; /* tag-20240227-a */
109957 pNew->op = (u8)op;
109958 pNew->iAgg = -1;
109961 pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
109962 pNew->u.iValue = iValue;
109964 pNew->u.zToken = (char*)&pNew[1];
109965 assert( pToken->z!=0 || pToken->n==0 );
109966 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
109967 pNew->u.zToken[pToken->n] = 0;
109968 if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
109974 pNew->nHeight = 1;
109981 ** Allocate a new expression node from a zero-terminated token that has
110008 assert( db->mallocFailed );
110013 assert( pRoot->x.pSelect==0 );
110015 pRoot->pRight = pRight;
110016 pRoot->flags |= EP_Propagate & pRight->flags;
110018 pRoot->nHeight = pRight->nHeight+1;
110020 pRoot->nHeight = 1;
110024 pRoot->pLeft = pLeft;
110025 pRoot->flags |= EP_Propagate & pLeft->flags;
110027 if( pLeft->nHeight>=pRoot->nHeight ){
110028 pRoot->nHeight = pLeft->nHeight+1;
110039 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
110049 p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
110052 p->op = op & 0xff;
110053 p->iAgg = -1;
110054 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
110055 sqlite3ExprCheckHeight(pParse, p->nHeight);
110057 sqlite3ExprDelete(pParse->db, pLeft);
110058 sqlite3ExprDelete(pParse->db, pRight);
110069 pExpr->x.pSelect = pSelect;
110073 assert( pParse->db->mallocFailed );
110074 sqlite3SelectDelete(pParse->db, pSelect);
110101 for(ii=0; ii<pEList->nExpr; ii++){
110103 Expr *pExpr = pEList->a[ii].pExpr;
110105 if( pExpr->op==TK_VECTOR ){
110107 nExprElem = pExpr->x.pList->nExpr;
110112 sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d",
110118 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
110119 pExpr->x.pList = 0;
110122 pSel->op = TK_ALL;
110123 pSel->pPrior = pRet;
110129 if( pRet && pRet->pPrior ){
110130 pRet->selFlags |= SF_MultiValue;
110132 sqlite3ExprListDelete(pParse->db, pEList);
110145 sqlite3 *db = pParse->db;
110151 u32 f = pLeft->flags | pRight->flags;
110175 sqlite3 *db = pParse->db;
110183 pNew->w.iOfst = (int)(pToken->z - pParse->zTail);
110185 && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
110186 && !pParse->nested
110190 pNew->x.pList = pList;
110200 ** the arguments of a non-aggregate function.
110204 "ORDER BY may not be used with non-aggregate %#T()", p
110224 sqlite3 *db = pParse->db;
110226 assert( db->mallocFailed );
110230 assert( db->mallocFailed );
110234 assert( pExpr->op==TK_FUNCTION );
110235 assert( pExpr->pLeft==0 );
110237 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
110238 /* Ignore ORDER BY on zero-argument aggregates */
110253 pOB->x.pList = pOrderBy;
110255 pExpr->pLeft = pOB;
110263 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
110265 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
110266 ** top-level SQL
110276 assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 );
110278 if( (pDef->funcFlags & SQLITE_FUNC_DIRECT)!=0
110279 || (pParse->db->flags & SQLITE_TrustedSchema)==0
110310 sqlite3 *db = pParse->db;
110316 z = pExpr->u.zToken;
110323 x = (ynVar)(++pParse->nVar);
110331 if( n==2 ){ /*OPTIMIZATION-IF-TRUE*/
110332 i = z[1]-'0'; /* The common case of ?N for a single digit N */
110335 bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
110339 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
110340 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
110341 if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
110343 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
110344 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110348 if( x>pParse->nVar ){
110349 pParse->nVar = (int)x;
110351 }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){
110359 x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n);
110361 x = (ynVar)(++pParse->nVar);
110366 pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x);
110369 pExpr->iColumn = x;
110370 if( x>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
110372 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110383 assert( !ExprUseUValue(p) || p->u.iValue>=0 );
110385 assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed );
110386 assert( p->op!=TK_FUNCTION || !ExprUseYSub(p) );
110389 assert( p->pLeft==0 );
110390 assert( p->pRight==0 );
110391 assert( !ExprUseXSelect(p) || p->x.pSelect==0 );
110392 assert( !ExprUseXList(p) || p->x.pList==0 );
110397 assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 );
110398 if( p->pRight ){
110400 sqlite3ExprDeleteNN(db, p->pRight);
110403 sqlite3SelectDelete(db, p->x.pSelect);
110405 sqlite3ExprListDelete(db, p->x.pList);
110408 sqlite3WindowDelete(db, p->y.pWin);
110412 if( p->pLeft && p->op!=TK_SELECT_COLUMN ){
110413 Expr *pLeft = p->pLeft;
110443 }else if( p->pOn ){
110444 sqlite3ExprDeleteNN(db, p->pOn);
110445 }else if( p->pUsing ){
110446 sqlite3IdListDelete(db, p->pUsing);
110457 ** Return 0 if the delete was successfully deferred. Return non-zero
110472 sqlite3ExprDeleteNN(pParse->db, p);
110498 ** The dupedExprStructSize() function returns two values OR-ed together:
110511 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
110532 if( p->pLeft || p->x.pList ){
110535 assert( p->pRight==0 );
110549 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
110550 nByte += sqlite3Strlen30NN(p->u.zToken)+1;
110570 if( p->pLeft ) nByte += dupedExprSize(p->pLeft);
110571 if( p->pRight ) nByte += dupedExprSize(p->pRight);
110579 ** compression while doing sqlite3ExprDup(). The top-level Expr does the
110595 ** of the input Expr p together with its p->u.zToken (if any). pEdupBuf
110607 int nToken = -1; /* Space needed for p->u.zToken. -1 means unknown */
110616 sEdupBuf.zAlloc = pEdupBuf->zAlloc;
110618 sEdupBuf.zEnd = pEdupBuf->zEnd;
110627 }else if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
110628 nToken = sqlite3Strlen30NN(p->u.zToken)+1;
110649 ** by the copy of the p->u.zToken string (if any).
110654 if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
110655 nToken = sqlite3Strlen30(p->u.zToken) + 1;
110661 assert( (int)(sEdupBuf.zEnd - sEdupBuf.zAlloc) >= nNewSize+nToken );
110666 assert( (int)(sEdupBuf.zEnd - sEdupBuf.zAlloc) >=
110670 memset(&sEdupBuf.zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
110676 pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
110677 pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
110678 pNew->flags |= staticFlag;
110684 /* Copy the p->u.zToken string, if any. */
110687 char *zToken = pNew->u.zToken = (char*)&sEdupBuf.zAlloc[nNewSize];
110688 memcpy(zToken, p->u.zToken, nToken);
110693 if( ((p->flags|pNew->flags)&(EP_TokenOnly|EP_Leaf))==0 ){
110695 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
110697 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags);
110699 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList,
110700 p->op!=TK_ORDER ? dupFlags : 0);
110705 pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin);
110710 /* Fill in pNew->pLeft and pNew->pRight. */
110712 if( p->op==TK_SELECT_COLUMN ){
110713 pNew->pLeft = p->pLeft;
110714 assert( p->pRight==0
110715 || p->pRight==p->pLeft
110716 || ExprHasProperty(p->pLeft, EP_Subquery) );
110718 pNew->pLeft = p->pLeft ?
110719 exprDup(db, p->pLeft, EXPRDUP_REDUCE, &sEdupBuf) : 0;
110721 pNew->pRight = p->pRight ?
110722 exprDup(db, p->pRight, EXPRDUP_REDUCE, &sEdupBuf) : 0;
110724 if( p->op==TK_SELECT_COLUMN ){
110725 pNew->pLeft = p->pLeft;
110726 assert( p->pRight==0
110727 || p->pRight==p->pLeft
110728 || ExprHasProperty(p->pLeft, EP_Subquery) );
110730 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
110732 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
110744 ** and the db->mallocFailed flag set.
110750 sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
110754 pRet->nCte = p->nCte;
110755 for(i=0; i<p->nCte; i++){
110756 pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0);
110757 pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0);
110758 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
110759 pRet->a[i].eM10d = p->a[i].eM10d;
110774 ** objects found there, assembling them onto the linked list at Select->pWin.
110777 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
110778 Select *pSelect = pWalker->u.pSelect;
110779 Window *pWin = pExpr->y.pWin;
110782 assert( pWin->ppThis==0 );
110788 return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune;
110817 ** part of the in-memory representation of the database schema.
110834 pNew->nExpr = p->nExpr;
110835 pNew->nAlloc = p->nAlloc;
110836 pItem = pNew->a;
110837 pOldItem = p->a;
110838 for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
110839 Expr *pOldExpr = pOldItem->pExpr;
110841 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
110843 && pOldExpr->op==TK_SELECT_COLUMN
110844 && (pNewExpr = pItem->pExpr)!=0
110846 if( pNewExpr->pRight ){
110847 pPriorSelectColOld = pOldExpr->pRight;
110848 pPriorSelectColNew = pNewExpr->pRight;
110849 pNewExpr->pLeft = pNewExpr->pRight;
110851 if( pOldExpr->pLeft!=pPriorSelectColOld ){
110852 pPriorSelectColOld = pOldExpr->pLeft;
110854 pNewExpr->pRight = pPriorSelectColNew;
110856 pNewExpr->pLeft = pPriorSelectColNew;
110859 pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName);
110860 pItem->fg = pOldItem->fg;
110861 pItem->fg.done = 0;
110862 pItem->u = pOldItem->u;
110881 nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
110884 pNew->nSrc = pNew->nAlloc = p->nSrc;
110885 for(i=0; i<p->nSrc; i++){
110886 SrcItem *pNewItem = &pNew->a[i];
110887 const SrcItem *pOldItem = &p->a[i];
110889 pNewItem->pSchema = pOldItem->pSchema;
110890 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
110891 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
110892 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
110893 pNewItem->fg = pOldItem->fg;
110894 pNewItem->iCursor = pOldItem->iCursor;
110895 pNewItem->addrFillSub = pOldItem->addrFillSub;
110896 pNewItem->regReturn = pOldItem->regReturn;
110897 pNewItem->regResult = pOldItem->regResult;
110898 if( pNewItem->fg.isIndexedBy ){
110899 pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
110900 }else if( pNewItem->fg.isTabFunc ){
110901 pNewItem->u1.pFuncArg =
110902 sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
110904 pNewItem->u1.nRow = pOldItem->u1.nRow;
110906 pNewItem->u2 = pOldItem->u2;
110907 if( pNewItem->fg.isCte ){
110908 pNewItem->u2.pCteUse->nUse++;
110910 pTab = pNewItem->pTab = pOldItem->pTab;
110912 pTab->nTabRef++;
110914 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
110915 if( pOldItem->fg.isUsing ){
110916 assert( pNewItem->fg.isUsing );
110917 pNewItem->u3.pUsing = sqlite3IdListDup(db, pOldItem->u3.pUsing);
110919 pNewItem->u3.pOn = sqlite3ExprDup(db, pOldItem->u3.pOn, flags);
110921 pNewItem->colUsed = pOldItem->colUsed;
110930 assert( p->eU4!=EU4_EXPR );
110931 pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew)+(p->nId-1)*sizeof(p->a[0]) );
110933 pNew->nId = p->nId;
110934 pNew->eU4 = p->eU4;
110935 for(i=0; i<p->nId; i++){
110936 struct IdList_item *pNewItem = &pNew->a[i];
110937 const struct IdList_item *pOldItem = &p->a[i];
110938 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
110939 pNewItem->u4 = pOldItem->u4;
110950 for(p=pDup; p; p=p->pPrior){
110953 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
110954 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
110955 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
110956 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
110957 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
110958 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
110959 pNew->op = p->op;
110960 pNew->pNext = pNext;
110961 pNew->pPrior = 0;
110962 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
110963 pNew->iLimit = 0;
110964 pNew->iOffset = 0;
110965 pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
110966 pNew->addrOpenEphm[0] = -1;
110967 pNew->addrOpenEphm[1] = -1;
110968 pNew->nSelectRow = p->nSelectRow;
110969 pNew->pWith = sqlite3WithDup(db, p->pWith);
110971 pNew->pWin = 0;
110972 pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
110973 if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
110975 pNew->selId = p->selId;
110976 if( db->mallocFailed ){
110980 pNew->pNext = 0;
110985 pp = &pNew->pPrior;
111007 ** NULL is returned. If non-NULL is returned, then it is guaranteed
111018 pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 );
111023 pList->nAlloc = 4;
111024 pList->nExpr = 1;
111025 pItem = &pList->a[0];
111027 pItem->pExpr = pExpr;
111037 pList->nAlloc *= 2;
111039 sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0]));
111047 pItem = &pList->a[pList->nExpr++];
111049 pItem->pExpr = pExpr;
111059 return sqlite3ExprListAppendNew(pParse->db,pExpr);
111061 if( pList->nAlloc<pList->nExpr+1 ){
111062 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
111064 pItem = &pList->a[pList->nExpr++];
111066 pItem->pExpr = pExpr;
111087 sqlite3 *db = pParse->db;
111090 int iFirst = pList ? pList->nExpr : 0;
111101 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
111103 pColumns->nId, n);
111107 for(i=0; i<pColumns->nId; i++){
111108 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
111109 assert( pSubExpr!=0 || db->mallocFailed );
111113 assert( pList->nExpr==iFirst+i+1 );
111114 pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName;
111115 pColumns->a[i].zName = 0;
111119 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
111120 Expr *pFirst = pList->a[iFirst].pExpr;
111122 assert( pFirst->op==TK_SELECT_COLUMN );
111126 pFirst->pRight = pExpr;
111131 pFirst->iTable = pColumns->nId;
111146 assert( p->nExpr>0 );
111158 pItem = &p->a[p->nExpr-1];
111159 assert( pItem->fg.bNulls==0 );
111163 pItem->fg.sortFlags = (u8)iSortOrder;
111166 pItem->fg.bNulls = 1;
111168 pItem->fg.sortFlags |= KEYINFO_ORDER_BIGNULL;
111178 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
111187 assert( pList!=0 || pParse->db->mallocFailed!=0 );
111188 assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 );
111191 assert( pList->nExpr>0 );
111192 pItem = &pList->a[pList->nExpr-1];
111193 assert( pItem->zEName==0 );
111194 assert( pItem->fg.eEName==ENAME_NAME );
111195 pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
111197 /* If dequote==0, then pName->z does not point to part of a DDL
111199 ** to the token-map. */
111200 sqlite3Dequote(pItem->zEName);
111202 sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName);
111213 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
111222 sqlite3 *db = pParse->db;
111223 assert( pList!=0 || db->mallocFailed!=0 );
111225 struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
111226 assert( pList->nExpr>0 );
111227 if( pItem->zEName==0 ){
111228 pItem->zEName = sqlite3DbSpanDup(db, zStart, zEnd);
111229 pItem->fg.eEName = ENAME_SPAN;
111243 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
111244 testcase( pEList && pEList->nExpr==mx );
111245 testcase( pEList && pEList->nExpr==mx+1 );
111246 if( pEList && pEList->nExpr>mx ){
111255 int i = pList->nExpr;
111256 struct ExprList_item *pItem = pList->a;
111257 assert( pList->nExpr>0 );
111260 sqlite3ExprDelete(db, pItem->pExpr);
111261 if( pItem->zEName ) sqlite3DbNNFreeNN(db, pItem->zEName);
111263 }while( --i>0 );
111274 ** Return the bitwise-OR of all Expr.flags fields in the given
111281 for(i=0; i<pList->nExpr; i++){
111282 Expr *pExpr = pList->a[i].pExpr;
111284 m |= pExpr->flags;
111290 ** This is a SELECT-node callback for the expression walker that
111292 ** pWalker->eCode to zero and abort.
111298 pWalker->eCode = 0;
111319 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
111324 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
111326 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
111328 pExpr->op = TK_TRUEFALSE;
111341 assert( pExpr->op==TK_TRUEFALSE );
111343 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
111344 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
111345 return pExpr->u.zToken[4]==0;
111363 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
111364 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
111365 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
111367 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
111369 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
111385 ** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
111386 ** It makes no changes to pWalker->eCode if pExpr is constant. In
111400 assert( pExpr->op==TK_FUNCTION );
111402 || (pList = pExpr->x.pList)==0
111406 n = pList->nExpr;
111408 if( pWalker->eCode==0 ) return WRC_Abort;
111410 db = pWalker->pParse->db;
111411 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
111413 || pDef->xFinalize!=0
111414 || (pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
111417 pWalker->eCode = 0;
111432 ** sqlite3ExprIsConstant() pWalker->eCode==1
111433 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
111434 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
111435 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
111451 assert( pWalker->eCode>0 );
111453 /* If pWalker->eCode is 2 then any term of the expression that comes from
111456 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
111457 pWalker->eCode = 0;
111461 switch( pExpr->op ){
111463 ** and either pWalker->eCode==4 or 5 or the function has the
111466 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
111469 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
111471 }else if( pWalker->pParse ){
111474 pWalker->eCode = 0;
111487 testcase( pExpr->op==TK_ID );
111488 testcase( pExpr->op==TK_COLUMN );
111489 testcase( pExpr->op==TK_AGG_FUNCTION );
111490 testcase( pExpr->op==TK_AGG_COLUMN );
111491 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
111494 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
111502 testcase( pExpr->op==TK_REGISTER );
111503 testcase( pExpr->op==TK_IF_NULL_ROW );
111504 testcase( pExpr->op==TK_DOT );
111505 testcase( pExpr->op==TK_RAISE );
111506 pWalker->eCode = 0;
111509 if( pWalker->eCode==5 ){
111513 pExpr->op = TK_NULL;
111514 }else if( pWalker->eCode==4 ){
111517 pWalker->eCode = 0;
111522 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
111523 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
111541 ** Walk an expression tree. Return non-zero if the expression is constant
111544 ** For the purposes of this function, a double-quoted string (ex: "abc")
111545 ** is considered a variable but a single-quoted string (ex: 'abc') is
111550 ** function calls will be considered to be non-constant. If pParse is
111559 ** Walk an expression tree. Return non-zero if
111568 ** can be added to the pParse->pConstExpr list and evaluated once when
111576 ** This routine examines sub-SELECT statements as an expression is being
111577 ** walked as part of sqlite3ExprIsTableConstant(). Sub-SELECTs are considered
111578 ** constant as long as they are uncorrelated - meaning that they do not
111583 assert( pWalker->eCode==3 || pWalker->eCode==0 );
111584 if( (pSelect->selFlags & SF_Correlated)!=0 ){
111585 pWalker->eCode = 0;
111592 ** Walk an expression tree. Return non-zero if the expression is constant
111594 ** expression must not refer to any non-deterministic function nor any
111620 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
111622 ** sources anywhere else in the query. Return true (non-zero) if pExpr
111629 ** To be an single-source constraint, the following must be true:
111631 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
111634 ** true and the subquery is non-correlated
111636 ** (2b) pExpr cannot use non-deterministic functions.
111656 ** Without this restriction, accepting pExpr as a single-table
111660 ** on push-down.
111666 int bAllowSubq /* Allow non-correlated subqueries */
111668 const SrcItem *pSrc = &pSrcList->a[iSrc];
111669 if( pSrc->fg.jointype & JT_LTORJ ){
111672 if( pSrc->fg.jointype & JT_LEFT ){
111674 if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */
111679 && (pSrcList->a[0].fg.jointype & JT_LTORJ)!=0 /* Fast pre-test of (6b) */
111683 if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
111684 if( (pSrcList->a[jj].fg.jointype & JT_LTORJ)!=0 ){
111692 return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
111700 ExprList *pGroupBy = pWalker->u.pGroupBy;
111705 for(i=0; i<pGroupBy->nExpr; i++){
111706 Expr *p = pGroupBy->a[i].pExpr;
111707 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
111708 CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p);
111715 /* Check if pExpr is a sub-select. If so, consider it variable. */
111717 pWalker->eCode = 0;
111725 ** Walk the expression tree passed as the first argument. Return non-zero
111733 ** assumes that no other collating sequence will have a finer-grained
111756 ** in a CREATE TABLE statement. Return non-zero if the expression is
111757 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
111771 ** For the purposes of this function, a double-quoted string (ex: "abc")
111772 ** is considered a variable but a single-quoted string (ex: 'abc') is
111800 ** to fit in a 32-bit integer, return 1 and put the value of the integer
111802 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
111808 /* If an expression is an integer literal that fits in a signed 32-bit
111810 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
111811 || sqlite3GetInt32(p->u.zToken, &rc)==0 );
111813 if( p->flags & EP_IntValue ){
111814 *pValue = p->u.iValue;
111817 switch( p->op ){
111819 rc = sqlite3ExprIsInteger(p->pLeft, pValue);
111824 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
111826 *pValue = -v;
111853 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
111854 p = p->pLeft;
111857 op = p->op;
111858 if( op==TK_REGISTER ) op = p->op2;
111868 || NEVER(p->y.pTab==0) /* Reference to column of index on expr */
111870 || (p->iColumn==XN_ROWID && IsView(p->y.pTab))
111872 || (p->iColumn>=0
111873 && p->y.pTab->aCol!=0 /* Possible due to prior error */
111874 && ALWAYS(p->iColumn<p->y.pTab->nCol)
111875 && p->y.pTab->aCol[p->iColumn].notNull==0);
111895 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
111896 if( p->op==TK_UMINUS ) unaryMinus = 1;
111897 p = p->pLeft;
111899 op = p->op;
111900 if( op==TK_REGISTER ) op = p->op2;
111915 assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
111916 return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0;
111925 ** Return TRUE if the given string is a row-id column name.
111936 ** pTab. An alias is usable if there is not an explicit user-defined column
111945 for(iCol=0; iCol<pTab->nCol; iCol++){
111946 if( sqlite3_stricmp(azOpt[ii], pTab->aCol[iCol].zCnName)==0 ) break;
111948 if( iCol==pTab->nCol ){
111971 p = pX->x.pSelect;
111972 if( p->pPrior ) return 0; /* Not a compound SELECT */
111973 if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
111974 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
111975 testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
111978 assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
111979 if( p->pLimit ) return 0; /* Has no LIMIT clause */
111980 if( p->pWhere ) return 0; /* Has no WHERE clause */
111981 pSrc = p->pSrc;
111983 if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
111984 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
111985 pTab = pSrc->a[0].pTab;
111989 pEList = p->pEList;
111992 for(i=0; i<pEList->nExpr; i++){
111993 Expr *pRes = pEList->a[i].pExpr;
111994 if( pRes->op!=TK_COLUMN ) return 0;
111995 assert( pRes->iTable==pSrc->a[0].iCursor ); /* Not a correlated subquery */
112003 ** Generate code that checks the left-most column of index table iCur to see if
112005 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
112023 ** right-hand side. Return TRUE if that list is constant.
112029 pLHS = pIn->pLeft;
112030 pIn->pLeft = 0;
112032 pIn->pLeft = pLHS;
112042 ** The job of this routine is to find or create a b-tree object that can
112046 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
112049 ** The returned value of this function indicates the b-tree type, as follows:
112051 ** IN_INDEX_ROWID - The cursor was opened on a database table.
112052 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
112053 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
112054 ** IN_INDEX_EPH - The cursor was opened on a specially created and
112056 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
112059 ** An existing b-tree might be used if the RHS expression pX is a simple
112066 ** pX->iTable made to point to the ephemeral table instead of an
112069 ** will be set on pX and the pX->y.sub fields will be set to show where
112078 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
112079 ** through the set members) then the b-tree must not contain duplicates.
112081 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
112084 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
112087 ** index can be found with the specified <columns> as its left-most.
112091 ** routine might decide that creating an ephemeral b-tree for membership
112096 ** When the b-tree is being used for membership tests, the calling function
112105 ** the value in that register will be NULL if the b-tree contains one or more
112106 ** NULL values, and it will be some non-NULL value if the b-tree contains no
112135 assert( pX->op==TK_IN );
112137 iTab = pParse->nTab++;
112146 ExprList *pEList = pX->x.pSelect->pEList;
112147 for(i=0; i<pEList->nExpr; i++){
112148 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
112150 if( i==pEList->nExpr ){
112158 if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){
112159 sqlite3 *db = pParse->db; /* Database connection */
112162 ExprList *pEList = p->pEList;
112163 int nExpr = pEList->nExpr;
112165 assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
112166 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
112167 assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
112168 pTab = p->pSrc->a[0].pTab;
112171 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112174 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
112177 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
112185 "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
112197 Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
112198 int iCol = pEList->a[i].pExpr->iColumn;
112220 for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
112223 if( pIdx->nColumn<nExpr ) continue;
112224 if( pIdx->pPartIdxWhere!=0 ) continue;
112225 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
112227 testcase( pIdx->nColumn==BMS-2 );
112228 testcase( pIdx->nColumn==BMS-1 );
112229 if( pIdx->nColumn>=BMS-1 ) continue;
112231 if( pIdx->nKeyCol>nExpr
112232 ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx))
112240 Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
112241 Expr *pRhs = pEList->a[i].pExpr;
112246 if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
112247 assert( pIdx->azColl[j] );
112248 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
112260 assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) );
112261 if( colUsed==(MASKBIT(nExpr)-1) ){
112265 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
112266 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
112268 VdbeComment((v, "%s", pIdx->zName));
112270 eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0];
112274 i64 mask = (1<<nExpr)-1;
112278 *prRhsHasNull = ++pParse->nMem;
112300 && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
112302 pParse->nTab--; /* Back out the allocation of the unused cursor */
112303 iTab = -1; /* Cursor is not allocated */
112308 /* Could not find an existing table or index to use as the RHS b-tree.
112311 u32 savedNQueryLoop = pParse->nQueryLoop;
112315 pParse->nQueryLoop = 0;
112317 *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
112319 assert( pX->op==TK_IN );
112324 pParse->nQueryLoop = savedNQueryLoop;
112329 n = sqlite3ExprVectorSize(pX->pLeft);
112340 ** function allocates and returns a nul-terminated string containing
112347 Expr *pLeft = pExpr->pLeft;
112349 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
112352 assert( pExpr->op==TK_IN );
112353 zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
112360 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
112376 ** "sub-select returns N columns - expected M"
112379 if( pParse->nErr==0 ){
112380 const char *zFmt = "sub-select returns %d columns - expected %d";
112388 ** it is not permitted. If pExpr is a sub-select vector, this routine
112391 ** "sub-select returns N columns - expected 1"
112400 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
112414 ** x IN (4,5,11) -- IN operator with list on right-hand side
112415 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
112419 ** table is computed, the cursor number is also stored in pExpr->iTable,
112443 v = pParse->pVdbe;
112449 ** * The right-hand side is a correlated subquery
112450 ** * The right-hand side is an expression list containing variables
112456 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
112465 pExpr->x.pSelect->selId));
112468 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112469 pExpr->y.sub.iAddr);
112470 assert( iTab!=pExpr->iTable );
112471 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
112480 pExpr->y.sub.regReturn = ++pParse->nMem;
112481 pExpr->y.sub.iAddr =
112482 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112488 pLeft = pExpr->pLeft;
112494 pExpr->iTable = iTab;
112495 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
112498 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
112503 pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
112511 Select *pSelect = pExpr->x.pSelect;
112512 ExprList *pEList = pSelect->pEList;
112515 addrOnce?"":"CORRELATED ", pSelect->selId
112519 if( ALWAYS(pEList->nExpr==nVal) ){
112526 pSelect->iLimit = 0;
112527 testcase( pSelect->selFlags & SF_Distinct );
112529 pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
112530 rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
112531 sqlite3SelectDelete(pParse->db, pCopy);
112532 sqlite3DbFree(pParse->db, dest.zAffSdst);
112539 assert( pEList->nExpr>0 );
112543 pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
112544 pParse, p, pEList->a[i].pExpr
112548 }else if( ALWAYS(pExpr->x.pList!=0) ){
112558 ExprList *pList = pExpr->x.pList;
112569 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112575 for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
112576 Expr *pE2 = pItem->pExpr;
112580 ** this code only executes once. Because for a non-constant
112584 sqlite3VdbeChangeToNoop(v, addrOnce-1);
112606 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112607 || pParse->nErr );
112608 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112609 pExpr->y.sub.iAddr, 1);
112620 ** (SELECT a FROM b) -- subquery
112621 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
112625 ** Return the register that holds the result. For a multi-column SELECT,
112627 ** return value is the register of the left-most result column.
112642 Vdbe *v = pParse->pVdbe;
112644 if( pParse->nErr ) return 0;
112645 testcase( pExpr->op==TK_EXISTS );
112646 testcase( pExpr->op==TK_SELECT );
112647 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
112649 pSel = pExpr->x.pSelect;
112654 ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
112656 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112657 pExpr->y.sub.iAddr);
112658 return pExpr->iTable;
112665 pExpr->y.sub.regReturn = ++pParse->nMem;
112666 pExpr->y.sub.iAddr =
112667 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112672 ** * The right-hand side is a correlated subquery
112673 ** * The right-hand side is an expression list containing variables
112694 addrOnce?"":"CORRELATED ", pSel->selId));
112695 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1);
112696 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
112697 sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
112698 pParse->nMem += nReg;
112699 if( pExpr->op==TK_SELECT ){
112703 sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
112710 if( pSel->pLimit ){
112711 /* The subquery already has a limit. If the pre-existing limit is X
112713 sqlite3 *db = pParse->db;
112716 pLimit->affExpr = SQLITE_AFF_NUMERIC;
112718 sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit);
112720 sqlite3ExprDeferredDelete(pParse, pSel->pLimit->pLeft);
112721 pSel->pLimit->pLeft = pLimit;
112723 /* If there is no pre-existing limit add a limit of 1 */
112724 pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
112725 pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
112727 pSel->iLimit = 0;
112729 pExpr->op2 = pExpr->op;
112730 pExpr->op = TK_ERROR;
112733 pExpr->iTable = rReg = dest.iSDParm;
112738 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
112742 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112743 || pParse->nErr );
112744 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112745 pExpr->y.sub.iAddr, 1);
112755 ** sub-select on the RHS of the IN() operator has the same number of
112757 ** a sub-query, that the LHS is a vector of size 1.
112760 int nVector = sqlite3ExprVectorSize(pIn->pLeft);
112761 if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){
112762 if( nVector!=pIn->x.pSelect->pEList->nExpr ){
112763 sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector);
112767 sqlite3VectorErrorMsg(pParse, pIn->pLeft);
112781 ** The left-hand side (LHS) is a scalar or vector expression. The
112782 ** right-hand side (RHS) is an array of zero or more scalar values, or a
112797 ** See the separate in-operator.md documentation file in the canonical
112821 int addrTop; /* Top of the step-6 loop */
112823 u8 okConstFactor = pParse->okConstFactor;
112826 pLeft = pExpr->pLeft;
112829 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
112831 pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1
112833 if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
112839 v = pParse->pVdbe;
112847 assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH
112852 ** nVector-1. */
112872 assert( pParse->okConstFactor==okConstFactor );
112873 pParse->okConstFactor = 0;
112875 pParse->okConstFactor = okConstFactor;
112892 ** This is step (1) in the in-operator.md optimized algorithm.
112902 pList = pExpr->x.pList;
112903 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112908 for(ii=0; ii<pList->nExpr; ii++){
112909 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
112910 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
112914 if( ii<pList->nExpr-1 || destIfNull!=destIfFalse ){
112918 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
112919 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
112920 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull);
112921 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull);
112952 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
112953 if( pParse->nErr ) goto sqlite3ExprCodeIN_oom_error;
112960 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
112965 /* In this case, the RHS is the ROWID of table b-tree and so we also
112966 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
112984 /* Step 4. If the RHS is known to be non-NULL and we did not find
113044 sqlite3DbFree(pParse->db, aiMap);
113045 sqlite3DbFree(pParse->db, zAff);
113052 ** value described by z[0..n-1] into register iMem.
113054 ** The z[] string will probably not be zero-terminated. But the
113063 if( negateFlag ) value = -value;
113072 ** text z[0..n-1] into register iMem.
113074 ** Expr.u.zToken is always UTF8 and zero-terminated.
113077 Vdbe *v = pParse->pVdbe;
113078 if( pExpr->flags & EP_IntValue ){
113079 int i = pExpr->u.iValue;
113081 if( negFlag ) i = -i;
113086 const char *z = pExpr->u.zToken;
113091 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
113096 negFlag?"-":"",pExpr);
113104 if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; }
113112 ** appropriate for the iIdxCol-th column of index pIdx.
113121 i16 iTabCol = pIdx->aiColumn[iIdxCol];
113123 assert( pIdx->aColExpr );
113124 assert( pIdx->aColExpr->nExpr>iIdxCol );
113125 pParse->iSelfTab = iTabCur + 1;
113126 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
113127 pParse->iSelfTab = 0;
113129 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur,
113146 Vdbe *v = pParse->pVdbe;
113147 int nErr = pParse->nErr;
113149 assert( pParse->iSelfTab!=0 );
113150 if( pParse->iSelfTab>0 ){
113151 iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
113156 if( pCol->affinity>=SQLITE_AFF_TEXT ){
113157 sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
113160 if( pParse->nErr>nErr ) pParse->db->errByteOffset = -1;
113165 ** Generate code to extract the value of the iCol-th column of a table.
113178 if( iCol<0 || iCol==pTab->iPKey ){
113180 VdbeComment((v, "%s.rowid", pTab->zName));
113188 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
113190 if( pCol->colFlags & COLFLAG_BUSY ){
113192 pCol->zCnName);
113194 int savedSelfTab = pParse->iSelfTab;
113195 pCol->colFlags |= COLFLAG_BUSY;
113196 pParse->iSelfTab = iTabCur+1;
113198 pParse->iSelfTab = savedSelfTab;
113199 pCol->colFlags &= ~COLFLAG_BUSY;
113218 ** Generate code that will extract the iColumn-th column from
113232 assert( pParse->pVdbe!=0 );
113235 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
113237 VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
113238 if( pOp->opcode==OP_Column ) pOp->p5 = p5;
113239 if( pOp->opcode==OP_VColumn ) pOp->p5 = (p5 & OPFLAG_NOCHNG);
113245 ** Generate code to move content from registers iFrom...iFrom+nReg-1
113246 ** over to iTo..iTo+nReg-1.
113249 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
113260 p->op2 = p->op;
113261 p->op = TK_REGISTER;
113262 p->iTable = iReg;
113283 if( p->op==TK_SELECT ){
113291 iResult = pParse->nMem+1;
113292 pParse->nMem += nResult;
113295 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
113303 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
113307 if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){
113314 ** in-line rather than by using the usual callbacks.
113323 Vdbe *v = pParse->pVdbe;
113326 nFarg = pFarg->nExpr;
113327 assert( nFarg>0 ); /* All in-line functions have at least one argument */
113330 /* Attempt a direct implementation of the built-in COALESCE() and
113332 ** arguments past the first non-NULL argument.
113337 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
113341 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
113356 Expr *pArg = pFarg->a[0].pExpr;
113357 if( pArg->op==TK_COLUMN && pArg->iTable>=0 ){
113358 sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
113366 /* The UNLIKELY() function is a no-op. The result is the value
113370 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
113375 ** Test-only SQL functions that are only usable if enabled
113383 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
113392 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
113401 pA1 = pFarg->a[1].pExpr;
113402 if( pA1->op==TK_COLUMN ){
113404 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable,1),
113421 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
113425 (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]);
113434 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
113446 for(p=pParse->pIdxEpr; p; p=p->pIENext){
113448 int iDataCur = p->iDataCur;
113450 if( pParse->iSelfTab ){
113451 if( p->iDataCur!=pParse->iSelfTab-1 ) continue;
113452 iDataCur = -1;
113454 if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue;
113455 assert( p->aff>=SQLITE_AFF_BLOB && p->aff<=SQLITE_AFF_NUMERIC );
113457 if( (exprAff<=SQLITE_AFF_BLOB && p->aff!=SQLITE_AFF_BLOB)
113458 || (exprAff==SQLITE_AFF_TEXT && p->aff!=SQLITE_AFF_TEXT)
113459 || (exprAff>=SQLITE_AFF_NUMERIC && p->aff!=SQLITE_AFF_NUMERIC)
113465 v = pParse->pVdbe;
113467 if( p->bMaybeNullRow ){
113472 sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target);
113474 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
113475 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
113477 p = pParse->pIdxEpr;
113478 pParse->pIdxEpr = 0;
113480 pParse->pIdxEpr = p;
113483 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
113484 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
113488 return -1; /* Not found */
113504 for(p=pParse->pIdxPartExpr; p; p=p->pIENext){
113505 if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
113506 Vdbe *v = pParse->pVdbe;
113510 if( p->bMaybeNullRow ){
113511 addr = sqlite3VdbeAddOp1(v, OP_IfNullRow, p->iIdxCur);
113513 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
113514 sqlite3VdbeAddOp4(pParse->pVdbe, OP_Affinity, ret, 1, 0,
113515 (const char*)&p->aff, 1);
113539 Vdbe *v = pParse->pVdbe; /* The VM under construction */
113542 int regFree1 = 0; /* If non-zero free this temporary register */
113543 int regFree2 = 0; /* If non-zero free this temporary register */
113548 assert( target>0 && target<=pParse->nMem );
113554 }else if( pParse->pIdxEpr!=0
113561 op = pExpr->op;
113566 AggInfo *pAggInfo = pExpr->pAggInfo;
113569 assert( pExpr->iAgg>=0 );
113570 if( pExpr->iAgg>=pAggInfo->nColumn ){
113576 ** tag-20230325-2 */
113582 pCol = &pAggInfo->aCol[pExpr->iAgg];
113583 if( !pAggInfo->directMode ){
113584 return AggInfoColumnReg(pAggInfo, pExpr->iAgg);
113585 }else if( pAggInfo->useSortingIdx ){
113586 Table *pTab = pCol->pTab;
113587 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
113588 pCol->iSorterColumn, target);
113591 }else if( pCol->iColumn<0 ){
113592 VdbeComment((v,"%s.rowid",pTab->zName));
113595 pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
113596 if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){
113601 }else if( pExpr->y.pTab==0 ){
113604 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
113611 int iTab = pExpr->iTable;
113615 ** constraints, and that constant is coded by the pExpr->pLeft
113621 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
113623 assert( pExpr->y.pTab!=0 );
113624 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
113630 &zAff[(aff-'B')*2], P4_STATIC);
113635 if( pParse->iSelfTab<0 ){
113639 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
113645 int iCol = pExpr->iColumn;
113647 pTab = pExpr->y.pTab;
113650 assert( iCol<pTab->nCol );
113652 return -1-pParse->iSelfTab;
113654 pCol = pTab->aCol + iCol;
113656 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
113658 if( pCol->colFlags & COLFLAG_GENERATED ){
113659 if( pCol->colFlags & COLFLAG_BUSY ){
113661 pCol->zCnName);
113664 pCol->colFlags |= COLFLAG_BUSY;
113665 if( pCol->colFlags & COLFLAG_NOTAVAIL ){
113668 pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL);
113672 if( pCol->affinity==SQLITE_AFF_REAL ){
113682 iTab = pParse->iSelfTab - 1;
113685 else if( pParse->pIdxPartExpr
113691 assert( pExpr->y.pTab!=0 );
113692 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
113693 pExpr->iColumn, iTab, target,
113694 pExpr->op2);
113708 codeReal(v, pExpr->u.zToken, 0, target);
113714 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
113722 assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed );
113732 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
113733 assert( pExpr->u.zToken[1]=='\'' );
113734 z = &pExpr->u.zToken[2];
113735 n = sqlite3Strlen30(z) - 1;
113744 assert( pExpr->u.zToken!=0 );
113745 assert( pExpr->u.zToken[0]!=0 );
113746 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
113750 return pExpr->iTable;
113755 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113759 sqlite3AffinityType(pExpr->u.zToken, 0));
113767 /* fall-through */
113774 Expr *pLeft = pExpr->pLeft;
113779 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113781 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
113823 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113824 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113831 Expr *pLeft = pExpr->pLeft;
113833 if( pLeft->op==TK_INTEGER ){
113837 }else if( pLeft->op==TK_FLOAT ){
113839 codeReal(v, pLeft->u.zToken, 1, target);
113848 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
113858 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113866 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113868 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
113869 bNormal = pExpr->op2==TK_IS;
113881 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113891 AggInfo *pInfo = pExpr->pAggInfo;
113893 || NEVER(pExpr->iAgg<0)
113894 || NEVER(pExpr->iAgg>=pInfo->nFunc)
113899 return AggInfoFuncReg(pInfo, pExpr->iAgg);
113910 sqlite3 *db = pParse->db; /* The database connection */
113916 return pExpr->y.pWin->regResult;
113925 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113929 pFarg = pExpr->x.pList;
113930 nFarg = pFarg ? pFarg->nExpr : 0;
113932 zId = pExpr->u.zToken;
113935 if( pDef==0 && pParse->explain ){
113939 if( pDef==0 || pDef->xFinalize!=0 ){
113943 if( (pDef->funcFlags & SQLITE_FUNC_INLINE)!=0 && ALWAYS(pFarg!=0) ){
113944 assert( (pDef->funcFlags & SQLITE_FUNC_UNSAFE)==0 );
113945 assert( (pDef->funcFlags & SQLITE_FUNC_DIRECT)==0 );
113947 SQLITE_PTR_TO_INT(pDef->pUserData), target);
113948 }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){
113953 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
113957 if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
113958 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
113963 r1 = pParse->nMem+1;
113964 pParse->nMem += nFarg;
113974 if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){
113977 assert( pFarg->a[0].pExpr!=0 );
113978 exprOp = pFarg->a[0].pExpr->op;
113984 testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_LENGTHARG );
113985 testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_TYPEOFARG );
113986 testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_BYTELENARG);
113987 pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
114009 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
114011 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
114014 if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){
114015 if( !pColl ) pColl = db->pDfltColl;
114019 pDef, pExpr->op2);
114035 if( pParse->db->mallocFailed ){
114039 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
114049 Expr *pLeft = pExpr->pLeft;
114050 if( pLeft->iTable==0 || pParse->withinRJSubrtn > pLeft->op2 ){
114051 pLeft->iTable = sqlite3CodeSubselect(pParse, pLeft);
114052 pLeft->op2 = pParse->withinRJSubrtn;
114054 assert( pLeft->op==TK_SELECT || pLeft->op==TK_ERROR );
114056 if( pExpr->iTable!=n ){
114058 pExpr->iTable, n);
114060 return pLeft->iTable + pExpr->iColumn;
114083 ** X is stored in pExpr->pLeft.
114084 ** Y is stored in pExpr->pList->a[0].pExpr.
114085 ** Z is stored in pExpr->pList->a[1].pExpr.
114093 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
114094 ** "SOFT-COLLATE" that is added to constraints that are pushed down
114095 ** from outer queries into sub-queries by the WHERE-clause push-down
114099 assert( pExpr->pLeft );
114100 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114104 pExpr = pExpr->pLeft;
114105 goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. */
114110 pExpr = pExpr->pLeft;
114111 goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */
114116 ** to a column in the new.* or old.* pseudo-tables available to
114118 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
114119 ** is set to the column of the pseudo-table to read, or to -1 to
114124 ** to reference another column of the old.* pseudo-table, where
114126 ** set to (n+1), where n is the number of columns in each pseudo-table.
114127 ** For a reference to any other column in the new.* pseudo-table, p1
114136 ** p1==0 -> old.rowid p1==3 -> new.rowid
114137 ** p1==1 -> old.a p1==4 -> new.a
114138 ** p1==2 -> old.b p1==5 -> new.b
114145 pTab = pExpr->y.pTab;
114146 iCol = pExpr->iColumn;
114147 p1 = pExpr->iTable * (pTab->nCol+1) + 1
114150 assert( pExpr->iTable==0 || pExpr->iTable==1 );
114151 assert( iCol>=-1 && iCol<pTab->nCol );
114152 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
114153 assert( p1>=0 && p1<(pTab->nCol*2+2) );
114157 (pExpr->iTable ? "new" : "old"),
114158 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
114165 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
114167 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
114180 ** that derive from the right-hand table of a LEFT JOIN. The
114181 ** Expr.iTable value is the table number for the right-hand table.
114187 u8 okConstFactor = pParse->okConstFactor;
114188 AggInfo *pAggInfo = pExpr->pAggInfo;
114190 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
114191 if( !pAggInfo->directMode ){
114192 inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);
114195 if( pExpr->pAggInfo->useSortingIdx ){
114196 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
114197 pAggInfo->aCol[pExpr->iAgg].iSorterColumn,
114203 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
114211 pParse->okConstFactor = 0; /* note (1) above */
114212 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114214 pParse->okConstFactor = okConstFactor;
114230 ** X (if it exists) is in pExpr->pLeft.
114231 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
114234 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
114251 sqlite3 *db = pParse->db;
114253 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
114254 assert(pExpr->x.pList->nExpr > 0);
114255 pEList = pExpr->x.pList;
114256 aListelem = pEList->a;
114257 nExpr = pEList->nExpr;
114259 if( (pX = pExpr->pLeft)!=0 ){
114261 if( db->mallocFailed ){
114265 testcase( pX->op==TK_COLUMN );
114273 ** The value in regFree1 might get SCopy-ed into the file result.
114278 for(i=0; i<nExpr-1; i=i+2){
114286 testcase( pTest->op==TK_COLUMN );
114288 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
114294 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
114305 assert( pExpr->affExpr==OE_Rollback
114306 || pExpr->affExpr==OE_Abort
114307 || pExpr->affExpr==OE_Fail
114308 || pExpr->affExpr==OE_Ignore
114310 if( !pParse->pTriggerTab && !pParse->nested ){
114312 "RAISE() may only be used within a trigger-program");
114315 if( pExpr->affExpr==OE_Abort ){
114319 if( pExpr->affExpr==OE_Ignore ){
114321 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
114325 pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR,
114326 pExpr->affExpr, pExpr->u.zToken, 0, 0);
114363 p = pParse->pConstExpr;
114367 for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
114368 if( pItem->fg.reusable
114369 && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0
114371 return pItem->u.iConstExprReg;
114375 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
114377 Vdbe *v = pParse->pVdbe;
114381 pParse->okConstFactor = 0;
114382 if( !pParse->db->mallocFailed ){
114383 if( regDest<0 ) regDest = ++pParse->nMem;
114386 pParse->okConstFactor = 1;
114387 sqlite3ExprDelete(pParse->db, pExpr);
114392 struct ExprList_item *pItem = &p->a[p->nExpr-1];
114393 pItem->fg.reusable = regDest<0;
114394 if( regDest<0 ) regDest = ++pParse->nMem;
114395 pItem->u.iConstExprReg = regDest;
114397 pParse->pConstExpr = p;
114420 && pExpr->op!=TK_REGISTER
114424 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114447 assert( target>0 && target<=pParse->nMem );
114448 assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
114449 if( pParse->pVdbe==0 ) return;
114456 && (ExprHasProperty(pX,EP_Subquery) || pX->op==TK_REGISTER)
114462 sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target);
114472 sqlite3 *db = pParse->db;
114474 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
114485 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
114497 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
114522 Vdbe *v = pParse->pVdbe;
114525 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
114526 n = pList->nExpr;
114528 for(pItem=pList->a, i=0; i<n; i++, pItem++){
114529 Expr *pExpr = pItem->pExpr;
114531 if( pItem->fg.bSorterRef ){
114532 i--;
114533 n--;
114536 if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){
114538 i--;
114539 n--;
114541 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
114552 && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy
114553 && pOp->p1+pOp->p3+1==inReg
114554 && pOp->p2+pOp->p3+1==target+i
114555 && pOp->p5==0 /* The do-not-merge flag must be clear */
114557 pOp->p3++;
114599 sqlite3 *db = pParse->db;
114606 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
114607 if( db->mallocFailed==0 ){
114613 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
114616 compRight.pRight = pExpr->x.pList->a[1].pExpr;
114626 pDel->flags |= EP_OuterON;
114660 Vdbe *v = pParse->pVdbe;
114670 op = pExpr->op;
114680 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
114682 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114686 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114687 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114693 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114700 isNot = pExpr->op2==TK_ISNOT;
114701 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
114705 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114708 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114726 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
114728 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114729 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114730 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114750 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114778 /* No-op */
114803 Vdbe *v = pParse->pVdbe;
114814 /* The value of pExpr->op and op are related as follows:
114816 ** pExpr->op op
114817 ** --------- ----------
114827 ** For other values of pExpr->op, op is undefined and unused.
114832 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
114836 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
114837 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
114838 assert( pExpr->op!=TK_NE || op==OP_Eq );
114839 assert( pExpr->op!=TK_EQ || op==OP_Ne );
114840 assert( pExpr->op!=TK_LT || op==OP_Ge );
114841 assert( pExpr->op!=TK_LE || op==OP_Gt );
114842 assert( pExpr->op!=TK_GT || op==OP_Le );
114843 assert( pExpr->op!=TK_GE || op==OP_Lt );
114845 switch( pExpr->op ){
114851 }else if( pExpr->op==TK_AND ){
114853 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114854 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114858 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
114860 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114867 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114874 isNot = pExpr->op2==TK_ISNOT;
114875 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
114880 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114885 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114892 testcase( pExpr->op==TK_IS );
114893 testcase( pExpr->op==TK_ISNOT );
114894 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
114903 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
114905 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114906 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114907 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114925 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114955 /* no-op */
114976 sqlite3 *db = pParse->db;
114978 if( db->mallocFailed==0 ){
114988 ** If pExpr is a simple SQL value - an integer, real, string, blob
114989 ** or NULL value - then the VDBE currently being prepared is configured
114990 ** to re-prepare each time a new value is bound to variable pVar.
114993 ** same as that currently bound to variable pVar, non-zero is returned.
115006 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
115008 iVar = pVar->iColumn;
115009 sqlite3VdbeSetVarmask(pParse->pVdbe, iVar);
115010 pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB);
115013 sqlite3_value_text(pL); /* Make sure the encoding is UTF-8 */
115028 ** other than the top-level COLLATE operator.
115030 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
115042 ** this routine is used, it does not hurt to get an extra 2 - that
115047 ** pParse->pReprepare can be matched against literals in pB. The
115048 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
115063 if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){
115066 combinedFlags = pA->flags | pB->flags;
115068 if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
115073 if( pA->op!=pB->op || pA->op==TK_RAISE ){
115074 if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){
115077 if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){
115080 if( pA->op==TK_AGG_COLUMN && pB->op==TK_COLUMN
115081 && pB->iTable<0 && pA->iTable==iTab
115090 if( pA->u.zToken ){
115091 if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){
115092 if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
115094 assert( pA->op==pB->op );
115099 if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){
115104 }else if( pA->op==TK_NULL ){
115106 }else if( pA->op==TK_COLLATE ){
115107 if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
115109 if( pB->u.zToken!=0
115110 && pA->op!=TK_COLUMN
115111 && pA->op!=TK_AGG_COLUMN
115112 && strcmp(pA->u.zToken,pB->u.zToken)!=0
115117 if( (pA->flags & (EP_Distinct|EP_Commuted))
115118 != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2;
115122 && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2;
115123 if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2;
115124 if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
115125 if( pA->op!=TK_STRING
115126 && pA->op!=TK_TRUEFALSE
115129 if( pA->iColumn!=pB->iColumn ) return 2;
115130 if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2;
115131 if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){
115144 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
115147 ** This routine might return non-zero for equivalent ExprLists. The
115153 ** always differs from a non-NULL pointer.
115159 if( pA->nExpr!=pB->nExpr ) return 1;
115160 for(i=0; i<pA->nExpr; i++){
115162 Expr *pExprA = pA->a[i].pExpr;
115163 Expr *pExprB = pB->a[i].pExpr;
115164 if( pA->a[i].fg.sortFlags!=pB->a[i].fg.sortFlags ) return 1;
115171 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
115182 ** Return non-zero if Expr p can only be true if pNN is not NULL.
115184 ** Or if seenNot is true, return non-zero if Expr p can only be
115185 ** non-NULL if pNN is not NULL
115192 int seenNot /* Return true only if p can be any non-NULL value */
115197 return pNN->op!=TK_NULL;
115199 switch( p->op ){
115202 assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) );
115203 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115208 pList = p->x.pList;
115210 assert( pList->nExpr==2 );
115212 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
115213 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
115217 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115237 if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1;
115244 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot);
115248 if( p->op2!=TK_IS ) return 0;
115249 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115253 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115276 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
115293 if( pE2->op==TK_OR
115294 && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab)
115295 || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) )
115299 if( pE2->op==TK_NOTNULL
115300 && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0)
115308 ** set pWalker->eCode to one only if *both* of the input expressions
115309 ** separately have the implies-not-null-row property.
115312 if( pWalker->eCode==0 ){
115314 if( pWalker->eCode ){
115315 pWalker->eCode = 0;
115323 ** If the expression node requires that the table at pWalker->iCur
115324 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
115326 ** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
115331 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
115332 ** (never setting pWalker->eCode) is a harmless missed optimization.
115335 testcase( pExpr->op==TK_AGG_COLUMN );
115336 testcase( pExpr->op==TK_AGG_FUNCTION );
115338 if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
115339 /* If iCur is used in an inner-join ON clause to the left of a
115340 ** RIGHT JOIN, that does *not* mean that the table must be non-null.
115342 ** To keep things simple, any use of iCur from any inner-join is
115346 switch( pExpr->op ){
115355 testcase( pExpr->op==TK_ISNOT );
115356 testcase( pExpr->op==TK_ISNULL );
115357 testcase( pExpr->op==TK_NOTNULL );
115358 testcase( pExpr->op==TK_IS );
115359 testcase( pExpr->op==TK_VECTOR );
115360 testcase( pExpr->op==TK_FUNCTION );
115361 testcase( pExpr->op==TK_TRUTH );
115362 testcase( pExpr->op==TK_CASE );
115366 if( pWalker->u.iCur==pExpr->iTable ){
115367 pWalker->eCode = 1;
115374 /* Both sides of an AND or OR must separately imply non-null-row.
115378 ** If only one of x or y is non-null-row, then the overall expression
115381 testcase( pExpr->op==TK_OR );
115382 testcase( pExpr->op==TK_AND );
115383 bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
115389 ** the left-hand side of the IN is NULL then the IN itself will be
115391 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
115392 sqlite3WalkExpr(pWalker, pExpr->pLeft);
115397 /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
115398 ** both y and z must be non-null row */
115400 assert( pExpr->x.pList->nExpr==2 );
115401 sqlite3WalkExpr(pWalker, pExpr->pLeft);
115402 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
115403 pExpr->x.pList->a[1].pExpr);
115415 Expr *pLeft = pExpr->pLeft;
115416 Expr *pRight = pExpr->pRight;
115417 testcase( pExpr->op==TK_EQ );
115418 testcase( pExpr->op==TK_NE );
115419 testcase( pExpr->op==TK_LT );
115420 testcase( pExpr->op==TK_LE );
115421 testcase( pExpr->op==TK_GT );
115422 testcase( pExpr->op==TK_GE );
115425 assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) );
115426 assert( pRight->op!=TK_COLUMN || ExprUseYTab(pRight) );
115427 if( (pLeft->op==TK_COLUMN
115428 && ALWAYS(pLeft->y.pTab!=0)
115429 && IsVirtual(pLeft->y.pTab))
115430 || (pRight->op==TK_COLUMN
115431 && ALWAYS(pRight->y.pTab!=0)
115432 && IsVirtual(pRight->y.pTab))
115444 ** Return true (non-zero) if expression p can only be true if at least
115445 ** one column of table iTab is non-null. In other words, return true
115462 ** be non-NULL, then the LEFT JOIN can be safely converted into an
115469 if( p->op==TK_NOTNULL ){
115470 p = p->pLeft;
115472 while( p->op==TK_AND ){
115473 if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab, isRJ) ) return 1;
115474 p = p->pRight;
115501 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
115502 ** pWalker->u.pIdxCover->pIdx.
115505 if( pExpr->op==TK_COLUMN
115506 && pExpr->iTable==pWalker->u.pIdxCover->iCur
115507 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
115509 pWalker->eCode = 1;
115561 struct RefSrcList *p = pWalker->u.pRefSrcList;
115562 SrcList *pSrc = pSelect->pSrc;
115565 if( pSrc->nSrc==0 ) return WRC_Continue;
115566 j = p->nExclude;
115567 p->nExclude += pSrc->nSrc;
115568 piNew = sqlite3DbRealloc(p->db, p->aiExclude, p->nExclude*sizeof(int));
115570 p->nExclude = 0;
115573 p->aiExclude = piNew;
115575 for(i=0; i<pSrc->nSrc; i++, j++){
115576 p->aiExclude[j] = pSrc->a[i].iCursor;
115581 struct RefSrcList *p = pWalker->u.pRefSrcList;
115582 SrcList *pSrc = pSelect->pSrc;
115583 if( p->nExclude ){
115584 assert( p->nExclude>=pSrc->nSrc );
115585 p->nExclude -= pSrc->nSrc;
115591 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
115594 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
115598 if( pExpr->op==TK_COLUMN
115599 || pExpr->op==TK_AGG_COLUMN
115602 struct RefSrcList *p = pWalker->u.pRefSrcList;
115603 SrcList *pSrc = p->pRef;
115604 int nSrc = pSrc ? pSrc->nSrc : 0;
115606 if( pExpr->iTable==pSrc->a[i].iCursor ){
115607 pWalker->eCode |= 1;
115611 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
115612 if( i>=p->nExclude ){
115613 pWalker->eCode |= 2;
115628 ** -1 pExpr only references no tables at all, or it only
115637 assert( pParse->db!=0 );
115644 x.db = pParse->db;
115646 assert( pExpr->op==TK_AGG_FUNCTION );
115648 sqlite3WalkExprList(&w, pExpr->x.pList);
115649 if( pExpr->pLeft ){
115650 assert( pExpr->pLeft->op==TK_ORDER );
115651 assert( ExprUseXList(pExpr->pLeft) );
115652 assert( pExpr->pLeft->x.pList!=0 );
115653 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
115657 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
115660 if( x.aiExclude ) sqlite3DbNNFreeNN(pParse->db, x.aiExclude);
115666 return -1;
115683 && pExpr->pAggInfo!=0
115685 AggInfo *pAggInfo = pExpr->pAggInfo;
115686 int iAgg = pExpr->iAgg;
115687 Parse *pParse = pWalker->pParse;
115688 sqlite3 *db = pParse->db;
115690 if( pExpr->op!=TK_AGG_FUNCTION ){
115691 if( iAgg<pAggInfo->nColumn
115692 && pAggInfo->aCol[iAgg].pCExpr==pExpr
115696 pAggInfo->aCol[iAgg].pCExpr = pExpr;
115700 assert( pExpr->op==TK_AGG_FUNCTION );
115701 if( ALWAYS(iAgg<pAggInfo->nFunc)
115702 && pAggInfo->aFunc[iAgg].pFExpr==pExpr
115706 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
115720 pWalker->pParse = pParse;
115721 pWalker->xExprCallback = agginfoPersistExprCb;
115722 pWalker->xSelectCallback = sqlite3SelectWalkNoop;
115726 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
115731 pInfo->aCol = sqlite3ArrayAllocate(
115733 pInfo->aCol,
115734 sizeof(pInfo->aCol[0]),
115735 &pInfo->nColumn,
115742 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
115747 pInfo->aFunc = sqlite3ArrayAllocate(
115749 pInfo->aFunc,
115750 sizeof(pInfo->aFunc[0]),
115751 &pInfo->nFunc,
115761 ** If no prior entry is found, create a new one and return -1. The
115762 ** new column will have an index of pAggInfo->nColumn-1.
115772 assert( pAggInfo->iFirstReg==0 );
115773 pCol = pAggInfo->aCol;
115774 for(k=0; k<pAggInfo->nColumn; k++, pCol++){
115775 if( pCol->pCExpr==pExpr ) return;
115776 if( pCol->iTable==pExpr->iTable
115777 && pCol->iColumn==pExpr->iColumn
115778 && pExpr->op!=TK_IF_NULL_ROW
115783 k = addAggInfoColumn(pParse->db, pAggInfo);
115786 assert( pParse->db->mallocFailed );
115789 pCol = &pAggInfo->aCol[k];
115791 pCol->pTab = pExpr->y.pTab;
115792 pCol->iTable = pExpr->iTable;
115793 pCol->iColumn = pExpr->iColumn;
115794 pCol->iSorterColumn = -1;
115795 pCol->pCExpr = pExpr;
115796 if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){
115798 ExprList *pGB = pAggInfo->pGroupBy;
115799 struct ExprList_item *pTerm = pGB->a;
115800 n = pGB->nExpr;
115802 Expr *pE = pTerm->pExpr;
115803 if( pE->op==TK_COLUMN
115804 && pE->iTable==pExpr->iTable
115805 && pE->iColumn==pExpr->iColumn
115807 pCol->iSorterColumn = j;
115812 if( pCol->iSorterColumn<0 ){
115813 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
115817 assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );
115818 pExpr->pAggInfo = pAggInfo;
115819 if( pExpr->op==TK_COLUMN ){
115820 pExpr->op = TK_AGG_COLUMN;
115822 pExpr->iAgg = (i16)k;
115832 NameContext *pNC = pWalker->u.pNC;
115833 Parse *pParse = pNC->pParse;
115834 SrcList *pSrcList = pNC->pSrcList;
115835 AggInfo *pAggInfo = pNC->uNC.pAggInfo;
115837 assert( pNC->ncFlags & NC_UAggInfo );
115838 assert( pAggInfo->iFirstReg==0 );
115839 switch( pExpr->op ){
115843 assert( pParse->iSelfTab==0 );
115844 if( (pNC->ncFlags & NC_InAggFunc)==0 ) break;
115845 if( pParse->pIdxEpr==0 ) break;
115846 for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){
115847 int iDataCur = pIEpr->iDataCur;
115849 if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;
115853 for(i=0; i<pSrcList->nSrc; i++){
115854 if( pSrcList->a[0].iCursor==pIEpr->iDataCur ) break;
115856 if( i>=pSrcList->nSrc ) break;
115857 if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */
115858 if( pParse->nErr ){ return WRC_Abort; }
115866 tmp.iTable = pIEpr->iIdxCur;
115867 tmp.iColumn = pIEpr->iIdxCol;
115869 if( pParse->nErr ){ return WRC_Abort; }
115870 assert( pAggInfo->aCol!=0 );
115871 assert( tmp.iAgg<pAggInfo->nColumn );
115872 pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;
115873 pExpr->pAggInfo = pAggInfo;
115874 pExpr->iAgg = tmp.iAgg;
115880 testcase( pExpr->op==TK_AGG_COLUMN );
115881 testcase( pExpr->op==TK_COLUMN );
115882 testcase( pExpr->op==TK_IF_NULL_ROW );
115886 SrcItem *pItem = pSrcList->a;
115887 for(i=0; i<pSrcList->nSrc; i++, pItem++){
115889 if( pExpr->iTable==pItem->iCursor ){
115892 } /* endif pExpr->iTable==pItem->iCursor */
115898 if( (pNC->ncFlags & NC_InAggFunc)==0
115899 && pWalker->walkerDepth==pExpr->op2
115900 && pExpr->pAggInfo==0
115905 struct AggInfo_func *pItem = pAggInfo->aFunc;
115906 for(i=0; i<pAggInfo->nFunc; i++, pItem++){
115907 if( NEVER(pItem->pFExpr==pExpr) ) break;
115908 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
115912 if( i>=pAggInfo->nFunc ){
115913 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
115915 u8 enc = ENC(pParse->db);
115916 i = addAggInfoFunc(pParse->db, pAggInfo);
115920 pItem = &pAggInfo->aFunc[i];
115921 pItem->pFExpr = pExpr;
115923 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
115924 pItem->pFunc = sqlite3FindFunction(pParse->db,
115925 pExpr->u.zToken, nArg, enc, 0);
115926 assert( pItem->bOBUnique==0 );
115927 if( pExpr->pLeft
115928 && (pItem->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)==0
115934 assert( pExpr->pLeft->op==TK_ORDER );
115935 assert( ExprUseXList(pExpr->pLeft) );
115936 pItem->iOBTab = pParse->nTab++;
115937 pOBList = pExpr->pLeft->x.pList;
115938 assert( pOBList->nExpr>0 );
115939 assert( pItem->bOBUnique==0 );
115940 if( pOBList->nExpr==1
115942 && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
115943 pExpr->x.pList->a[0].pExpr,0)==0
115945 pItem->bOBPayload = 0;
115946 pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
115948 pItem->bOBPayload = 1;
115950 pItem->bUseSubtype =
115951 (pItem->pFunc->funcFlags & SQLITE_SUBTYPE)!=0;
115953 pItem->iOBTab = -1;
115955 if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
115956 pItem->iDistinct = pParse->nTab++;
115958 pItem->iDistinct = -1;
115962 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
115966 pExpr->iAgg = (i16)i;
115967 pExpr->pAggInfo = pAggInfo;
115979 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
115994 assert( pNC->pSrcList!=0 );
116008 for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
116009 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
116018 if( pParse->nTempReg==0 ){
116019 return ++pParse->nMem;
116021 return pParse->aTempReg[--pParse->nTempReg];
116031 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
116032 pParse->aTempReg[pParse->nTempReg++] = iReg;
116043 i = pParse->iRangeReg;
116044 n = pParse->nRangeReg;
116046 pParse->iRangeReg += nReg;
116047 pParse->nRangeReg -= nReg;
116049 i = pParse->nMem+1;
116050 pParse->nMem += nReg;
116060 if( nReg>pParse->nRangeReg ){
116061 pParse->nRangeReg = nReg;
116062 pParse->iRangeReg = iReg;
116069 ** Always invoke this procedure after coding a subroutine or co-routine
116071 ** the sub/co-routine does not use registers in common with the code that
116072 ** invokes the sub/co-routine.
116075 pParse->nTempReg = 0;
116076 pParse->nRangeReg = 0;
116084 if( pParse->nMem<iReg ) pParse->nMem = iReg;
116095 const ExprList *pList = pParse->pConstExpr;
116098 for(i=0; i<pList->nExpr; i++){
116099 if( pList->a[i].u.iConstExprReg>=iMin ){
116100 iMin = pList->a[i].u.iConstExprReg + 1;
116104 pParse->nTempReg = 0;
116105 pParse->nRangeReg = 0;
116118 if( pParse->nRangeReg>0
116119 && pParse->iRangeReg+pParse->nRangeReg > iFirst
116120 && pParse->iRangeReg <= iLast
116124 for(i=0; i<pParse->nTempReg; i++){
116125 if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){
116129 if( pParse->pConstExpr ){
116130 ExprList *pList = pParse->pConstExpr;
116131 for(i=0; i<pList->nExpr; i++){
116132 int iReg = pList->a[i].u.iConstExprReg;
116169 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
116174 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
116176 || (pTab->tabFlags & TF_Eponymous)!=0
116177 || ( (pTab->tabFlags & TF_Shadow)!=0
116178 && sqlite3ReadOnlyShadowTables(pParse->db)
116182 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
116202 pParse->colNamesSet = 1;
116226 ** Generate VM code to replace any double-quoted strings (but not double-quoted
116228 ** database zDb with their single-quoted equivalents. If argument bTemp is
116254 Vdbe *v = pParse->pVdbe;
116257 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
116258 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
116274 char *zName = 0; /* NULL-terminated version of pName */
116275 sqlite3 *db = pParse->db; /* Database connection */
116276 int nTabName; /* Number of UTF-8 characters in zTabName */
116279 VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
116281 if( NEVER(db->mallocFailed) ) goto exit_rename_table;
116282 assert( pSrc->nSrc==1 );
116283 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
116285 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116287 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
116288 zDb = db->aDb[iDb].zDbSName;
116318 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
116325 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116336 if( pVTab->pVtab->pModule->xRename==0 ){
116352 /* figure out how many UTF-8 characters are in zName */
116353 zTabName = pTab->zName;
116354 nTabName = sqlite3Utf8CharLen(zTabName, -1);
116391 zDb, zName, pTab->zName);
116412 ** of any resources used by the v-table implementation (including other
116417 int i = ++pParse->nMem;
116452 ** The Table structure pParse->pNewTable was extended to include
116456 Table *pNew; /* Copy of pParse->pNewTable */
116461 char *zCol; /* Null-terminated column definition */
116468 db = pParse->db;
116469 assert( db->pParse==pParse );
116470 if( pParse->nErr ) return;
116471 assert( db->mallocFailed==0 );
116472 pNew = pParse->pNewTable;
116476 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
116477 zDb = db->aDb[iDb].zDbSName;
116478 zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
116479 pCol = &pNew->aCol[pNew->nCol-1];
116486 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116496 if( pCol->colFlags & COLFLAG_PRIMKEY ){
116500 if( pNew->pIndex ){
116505 if( (pCol->colFlags & COLFLAG_GENERATED)==0 ){
116510 assert( pDflt==0 || pDflt->op==TK_SPAN );
116511 if( pDflt && pDflt->pLeft->op==TK_NULL ){
116515 if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){
116517 "Cannot add a REFERENCES column with non-NULL default value");
116519 if( pCol->notNull && !pDflt ){
116534 assert( db->mallocFailed == 1 );
116539 "Cannot add a column with non-constant default");
116543 }else if( pCol->colFlags & COLFLAG_STORED ){
116549 zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
116551 char *zEnd = &zCol[pColDef->n-1];
116553 *zEnd-- = '\0';
116564 zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset,
116579 sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
116589 if( pNew->pCheck!=0
116590 || (pCol->notNull && (pCol->colFlags & COLFLAG_GENERATED)!=0)
116591 || (pTab->tabFlags & TF_Strict)!=0
116596 " WHEN quick_check GLOB 'non-* value in*'"
116603 " OR quick_check GLOB 'non-* value in*'",
116611 ** This function is called by the parser after the table-name in
116612 ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
116613 ** pSrc is the full-name of the table being altered.
116631 sqlite3 *db = pParse->db;
116634 assert( pParse->pNewTable==0 );
116636 if( db->mallocFailed ) goto exit_begin_add_column;
116637 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116658 assert( pTab->u.tab.addColOffset>0 );
116659 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
116670 pParse->pNewTable = pNew;
116671 pNew->nTabRef = 1;
116672 pNew->nCol = pTab->nCol;
116673 assert( pNew->nCol>0 );
116674 nAlloc = (((pNew->nCol-1)/8)*8)+8;
116675 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
116676 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
116677 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
116678 if( !pNew->aCol || !pNew->zName ){
116679 assert( db->mallocFailed );
116682 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
116683 for(i=0; i<pNew->nCol; i++){
116684 Column *pCol = &pNew->aCol[i];
116685 pCol->zCnName = sqlite3DbStrDup(db, pCol->zCnName);
116686 pCol->hName = sqlite3StrIHash(pCol->zCnName);
116689 pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
116690 pNew->pSchema = db->aDb[iDb].pSchema;
116691 pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
116692 assert( pNew->nTabRef==1 );
116703 ** it loads an error message into pParse and returns non-zero.
116723 zType, pTab->zName
116740 SrcList *pSrc, /* Table being altered. pSrc->nSrc==1 */
116744 sqlite3 *db = pParse->db; /* Database connection */
116754 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116762 iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
116764 zDb = db->aDb[iSchema].zDbSName;
116768 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116777 for(iCol=0; iCol<pTab->nCol; iCol++){
116778 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
116780 if( iCol==pTab->nCol ){
116785 /* Ensure the schema contains no double-quoted strings */
116796 assert( pNew->n>0 );
116797 bQuote = sqlite3Isquote(pNew->z[0]);
116804 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
116805 pTab->zName
116812 zDb, pTab->zName, iCol, zNew, bQuote
116867 ** rename-token list.
116869 ** 2. Dereferences each pointer in the rename-token list.
116872 ** address-sanitizer or similar. If any of these pointers no longer
116873 ** point to valid objects, an exception is raised by the memory-checking
116887 assert( pParse==pParse->db->pParse );
116888 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
116889 if( pParse->nErr==0 ){
116892 for(p=pParse->pRename; p; p=p->pNext){
116893 if( p->p ){
116894 assert( p->p!=pPtr );
116895 i += *(u8*)(p->p) | 1;
116911 ** in pParse->pRename.
116923 assert( pPtr || pParse->db->mallocFailed );
116925 if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){
116926 pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
116928 pNew->p = pPtr;
116929 pNew->t = *pToken;
116930 pNew->pNext = pParse->pRename;
116931 pParse->pRename = pNew;
116946 for(p=pParse->pRename; p; p=p->pNext){
116947 if( p->p==pFrom ){
116948 p->p = pTo;
116958 Parse *pParse = pWalker->pParse;
116961 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
116971 With *pWith = pSelect->pWith;
116973 Parse *pParse = pWalker->pParse;
116976 assert( pWith->nCte>0 );
116977 if( (pWith->a[0].pSelect->selFlags & SF_Expanded)==0 ){
116978 /* Push a copy of the With object onto the with-stack. We use a copy
116980 ** and SF_Resolved) below. And the parser code that uses the with-stack
116983 pCopy = sqlite3WithDup(pParse->db, pWith);
116986 for(i=0; i<pWith->nCte; i++){
116987 Select *p = pWith->a[i].pSelect;
116992 if( sNC.pParse->db->mallocFailed ) return;
116994 sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols);
116996 if( pCopy && pParse->pWith==pCopy ){
116997 pParse->pWith = pCopy->pOuter;
117011 for(ii=0; ii<pIdList->nId; ii++){
117012 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
117020 Parse *pParse = pWalker->pParse;
117022 if( pParse->nErr ) return WRC_Abort;
117023 testcase( p->selFlags & SF_View );
117024 testcase( p->selFlags & SF_CopyCte );
117025 if( p->selFlags & (SF_View|SF_CopyCte) ){
117028 if( ALWAYS(p->pEList) ){
117029 ExprList *pList = p->pEList;
117030 for(i=0; i<pList->nExpr; i++){
117031 if( pList->a[i].zEName && pList->a[i].fg.eEName==ENAME_NAME ){
117032 sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
117036 if( ALWAYS(p->pSrc) ){ /* Every Select as a SrcList, even if it is empty */
117037 SrcList *pSrc = p->pSrc;
117038 for(i=0; i<pSrc->nSrc; i++){
117039 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
117040 if( pSrc->a[i].fg.isUsing==0 ){
117041 sqlite3WalkExpr(pWalker, pSrc->a[i].u3.pOn);
117043 unmapColumnIdlistNames(pParse, pSrc->a[i].u3.pUsing);
117056 u8 eMode = pParse->eParseMode;
117062 pParse->eParseMode = PARSE_MODE_UNMAP;
117064 pParse->eParseMode = eMode;
117068 ** Remove all nodes that are part of expression-list pEList from the
117079 for(i=0; i<pEList->nExpr; i++){
117080 if( ALWAYS(pEList->a[i].fg.eEName==ENAME_NAME) ){
117081 sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);
117094 pNext = p->pNext;
117117 for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
117118 if( (*pp)->p==pPtr ){
117121 *pp = pToken->pNext;
117122 pToken->pNext = pCtx->pList;
117123 pCtx->pList = pToken;
117124 pCtx->nList++;
117135 ** descend into sub-select statements.
117138 if( p->selFlags & (SF_View|SF_CopyCte) ){
117139 testcase( p->selFlags & SF_View );
117140 testcase( p->selFlags & SF_CopyCte );
117154 ** constructed in RenameCtx object at pWalker->u.pRename.
117157 RenameCtx *p = pWalker->u.pRename;
117158 if( pExpr->op==TK_TRIGGER
117159 && pExpr->iColumn==p->iCol
117160 && pWalker->pParse->pTriggerTab==p->pTab
117162 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117163 }else if( pExpr->op==TK_COLUMN
117164 && pExpr->iColumn==p->iCol
117166 && p->pTab==pExpr->y.pTab
117168 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117183 RenameToken *pBest = pCtx->pList;
117187 for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){
117188 if( pToken->t.z>pBest->t.z ) pBest = pToken;
117190 for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
117191 *pp = pBest->pNext;
117198 ** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an
117200 ** sub-routine is currently stored in pParse->zErrMsg. This function
117214 zErr = sqlite3MPrintf(pParse->db, "error in %s %s%s%s: %s",
117216 pParse->zErrMsg
117218 sqlite3_result_error(pCtx, zErr, -1);
117219 sqlite3DbFree(pParse->db, zErr);
117223 ** For each name in the the expression-list pEList (i.e. each
117224 ** pEList->a[i].zName) that matches the string in zOld, extract the
117225 ** corresponding rename-token from Parse object pParse and add it
117236 for(i=0; i<pEList->nExpr; i++){
117237 const char *zName = pEList->a[i].zEName;
117238 if( ALWAYS(pEList->a[i].fg.eEName==ENAME_NAME)
117249 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
117250 ** that matches the string in zOld, extract the corresponding rename-token
117261 for(i=0; i<pIdList->nId; i++){
117262 const char *zName = pIdList->a[i].zName;
117291 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
117292 p->eParseMode = PARSE_MODE_RENAME;
117293 p->db = db;
117294 p->nQueryLoop = 1;
117296 if( db->mallocFailed ) rc = SQLITE_NOMEM;
117298 && NEVER(p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0)
117309 for(pToken=p->pRename; pToken; pToken=pToken->pNext){
117310 assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
117315 db->init.iDb = 0;
117355 nQuot = sqlite3Strlen30(zQuot)-1;
117359 zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
117368 /* At this point pRename->pList contains a list of RenameToken objects
117370 ** with the new column name, or with single-quoted versions of themselves.
117375 while( pRename->pList ){
117382 if( bQuote==0 && sqlite3IsIdChar(*pBest->t.z) ){
117388 if( pBest->t.z[pBest->t.n]=='"' ) nReplace++;
117391 /* Dequote the double-quoted token. Then requote it again, this time
117394 ** add another space after the new, single-quoted version of the
117397 memcpy(zBuf1, pBest->t.z, pBest->t.n);
117398 zBuf1[pBest->t.n] = 0;
117401 pBest->t.z[pBest->t.n]=='\'' ? " " : ""
117407 iOff = pBest->t.z - zSql;
117408 if( pBest->t.n!=nReplace ){
117409 memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n],
117410 nOut - (iOff + pBest->t.n)
117412 nOut += nReplace - pBest->t.n;
117419 sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
117430 ** Set all pEList->a[].fg.eEName fields in the expression-list to val.
117435 for(i=0; i<pEList->nExpr; i++){
117436 assert( val==ENAME_NAME || pEList->a[i].fg.eEName==ENAME_NAME );
117437 pEList->a[i].fg.eEName = val;
117443 ** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming
117449 sqlite3 *db = pParse->db;
117450 Trigger *pNew = pParse->pNewTrigger;
117457 assert( pNew->pTabSchema );
117458 pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
117459 db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName
117461 pParse->eTriggerOp = pNew->op;
117464 if( ALWAYS(pParse->pTriggerTab) ){
117465 rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab)!=0;
117469 if( rc==SQLITE_OK && pNew->pWhen ){
117470 rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen);
117473 for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
117474 if( pStep->pSelect ){
117475 sqlite3SelectPrep(pParse, pStep->pSelect, &sNC);
117476 if( pParse->nErr ) rc = pParse->rc;
117478 if( rc==SQLITE_OK && pStep->zTarget ){
117482 pParse, pStep->pExprList, pSrc, 0, 0, 0, 0, 0, 0
117485 pStep->pExprList = 0;
117489 /* pStep->pExprList contains an expression-list used for an UPDATE
117493 ** pStep->pExprList to ENAME_SPAN (from their current value of
117497 renameSetENames(pStep->pExprList, ENAME_SPAN);
117499 renameSetENames(pStep->pExprList, ENAME_NAME);
117500 rc = pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
117501 assert( pStep->pExprList==0 || pStep->pExprList==pSel->pEList );
117502 assert( pSrc==pSel->pSrc );
117503 if( pStep->pExprList ) pSel->pEList = 0;
117504 pSel->pSrc = 0;
117507 if( pStep->pFrom ){
117509 for(i=0; i<pStep->pFrom->nSrc && rc==SQLITE_OK; i++){
117510 SrcItem *p = &pStep->pFrom->a[i];
117511 if( p->pSelect ){
117512 sqlite3SelectPrep(pParse, p->pSelect, 0);
117517 if( db->mallocFailed ){
117521 if( rc==SQLITE_OK && pStep->pWhere ){
117522 rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere);
117525 rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList);
117527 assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) );
117528 if( pStep->pUpsert && rc==SQLITE_OK ){
117529 Upsert *pUpsert = pStep->pUpsert;
117530 pUpsert->pUpsertSrc = pSrc;
117533 rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
117535 ExprList *pUpsertSet = pUpsert->pUpsertSet;
117539 rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere);
117542 rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
117564 sqlite3WalkExpr(pWalker, pTrigger->pWhen);
117567 for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
117568 sqlite3WalkSelect(pWalker, pStep->pSelect);
117569 sqlite3WalkExpr(pWalker, pStep->pWhere);
117570 sqlite3WalkExprList(pWalker, pStep->pExprList);
117571 if( pStep->pUpsert ){
117572 Upsert *pUpsert = pStep->pUpsert;
117573 sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget);
117574 sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet);
117575 sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere);
117576 sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere);
117578 if( pStep->pFrom ){
117580 for(i=0; i<pStep->pFrom->nSrc; i++){
117581 sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect);
117592 sqlite3 *db = pParse->db;
117594 if( pParse->pVdbe ){
117595 sqlite3VdbeFinalize(pParse->pVdbe);
117597 sqlite3DeleteTable(db, pParse->pNewTable);
117598 while( (pIdx = pParse->pNewIndex)!=0 ){
117599 pParse->pNewIndex = pIdx->pNext;
117602 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
117603 sqlite3DbFree(db, pParse->zErrMsg);
117604 renameTokenFree(db, pParse->pRename);
117620 ** 7. bQuote: Non-zero if the new column name should be quoted.
117624 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
117654 sqlite3_xauth xAuth = db->xAuth;
117664 if( pTab==0 || iCol>=pTab->nCol ){
117668 zOld = pTab->aCol[iCol].zCnName;
117670 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
117673 db->xAuth = 0;
117688 Select *pSelect = sParse.pNewTable->u.view.pSelect;
117689 pSelect->selFlags &= ~SF_View;
117692 rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc);
117699 int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
117703 if( iCol<sParse.pNewTable->nCol ){
117705 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
117709 renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey);
117711 sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck);
117712 for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){
117713 sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
117715 for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
117716 sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
117719 for(i=0; i<sParse.pNewTable->nCol; i++){
117721 &sParse.pNewTable->aCol[i]);
117728 for(pFKey=sParse.pNewTable->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
117729 for(i=0; i<pFKey->nCol; i++){
117730 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
117731 renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]);
117733 if( 0==sqlite3_stricmp(pFKey->zTo, zTable)
117734 && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld)
117736 renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol);
117742 sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr);
117743 sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
117750 for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){
117751 if( pStep->zTarget ){
117752 Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb);
117754 if( pStep->pUpsert ){
117755 ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet;
117758 renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld);
117759 renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld);
117767 renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld);
117791 db->xAuth = xAuth;
117800 RenameCtx *p = pWalker->u.pRename;
117801 if( pExpr->op==TK_COLUMN
117803 && p->pTab==pExpr->y.pTab
117805 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
117815 RenameCtx *p = pWalker->u.pRename;
117816 SrcList *pSrc = pSelect->pSrc;
117817 if( pSelect->selFlags & (SF_View|SF_CopyCte) ){
117818 testcase( pSelect->selFlags & SF_View );
117819 testcase( pSelect->selFlags & SF_CopyCte );
117823 assert( pWalker->pParse->db->mallocFailed );
117826 for(i=0; i<pSrc->nSrc; i++){
117827 SrcItem *pItem = &pSrc->a[i];
117828 if( pItem->pTab==p->pTab ){
117829 renameTokenFind(pWalker->pParse, p, pItem->zName);
117855 ** -> 'CREATE TABLE t1(a REFERENCES t3)'
117878 sqlite3_xauth xAuth = db->xAuth;
117879 db->xAuth = 0;
117895 int isLegacy = (db->flags & SQLITE_LegacyAlter);
117901 Select *pSelect = pTab->u.view.pSelect;
117906 assert( pSelect->selFlags & SF_View );
117907 pSelect->selFlags &= ~SF_View;
117908 sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC);
117912 sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect);
117918 if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys))
117923 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
117924 if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){
117925 renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo);
117934 if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
117937 sqlite3WalkExprList(&sWalker, pTab->pCheck);
117939 renameTokenFind(&sParse, &sCtx, pTab->zName);
117945 renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
117947 sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
117955 if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld)
117956 && sCtx.pTab->pSchema==pTrigger->pTabSchema
117958 renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table);
117965 for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
117966 if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){
117967 renameTokenFind(&sParse, &sCtx, pStep->zTarget);
117969 if( pStep->pFrom ){
117971 for(i=0; i<pStep->pFrom->nSrc; i++){
117972 SrcItem *pItem = &pStep->pFrom->a[i];
117973 if( 0==sqlite3_stricmp(pItem->zName, zOld) ){
117974 renameTokenFind(&sParse, &sCtx, pItem->zName);
118002 db->xAuth = xAuth;
118010 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
118011 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
118019 ** double-quotes use single quotes instead.
118053 sqlite3_xauth xAuth = db->xAuth;
118054 db->xAuth = 0;
118079 Select *pSelect = sParse.pNewTable->u.view.pSelect;
118080 pSelect->selFlags &= ~SF_View;
118083 rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc);
118089 sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck);
118091 for(i=0; i<sParse.pNewTable->nCol; i++){
118094 &sParse.pNewTable->aCol[i]));
118099 sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr);
118100 sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
118126 db->xAuth = xAuth;
118165 int isLegacy = (db->flags & SQLITE_LegacyAlter);
118170 sqlite3_xauth xAuth = db->xAuth;
118171 db->xAuth = 0;
118179 int flags = db->flags;
118180 if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL);
118182 db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL));
118188 sqlite3SelectPrep(&sParse, sParse.pNewTable->u.view.pSelect, &sNC);
118197 int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema);
118215 db->xAuth = xAuth;
118224 ** argv[0]: An integer - the index of the schema containing the table
118226 ** argv[2]: An integer - the index of the column to remove.
118240 const char *zDb = db->aDb[iSchema].zDbSName;
118249 sqlite3_xauth xAuth = db->xAuth;
118250 db->xAuth = 0;
118257 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
118263 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
118264 if( iCol<pTab->nCol-1 ){
118266 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
118267 zEnd = (const char*)pEnd->t.z;
118270 zEnd = (const char*)&zSql[pTab->u.tab.addColOffset];
118271 while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--;
118274 zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd);
118275 sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT);
118281 db->xAuth = xAuth;
118297 sqlite3 *db = pParse->db; /* Database handle */
118302 int iCol; /* Index of column zCol in pTab->aCol[] */
118305 assert( pParse->pNewTable==0 );
118307 if( NEVER(db->mallocFailed) ) goto exit_drop_column;
118308 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
118319 assert( db->mallocFailed );
118330 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
118332 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
118339 if( pTab->nCol<=1 ){
118345 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
118347 zDb = db->aDb[iDb].zDbSName;
118350 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
118360 , zDb, iDb, iCol, pTab->zName
118368 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
118374 int nField = 0; /* Number of non-virtual columns after drop */
118377 iCur = pParse->nTab++;
118380 reg = ++pParse->nMem;
118383 pParse->nMem += pTab->nCol;
118386 pParse->nMem += pPk->nColumn;
118387 for(i=0; i<pPk->nKeyCol; i++){
118390 nField = pPk->nKeyCol;
118392 regRec = ++pParse->nMem;
118393 for(i=0; i<pTab->nCol; i++){
118394 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
118399 if( iPos<pPk->nKeyCol ) continue;
118400 regOut = reg+1+iPos-(iPos>iColPos);
118404 if( i==pTab->iPKey ){
118407 char aff = pTab->aCol[i].affinity;
118409 pTab->aCol[i].affinity = SQLITE_AFF_NUMERIC;
118412 pTab->aCol[i].affinity = aff;
118419 pParse->nMem++;
118425 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
118441 ** Register built-in functions used to help implement ALTER TABLE
118458 ** 2005-07-08
118508 ** columns. The N-th integer (for N>1) is the average number of rows in
118509 ** the index which have the same value for the first N-1 columns. For
118510 ** a K-column index, there will be K+1 integers in the stat column. If
118534 ** inclusive are samples of the left-most key value in the index taken at
118541 ** For i between 0 and S-1. Conceptually, the index space is divided into
118568 ** of entries in the index whose left-most column exactly matches
118569 ** the left-most column of the sample. The second integer in nEq
118575 ** left-most column is less than the left-most column of the sample.
118576 ** The K-th integer in the nLt entry is the number of index entries
118591 ** looks at the left-most column of the index. The sqlite_stat3.sample
118592 ** column contains the actual value of the left-most column instead
118613 ** appropriate compile-time options are provided.
118642 sqlite3 *db = pParse->db;
118656 pDb = &db->aDb[iDb];
118665 if( (pStat = sqlite3FindTable(db, zTab, pDb->zDbSName))==0 ){
118668 ** side-effect of the CREATE TABLE statement is to leave the rootpage
118669 ** of the new table in register pParse->regRoot. This is important
118672 "CREATE TABLE %Q.%s(%s)", pDb->zDbSName, zTab, aTable[i].zCols
118674 aRoot[i] = (u32)pParse->regRoot;
118681 aRoot[i] = pStat->tnum;
118686 pDb->zDbSName, zTab, zWhereType, zWhere
118689 }else if( db->xPreUpdateCallback ){
118690 sqlite3NestedParse(pParse, "DELETE FROM %Q.%s", pDb->zDbSName, zTab);
118716 ** Three SQL functions - stat_init(), stat_push(), and stat_get() -
118741 int nLimit; /* Analysis row-scan limit */
118744 u8 nSkipAhead; /* Number of times of skip-ahead */
118749 u32 iPrn; /* Pseudo-random number used for sampling */
118764 if( p->nRowid ){
118765 sqlite3DbFree(db, p->u.aRowid);
118766 p->nRowid = 0;
118776 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
118777 p->u.aRowid = sqlite3DbMallocRawNN(db, n);
118778 if( p->u.aRowid ){
118779 p->nRowid = n;
118780 memcpy(p->u.aRowid, pData, n);
118782 p->nRowid = 0;
118792 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
118793 p->nRowid = 0;
118794 p->u.iRowid = iRowid;
118804 pTo->isPSample = pFrom->isPSample;
118805 pTo->iCol = pFrom->iCol;
118806 pTo->iHash = pFrom->iHash;
118807 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
118808 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
118809 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
118810 if( pFrom->nRowid ){
118811 sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
118813 sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
118824 if( p->mxSample ){
118826 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
118827 for(i=0; i<p->mxSample; i++) sampleClear(p->db, p->a+i);
118828 sampleClear(p->db, &p->current);
118831 sqlite3DbFree(p->db, p);
118840 ** L: A limit on the number of rows to scan, or 0 for no-limit
118898 p->db = db;
118899 p->nEst = sqlite3_value_int64(argv[2]);
118900 p->nRow = 0;
118901 p->nLimit = sqlite3_value_int64(argv[3]);
118902 p->nCol = nCol;
118903 p->nKeyCol = nKeyCol;
118904 p->nSkipAhead = 0;
118905 p->current.anDLt = (tRowcnt*)&p[1];
118908 p->current.anEq = &p->current.anDLt[nColUp];
118909 p->mxSample = p->nLimit==0 ? mxSample : 0;
118912 int i; /* Used to iterate through p->aSample[] */
118914 p->iGet = -1;
118915 p->nPSample = (tRowcnt)(p->nEst/(mxSample/3+1) + 1);
118916 p->current.anLt = &p->current.anEq[nColUp];
118917 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
118920 p->a = (struct StatSample*)&p->current.anLt[nColUp];
118921 p->aBest = &p->a[mxSample];
118922 pSpace = (u8*)(&p->a[mxSample+nCol]);
118924 p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
118925 p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
118926 p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp);
118928 assert( (pSpace - (u8*)p)==n );
118931 p->aBest[i].iCol = i;
118956 ** pNew and pOld are both candidate non-periodic samples selected for
118957 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
118964 ** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid.
118971 int nCol = pAccum->nCol;
118973 assert( pNew->iCol==pOld->iCol );
118974 for(i=pNew->iCol+1; i<nCol; i++){
118975 if( pNew->anEq[i]>pOld->anEq[i] ) return 1;
118976 if( pNew->anEq[i]<pOld->anEq[i] ) return 0;
118978 if( pNew->iHash>pOld->iHash ) return 1;
118988 ** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid.
118995 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
118996 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
118998 assert( pOld->isPSample==0 && pNew->isPSample==0 );
118999 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
119003 if( pNew->iCol<pOld->iCol ) return 1;
119004 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
119010 ** Copy the contents of sample *pNew into the p->a[] array. If necessary,
119011 ** remove the least desirable sample from p->a[] to make room.
119023 if( nEqZero>p->nMaxEqZero ){
119024 p->nMaxEqZero = nEqZero;
119026 if( pNew->isPSample==0 ){
119028 assert( pNew->anEq[pNew->iCol]>0 );
119035 for(i=p->nSample-1; i>=0; i--){
119036 StatSample *pOld = &p->a[i];
119037 if( pOld->anEq[pNew->iCol]==0 ){
119038 if( pOld->isPSample ) return;
119039 assert( pOld->iCol>pNew->iCol );
119047 pUpgrade->iCol = pNew->iCol;
119048 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
119054 if( p->nSample>=p->mxSample ){
119055 StatSample *pMin = &p->a[p->iMin];
119056 tRowcnt *anEq = pMin->anEq;
119057 tRowcnt *anLt = pMin->anLt;
119058 tRowcnt *anDLt = pMin->anDLt;
119059 sampleClear(p->db, pMin);
119060 memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1));
119061 pSample = &p->a[p->nSample-1];
119062 pSample->nRowid = 0;
119063 pSample->anEq = anEq;
119064 pSample->anDLt = anDLt;
119065 pSample->anLt = anLt;
119066 p->nSample = p->mxSample-1;
119069 /* The "rows less-than" for the rowid column must be greater than that
119070 ** for the last sample in the p->a[] array. Otherwise, the samples would
119072 assert( p->nSample==0
119073 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
119076 pSample = &p->a[p->nSample];
119078 p->nSample++;
119081 memset(pSample->anEq, 0, sizeof(tRowcnt)*nEqZero);
119084 if( p->nSample>=p->mxSample ){
119085 int iMin = -1;
119086 for(i=0; i<p->mxSample; i++){
119087 if( p->a[i].isPSample ) continue;
119088 if( iMin<0 || sampleIsBetter(p, &p->a[iMin], &p->a[i]) ){
119093 p->iMin = iMin;
119101 ** p->current contains a sample that reflects the previous row of the
119110 for(i=(p->nCol-2); i>=iChng; i--){
119111 StatSample *pBest = &p->aBest[i];
119112 pBest->anEq[i] = p->current.anEq[i];
119113 if( p->nSample<p->mxSample || sampleIsBetter(p, pBest, &p->a[p->iMin]) ){
119119 ** p->nMaxEqZero or greater set to zero. */
119120 for(i=p->nSample-1; i>=0; i--){
119122 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
119126 if( iChng<p->nMaxEqZero ){
119127 for(i=p->nSample-1; i>=0; i--){
119129 for(j=iChng; j<p->nCol; j++){
119130 if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
119133 p->nMaxEqZero = iChng;
119143 ** C Index of left-most column to differ from previous row
119153 ** if it wants the byte-code to do special processing.
119170 assert( p->nCol>0 );
119171 assert( iChng<p->nCol );
119173 if( p->nRow==0 ){
119176 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
119181 if( p->mxSample ) samplePushPrevious(p, iChng);
119188 p->current.anEq[i]++;
119191 for(i=iChng; i<p->nCol; i++){
119192 p->current.anDLt[i]++;
119194 if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i];
119195 p->current.anEq[i] = 1;
119200 p->nRow++;
119202 if( p->mxSample ){
119205 sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
119207 sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
119210 p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
119212 nLt = p->current.anLt[p->nCol-1];
119214 if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){
119215 p->current.isPSample = 1;
119216 p->current.iCol = 0;
119217 sampleInsert(p, &p->current, p->nCol-1);
119218 p->current.isPSample = 0;
119222 for(i=0; i<(p->nCol-1); i++){
119223 p->current.iCol = i;
119224 if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){
119225 sampleCopy(p, &p->aBest[i], &p->current);
119230 if( p->nLimit && p->nRow>(tRowcnt)p->nLimit*(p->nSkipAhead+1) ){
119231 p->nSkipAhead++;
119232 sqlite3_result_int(context, p->current.anDLt[0]>0);
119270 ** a one-parameter function, stat_get(P), that always returns the
119287 assert( eCall==STAT_GET_STAT1 || p->mxSample );
119303 ** "100 10 2", then SQLite estimates that:
119305 ** * the index contains 100 rows,
119312 ** I = (K+D-1)/D
119322 sqlite3StrAccumInit(&sStat, 0, 0, 0, (p->nKeyCol+1)*100);
119324 p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow);
119325 for(i=0; i<p->nKeyCol; i++){
119326 u64 nDistinct = p->current.anDLt[i] + 1;
119327 u64 iVal = (p->nRow + nDistinct - 1) / nDistinct;
119328 if( iVal==2 && p->nRow*10 <= nDistinct*11 ) iVal = 1;
119331 assert( p->current.anEq[i] || p->nRow==0 );
119338 if( p->iGet<0 ){
119340 p->iGet = 0;
119342 if( p->iGet<p->nSample ){
119343 StatSample *pS = p->a + p->iGet;
119344 if( pS->nRowid==0 ){
119345 sqlite3_result_int64(context, pS->u.iRowid);
119347 sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid,
119356 assert( p->iGet<p->nSample );
119358 case STAT_GET_NEQ: aCnt = p->a[p->iGet].anEq; break;
119359 case STAT_GET_NLT: aCnt = p->a[p->iGet].anLt; break;
119361 aCnt = p->a[p->iGet].anDLt;
119362 p->iGet++;
119366 sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
119367 for(i=0; i<p->nCol; i++){
119370 if( sStat.nChar ) sStat.nChar--;
119392 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Integer, iParam, regStat+1);
119405 ** of the k-th column of the pIdx index.
119413 assert( k>=0 && k<pIdx->nColumn );
119414 i = pIdx->aiColumn[k];
119416 VdbeComment((v,"%s.rowid",pIdx->zName));
119418 assert( pIdx->bHasExpr );
119419 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
119421 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
119440 sqlite3 *db = pParse->db; /* Database handle */
119446 int jZeroRows = -1; /* Jump from here if number of rows is zero */
119460 int doOnce = 1; /* Flag for a one-time computation */
119476 if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
119481 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
119485 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
119486 db->aDb[iDb].zDbSName ) ){
119492 if( db->xPreUpdateCallback ){
119495 pStat1->zName = (char*)&pStat1[1];
119496 memcpy(pStat1->zName, "sqlite_stat1", 13);
119497 pStat1->nCol = 3;
119498 pStat1->iPKey = -1;
119499 sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNAMIC);
119503 /* Establish a read-lock on the table at the shared-cache level.
119504 ** Open a read-only cursor on the table. Also allocate a cursor number
119507 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119510 pParse->nTab = MAX(pParse->nTab, iTab);
119512 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
119514 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
119522 if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0;
119524 nCol = pIdx->nKeyCol;
119525 zIdxName = pTab->zName;
119526 nColTest = nCol - 1;
119528 nCol = pIdx->nColumn;
119529 zIdxName = pIdx->zName;
119530 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
119535 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
119538 ** Pseudo-code for loop that calls stat_push():
119580 /* Open a read-only cursor on the index being analyzed. */
119581 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
119582 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
119584 VdbeComment((v, "%s", pIdx->zName));
119599 sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
119608 sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
119637 if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){
119638 /* For a single-column UNIQUE index, once we have found a non-NULL
119645 char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
119665 sqlite3VdbeJumpHere(v, addrNextRow-1);
119688 Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
119690 regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
119691 for(j=0; j<pPk->nKeyCol; j++){
119692 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
119693 assert( k>=0 && k<pIdx->nColumn );
119697 sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid);
119698 sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol);
119706 if( db->nAnalysisLimit ){
119722 if( pIdx->pPartIdxWhere ){
119723 /* Partial indexes might get a zero-entry in sqlite_stat1. But
119734 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
119740 if( OptimizationEnabled(db, SQLITE_Stat4) && db->nAnalysisLimit==0 ){
119763 for(pX=pTab->pIndex; pX; pX=pX->pNext){
119766 nColX = pX->nKeyCol;
119768 nColX = pX->nColumn;
119779 ** https://sqlite.org/forum/forumpost/83cb4a95a0 (2023-03-25)
119783 sqlite3ClearTempRegCache(pParse); /* tag-20230325-1 */
119804 sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
119818 VdbeComment((v, "%s", pTab->zName));
119828 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
119850 sqlite3 *db = pParse->db;
119851 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
119858 iStatCur = pParse->nTab;
119859 pParse->nTab += 3;
119861 iMem = pParse->nMem+1;
119862 iTab = pParse->nTab;
119864 for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
119886 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
119887 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
119889 iStatCur = pParse->nTab;
119890 pParse->nTab += 3;
119892 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
119894 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
119896 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
119904 ** ANALYZE -- 1
119905 ** ANALYZE <database> -- 2
119906 ** ANALYZE ?<database>.?<tablename> -- 3
119913 sqlite3 *db = pParse->db;
119924 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
119932 for(i=0; i<db->nDb; i++){
119936 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
119943 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
119947 analyzeTable(pParse, pIdx->pTable, pIdx);
119955 if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
119971 ** The first argument points to a nul-terminated string containing a
119995 v = v*10 + c - '0';
120014 pIndex->bUnordered = 0;
120015 pIndex->noSkipScan = 0;
120018 pIndex->bUnordered = 1;
120019 }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){
120022 pIndex->szIdxRow = sqlite3LogEst(sz);
120024 pIndex->noSkipScan = 1;
120027 else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){
120028 pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9));
120039 if( aLog[0] > 66 /* Index has more than 100 rows */
120040 && aLog[0] <= aLog[nOut-1] /* And only a single value seen */
120042 pIndex->bLowQual = 1;
120053 ** argv[2] = results of analysis - on integer for each column
120070 pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
120079 pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
120085 int nCol = pIndex->nKeyCol+1;
120090 if( pIndex->aiRowEst==0 ){
120091 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
120092 if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db);
120094 aiRowEst = pIndex->aiRowEst;
120096 pIndex->bUnordered = 0;
120097 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
120098 pIndex->hasStat1 = 1;
120099 if( pIndex->pPartIdxWhere==0 ){
120100 pTable->nRowLogEst = pIndex->aiRowLogEst[0];
120101 pTable->tabFlags |= TF_HasStat1;
120105 fakeIdx.szIdxRow = pTable->szTabRow;
120109 decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
120110 pTable->szTabRow = fakeIdx.szIdxRow;
120111 pTable->tabFlags |= TF_HasStat1;
120125 if( pIdx->aSample ){
120127 for(j=0; j<pIdx->nSample; j++){
120128 IndexSample *p = &pIdx->aSample[j];
120129 sqlite3DbFree(db, p->p);
120131 sqlite3DbFree(db, pIdx->aSample);
120133 if( db->pnBytesFreed==0 ){
120134 pIdx->nSample = 0;
120135 pIdx->aSample = 0;
120145 ** Populate the pIdx->aAvgEq[] array based on the samples currently
120146 ** stored in pIdx->aSample[].
120150 IndexSample *aSample = pIdx->aSample;
120151 IndexSample *pFinal = &aSample[pIdx->nSample-1];
120154 if( pIdx->nSampleCol>1 ){
120159 nCol = pIdx->nSampleCol-1;
120160 pIdx->aAvgEq[nCol] = 1;
120163 int nSample = pIdx->nSample;
120171 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
120172 nRow = pFinal->anLt[iCol];
120173 nDist100 = (i64)100 * pFinal->anDLt[iCol];
120174 nSample--;
120176 nRow = pIdx->aiRowEst[0];
120177 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
120179 pIdx->nRowEst0 = nRow;
120186 if( i==(pIdx->nSample-1)
120190 nSum100 += 100;
120195 avgEq = ((i64)100 * (nRow - sumEq))/(nDist100 - nSum100);
120198 pIdx->aAvgEq[iCol] = avgEq;
120242 IndexSample *pSample; /* A slot in pIdx->aSample[] */
120244 assert( db->lookaside.bDisable );
120249 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
120267 assert( pIdx==0 || pIdx->nSample==0 );
120269 if( pIdx->aSample!=0 ){
120273 assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 );
120274 if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){
120275 nIdxCol = pIdx->nKeyCol;
120277 nIdxCol = pIdx->nColumn;
120279 pIdx->nSampleCol = nIdxCol;
120280 pIdx->mxSample = nSample;
120285 pIdx->aSample = sqlite3DbMallocZero(db, nByte);
120286 if( pIdx->aSample==0 ){
120290 pSpace = (tRowcnt*)&pIdx->aSample[nSample];
120291 pIdx->aAvgEq = pSpace; pSpace += nIdxCol;
120292 pIdx->pTable->tabFlags |= TF_HasStat4;
120294 pIdx->aSample[i].anEq = pSpace; pSpace += nIdxCol;
120295 pIdx->aSample[i].anLt = pSpace; pSpace += nIdxCol;
120296 pIdx->aSample[i].anDLt = pSpace; pSpace += nIdxCol;
120298 assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) );
120307 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
120320 if( pIdx->nSample>=pIdx->mxSample ){
120327 nCol = pIdx->nSampleCol;
120332 pSample = &pIdx->aSample[pIdx->nSample];
120333 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
120334 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
120335 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
120344 pSample->n = sqlite3_column_bytes(pStmt, 4);
120345 pSample->p = sqlite3DbMallocZero(db, pSample->n + 8);
120346 if( pSample->p==0 ){
120350 if( pSample->n ){
120351 memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n);
120353 pIdx->nSample++;
120368 assert( db->lookaside.bDisable );
120399 ** If an OOM error occurs, this function always sets db->mallocFailed.
120408 Schema *pSchema = db->aDb[iDb].pSchema;
120411 assert( iDb>=0 && iDb<db->nDb );
120412 assert( db->aDb[iDb].pBt!=0 );
120416 for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){
120418 pTab->tabFlags &= ~TF_HasStat1;
120420 for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
120422 pIdx->hasStat1 = 0;
120425 pIdx->aSample = 0;
120431 sInfo.zDatabase = db->aDb[iDb].zDbSName;
120447 for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
120449 if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx);
120459 for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){
120461 sqlite3_free(pIdx->aiRowEst);
120462 pIdx->aiRowEst = 0;
120515 if( pExpr->op!=TK_ID ){
120518 pExpr->op = TK_STRING;
120530 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
120536 ** An SQL user-function registered to do the work of an ATTACH statement. The
120546 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
120547 ** new database, close the database on db->init.iDb and reopen it as an
120575 # define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb)
120582 ** from sqlite3_deserialize() to close database db->init.iDb and
120594 pNew = &db->aDb[db->init.iDb];
120595 if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt);
120596 pNew->pBt = pNewBt;
120597 pNew->pSchema = pNewSchema;
120613 if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
120614 zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
120615 db->aLimit[SQLITE_LIMIT_ATTACHED]
120619 for(i=0; i<db->nDb; i++){
120627 /* Allocate the new entry in the db->aDb[] array and initialize the schema
120630 if( db->aDb==db->aDbStatic ){
120631 aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
120633 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
120635 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
120638 db->aDb = aNew;
120639 pNew = &db->aDb[db->nDb];
120646 flags = db->openFlags;
120647 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
120650 sqlite3_result_error(context, zErr, -1);
120656 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
120657 db->nDb++;
120658 pNew->zDbSName = sqlite3DbStrDup(db, zName);
120660 db->noSharedCache = 0;
120666 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
120667 if( !pNew->pSchema ){
120669 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
120674 sqlite3BtreeEnter(pNew->pBt);
120675 pPager = sqlite3BtreePager(pNew->pBt);
120676 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
120677 sqlite3BtreeSecureDelete(pNew->pBt,
120678 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
120680 sqlite3BtreeSetPagerFlags(pNew->pBt,
120681 PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
120683 sqlite3BtreeLeave(pNew->pBt);
120685 pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
120686 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
120693 ** remove the entry from the db->aDb[] array. i.e. put everything back the
120698 db->init.iDb = 0;
120699 db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
120710 if( newAuth<db->auth.authLevel ){
120717 int iDb = db->nDb - 1;
120719 if( db->aDb[iDb].pBt ){
120720 sqlite3BtreeClose(db->aDb[iDb].pBt);
120721 db->aDb[iDb].pBt = 0;
120722 db->aDb[iDb].pSchema = 0;
120725 db->nDb = iDb;
120742 sqlite3_result_error(context, zErrDyn, -1);
120749 ** An SQL user-function registered to do the work of an DETACH statement. The
120771 for(i=0; i<db->nDb; i++){
120772 pDb = &db->aDb[i];
120773 if( pDb->pBt==0 ) continue;
120777 if( i>=db->nDb ){
120785 if( sqlite3BtreeTxnState(pDb->pBt)!=SQLITE_TXN_NONE
120786 || sqlite3BtreeIsInBackup(pDb->pBt)
120794 assert( db->aDb[1].pSchema );
120795 pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
120798 if( pTrig->pTabSchema==pDb->pSchema ){
120799 pTrig->pTabSchema = pTrig->pSchema;
120804 sqlite3BtreeClose(pDb->pBt);
120805 pDb->pBt = 0;
120806 pDb->pSchema = 0;
120811 sqlite3_result_error(context, zErr, -1);
120830 sqlite3* db = pParse->db;
120835 if( pParse->nErr ) goto attach_end;
120850 if( pAuthArg->op==TK_STRING ){
120852 zAuthArg = pAuthArg->u.zToken;
120870 assert( v || db->mallocFailed );
120872 sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
120873 pFunc->nArg, pFunc, 0);
120932 DbFixer *pFix = p->u.pFix;
120933 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
120934 if( pExpr->op==TK_VARIABLE ){
120935 if( pFix->pParse->db->init.busy ){
120936 pExpr->op = TK_NULL;
120938 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
120949 DbFixer *pFix = p->u.pFix;
120952 sqlite3 *db = pFix->pParse->db;
120953 int iDb = sqlite3FindDbName(db, pFix->zDb);
120954 SrcList *pList = pSelect->pSrc;
120957 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
120958 if( pFix->bTemp==0 ){
120959 if( pItem->zDatabase ){
120960 if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
120961 sqlite3ErrorMsg(pFix->pParse,
120963 pFix->zType, pFix->pName, pItem->zDatabase);
120966 sqlite3DbFree(db, pItem->zDatabase);
120967 pItem->zDatabase = 0;
120968 pItem->fg.notCte = 1;
120970 pItem->pSchema = pFix->pSchema;
120971 pItem->fg.fromDDL = 1;
120974 if( pList->a[i].fg.isUsing==0
120975 && sqlite3WalkExpr(&pFix->w, pList->a[i].u3.pOn)
120981 if( pSelect->pWith ){
120982 for(i=0; i<pSelect->pWith->nCte; i++){
120983 if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){
121002 sqlite3 *db = pParse->db;
121003 assert( db->nDb>iDb );
121004 pFix->pParse = pParse;
121005 pFix->zDb = db->aDb[iDb].zDbSName;
121006 pFix->pSchema = db->aDb[iDb].pSchema;
121007 pFix->zType = zType;
121008 pFix->pName = pName;
121009 pFix->bTemp = (iDb==1);
121010 pFix->w.pParse = pParse;
121011 pFix->w.xExprCallback = fixExprCb;
121012 pFix->w.xSelectCallback = fixSelectCb;
121013 pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback;
121014 pFix->w.walkerDepth = 0;
121015 pFix->w.eCode = 0;
121016 pFix->w.u.pFix = pFix;
121030 ** pParse->zErrMsg and these routines return non-zero. If everything
121042 res = sqlite3WalkSelect(&pFix->w, &s);
121051 return sqlite3WalkSelect(&pFix->w, pSelect);
121057 return sqlite3WalkExpr(&pFix->w, pExpr);
121067 if( sqlite3WalkSelect(&pFix->w, pStep->pSelect)
121068 || sqlite3WalkExpr(&pFix->w, pStep->pWhere)
121069 || sqlite3WalkExprList(&pFix->w, pStep->pExprList)
121070 || sqlite3FixSrcList(pFix, pStep->pFrom)
121077 for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){
121078 if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget)
121079 || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere)
121080 || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet)
121081 || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere)
121088 pStep = pStep->pNext;
121111 ** the library with -DSQLITE_OMIT_AUTHORIZATION=1
121158 ** means that the SQL statement will never-run - the sqlite3_exec() call
121174 sqlite3_mutex_enter(db->mutex);
121175 db->xAuth = (sqlite3_xauth)xAuth;
121176 db->pAuthArg = pArg;
121177 if( db->xAuth ) sqlite3ExpirePreparedStatements(db, 1);
121178 sqlite3_mutex_leave(db->mutex);
121183 ** Write an error message into pParse->zErrMsg that explains that the
121184 ** user-supplied authorization function returned an illegal value.
121188 pParse->rc = SQLITE_ERROR;
121206 sqlite3 *db = pParse->db; /* Database handle */
121207 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
121210 if( db->init.busy ) return SQLITE_OK;
121211 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
121213 ,db->auth.zAuthUser
121218 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
121220 pParse->rc = SQLITE_AUTH;
121244 int iSrc; /* Index in pTabList->a[] of table being read */
121248 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
121250 assert( pParse->db->xAuth!=0 );
121251 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
121258 if( pExpr->op==TK_TRIGGER ){
121259 pTab = pParse->pTriggerTab;
121262 for(iSrc=0; iSrc<pTabList->nSrc; iSrc++){
121263 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
121264 pTab = pTabList->a[iSrc].pTab;
121269 iCol = pExpr->iColumn;
121273 assert( iCol<pTab->nCol );
121274 zCol = pTab->aCol[iCol].zCnName;
121275 }else if( pTab->iPKey>=0 ){
121276 assert( pTab->iPKey<pTab->nCol );
121277 zCol = pTab->aCol[pTab->iPKey].zCnName;
121281 assert( iDb>=0 && iDb<pParse->db->nDb );
121282 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
121283 pExpr->op = TK_NULL;
121300 sqlite3 *db = pParse->db;
121306 assert( !IN_RENAME_OBJECT || db->xAuth==0 );
121307 if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){
121311 /* EVIDENCE-OF: R-43249-19882 The third through sixth parameters to the
121312 ** callback are either NULL pointers or zero-terminated strings that
121320 testcase( pParse->zAuthContext==0 );
121322 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
121324 ,db->auth.zAuthUser
121329 pParse->rc = SQLITE_AUTH;
121340 ** popped. Or if pParse==0, this routine is a no-op.
121348 pContext->pParse = pParse;
121349 pContext->zAuthContext = pParse->zAuthContext;
121350 pParse->zAuthContext = zContext;
121358 if( pContext->pParse ){
121359 pContext->pParse->zAuthContext = pContext->zAuthContext;
121360 pContext->pParse = 0;
121407 ** Record the fact that we want to lock a table at run-time.
121430 for(i=0; i<pToplevel->nTableLock; i++){
121431 p = &pToplevel->aTableLock[i];
121432 if( p->iDb==iDb && p->iTab==iTab ){
121433 p->isWriteLock = (p->isWriteLock || isWriteLock);
121438 nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
121439 pToplevel->aTableLock =
121440 sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
121441 if( pToplevel->aTableLock ){
121442 p = &pToplevel->aTableLock[pToplevel->nTableLock++];
121443 p->iDb = iDb;
121444 p->iTab = iTab;
121445 p->isWriteLock = isWriteLock;
121446 p->zLockName = zName;
121448 pToplevel->nTableLock = 0;
121449 sqlite3OomFault(pToplevel->db);
121460 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
121470 Vdbe *pVdbe = pParse->pVdbe;
121473 for(i=0; i<pParse->nTableLock; i++){
121474 TableLock *p = &pParse->aTableLock[i];
121475 int p1 = p->iDb;
121476 sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
121477 p->zLockName, P4_STATIC);
121485 ** Return TRUE if the given yDbMask object is empty - if it contains no
121512 assert( pParse->pToplevel==0 );
121513 db = pParse->db;
121514 assert( db->pParse==pParse );
121515 if( pParse->nested ) return;
121516 if( pParse->nErr ){
121517 if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM;
121520 assert( db->mallocFailed==0 );
121525 v = pParse->pVdbe;
121527 if( db->init.busy ){
121528 pParse->rc = SQLITE_DONE;
121532 if( v==0 ) pParse->rc = SQLITE_ERROR;
121534 assert( !pParse->isMultiWrite
121535 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
121537 if( pParse->bReturning ){
121538 Returning *pReturning = pParse->u1.pReturning;
121542 if( pReturning->nRetCol ){
121545 sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
121547 reg = pReturning->iRetReg;
121548 for(i=0; i<pReturning->nRetCol; i++){
121549 sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
121552 sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
121560 if( pParse->nTableLock>0 && db->init.busy==0 ){
121562 if( db->auth.authLevel<UAUTH_User ){
121564 pParse->rc = SQLITE_AUTH_USER;
121576 assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
121578 assert( db->nDb>0 );
121582 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
121584 pSchema = db->aDb[iDb].pSchema;
121588 DbMaskTest(pParse->writeMask,iDb), /* P2 */
121589 pSchema->schema_cookie, /* P3 */
121590 pSchema->iGeneration /* P4 */
121592 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
121594 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
121595 }while( ++iDb<db->nDb );
121597 for(i=0; i<pParse->nVtabLock; i++){
121598 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
121601 pParse->nVtabLock = 0;
121606 ** obtain the required table-locks. This is a no-op unless the
121607 ** shared-cache feature is enabled.
121609 if( pParse->nTableLock ) codeTableLocks(pParse);
121614 if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
121618 if( pParse->pConstExpr ){
121619 ExprList *pEL = pParse->pConstExpr;
121620 pParse->okConstFactor = 0;
121621 for(i=0; i<pEL->nExpr; i++){
121622 assert( pEL->a[i].u.iConstExprReg>0 );
121623 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
121627 if( pParse->bReturning ){
121628 Returning *pRet = pParse->u1.pReturning;
121629 if( pRet->nRetCol ){
121630 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
121640 assert( v!=0 || pParse->nErr );
121641 assert( db->mallocFailed==0 || pParse->nErr );
121642 if( pParse->nErr==0 ){
121645 assert( pParse->pAinc==0 || pParse->nTab>0 );
121647 pParse->rc = SQLITE_DONE;
121649 pParse->rc = SQLITE_ERROR;
121662 ** * Built-in SQL functions always take precedence over application-defined
121664 ** built-in function.
121669 sqlite3 *db = pParse->db;
121670 u32 savedDbFlags = db->mDbFlags;
121673 if( pParse->nErr ) return;
121674 if( pParse->eParseMode ) return;
121675 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
121683 if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
121684 pParse->nErr++;
121687 pParse->nested++;
121690 db->mDbFlags |= DBFLAG_PreferBuiltin;
121692 db->mDbFlags = savedDbFlags;
121695 pParse->nested--;
121709 ** Locate the in-memory structure that describes a particular database
121729 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
121734 for(i=0; i<db->nDb; i++){
121735 if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;
121737 if( i>=db->nDb ){
121746 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
121753 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
121758 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
121765 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
121768 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
121771 for(i=2; i<db->nDb; i++){
121773 p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
121778 p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, LEGACY_SCHEMA_TABLE);
121780 p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
121789 ** Locate the in-memory structure that describes a particular database
121792 ** error message in pParse->zErrMsg.
121795 ** routine leaves an error message in pParse->zErrMsg where
121805 sqlite3 *db = pParse->db;
121809 if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
121821 if( (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==0 ){
121822 Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
121827 testcase( pMod->pEpoTab==0 );
121828 return pMod->pEpoTab;
121833 pParse->checkSchema = 1;
121834 }else if( IsVirtual(p) && (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)!=0 ){
121846 assert( HasRowid(p) || p->iPKey<0 );
121857 ** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be
121858 ** non-NULL if it is part of a view or trigger program definition. See
121867 assert( p->pSchema==0 || p->zDatabase==0 );
121868 if( p->pSchema ){
121869 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
121870 zDb = pParse->db->aDb[iDb].zDbSName;
121872 zDb = p->zDatabase;
121874 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
121894 ** Locate the in-memory structure that describes
121910 for(i=OMIT_TEMPDB; i<db->nDb; i++){
121912 Schema *pSchema = db->aDb[j].pSchema;
121916 p = sqlite3HashFind(&pSchema->idxHash, zName);
121929 sqlite3ExprDelete(db, p->pPartIdxWhere);
121930 sqlite3ExprListDelete(db, p->aColExpr);
121931 sqlite3DbFree(db, p->zColAff);
121932 if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
121934 sqlite3_free(p->aiRowEst);
121950 pHash = &db->aDb[iDb].pSchema->idxHash;
121953 if( pIndex->pTable->pIndex==pIndex ){
121954 pIndex->pTable->pIndex = pIndex->pNext;
121959 p = pIndex->pTable->pIndex;
121960 while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
121961 if( ALWAYS(p && p->pNext==pIndex) ){
121962 p->pNext = pIndex->pNext;
121967 db->mDbFlags |= DBFLAG_SchemaChange;
121971 ** Look through the list of open database files in db->aDb[] and if
121973 ** db->aDb[] structure to a smaller size, if possible.
121980 for(i=j=2; i<db->nDb; i++){
121981 struct Db *pDb = &db->aDb[i];
121982 if( pDb->pBt==0 ){
121983 sqlite3DbFree(db, pDb->zDbSName);
121984 pDb->zDbSName = 0;
121988 db->aDb[j] = db->aDb[i];
121992 db->nDb = j;
121993 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
121994 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
121995 sqlite3DbFree(db, db->aDb);
121996 db->aDb = db->aDbStatic;
122002 ** TEMP schema. The reset is deferred if db->nSchemaLock is not zero.
122007 assert( iDb<db->nDb );
122013 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
122016 if( db->nSchemaLock==0 ){
122017 for(i=0; i<db->nDb; i++){
122019 sqlite3SchemaClear(db->aDb[i].pSchema);
122032 for(i=0; i<db->nDb; i++){
122033 Db *pDb = &db->aDb[i];
122034 if( pDb->pSchema ){
122035 if( db->nSchemaLock==0 ){
122036 sqlite3SchemaClear(pDb->pSchema);
122042 db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
122045 if( db->nSchemaLock==0 ){
122054 db->mDbFlags &= ~DBFLAG_SchemaChange;
122070 pList = pTab->u.tab.pDfltList;
122071 if( pCol->iDflt==0
122073 || NEVER(pList->nExpr<pCol->iDflt)
122075 pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;
122076 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
122078 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
122079 pList->a[pCol->iDflt-1].pExpr = pExpr;
122089 if( pCol->iDflt==0 ) return 0;
122091 if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
122092 if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
122093 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
122108 n = sqlite3Strlen30(pCol->zCnName) + 1;
122109 if( pCol->colFlags & COLFLAG_HASTYPE ){
122110 n += sqlite3Strlen30(pCol->zCnName+n) + 1;
122113 zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n);
122115 pCol->zCnName = zNew;
122116 memcpy(pCol->zCnName + n, zColl, nColl);
122117 pCol->colFlags |= COLFLAG_HASCOLL;
122126 if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0;
122127 z = pCol->zCnName;
122129 if( pCol->colFlags & COLFLAG_HASTYPE ){
122144 if( (pCol = pTable->aCol)!=0 ){
122145 for(i=0; i<pTable->nCol; i++, pCol++){
122146 assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) );
122147 sqlite3DbFree(db, pCol->zCnName);
122149 sqlite3DbNNFreeNN(db, pTable->aCol);
122151 sqlite3ExprListDelete(db, pTable->u.tab.pDfltList);
122153 if( db->pnBytesFreed==0 ){
122154 pTable->aCol = 0;
122155 pTable->nCol = 0;
122157 pTable->u.tab.pDfltList = 0;
122175 ** db parameter can be used with db->pnBytesFreed to measure the memory
122191 if( !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
122197 for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
122198 pNext = pIndex->pNext;
122199 assert( pIndex->pSchema==pTable->pSchema
122200 || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) );
122201 if( db->pnBytesFreed==0 && !IsVirtual(pTable) ){
122202 char *zName = pIndex->zName;
122204 &pIndex->pSchema->idxHash, zName, 0
122206 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
122222 sqlite3SelectDelete(db, pTable->u.view.pSelect);
122228 sqlite3DbFree(db, pTable->zName);
122229 sqlite3DbFree(db, pTable->zColAff);
122230 sqlite3ExprListDelete(db, pTable->pCheck);
122240 if( db->pnBytesFreed==0 && (--pTable->nTabRef)>0 ) return;
122257 assert( iDb>=0 && iDb<db->nDb );
122260 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
122261 pDb = &db->aDb[iDb];
122262 p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0);
122264 db->mDbFlags |= DBFLAG_SchemaChange;
122283 zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
122299 if( p->nTab==0 ){
122300 p->nTab = 1;
122305 ** Parameter zName points to a nul-terminated buffer containing the name
122307 ** function returns the index of the named database in db->aDb[], or
122308 ** -1 if the named db cannot be found.
122311 int i = -1; /* Database number */
122314 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
122315 if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break;
122327 ** index of the named database in db->aDb[], or -1 if the named db
122362 sqlite3 *db = pParse->db;
122365 if( pName2->n>0 ){
122366 if( db->init.busy ) {
122368 return -1;
122374 return -1;
122377 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
122378 || (db->mDbFlags & DBFLAG_Vacuum)!=0);
122379 iDb = db->init.iDb;
122389 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
122390 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
122392 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
122394 testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
122396 return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
122400 ** This routine is used to check if the UTF-8 string zName is a legal
122416 sqlite3 *db = pParse->db;
122418 || db->init.imposterTable
122424 if( db->init.busy ){
122425 if( sqlite3_stricmp(zType, db->init.azInit[0])
122426 || sqlite3_stricmp(zName, db->init.azInit[1])
122427 || sqlite3_stricmp(zTblName, db->init.azInit[2])
122433 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
122450 for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){}
122457 ** find the (first) offset of that column in index pIdx. Or return -1
122462 for(i=0; i<pIdx->nColumn; i++){
122463 if( iCol==pIdx->aiColumn[i] ) return i;
122465 return -1;
122478 ** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro.
122481 if( pTab->tabFlags & TF_HasVirtual ){
122484 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
122496 ** the N-th virtual column (zero-based) then the storage number is
122497 ** the number of non-virtual columns in the table plus N.
122513 ** -- 0 1 2 3 4 5 6 7 8
122524 ** this routine is a no-op macro. If the pTab does not have any virtual
122525 ** columns, then this routine is no-op that always return iCol. If iCol
122531 assert( iCol<pTab->nCol );
122532 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
122534 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
122536 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
122538 return pTab->nNVCol + i - n;
122552 ** is a read-only no-op.
122555 int iReg = ++pParse->nMem;
122573 ** The new table record is initialized and put in pParse->pNewTable.
122590 sqlite3 *db = pParse->db;
122595 if( db->init.busy && db->init.newTnum==1 ){
122597 iDb = db->init.iDb;
122604 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
122616 pParse->sNameToken = *pName;
122621 if( db->init.iDb==1 ) isTemp = 1;
122632 char *zDb = db->aDb[iDb].zDbSName;
122651 char *zDb = db->aDb[iDb].zDbSName;
122661 assert( !db->init.busy || CORRUPT_DB );
122675 assert( db->mallocFailed );
122676 pParse->rc = SQLITE_NOMEM_BKPT;
122677 pParse->nErr++;
122680 pTable->zName = zName;
122681 pTable->iPKey = -1;
122682 pTable->pSchema = db->aDb[iDb].pSchema;
122683 pTable->nTabRef = 1;
122685 pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST);
122687 pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
122689 assert( pParse->pNewTable==0 );
122690 pParse->pNewTable = pTable;
122700 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
122717 reg1 = pParse->regRowid = ++pParse->nMem;
122718 reg2 = pParse->regRoot = ++pParse->nMem;
122719 reg3 = ++pParse->nMem;
122723 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
122729 /* This just creates a place-holder record in the sqlite_schema table.
122733 ** The rowid for the new entry is left in register pParse->regRowid.
122734 ** The root page number of the new table is left in reg pParse->regRoot.
122744 assert( !pParse->bReturning );
122745 pParse->u1.addrCrTab =
122756 /* Normal (non-error) return. */
122761 pParse->checkSchema = 1;
122771 if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){
122772 pCol->colFlags |= COLFLAG_HIDDEN;
122773 if( pTab ) pTab->tabFlags |= TF_HasHidden;
122774 }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
122775 pTab->tabFlags |= TF_OOOHidden;
122786 pHash = &(db->aDb[1].pSchema->trigHash);
122787 sqlite3HashInsert(pHash, pRet->zName, 0);
122788 sqlite3ExprListDelete(db, pRet->pReturnEL);
122811 sqlite3 *db = pParse->db;
122812 if( pParse->pNewTrigger ){
122815 assert( pParse->bReturning==0 || pParse->ifNotExists );
122817 pParse->bReturning = 1;
122823 pParse->u1.pReturning = pRet;
122824 pRet->pParse = pParse;
122825 pRet->pReturnEL = pList;
122827 testcase( pParse->earlyCleanup );
122828 if( db->mallocFailed ) return;
122829 sqlite3_snprintf(sizeof(pRet->zName), pRet->zName,
122831 pRet->retTrig.zName = pRet->zName;
122832 pRet->retTrig.op = TK_RETURNING;
122833 pRet->retTrig.tr_tm = TRIGGER_AFTER;
122834 pRet->retTrig.bReturning = 1;
122835 pRet->retTrig.pSchema = db->aDb[1].pSchema;
122836 pRet->retTrig.pTabSchema = db->aDb[1].pSchema;
122837 pRet->retTrig.step_list = &pRet->retTStep;
122838 pRet->retTStep.op = TK_RETURNING;
122839 pRet->retTStep.pTrig = &pRet->retTrig;
122840 pRet->retTStep.pExprList = pList;
122841 pHash = &(db->aDb[1].pSchema->trigHash);
122842 assert( sqlite3HashFind(pHash, pRet->zName)==0
122843 || pParse->nErr || pParse->ifNotExists );
122844 if( sqlite3HashInsert(pHash, pRet->zName, &pRet->retTrig)
122845 ==&pRet->retTrig ){
122864 sqlite3 *db = pParse->db;
122871 if( (p = pParse->pNewTable)==0 ) return;
122872 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
122873 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
122883 && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0
122885 sType.n -= 6;
122886 while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
122888 && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0
122890 sType.n -= 9;
122891 while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
122920 for(i=0; i<p->nCol; i++){
122921 if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){
122927 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
122932 p->aCol = aNew;
122933 pCol = &p->aCol[p->nCol];
122934 memset(pCol, 0, sizeof(p->aCol[0]));
122935 pCol->zCnName = z;
122936 pCol->hName = hName;
122942 pCol->affinity = affinity;
122943 pCol->eCType = eType;
122944 pCol->szEst = szEst;
122948 pCol->colFlags |= COLFLAG_SORTERREF;
122957 pCol->affinity = sqlite3AffinityType(zType, pCol);
122958 pCol->colFlags |= COLFLAG_HASTYPE;
122960 p->nCol++;
122961 p->nNVCol++;
122962 pParse->constraintName.n = 0;
122974 p = pParse->pNewTable;
122975 if( p==0 || NEVER(p->nCol<1) ) return;
122976 pCol = &p->aCol[p->nCol-1];
122977 pCol->notNull = (u8)onError;
122978 p->tabFlags |= TF_HasNotNull;
122982 if( pCol->colFlags & COLFLAG_UNIQUE ){
122984 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
122985 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
122986 if( pIdx->aiColumn[0]==p->nCol-1 ){
122987 pIdx->uniqNotNull = 1;
122997 ** This routine does a case-independent search of zType for the
123005 ** --------------------------------
123064 /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
123071 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
123076 pCol->colFlags |= COLFLAG_SORTERREF;
123081 pCol->szEst = v;
123104 sqlite3 *db = pParse->db;
123105 p = pParse->pNewTable;
123107 int isInit = db->init.busy && db->init.iDb!=1;
123108 pCol = &(p->aCol[p->nCol-1]);
123111 pCol->zCnName);
123113 }else if( pCol->colFlags & COLFLAG_GENERATED ){
123114 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
123115 testcase( pCol->colFlags & COLFLAG_STORED );
123156 if( p->op==TK_STRING ){
123157 p->op = TK_ID;
123158 }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){
123159 p->pLeft->op = TK_ID;
123167 pCol->colFlags |= COLFLAG_PRIMKEY;
123169 if( pCol->colFlags & COLFLAG_GENERATED ){
123170 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
123171 testcase( pCol->colFlags & COLFLAG_STORED );
123190 ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
123203 Table *pTab = pParse->pNewTable;
123205 int iCol = -1, i;
123208 if( pTab->tabFlags & TF_HasPrimaryKey ){
123210 "table \"%s\" has more than one primary key", pTab->zName);
123213 pTab->tabFlags |= TF_HasPrimaryKey;
123215 iCol = pTab->nCol - 1;
123216 pCol = &pTab->aCol[iCol];
123220 nTerm = pList->nExpr;
123222 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
123225 if( pCExpr->op==TK_ID ){
123228 zCName = pCExpr->u.zToken;
123229 for(iCol=0; iCol<pTab->nCol; iCol++){
123230 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
123231 pCol = &pTab->aCol[iCol];
123241 && pCol->eCType==COLTYPE_INTEGER
123245 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
123246 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
123248 pTab->iPKey = iCol;
123249 pTab->keyConf = (u8)onError;
123251 pTab->tabFlags |= autoInc*TF_Autoincrement;
123252 if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags;
123266 sqlite3ExprListDelete(pParse->db, pList);
123280 Table *pTab = pParse->pNewTable;
123281 sqlite3 *db = pParse->db;
123283 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
123285 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
123286 if( pParse->constraintName.n ){
123287 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
123291 while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; }
123293 t.n = (int)(zEnd - t.z);
123294 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
123299 sqlite3ExprDelete(pParse->db, pCheckExpr);
123313 if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return;
123314 i = p->nCol-1;
123315 db = pParse->db;
123321 sqlite3ColumnSetColl(db, &p->aCol[i], zColl);
123327 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
123328 assert( pIdx->nKeyCol==1 );
123329 if( pIdx->aiColumn[0]==i ){
123330 pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
123343 Table *pTab = pParse->pNewTable;
123349 pCol = &(pTab->aCol[pTab->nCol-1]);
123354 if( pCol->iDflt>0 ) goto generated_error;
123356 if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
123357 /* no-op */
123358 }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
123364 if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
123365 pCol->colFlags |= eType;
123368 pTab->tabFlags |= eType;
123369 if( pCol->colFlags & COLFLAG_PRIMKEY ){
123372 if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
123379 if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
123386 pCol->zCnName);
123388 sqlite3ExprDelete(pParse->db, pExpr);
123391 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
123393 sqlite3ExprDelete(pParse->db, pExpr);
123407 ** This plan is not completely bullet-proof. It is possible for
123413 ** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments
123414 ** the schema-version whenever the schema changes.
123417 sqlite3 *db = pParse->db;
123418 Vdbe *v = pParse->pVdbe;
123421 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
123444 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
123451 ** it is quoted using double-quotes.
123487 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
123488 n += identLength(pCol->zCnName) + 5;
123490 n += identLength(p->zName);
123500 n += 35 + 6*p->nCol;
123508 identPut(zStmt, &k, p->zName);
123510 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
123522 sqlite3_snprintf(n-k, &zStmt[k], zSep);
123525 identPut(zStmt, &k, pCol->zCnName);
123526 assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
123527 assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
123528 testcase( pCol->affinity==SQLITE_AFF_BLOB );
123529 testcase( pCol->affinity==SQLITE_AFF_TEXT );
123530 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
123531 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
123532 testcase( pCol->affinity==SQLITE_AFF_REAL );
123533 testcase( pCol->affinity==SQLITE_AFF_FLEXNUM );
123535 zType = azType[pCol->affinity - SQLITE_AFF_BLOB];
123537 assert( pCol->affinity==SQLITE_AFF_BLOB
123538 || pCol->affinity==SQLITE_AFF_FLEXNUM
123539 || pCol->affinity==sqlite3AffinityType(zType, 0) );
123544 sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
123555 if( pIdx->nColumn>=N ) return SQLITE_OK;
123556 assert( pIdx->isResized==0 );
123560 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
123561 pIdx->azColl = (const char**)zExtra;
123563 memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
123564 pIdx->aiRowLogEst = (LogEst*)zExtra;
123566 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
123567 pIdx->aiColumn = (i16*)zExtra;
123569 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
123570 pIdx->aSortOrder = (u8*)zExtra;
123571 pIdx->nColumn = N;
123572 pIdx->isResized = 1;
123583 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
123584 wTable += pTabCol->szEst;
123586 if( pTab->iPKey<0 ) wTable++;
123587 pTab->szTabRow = sqlite3LogEst(wTable*4);
123596 const Column *aCol = pIdx->pTable->aCol;
123597 for(i=0; i<pIdx->nColumn; i++){
123598 i16 x = pIdx->aiColumn[i];
123599 assert( x<pIdx->pTable->nCol );
123602 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
123610 while( nCol-- > 0 ){
123620 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
123633 assert( nKey<=pIdx->nColumn );
123634 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
123635 assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
123636 assert( pPk->pTable->tabFlags & TF_WithoutRowid );
123637 assert( pPk->pTable==pIdx->pTable );
123639 j = pPk->aiColumn[iCol];
123642 assert( pIdx->aiColumn[i]>=0 || j>=0 );
123643 if( pIdx->aiColumn[i]==j
123644 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
123657 ** high-order bit of colNotIdxed is always 1. All unindexed columns
123660 ** 2019-10-24: For the purpose of this computation, virtual columns are
123668 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
123674 Table *pTab = pIdx->pTable;
123675 for(j=pIdx->nColumn-1; j>=0; j--){
123676 int x = pIdx->aiColumn[j];
123677 if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
123678 testcase( x==BMS-1 );
123679 testcase( x==BMS-2 );
123680 if( x<BMS-1 ) m |= MASKBIT(x);
123683 pIdx->colNotIdxed = ~m;
123684 assert( (pIdx->colNotIdxed>>63)==1 ); /* See note-20221022-a */
123717 sqlite3 *db = pParse->db;
123718 Vdbe *v = pParse->pVdbe;
123722 if( !db->init.imposterTable ){
123723 for(i=0; i<pTab->nCol; i++){
123724 if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
123725 && (pTab->aCol[i].notNull==OE_None)
123727 pTab->aCol[i].notNull = OE_Abort;
123730 pTab->tabFlags |= TF_HasNotNull;
123736 assert( !pParse->bReturning );
123737 if( pParse->u1.addrCrTab ){
123739 sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
123745 if( pTab->iPKey>=0 ){
123748 sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
123752 pTab->tabFlags &= ~TF_WithoutRowid;
123756 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123758 pList->a[0].fg.sortFlags = pParse->iPkSortOrder;
123759 assert( pParse->pNewTable==pTab );
123760 pTab->iPKey = -1;
123761 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
123763 if( pParse->nErr ){
123764 pTab->tabFlags &= ~TF_WithoutRowid;
123767 assert( db->mallocFailed==0 );
123769 assert( pPk->nKeyCol==1 );
123779 for(i=j=1; i<pPk->nKeyCol; i++){
123781 pPk->nColumn--;
123783 testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
123784 pPk->azColl[j] = pPk->azColl[i];
123785 pPk->aSortOrder[j] = pPk->aSortOrder[i];
123786 pPk->aiColumn[j++] = pPk->aiColumn[i];
123789 pPk->nKeyCol = j;
123792 pPk->isCovering = 1;
123793 if( !db->init.imposterTable ) pPk->uniqNotNull = 1;
123794 nPk = pPk->nColumn = pPk->nKeyCol;
123800 if( v && pPk->tnum>0 ){
123801 assert( db->init.busy==0 );
123802 sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
123806 pPk->tnum = pTab->tnum;
123808 /* Update the in-memory representation of all UNIQUE indices by converting
123811 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
123815 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
123816 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
123822 pIdx->nColumn = pIdx->nKeyCol;
123825 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
123826 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
123827 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
123828 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
123829 pIdx->aiColumn[j] = pPk->aiColumn[i];
123830 pIdx->azColl[j] = pPk->azColl[i];
123831 if( pPk->aSortOrder[i] ){
123833 pIdx->bAscKeyBug = 1;
123838 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
123839 assert( pIdx->nColumn>=j );
123845 for(i=0; i<pTab->nCol; i++){
123846 if( !hasColumn(pPk->aiColumn, nPk, i)
123847 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
123850 for(i=0, j=nPk; i<pTab->nCol; i++){
123851 if( !hasColumn(pPk->aiColumn, j, i)
123852 && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
123854 assert( j<pPk->nColumn );
123855 pPk->aiColumn[j] = i;
123856 pPk->azColl[j] = sqlite3StrBINARY;
123860 assert( pPk->nColumn==j );
123861 assert( pTab->nNVCol<=j );
123876 nName = sqlite3Strlen30(pTab->zName);
123877 if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
123879 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
123881 if( pMod->pModule->iVersion<3 ) return 0;
123882 if( pMod->pModule->xShadowName==0 ) return 0;
123883 return pMod->pModule->xShadowName(zName+nName+1);
123895 int nName; /* Length of pTab->zName */
123900 pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
123902 if( NEVER(pMod->pModule==0) ) return;
123903 if( pMod->pModule->iVersion<3 ) return;
123904 if( pMod->pModule->xShadowName==0 ) return;
123905 assert( pTab->zName!=0 );
123906 nName = sqlite3Strlen30(pTab->zName);
123907 for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
123909 assert( pOther->zName!=0 );
123911 if( pOther->tabFlags & TF_Shadow ) continue;
123912 if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
123913 && pOther->zName[nName]=='_'
123914 && pMod->pModule->xShadowName(pOther->zName+nName+1)
123916 pOther->tabFlags |= TF_Shadow;
123968 #define markExprListImmutable(X) /* no-op */
123981 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
124000 sqlite3 *db = pParse->db; /* The database connection */
124007 p = pParse->pNewTable;
124010 if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
124011 p->tabFlags |= TF_Shadow;
124014 /* If the db->init.busy is 1 it means we are reading the SQL off the
124017 ** for the table from the db->init.newTnum field. (The page number
124021 ** table itself. So mark it read-only.
124023 if( db->init.busy ){
124024 if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
124028 p->tnum = db->init.newTnum;
124029 if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
124043 p->tabFlags |= TF_Strict;
124044 for(ii=0; ii<p->nCol; ii++){
124045 Column *pCol = &p->aCol[ii];
124046 if( pCol->eCType==COLTYPE_CUSTOM ){
124047 if( pCol->colFlags & COLFLAG_HASTYPE ){
124050 p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
124054 p->zName, pCol->zCnName);
124057 }else if( pCol->eCType==COLTYPE_ANY ){
124058 pCol->affinity = SQLITE_AFF_BLOB;
124060 if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0
124061 && p->iPKey!=ii
124062 && pCol->notNull == OE_None
124064 pCol->notNull = OE_Abort;
124065 p->tabFlags |= TF_HasNotNull;
124070 assert( (p->tabFlags & TF_HasPrimaryKey)==0
124071 || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
124072 assert( (p->tabFlags & TF_HasPrimaryKey)!=0
124073 || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
124077 if( (p->tabFlags & TF_Autoincrement) ){
124082 if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
124083 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
124086 p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid;
124089 iDb = sqlite3SchemaToIndex(db, p->pSchema);
124094 if( p->pCheck ){
124095 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
124096 if( pParse->nErr ){
124099 sqlite3ExprListDelete(db, p->pCheck);
124100 p->pCheck = 0;
124102 markExprListImmutable(p->pCheck);
124107 if( p->tabFlags & TF_HasGenerated ){
124109 testcase( p->tabFlags & TF_HasVirtual );
124110 testcase( p->tabFlags & TF_HasStored );
124111 for(ii=0; ii<p->nCol; ii++){
124112 u32 colFlags = p->aCol[ii].colFlags;
124114 Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
124124 sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
124132 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
124140 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
124150 if( !db->init.busy ){
124178 ** statement to populate the new table. The root-page number for the
124179 ** new table is in register pParse->regRoot.
124185 ** A shared-cache write-lock is not required to write to the new table,
124186 ** as a schema-lock must have already been obtained to create it. Since
124187 ** a schema-lock excludes all other database users, the write-lock would
124192 int regYield; /* Register holding co-routine entry-point */
124193 int addrTop; /* Top of the co-routine */
124201 pParse->rc = SQLITE_ERROR;
124202 pParse->nErr++;
124205 iCsr = pParse->nTab++;
124206 regYield = ++pParse->nMem;
124207 regRec = ++pParse->nMem;
124208 regRowid = ++pParse->nMem;
124210 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->regRoot, iDb);
124214 if( pParse->nErr ) return;
124217 assert( p->aCol==0 );
124218 p->nCol = p->nNVCol = pSelTab->nCol;
124219 p->aCol = pSelTab->aCol;
124220 pSelTab->nCol = 0;
124221 pSelTab->aCol = 0;
124225 if( pParse->nErr ) return;
124227 sqlite3VdbeJumpHere(v, addrTop - 1);
124243 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
124244 n = (int)(pEnd2->z - pParse->sNameToken.z);
124245 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
124247 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
124259 db->aDb[iDb].zDbSName,
124261 p->zName,
124262 p->zName,
124263 pParse->regRoot,
124265 pParse->regRowid
124274 if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){
124275 Db *pDb = &db->aDb[iDb];
124277 if( pDb->pSchema->pSeqTab==0 ){
124280 pDb->zDbSName
124288 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
124292 if( p->tabFlags & TF_HasGenerated ){
124295 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
124299 /* Add the table to the in-memory representation of the database.
124301 if( db->init.busy ){
124303 Schema *pSchema = p->pSchema;
124305 assert( HasRowid(p) || p->iPKey<0 );
124306 pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
124312 pParse->pNewTable = 0;
124313 db->mDbFlags |= DBFLAG_SchemaChange;
124318 assert( !pParse->nested );
124320 if( strcmp(p->zName, "sqlite_sequence")==0 ){
124322 p->pSchema->pSeqTab = p;
124330 if( pCons->z==0 ){
124333 p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
124359 sqlite3 *db = pParse->db;
124361 if( pParse->nVar>0 ){
124366 p = pParse->pNewTable;
124367 if( p==0 || pParse->nErr ) goto create_view_fail;
124372 ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
124376 p->tabFlags |= sqlite3Config.mNoVisibleRowid; /* Optional. Allow by default */
124378 p->tabFlags |= TF_NoVisibleRowid; /* Never allow rowid in view */
124382 iDb = sqlite3SchemaToIndex(db, p->pSchema);
124388 ** allocated rather than point to the input string - which means that
124391 pSelect->selFlags |= SF_View;
124393 p->u.view.pSelect = pSelect;
124396 p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
124398 p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
124399 p->eTabType = TABTYP_VIEW;
124400 if( db->mallocFailed ) goto create_view_fail;
124405 sEnd = pParse->sLastToken;
124411 n = (int)(sEnd.z - pBegin->z);
124413 z = pBegin->z;
124414 while( sqlite3Isspace(z[n-1]) ){ n--; }
124415 sEnd.z = &z[n-1];
124434 ** the columns of the view in the pTable structure. Return non-zero if
124436 ** in pParse->zErrMsg.
124442 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
124454 db->nSchemaLock++;
124456 db->nSchemaLock--;
124466 assert( pTable->nCol<=0 );
124483 if( pTable->nCol<0 ){
124484 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
124487 assert( pTable->nCol>=0 );
124497 pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
124499 u8 eParseMode = pParse->eParseMode;
124500 int nTab = pParse->nTab;
124501 int nSelect = pParse->nSelect;
124502 pParse->eParseMode = PARSE_MODE_NORMAL;
124503 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
124504 pTable->nCol = -1;
124507 xAuth = db->xAuth;
124508 db->xAuth = 0;
124510 db->xAuth = xAuth;
124514 pParse->nTab = nTab;
124515 pParse->nSelect = nSelect;
124517 pTable->nCol = 0;
124519 }else if( pTable->pCheck ){
124522 ** arglist which is stored in pTable->pCheck. The pCheck field
124526 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
124527 &pTable->nCol, &pTable->aCol);
124528 if( pParse->nErr==0
124529 && pTable->nCol==pSel->pEList->nExpr
124531 assert( db->mallocFailed==0 );
124538 assert( pTable->aCol==0 );
124539 pTable->nCol = pSelTab->nCol;
124540 pTable->aCol = pSelTab->aCol;
124541 pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT);
124542 pSelTab->nCol = 0;
124543 pSelTab->aCol = 0;
124544 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
124546 pTable->nNVCol = pTable->nCol;
124550 pParse->eParseMode = eParseMode;
124554 pTable->pSchema->schemaFlags |= DB_UnresetViews;
124555 if( db->mallocFailed ){
124559 return nErr + pParse->nErr;
124563 if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
124576 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
124591 ** root-page of a table or index in database iDb has changed from iFrom
124612 pDb = &db->aDb[iDb];
124613 pHash = &pDb->pSchema->tblHash;
124616 if( pTab->tnum==iFrom ){
124617 pTab->tnum = iTo;
124620 pHash = &pDb->pSchema->idxHash;
124623 if( pIdx->tnum==iFrom ){
124624 pIdx->tnum = iTo;
124631 ** Write code to erase the table with root-page iTable from database iDb.
124633 ** if a root-page of another table is moved by the btree-layer whilst
124634 ** erasing iTable (this can happen with an auto-vacuum database).
124644 ** is non-zero, then it is the root page number of a table moved to
124655 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
124663 ** in case a root-page belonging to another table is moved by the btree layer
124664 ** is also added (this can happen with an auto-vacuum database).
124667 /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
124669 ** table and index root-pages in order, starting with the numerically
124670 ** largest root-page number. This guarantees that none of the root-pages
124678 ** and root page 5 happened to be the largest root-page number in the
124681 ** a free-list page.
124683 Pgno iTab = pTab->tnum;
124693 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
124694 Pgno iIdx = pIdx->tnum;
124695 assert( pIdx->pSchema==pTab->pSchema );
124703 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
124704 assert( iDb>=0 && iDb<pParse->db->nDb );
124722 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
124726 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
124740 sqlite3 *db = pParse->db;
124742 Db *pDb = &db->aDb[iDb];
124760 assert( pTrigger->pSchema==pTab->pSchema ||
124761 pTrigger->pSchema==db->aDb[1].pSchema );
124763 pTrigger = pTrigger->pNext;
124770 ** move as a result of the drop (can happen in auto-vacuum mode).
124772 if( pTab->tabFlags & TF_Autoincrement ){
124775 pDb->zDbSName, pTab->zName
124790 pDb->zDbSName, pTab->zName);
124799 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124802 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124808 ** Return TRUE if shadow tables should be read-only in the current
124813 if( (db->flags & SQLITE_Defensive)!=0
124814 && db->pVtabCtx==0
124815 && db->nVdbeExec==0
124828 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
124829 if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0;
124830 if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0;
124833 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
124836 if( pTab->tabFlags & TF_Eponymous ){
124849 sqlite3 *db = pParse->db;
124852 if( db->mallocFailed ){
124855 assert( pParse->nErr==0 );
124856 assert( pName->nSrc==1 );
124858 if( noErr ) db->suppressErr++;
124860 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
124861 if( noErr ) db->suppressErr--;
124865 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
124870 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124871 assert( iDb>=0 && iDb<db->nDb );
124883 const char *zDb = db->aDb[iDb].zDbSName;
124897 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
124906 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
124909 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
124915 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
124924 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
124928 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
124940 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
124961 ** under construction in the pParse->pNewTable field.
124973 sqlite3 *db = pParse->db;
124977 Table *p = pParse->pNewTable;
124986 int iCol = p->nCol-1;
124988 if( pToCol && pToCol->nExpr!=1 ){
124991 p->aCol[iCol].zCnName, pTo);
124995 }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
125001 nCol = pFromCol->nExpr;
125003 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
125005 for(i=0; i<pToCol->nExpr; i++){
125006 nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1;
125013 pFKey->pFrom = p;
125015 pFKey->pNextFrom = p->u.tab.pFKey;
125016 z = (char*)&pFKey->aCol[nCol];
125017 pFKey->zTo = z;
125021 memcpy(z, pTo->z, pTo->n);
125022 z[pTo->n] = 0;
125024 z += pTo->n+1;
125025 pFKey->nCol = nCol;
125027 pFKey->aCol[0].iFrom = p->nCol-1;
125031 for(j=0; j<p->nCol; j++){
125032 if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){
125033 pFKey->aCol[i].iFrom = j;
125037 if( j>=p->nCol ){
125040 pFromCol->a[i].zEName);
125044 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
125050 int n = sqlite3Strlen30(pToCol->a[i].zEName);
125051 pFKey->aCol[i].zCol = z;
125053 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
125055 memcpy(z, pToCol->a[i].zEName, n);
125060 pFKey->isDeferred = 0;
125061 pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
125062 pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
125064 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
125065 pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
125066 pFKey->zTo, (void *)pFKey
125073 assert( pNextTo->pPrevTo==0 );
125074 pFKey->pNextTo = pNextTo;
125075 pNextTo->pPrevTo = pFKey;
125081 p->u.tab.pFKey = pFKey;
125102 if( (pTab = pParse->pNewTable)==0 ) return;
125104 if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
125105 assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
125106 pFKey->isDeferred = (u8)isDeferred;
125119 ** the root page number of the index is taken from pIndex->tnum.
125122 Table *pTab = pIndex->pTable; /* The table that is indexed */
125123 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
125124 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
125133 sqlite3 *db = pParse->db; /* The database connection */
125134 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
125137 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
125138 db->aDb[iDb].zDbSName ) ){
125143 /* Require a write-lock on the table to perform this operation */
125144 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
125151 tnum = pIndex->tnum;
125154 assert( pKey!=0 || pParse->nErr );
125157 iSorter = pParse->nTab++;
125158 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
125184 pIndex->nKeyCol); VdbeCoverage(v);
125199 if( !pIndex->bAscKeyBug ){
125224 ** of 8-byte aligned space after the Index object and return a
125244 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
125245 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
125246 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
125247 p->aSortOrder = (u8*)pExtra;
125248 p->nColumn = nCol;
125249 p->nKeyCol = nCol - 1;
125258 ** pParse and return non-zero. Otherwise, return zero.
125263 for(i=0; i<pList->nExpr; i++){
125264 if( pList->a[i].fg.bNulls ){
125265 u8 sf = pList->a[i].fg.sortFlags;
125280 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
125281 ** as the table to be indexed. pParse->pNewTable is a table that is
125285 ** is a primary key or unique-constraint on the most recent column added
125292 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
125308 sqlite3 *db = pParse->db;
125318 assert( db->pParse==pParse );
125319 if( pParse->nErr ){
125322 assert( db->mallocFailed==0 );
125338 /* Use the two-part index name to determine the database
125345 assert( pName && pName->z );
125352 if( !db->init.busy ){
125354 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
125366 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
125367 assert( db->mallocFailed==0 || pTab==0 );
125369 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
125371 "cannot create a TEMP index on non-TEMP table \"%s\"",
125372 pTab->zName);
125379 pTab = pParse->pNewTable;
125381 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
125383 pDb = &db->aDb[iDb];
125386 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
125387 && db->init.busy==0
125390 && sqlite3UserAuthTable(pTab->zName)==0
125393 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
125425 assert( pName->z!=0 );
125426 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
125430 if( !db->init.busy ){
125431 if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){
125436 if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
125440 assert( !db->init.busy );
125450 for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
125451 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
125468 const char *zDb = pDb->zDbSName;
125474 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
125486 Column *pCol = &pTab->aCol[pTab->nCol-1];
125487 pCol->colFlags |= COLFLAG_UNIQUE;
125488 sqlite3TokenInit(&prevCol, pCol->zCnName);
125492 assert( pList->nExpr==1 );
125496 if( pParse->nErr ) goto exit_create_index;
125502 for(i=0; i<pList->nExpr; i++){
125503 Expr *pExpr = pList->a[i].pExpr;
125505 if( pExpr->op==TK_COLLATE ){
125507 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
125515 nExtraCol = pPk ? pPk->nKeyCol : 1;
125516 assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
125517 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
125519 if( db->mallocFailed ){
125522 assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) );
125523 assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
125524 pIndex->zName = zExtra;
125526 memcpy(pIndex->zName, zName, nName+1);
125527 pIndex->pTable = pTab;
125528 pIndex->onError = (u8)onError;
125529 pIndex->uniqNotNull = onError!=OE_None;
125530 pIndex->idxType = idxType;
125531 pIndex->pSchema = db->aDb[iDb].pSchema;
125532 pIndex->nKeyCol = pList->nExpr;
125535 pIndex->pPartIdxWhere = pPIWhere;
125542 if( pDb->pSchema->file_format>=4 ){
125543 sortOrderMask = -1; /* Honor DESC */
125551 ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[].
125557 pListItem = pList->a;
125559 pIndex->aColExpr = pList;
125562 for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
125563 Expr *pCExpr; /* The i-th index expression */
125564 int requestedSortOrder; /* ASC or DESC on the i-th expression */
125567 sqlite3StringToId(pListItem->pExpr);
125568 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
125569 if( pParse->nErr ) goto exit_create_index;
125570 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
125571 if( pCExpr->op!=TK_COLUMN ){
125572 if( pTab==pParse->pNewTable ){
125577 if( pIndex->aColExpr==0 ){
125578 pIndex->aColExpr = pList;
125582 pIndex->aiColumn[i] = XN_EXPR;
125583 pIndex->uniqNotNull = 0;
125584 pIndex->bHasExpr = 1;
125586 j = pCExpr->iColumn;
125589 j = pTab->iPKey;
125591 if( pTab->aCol[j].notNull==0 ){
125592 pIndex->uniqNotNull = 0;
125594 if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){
125595 pIndex->bHasVCol = 1;
125596 pIndex->bHasExpr = 1;
125599 pIndex->aiColumn[i] = (i16)j;
125602 if( pListItem->pExpr->op==TK_COLLATE ){
125604 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
125605 zColl = pListItem->pExpr->u.zToken;
125611 nExtra -= nColl;
125613 zColl = sqlite3ColumnColl(&pTab->aCol[j]);
125616 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
125619 pIndex->azColl[i] = zColl;
125620 requestedSortOrder = pListItem->fg.sortFlags & sortOrderMask;
125621 pIndex->aSortOrder[i] = (u8)requestedSortOrder;
125629 for(j=0; j<pPk->nKeyCol; j++){
125630 int x = pPk->aiColumn[j];
125632 if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
125633 pIndex->nColumn--;
125635 testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
125636 pIndex->aiColumn[i] = x;
125637 pIndex->azColl[i] = pPk->azColl[j];
125638 pIndex->aSortOrder[i] = pPk->aSortOrder[j];
125642 assert( i==pIndex->nColumn );
125644 pIndex->aiColumn[i] = XN_ROWID;
125645 pIndex->azColl[i] = sqlite3StrBINARY;
125648 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
125653 || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
125655 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
125656 pIndex->isCovering = 1;
125657 for(j=0; j<pTab->nCol; j++){
125658 if( j==pTab->iPKey ) continue;
125660 pIndex->isCovering = 0;
125665 if( pTab==pParse->pNewTable ){
125688 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
125691 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
125694 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
125695 for(k=0; k<pIdx->nKeyCol; k++){
125698 assert( pIdx->aiColumn[k]>=0 );
125699 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
125700 z1 = pIdx->azColl[k];
125701 z2 = pIndex->azColl[k];
125704 if( k==pIdx->nKeyCol ){
125705 if( pIdx->onError!=pIndex->onError ){
125713 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
125717 if( pIdx->onError==OE_Default ){
125718 pIdx->onError = pIndex->onError;
125721 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
125723 pIndex->pNext = pParse->pNewIndex;
125724 pParse->pNewIndex = pIndex;
125735 ** in-memory database structures.
125737 assert( pParse->nErr==0 );
125738 if( db->init.busy ){
125741 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
125743 pIndex->tnum = db->init.newTnum;
125746 pParse->rc = SQLITE_CORRUPT_BKPT;
125750 p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
125751 pIndex->zName, pIndex);
125757 db->mDbFlags |= DBFLAG_SchemaChange;
125776 int iMem = ++pParse->nMem;
125789 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
125797 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
125798 if( pName->z[n-1]==';' ) n--;
125801 onError==OE_None ? "" : " UNIQUE", n, pName->z);
125812 db->aDb[iDb].zDbSName,
125813 pIndex->zName,
125814 pTab->zName,
125821 ** to invalidate all pre-compiled statements.
125827 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
125831 sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
125834 if( db->init.busy || pTblName==0 ){
125835 pIndex->pNext = pTab->pIndex;
125836 pTab->pIndex = pIndex;
125840 assert( pParse->pNewIndex==0 );
125841 pParse->pNewIndex = pIndex;
125855 for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
125857 if( pThis->onError!=OE_Replace ) continue;
125858 while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){
125860 pThis->pNext = pNext->pNext;
125861 pNext->pNext = pThis;
125862 ppFrom = &pNext->pNext;
125870 for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
125871 assert( pThis->onError!=OE_Replace
125872 || pThis->pNext==0
125873 || pThis->pNext->onError==OE_Replace );
125884 ** Fill the Index.aiRowEst[] array with default information - information
125894 ** aiRowEst[N]<=aiRowEst[N-1]
125904 LogEst *a = pIdx->aiRowLogEst;
125906 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
125910 assert( !pIdx->hasStat1 );
125916 ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1
125922 x = pIdx->pTable->nRowLogEst;
125925 pIdx->pTable->nRowLogEst = x = 99;
125927 if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); }
125933 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
125938 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
125948 sqlite3 *db = pParse->db;
125951 if( db->mallocFailed ){
125954 assert( pParse->nErr==0 ); /* Never called with prior non-OOM errors */
125955 assert( pName->nSrc==1 );
125959 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
125962 sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
125964 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
125967 pParse->checkSchema = 1;
125970 if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){
125975 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
125979 Table *pTab = pIndex->pTable;
125980 const char *zDb = db->aDb[iDb].zDbSName;
125986 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
125998 db->aDb[iDb].zDbSName, pIndex->zName
126000 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
126002 destroyRootPage(pParse, pIndex->tnum, iDb);
126003 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
126016 ** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes
126024 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
126036 if( (n & (n-1))==0 ){
126040 *pIdx = -1;
126058 sqlite3 *db = pParse->db;
126066 sizeof(IdList) + pList->nId*sizeof(pList->a));
126073 i = pList->nId++;
126074 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
126075 if( IN_RENAME_OBJECT && pList->a[i].zName ){
126076 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
126088 assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */
126089 for(i=0; i<pList->nId; i++){
126090 sqlite3DbFree(db, pList->a[i].zName);
126096 ** Return the index in pList of the identifier named zId. Return -1
126102 for(i=0; i<pList->nId; i++){
126103 if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
126105 return -1;
126114 ** appropriate for small and memory-limited applications.
126143 int nExtra, /* Number of new slots to add to pSrc->a[] */
126144 int iStart /* Index in pSrc->a[] of first new slot */
126152 assert( iStart<=pSrc->nSrc );
126155 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
126157 sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
126158 sqlite3 *db = pParse->db;
126160 if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
126167 sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
126169 assert( db->mallocFailed );
126173 pSrc->nAlloc = nAlloc;
126178 for(i=pSrc->nSrc-1; i>=iStart; i--){
126179 pSrc->a[i+nExtra] = pSrc->a[i];
126181 pSrc->nSrc += nExtra;
126184 memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
126186 pSrc->a[i].iCursor = -1;
126239 assert( pParse->db!=0 );
126240 db = pParse->db;
126242 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
126244 pList->nAlloc = 1;
126245 pList->nSrc = 1;
126246 memset(&pList->a[0], 0, sizeof(pList->a[0]));
126247 pList->a[0].iCursor = -1;
126249 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
126257 pItem = &pList->a[pList->nSrc-1];
126258 if( pDatabase && pDatabase->z==0 ){
126262 pItem->zName = sqlite3NameFromToken(db, pDatabase);
126263 pItem->zDatabase = sqlite3NameFromToken(db, pTable);
126265 pItem->zName = sqlite3NameFromToken(db, pTable);
126266 pItem->zDatabase = 0;
126277 assert( pList || pParse->db->mallocFailed );
126279 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
126280 if( pItem->iCursor>=0 ) continue;
126281 pItem->iCursor = pParse->nTab++;
126282 if( pItem->pSelect ){
126283 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
126297 for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
126298 if( pItem->zDatabase ) sqlite3DbNNFreeNN(db, pItem->zDatabase);
126299 if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
126300 if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias);
126301 if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
126302 if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
126303 sqlite3DeleteTable(db, pItem->pTab);
126304 if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect);
126305 if( pItem->fg.isUsing ){
126306 sqlite3IdListDelete(db, pItem->u3.pUsing);
126307 }else if( pItem->u3.pOn ){
126308 sqlite3ExprDelete(db, pItem->u3.pOn);
126320 ** pDatabase is NULL if the database name qualifier is missing - the
126335 Token *pAlias, /* The right-hand side of the AS subexpression */
126340 sqlite3 *db = pParse->db;
126341 if( !p && pOnUsing!=0 && (pOnUsing->pOn || pOnUsing->pUsing) ){
126343 (pOnUsing->pOn ? "ON" : "USING")
126351 assert( p->nSrc>0 );
126352 pItem = &p->a[p->nSrc-1];
126354 assert( pItem->zName==0 || pDatabase!=0 );
126355 if( IN_RENAME_OBJECT && pItem->zName ){
126356 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
126357 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
126360 if( pAlias->n ){
126361 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
126364 pItem->pSelect = pSubquery;
126365 if( pSubquery->selFlags & SF_NestedFrom ){
126366 pItem->fg.isNestedFrom = 1;
126369 assert( pOnUsing==0 || pOnUsing->pOn==0 || pOnUsing->pUsing==0 );
126370 assert( pItem->fg.isUsing==0 );
126372 pItem->u3.pOn = 0;
126373 }else if( pOnUsing->pUsing ){
126374 pItem->fg.isUsing = 1;
126375 pItem->u3.pUsing = pOnUsing->pUsing;
126377 pItem->u3.pOn = pOnUsing->pOn;
126390 ** element of the source-list passed as the second argument.
126394 if( p && pIndexedBy->n>0 ){
126396 assert( p->nSrc>0 );
126397 pItem = &p->a[p->nSrc-1];
126398 assert( pItem->fg.notIndexed==0 );
126399 assert( pItem->fg.isIndexedBy==0 );
126400 assert( pItem->fg.isTabFunc==0 );
126401 if( pIndexedBy->n==1 && !pIndexedBy->z ){
126404 pItem->fg.notIndexed = 1;
126406 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
126407 pItem->fg.isIndexedBy = 1;
126408 assert( pItem->fg.isCte==0 ); /* No collision on union u2 */
126419 assert( p1 && p1->nSrc==1 );
126421 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
126423 sqlite3SrcListDelete(pParse->db, p2);
126426 memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
126427 sqlite3DbFree(pParse->db, p2);
126428 p1->a[0].fg.jointype |= (JT_LTORJ & p1->a[1].fg.jointype);
126436 ** table-valued-function.
126440 SrcItem *pItem = &p->a[p->nSrc-1];
126441 assert( pItem->fg.notIndexed==0 );
126442 assert( pItem->fg.isIndexedBy==0 );
126443 assert( pItem->fg.isTabFunc==0 );
126444 pItem->u1.pFuncArg = pList;
126445 pItem->fg.isTabFunc = 1;
126447 sqlite3ExprListDelete(pParse->db, pList);
126463 ** in p->a[0] and p->a[1], respectively. The parser initially stores the
126468 ** * All tables to the left of the right-most RIGHT JOIN are tagged with
126475 if( p && p->nSrc>1 ){
126476 int i = p->nSrc-1;
126479 allFlags |= p->a[i].fg.jointype = p->a[i-1].fg.jointype;
126480 }while( (--i)>0 );
126481 p->a[0].fg.jointype = 0;
126486 for(i=p->nSrc-1; ALWAYS(i>0) && (p->a[i].fg.jointype&JT_RIGHT)==0; i--){}
126487 i--;
126490 p->a[i].fg.jointype |= JT_LTORJ;
126491 }while( (--i)>=0 );
126505 db = pParse->db;
126513 for(i=0; i<db->nDb; i++){
126515 Btree *pBt = db->aDb[i].pBt;
126540 assert( pParse->db!=0 );
126558 char *zName = sqlite3NameFromToken(pParse->db, pName);
126566 sqlite3DbFree(pParse->db, zName);
126578 sqlite3 *db = pParse->db;
126579 if( db->aDb[1].pBt==0 && !pParse->explain ){
126589 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
126593 pParse->rc = rc;
126596 db->aDb[1].pBt = pBt;
126597 assert( db->aDb[1].pSchema );
126598 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){
126609 ** will occur at the end of the top-level VDBE and will be generated
126613 assert( iDb>=0 && iDb<pToplevel->db->nDb );
126614 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
126616 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
126617 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
126618 DbMaskSet(pToplevel->cookieMask, iDb);
126634 sqlite3 *db = pParse->db;
126636 for(i=0; i<db->nDb; i++){
126637 Db *pDb = &db->aDb[i];
126638 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
126660 DbMaskSet(pToplevel->writeMask, iDb);
126661 pToplevel->isMultiWrite |= setStatement;
126673 pToplevel->isMultiWrite = 1;
126694 pToplevel->mayAbort = 1;
126711 assert( pParse->pVdbe!=0 );
126713 assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );
126732 Table *pTab = pIdx->pTable;
126734 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
126735 pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
126736 if( pIdx->aColExpr ){
126737 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
126739 for(j=0; j<pIdx->nKeyCol; j++){
126741 assert( pIdx->aiColumn[j]>=0 );
126742 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
126744 sqlite3_str_appendall(&errMsg, pTab->zName);
126758 ** Code an OP_Halt due to non-unique rowid.
126763 Table *pTab /* The table with the non-unique rowid */
126767 if( pTab->iPKey>=0 ){
126768 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
126769 pTab->aCol[pTab->iPKey].zCnName);
126772 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
126787 for(i=0; i<pIndex->nColumn; i++){
126788 const char *z = pIndex->azColl[i];
126789 assert( z!=0 || pIndex->aiColumn[i]<0 );
126790 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
126807 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
126809 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126811 sqlite3RefillIndex(pParse, pIndex, -1);
126827 sqlite3 *db = pParse->db; /* The database connection */
126832 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
126834 for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
126845 ** REINDEX -- 1
126846 ** REINDEX <collation> -- 2
126847 ** REINDEX ?<database>.?<tablename> -- 3
126848 ** REINDEX ?<database>.?<indexname> -- 4
126863 sqlite3 *db = pParse->db; /* The database connection */
126875 }else if( NEVER(pName2==0) || pName2->z==0 ){
126877 assert( pName1->z );
126878 zColl = sqlite3NameFromToken(pParse->db, pName1);
126892 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
126902 iDb = sqlite3SchemaToIndex(db, pIndex->pTable->pSchema);
126904 sqlite3RefillIndex(pParse, pIndex, -1);
126919 int nCol = pIdx->nColumn;
126920 int nKey = pIdx->nKeyCol;
126922 if( pParse->nErr ) return 0;
126923 if( pIdx->uniqNotNull ){
126924 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
126926 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
126931 const char *zColl = pIdx->azColl[i];
126932 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
126934 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
126935 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
126937 if( pParse->nErr ){
126938 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
126939 if( pIdx->bNoQuery==0 ){
126944 ** the missing index using the collation-needed callback. For
126947 pIdx->bNoQuery = 1;
126948 pParse->rc = SQLITE_ERROR_RETRY;
126963 Token *pName, /* Name of the common-table */
126969 sqlite3 *db = pParse->db;
126972 assert( pNew!=0 || db->mallocFailed );
126974 if( db->mallocFailed ){
126978 pNew->pSelect = pQuery;
126979 pNew->pCols = pArglist;
126980 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
126981 pNew->eM10d = eM10d;
126992 sqlite3ExprListDelete(db, pCte->pCols);
126993 sqlite3SelectDelete(db, pCte->pSelect);
126994 sqlite3DbFree(db, pCte->zName);
127017 sqlite3 *db = pParse->db;
127027 zName = pCte->zName;
127030 for(i=0; i<pWith->nCte; i++){
127031 if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
127038 sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
127043 assert( (pNew!=0 && zName!=0) || db->mallocFailed );
127045 if( db->mallocFailed ){
127049 pNew->a[pNew->nCte++] = *pCte;
127062 for(i=0; i<pWith->nCte; i++){
127063 cteClear(db, &pWith->a[i]);
127098 assert( !db->xCollNeeded || !db->xCollNeeded16 );
127099 if( db->xCollNeeded ){
127102 db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
127106 if( db->xCollNeeded16 ){
127109 sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
127112 db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
127123 ** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if
127128 char *z = pColl->zName;
127133 if( pColl2->xCmp!=0 ){
127135 pColl->xDel = 0; /* Do not copy the destructor */
127154 if( pColl && pColl->xCmp==0 ){
127155 const char *zName = pColl->zName;
127156 sqlite3 *db = pParse->db;
127175 ** preferred for UTF-8, the second UTF-16le, and the third UTF-16be.
127187 pColl = sqlite3HashFind(&db->aCollSeq, zName);
127201 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
127219 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
127244 if( pColl ) pColl += enc-1;
127246 pColl = db->pDfltColl;
127257 db->enc = enc;
127258 /* EVIDENCE-OF: R-08308-17224 The default collating function for all
127261 db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0);
127286 sqlite3 *db = pParse->db;
127292 if( !p || !p->xCmp ){
127299 if( p && !p->xCmp && synthCollSeq(db, p) ){
127302 assert( !p || p->xCmp );
127305 pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ;
127331 sqlite3 *db = pParse->db;
127333 u8 initbusy = db->init.busy;
127337 if( !initbusy && (!pColl || !pColl->xCmp) ){
127350 ** If nArg is -1 that means to only return a match (non-zero) if p->nArg
127351 ** is also -1. In other words, we are searching for a function that
127354 ** If nArg is -2 that means that we are searching for any function
127364 ** 4: UTF8/16 conversion required - argument count matches exactly
127365 ** 5: UTF16 byte order conversion required - argument count matches exactly
127368 ** If nArg==(-2) then any function with a non-null xSFunc is
127370 ** a non-match.
127375 int nArg, /* Desired number of arguments. (-1)==any */
127379 assert( p->nArg>=-1 );
127382 if( p->nArg!=nArg ){
127383 if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH;
127384 if( p->nArg>=0 ) return 0;
127389 if( p->nArg==nArg ){
127396 if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
127398 }else if( (enc & p->funcFlags & 2)!=0 ){
127414 for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){
127415 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
127416 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
127439 assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
127440 aDef[i].pNext = pOther->pNext;
127441 pOther->pNext = &aDef[i];
127454 ** indicating whether the function prefers UTF-16 over UTF-8. Return a
127462 ** If nArg is -2, then the first valid function found is returned. A
127463 ** function is valid if xSFunc is non-zero. The nArg==(-2)
127465 ** of arguments. If nArg is -2, then createFlag must be 0.
127473 const char *zName, /* Name of the function. zero-terminated */
127474 int nArg, /* Number of arguments. -1 means any number */
127484 assert( nArg>=(-2) );
127485 assert( nArg>=(-1) || createFlag==0 );
127488 /* First search for a match amongst the application-defined functions.
127490 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
127497 p = p->pNext;
127500 /* If no match is found, search the built-in functions.
127502 ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in
127503 ** functions even if a prior app-defined function was found. And give
127504 ** priority to built-in functions.
127509 ** new function. But the FuncDefs for built-in functions are read-only.
127510 ** So we must not search for built-ins when creating a new function.
127512 if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){
127522 p = p->pNext;
127534 pBest->zName = (const char*)&pBest[1];
127535 pBest->nArg = (u16)nArg;
127536 pBest->funcFlags = enc;
127538 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
127539 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
127545 pBest->pNext = pOther;
127549 if( pBest && (pBest->xSFunc || createFlag) ){
127571 temp1 = pSchema->tblHash;
127572 temp2 = pSchema->trigHash;
127573 sqlite3HashInit(&pSchema->trigHash);
127574 sqlite3HashClear(&pSchema->idxHash);
127579 sqlite3HashInit(&pSchema->tblHash);
127585 sqlite3HashClear(&pSchema->fkeyHash);
127586 pSchema->pSeqTab = 0;
127587 if( pSchema->schemaFlags & DB_SchemaLoaded ){
127588 pSchema->iGeneration++;
127590 pSchema->schemaFlags &= ~(DB_SchemaLoaded|DB_ResetWanted);
127606 }else if ( 0==p->file_format ){
127607 sqlite3HashInit(&p->tblHash);
127608 sqlite3HashInit(&p->idxHash);
127609 sqlite3HashInit(&p->trigHash);
127610 sqlite3HashInit(&p->fkeyHash);
127611 p->enc = SQLITE_UTF8;
127644 ** pSrc->a[0].pTab Pointer to the Table object
127645 ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one
127649 SrcItem *pItem = pSrc->a;
127651 assert( pItem && pSrc->nSrc>=1 );
127653 if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
127654 pItem->pTab = pTab;
127655 pItem->fg.notCte = 1;
127657 pTab->nTabRef++;
127658 if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
127665 /* Generate byte-code that will report the number of rows modified
127675 /* Return true if table pTab is read-only.
127677 ** A table is read-only if any of the following are true:
127692 ** is for a top-level SQL statement.
127695 if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){
127702 ** * Only allow DELETE, INSERT, or UPDATE of non-SQLITE_VTAB_INNOCUOUS
127705 if( pParse->pToplevel!=0
127706 && pTab->u.vtab.p->eVtabRisk >
127707 ((pParse->db->flags & SQLITE_TrustedSchema)!=0)
127710 pTab->zName);
127719 if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
127720 db = pParse->db;
127721 if( (pTab->tabFlags & TF_Readonly)!=0 ){
127722 return sqlite3WritableSchema(db)==0 && pParse->nested==0;
127724 assert( pTab->tabFlags & TF_Shadow );
127731 ** If pTab is not writable -> generate an error message and return 1.
127732 ** If pTab is writable but other errors have occurred -> return 1.
127733 ** If pTab is writable and no prior errors -> return 0;
127737 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
127742 && (pTrigger==0 || (pTrigger->bReturning && pTrigger->pNext==0))
127744 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
127769 sqlite3 *db = pParse->db;
127770 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
127774 assert( pFrom->nSrc==1 );
127775 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
127776 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
127777 assert( pFrom->a[0].fg.isUsing==0 );
127778 assert( pFrom->a[0].u3.pOn==0 );
127799 SrcList *pSrc, /* the FROM clause -- which tables to scan */
127805 sqlite3 *db = pParse->db;
127817 sqlite3ExprDelete(pParse->db, pWhere);
127818 sqlite3ExprListDelete(pParse->db, pOrderBy);
127838 pTab = pSrc->a[0].pTab;
127847 assert( pPk->nKeyCol>=1 );
127848 if( pPk->nKeyCol==1 ){
127850 assert( pPk->aiColumn[0]>=0 && pPk->aiColumn[0]<pTab->nCol );
127851 zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
127856 for(i=0; i<pPk->nKeyCol; i++){
127858 assert( pPk->aiColumn[i]>=0 && pPk->aiColumn[i]<pTab->nCol );
127859 p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName);
127864 pLhs->x.pList = sqlite3ExprListDup(db, pEList, 0);
127871 pSrc->a[0].pTab = 0;
127873 pSrc->a[0].pTab = pTab;
127874 if( pSrc->a[0].fg.isIndexedBy ){
127875 assert( pSrc->a[0].fg.isCte==0 );
127876 pSrc->a[0].u2.pIBIndex = 0;
127877 pSrc->a[0].fg.isIndexedBy = 0;
127878 sqlite3DbFree(db, pSrc->a[0].u1.zIndexedBy);
127879 }else if( pSrc->a[0].fg.isCte ){
127880 pSrc->a[0].u2.pCteUse->nUse++;
127947 db = pParse->db;
127948 assert( db->pParse==pParse );
127949 if( pParse->nErr ){
127952 assert( db->mallocFailed==0 );
127953 assert( pTabList->nSrc==1 );
127982 sqlite3TreeViewDelete(pParse->pWith, pTabList, pWhere,
128006 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128007 assert( iDb<db->nDb );
128008 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
128009 db->aDb[iDb].zDbSName);
128018 assert( pTabList->nSrc==1 );
128019 iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
128020 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
128021 pParse->nTab++;
128027 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
128036 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
128065 if( (db->flags & SQLITE_CountRows)!=0
128066 && !pParse->nested
128067 && !pParse->pTriggerTab
128068 && !pParse->bReturning
128070 memCnt = ++pParse->nMem;
128081 ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
128091 && db->xPreUpdateCallback==0
128095 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
128097 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
128098 pTab->zName, P4_STATIC);
128100 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
128101 assert( pIdx->pSchema==pTab->pSchema );
128103 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
128105 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
128118 iRowSet = ++pParse->nMem;
128125 nPk = pPk->nKeyCol;
128126 iPk = pParse->nMem+1;
128127 pParse->nMem += nPk;
128128 iEphCur = pParse->nTab++;
128137 ** ONEPASS_OFF: Two-pass approach - use a FIFO for rowids/PK values.
128138 ** ONEPASS_SINGLE: One-pass approach - at most one row deleted.
128139 ** ONEPASS_MULTI: One-pass approach - any number of rows may be deleted.
128160 assert( pPk->aiColumn[i]>=0 );
128162 pPk->aiColumn[i], iPk+i);
128166 iKey = ++pParse->nMem;
128167 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
128171 /* For ONEPASS, no need to store the rowid/primary-key. There is only
128182 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0;
128183 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0;
128189 iKey = ++pParse->nMem;
128192 sqlite3IndexAffinityStr(pParse->db, pPk), nPk);
128222 /* Set up a loop over the rowids/primary-keys that were found in the
128223 ** where-clause loop above.
128227 if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
128256 pParse->isMultiWrite = 0;
128264 int count = (pParse->nested==0); /* True to count changes */
128269 /* End of the loop over all rowids/primary-keys. */
128280 } /* End non-truncate path */
128286 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
128332 ** cursor number iIdxCur+i for the i-th index.
128368 u8 count, /* If non-zero, increment the row change counter */
128373 Vdbe *v = pParse->pVdbe; /* Vdbe */
128407 iOld = pParse->nMem+1;
128408 pParse->nMem += (1 + pTab->nCol);
128410 /* Populate the OLD.* pseudo-table register array. These values will be
128413 for(iCol=0; iCol<pTab->nCol; iCol++){
128441 iIdxNoSeek = -1;
128454 ** If variable 'count' is non-zero, then this OP_Delete instruction should
128455 ** invoke the update-hook. The pre-update-hook, on the other hand should
128457 ** the update-hook is not invoked for rows removed by REPLACE, but the
128458 ** pre-update-hook is.
128464 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
128508 ** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex
128509 ** index is the 0-th index.)
128523 int r1 = -1; /* Register holding an index key */
128530 v = pParse->pVdbe;
128532 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
128537 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
128541 pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);
128589 Vdbe *v = pParse->pVdbe;
128595 if( pIdx->pPartIdxWhere ){
128597 pParse->iSelfTab = iDataCur + 1;
128598 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
128600 pParse->iSelfTab = 0;
128601 pPrior = 0; /* Ticket a9efb42811fa41ee 2019-11-02;
128607 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
128609 if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
128612 && pPrior->aiColumn[j]==pIdx->aiColumn[j]
128613 && pPrior->aiColumn[j]!=XN_EXPR
128619 if( pIdx->aiColumn[j]>=0 ){
128637 ** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label
128643 sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel);
128660 ** This file contains the C-language implementations for many of the SQL
128677 assert( context->pVdbe!=0 );
128678 pOp = &context->pVdbe->aOp[context->iOp-1];
128679 assert( pOp->opcode==OP_CollSeq );
128680 assert( pOp->p4type==P4_COLLSEQ );
128681 return pOp->p4.pColl;
128689 assert( context->isError<=0 );
128690 context->isError = -1;
128691 context->skipFlag = 1;
128695 ** Implementation of the non-aggregate min() and max() functions
128708 mask = sqlite3_user_data(context)==0 ? 0 : -1;
128711 assert( mask==-1 || mask==0 );
128733 int i = sqlite3_value_type(argv[0]) - 1;
128741 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
128745 sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC);
128790 sqlite3_result_int(context, (int)(z-z0));
128817 i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
128839 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
128850 /* IMP: R-31676-45509 If X is the integer -9223372036854775808
128852 ** equivalent positive 64-bit two complement value. */
128853 sqlite3_result_error(context, "integer overflow", -1);
128856 iVal = -iVal;
128862 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
128869 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
128873 if( rVal<0 ) rVal = -rVal;
128940 nHaystack--;
128971 x.nArg = argc-1;
128974 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
128987 ** p1 is 1-indexed. So substr(x,1,1) returns the first character
128988 ** of x. If x is text, then we actually count UTF-8 characters.
129032 ** as substr(X,1,N) - it returns the first N characters of X. This
129033 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
129034 ** from 2009-02-02 for compatibility of applications that exploited the
129041 p2 = -p2;
129045 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
129055 p1--;
129057 p2--;
129060 p1 -= p2;
129070 p1--;
129072 for(z2=z; *z2 && p2; p2--){
129075 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
129079 p2 = len-p1;
129103 /* If Y==0 and X will fit in a 64-bit int,
129107 if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
129110 r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
129135 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
129136 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
129137 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
129199 #define noopFunc versionFunc /* Substitute function - never called */
129214 ** (or -9223372036854775808) since when you do abs() of that
129219 ** therefore be no less than -9223372036854775807.
129221 r = -(r & LARGEST_INT64);
129261 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
129270 ** IMP: R-32760-32347 The changes() SQL function is a wrapper
129295 /* IMP: R-11217-42568 This function is a wrapper around the
129301 ** A structure defining how to do GLOB-style comparisons.
129324 /* The correct SQL-92 behavior is for the LIKE operator to ignore
129339 ** Compare two UTF-8 strings for equality where the first string is
129359 ** range of characters can be specified using '-'. Example:
129360 ** "[a-z]" matches any single lower-case letter. To match a '-', make
129383 u32 matchOne = pInfo->matchOne; /* "?" or "_" */
129384 u32 matchAll = pInfo->matchAll; /* "*" or "%" */
129385 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */
129402 if( pInfo->matchSet==0 ){
129408 assert( matchOther<0x80 ); /* '[' is a single-byte character */
129410 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther);
129423 ** For a case-insensitive search, set variable cx to be the same as
129456 if( pInfo->matchSet==0 ){
129476 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
129507 ** non-zero if there is no match.
129520 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for
129521 ** a miss - like strcmp().
129545 ** the built-in LIKE operator. The first argument to the function is the
129583 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
129584 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
129585 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
129586 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
129590 /* The escape character string must consist of a single UTF-8 character.
129595 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
129597 "ESCAPE expression must be a single character", -1);
129601 if( escape==pInfo->matchAll || escape==pInfo->matchOne ){
129604 if( escape==pInfo->matchAll ) pInfo->matchAll = 0;
129605 if( escape==pInfo->matchOne ) pInfo->matchOne = 0;
129608 escape = pInfo->matchSet;
129648 /* IMP: R-48699-48617 This function is an SQL wrapper around the
129649 ** sqlite3_libversion() C-interface. */
129650 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
129664 /* IMP: R-24470-31136 This function is an SQL wrapper around the
129666 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
129672 ** its side-effects.
129698 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
129722 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
129726 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
129730 /* Array for converting from half-bytes (nybbles) into ASCII hex
129745 assert( pStr!=0 && pStr->nChar==0 );
129755 sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8);
129772 if( pStr->accError==0 ){
129773 char *zText = pStr->zText;
129783 pStr->nChar = nBlob*2 + 3;
129805 ** Strings are surrounded by single-quotes with escapes on interior quotes
129815 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
129826 ** The unicode() function. Return the integer unicode code-point value
129879 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
129907 sqlite3_result_text64(context, zHex, (u64)(z-zHex),
129913 ** Buffer zStr contains nStr bytes of utf-8 encoded text. Return 1 if zStr
129993 sqlite3_result_blob(pCtx, pBlob, (p - pBlob), sqlite3_free);
130003 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
130016 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
130055 || sqlite3_context_db_handle(context)->mallocFailed );
130075 loopLimit = nStr - nPattern;
130082 nOut += nRep - nPattern;
130083 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
130084 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
130085 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
130091 if( (cntExpand&(cntExpand-1))==0 ){
130096 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
130106 i += nPattern-1;
130109 assert( j+nStr-i+1<=nOut );
130110 memcpy(&zOut[j], &zStr[i], nStr-i);
130111 j += nStr - i;
130166 aLen[nChar] = (unsigned)(z - azChar[nChar]);
130181 nIn -= len;
130189 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
130192 nIn -= len;
130205 ** Return a string value that is the concatenation of all non-null
130221 n += (argc-1)*nSep;
130249 ** concatentation of all non-null arguments.
130263 ** argument. Use the first argument (which must be non-NULL) as the
130274 concatFuncCore(context, argc-1, argv+1, nSep, zSep);
130282 ** when the SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION compile-time option is used.
130283 ** When the "sqlite3" command-line shell is built using this functionality,
130285 ** involving application-defined functions to be examined in a generic
130293 /* no-op */
130301 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
130302 ** is only available if the SQLITE_SOUNDEX compile-time option is used
130309 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
130354 /* IMP: R-64894-50321 The string "?000" is returned if the argument
130363 ** A function that loads a shared-library extension then returns NULL.
130374 if( (db->flags & SQLITE_LoadExtFunc)==0 ){
130375 sqlite3_result_error(context, "not authorized", -1);
130385 sqlite3_result_error(context, zErrMsg, -1);
130399 double rErr; /* Error term for Kahan-Babushka-Neumaier summation */
130402 u8 approx; /* True if any non-integer value was input to the sum */
130407 ** Do one step of the Kahan-Babushka-Neumaier summation.
130418 volatile double s = pSum->rSum;
130421 pSum->rErr += (s - t) + r;
130423 pSum->rErr += (r - t) + s;
130425 pSum->rSum = t;
130432 if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
130435 iBig = iVal - iSm;
130444 ** Initialize the Kahan-Babaska-Neumaier sum from a 64-bit integer
130450 if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
130452 p->rSum = (double)(iVal - iSm);
130453 p->rErr = (double)iSm;
130455 p->rSum = (double)iVal;
130456 p->rErr = 0.0;
130478 p->cnt++;
130479 if( p->approx==0 ){
130481 kahanBabuskaNeumaierInit(p, p->iSum);
130482 p->approx = 1;
130485 i64 x = p->iSum;
130487 p->iSum = x;
130489 p->ovrfl = 1;
130490 kahanBabuskaNeumaierInit(p, p->iSum);
130491 p->approx = 1;
130499 p->ovrfl = 0;
130513 /* p is always non-NULL because sumStep() will have been called first
130516 assert( p->cnt>0 );
130517 p->cnt--;
130518 if( !p->approx ){
130519 p->iSum -= sqlite3_value_int64(argv[0]);
130523 kahanBabuskaNeumaierStepInt64(p, -iVal);
130529 kahanBabuskaNeumaierStep(p, -sqlite3_value_double(argv[0]));
130539 if( p && p->cnt>0 ){
130540 if( p->approx ){
130541 if( p->ovrfl ){
130542 sqlite3_result_error(context,"integer overflow",-1);
130543 }else if( !sqlite3IsOverflow(p->rErr) ){
130544 sqlite3_result_double(context, p->rSum+p->rErr);
130546 sqlite3_result_double(context, p->rSum);
130549 sqlite3_result_int64(context, p->iSum);
130556 if( p && p->cnt>0 ){
130558 if( p->approx ){
130559 r = p->rSum;
130560 if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
130562 r = (double)(p->iSum);
130564 sqlite3_result_double(context, r/(double)p->cnt);
130572 if( p->approx ){
130573 r = p->rSum;
130574 if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
130576 r = (double)(p->iSum);
130601 p->n++;
130608 ** expressed as a 32-bit integer. */
130609 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
130610 || p->n==sqlite3_aggregate_count(context) );
130616 sqlite3_result_int64(context, p ? p->n : 0);
130622 /* p is always non-NULL since countStep() will have been called first */
130624 p->n--;
130626 p->bInverse = 1;
130650 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
130651 }else if( pBest->flags ){
130658 ** sqlite3_user_data() function returns (void *)-1. For min() it
130671 pBest->db = sqlite3_context_db_handle(context);
130679 if( pRes->flags ){
130711 /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
130713 ** (Hence, its slots in use number nAccum-1 between method calls.)
130734 int firstTerm = pGCC->str.mxAlloc==0;
130735 pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
130738 sqlite3_str_appendchar(&pGCC->str, 1, ',');
130742 pGCC->nFirstSepLength = 1;
130749 sqlite3_str_append(&pGCC->str, zSep, nSep);
130755 if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){
130756 int *pnsl = pGCC->pnSepLengths;
130759 pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int));
130761 int i = 0, nA = pGCC->nAccum-1;
130762 while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
130765 pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int));
130768 if( ALWAYS(pGCC->nAccum>0) ){
130769 pnsl[pGCC->nAccum-1] = nSep;
130771 pGCC->pnSepLengths = pnsl;
130773 sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM);
130780 pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]);
130782 pGCC->nAccum += 1;
130786 if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal);
130801 /* pGCC is always non-NULL since groupConcatStep() will have always
130809 pGCC->nAccum -= 1;
130810 if( pGCC->pnSepLengths!=0 ){
130811 assert(pGCC->nAccum >= 0);
130812 if( pGCC->nAccum>0 ){
130813 nVS += *pGCC->pnSepLengths;
130814 memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
130815 (pGCC->nAccum-1)*sizeof(int));
130818 /* If removing single accumulated string, harmlessly over-do. */
130819 nVS += pGCC->nFirstSepLength;
130821 if( nVS>=(int)pGCC->str.nChar ){
130822 pGCC->str.nChar = 0;
130824 pGCC->str.nChar -= nVS;
130825 memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
130827 if( pGCC->str.nChar==0 ){
130828 pGCC->str.mxAlloc = 0;
130829 sqlite3_free(pGCC->pnSepLengths);
130830 pGCC->pnSepLengths = 0;
130841 sqlite3ResultStrAccum(context, &pGCC->str);
130843 sqlite3_free(pGCC->pnSepLengths);
130852 StrAccum *pAccum = &pGCC->str;
130853 if( pAccum->accError==SQLITE_TOOBIG ){
130855 }else if( pAccum->accError==SQLITE_NOMEM ){
130857 }else if( pGCC->nAccum>0 && pAccum->nChar==0 ){
130861 sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
130870 ** This routine does per-connection function registration. Most
130871 ** of the built-in functions above are part of the global function set.
130883 ** Re-register the built-in LIKE functions. The caseSensitive
130903 pDef->funcFlags |= flags;
130904 pDef->funcFlags &= ~SQLITE_FUNC_UNSAFE;
130913 ** LIKE-style function then return FALSE.
130929 assert( pExpr->op==TK_FUNCTION );
130931 if( !pExpr->x.pList ){
130934 nExpr = pExpr->x.pList->nExpr;
130936 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
130940 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
130948 memcpy(aWc, pDef->pUserData, 3);
130956 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
130958 if( pEscape->op!=TK_STRING ) return 0;
130960 zEscape = pEscape->u.zToken;
130967 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
130983 /* Extra math functions that require linking with -lm
131041 ** ln(X) - natural logarithm
131042 ** log(X) - log X base 10
131043 ** log10(X) - log X base 10
131044 ** log(B,X) - log X base B
131098 ** Implementation of 1-argument SQL math functions:
131100 ** exp(X) - Compute e to the X-th power
131120 ** Implementation of 2-argument SQL math functions:
131122 ** power(X,Y) - Compute X to the Y-th power
131145 ** Implementation of 0-argument pi() function.
131174 sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
131192 char zBuf[100];
131204 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
131210 ** to the global function hash table. This occurs at start-time (as
131221 ** FuncDef.pHash elements at start-time. The elements of this array
131222 ** are read-only after initialization is complete.
131261 FUNCTION(min, -1, 0, 1, minmaxFunc ),
131265 FUNCTION(max, -1, 1, 1, minmaxFunc ),
131274 FUNCTION(printf, -1, 0, 0, printfFunc ),
131275 FUNCTION(format, -1, 0, 0, printfFunc ),
131277 FUNCTION(char, -1, 0, 0, charFunc ),
131291 FUNCTION(concat, -1, 0, 0, concatFunc ),
131293 FUNCTION(concat_ws, -1, 0, 0, concatwsFunc ),
131337 FUNCTION(unknown, -1, 0, 0, unknownFunc ),
131378 INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ),
131389 #if 0 /* Enable to print out how the built-in functions are hashed */
131394 printf("FUNC-HASH %02d:", i);
131395 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
131396 int n = sqlite3Strlen30(p->zName);
131397 int h = p->zName[0] + n;
131398 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
131399 printf(" %s(%d)", p->zName, h);
131429 ** --------------------------
131511 ** ---------------
131513 ** Before coding an UPDATE or DELETE row operation, the code-generator
131518 ** accessed). No information is required by the code-generator before
131522 ** sqlite3FkRequired() - Test to see if FK processing is required.
131523 ** sqlite3FkOldmask() - Query for the set of required old.* columns.
131527 ** --------------------------------------
131529 ** sqlite3FkCheck() - Check for foreign key violations.
131530 ** sqlite3FkActions() - Code triggers for ON UPDATE/ON DELETE actions.
131531 ** sqlite3FkDelete() - Delete an FKey structure.
131536 ** -----------------------
131566 ** constraint to the parent table column stored in the left-most column
131568 ** child table column that corresponds to the second left-most column of
131587 ** then non-zero is returned, and a "foreign key mismatch" error loaded
131588 ** into pParse. If an OOM error occurs, non-zero is returned and the
131589 ** pParse->db->mallocFailed flag is set.
131600 int nCol = pFKey->nCol; /* Number of columns in parent key */
131601 char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */
131608 /* If this is a non-composite (single column) foreign key, check if it
131614 ** Non-composite foreign keys do not require the aiCol array.
131624 if( pParent->iPKey>=0 ){
131626 if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zCnName, zKey) ){
131632 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
131637 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
131638 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
131650 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
131655 /* If zKey is non-NULL, then this foreign key was declared to
131661 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
131670 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
131672 if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
131674 zIdxCol = pParent->aCol[iCol].zCnName;
131676 if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){
131677 if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;
131689 if( !pParse->disableTriggers ){
131691 "foreign key mismatch - \"%w\" referencing \"%w\"",
131692 pFKey->pFrom->zName, pFKey->zTo);
131694 sqlite3DbFree(pParse->db, aiCol);
131706 ** affected - once to "delete" the old row, and then again to "insert" the
131716 ** --------------------------------------------------------------------------
131741 int iCur = pParse->nTab - 1; /* Cursor number to use */
131745 (!pFKey->isDeferred
131746 && !(pParse->db->flags & SQLITE_DeferFKs)
131747 && !pParse->pToplevel
131748 && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);
131758 sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
131761 for(i=0; i<pFKey->nCol; i++){
131762 int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1;
131779 sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp);
131784 ** to increment the constraint-counter (i.e. this is an INSERT operation),
131786 ** increment the constraint-counter. */
131787 if( pTab==pFKey->pFrom && nIncr==1 ){
131795 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
131799 int nCol = pFKey->nCol;
131802 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
131806 sqlite3TableColumnToStorage(pFKey->pFrom, aiCol[i])+1+regData,
131811 ** to increment the constraint-counter (i.e. this is an INSERT operation),
131813 ** increment the constraint-counter.
131815 ** If any of the parent-key values are NULL, then the row cannot match
131817 ** of the parent-key values are NULL (at this point it is known that
131820 if( pTab==pFKey->pFrom && nIncr==1 ){
131823 int iChild = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i])
131826 iParent += sqlite3TableColumnToStorage(pIdx->pTable,
131827 pIdx->aiColumn[i]);
131828 assert( pIdx->aiColumn[i]>=0 );
131829 assert( aiCol[i]!=pTab->iPKey );
131830 if( pIdx->aiColumn[i]==pTab->iPKey ){
131841 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
131848 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
131849 && !pParse->pToplevel
131850 && !pParse->isMultiWrite
131860 if( nIncr>0 && pFKey->isDeferred==0 ){
131863 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
131888 sqlite3 *db = pParse->db;
131892 if( iCol>=0 && iCol!=pTab->iPKey ){
131893 pCol = &pTab->aCol[iCol];
131894 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131895 pExpr->affExpr = pCol->affinity;
131897 if( zColl==0 ) zColl = db->pDfltColl->zName;
131900 pExpr->iTable = regBase;
131901 pExpr->affExpr = SQLITE_AFF_INTEGER;
131920 pExpr->y.pTab = pTab;
131921 pExpr->iTable = iCursor;
131922 pExpr->iColumn = iCol;
131931 ** code for an SQL UPDATE operation, this function may be called twice -
131934 ** Parameter nIncr is passed -1 when inserting a row (as this may decrease
131943 ** --------------------------------------------------------------------------
131965 sqlite3 *db = pParse->db; /* Database handle */
131973 assert( pIdx==0 || pIdx->pTable==pTab );
131974 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
131975 assert( pIdx!=0 || pFKey->nCol==1 );
131979 iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
131985 ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
131991 for(i=0; i<pFKey->nCol; i++){
131998 iCol = pIdx ? pIdx->aiColumn[i] : -1;
132000 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
132002 zCol = pFKey->pFrom->aCol[iCol].zCnName;
132022 if( pTab==pFKey->pFrom && nIncr>0 ){
132027 pLeft = exprTableRegister(pParse, pTab, regData, -1);
132028 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
132033 for(i=0; i<pIdx->nKeyCol; i++){
132034 i16 iCol = pIdx->aiColumn[i];
132037 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
132055 if( pParse->nErr==0 ){
132057 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
132085 return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName);
132091 ** and all of its sub-components.
132093 ** The Trigger structure or any of its sub-components may be allocated from
132098 TriggerStep *pStep = p->step_list;
132099 sqlite3ExprDelete(dbMem, pStep->pWhere);
132100 sqlite3ExprListDelete(dbMem, pStep->pExprList);
132101 sqlite3SelectDelete(dbMem, pStep->pSelect);
132102 sqlite3ExprDelete(dbMem, p->pWhen);
132114 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;
132119 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
132120 fkTriggerDelete(db, pFKey->apTrigger[0]); pFKey->apTrigger[0] = 0;
132121 fkTriggerDelete(db, pFKey->apTrigger[1]); pFKey->apTrigger[1] = 0;
132144 sqlite3 *db = pParse->db;
132145 if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){
132158 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132159 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
132166 pParse->disableTriggers = 1;
132168 pParse->disableTriggers = 0;
132179 if( (db->flags & SQLITE_DeferFKs)==0 ){
132200 ** is set to -1). If the rowid column is modified by the UPDATE statement
132201 ** the bChngRowid argument is non-zero.
132213 for(i=0; i<p->nCol; i++){
132214 int iChildKey = p->aCol[i].iFrom;
132216 if( iChildKey==pTab->iPKey && bChngRowid ) return 1;
132227 ** is set to -1). If the rowid column is modified by the UPDATE statement
132228 ** the bChngRowid argument is non-zero.
132240 for(i=0; i<p->nCol; i++){
132241 char *zKey = p->aCol[i].zCol;
132243 for(iKey=0; iKey<pTab->nCol; iKey++){
132244 if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
132245 Column *pCol = &pTab->aCol[iKey];
132247 if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1;
132248 }else if( pCol->colFlags & COLFLAG_PRIMKEY ){
132264 if( pTop->pTriggerPrg ){
132265 Trigger *p = pTop->pTriggerPrg->pTrigger;
132266 if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull)
132267 || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull)
132269 assert( (pTop->db->flags & SQLITE_FkNoAction)==0 );
132282 ** first register in an array of (pTab->nCol+1) registers containing the
132288 ** first register of an array of (pTab->nCol+1) registers containing the new
132304 sqlite3 *db = pParse->db; /* Database handle */
132308 int isIgnoreErrors = pParse->disableTriggers;
132310 /* Exactly one of regOld and regNew should be non-zero. */
132313 /* If foreign-keys are disabled, this function is a no-op. */
132314 if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
132317 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132318 zDb = db->aDb[iDb].zDbSName;
132322 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
132332 && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0
132342 if( pParse->disableTriggers ){
132343 pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
132345 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
132349 if( !isIgnoreErrors || db->mallocFailed ) return;
132356 ** FK counter for each row of the current table with non-NULL keys.
132359 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
132360 for(i=0; i<pFKey->nCol; i++){
132362 iFromCol = pFKey->aCol[i].iFrom;
132363 iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1;
132366 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
132370 assert( pFKey->nCol==1 || (aiFree && pIdx) );
132375 iCol = pFKey->aCol[0].iFrom;
132378 for(i=0; i<pFKey->nCol; i++){
132379 if( aiCol[i]==pTab->iPKey ){
132380 aiCol[i] = -1;
132382 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
132387 if( db->xAuth ){
132389 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName;
132390 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
132396 /* Take a shared-cache advisory read-lock on the parent table. Allocate
132399 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
132400 pParse->nTab++;
132406 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
132425 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
132434 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs)
132435 && !pParse->pToplevel && !pParse->isMultiWrite
132444 if( !isIgnoreErrors || db->mallocFailed ) return;
132447 assert( aiCol || pFKey->nCol==1 );
132453 SrcItem *pItem = pSrc->a;
132454 pItem->pTab = pFKey->pFrom;
132455 pItem->zName = pFKey->pFrom->zName;
132456 pItem->pTab->nTabRef++;
132457 pItem->iCursor = pParse->nTab++;
132460 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
132463 int eAction = pFKey->aAction[aChange!=0];
132464 if( (db->flags & SQLITE_FkNoAction) ) eAction = OE_None;
132470 ** So do not set the "may-abort" flag in this case.
132473 ** may-abort flag will eventually be set on this statement anyway
132484 if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){
132488 pItem->zName = 0;
132506 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132509 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132510 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
132512 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
132516 for(i=0; i<pIdx->nKeyCol; i++){
132517 assert( pIdx->aiColumn[i]>=0 );
132518 mask |= COLUMN_MASK(pIdx->aiColumn[i]);
132533 ** entry in the aChange[] array is set to -1. If the column is modified,
132538 ** non-zero. If there is no foreign key related processing, this function
132554 int *aChange, /* Non-NULL for UPDATE operations */
132559 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132564 bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey);
132571 for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
132573 if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
132579 for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
132581 if( (pParse->db->flags & SQLITE_FkNoAction)==0
132582 && p->aAction[1]!=OE_None
132596 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
132604 ** require no special handling by the triggers sub-system, code for them is
132627 ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */
132629 sqlite3 *db = pParse->db; /* Database handle */
132634 action = pFKey->aAction[iAction];
132635 if( (db->flags & SQLITE_FkNoAction) ) action = OE_None;
132636 if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){
132639 pTrigger = pFKey->apTrigger[iAction];
132645 int *aiCol = 0; /* child table cols -> parent key cols */
132654 assert( aiCol || pFKey->nCol==1 );
132656 for(i=0; i<pFKey->nCol; i++){
132664 iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
132666 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
132667 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
132669 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName);
132670 sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName);
132708 Column *pCol = pFKey->pFrom->aCol + iFromCol;
132710 if( pCol->colFlags & COLFLAG_GENERATED ){
132711 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
132712 testcase( pCol->colFlags & COLFLAG_STORED );
132715 pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol);
132731 zFrom = pFKey->pFrom->zName;
132735 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132741 pRaise->affExpr = OE_Abort;
132745 assert( pSrc->nSrc==1 );
132746 pSrc->a[0].zName = sqlite3DbStrDup(db, zFrom);
132747 pSrc->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
132764 nFrom + 1 /* Space for pStep->zTarget */
132767 pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
132768 pStep->zTarget = (char *)&pStep[1];
132769 memcpy((char *)pStep->zTarget, zFrom, nFrom);
132771 pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
132772 pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
132773 pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
132776 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
132780 /* Re-enable the lookaside buffer, if it was disabled earlier. */
132787 if( db->mallocFailed==1 ){
132796 pStep->op = TK_SELECT;
132800 pStep->op = TK_DELETE;
132805 pStep->op = TK_UPDATE;
132807 pStep->pTrig = pTrigger;
132808 pTrigger->pSchema = pTab->pSchema;
132809 pTrigger->pTabSchema = pTab->pSchema;
132810 pFKey->apTrigger[iAction] = pTrigger;
132811 pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
132824 ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */
132829 /* If foreign-key support is enabled, iterate through all FKs that
132832 ** trigger sub-program. */
132833 if( pParse->db->flags&SQLITE_ForeignKeys ){
132835 for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
132855 FKey *pNext; /* Copy of pFKey->pNextFrom */
132859 for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){
132860 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
132863 if( db->pnBytesFreed==0 ){
132864 if( pFKey->pPrevTo ){
132865 pFKey->pPrevTo->pNextTo = pFKey->pNextTo;
132867 const char *z = (pFKey->pNextTo ? pFKey->pNextTo->zTo : pFKey->zTo);
132868 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, pFKey->pNextTo);
132870 if( pFKey->pNextTo ){
132871 pFKey->pNextTo->pPrevTo = pFKey->pPrevTo;
132875 /* EV: R-30323-21917 Each foreign key constraint in SQLite is
132878 assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
132882 fkTriggerDelete(db, pFKey->apTrigger[0]);
132883 fkTriggerDelete(db, pFKey->apTrigger[1]);
132886 pNext = pFKey->pNextFrom;
132928 assert( pParse->pVdbe!=0 );
132929 v = pParse->pVdbe;
132931 if( !pParse->db->noSharedCache ){
132932 sqlite3TableLock(pParse, iDb, pTab->tnum,
132933 (opcode==OP_OpenWrite)?1:0, pTab->zName);
132936 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
132937 VdbeComment((v, "%s", pTab->zName));
132941 assert( pPk->tnum==pTab->tnum || CORRUPT_DB );
132942 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
132944 VdbeComment((v, "%s", pTab->zName));
132954 ** ------------------------------
132978 Table *pTab = pIdx->pTable;
132979 pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
132980 if( !pIdx->zColAff ){
132984 for(n=0; n<pIdx->nColumn; n++){
132985 i16 x = pIdx->aiColumn[n];
132988 aff = pTab->aCol[x].affinity;
132993 assert( pIdx->bHasExpr );
132994 assert( pIdx->aColExpr!=0 );
132995 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
132999 pIdx->zColAff[n] = aff;
133001 pIdx->zColAff[n] = 0;
133002 return pIdx->zColAff;
133005 if( !pIdx->zColAff ) return computeIndexAffStr(db, pIdx);
133006 return pIdx->zColAff;
133017 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
133020 for(i=j=0; i<pTab->nCol; i++){
133021 if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
133022 zColAff[j++] = pTab->aCol[i].affinity;
133026 zColAff[j--] = 0;
133036 ** For ordinary (legacy, non-strict) tables:
133037 ** -----------------------------------------
133043 ** which were then optimized out) then this routine becomes a no-op.
133053 ** --------- ---------------
133061 ** ------------------
133075 if( pTab->tabFlags & TF_Strict ){
133084 assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
133085 pPrev->opcode = OP_TypeCheck;
133086 sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);
133089 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
133094 zColAff = pTab->zColAff;
133101 pTab->zColAff = zColAff;
133109 assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord
133110 || sqlite3VdbeDb(v)->mallocFailed );
133111 sqlite3VdbeChangeP4(v, -1, zColAff, i);
133117 ** Return non-zero if the table pTab in database iDb or any of its indices
133127 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
133133 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
133135 Pgno tnum = pOp->p2;
133136 if( tnum==pTab->tnum ){
133139 for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
133140 if( tnum==pIndex->tnum ){
133146 if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
133147 assert( pOp->p4.pVtab!=0 );
133148 assert( pOp->p4type==P4_VTAB );
133160 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
133161 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
133162 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
133186 assert( pTab->tabFlags & TF_HasGenerated );
133187 testcase( pTab->tabFlags & TF_HasVirtual );
133188 testcase( pTab->tabFlags & TF_HasStored );
133193 sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
133194 if( (pTab->tabFlags & TF_HasStored)!=0 ){
133195 pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
133196 if( pOp->opcode==OP_Affinity ){
133198 ** columns. '@' is the no-op affinity and those columns have not
133201 char *zP4 = pOp->p4.z;
133203 assert( pOp->p4type==P4_DYNAMIC );
133205 if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
133208 if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
133213 }else if( pOp->opcode==OP_TypeCheck ){
133217 pOp->p3 = 1;
133222 ** this is a two-pass algorithm. On the first pass, mark all generated
133225 for(i=0; i<pTab->nCol; i++){
133226 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
133227 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
133228 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
133229 pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL;
133238 /* On the second pass, compute the value of each NOT-AVAILABLE column.
133243 pParse->iSelfTab = -iRegStore;
133247 for(i=0; i<pTab->nCol; i++){
133248 Column *pCol = pTab->aCol + i;
133249 if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){
133251 pCol->colFlags |= COLFLAG_BUSY;
133254 pCol->colFlags &= ~COLFLAG_BUSY;
133260 assert( pCol->colFlags & COLFLAG_GENERATED );
133263 pCol->colFlags &= ~COLFLAG_NOTAVAIL;
133268 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName);
133270 pParse->iSelfTab = 0;
133305 assert( pParse->db->aDb[iDb].pSchema!=0 );
133306 if( (pTab->tabFlags & TF_Autoincrement)!=0
133307 && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
133311 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
133315 ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
133319 || pSeqTab->nCol!=2
133321 pParse->nErr++;
133322 pParse->rc = SQLITE_CORRUPT_SEQUENCE;
133326 pInfo = pToplevel->pAinc;
133327 while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
133329 pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
133331 testcase( pParse->earlyCleanup );
133332 if( pParse->db->mallocFailed ) return 0;
133333 pInfo->pNext = pToplevel->pAinc;
133334 pToplevel->pAinc = pInfo;
133335 pInfo->pTab = pTab;
133336 pInfo->iDb = iDb;
133337 pToplevel->nMem++; /* Register to hold name of table */
133338 pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */
133339 pToplevel->nMem +=2; /* Rowid in sqlite_sequence + orig max val */
133341 memId = pInfo->regCtr;
133352 sqlite3 *db = pParse->db; /* The database connection */
133355 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
133357 /* This routine is never called during trigger-generation. It is
133358 ** only called from the top-level */
133359 assert( pParse->pTriggerTab==0 );
133363 for(p = pParse->pAinc; p; p = p->pNext){
133380 pDb = &db->aDb[p->iDb];
133381 memId = p->regCtr;
133382 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
133383 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
133384 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
133390 aOp[3].p1 = memId-1;
133399 if( pParse->nTab==0 ) pParse->nTab = 1;
133413 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
133426 Vdbe *v = pParse->pVdbe;
133427 sqlite3 *db = pParse->db;
133430 for(p = pParse->pAinc; p; p = p->pNext){
133440 Db *pDb = &db->aDb[p->iDb];
133442 int memId = p->regCtr;
133445 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
133448 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
133453 aOp[2].p1 = memId-1;
133462 if( pParse->pAinc ) autoIncrementEnd(pParse);
133467 ** above are all no-ops
133475 ** that was able to use the co-routine optimization, finish coding the
133476 ** co-routine.
133479 if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
133480 SrcItem *pItem = &pVal->pSrc->a[0];
133481 sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->regReturn);
133482 sqlite3VdbeJumpHere(pParse->pVdbe, pItem->addrFillSub - 1);
133487 ** Return true if all expressions in the expression-list passed as the
133492 for(ii=0; ii<pRow->nExpr; ii++){
133493 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
133499 ** Return true if all expressions in the expression-list passed as the
133505 for(ii=0; ii<pRow->nExpr; ii++){
133506 Expr *pExpr = pRow->a[ii].pExpr;
133507 assert( pExpr->op!=TK_RAISE );
133508 assert( pExpr->affExpr==0 );
133517 ** rows of a multi-row VALUES clause. Argument pLeft is the part of
133522 ** There are two ways in which this may be achieved - by incremental
133523 ** coding of a co-routine (the "co-routine" method) or by returning a
133531 ** When the co-routine method is used, each row that will be returned
133532 ** by the VALUES clause is coded into part of a co-routine as it is
133536 ** Select object to read co-routine
133539 ** The co-routine method is used in most cases. Exceptions are:
133547 ** This will not work, as the co-routine uses a hard-coded register
133554 ** a co-routine is not possible.
133556 ** c) There are non-constant expressions in the VALUES clause (e.g.
133557 ** the VALUES clause is part of a correlated sub-query).
133568 if( pParse->bHasWith /* condition (a) above */
133569 || pParse->db->init.busy /* condition (b) above */
133571 || (pLeft->pSrc->nSrc==0 &&
133572 exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
133575 /* The co-routine method cannot be used. Fall back to UNION ALL. */
133578 if( pLeft->pSrc->nSrc ){
133581 }else if( pLeft->pPrior ){
133583 f = (f & pLeft->selFlags);
133586 pLeft->selFlags &= ~SF_MultiValue;
133588 pSelect->op = TK_ALL;
133589 pSelect->pPrior = pLeft;
133593 SrcItem *p = 0; /* SrcItem that reads from co-routine */
133595 if( pLeft->pSrc->nSrc==0 ){
133596 /* Co-routine has not yet been started and the special Select object
133597 ** that accesses the co-routine has not yet been created. This block
133604 if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
133610 pRet->pSrc->nSrc = 1;
133611 pRet->pPrior = pLeft->pPrior;
133612 pRet->op = pLeft->op;
133613 if( pRet->pPrior ) pRet->selFlags |= SF_Values;
133614 pLeft->pPrior = 0;
133615 pLeft->op = TK_SELECT;
133616 assert( pLeft->pNext==0 );
133617 assert( pRet->pNext==0 );
133618 p = &pRet->pSrc->a[0];
133619 p->pSelect = pLeft;
133620 p->fg.viaCoroutine = 1;
133621 p->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
133622 p->regReturn = ++pParse->nMem;
133623 p->iCursor = -1;
133624 p->u1.nRow = 2;
133625 sqlite3VdbeAddOp3(v,OP_InitCoroutine,p->regReturn,0,p->addrFillSub);
133626 sqlite3SelectDestInit(&dest, SRT_Coroutine, p->regReturn);
133628 /* Allocate registers for the output of the co-routine. Do so so
133630 ** used by the co-routine. This allows the code in sqlite3Insert()
133632 ** of the co-routine to a separate array for processing. */
133633 dest.iSdst = pParse->nMem + 3;
133634 dest.nSdst = pLeft->pEList->nExpr;
133635 pParse->nMem += 2 + dest.nSdst;
133637 pLeft->selFlags |= SF_MultiValue;
133639 p->regResult = dest.iSdst;
133640 assert( pParse->nErr || dest.iSdst>0 );
133644 p = &pLeft->pSrc->a[0];
133645 assert( !p->fg.isTabFunc && !p->fg.isIndexedBy );
133646 p->u1.nRow++;
133649 if( pParse->nErr==0 ){
133651 if( p->pSelect->pEList->nExpr!=pRow->nExpr ){
133652 sqlite3SelectWrongNumTermsError(pParse, p->pSelect);
133654 sqlite3ExprCodeExprList(pParse, pRow, p->regResult, 0, 0);
133655 sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, p->regReturn);
133658 sqlite3ExprListDelete(pParse->db, pRow);
133681 ** then a list of all (non-hidden) columns for the table is substituted.
133686 ** first two forms shown above. A VALUES clause is really just short-hand
133692 ** insert with data coming from a single-row VALUES clause, the code executes
133693 ** once straight down through. Pseudo-code follows (we call this
133705 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
133729 ** X <- A
133737 ** end-coroutine X
133750 ** X <- A
133758 ** end co-routine R
133787 int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
133802 int regFromSelect = 0;/* Base register for data coming from SELECT */
133816 db = pParse->db;
133817 assert( db->pParse==pParse );
133818 if( pParse->nErr ){
133821 assert( db->mallocFailed==0 );
133828 if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
133829 pList = pSelect->pEList;
133830 pSelect->pEList = 0;
133837 assert( pTabList->nSrc==1 );
133842 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
133843 assert( iDb<db->nDb );
133844 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
133845 db->aDb[iDb].zDbSName) ){
133870 sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList,
133876 ** ViewGetColumnNames() is a no-op if pTab is not a view.
133882 /* Cannot insert into a read-only table.
133892 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
133924 regRowid = regIns = pParse->nMem+1;
133925 pParse->nMem += pTab->nCol + 1;
133928 pParse->nMem++;
133941 ** PRIMARY KEY in the original table is pTab->iPKey.) After this
133942 ** loop, if ipkColumn==(-1), that means that integer primary key
133951 bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0;
133953 assert( pColumn->eU4!=EU4_EXPR );
133954 pColumn->eU4 = EU4_IDX;
133955 for(i=0; i<pColumn->nId; i++){
133956 pColumn->a[i].u4.idx = -1;
133958 for(i=0; i<pColumn->nId; i++){
133959 for(j=0; j<pTab->nCol; j++){
133960 if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
133961 pColumn->a[i].u4.idx = j;
133963 if( j==pTab->iPKey ){
133967 if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
133970 pTab->aCol[j].zCnName);
133977 if( j>=pTab->nCol ){
133978 if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
133983 pTabList->a, pColumn->a[i].zName);
133984 pParse->checkSchema = 1;
133992 ** is coming from a SELECT statement, then generate a co-routine that
133994 ** co-routine is the common header to the 3rd and 4th templates.
133997 /* Data is coming from a SELECT or from a multi-row VALUES clause.
133998 ** Generate a co-routine to run the SELECT. */
134001 if( pSelect->pSrc->nSrc==1
134002 && pSelect->pSrc->a[0].fg.viaCoroutine
134003 && pSelect->pPrior==0
134005 SrcItem *pItem = &pSelect->pSrc->a[0];
134006 dest.iSDParm = pItem->regReturn;
134007 regFromSelect = pItem->regResult;
134008 nColumn = pItem->pSelect->pEList->nExpr;
134010 if( bIdListInOrder && nColumn==pTab->nCol ){
134012 regRowid = regData - 1;
134013 regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
134016 int addrTop; /* Top of the co-routine */
134017 int regYield = ++pParse->nMem;
134022 dest.nSdst = pTab->nCol;
134025 assert( db->pParse==pParse );
134026 if( rc || pParse->nErr ) goto insert_cleanup;
134027 assert( db->mallocFailed==0 );
134029 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
134030 assert( pSelect->pEList );
134031 nColumn = pSelect->pEList->nExpr;
134062 srcTab = pParse->nTab++;
134077 ** single-row VALUES clause
134082 srcTab = -1;
134085 nColumn = pList->nExpr;
134099 ipkColumn = pTab->iPKey;
134101 if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
134102 testcase( pTab->tabFlags & TF_HasVirtual );
134103 testcase( pTab->tabFlags & TF_HasStored );
134104 for(i=ipkColumn-1; i>=0; i--){
134105 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
134106 testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL );
134107 testcase( pTab->aCol[i].colFlags & COLFLAG_STORED );
134108 ipkColumn--;
134120 if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
134121 for(i=0; i<pTab->nCol; i++){
134122 if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
134125 if( nColumn!=(pTab->nCol-nHidden) ){
134128 pTabList->a, pTab->nCol-nHidden, nColumn);
134132 if( pColumn!=0 && nColumn!=pColumn->nId ){
134133 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
134139 if( (db->flags & SQLITE_CountRows)!=0
134140 && !pParse->nested
134141 && !pParse->pTriggerTab
134142 && !pParse->bReturning
134144 regRowCount = ++pParse->nMem;
134151 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
134157 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
134159 aRegIdx[i] = ++pParse->nMem;
134160 pParse->nMem += pIdx->nColumn;
134162 aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */
134169 pTab->zName);
134176 if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
134179 pTabList->a[0].iCursor = iDataCur;
134182 pNx->pUpsertSrc = pTabList;
134183 pNx->regData = regData;
134184 pNx->iDataCur = iDataCur;
134185 pNx->iIdxCur = iIdxCur;
134186 if( pNx->pUpsertTarget ){
134191 pNx = pNx->pNextUpsert;
134219 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
134223 /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
134225 ** the value does not get overwritten by a NULL at tag-20191021-002. */
134239 for(i=0; i<pTab->nCol; i++, iRegStore++){
134243 if( i==pTab->iPKey ){
134244 /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
134247 ** NULL - we cannot optimize further by skipping the column completely */
134251 if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){
134257 iRegStore--;
134261 ** triggers, the slots used for stored columns will be OP_Copy-ed
134272 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134278 assert( pColumn->eU4==EU4_IDX );
134279 for(j=0; j<pColumn->nId && pColumn->a[j].u4.idx!=i; j++){}
134280 if( j>=pColumn->nId ){
134284 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134292 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
134296 k = i - nHidden;
134306 Expr *pX = pList->a[k].pExpr;
134320 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
134326 ** not happened yet) so we substitute a rowid of -1
134329 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
134337 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
134340 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
134346 assert( pTab->nNVCol>0 || pParse->nErr>0 );
134347 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
134354 if( pTab->tabFlags & TF_HasGenerated ){
134355 testcase( pTab->tabFlags & TF_HasVirtual );
134356 testcase( pTab->tabFlags & TF_HasStored );
134372 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
134374 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
134387 /* Rowid already initialized at tag-20191021-001 */
134389 Expr *pIpk = pList->a[ipkColumn].pExpr;
134390 if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
134394 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
134425 if( pTab->tabFlags & TF_HasGenerated ){
134437 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
134448 if( db->flags & SQLITE_ForeignKeys ){
134466 }else if( pParse->bReturning ){
134468 ** constant value -1, in case one or more of the returned expressions
134470 sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
134483 pTab, regData-2-pTab->nCol, onError, endOfLoop);
134500 if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
134501 assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
134515 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
134551 ** Meanings of bits in of pWalker->eCode for
134558 * Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
134563 if( pExpr->op==TK_COLUMN ){
134564 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
134565 if( pExpr->iColumn>=0 ){
134566 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
134567 pWalker->eCode |= CKCNSTRNT_COLUMN;
134570 pWalker->eCode |= CKCNSTRNT_ROWID;
134577 ** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
134586 ** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
134587 ** The operation of this routine is the same - return true if an only if
134615 ** the indexes of a table in the order provided in the Table->pIndex list.
134616 ** However, sometimes (rarely - when there is an upsert) it wants to visit
134650 assert( pIter->i==0 );
134651 if( pIter->eType ){
134652 *pIx = pIter->u.ax.aIdx[0].ix;
134653 return pIter->u.ax.aIdx[0].p;
134656 return pIter->u.lx.pIdx;
134662 if( pIter->eType ){
134663 int i = ++pIter->i;
134664 if( i>=pIter->u.ax.nIdx ){
134668 *pIx = pIter->u.ax.aIdx[i].ix;
134669 return pIter->u.ax.aIdx[i].p;
134672 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
134673 return pIter->u.lx.pIdx;
134683 ** pTab->nCol+1 registers in this range. The first register (the one
134710 ** at pTab->pIndex.
134712 ** (2019-05-07) The generated code also creates a new record for the
134714 ** register identified by aRegIdx[nIdx] - in other words in the first
134725 ** for the first index in the pTab->pIndex list. Cursors for other indices
134726 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
134734 ** --------------- ---------- ----------------------------------------
134764 ** Or if overrideError==OE_Default, then the pParse->onError parameter
134765 ** is used. Or if pParse->onError==OE_Default then the onError value
134776 u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */
134810 db = pParse->db;
134811 v = pParse->pVdbe;
134814 nCol = pTab->nCol;
134825 nPkField = pPk->nKeyCol;
134834 if( pTab->tabFlags & TF_HasNotNull ){
134841 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
134842 int isGenerated; /* non-zero if column is generated */
134843 onError = pCol->notNull;
134845 if( i==pTab->iPKey ){
134848 isGenerated = pCol->colFlags & COLFLAG_GENERATED;
134864 || pCol->iDflt==0 /* REPLACE is ABORT if no DEFAULT value */
134866 testcase( pCol->colFlags & COLFLAG_VIRTUAL );
134867 testcase( pCol->colFlags & COLFLAG_STORED );
134868 testcase( pCol->colFlags & COLFLAG_GENERATED );
134884 assert( (pCol->colFlags & COLFLAG_GENERATED)==0 );
134896 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
134897 pCol->zCnName);
134898 testcase( zMsg==0 && db->mallocFailed==0 );
134923 if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){
134931 } /* end of 2-pass loop */
134932 } /* end if( has-not-null-constraints ) */
134937 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
134938 ExprList *pCheck = pTab->pCheck;
134939 pParse->iSelfTab = -(regNewData+1);
134941 for(i=0; i<pCheck->nExpr; i++){
134944 Expr *pExpr = pCheck->a[i].pExpr;
134959 if( !db->mallocFailed ){
134966 char *zName = pCheck->a[i].zEName;
134967 assert( zName!=0 || pParse->db->mallocFailed );
134968 if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */
134975 pParse->iSelfTab = 0;
134992 ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
135010 sIdxIter.u.lx.pIdx = pTab->pIndex;
135012 if( pUpsert->pUpsertTarget==0 ){
135013 /* There is just on ON CONFLICT clause and it has no constraint-target */
135014 assert( pUpsert->pNextUpsert==0 );
135015 if( pUpsert->isDoUpdate==0 ){
135016 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
135024 }else if( pTab->pIndex!=0 ){
135032 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
135041 pUpsert->pToFree = sIdxIter.u.ax.aIdx;
135042 for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){
135043 if( pTerm->pUpsertTarget==0 ) break;
135044 if( pTerm->pUpsertIdx==0 ) continue; /* Skip ON CONFLICT for the IPK */
135046 pIdx = pTab->pIndex;
135047 while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
135048 pIdx = pIdx->pNext;
135057 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
135087 if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){
135093 if( db->flags&SQLITE_RecTriggers ){
135103 regTrigCnt = ++pParse->nMem;
135118 onError = pTab->keyConf;
135129 if( pUpsertClause->isDoUpdate==0 ){
135150 && pTab->pIndex /* There exist other constraints */
135189 ** recursive-triggers flag is set, call GenerateRowDelete() to
135191 ** the triggers and remove both the table and index b-tree entries.
135193 ** Otherwise, if there are no triggers or the recursive-triggers
135195 ** GenerateRowIndexDelete(). This removes the index b-tree entries
135196 ** only. The table b-tree entry will be replaced by the new entry
135213 regNewData, 1, 0, OE_Replace, 1, -1);
135219 /* This OP_Delete opcode fires the pre-update-hook only. It does
135220 ** not modify the b-tree. It is more efficient to let the coming
135226 if( pTab->pIndex ){
135228 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
135251 sqlite3VdbeJumpHere(v, ipkTop-1);
135284 VdbeNoopComment((v, "prep index %s", pIdx->zName));
135289 if( pIdx->pPartIdxWhere ){
135291 pParse->iSelfTab = -(regNewData+1);
135292 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
135294 pParse->iSelfTab = 0;
135301 for(i=0; i<pIdx->nColumn; i++){
135302 int iField = pIdx->aiColumn[i];
135305 pParse->iSelfTab = -(regNewData+1);
135306 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
135307 pParse->iSelfTab = 0;
135308 VdbeComment((v, "%s column %d", pIdx->zName, i));
135309 }else if( iField==XN_ROWID || iField==pTab->iPKey ){
135317 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
135320 sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
135321 VdbeComment((v, "for %s", pIdx->zName));
135323 if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
135324 sqlite3SetMakeRecordP5(v, pIdx->pTable);
135327 sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
135339 onError = pIdx->onError;
135352 if( pUpsertClause->isDoUpdate==0 ){
135367 ** must be explicitly deleted in order to ensure any pre-update hook
135371 if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
135374 && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */
135376 && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */
135377 (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab)))
135388 regIdx, pIdx->nKeyCol); VdbeCoverage(v);
135396 ** is different from old-rowid */
135405 ** store it in registers regR..regR+nPk-1 */
135407 for(i=0; i<pPk->nKeyCol; i++){
135408 assert( pPk->aiColumn[i]>=0 );
135409 x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
135411 VdbeComment((v, "%s.%s", pTab->zName,
135412 pTab->aCol[pPk->aiColumn[i]].zCnName));
135423 int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
135427 for(i=0; i<pPk->nKeyCol; i++){
135428 char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
135429 x = pPk->aiColumn[i];
135431 if( i==(pPk->nKeyCol-1) ){
135475 nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
135476 assert( nConflictCk>0 || db->mallocFailed );
135504 if( pIdx->pPartIdxWhere ){
135507 sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
135511 ** the constraint-ok jump destination to be the address of
135532 nConflictCk--;
135587 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
135601 ** to be the number of columns in table pTab that must not be NULL-trimmed.
135603 ** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero.
135609 ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */
135610 if( pTab->pSchema->file_format<2 ) return;
135612 for(i=pTab->nCol-1; i>0; i--){
135613 if( pTab->aCol[i].iDflt!=0 ) break;
135614 if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
135623 ** PK index. This function adds code to invoke the pre-update hook,
135633 Vdbe *v = pParse->pVdbe;
135636 assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB );
135676 v = pParse->pVdbe;
135679 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
135681 assert( pIdx->onError!=OE_Replace
135682 || pIdx->pNext==0
135683 || pIdx->pNext->onError==OE_Replace );
135685 if( pIdx->pPartIdxWhere ){
135699 pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
135703 if( pParse->nested ){
135716 if( !pParse->nested ){
135732 ** or the first index for WITHOUT ROWID tables) if it is non-negative.
135738 ** pTab->pIndex list.
135740 ** If pTab is a virtual table, then this routine is a no-op and the
135764 /* This routine is a no-op for virtual tables. Leave the output
135767 *piDataCur = *piIdxCur = -999;
135770 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
135771 v = pParse->pVdbe;
135773 if( iBase<0 ) iBase = pParse->nTab;
135778 }else if( pParse->db->noSharedCache==0 ){
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
135782 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
135784 assert( pIdx->pSchema==pTab->pSchema );
135790 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
135793 VdbeComment((v, "%s", pIdx->zName));
135796 if( iBase>pParse->nTab ) pParse->nTab = iBase;
135805 ** purposes only - to make sure the transfer optimization really
135827 assert( pDest->pTable!=pSrc->pTable );
135828 if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){
135831 if( pDest->onError!=pSrc->onError ){
135834 for(i=0; i<pSrc->nKeyCol; i++){
135835 if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
135838 if( pSrc->aiColumn[i]==XN_EXPR ){
135839 assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
135840 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
135841 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
135845 if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
135848 if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
135852 if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
135870 ** There are lots of rules for determining compatibility - see comments
135875 ** is empty - a factor that can only be determined at run-time. In that
135892 sqlite3 *db = pParse->db;
135896 SrcItem *pItem; /* An element of pSelect->pSrc */
135909 if( pParse->pWith || pSelect->pWith ){
135921 if( pDest->iPKey>=0 ) onError = pDest->keyConf;
135924 assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
135925 if( pSelect->pSrc->nSrc!=1 ){
135928 if( pSelect->pSrc->a[0].pSelect ){
135931 if( pSelect->pWhere ){
135934 if( pSelect->pOrderBy ){
135939 if( pSelect->pGroupBy ){
135942 if( pSelect->pLimit ){
135945 if( pSelect->pPrior ){
135948 if( pSelect->selFlags & SF_Distinct ){
135951 pEList = pSelect->pEList;
135953 if( pEList->nExpr!=1 ){
135956 assert( pEList->a[0].pExpr );
135957 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
135965 pItem = pSelect->pSrc->a;
135970 if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){
135980 if( pDest->nCol!=pSrc->nCol ){
135983 if( pDest->iPKey!=pSrc->iPKey ){
135986 if( (pDest->tabFlags & TF_Strict)!=0 && (pSrc->tabFlags & TF_Strict)==0 ){
135987 return 0; /* Cannot feed from a non-strict into a strict table */
135989 for(i=0; i<pDest->nCol; i++){
135990 Column *pDestCol = &pDest->aCol[i];
135991 Column *pSrcCol = &pSrc->aCol[i];
135993 if( (db->mDbFlags & DBFLAG_Vacuum)==0
135994 && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN
136016 if( (pDestCol->colFlags & COLFLAG_GENERATED) !=
136017 (pSrcCol->colFlags & COLFLAG_GENERATED) ){
136018 return 0; /* Both columns have the same generated-column type */
136024 if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){
136027 sqlite3ColumnExpr(pDest, pDestCol), -1)!=0 ){
136028 testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
136029 testcase( pDestCol->colFlags & COLFLAG_STORED );
136034 if( pDestCol->affinity!=pSrcCol->affinity ){
136041 if( pDestCol->notNull && !pSrcCol->notNull ){
136045 if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){
136048 assert( pDestExpr==0 || pDestExpr->op==TK_SPAN );
136050 assert( pSrcExpr==0 || pSrcExpr->op==TK_SPAN );
136053 || (pDestExpr!=0 && strcmp(pDestExpr->u.zToken,
136054 pSrcExpr->u.zToken)!=0)
136060 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
136064 for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
136070 if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema
136075 return 0; /* Corrupt schema - two indexes on the same btree */
136079 if( pDest->pCheck
136080 && (db->mDbFlags & DBFLAG_Vacuum)==0
136081 && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1)
136095 if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){
136099 if( (db->flags & SQLITE_CountRows)!=0 ){
136110 iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
136113 iSrc = pParse->nTab++;
136114 iDest = pParse->nTab++;
136121 if( (db->mDbFlags & DBFLAG_Vacuum)==0 && (
136122 (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
136151 if( pDest->iPKey>=0 ){
136153 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
136161 }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
136165 assert( (pDest->tabFlags & TF_Autoincrement)==0 );
136168 if( db->mDbFlags & DBFLAG_Vacuum ){
136175 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
136184 if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
136185 sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
136193 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
136194 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
136196 for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
136198 for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
136202 sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
136204 VdbeComment((v, "%s", pSrcIdx->zName));
136205 sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
136208 VdbeComment((v, "%s", pDestIdx->zName));
136210 if( db->mDbFlags & DBFLAG_Vacuum ){
136215 ** order. In this case, instead of seeking within the b-tree as part
136217 ** OP_IdxInsert to seek to the point within the b-tree where each key
136225 for(i=0; i<pSrcIdx->nColumn; i++){
136226 const char *zColl = pSrcIdx->azColl[i];
136229 if( i==pSrcIdx->nColumn ){
136234 }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
136239 if( (db->mDbFlags & DBFLAG_Vacuum)==0
136315 sqlite3_mutex_enter(db->mutex);
136322 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
136328 /* this happens for a comment or white-space */
136341 && db->flags&SQLITE_NullCallback)) ){
136368 /* EVIDENCE-OF: R-38229-40159 If the callback function to
136369 ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
136407 assert( (rc&db->errMask)==rc );
136408 sqlite3_mutex_leave(db->mutex);
136819 ** (part of the main SQLite library - not an extension) so that
136826 #define sqlite3_aggregate_context sqlite3_api->aggregate_context
136828 #define sqlite3_aggregate_count sqlite3_api->aggregate_count
136830 #define sqlite3_bind_blob sqlite3_api->bind_blob
136831 #define sqlite3_bind_double sqlite3_api->bind_double
136832 #define sqlite3_bind_int sqlite3_api->bind_int
136833 #define sqlite3_bind_int64 sqlite3_api->bind_int64
136834 #define sqlite3_bind_null sqlite3_api->bind_null
136835 #define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count
136836 #define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index
136837 #define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name
136838 #define sqlite3_bind_text sqlite3_api->bind_text
136839 #define sqlite3_bind_text16 sqlite3_api->bind_text16
136840 #define sqlite3_bind_value sqlite3_api->bind_value
136841 #define sqlite3_busy_handler sqlite3_api->busy_handler
136842 #define sqlite3_busy_timeout sqlite3_api->busy_timeout
136843 #define sqlite3_changes sqlite3_api->changes
136844 #define sqlite3_close sqlite3_api->close
136845 #define sqlite3_collation_needed sqlite3_api->collation_needed
136846 #define sqlite3_collation_needed16 sqlite3_api->collation_needed16
136847 #define sqlite3_column_blob sqlite3_api->column_blob
136848 #define sqlite3_column_bytes sqlite3_api->column_bytes
136849 #define sqlite3_column_bytes16 sqlite3_api->column_bytes16
136850 #define sqlite3_column_count sqlite3_api->column_count
136851 #define sqlite3_column_database_name sqlite3_api->column_database_name
136852 #define sqlite3_column_database_name16 sqlite3_api->column_database_name16
136853 #define sqlite3_column_decltype sqlite3_api->column_decltype
136854 #define sqlite3_column_decltype16 sqlite3_api->column_decltype16
136855 #define sqlite3_column_double sqlite3_api->column_double
136856 #define sqlite3_column_int sqlite3_api->column_int
136857 #define sqlite3_column_int64 sqlite3_api->column_int64
136858 #define sqlite3_column_name sqlite3_api->column_name
136859 #define sqlite3_column_name16 sqlite3_api->column_name16
136860 #define sqlite3_column_origin_name sqlite3_api->column_origin_name
136861 #define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16
136862 #define sqlite3_column_table_name sqlite3_api->column_table_name
136863 #define sqlite3_column_table_name16 sqlite3_api->column_table_name16
136864 #define sqlite3_column_text sqlite3_api->column_text
136865 #define sqlite3_column_text16 sqlite3_api->column_text16
136866 #define sqlite3_column_type sqlite3_api->column_type
136867 #define sqlite3_column_value sqlite3_api->column_value
136868 #define sqlite3_commit_hook sqlite3_api->commit_hook
136869 #define sqlite3_complete sqlite3_api->complete
136870 #define sqlite3_complete16 sqlite3_api->complete16
136871 #define sqlite3_create_collation sqlite3_api->create_collation
136872 #define sqlite3_create_collation16 sqlite3_api->create_collation16
136873 #define sqlite3_create_function sqlite3_api->create_function
136874 #define sqlite3_create_function16 sqlite3_api->create_function16
136875 #define sqlite3_create_module sqlite3_api->create_module
136876 #define sqlite3_create_module_v2 sqlite3_api->create_module_v2
136877 #define sqlite3_data_count sqlite3_api->data_count
136878 #define sqlite3_db_handle sqlite3_api->db_handle
136879 #define sqlite3_declare_vtab sqlite3_api->declare_vtab
136880 #define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache
136881 #define sqlite3_errcode sqlite3_api->errcode
136882 #define sqlite3_errmsg sqlite3_api->errmsg
136883 #define sqlite3_errmsg16 sqlite3_api->errmsg16
136884 #define sqlite3_exec sqlite3_api->exec
136886 #define sqlite3_expired sqlite3_api->expired
136888 #define sqlite3_finalize sqlite3_api->finalize
136889 #define sqlite3_free sqlite3_api->free
136890 #define sqlite3_free_table sqlite3_api->free_table
136891 #define sqlite3_get_autocommit sqlite3_api->get_autocommit
136892 #define sqlite3_get_auxdata sqlite3_api->get_auxdata
136893 #define sqlite3_get_table sqlite3_api->get_table
136895 #define sqlite3_global_recover sqlite3_api->global_recover
136897 #define sqlite3_interrupt sqlite3_api->interruptx
136898 #define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid
136899 #define sqlite3_libversion sqlite3_api->libversion
136900 #define sqlite3_libversion_number sqlite3_api->libversion_number
136901 #define sqlite3_malloc sqlite3_api->malloc
136902 #define sqlite3_mprintf sqlite3_api->mprintf
136903 #define sqlite3_open sqlite3_api->open
136904 #define sqlite3_open16 sqlite3_api->open16
136905 #define sqlite3_prepare sqlite3_api->prepare
136906 #define sqlite3_prepare16 sqlite3_api->prepare16
136907 #define sqlite3_prepare_v2 sqlite3_api->prepare_v2
136908 #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
136909 #define sqlite3_profile sqlite3_api->profile
136910 #define sqlite3_progress_handler sqlite3_api->progress_handler
136911 #define sqlite3_realloc sqlite3_api->realloc
136912 #define sqlite3_reset sqlite3_api->reset
136913 #define sqlite3_result_blob sqlite3_api->result_blob
136914 #define sqlite3_result_double sqlite3_api->result_double
136915 #define sqlite3_result_error sqlite3_api->result_error
136916 #define sqlite3_result_error16 sqlite3_api->result_error16
136917 #define sqlite3_result_int sqlite3_api->result_int
136918 #define sqlite3_result_int64 sqlite3_api->result_int64
136919 #define sqlite3_result_null sqlite3_api->result_null
136920 #define sqlite3_result_text sqlite3_api->result_text
136921 #define sqlite3_result_text16 sqlite3_api->result_text16
136922 #define sqlite3_result_text16be sqlite3_api->result_text16be
136923 #define sqlite3_result_text16le sqlite3_api->result_text16le
136924 #define sqlite3_result_value sqlite3_api->result_value
136925 #define sqlite3_rollback_hook sqlite3_api->rollback_hook
136926 #define sqlite3_set_authorizer sqlite3_api->set_authorizer
136927 #define sqlite3_set_auxdata sqlite3_api->set_auxdata
136928 #define sqlite3_snprintf sqlite3_api->xsnprintf
136929 #define sqlite3_step sqlite3_api->step
136930 #define sqlite3_table_column_metadata sqlite3_api->table_column_metadata
136931 #define sqlite3_thread_cleanup sqlite3_api->thread_cleanup
136932 #define sqlite3_total_changes sqlite3_api->total_changes
136933 #define sqlite3_trace sqlite3_api->trace
136935 #define sqlite3_transfer_bindings sqlite3_api->transfer_bindings
136937 #define sqlite3_update_hook sqlite3_api->update_hook
136938 #define sqlite3_user_data sqlite3_api->user_data
136939 #define sqlite3_value_blob sqlite3_api->value_blob
136940 #define sqlite3_value_bytes sqlite3_api->value_bytes
136941 #define sqlite3_value_bytes16 sqlite3_api->value_bytes16
136942 #define sqlite3_value_double sqlite3_api->value_double
136943 #define sqlite3_value_int sqlite3_api->value_int
136944 #define sqlite3_value_int64 sqlite3_api->value_int64
136945 #define sqlite3_value_numeric_type sqlite3_api->value_numeric_type
136946 #define sqlite3_value_text sqlite3_api->value_text
136947 #define sqlite3_value_text16 sqlite3_api->value_text16
136948 #define sqlite3_value_text16be sqlite3_api->value_text16be
136949 #define sqlite3_value_text16le sqlite3_api->value_text16le
136950 #define sqlite3_value_type sqlite3_api->value_type
136951 #define sqlite3_vmprintf sqlite3_api->vmprintf
136952 #define sqlite3_vsnprintf sqlite3_api->xvsnprintf
136953 #define sqlite3_overload_function sqlite3_api->overload_function
136954 #define sqlite3_prepare_v2 sqlite3_api->prepare_v2
136955 #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
136956 #define sqlite3_clear_bindings sqlite3_api->clear_bindings
136957 #define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob
136958 #define sqlite3_blob_bytes sqlite3_api->blob_bytes
136959 #define sqlite3_blob_close sqlite3_api->blob_close
136960 #define sqlite3_blob_open sqlite3_api->blob_open
136961 #define sqlite3_blob_read sqlite3_api->blob_read
136962 #define sqlite3_blob_write sqlite3_api->blob_write
136963 #define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2
136964 #define sqlite3_file_control sqlite3_api->file_control
136965 #define sqlite3_memory_highwater sqlite3_api->memory_highwater
136966 #define sqlite3_memory_used sqlite3_api->memory_used
136967 #define sqlite3_mutex_alloc sqlite3_api->mutex_alloc
136968 #define sqlite3_mutex_enter sqlite3_api->mutex_enter
136969 #define sqlite3_mutex_free sqlite3_api->mutex_free
136970 #define sqlite3_mutex_leave sqlite3_api->mutex_leave
136971 #define sqlite3_mutex_try sqlite3_api->mutex_try
136972 #define sqlite3_open_v2 sqlite3_api->open_v2
136973 #define sqlite3_release_memory sqlite3_api->release_memory
136974 #define sqlite3_result_error_nomem sqlite3_api->result_error_nomem
136975 #define sqlite3_result_error_toobig sqlite3_api->result_error_toobig
136976 #define sqlite3_sleep sqlite3_api->sleep
136977 #define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit
136978 #define sqlite3_vfs_find sqlite3_api->vfs_find
136979 #define sqlite3_vfs_register sqlite3_api->vfs_register
136980 #define sqlite3_vfs_unregister sqlite3_api->vfs_unregister
136981 #define sqlite3_threadsafe sqlite3_api->xthreadsafe
136982 #define sqlite3_result_zeroblob sqlite3_api->result_zeroblob
136983 #define sqlite3_result_error_code sqlite3_api->result_error_code
136984 #define sqlite3_test_control sqlite3_api->test_control
136985 #define sqlite3_randomness sqlite3_api->randomness
136986 #define sqlite3_context_db_handle sqlite3_api->context_db_handle
136987 #define sqlite3_extended_result_codes sqlite3_api->extended_result_codes
136988 #define sqlite3_limit sqlite3_api->limit
136989 #define sqlite3_next_stmt sqlite3_api->next_stmt
136990 #define sqlite3_sql sqlite3_api->sql
136991 #define sqlite3_status sqlite3_api->status
136992 #define sqlite3_backup_finish sqlite3_api->backup_finish
136993 #define sqlite3_backup_init sqlite3_api->backup_init
136994 #define sqlite3_backup_pagecount sqlite3_api->backup_pagecount
136995 #define sqlite3_backup_remaining sqlite3_api->backup_remaining
136996 #define sqlite3_backup_step sqlite3_api->backup_step
136997 #define sqlite3_compileoption_get sqlite3_api->compileoption_get
136998 #define sqlite3_compileoption_used sqlite3_api->compileoption_used
136999 #define sqlite3_create_function_v2 sqlite3_api->create_function_v2
137000 #define sqlite3_db_config sqlite3_api->db_config
137001 #define sqlite3_db_mutex sqlite3_api->db_mutex
137002 #define sqlite3_db_status sqlite3_api->db_status
137003 #define sqlite3_extended_errcode sqlite3_api->extended_errcode
137004 #define sqlite3_log sqlite3_api->log
137005 #define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64
137006 #define sqlite3_sourceid sqlite3_api->sourceid
137007 #define sqlite3_stmt_status sqlite3_api->stmt_status
137008 #define sqlite3_strnicmp sqlite3_api->strnicmp
137009 #define sqlite3_unlock_notify sqlite3_api->unlock_notify
137010 #define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint
137011 #define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint
137012 #define sqlite3_wal_hook sqlite3_api->wal_hook
137013 #define sqlite3_blob_reopen sqlite3_api->blob_reopen
137014 #define sqlite3_vtab_config sqlite3_api->vtab_config
137015 #define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict
137017 #define sqlite3_close_v2 sqlite3_api->close_v2
137018 #define sqlite3_db_filename sqlite3_api->db_filename
137019 #define sqlite3_db_readonly sqlite3_api->db_readonly
137020 #define sqlite3_db_release_memory sqlite3_api->db_release_memory
137021 #define sqlite3_errstr sqlite3_api->errstr
137022 #define sqlite3_stmt_busy sqlite3_api->stmt_busy
137023 #define sqlite3_stmt_readonly sqlite3_api->stmt_readonly
137024 #define sqlite3_stricmp sqlite3_api->stricmp
137025 #define sqlite3_uri_boolean sqlite3_api->uri_boolean
137026 #define sqlite3_uri_int64 sqlite3_api->uri_int64
137027 #define sqlite3_uri_parameter sqlite3_api->uri_parameter
137028 #define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf
137029 #define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2
137031 #define sqlite3_auto_extension sqlite3_api->auto_extension
137032 #define sqlite3_bind_blob64 sqlite3_api->bind_blob64
137033 #define sqlite3_bind_text64 sqlite3_api->bind_text64
137034 #define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension
137035 #define sqlite3_load_extension sqlite3_api->load_extension
137036 #define sqlite3_malloc64 sqlite3_api->malloc64
137037 #define sqlite3_msize sqlite3_api->msize
137038 #define sqlite3_realloc64 sqlite3_api->realloc64
137039 #define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension
137040 #define sqlite3_result_blob64 sqlite3_api->result_blob64
137041 #define sqlite3_result_text64 sqlite3_api->result_text64
137042 #define sqlite3_strglob sqlite3_api->strglob
137044 #define sqlite3_value_dup sqlite3_api->value_dup
137045 #define sqlite3_value_free sqlite3_api->value_free
137046 #define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64
137047 #define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64
137049 #define sqlite3_value_subtype sqlite3_api->value_subtype
137050 #define sqlite3_result_subtype sqlite3_api->result_subtype
137052 #define sqlite3_status64 sqlite3_api->status64
137053 #define sqlite3_strlike sqlite3_api->strlike
137054 #define sqlite3_db_cacheflush sqlite3_api->db_cacheflush
137056 #define sqlite3_system_errno sqlite3_api->system_errno
137058 #define sqlite3_trace_v2 sqlite3_api->trace_v2
137059 #define sqlite3_expanded_sql sqlite3_api->expanded_sql
137061 #define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid
137063 #define sqlite3_prepare_v3 sqlite3_api->prepare_v3
137064 #define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3
137065 #define sqlite3_bind_pointer sqlite3_api->bind_pointer
137066 #define sqlite3_result_pointer sqlite3_api->result_pointer
137067 #define sqlite3_value_pointer sqlite3_api->value_pointer
137069 #define sqlite3_vtab_nochange sqlite3_api->vtab_nochange
137070 #define sqlite3_value_nochange sqlite3_api->value_nochange
137071 #define sqlite3_vtab_collation sqlite3_api->vtab_collation
137073 #define sqlite3_keyword_count sqlite3_api->keyword_count
137074 #define sqlite3_keyword_name sqlite3_api->keyword_name
137075 #define sqlite3_keyword_check sqlite3_api->keyword_check
137076 #define sqlite3_str_new sqlite3_api->str_new
137077 #define sqlite3_str_finish sqlite3_api->str_finish
137078 #define sqlite3_str_appendf sqlite3_api->str_appendf
137079 #define sqlite3_str_vappendf sqlite3_api->str_vappendf
137080 #define sqlite3_str_append sqlite3_api->str_append
137081 #define sqlite3_str_appendall sqlite3_api->str_appendall
137082 #define sqlite3_str_appendchar sqlite3_api->str_appendchar
137083 #define sqlite3_str_reset sqlite3_api->str_reset
137084 #define sqlite3_str_errcode sqlite3_api->str_errcode
137085 #define sqlite3_str_length sqlite3_api->str_length
137086 #define sqlite3_str_value sqlite3_api->str_value
137088 #define sqlite3_create_window_function sqlite3_api->create_window_function
137090 #define sqlite3_normalized_sql sqlite3_api->normalized_sql
137092 #define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain
137093 #define sqlite3_value_frombind sqlite3_api->value_frombind
137095 #define sqlite3_drop_modules sqlite3_api->drop_modules
137097 #define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64
137098 #define sqlite3_uri_key sqlite3_api->uri_key
137099 #define sqlite3_filename_database sqlite3_api->filename_database
137100 #define sqlite3_filename_journal sqlite3_api->filename_journal
137101 #define sqlite3_filename_wal sqlite3_api->filename_wal
137103 #define sqlite3_create_filename sqlite3_api->create_filename
137104 #define sqlite3_free_filename sqlite3_api->free_filename
137105 #define sqlite3_database_file_object sqlite3_api->database_file_object
137107 #define sqlite3_txn_state sqlite3_api->txn_state
137109 #define sqlite3_changes64 sqlite3_api->changes64
137110 #define sqlite3_total_changes64 sqlite3_api->total_changes64
137112 #define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages
137114 #define sqlite3_error_offset sqlite3_api->error_offset
137115 #define sqlite3_vtab_rhs_value sqlite3_api->vtab_rhs_value
137116 #define sqlite3_vtab_distinct sqlite3_api->vtab_distinct
137117 #define sqlite3_vtab_in sqlite3_api->vtab_in
137118 #define sqlite3_vtab_in_first sqlite3_api->vtab_in_first
137119 #define sqlite3_vtab_in_next sqlite3_api->vtab_in_next
137122 #define sqlite3_deserialize sqlite3_api->deserialize
137123 #define sqlite3_serialize sqlite3_api->serialize
137125 #define sqlite3_db_name sqlite3_api->db_name
137127 #define sqlite3_value_encoding sqlite3_api->value_encoding
137129 #define sqlite3_is_interrupted sqlite3_api->is_interrupted
137131 #define sqlite3_stmt_explain sqlite3_api->stmt_explain
137133 #define sqlite3_get_clientdata sqlite3_api->get_clientdata
137134 #define sqlite3_set_clientdata sqlite3_api->set_clientdata
137147 # define SQLITE_EXTENSION_INIT1 /*no-op*/
137149 # define SQLITE_EXTENSION_INIT3 /*no-op*/
137685 sqlite3_vfs *pVfs = db->pVfs;
137717 if( (db->flags & SQLITE_LoadExtension)==0 ){
137726 /* tag-20210611-1. Some dlopen() implementations will segfault if given
137731 ** Later (2023-03-25): Save an extra 6 bytes for the filename suffix.
137774 for(iFile=ncFile-1; iFile>=0 && !DirSep(zFile[iFile]); iFile--){}
137794 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
137813 /* Append the new shared library handle to the db->aExtension array. */
137814 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
137818 if( db->nExtension>0 ){
137819 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
137821 sqlite3DbFree(db, db->aExtension);
137822 db->aExtension = aHandle;
137824 db->aExtension[db->nExtension++] = handle;
137835 sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
137847 sqlite3_mutex_enter(db->mutex);
137850 sqlite3_mutex_leave(db->mutex);
137860 assert( sqlite3_mutex_held(db->mutex) );
137861 for(i=0; i<db->nExtension; i++){
137862 sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
137864 sqlite3DbFree(db, db->aExtension);
137875 sqlite3_mutex_enter(db->mutex);
137877 db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
137879 db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
137881 sqlite3_mutex_leave(db->mutex);
137902 ** we have to locate the state vector at run-time. In the more common
137965 ** routine is a no-op.
137983 for(i=(int)wsdAutoext.nExt-1; i>=0; i--){
137985 wsdAutoext.nExt--;
138151 #define PragFlg_ReadOnly 0x08 /* Read-only HEADER_VALUE */
138155 #define PragFlg_SchemaReq 0x80 /* Schema required - "main" is default */
138157 /* Names of columns for pragmas that return multi-column result
138158 ** or that return single-column results where the name of the
138225 /* Definitions of all built-in pragmas */
138760 ** the following macro or to the actual analysis_limit if it is non-zero,
138763 ** The value of 2000 is chosen emperically so that the worst-case run-time
138764 ** for PRAGMA optimize does not exceed 100 milliseconds against a variety
138765 ** of test databases on a RaspberryPI-4 compiled using -Os and without
138766 ** -DSQLITE_DEBUG. Of course, your mileage may vary. For the purpose of
138767 ** this paragraph, "worst-case" means that ANALYZE ends up being
138774 ** optimize on a PI-4 is more like 1 millisecond or less with the 0x10000
138775 ** flag or less than 100 microseconds without the 0x10000 flag.
138844 ** Interpret the given string as an auto-vacuum mode value.
138862 ** backed temporary databases, 2 for the Red-Black tree in memory database
138863 ** and 0 to use the compile-time default.
138867 return z[0] - '0';
138884 sqlite3 *db = pParse->db;
138885 if( db->aDb[1].pBt!=0 ){
138886 if( !db->autoCommit
138887 || sqlite3BtreeTxnState(db->aDb[1].pBt)!=SQLITE_TXN_NONE
138893 sqlite3BtreeClose(db->aDb[1].pBt);
138894 db->aDb[1].pBt = 0;
138909 sqlite3 *db = pParse->db;
138910 if( db->temp_store==ts ) return SQLITE_OK;
138914 db->temp_store = (u8)ts;
138926 u8 n = pPragma->nPragCName;
138929 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
138932 for(i=0, j=pPragma->iPragCName; i<n; i++, j++){
138966 if( db->autoCommit ){
138967 Db *pDb = db->aDb;
138968 int n = db->nDb;
138974 assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
138975 while( (n--) > 0 ){
138976 if( pDb->pBt ){
138977 sqlite3BtreeSetPagerFlags(pDb->pBt,
138978 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
138985 # define setAllPagerFlags(X) /* no-op */
138990 ** Return a human-readable name for a constraint resolution action.
139011 ** journal-mode name.
139038 upr = ArraySize(aPragmaName)-1;
139044 upr = mid - 1;
139059 int isBuiltin, /* True if this is a built-in function */
139070 for(; p; p=p->pNext){
139079 if( p->xSFunc==0 ) continue;
139080 if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0
139085 if( p->xValue!=0 ){
139087 }else if( p->xFinalize!=0 ){
139093 p->zName, isBuiltin,
139094 zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK],
139095 p->nArg,
139096 (p->funcFlags & mask) ^ SQLITE_INNOCUOUS
139105 ** Generate code to output a single-column result row with a value of the
139138 int minusFlag /* True if a '-' sign preceded <value> */
139140 char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
139141 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
139147 sqlite3 *db = pParse->db; /* The database connection */
139154 pParse->nMem = 2;
139160 pDb = &db->aDb[iDb];
139172 zRight = sqlite3MPrintf(db, "-%T", pValue);
139178 zDb = pId2->n>0 ? pDb->zDbSName : 0;
139183 /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS
139185 ** handled the pragma and generate a no-op prepared statement.
139187 ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed,
139192 ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
139202 db->busyHandler.nBusy = 0;
139216 pParse->nErr++;
139217 pParse->rc = rc;
139224 /* IMP: R-43042-22504 No error messages are generated if an
139230 if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){
139235 if( (pPragma->mPragFlg & PragFlg_NoColumns)==0
139236 && ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0)
139242 switch( pPragma->ePragTyp ){
139277 pParse->nMem += 2;
139289 pDb->pSchema->cache_size = size;
139290 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
139307 Btree *pBt = pDb->pBt;
139313 /* Malloc may fail when setting the page-size, as there is an internal
139316 db->nextPagesize = sqlite3Atoi(zRight);
139317 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,0,0) ){
139333 Btree *pBt = pDb->pBt;
139334 int b = -1;
139343 if( pId2->n==0 && b>=0 ){
139345 for(ii=0; ii<db->nDb; ii++){
139346 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
139375 iReg = ++pParse->nMem;
139399 if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
139402 ** the locking-mode of the main database).
139404 eMode = db->dfltLockMode;
139407 if( pId2->n==0 ){
139409 ** of the PRAGMA command. In this case the locking-mode must be
139417 assert(pDb==&db->aDb[0]);
139418 for(ii=2; ii<db->nDb; ii++){
139419 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
139422 db->dfltLockMode = (u8)eMode;
139424 pPager = sqlite3BtreePager(pDb->pBt);
139461 if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){
139462 /* Do not allow journal-mode "OFF" in defensive since the database
139467 if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
139470 pId2->n = 1;
139472 for(ii=db->nDb-1; ii>=0; ii--){
139473 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
139489 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139490 i64 iLimit = -2;
139493 if( iLimit<-1 ) iLimit = -1;
139506 ** Get or set the value of the database 'auto-vacuum' parameter.
139511 Btree *pBt = pDb->pBt;
139518 db->nextAutovac = (u8)eAuto;
139520 ** incr-vacuum flags. This is required in case this connection
139522 ** as an auto-vacuum capable db.
139529 ** that this really is an auto-vacuum capable database.
139548 aOp[4].p3 = eAuto - 1;
139571 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
139587 ** number of pages is adjusted so that the cache uses -N kibibytes
139593 returnSingleInt(v, pDb->pSchema->cache_size);
139596 pDb->pSchema->cache_size = size;
139597 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
139614 ** number of pages is adjusted so that the cache uses -N kibibytes
139628 (db->flags & SQLITE_CacheSpill)==0 ? 0 :
139629 sqlite3BtreeSetSpillSize(pDb->pBt,0));
139633 sqlite3BtreeSetSpillSize(pDb->pBt, size);
139636 db->flags |= SQLITE_CacheSpill;
139638 db->flags &= ~(u64)SQLITE_CacheSpill;
139667 if( pId2->n==0 ) db->szMmap = sz;
139668 for(ii=db->nDb-1; ii>=0; ii--){
139669 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
139670 sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
139674 sz = -1;
139683 pParse->nErr++;
139684 pParse->rc = rc;
139697 ** Note that it is possible for the library compile-time options to
139702 returnSingleInt(v, db->temp_store);
139727 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
139735 || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
139736 || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
139774 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
139805 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139812 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139842 returnSingleInt(v, pDb->safety_level-1);
139844 if( !db->autoCommit ){
139850 pDb->safety_level = iLevel;
139851 pDb->bSyncSet = 1;
139863 returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
139865 u64 mask = pPragma->iArg; /* Mask of bits to set or clear. */
139866 if( db->autoCommit==0 ){
139868 ** in auto-commit mode. */
139872 if( db->auth.authLevel==UAUTH_User ){
139873 /* Do not allow non-admin users to modify the schema arbitrarily */
139880 || (db->flags & SQLITE_Defensive)==0
139882 db->flags |= mask;
139885 db->flags &= ~mask;
139886 if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
139890 /* IMP: R-60817-01178 If the argument is "RESET" then schema
139897 /* Many of the flag-pragmas modify the code generated by the SQL
139920 ** pk: Non-zero for PK fields.
139931 pParse->nMem = 7;
139933 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
139936 if( pCol->colFlags & COLFLAG_NOINSERT ){
139937 if( pPragma->iArg==0 ){
139941 if( pCol->colFlags & COLFLAG_VIRTUAL ){
139943 }else if( pCol->colFlags & COLFLAG_STORED ){
139945 }else{ assert( pCol->colFlags & COLFLAG_HIDDEN );
139949 if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){
139954 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
139957 assert( pColExpr==0 || pColExpr->op==TK_SPAN || isHidden>=2 );
139960 sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
139961 i-nHidden,
139962 pCol->zCnName,
139964 pCol->notNull ? 1 : 0,
139965 (isHidden>=2 || pColExpr==0) ? 0 : pColExpr->u.zToken,
139988 pParse->nMem = 6;
139990 for(ii=0; ii<db->nDb; ii++){
139994 if( zDb && sqlite3_stricmp(zDb, db->aDb[ii].zDbSName)!=0 ) continue;
140001 pHash = &db->aDb[ii].pSchema->tblHash;
140003 while( initNCol-- ){
140008 if( pTab->nCol==0 ){
140009 char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
140012 (void)sqlite3_prepare(db, zSql, -1, &pDummy, 0);
140016 if( db->mallocFailed ){
140017 sqlite3ErrorMsg(db->pParse, "out of memory");
140018 db->pParse->rc = SQLITE_NOMEM_BKPT;
140020 pHash = &db->aDb[ii].pSchema->tblHash;
140029 if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
140034 }else if( pTab->tabFlags & TF_Shadow ){
140040 db->aDb[ii].zDbSName,
140041 sqlite3PreferredTableName(pTab->zName),
140043 pTab->nCol,
140044 (pTab->tabFlags & TF_WithoutRowid)!=0,
140045 (pTab->tabFlags & TF_Strict)!=0
140056 pParse->nMem = 5;
140058 for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
140061 sqlite3PreferredTableName(pTab->zName),
140063 pTab->szTabRow,
140064 pTab->nRowLogEst,
140065 pTab->tabFlags);
140066 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140068 pIdx->zName,
140069 pIdx->szIdxRow,
140070 pIdx->aiRowLogEst[0],
140071 pIdx->hasStat1);
140093 int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
140096 if( pPragma->iArg ){
140098 mx = pIdx->nColumn;
140099 pParse->nMem = 6;
140102 mx = pIdx->nKeyCol;
140103 pParse->nMem = 3;
140105 pTab = pIdx->pTable;
140107 assert( pParse->nMem<=pPragma->nPragCName );
140109 i16 cnum = pIdx->aiColumn[i];
140111 cnum<0 ? 0 : pTab->aCol[cnum].zCnName);
140112 if( pPragma->iArg ){
140114 pIdx->aSortOrder[i],
140115 pIdx->azColl[i],
140116 i<pIdx->nKeyCol);
140118 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
140130 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140131 pParse->nMem = 5;
140133 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
140137 pIdx->zName,
140139 azOrigin[pIdx->idxType],
140140 pIdx->pPartIdxWhere!=0);
140148 pParse->nMem = 3;
140149 for(i=0; i<db->nDb; i++){
140150 if( db->aDb[i].pBt==0 ) continue;
140151 assert( db->aDb[i].zDbSName!=0 );
140154 db->aDb[i].zDbSName,
140155 sqlite3BtreeGetFilename(db->aDb[i].pBt));
140163 pParse->nMem = 2;
140164 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
140166 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
140176 int showInternFunc = (db->mDbFlags & DBFLAG_InternalFunc)!=0;
140177 pParse->nMem = 6;
140179 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){
140180 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
140184 for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){
140186 assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 );
140195 pParse->nMem = 1;
140196 for(j=sqliteHashFirst(&db->aModule); j; j=sqliteHashNext(j)){
140198 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
140221 pFK = pTab->u.tab.pFKey;
140223 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140225 pParse->nMem = 8;
140229 for(j=0; j<pFK->nCol; j++){
140233 pFK->zTo,
140234 pTab->aCol[pFK->aCol[j].iFrom].zCnName,
140235 pFK->aCol[j].zCol,
140236 actionName(pFK->aAction[1]), /* ON UPDATE */
140237 actionName(pFK->aAction[0]), /* ON DELETE */
140241 pFK = pFK->pNextFrom;
140266 regResult = pParse->nMem+1;
140267 pParse->nMem += 4;
140268 regRow = ++pParse->nMem;
140269 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
140278 if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue;
140279 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140280 zDb = db->aDb[iDb].zDbSName;
140282 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
140283 sqlite3TouchRegister(pParse, pTab->nCol+regRow);
140285 sqlite3VdbeLoadString(v, regResult, pTab->zName);
140287 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
140288 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
140291 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
140297 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
140305 assert( pParse->nErr>0 || pFK==0 );
140307 if( pParse->nTab<i ) pParse->nTab = i;
140310 for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
140311 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
140316 assert( x==0 || db->mallocFailed );
140324 sqlite3TouchRegister(pParse, regRow + pFK->nCol);
140325 for(j=0; j<pFK->nCol; j++){
140326 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
140334 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
140335 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
140336 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
140342 assert( pFK->nCol==1 || db->mallocFailed );
140351 sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1);
140377 # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
140390 ** without the overhead of cross-checking indexes. Quick_check
140393 ** The maximum number of errors is 100 by default. A different default
140418 ** to -1 here, to indicate that the VDBE should verify the integrity
140421 assert( iDb==0 || pId2->z );
140422 if( pId2->z==0 ) iDb = -1;
140425 pParse->nMem = 6;
140430 if( sqlite3GetInt32(pValue->z, &mxErr) ){
140436 iDb>=0 ? db->aDb[iDb].zDbSName : 0);
140439 sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
140442 for(i=0; i<db->nDb; i++){
140452 pParse->okConstFactor = 0; /* tag-20230327-1 */
140454 /* Do an integrity check of the B-Tree
140460 pTbls = &db->aDb[i].pSchema->tblHash;
140467 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
140479 if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum;
140480 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140481 aRoot[++cnt] = pIdx->tnum;
140490 /* Do the b-tree integrity checks */
140495 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zDbSName),
140513 for(pIdx=pTab->pIndex; ALWAYS(pIdx); pIdx=pIdx->pNext){
140518 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
140519 if( pIdx->pPartIdxWhere==0 ){
140522 sqlite3VdbeLoadString(v, 4, pIdx->zName);
140539 int r1 = -1;
140542 int mxCol; /* Maximum non-virtual column number */
140551 r2 = sqlite3GetTempRange(pParse, pPk->nKeyCol);
140552 sqlite3VdbeAddOp3(v, OP_Null, 1, r2, r2+pPk->nKeyCol-1);
140557 ** reg[8+i] counts the number of entries in the i-th index
140560 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
140563 assert( pParse->nMem>=8+j );
140568 /* Fetch the right-most column from the table. This will cause
140575 mxCol = -1;
140576 for(j=0; j<pTab->nCol; j++){
140577 if( (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)==0 ) mxCol++;
140579 if( mxCol==pTab->iPKey ) mxCol--;
140582 ** PK index column-count, so there is no need to account for them
140584 mxCol = sqlite3PrimaryKeyIndex(pTab)->nColumn-1;
140596 a1 = sqlite3VdbeAddOp4Int(v, OP_IdxGT, iDataCur, 0,r2,pPk->nKeyCol);
140601 pTab->zName);
140606 for(j=0; j<pPk->nKeyCol; j++){
140614 ** (2) Datatype must be exact for non-ANY columns in STRICT tables
140615 ** (3) Datatype for TEXT columns in non-STRICT tables must be
140617 ** (4) Datatype for numeric columns in non-STRICT tables must not
140620 bStrict = (pTab->tabFlags & TF_Strict)!=0;
140621 for(j=0; j<pTab->nCol; j++){
140623 Column *pCol = pTab->aCol + j; /* The column to be checked */
140629 if( j==pTab->iPKey ) continue;
140631 doTypeCheck = pCol->eCType>COLTYPE_ANY;
140633 doTypeCheck = pCol->affinity>SQLITE_AFF_BLOB;
140635 if( pCol->notNull==0 && !doTypeCheck ) continue;
140639 if( pCol->colFlags & COLFLAG_VIRTUAL ){
140641 p1 = -1;
140644 if( pCol->iDflt ){
140647 pCol->affinity, &pDfltValue);
140665 if( pCol->notNull ){
140684 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
140685 pCol->zCnName);
140696 /* (2) Datatype must be exact for non-ANY columns in STRICT tables*/
140706 assert( pCol->eCType>=1 && pCol->eCType<=sizeof(aStdTypeMask) );
140707 sqlite3VdbeChangeP5(v, aStdTypeMask[pCol->eCType-1]);
140709 zErr = sqlite3MPrintf(db, "non-%s value in %s.%s",
140710 sqlite3StdType[pCol->eCType-1],
140711 pTab->zName, pTab->aCol[j].zCnName);
140713 }else if( !bStrict && pCol->affinity==SQLITE_AFF_TEXT ){
140714 /* (3) Datatype for TEXT columns in non-STRICT tables must be
140720 pTab->zName, pTab->aCol[j].zCnName);
140722 }else if( !bStrict && pCol->affinity>=SQLITE_AFF_NUMERIC ){
140723 /* (4) Datatype for numeric columns in non-STRICT tables must not
140732 sqlite3VdbeAddOp4Int(v, OP_IsType, -1, labelOk, 3, p4);
140736 pTab->zName, pTab->aCol[j].zCnName);
140744 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
140745 ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0);
140746 if( db->mallocFailed==0 ){
140751 pParse->iSelfTab = iDataCur + 1;
140752 for(k=pCheck->nExpr-1; k>0; k--){
140753 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
140755 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
140758 pParse->iSelfTab = 0;
140760 pTab->zName);
140769 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
140780 pIdx->nColumn); VdbeCoverage(v);
140785 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
140797 jmp7 = sqlite3VdbeAddOp3(v, OP_Eq, 3, 0, r1+pIdx->nColumn-1);
140800 "rowid not at end-of-record for row ");
140803 sqlite3VdbeGoto(v, jmp5-1);
140807 /* Any indexed columns with non-BINARY collations must still hold
140810 for(kk=0; kk<pIdx->nKeyCol; kk++){
140811 if( pIdx->azColl[kk]==sqlite3StrBINARY ) continue;
140822 sqlite3VdbeGoto(v, jmp5-1);
140832 for(kk=0; kk<pIdx->nKeyCol; kk++){
140833 int iCol = pIdx->aiColumn[kk];
140834 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
140835 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
140843 pIdx->nKeyCol); VdbeCoverage(v);
140844 sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
140853 sqlite3VdbeJumpHere(v, loopTop-1);
140856 sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol);
140871 if( pTab->nCol<=0 ){
140872 const char *zMod = pTab->u.vtab.azArg[0];
140873 if( sqlite3HashFind(&db->aModule, zMod)==0 ) continue;
140876 if( pTab->u.vtab.p==0 ) continue;
140877 pVTab = pTab->u.vtab.p->pVtab;
140879 if( NEVER(pVTab->pModule==0) ) continue;
140880 if( pVTab->pModule->iVersion<4 ) continue;
140881 if( pVTab->pModule->xIntegrity==0 ) continue;
140883 pTab->nTabRef++;
140907 aOp[0].p2 = 1-mxErr;
140913 sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2);
140922 ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
140927 ** The second form of this pragma is a no-op if the main database file
140948 { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */
140949 { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */
140950 { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */
140953 { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
140963 returnSingleText(v, encnames[ENC(pParse->db)].zName);
140970 if( (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
140971 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
140972 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
140973 u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
140979 if( !pEnc->zName ){
141004 ** the value of the schema-version and user-version, respectively. Both
141005 ** the schema-version and the user-version are 32-bit signed integers
141008 ** The schema-cookie is usually only manipulated internally by SQLite. It
141015 ** the schema-version is potentially dangerous and may lead to program
141018 ** The user-version is not used internally by SQLite. It may be used by
141022 int iCookie = pPragma->iArg; /* Which cookie to read or write */
141024 if( zRight && (pPragma->mPragFlg & PragFlg_ReadOnly)==0 ){
141039 if( iCookie==BTREE_SCHEMA_VERSION && (db->flags & SQLITE_Defensive)!=0 ){
141041 ** mode. Change the OP_SetCookie opcode into a no-op. */
141068 ** Return the names of all compile-time options used in this build,
141074 pParse->nMem = 1;
141091 int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
141102 pParse->nMem = 3;
141121 db->xWalCallback==sqlite3WalDefaultHook ?
141122 SQLITE_PTR_TO_INT(db->pWalArg) : 0);
141130 ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database
141163 ** SQLITE_DEFAULT_OPTIMIZE_LIMIT compile-time option.
141165 ** currently (2024-02-19) set to 2000, which is such that
141166 ** the worst case run-time for PRAGMA optimize on a 100MB
141167 ** database will usually be less than 100 milliseconds on
141168 ** a RaspberryPI-4 class machine. On by default.
141195 ** (4c) The query planner used sqlite_stat1-style statistics for one
141203 ** 10-fold. In other words, the current size of the table is
141235 }else if( db->nAnalysisLimit>0
141236 && db->nAnalysisLimit<SQLITE_DEFAULT_OPTIMIZE_LIMIT ){
141241 iTabCur = pParse->nTab++;
141242 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
141245 pSchema = db->aDb[iDb].pSchema;
141246 for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
141253 if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
141256 ** If any index is unanalyzed, then the threshold is -1 to
141259 szThreshold = pTab->nRowLogEst;
141261 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
141263 if( !pIdx->hasStat1 ){
141264 szThreshold = -1; /* Always analyze if any index lacks statistics */
141271 if( (pTab->tabFlags & TF_MaybeReanalyze)!=0 ){
141275 }else if( pTab->pIndex!=0 && szThreshold<0 ){
141298 szThreshold>=iRange ? szThreshold-iRange : -1,
141307 db->aDb[iDb].zDbSName, pTab->zName);
141321 ** the analysis_limit to avoid excess run-time in the worst case.
141323 if( !db->mallocFailed && nLimit>0 && nBtree>100 ){
141326 nLimit = 100*nLimit/nBtree;
141327 if( nLimit<100 ) nLimit = 100;
141347 assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT );
141351 returnSingleInt(v, db->busyTimeout);
141359 ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the
141361 ** specified and is a non-negative integer.
141362 ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always
141364 ** sqlite3_soft_heap_limit64(-1) C-language function.
141371 returnSingleInt(v, sqlite3_soft_heap_limit64(-1));
141382 ** sqlite3_hard_heap_limit64() C-language API can raise or deactivate
141389 sqlite3_int64 iPrior = sqlite3_hard_heap_limit64(-1);
141392 returnSingleInt(v, sqlite3_hard_heap_limit64(-1));
141411 returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
141425 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */
141428 db->nAnalysisLimit = (int)(N&0x7fffffff);
141430 returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */
141443 pParse->nMem = 2;
141444 for(i=0; i<db->nDb; i++){
141448 if( db->aDb[i].zDbSName==0 ) continue;
141449 pBt = db->aDb[i].pBt;
141452 }else if( sqlite3_file_control(db, i ? db->aDb[i].zDbSName : 0,
141456 sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState);
141464 if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
141473 /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only
141478 if( (pPragma->mPragFlg & PragFlg_NoColumns1) && zRight ){
141494 sqlite3_vtab base; /* Base class. Must be first */
141501 sqlite3_vtab_cursor base; /* Base class. Must be first */
141529 for(i=0, j=pPragma->iPragCName; i<pPragma->nPragCName; i++, j++){
141534 sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
141538 if( pPragma->mPragFlg & PragFlg_Result1 ){
141542 if( pPragma->mPragFlg & (PragFlg_SchemaOpt|PragFlg_SchemaReq) ){
141548 assert( strlen(zBuf) < sizeof(zBuf)-1 );
141556 pTab->pName = pPragma;
141557 pTab->db = db;
141558 pTab->iHidden = i;
141559 pTab->nHidden = j;
141591 pIdxInfo->estimatedCost = (double)1;
141592 if( pTab->nHidden==0 ){ return SQLITE_OK; }
141593 pConstraint = pIdxInfo->aConstraint;
141596 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
141597 if( pConstraint->iColumn < pTab->iHidden ) continue;
141598 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
141599 if( pConstraint->usable==0 ) return SQLITE_CONSTRAINT;
141600 j = pConstraint->iColumn - pTab->iHidden;
141605 pIdxInfo->estimatedCost = (double)2147483647;
141606 pIdxInfo->estimatedRows = 2147483647;
141609 j = seen[0]-1;
141610 pIdxInfo->aConstraintUsage[j].argvIndex = 1;
141611 pIdxInfo->aConstraintUsage[j].omit = 1;
141612 pIdxInfo->estimatedCost = (double)20;
141613 pIdxInfo->estimatedRows = 20;
141615 j = seen[1]-1;
141616 pIdxInfo->aConstraintUsage[j].argvIndex = 2;
141617 pIdxInfo->aConstraintUsage[j].omit = 1;
141628 pCsr->base.pVtab = pVtab;
141629 *ppCursor = &pCsr->base;
141636 sqlite3_finalize(pCsr->pPragma);
141637 pCsr->pPragma = 0;
141638 pCsr->iRowid = 0;
141639 for(i=0; i<ArraySize(pCsr->azArg); i++){
141640 sqlite3_free(pCsr->azArg[i]);
141641 pCsr->azArg[i] = 0;
141659 pCsr->iRowid++;
141660 assert( pCsr->pPragma );
141661 if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
141662 rc = sqlite3_finalize(pCsr->pPragma);
141663 pCsr->pPragma = 0;
141678 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
141687 j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1;
141690 assert( j<ArraySize(pCsr->azArg) );
141691 assert( pCsr->azArg[j]==0 );
141693 pCsr->azArg[j] = sqlite3_mprintf("%s", zText);
141694 if( pCsr->azArg[j]==0 ){
141699 sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]);
141701 if( pCsr->azArg[1] ){
141702 sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
141704 sqlite3_str_appendall(&acc, pTab->pName->zName);
141705 if( pCsr->azArg[0] ){
141706 sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
141710 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
141713 pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
141724 return (pCsr->pPragma==0);
141736 PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
141737 if( i<pTab->iHidden ){
141738 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
141740 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
141750 *p = pCsr->iRowid;
141757 0, /* xCreate - create a table */
141758 pragmaVtabConnect, /* xConnect - connect to an existing table */
141759 pragmaVtabBestIndex, /* xBestIndex - Determine search strategy */
141760 pragmaVtabDisconnect, /* xDisconnect - Disconnect from a table */
141761 0, /* xDestroy - Drop a table */
141762 pragmaVtabOpen, /* xOpen - open a cursor */
141763 pragmaVtabClose, /* xClose - close a cursor */
141764 pragmaVtabFilter, /* xFilter - configure scan constraints */
141765 pragmaVtabNext, /* xNext - advance a cursor */
141767 pragmaVtabColumn, /* xColumn - read data */
141768 pragmaVtabRowid, /* xRowid - read data */
141769 0, /* xUpdate - write data */
141770 0, /* xBegin - begin transaction */
141771 0, /* xSync - sync transaction */
141772 0, /* xCommit - commit transaction */
141773 0, /* xRollback - rollback transaction */
141774 0, /* xFindFunction - function overloading */
141775 0, /* xRename - rename the table */
141793 if( (pName->mPragFlg & (PragFlg_Result0|PragFlg_Result1))==0 ) return 0;
141794 assert( sqlite3HashFind(&db->aModule, zName)==0 );
141830 sqlite3 *db = pData->db;
141831 if( db->mallocFailed ){
141832 pData->rc = SQLITE_NOMEM_BKPT;
141833 }else if( pData->pzErrMsg[0]!=0 ){
141835 }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){
141841 *pData->pzErrMsg = sqlite3MPrintf(db,
141843 azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1],
141846 pData->rc = SQLITE_ERROR;
141847 }else if( db->flags & SQLITE_WriteSchema ){
141848 pData->rc = SQLITE_CORRUPT_BKPT;
141853 if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
141854 *pData->pzErrMsg = z;
141855 pData->rc = SQLITE_CORRUPT_BKPT;
141866 for(p=pIndex->pTable->pIndex; p; p=p->pNext){
141867 if( p->tnum==pIndex->tnum && p!=pIndex ) return 1;
141875 const char *zSql, /* UTF-8 encoded SQL statement. */
141900 sqlite3 *db = pData->db;
141901 int iDb = pData->iDb;
141905 assert( sqlite3_mutex_held(db->mutex) );
141906 db->mDbFlags |= DBFLAG_EncodingFixed;
141908 pData->nInitRow++;
141909 if( db->mallocFailed ){
141914 assert( iDb>=0 && iDb<db->nDb );
141921 ** But because db->init.busy is set to 1, no VDBE code is generated
141931 u8 saved_iDb = db->init.iDb;
141935 assert( db->init.busy );
141936 db->init.iDb = iDb;
141937 if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0
141938 || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
141944 db->init.orphanTrigger = 0;
141945 db->init.azInit = (const char**)argv;
141947 TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
141948 rc = db->errCode;
141950 db->init.iDb = saved_iDb;
141951 /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
141953 if( db->init.orphanTrigger ){
141956 if( rc > pData->rc ) pData->rc = rc;
141964 db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
141976 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
141980 if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
141981 || pIndex->tnum<2
141982 || pIndex->tnum>pData->mxPage
142013 int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
142015 assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
142016 assert( iDb>=0 && iDb<db->nDb );
142017 assert( db->aDb[iDb].pSchema );
142018 assert( sqlite3_mutex_held(db->mutex) );
142019 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
142021 db->init.busy = 1;
142023 /* Construct the in-memory representation schema tables (sqlite_schema or
142027 ** the schema table as read-only. */
142043 db->mDbFlags &= mask;
142051 pDb = &db->aDb[iDb];
142052 if( pDb->pBt==0 ){
142059 /* If there is not already a read-only (or read-write) transaction opened
142060 ** on the b-tree database, open one now. If a transaction is opened, it
142062 sqlite3BtreeEnter(pDb->pBt);
142063 if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){
142064 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
142079 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
142090 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
142092 if( (db->flags & SQLITE_ResetDatabase)!=0 ){
142095 pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
142097 /* If opening a non-empty database, check the text encoding. For the
142102 if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */
142103 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
142107 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
142112 if( db->nVdbeActive>0 && encoding!=ENC(db)
142113 && (db->mDbFlags & DBFLAG_Vacuum)==0
142122 if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){
142130 pDb->pSchema->enc = ENC(db);
142132 if( pDb->pSchema->cache_size==0 ){
142134 size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
142136 pDb->pSchema->cache_size = size;
142138 pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
142140 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
142146 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
142149 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
142150 if( pDb->pSchema->file_format==0 ){
142151 pDb->pSchema->file_format = 1;
142153 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
142164 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
142165 db->flags &= ~(u64)SQLITE_LegacyFileFmt;
142170 assert( db->init.busy );
142171 initData.mxPage = sqlite3BtreeLastPage(pDb->pBt);
142176 db->aDb[iDb].zDbSName, zSchemaTabName);
142180 xAuth = db->xAuth;
142181 db->xAuth = 0;
142185 db->xAuth = xAuth;
142196 assert( pDb == &(db->aDb[iDb]) );
142197 if( db->mallocFailed ){
142200 pDb = &db->aDb[iDb];
142202 if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){
142223 sqlite3BtreeCommit(pDb->pBt);
142225 sqlite3BtreeLeave(pDb->pBt);
142234 db->init.busy = 0;
142239 ** Initialize all database files - the main database file, the file
142249 int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange);
142251 assert( sqlite3_mutex_held(db->mutex) );
142252 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
142253 assert( db->init.busy==0 );
142255 assert( db->nDb>0 );
142262 for(i=db->nDb-1; i>0; i--){
142263 assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
142276 ** This routine is a no-op if the database schema is already initialized.
142281 sqlite3 *db = pParse->db;
142282 assert( sqlite3_mutex_held(db->mutex) );
142283 if( !db->init.busy ){
142284 rc = sqlite3Init(db, &pParse->zErrMsg);
142286 pParse->rc = rc;
142287 pParse->nErr++;
142288 }else if( db->noSharedCache ){
142289 db->mDbFlags |= DBFLAG_SchemaKnownOk;
142298 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
142299 ** make no changes to pParse->rc.
142302 sqlite3 *db = pParse->db;
142307 assert( pParse->checkSchema );
142308 assert( sqlite3_mutex_held(db->mutex) );
142309 for(iDb=0; iDb<db->nDb; iDb++){
142311 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
142314 /* If there is not already a read-only (or read-write) transaction opened
142315 ** on the b-tree database, open one now. If a transaction is opened, it
142316 ** will be closed immediately after reading the meta-value. */
142321 pParse->rc = SQLITE_NOMEM;
142328 ** value stored as part of the in-memory schema representation,
142332 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
142333 if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;
142346 ** which database file in db->aDb[] the schema refers to.
142352 int i = -32768;
142354 /* If pSchema is NULL, then return -32768. This happens when code in
142356 ** created by a sub-select). In this case the return value of this
142359 ** We return -32768 instead of the more usual -1 simply because using
142360 ** -32768 as the incorrect index into db->aDb[] is much
142361 ** more likely to cause a segfault than -1 (of course there are assert()
142363 ** -32768 will still fit into a 16-bit signed integer.
142365 assert( sqlite3_mutex_held(db->mutex) );
142368 assert( i<db->nDb );
142369 if( db->aDb[i].pSchema==pSchema ){
142373 assert( i>=0 && i<db->nDb );
142382 sqlite3 *db = pParse->db;
142384 assert( db->pParse==pParse );
142385 assert( pParse->nested==0 );
142387 if( pParse->aTableLock ) sqlite3DbNNFreeNN(db, pParse->aTableLock);
142389 while( pParse->pCleanup ){
142390 ParseCleanup *pCleanup = pParse->pCleanup;
142391 pParse->pCleanup = pCleanup->pNext;
142392 pCleanup->xCleanup(db, pCleanup->pPtr);
142395 if( pParse->aLabel ) sqlite3DbNNFreeNN(db, pParse->aLabel);
142396 if( pParse->pConstExpr ){
142397 sqlite3ExprListDelete(db, pParse->pConstExpr);
142399 assert( db->lookaside.bDisable >= pParse->disableLookaside );
142400 db->lookaside.bDisable -= pParse->disableLookaside;
142401 db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
142402 assert( pParse->db->pParse==pParse );
142403 db->pParse = pParse->pOuterParse;
142414 ** common cleanups, we save a single NULL-pointer comparison in
142419 ** pParse->earlyCleanup flag is set in that case. Calling code show verify
142421 ** use-after-free errors following an OOM. The preferred way to do this is
142424 ** testcase( pParse->earlyCleanup );
142442 sqlite3OomFault(pParse->db);
142444 pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
142447 pCleanup->pNext = pParse->pCleanup;
142448 pParse->pCleanup = pCleanup;
142449 pCleanup->pPtr = pPtr;
142450 pCleanup->xCleanup = xCleanup;
142452 xCleanup(pParse->db, pPtr);
142455 pParse->earlyCleanup = 1;
142473 assert( db->pParse!=pParse );
142474 pParse->pOuterParse = db->pParse;
142475 db->pParse = pParse;
142476 pParse->db = db;
142477 if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory");
142489 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
142493 const char *zSql, /* UTF-8 encoded SQL statement. */
142507 sParse.pOuterParse = db->pParse;
142508 db->pParse = &sParse;
142517 if( db->mallocFailed ){
142519 db->errCode = rc = SQLITE_NOMEM;
142522 assert( sqlite3_mutex_held(db->mutex) );
142524 /* For a long-term use prepared statement avoid the use of
142535 ** some other database connection is holding a write-lock, which in
142556 if( !db->noSharedCache ){
142557 for(i=0; i<db->nDb; i++) {
142558 Btree *pBt = db->aDb[i].pBt;
142563 const char *zDb = db->aDb[i].zDbSName;
142565 testcase( db->flags & SQLITE_ReadUncommit );
142573 if( db->pDisconnect ) sqlite3VtabUnlockList(db);
142576 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
142578 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
142589 sParse.zTail = &zSql[sParse.zTail-zSqlCopy];
142603 if( db->init.busy==0 ){
142604 sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags);
142606 if( db->mallocFailed ){
142611 if( sParse.checkSchema && db->init.busy==0 ){
142636 sParse.pTriggerPrg = pT->pNext;
142647 const char *zSql, /* UTF-8 encoded SQL statement. */
142664 sqlite3_mutex_enter(db->mutex);
142672 if( rc==SQLITE_OK || db->mallocFailed ) break;
142674 || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) );
142677 assert( (rc&db->errMask)==rc );
142678 db->busyHandler.nBusy = 0;
142679 sqlite3_mutex_leave(db->mutex);
142700 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
142704 assert( sqlite3_mutex_held(db->mutex) );
142706 rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
142734 const char *zSql, /* UTF-8 encoded SQL statement. */
142746 const char *zSql, /* UTF-8 encoded SQL statement. */
142752 /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
142764 const char *zSql, /* UTF-8 encoded SQL statement. */
142771 /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
142788 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
142792 const void *zSql, /* UTF-16 encoded SQL statement. */
142798 /* This function currently works by first transforming the UTF-16
142799 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
142819 sqlite3_mutex_enter(db->mutex);
142822 rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
142827 ** equivalent pointer into the UTF-16 string by counting the unicode
142829 ** the same number of characters into the UTF-16 string.
142831 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
142836 sqlite3_mutex_leave(db->mutex);
142850 const void *zSql, /* UTF-16 encoded SQL statement. */
142862 const void *zSql, /* UTF-16 encoded SQL statement. */
142874 const void *zSql, /* UTF-16 encoded SQL statement. */
142925 ** The aDefer[] array is used by the sorter-references optimization. For
142935 ** When the sorter-reference optimization is used, there is one entry in the
142944 int regReturn; /* Register holding block-output return address */
142945 int labelBkOut; /* Start label for the block-output subroutine */
142976 Select *pPrior = p->pPrior;
142977 sqlite3ExprListDelete(db, p->pEList);
142978 sqlite3SrcListDelete(db, p->pSrc);
142979 sqlite3ExprDelete(db, p->pWhere);
142980 sqlite3ExprListDelete(db, p->pGroupBy);
142981 sqlite3ExprDelete(db, p->pHaving);
142982 sqlite3ExprListDelete(db, p->pOrderBy);
142983 sqlite3ExprDelete(db, p->pLimit);
142984 if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
142986 if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
142987 sqlite3WindowListDelete(db, p->pWinDefn);
142989 while( p->pWin ){
142990 assert( p->pWin->ppThis==&p->pWin );
142991 sqlite3WindowUnlinkFromSelect(p->pWin);
143004 pDest->eDest = (u8)eDest;
143005 pDest->iSDParm = iParm;
143006 pDest->iSDParm2 = 0;
143007 pDest->zAffSdst = 0;
143008 pDest->iSdst = 0;
143009 pDest->nSdst = 0;
143020 SrcList *pSrc, /* the FROM clause -- which tables to scan */
143030 pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
143032 assert( pParse->db->mallocFailed );
143037 sqlite3Expr(pParse->db,TK_ASTERISK,0));
143039 pNew->pEList = pEList;
143040 pNew->op = TK_SELECT;
143041 pNew->selFlags = selFlags;
143042 pNew->iLimit = 0;
143043 pNew->iOffset = 0;
143044 pNew->selId = ++pParse->nSelect;
143045 pNew->addrOpenEphm[0] = -1;
143046 pNew->addrOpenEphm[1] = -1;
143047 pNew->nSelectRow = 0;
143048 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
143049 pNew->pSrc = pSrc;
143050 pNew->pWhere = pWhere;
143051 pNew->pGroupBy = pGroupBy;
143052 pNew->pHaving = pHaving;
143053 pNew->pOrderBy = pOrderBy;
143054 pNew->pPrior = 0;
143055 pNew->pNext = 0;
143056 pNew->pLimit = pLimit;
143057 pNew->pWith = 0;
143059 pNew->pWin = 0;
143060 pNew->pWinDefn = 0;
143062 if( pParse->db->mallocFailed ) {
143063 clearSelect(pParse->db, pNew, pNew!=&standin);
143066 assert( pNew->pSrc!=0 || pParse->nErr>0 );
143083 ** Return a pointer to the right-most SELECT statement in a compound.
143086 while( p->pNext ) p = p->pNext;
143111 ** ------- ----- ----- ------------
143112 ** CROSS - - JT_CROSS
143113 ** INNER - - JT_INNER
143114 ** LEFT - - JT_LEFT|JT_OUTER
143115 ** LEFT OUTER - JT_LEFT|JT_OUTER
143116 ** RIGHT - - JT_RIGHT|JT_OUTER
143117 ** RIGHT OUTER - JT_RIGHT|JT_OUTER
143118 ** FULL - - JT_LEFT|JT_RIGHT|JT_OUTER
143119 ** FULL OUTER - JT_LEFT|JT_RIGHT|JT_OUTER
143120 ** NATURAL INNER - JT_NATURAL|JT_INNER
143121 ** NATURAL LEFT - JT_NATURAL|JT_LEFT|JT_OUTER
143123 ** NATURAL RIGHT - JT_NATURAL|JT_RIGHT|JT_OUTER
143125 ** NATURAL FULL - JT_NATURAL|JT_LEFT|JT_RIGHT
143129 ** of other non-standard and in many cases nonsensical join types.
143134 ** INNER CROSS JOIN -> same as JOIN
143135 ** NATURAL CROSS JOIN -> same as NATURAL JOIN
143136 ** OUTER LEFT JOIN -> same as LEFT JOIN
143137 ** LEFT NATURAL JOIN -> same as NATURAL LEFT JOIN
143138 ** LEFT RIGHT JOIN -> same as FULL JOIN
143139 ** RIGHT OUTER FULL JOIN -> same as FULL JOIN
143140 ** CROSS CROSS CROSS JOIN -> same as JOIN
143179 if( p->n==aKeyword[j].nChar
143180 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
143208 ** Return the index of a column in a table. Return -1 if the column
143215 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
143216 if( pCol->hName==h && sqlite3StrICmp(pCol->zCnName, zCol)==0 ) return i;
143218 return -1;
143226 assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
143227 if( pItem->fg.isNestedFrom ){
143229 assert( pItem->pSelect!=0 );
143230 pResults = pItem->pSelect->pEList;
143232 assert( iCol>=0 && iCol<pResults->nExpr );
143233 pResults->a[iCol].fg.bUsed = 1;
143239 ** table that has a column named zCol. The search is left-to-right.
143249 int iStart, /* First member of pSrc->a[] to check */
143250 int iEnd, /* Last member of pSrc->a[] to check */
143252 int *piTab, /* Write index of pSrc->a[] here */
143253 int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
143259 assert( iEnd<pSrc->nSrc );
143264 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
143266 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
143269 sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
143311 p->w.iJoin = iTable;
143312 if( p->op==TK_FUNCTION ){
143314 if( p->x.pList ){
143316 for(i=0; i<p->x.pList->nExpr; i++){
143317 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
143321 sqlite3SetJoinExpr(p->pLeft, iTable, joinFlag);
143322 p = p->pRight;
143342 if( iTable<0 || (ExprHasProperty(p, EP_OuterON) && p->w.iJoin==iTable) ){
143346 if( p->op==TK_COLUMN && p->iTable==iTable && !nullable ){
143349 if( p->op==TK_FUNCTION ){
143351 assert( p->pLeft==0 );
143352 if( p->x.pList ){
143354 for(i=0; i<p->x.pList->nExpr; i++){
143355 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
143359 unsetJoinExpr(p->pLeft, iTable, nullable);
143360 p = p->pRight;
143377 ** The left most table is the first entry in Select.pSrc. The right-most
143391 pSrc = p->pSrc;
143392 pLeft = &pSrc->a[0];
143394 for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
143395 Table *pRightTab = pRight->pTab;
143398 if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue;
143399 joinType = (pRight->fg.jointype & JT_OUTER)!=0 ? EP_OuterON : EP_InnerON;
143404 if( pRight->fg.jointype & JT_NATURAL ){
143406 if( pRight->fg.isUsing || pRight->u3.pOn ){
143411 for(j=0; j<pRightTab->nCol; j++){
143414 if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue;
143415 zName = pRightTab->aCol[j].zCnName;
143419 assert( pUsing->nId>0 );
143420 assert( pUsing->a[pUsing->nId-1].zName==0 );
143421 pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName);
143426 pRight->fg.isUsing = 1;
143427 pRight->fg.isSynthUsing = 1;
143428 pRight->u3.pUsing = pUsing;
143430 if( pParse->nErr ) return 1;
143440 if( pRight->fg.isUsing ){
143441 IdList *pList = pRight->u3.pUsing;
143442 sqlite3 *db = pParse->db;
143444 for(j=0; j<pList->nId; j++){
143453 zName = pList->a[j].zName;
143457 pRight->fg.isSynthUsing)==0
143459 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
143464 sqlite3SrcItemColumnUsed(&pSrc->a[iLeft], iLeftCol);
143465 if( (pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){
143468 ** contains the zName column, then this branch is a no-op.
143475 ** non-USING references to zName on the left of an INNER or LEFT
143482 pRight->fg.isSynthUsing)!=0 ){
143483 if( pSrc->a[iLeft].fg.isUsing==0
143484 || sqlite3IdListIndex(pSrc->a[iLeft].u3.pUsing, zName)<0
143492 sqlite3SrcItemColumnUsed(&pSrc->a[iLeft], iLeftCol);
143507 pEq->w.iJoin = pE2->iTable;
143509 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pEq);
143516 else if( pRight->u3.pOn ){
143517 sqlite3SetJoinExpr(pRight->u3.pOn, pRight->iCursor, joinType);
143518 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->u3.pOn);
143519 pRight->u3.pOn = 0;
143520 pRight->fg.isOn = 1;
143549 sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
143550 0, pInfo->ecelFlags);
143552 if( pInfo->pExtra ){
143553 sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
143554 sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
143572 int nOBSat = pSort->nOBSat;
143573 Vdbe *v = pParse->pVdbe;
143574 int regOut = ++pParse->nMem;
143575 if( pSort->pDeferredRowLoad ){
143576 innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
143578 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
143584 ** through regData+nData-1 onto the sorter.
143595 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
143596 int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);
143597 int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */
143601 int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */
143624 pSort->addrPush = sqlite3VdbeCurrentAddr(v);
143629 regBase = regData - nPrefixReg;
143631 regBase = pParse->nMem + 1;
143632 pParse->nMem += nBase;
143634 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
143635 iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
143636 pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
143637 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
143640 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
143654 regPrevKey = pParse->nMem+1;
143655 pParse->nMem += pSort->nOBSat;
143656 nKey = nExpr - pSort->nOBSat + bSeq;
143660 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
143663 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
143664 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
143665 if( pParse->db->mallocFailed ) return;
143666 pOp->p2 = nKey + nData;
143667 pKI = pOp->p4.pKeyInfo;
143668 memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */
143669 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
143670 testcase( pKI->nAllField > pKI->nKeyField+2 );
143671 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
143672 pKI->nAllField-pKI->nKeyField-1);
143676 pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
143677 pSort->regReturn = ++pParse->nMem;
143678 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
143679 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
143681 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
143685 sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
143699 ** jump to the next iteration of the loop. If the pSort->labelOBLopt
143704 int iCsr = pSort->iECursor;
143709 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
143716 if( pSort->sortFlags & SORTFLAG_UseSorter ){
143721 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
143722 regBase+nOBSat, nBase-nOBSat);
143725 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
143728 pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1;
143798 int nResultCol = pEList->nExpr;
143799 Vdbe *v = pParse->pVdbe;
143808 iRet = regPrev = pParse->nMem+1;
143809 pParse->nMem += nResultCol;
143813 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
143814 if( i<nResultCol-1 ){
143821 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
143824 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
143825 sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1);
143860 ** No adjustments necessary. This function is a no-op.
143879 if( pParse->nErr==0
143882 Vdbe *v = pParse->pVdbe;
143884 if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){
143893 pOp->opcode = OP_Null;
143894 pOp->p1 = 1;
143895 pOp->p2 = iVal;
143902 ** This function is called as part of inner-loop generation for a SELECT
143904 ** determines the expressions, if any, that the sorter-reference
143905 ** optimization should be used for. The sorter-reference optimization
143918 ** for which the sorter-reference optimization should be enabled.
143919 ** Additionally, the pSort->aDefer[] array is populated with entries
143934 for(i=0; i<pEList->nExpr; i++){
143935 struct ExprList_item *pItem = &pEList->a[i];
143936 if( pItem->u.x.iOrderByCol==0 ){
143937 Expr *pExpr = pItem->pExpr;
143939 if( pExpr->op==TK_COLUMN
143940 && pExpr->iColumn>=0
143942 && (pTab = pExpr->y.pTab)!=0
143944 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
143948 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
143951 if( nDefer==ArraySize(pSort->aDefer) ){
143959 nKey = pPk->nKeyCol;
143964 pNew->iTable = pExpr->iTable;
143966 pNew->y.pTab = pExpr->y.pTab;
143967 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
143971 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
143972 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
143973 pSort->aDefer[nDefer].nKey = nKey;
143977 pItem->fg.bSorterRef = 1;
143981 pSort->nDefer = (u8)nDefer;
143990 ** If srcTab is negative, then the p->pEList expressions
143992 ** zero or more, then data is pulled from srcTab and p->pEList is used only
143998 int srcTab, /* Pull data from this table if non-negative */
144005 Vdbe *v = pParse->pVdbe;
144008 int eDest = pDest->eDest; /* How to dispose of results */
144009 int iParm = pDest->iSDParm; /* First argument to disposal method */
144017 ** values for any expressions that are also part of the sort-key are omitted
144023 assert( p->pEList!=0 );
144024 hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
144025 if( pSort && pSort->pOrderBy==0 ) pSort = 0;
144028 codeOffset(v, p->iOffset, iContinue);
144033 nResultCol = p->pEList->nExpr;
144035 if( pDest->iSdst==0 ){
144037 nPrefixReg = pSort->pOrderBy->nExpr;
144038 if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;
144039 pParse->nMem += nPrefixReg;
144041 pDest->iSdst = pParse->nMem+1;
144042 pParse->nMem += nResultCol;
144043 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
144045 ** on the right-hand side of an INSERT contains more result columns than
144049 pParse->nMem += nResultCol;
144051 pDest->nSdst = nResultCol;
144052 regOrig = regResult = pDest->iSdst;
144056 VdbeComment((v, "%s", p->pEList->a[i].zEName));
144073 /* For each expression in p->pEList that is a copy of an expression in
144074 ** the ORDER BY clause (pSort->pOrderBy), set the associated
144076 ** expression within the sort-key that pushOntoSorter() will generate.
144077 ** This allows the p->pEList field to be omitted from the sorted record,
144081 for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
144083 if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
144084 p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
144088 selectExprDefer(pParse, pSort, p->pEList, &pExtra);
144089 if( pExtra && pParse->db->mallocFailed==0 ){
144095 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
144096 pOp->p2 += (pExtra->nExpr - pSort->nDefer);
144097 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
144098 pParse->nMem += pExtra->nExpr;
144104 pEList = p->pEList;
144105 for(i=0; i<pEList->nExpr; i++){
144106 if( pEList->a[i].u.x.iOrderByCol>0
144108 || pEList->a[i].fg.bSorterRef
144111 nResultCol--;
144130 if( pExtra ) nResultCol += pExtra->nExpr;
144132 if( p->iLimit
144138 pSort->pDeferredRowLoad = &sRowLoadInfo;
144150 int eType = pDistinct->eTnctType;
144151 int iTab = pDistinct->tabTnct;
144152 assert( nResultCol==p->pEList->nExpr );
144153 iTab = codeDistinct(pParse, eType, iTab, iContinue, p->pEList, regResult);
144154 fixDistinctOpenEph(pParse, eType, iTab, pDistinct->addrTnct);
144156 codeOffset(v, p->iOffset, iContinue);
144197 /* A destination of SRT_Table and a non-zero iSDParm2 parameter means
144200 ** This does not affect operation in any way - it just allows MakeRecord
144202 if( eDest==SRT_Table && pDest->iSDParm2 ){
144239 int i2 = pDest->iSDParm2;
144248 regResult+(i2<0), nResultCol-(i2<0), r1);
144273 assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );
144275 r1, pDest->zAffSdst, nResultCol);
144297 assert( nResultCol<=pDest->nSdst );
144301 assert( nResultCol==pDest->nSdst );
144309 case SRT_Coroutine: /* Send data to a co-routine */
144317 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
144326 ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an
144327 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
144328 ** pSO->nExpr columns, then make sure all keys are unique by adding a
144337 pSO = pDest->pOrderBy;
144339 nKey = pSO->nExpr;
144358 regResult + pSO->a[i].u.x.iOrderByCol - 1,
144376 ** user-defined functions that have side effects. We do not care
144390 if( pSort==0 && p->iLimit ){
144391 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
144400 int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
144403 p->aSortFlags = (u8*)&p->aColl[N+X];
144404 p->nKeyField = (u16)N;
144405 p->nAllField = (u16)(N+X);
144406 p->enc = ENC(db);
144407 p->db = db;
144408 p->nRef = 1;
144421 assert( p->db!=0 );
144422 assert( p->nRef>0 );
144423 p->nRef--;
144424 if( p->nRef==0 ) sqlite3DbNNFreeNN(p->db, p);
144433 assert( p->nRef>0 );
144434 p->nRef++;
144446 SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
144472 sqlite3 *db = pParse->db;
144475 nExpr = pList->nExpr;
144476 pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
144479 for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
144480 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
144481 pInfo->aSortFlags[i-iStart] = pItem->fg.sortFlags;
144504 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
144507 ** "USE TEMP B-TREE FOR xxx"
144513 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
144517 ** Assign expression b to lvalue a. A second, no-op, version of this macro
144526 /* No-op versions of the explainXXX() functions and macros. */
144533 ** If the inner loop was generated using a non-null pOrderBy argument,
144545 Vdbe *v = pParse->pVdbe; /* The prepared statement */
144546 int addrBreak = pSort->labelDone; /* Jump here to exit loop */
144551 ExprList *pOrderBy = pSort->pOrderBy;
144552 int eDest = pDest->eDest;
144553 int iParm = pDest->iSDParm;
144562 struct ExprList_item *aOutEx = p->pEList->a;
144567 nKey = pOrderBy->nExpr - pSort->nOBSat;
144568 if( pSort->nOBSat==0 || nKey==1 ){
144570 "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat?"LAST TERM OF ":""
144574 "USE TEMP B-TREE FOR LAST %d TERMS OF ORDER BY", nKey
144577 sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);
144578 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);
144582 if( pSort->labelBkOut ){
144583 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
144585 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
144589 /* Open any cursors needed for sorter-reference expressions */
144590 for(i=0; i<pSort->nDefer; i++){
144591 Table *pTab = pSort->aDefer[i].pTab;
144592 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
144593 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
144594 nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
144598 iTab = pSort->iECursor;
144600 if( eDest==SRT_Mem && p->iOffset ){
144601 sqlite3VdbeAddOp2(v, OP_Null, 0, pDest->iSdst);
144604 regRow = pDest->iSdst;
144614 if( pSort->sortFlags & SORTFLAG_UseSorter ){
144615 int regSortOut = ++pParse->nMem;
144616 iSortTab = pParse->nTab++;
144617 if( pSort->labelBkOut ){
144625 assert( p->iLimit==0 && p->iOffset==0 );
144630 codeOffset(v, p->iOffset, addrContinue);
144633 if( p->iOffset>0 ){
144634 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
144637 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
144644 if( pSort->nDefer ){
144648 for(i=0; i<pSort->nDefer; i++){
144649 int iCsr = pSort->aDefer[i].iCsr;
144650 Table *pTab = pSort->aDefer[i].pTab;
144651 int nKey = pSort->aDefer[i].nKey;
144661 assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
144674 for(i=nColumn-1; i>=0; i--){
144683 iRead = aOutEx[i].u.x.iOrderByCol-1;
144685 iRead = iCol--;
144691 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
144703 assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) );
144705 pDest->zAffSdst, nColumn);
144715 int i2 = pDest->iSDParm2;
144717 sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1);
144730 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
144732 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
144748 if( pSort->sortFlags & SORTFLAG_UseSorter ){
144753 sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1);
144754 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
144766 ** result-set expression in all of the following SELECT statements is
144777 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
144804 assert( pNC->pSrcList!=0 );
144805 switch( pExpr->op ){
144813 int iCol = pExpr->iColumn; /* Index of column in pTab */
144815 SrcList *pTabList = pNC->pSrcList;
144816 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
144817 if( j<pTabList->nSrc ){
144818 pTab = pTabList->a[j].pTab;
144819 pS = pTabList->a[j].pSelect;
144821 pNC = pNC->pNext;
144836 ** sub-select. In this case, set the column type to NULL, even
144846 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
144848 /* The "table" is actually a sub-select or a view in the FROM clause
144850 ** data for the result-set column of the sub-select.
144852 if( iCol<pS->pEList->nExpr
144856 ** rowid of the sub-select or view. This expression is legal (see
144857 ** test case misc2.2.2) - it always evaluates to NULL.
144860 Expr *p = pS->pEList->a[iCol].pExpr;
144861 sNC.pSrcList = pS->pSrc;
144863 sNC.pParse = pNC->pParse;
144870 if( iCol<0 ) iCol = pTab->iPKey;
144871 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144876 zOrigCol = pTab->aCol[iCol].zCnName;
144877 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
144879 zOrigTab = pTab->zName;
144880 if( pNC->pParse && pTab->pSchema ){
144881 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
144882 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
144885 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144889 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
144897 /* The expression is a sub-select. Return the declaration type and
144905 pS = pExpr->x.pSelect;
144906 p = pS->pEList->a[0].pExpr;
144907 sNC.pSrcList = pS->pSrc;
144909 sNC.pParse = pNC->pParse;
144937 Vdbe *v = pParse->pVdbe;
144943 for(i=0; i<pEList->nExpr; i++){
144944 Expr *p = pEList->a[i].pExpr;
144952 /* The vdbe must make its own copy of the column-type and other
145002 Vdbe *v = pParse->pVdbe;
145007 sqlite3 *db = pParse->db;
145011 if( pParse->colNamesSet ) return;
145012 /* Column names are determined by the left-most term of a compound select */
145013 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145015 pTabList = pSelect->pSrc;
145016 pEList = pSelect->pEList;
145019 pParse->colNamesSet = 1;
145020 fullName = (db->flags & SQLITE_FullColNames)!=0;
145021 srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName;
145022 sqlite3VdbeSetNumCols(v, pEList->nExpr);
145023 for(i=0; i<pEList->nExpr; i++){
145024 Expr *p = pEList->a[i].pExpr;
145027 assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */
145028 assert( p->op!=TK_COLUMN
145029 || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */
145030 if( pEList->a[i].zEName && pEList->a[i].fg.eEName==ENAME_NAME ){
145032 char *zName = pEList->a[i].zEName;
145034 }else if( srcName && p->op==TK_COLUMN ){
145036 int iCol = p->iColumn;
145037 pTab = p->y.pTab;
145039 if( iCol<0 ) iCol = pTab->iPKey;
145040 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
145044 zCol = pTab->aCol[iCol].zCnName;
145048 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
145054 const char *z = pEList->a[i].zEName;
145090 sqlite3 *db = pParse->db; /* Database connection */
145102 nCol = pEList->nExpr;
145114 for(i=0, pCol=aCol; i<nCol && !pParse->nErr; i++, pCol++){
145115 struct ExprList_item *pX = &pEList->a[i];
145119 if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){
145122 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
145123 while( ALWAYS(pColExpr!=0) && pColExpr->op==TK_DOT ){
145124 pColExpr = pColExpr->pRight;
145127 if( pColExpr->op==TK_COLUMN
145129 && ALWAYS( pColExpr->y.pTab!=0 )
145132 int iCol = pColExpr->iColumn;
145133 pTab = pColExpr->y.pTab;
145134 if( iCol<0 ) iCol = pTab->iPKey;
145135 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
145136 }else if( pColExpr->op==TK_ID ){
145138 zName = pColExpr->u.zToken;
145141 assert( zName==pX->zEName ); /* pointer comparison intended */
145155 if( pCollide->fg.bUsingTerm ){
145156 pCol->colFlags |= COLFLAG_NOEXPAND;
145160 for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){}
145169 pCol->zCnName = zName;
145170 pCol->hName = sqlite3StrIHash(zName);
145171 if( pX->fg.bNoExpand ){
145172 pCol->colFlags |= COLFLAG_NOEXPAND;
145180 if( pParse->nErr ){
145187 return pParse->rc;
145209 sqlite3 *db = pParse->db;
145218 assert( (pSelect->selFlags & SF_Resolved)!=0 );
145219 assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
145221 if( db->mallocFailed || IN_RENAME_OBJECT ) return;
145222 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145223 a = pSelect->pEList->a;
145225 sNC.pSrcList = pSelect->pSrc;
145226 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
145231 pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
145233 /* pCol->szEst = ... // Column size est for SELECT tables never used */
145234 pCol->affinity = sqlite3ExprAffinity(p);
145235 while( pCol->affinity<=SQLITE_AFF_NONE && pS2->pNext!=0 ){
145236 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
145237 pS2 = pS2->pNext;
145238 pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
145240 if( pCol->affinity<=SQLITE_AFF_NONE ){
145241 pCol->affinity = aff;
145243 if( pCol->affinity>=SQLITE_AFF_TEXT && (pS2->pNext || pS2!=pSelect) ){
145244 for(pS2=pS2->pNext; pS2; pS2=pS2->pNext){
145245 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
145247 if( pCol->affinity==SQLITE_AFF_TEXT && (m&0x01)!=0 ){
145248 pCol->affinity = SQLITE_AFF_BLOB;
145250 if( pCol->affinity>=SQLITE_AFF_NUMERIC && (m&0x02)!=0 ){
145251 pCol->affinity = SQLITE_AFF_BLOB;
145253 if( pCol->affinity>=SQLITE_AFF_NUMERIC && p->op==TK_CAST ){
145254 pCol->affinity = SQLITE_AFF_FLEXNUM;
145258 if( zType==0 || pCol->affinity!=sqlite3AffinityType(zType, 0) ){
145259 if( pCol->affinity==SQLITE_AFF_NUMERIC
145260 || pCol->affinity==SQLITE_AFF_FLEXNUM
145266 if( sqlite3StdTypeAffinity[j]==pCol->affinity ){
145275 n = sqlite3Strlen30(pCol->zCnName);
145276 pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+k+2);
145277 pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL);
145278 if( pCol->zCnName ){
145279 memcpy(&pCol->zCnName[n+1], zType, k+1);
145280 pCol->colFlags |= COLFLAG_HASTYPE;
145285 assert( pTab->pIndex==0 );
145286 sqlite3ColumnSetColl(db, pCol, pColl->zName);
145289 pTab->szTabRow = 1; /* Any non-zero value works */
145298 sqlite3 *db = pParse->db;
145301 savedFlags = db->flags;
145302 db->flags &= ~(u64)SQLITE_FullColNames;
145303 db->flags |= SQLITE_ShortColNames;
145305 db->flags = savedFlags;
145306 if( pParse->nErr ) return 0;
145307 while( pSelect->pPrior ) pSelect = pSelect->pPrior;
145312 pTab->nTabRef = 1;
145313 pTab->zName = 0;
145314 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
145315 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
145317 pTab->iPKey = -1;
145318 if( db->mallocFailed ){
145330 if( pParse->pVdbe ){
145331 return pParse->pVdbe;
145333 if( pParse->pToplevel==0
145334 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
145336 pParse->okConstFactor = 1;
145344 ** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions
145352 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
145360 ** Only if pLimit->pLeft!=0 do the limit registers get
145370 Expr *pLimit = p->pLimit;
145372 if( p->iLimit ) return;
145375 ** "LIMIT -1" always shows all rows. There is some
145381 assert( pLimit->op==TK_LIMIT );
145382 assert( pLimit->pLeft!=0 );
145383 p->iLimit = iLimit = ++pParse->nMem;
145386 if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){
145391 }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){
145392 p->nSelectRow = sqlite3LogEst((u64)n);
145393 p->selFlags |= SF_FixedLimit;
145396 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
145401 if( pLimit->pRight ){
145402 p->iOffset = iOffset = ++pParse->nMem;
145403 pParse->nMem++; /* Allocate an extra register for limit+offset */
145404 sqlite3ExprCode(pParse, pLimit->pRight, iOffset);
145415 ** Return the appropriate collating sequence for the iCol-th column of
145416 ** the result set for the compound-select statement "p". Return NULL if
145420 ** left-most term of the select that has a collating sequence.
145424 if( p->pPrior ){
145425 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
145430 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
145433 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
145434 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
145449 ExprList *pOrderBy = p->pOrderBy;
145450 int nOrderBy = ALWAYS(pOrderBy!=0) ? pOrderBy->nExpr : 0;
145451 sqlite3 *db = pParse->db;
145456 struct ExprList_item *pItem = &pOrderBy->a[i];
145457 Expr *pTerm = pItem->pExpr;
145460 if( pTerm->flags & EP_Collate ){
145463 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
145464 if( pColl==0 ) pColl = db->pDfltColl;
145465 pOrderBy->a[i].pExpr =
145466 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
145469 pRet->aColl[i] = pColl;
145470 pRet->aSortFlags[i] = pOrderBy->a[i].fg.sortFlags;
145482 ** <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
145484 ** p->pPrior p
145487 ** There is exactly one reference to the recursive-table in the FROM clause
145488 ** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
145490 ** The setup-query runs once to generate an initial set of rows that go
145494 ** recursive-table for a recursive-query run. The output of the recursive-query
145519 SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */
145520 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
145521 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
145523 Select *pFirstRec; /* Left-most recursive term */
145539 if( p->pWin ){
145550 p->nSelectRow = 320; /* 4 billion rows */
145552 pLimit = p->pLimit;
145553 regLimit = p->iLimit;
145554 regOffset = p->iOffset;
145555 p->pLimit = 0;
145556 p->iLimit = p->iOffset = 0;
145557 pOrderBy = p->pOrderBy;
145560 for(i=0; ALWAYS(i<pSrc->nSrc); i++){
145561 if( pSrc->a[i].fg.isRecursive ){
145562 iCurrent = pSrc->a[i].iCursor;
145570 iQueue = pParse->nTab++;
145571 if( p->op==TK_UNION ){
145573 iDistinct = pParse->nTab++;
145580 regCurrent = ++pParse->nMem;
145584 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
145592 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
145593 p->selFlags |= SF_UsesEphemeral;
145597 p->pOrderBy = 0;
145603 ** iDistinct table. pFirstRec is left pointing to the left-most
145606 for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){
145607 if( pFirstRec->selFlags & SF_Aggregate ){
145611 pFirstRec->op = TK_ALL;
145612 if( (pFirstRec->pPrior->selFlags & SF_Recursive)==0 ) break;
145615 /* Store the results of the setup-query in Queue. */
145616 pSetup = pFirstRec->pPrior;
145617 pSetup->pNext = 0;
145620 pSetup->pNext = p;
145629 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
145647 ** the value for the recursive-table. Store the results in the Queue.
145649 pFirstRec->pPrior = 0;
145652 assert( pFirstRec->pPrior==0 );
145653 pFirstRec->pPrior = pSetup;
145660 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
145661 p->pOrderBy = pOrderBy;
145662 p->pLimit = pLimit;
145670 Select *p, /* The right-most of SELECTs to be coded */
145675 ** Handle the special case of a compound-select that originates from a
145688 ** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
145692 Select *p, /* The right-most of SELECTs to be coded */
145697 int bShowAll = p->pLimit==0;
145698 assert( p->selFlags & SF_MultiValue );
145700 assert( p->selFlags & SF_Values );
145701 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
145702 assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr );
145704 if( p->pWin ) return -1;
145706 if( p->pPrior==0 ) break;
145707 assert( p->pPrior->pNext==p );
145708 p = p->pPrior;
145714 selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
145716 p->nSelectRow = nRow;
145717 p = p->pNext;
145728 while( p && (p->selFlags & SF_Recursive)!=0 ){ p = p->pPrior; }
145737 ** "p" points to the right-most of the two queries. the query on the
145738 ** left is p->pPrior. The left query could also be a compound query
145744 ** Example 1: Consider a three-way compound SQL statement.
145752 ** `-----> SELECT b FROM t2
145754 ** `------> SELECT a FROM t1
145758 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
145765 Select *p, /* The right-most of SELECTs to be coded */
145776 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
145778 assert( p && p->pPrior ); /* Calling function guarantees this much */
145779 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
145780 assert( p->selFlags & SF_Compound );
145781 db = pParse->db;
145782 pPrior = p->pPrior;
145784 assert( pPrior->pOrderBy==0 );
145785 assert( pPrior->pLimit==0 );
145793 assert( p->pEList );
145794 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
145798 /* Special handling for a compound-select that originates as a VALUES clause.
145800 if( p->selFlags & SF_MultiValue ){
145809 assert( p->pEList && pPrior->pEList );
145810 assert( p->pEList->nExpr==pPrior->pEList->nExpr );
145813 if( (p->selFlags & SF_Recursive)!=0 && hasAnchor(p) ){
145820 if( p->pOrderBy ){
145825 if( pPrior->pPrior==0 ){
145827 ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
145833 switch( p->op ){
145837 assert( !pPrior->pLimit );
145838 pPrior->iLimit = p->iLimit;
145839 pPrior->iOffset = p->iOffset;
145840 pPrior->pLimit = p->pLimit;
145843 pPrior->pLimit = 0;
145847 p->pPrior = 0;
145848 p->iLimit = pPrior->iLimit;
145849 p->iOffset = pPrior->iOffset;
145850 if( p->iLimit ){
145851 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
145853 if( p->iOffset ){
145855 p->iLimit, p->iOffset+1, p->iOffset);
145862 pDelete = p->pPrior;
145863 p->pPrior = pPrior;
145864 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
145865 if( p->pLimit
145866 && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit)
145867 && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
145869 p->nSelectRow = sqlite3LogEst((u64)nLimit);
145881 Expr *pLimit; /* Saved values of p->nLimit */
145885 testcase( p->op==TK_EXCEPT );
145886 testcase( p->op==TK_UNION );
145892 assert( p->pLimit==0 ); /* Not allowed on leftward elements */
145898 unionTab = pParse->nTab++;
145899 assert( p->pOrderBy==0 );
145901 assert( p->addrOpenEphm[0] == -1 );
145902 p->addrOpenEphm[0] = addr;
145903 findRightmost(p)->selFlags |= SF_UsesEphemeral;
145904 assert( p->pEList );
145910 assert( !pPrior->pOrderBy );
145920 if( p->op==TK_EXCEPT ){
145923 assert( p->op==TK_UNION );
145926 p->pPrior = 0;
145927 pLimit = p->pLimit;
145928 p->pLimit = 0;
145930 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
145931 sqlite3SelectOpName(p->op)));
145935 assert( p->pOrderBy==0 );
145936 pDelete = p->pPrior;
145937 p->pPrior = pPrior;
145938 p->pOrderBy = 0;
145939 if( p->op==TK_UNION ){
145940 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
145942 sqlite3ExprDelete(db, p->pLimit);
145943 p->pLimit = pLimit;
145944 p->iLimit = 0;
145945 p->iOffset = 0;
145951 assert( p->pEList || db->mallocFailed );
145952 if( dest.eDest!=priorOp && db->mallocFailed==0 ){
145968 default: assert( p->op==TK_INTERSECT ); {
145980 tab1 = pParse->nTab++;
145981 tab2 = pParse->nTab++;
145982 assert( p->pOrderBy==0 );
145985 assert( p->addrOpenEphm[0] == -1 );
145986 p->addrOpenEphm[0] = addr;
145987 findRightmost(p)->selFlags |= SF_UsesEphemeral;
145988 assert( p->pEList );
146002 assert( p->addrOpenEphm[1] == -1 );
146003 p->addrOpenEphm[1] = addr;
146004 p->pPrior = 0;
146005 pLimit = p->pLimit;
146006 p->pLimit = 0;
146008 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
146009 sqlite3SelectOpName(p->op)));
146013 pDelete = p->pPrior;
146014 p->pPrior = pPrior;
146015 if( p->nSelectRow>pPrior->nSelectRow ){
146016 p->nSelectRow = pPrior->nSelectRow;
146018 sqlite3ExprDelete(db, p->pLimit);
146019 p->pLimit = pLimit;
146025 assert( p->pEList );
146047 if( p->pNext==0 ){
146052 if( pParse->nErr ) goto multi_select_end;
146058 ** This section is run by the right-most SELECT statement only.
146059 ** SELECT statements to the left always skip this part. The right-most
146063 if( p->selFlags & SF_UsesEphemeral ){
146067 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
146070 assert( p->pNext==0 );
146071 assert( p->pEList!=0 );
146072 nCol = p->pEList->nExpr;
146078 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
146081 *apColl = db->pDfltColl;
146085 for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
146087 int addr = pLoop->addrOpenEphm[i];
146091 assert( pLoop->addrOpenEphm[1]<0 );
146097 pLoop->addrOpenEphm[i] = -1;
146104 pDest->iSdst = dest.iSdst;
146105 pDest->nSdst = dest.nSdst;
146118 if( p->selFlags & SF_Values ){
146123 sqlite3SelectOpName(p->op));
146131 ** The data to be output is contained in pIn->iSdst. There are
146132 ** pIn->nSdst columns to be output. pDest is where the output should
146144 ** If the LIMIT found in p->iLimit is reached, jump immediately to
146157 Vdbe *v = pParse->pVdbe;
146169 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
146173 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
146176 if( pParse->db->mallocFailed ) return 0;
146180 codeOffset(v, p->iOffset, iContinue);
146182 assert( pDest->eDest!=SRT_Exists );
146183 assert( pDest->eDest!=SRT_Table );
146184 switch( pDest->eDest ){
146190 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
146191 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
146192 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
146204 testcase( pIn->nSdst>1 );
146206 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
146207 r1, pDest->zAffSdst, pIn->nSdst);
146208 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
146209 pIn->iSdst, pIn->nSdst);
146217 ** if it is the RHS of a row-value IN operator.
146220 testcase( pIn->nSdst>1 );
146221 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
146228 ** starting at pDest->iSdst. Then the co-routine yields.
146231 if( pDest->iSdst==0 ){
146232 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
146233 pDest->nSdst = pIn->nSdst;
146235 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
146236 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
146249 assert( pDest->eDest==SRT_Output );
146250 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
146257 if( p->iLimit ){
146258 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
146279 ** co-routines. Then run the co-routines in parallel and merge the results
146306 ** ------------- ----------------- -------------- -----------------
146357 Select *p, /* The right-most of SELECTs to be coded */
146362 Select *pSplit; /* Left-most SELECT in the right-hand group */
146367 int regAddrA; /* Address register for select-A coroutine */
146368 int regAddrB; /* Address register for select-B coroutine */
146369 int addrSelectA; /* Address of the select-A coroutine */
146370 int addrSelectB; /* Address of the select-B coroutine */
146371 int regOutA; /* Address register for the output-A subroutine */
146372 int regOutB; /* Address register for the output-B subroutine */
146373 int addrOutA; /* Address of the output-A subroutine */
146374 int addrOutB = 0; /* Address of the output-B subroutine */
146375 int addrEofA; /* Address of the select-A-exhausted subroutine */
146377 int addrEofB; /* Address of the select-B-exhausted subroutine */
146381 int regLimitA; /* Limit register for select-A */
146382 int regLimitB; /* Limit register for select-A */
146384 int savedLimit; /* Saved value of p->iLimit */
146385 int savedOffset; /* Saved value of p->iOffset */
146397 assert( p->pOrderBy!=0 );
146399 db = pParse->db;
146400 v = pParse->pVdbe;
146408 op = p->op;
146409 assert( p->pPrior->pOrderBy==0 );
146410 pOrderBy = p->pOrderBy;
146412 nOrderBy = pOrderBy->nExpr;
146419 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
146421 for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
146423 assert( pItem->u.x.iOrderByCol>0 );
146424 if( pItem->u.x.iOrderByCol==i ) break;
146429 pNew->flags |= EP_IntValue;
146430 pNew->u.iValue = i;
146431 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
146432 if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
146448 for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
146450 assert( pItem->u.x.iOrderByCol>0 );
146451 assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
146452 aPermute[i] = pItem->u.x.iOrderByCol - 1;
146466 int nExpr = p->pEList->nExpr;
146467 assert( nOrderBy>=nExpr || db->mallocFailed );
146468 regPrev = pParse->nMem+1;
146469 pParse->nMem += nExpr+1;
146475 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
146476 pKeyDup->aSortFlags[i] = 0;
146487 for(pSplit=p; pSplit->pPrior!=0 && pSplit->op==op; pSplit=pSplit->pPrior){
146489 assert( pSplit->pPrior->pNext==pSplit );
146496 for(i=2; i<nSelect; i+=2){ pSplit = pSplit->pPrior; }
146498 pPrior = pSplit->pPrior;
146500 pSplit->pPrior = 0;
146501 pPrior->pNext = 0;
146502 assert( p->pOrderBy == pOrderBy );
146503 assert( pOrderBy!=0 || db->mallocFailed );
146504 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
146505 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
146506 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
146510 if( p->iLimit && op==TK_ALL ){
146511 regLimitA = ++pParse->nMem;
146512 regLimitB = ++pParse->nMem;
146513 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
146519 sqlite3ExprDelete(db, p->pLimit);
146520 p->pLimit = 0;
146522 regAddrA = ++pParse->nMem;
146523 regAddrB = ++pParse->nMem;
146524 regOutA = ++pParse->nMem;
146525 regOutB = ++pParse->nMem;
146529 ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op)));
146532 ** left of the compound operator - the "A" select.
146537 pPrior->iLimit = regLimitA;
146544 ** the right - the "B" select
146549 savedLimit = p->iLimit;
146550 savedOffset = p->iOffset;
146551 p->iLimit = regLimitB;
146552 p->iOffset = 0;
146555 p->iLimit = savedLimit;
146556 p->iOffset = savedOffset;
146584 VdbeNoopComment((v, "eof-A subroutine"));
146589 p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
146597 if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
146599 VdbeNoopComment((v, "eof-B subroutine"));
146607 VdbeNoopComment((v, "A-lt-B subroutine"));
146620 VdbeNoopComment((v, "A-eq-B subroutine"));
146628 VdbeNoopComment((v, "A-gt-B subroutine"));
146657 if( pSplit->pPrior ){
146658 sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, pSplit->pPrior);
146660 pSplit->pPrior = pPrior;
146661 pPrior->pNext = pSplit;
146662 sqlite3ExprListDelete(db, pPrior->pOrderBy);
146663 pPrior->pOrderBy = 0;
146668 return pParse->nErr!=0;
146683 ** position in the parent that NULL-able due to an OUTER JOIN. Either the
146706 ** when processing a non-matched row of the left.
146723 ** a column in table number iTable with a copy of the iColumn-th
146740 && pExpr->w.iJoin==pSubst->iTable
146743 pExpr->w.iJoin = pSubst->iNewTable;
146745 if( pExpr->op==TK_COLUMN
146746 && pExpr->iTable==pSubst->iTable
146750 if( pExpr->iColumn<0 ){
146751 pExpr->op = TK_NULL;
146759 iColumn = pExpr->iColumn;
146761 assert( pSubst->pEList!=0 && iColumn<pSubst->pEList->nExpr );
146762 assert( pExpr->pRight==0 );
146763 pCopy = pSubst->pEList->a[iColumn].pExpr;
146765 sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
146767 sqlite3 *db = pSubst->pParse->db;
146768 if( pSubst->isOuterJoin
146769 && (pCopy->op!=TK_COLUMN || pCopy->iTable!=pSubst->iNewTable)
146774 ifNullRow.iTable = pSubst->iNewTable;
146775 ifNullRow.iColumn = -99;
146781 if( db->mallocFailed ){
146785 if( pSubst->isOuterJoin ){
146789 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
146790 pExpr->flags & (EP_OuterON|EP_InnerON));
146794 if( pExpr->op==TK_TRUEFALSE ){
146795 pExpr->u.iValue = sqlite3ExprTruthValue(pExpr);
146796 pExpr->op = TK_INTEGER;
146801 ** just as it did when it was a column of a view or sub-query. */
146803 CollSeq *pNat = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
146804 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse,
146805 pSubst->pCList->a[iColumn].pExpr
146807 if( pNat!=pColl || (pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE) ){
146808 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
146809 (pColl ? pColl->zName : "BINARY")
146817 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
146818 pExpr->iTable = pSubst->iNewTable;
146820 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
146821 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
146823 substSelect(pSubst, pExpr->x.pSelect, 1);
146825 substExprList(pSubst, pExpr->x.pList);
146829 Window *pWin = pExpr->y.pWin;
146830 pWin->pFilter = substExpr(pSubst, pWin->pFilter);
146831 substExprList(pSubst, pWin->pPartition);
146832 substExprList(pSubst, pWin->pOrderBy);
146844 for(i=0; i<pList->nExpr; i++){
146845 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
146851 int doPrior /* Do substitutes on p->pPrior too */
146858 substExprList(pSubst, p->pEList);
146859 substExprList(pSubst, p->pGroupBy);
146860 substExprList(pSubst, p->pOrderBy);
146861 p->pHaving = substExpr(pSubst, p->pHaving);
146862 p->pWhere = substExpr(pSubst, p->pWhere);
146863 pSrc = p->pSrc;
146865 for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
146866 substSelect(pSubst, pItem->pSelect, 1);
146867 if( pItem->fg.isTabFunc ){
146868 substExprList(pSubst, pItem->u1.pFuncArg);
146871 }while( doPrior && (p = p->pPrior)!=0 );
146881 ** pSrcItem->colUsed mask.
146885 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
146886 pItem = pWalker->u.pSrcItem;
146887 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
146888 if( pExpr->iColumn<0 ) return WRC_Continue;
146889 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
146897 if( NEVER(pSrcItem->pTab==0) ) return;
146902 pSrcItem->colUsed = 0;
146918 ** If pSrc contains any sub-selects, call this routine recursively
146919 ** on the FROM clause of each such sub-select, with iExcept set to -1.
146929 for(i=0, pItem=pSrc->a; i<pSrc->nSrc; i++, pItem++){
146932 assert( pItem->iCursor < aCsrMap[0] );
146933 if( !pItem->fg.isRecursive || aCsrMap[pItem->iCursor+1]==0 ){
146934 aCsrMap[pItem->iCursor+1] = pParse->nTab++;
146936 pItem->iCursor = aCsrMap[pItem->iCursor+1];
146937 for(p=pItem->pSelect; p; p=p->pPrior){
146938 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
146948 int *aCsrMap = pWalker->u.aiCol;
146960 int op = pExpr->op;
146962 renumberCursorDoMapping(pWalker, &pExpr->iTable);
146965 renumberCursorDoMapping(pWalker, &pExpr->w.iJoin);
146973 ** cursor in the FROM clause of any FROM clause sub-selects, recursively.
146995 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept);
147010 while( pSel->pPrior ){
147011 pSel = pSel->pPrior;
147013 return pSel->pEList;
147017 ** Return true if any of the result-set columns in the compound query
147024 assert( p->pEList!=0 );
147025 assert( p->pPrior!=0 );
147026 pList = p->pEList;
147027 for(ii=0; ii<pList->nExpr; ii++){
147030 assert( pList->a[ii].pExpr!=0 );
147031 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
147032 for(pSub1=p->pPrior; pSub1; pSub1=pSub1->pPrior){
147033 assert( pSub1->pEList!=0 );
147034 assert( pSub1->pEList->nExpr>ii );
147035 assert( pSub1->pEList->a[ii].pExpr!=0 );
147036 if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){
147052 ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
147064 ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
147080 ** other than the one FROM-clause subquery that is a candidate
147082 ** from 2015-02-09.)
147096 ** sub-queries that were excluded from this optimization. Restriction
147111 ** (**) Restriction (10) was removed from the code on 2005-02-05 but we
147112 ** accidentally carried the comment forward until 2014-09-15. Original
147149 ** The parent and sub-query may contain WHERE clauses. Subject to
147156 ** Also, each component of the sub-query must return the same number
147159 ** such (illegal) sub-query is flattened. The caller will detect the
147162 ** (18) If the sub-query is a compound select, then all terms of the
147169 ** (20) If the sub-query is a compound select, then it must not use
147180 ** (23) If the outer query is a recursive CTE, then the sub-query may not be
147186 ** The subquery may not be an aggregate that uses the built-in min() or
147209 ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
147212 ** If flattening is not attempted, this routine is a no-op and returns 0.
147221 int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
147224 const char *zSavedAuthContext = pParse->zAuthContext;
147227 Select *pSub1; /* Pointer to the rightmost select in sub-query */
147231 int iNewParent = -1;/* Replacement table for iParent */
147236 sqlite3 *db = pParse->db;
147243 assert( p->pPrior==0 );
147245 pSrc = p->pSrc;
147246 assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
147247 pSubitem = &pSrc->a[iFrom];
147248 iParent = pSubitem->iCursor;
147249 pSub = pSubitem->pSelect;
147253 if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */
147256 pSubSrc = pSub->pSrc;
147260 ** because they could be computed at compile-time. But when LIMIT and OFFSET
147263 if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
147264 if( pSub->pLimit && pSub->pLimit->pRight ) return 0; /* Restriction (14) */
147265 if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
147268 if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
147269 if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */
147270 if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
147273 if( p->pOrderBy && pSub->pOrderBy ){
147276 if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
147277 if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
147278 if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
147281 if( pSub->selFlags & (SF_Recursive) ){
147300 if( (pSubitem->fg.jointype & (JT_OUTER|JT_LTORJ))!=0 ){
147301 if( pSubSrc->nSrc>1 /* (3a) */
147302 || IsVirtual(pSubSrc->a[0].pTab) /* (3b) */
147303 || (p->selFlags & SF_Distinct)!=0 /* (3d) */
147304 || (pSubitem->fg.jointype & JT_RIGHT)!=0 /* (26) */
147311 assert( pSubSrc->nSrc>0 ); /* True by restriction (7) */
147312 if( iFrom>0 && (pSubSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){
147317 assert( !pSubitem->fg.isCte || pSubitem->u2.pCteUse->eM10d!=M10d_Yes );
147319 /* Restriction (17): If the sub-query is a compound SELECT, then it must
147324 if( pSub->pPrior ){
147326 if( pSub->pOrderBy ){
147329 if( isAgg || (p->selFlags & SF_Distinct)!=0 || isOuterJoin>0 ){
147332 for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
147333 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
147334 testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
147335 assert( pSub->pSrc!=0 );
147336 assert( (pSub->selFlags & SF_Recursive)==0 );
147337 assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
147338 if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */
147339 || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */
147340 || pSub1->pSrc->nSrc<1 /* (17c) */
147342 || pSub1->pWin /* (17e) */
147347 if( iFrom>0 && (pSub1->pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){
147349 ** omitted on left-hand tables of the right join that is being
147353 testcase( pSub1->pSrc->nSrc>1 );
147357 if( p->pOrderBy ){
147358 for(ii=0; ii<p->pOrderBy->nExpr; ii++){
147359 if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
147364 if( (p->selFlags & SF_Recursive) ) return 0;
147369 if( pSrc->nSrc>1 ){
147370 if( pParse->nSelect>500 ) return 0;
147372 aCsrMap = sqlite3DbMallocZero(db, ((i64)pParse->nTab+1)*sizeof(int));
147373 if( aCsrMap ) aCsrMap[0] = pParse->nTab;
147379 pSub->selId, pSub, iFrom));
147382 pParse->zAuthContext = pSubitem->zName;
147385 pParse->zAuthContext = zSavedAuthContext;
147388 pSub1 = pSubitem->pSelect;
147389 sqlite3DbFree(db, pSubitem->zDatabase);
147390 sqlite3DbFree(db, pSubitem->zName);
147391 sqlite3DbFree(db, pSubitem->zAlias);
147392 pSubitem->zDatabase = 0;
147393 pSubitem->zName = 0;
147394 pSubitem->zAlias = 0;
147395 pSubitem->pSelect = 0;
147396 assert( pSubitem->fg.isUsing!=0 || pSubitem->u3.pOn==0 );
147398 /* If the sub-query is a compound SELECT statement, then (by restrictions
147402 ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
147405 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
147406 ** OFFSET clauses and joins them to the left-hand-side of the original
147408 ** select statements in the compound sub-query.
147429 ** We call this the "compound-subquery flattening".
147431 for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
147433 ExprList *pOrderBy = p->pOrderBy;
147434 Expr *pLimit = p->pLimit;
147435 Select *pPrior = p->pPrior;
147436 Table *pItemTab = pSubitem->pTab;
147437 pSubitem->pTab = 0;
147438 p->pOrderBy = 0;
147439 p->pPrior = 0;
147440 p->pLimit = 0;
147442 p->pLimit = pLimit;
147443 p->pOrderBy = pOrderBy;
147444 p->op = TK_ALL;
147445 pSubitem->pTab = pItemTab;
147447 p->pPrior = pPrior;
147449 pNew->selId = ++pParse->nSelect;
147450 if( aCsrMap && ALWAYS(db->mallocFailed==0) ){
147453 pNew->pPrior = pPrior;
147454 if( pPrior ) pPrior->pNext = pNew;
147455 pNew->pNext = p;
147456 p->pPrior = pNew;
147457 TREETRACE(0x4,pParse,p,("compound-subquery flattener"
147458 " creates %u as peer\n",pNew->selId));
147460 assert( pSubitem->pSelect==0 );
147463 if( db->mallocFailed ){
147464 pSubitem->pSelect = pSub1;
147473 ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
147475 if( ALWAYS(pSubitem->pTab!=0) ){
147476 Table *pTabToDel = pSubitem->pTab;
147477 if( pTabToDel->nTabRef==1 ){
147480 testcase( pToplevel->earlyCleanup );
147482 pTabToDel->nTabRef--;
147484 pSubitem->pTab = 0;
147487 /* The following loop runs once for each term in a compound-subquery
147489 ** of flattening - a flattening other than a compound-subquery flattening -
147501 for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
147504 u8 ltorj = pSrc->a[iFrom].fg.jointype & JT_LTORJ;
147506 pSubSrc = pSub->pSrc; /* FROM clause of subquery */
147507 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
147508 pSrc = pParent->pSrc; /* FROM clause of the outer query */
147511 jointype = pSubitem->fg.jointype; /* First time through the loop */
147530 pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
147532 pParent->pSrc = pSrc;
147539 SrcItem *pItem = &pSrc->a[i+iFrom];
147540 if( pItem->fg.isUsing ) sqlite3IdListDelete(db, pItem->u3.pUsing);
147541 assert( pItem->fg.isTabFunc==0 );
147542 *pItem = pSubSrc->a[i];
147543 pItem->fg.jointype |= ltorj;
147544 iNewParent = pSubSrc->a[i].iCursor;
147545 memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
147547 pSrc->a[iFrom].fg.jointype &= JT_LTORJ;
147548 pSrc->a[iFrom].fg.jointype |= jointype | ltorj;
147562 if( pSub->pOrderBy && (pParent->selFlags & SF_NoopOrderBy)==0 ){
147563 /* At this point, any non-zero iOrderByCol values indicate that the
147570 ** function attempts to flatten a compound sub-query into pParent
147571 ** (the only way this can happen is if the compound sub-query is
147572 ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */
147573 ExprList *pOrderBy = pSub->pOrderBy;
147574 for(i=0; i<pOrderBy->nExpr; i++){
147575 pOrderBy->a[i].u.x.iOrderByCol = 0;
147577 assert( pParent->pOrderBy==0 );
147578 pParent->pOrderBy = pOrderBy;
147579 pSub->pOrderBy = 0;
147581 pWhere = pSub->pWhere;
147582 pSub->pWhere = 0;
147587 if( pParent->pWhere ){
147588 pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere);
147590 pParent->pWhere = pWhere;
147593 if( db->mallocFailed==0 ){
147599 x.pEList = pSub->pEList;
147606 pParent->selFlags |= pSub->selFlags & SF_Compound;
147607 assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */
147615 if( pSub->pLimit ){
147616 pParent->pLimit = pSub->pLimit;
147617 pSub->pLimit = 0;
147623 recomputeColumnsUsed(pParent, &pSrc->a[i+iFrom]);
147651 u8 *pOomFault; /* Pointer to pParse->db->mallocFailed */
147675 assert( pColumn->op==TK_COLUMN );
147676 assert( sqlite3ExprIsConstant(pConst->pParse, pValue) );
147680 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147684 /* 2018-10-25 ticket [cf5ed20f]
147686 for(i=0; i<pConst->nConst; i++){
147687 const Expr *pE2 = pConst->apExpr[i*2];
147688 assert( pE2->op==TK_COLUMN );
147689 if( pE2->iTable==pColumn->iTable
147690 && pE2->iColumn==pColumn->iColumn
147696 pConst->bHasAffBlob = 1;
147699 pConst->nConst++;
147700 pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
147701 pConst->nConst*2*sizeof(Expr*));
147702 if( pConst->apExpr==0 ){
147703 pConst->nConst = 0;
147705 pConst->apExpr[pConst->nConst*2-2] = pColumn;
147706 pConst->apExpr[pConst->nConst*2-1] = pValue;
147713 ** is part of the AND-connected terms of the expression. For each term
147719 if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){
147724 if( pExpr->op==TK_AND ){
147725 findConstInWhere(pConst, pExpr->pRight);
147726 findConstInWhere(pConst, pExpr->pLeft);
147729 if( pExpr->op!=TK_EQ ) return;
147730 pRight = pExpr->pRight;
147731 pLeft = pExpr->pLeft;
147734 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pLeft) ){
147737 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pRight) ){
147746 ** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
147748 ** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
147757 if( pConst->pOomFault[0] ) return WRC_Prune;
147758 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
147759 if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){
147765 for(i=0; i<pConst->nConst; i++){
147766 Expr *pColumn = pConst->apExpr[i*2];
147768 if( pColumn->iTable!=pExpr->iTable ) continue;
147769 if( pColumn->iColumn!=pExpr->iColumn ) continue;
147774 pConst->nChng++;
147777 assert( pExpr->pLeft==0 );
147778 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
147779 if( pConst->pParse->db->mallocFailed ) return WRC_Prune;
147788 ** any substitutions based on the contents of pWalker->u.pConst should
147794 ** one of the columns in pWalker->u.pConst, or
147799 ** pWalker->u.pConst.
147802 WhereConst *pConst = pWalker->u.pConst;
147807 if( pConst->bHasAffBlob ){
147808 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
147809 || pExpr->op==TK_IS
147811 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
147812 if( pConst->pOomFault[0] ) return WRC_Prune;
147813 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
147814 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
147818 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
147822 ** The WHERE-clause constant propagation optimization.
147825 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
147857 ** 2021-05-25 forum post 6a06202608: Another troublesome case is...
147880 x.pOomFault = &pParse->db->mallocFailed;
147886 if( ALWAYS(p->pSrc!=0)
147887 && p->pSrc->nSrc>0
147888 && (p->pSrc->a[0].fg.jointype & JT_LTORJ)!=0
147897 findConstInWhere(&x, p->pWhere);
147906 sqlite3WalkExpr(&w, p->pWhere);
147907 sqlite3DbFree(x.pParse->db, x.apExpr);
147918 ** push WHERE clause expression pExpr down to FROM clause sub-query
147925 ** BY clause of all window function used by the sub-query. It is safe
147931 ** * the sub-query uses only one distinct window frame, and
147935 assert( pSubq->pWin->pPartition );
147936 assert( (pSubq->selFlags & SF_MultiPart)==0 );
147937 assert( pSubq->pPrior==0 );
147938 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
147948 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10;
147952 ** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10)
147960 ** This optimization is called the "WHERE-clause push-down optimization".
147963 ** with a similar name: The "MySQL push-down optimization" causes WHERE
147972 ** (1) (** This restriction was removed on 2017-09-29. We used to
147990 ** of a LEFT JOIN where iCursor is not the right-hand table of that
148009 ** (6b) The inner query is a compound and uses window-functions.
148013 ** all window-functions used by the sub-query. It is safe to
148015 ** window over which any window-function is calculated.
148035 ** Without this restriction, the WHERE-clause push-down optimization
148040 ** (10) The inner query is not the right-hand table of a RIGHT JOIN.
148048 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
148061 pSrc = &pSrcList->a[iSrc];
148063 if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ){
148066 if( pSrc->fg.jointype & (JT_LTORJ|JT_RIGHT) ){
148070 if( pSubq->pPrior ){
148073 for(pSel=pSubq; pSel; pSel=pSel->pPrior){
148074 u8 op = pSel->op;
148081 if( pSel->pWin ) return 0; /* restriction (6b) */
148087 ** non-BINARY collating sequence. */
148088 for(pSel=pSubq; pSel; pSel=pSel->pPrior){
148090 const ExprList *pList = pSel->pEList;
148092 for(ii=0; ii<pList->nExpr; ii++){
148093 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
148102 if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0;
148113 for(pX=pSubq; pX; pX=pX->pPrior){
148114 assert( (pX->selFlags & (SF_Recursive))==0 );
148119 if( pSubq->pLimit!=0 ){
148122 while( pWhere->op==TK_AND ){
148123 nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight, pSrcList, iSrc);
148124 pWhere = pWhere->pLeft;
148129 && (pSrcList->a[0].fg.jointype & JT_LTORJ)!=0 /* Fast pre-test of (9c) */
148133 if( pWhere->w.iJoin==pSrcList->a[jj].iCursor ){
148138 if( (pSrcList->a[jj].fg.jointype & JT_RIGHT)!=0 ){
148147 || pWhere->w.iJoin!=iCursor)
148152 && pWhere->w.iJoin!=iCursor
148159 if( ViewCanHaveRowid && (pWhere->op==TK_ISNULL || pWhere->op==TK_NOTNULL) ){
148160 Expr *pLeft = pWhere->pLeft;
148162 && pLeft->op==TK_COLUMN
148163 && pLeft->iColumn < 0
148172 pSubq->selFlags |= SF_PushDown;
148175 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
148176 unsetJoinExpr(pNew, -1, 1);
148178 x.iTable = pSrc->iCursor;
148179 x.iNewTable = pSrc->iCursor;
148181 x.pEList = pSubq->pEList;
148185 if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){
148186 /* Restriction 6c has prevented push-down in this case */
148187 sqlite3ExprDelete(pParse->db, pNew);
148188 nChng--;
148192 if( pSubq->selFlags & SF_Aggregate ){
148193 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
148195 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
148197 pSubq = pSubq->pPrior;
148205 ** Check to see if a subquery contains result-set columns that are
148206 ** never used. If it does, change the value of those result-set columns
148221 if( pItem->fg.isCorrelated || pItem->fg.isCte ){
148224 assert( pItem->pTab!=0 );
148225 pTab = pItem->pTab;
148226 assert( pItem->pSelect!=0 );
148227 pSub = pItem->pSelect;
148228 assert( pSub->pEList->nExpr==pTab->nCol );
148229 for(pX=pSub; pX; pX=pX->pPrior){
148230 if( (pX->selFlags & (SF_Distinct|SF_Aggregate))!=0 ){
148231 testcase( pX->selFlags & SF_Distinct );
148232 testcase( pX->selFlags & SF_Aggregate );
148235 if( pX->pPrior && pX->op!=TK_ALL ){
148241 if( pX->pWin ){
148248 colUsed = pItem->colUsed;
148249 if( pSub->pOrderBy ){
148250 ExprList *pList = pSub->pOrderBy;
148251 for(j=0; j<pList->nExpr; j++){
148252 u16 iCol = pList->a[j].u.x.iOrderByCol;
148254 iCol--;
148255 colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
148259 nCol = pTab->nCol;
148261 Bitmask m = j<BMS-1 ? MASKBIT(j) : TOPBIT;
148263 for(pX=pSub; pX; pX=pX->pPrior) {
148264 Expr *pY = pX->pEList->a[j].pExpr;
148265 if( pY->op==TK_NULL ) continue;
148266 pY->op = TK_NULL;
148268 pX->selFlags |= SF_PushDown;
148300 assert( pFunc->op==TK_AGG_FUNCTION );
148303 pEList = pFunc->x.pList;
148305 || pEList->nExpr!=1
148312 zFunc = pFunc->u.zToken;
148315 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
148325 assert( pOrderBy!=0 || db->mallocFailed );
148326 if( pOrderBy ) pOrderBy->a[0].fg.sortFlags = sortFlags;
148332 ** The second argument is the associated aggregate-info object. This
148337 ** where table is a database table, not a sub-select or view. If the query
148351 assert( !p->pGroupBy );
148353 if( p->pWhere
148354 || p->pEList->nExpr!=1
148355 || p->pSrc->nSrc!=1
148356 || p->pSrc->a[0].pSelect
148357 || pAggInfo->nFunc!=1
148358 || p->pHaving
148362 pTab = p->pSrc->a[0].pTab;
148366 pExpr = p->pEList->a[0].pExpr;
148368 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
148369 if( pExpr->pAggInfo!=pAggInfo ) return 0;
148370 if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
148371 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
148380 ** If the source-list item passed as an argument was augmented with an
148384 ** pFrom->pIndex and return SQLITE_OK.
148387 Table *pTab = pFrom->pTab;
148388 char *zIndexedBy = pFrom->u1.zIndexedBy;
148391 assert( pFrom->fg.isIndexedBy!=0 );
148393 for(pIdx=pTab->pIndex;
148394 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
148395 pIdx=pIdx->pNext
148399 pParse->checkSchema = 1;
148402 assert( pFrom->fg.isCte==0 );
148403 pFrom->u2.pIBIndex = pIdx;
148438 if( p->pPrior==0 ) return WRC_Continue;
148439 if( p->pOrderBy==0 ) return WRC_Continue;
148440 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
148442 a = p->pOrderBy->a;
148444 /* If iOrderByCol is already non-zero, then it has already been matched
148446 ** SELECT is rewritten for window-functions processing and then passed
148451 for(i=p->pOrderBy->nExpr-1; i>=0; i--){
148452 if( a[i].pExpr->flags & EP_Collate ) break;
148458 pParse = pWalker->pParse;
148459 db = pParse->db;
148466 p->pSrc = pNewSrc;
148467 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
148468 p->op = TK_SELECT;
148469 p->pWhere = 0;
148470 pNew->pGroupBy = 0;
148471 pNew->pHaving = 0;
148472 pNew->pOrderBy = 0;
148473 p->pPrior = 0;
148474 p->pNext = 0;
148475 p->pWith = 0;
148477 p->pWinDefn = 0;
148479 p->selFlags &= ~SF_Compound;
148480 assert( (p->selFlags & SF_Converted)==0 );
148481 p->selFlags |= SF_Converted;
148482 assert( pNew->pPrior!=0 );
148483 pNew->pPrior->pNext = pNew;
148484 pNew->pLimit = 0;
148489 ** Check to see if the FROM clause term pFrom has table-valued function
148491 ** non-zero, since pFrom is not allowed to be a table-valued function.
148494 if( pFrom->fg.isTabFunc ){
148495 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
148505 ** FROM clause element pItem is really a common-table-expression (CTE)
148509 ** If a non-NULL value is returned, set *ppContext to point to the With
148517 const char *zName = pItem->zName;
148519 assert( pItem->zDatabase==0 );
148521 for(p=pWith; p; p=p->pOuter){
148523 for(i=0; i<p->nCte; i++){
148524 if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
148526 return &p->a[i];
148529 if( p->bView ) break;
148535 ** with the inner-most WITH clause being at the top of the stack.
148558 if( pParse->nErr==0 ){
148559 assert( pParse->pWith!=pWith );
148560 pWith->pOuter = pParse->pWith;
148561 pParse->pWith = pWith;
148570 ** pParse->pWith linked list). And if currently processing a CTE
148574 ** If pFrom matches a CTE according to either of these two above, pFrom->pTab
148589 assert( pFrom->pTab==0 );
148590 if( pParse->pWith==0 ){
148594 if( pParse->nErr ){
148595 /* Prior errors might have left pParse->pWith in a goofy state, so
148599 if( pFrom->zDatabase!=0 ){
148604 if( pFrom->fg.notCte ){
148612 pCte = searchWith(pParse->pWith, pFrom, &pWith);
148614 sqlite3 *db = pParse->db;
148618 Select *pLeft; /* Left-most SELECT statement */
148619 Select *pRecTerm; /* Left-most recursive term */
148621 With *pSavedWith; /* Initial value of pParse->pWith */
148622 int iRecTab = -1; /* Cursor for recursive table */
148625 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
148627 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
148629 if( pCte->zCteErr ){
148630 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
148635 assert( pFrom->pTab==0 );
148638 pCteUse = pCte->pUse;
148640 pCte->pUse = pCteUse = sqlite3DbMallocZero(db, sizeof(pCteUse[0]));
148647 pCteUse->eM10d = pCte->eM10d;
148649 pFrom->pTab = pTab;
148650 pTab->nTabRef = 1;
148651 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
148652 pTab->iPKey = -1;
148653 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
148654 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
148655 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
148656 if( db->mallocFailed ) return 2;
148657 pFrom->pSelect->selFlags |= SF_CopyCte;
148658 assert( pFrom->pSelect );
148659 if( pFrom->fg.isIndexedBy ){
148660 sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
148663 pFrom->fg.isCte = 1;
148664 pFrom->u2.pCteUse = pCteUse;
148665 pCteUse->nUse++;
148668 pRecTerm = pSel = pFrom->pSelect;
148669 bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
148670 while( bMayRecursive && pRecTerm->op==pSel->op ){
148672 SrcList *pSrc = pRecTerm->pSrc;
148673 assert( pRecTerm->pPrior!=0 );
148674 for(i=0; i<pSrc->nSrc; i++){
148675 SrcItem *pItem = &pSrc->a[i];
148676 if( pItem->zDatabase==0
148677 && pItem->zName!=0
148678 && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
148680 pItem->pTab = pTab;
148681 pTab->nTabRef++;
148682 pItem->fg.isRecursive = 1;
148683 if( pRecTerm->selFlags & SF_Recursive ){
148685 "multiple references to recursive table: %s", pCte->zName
148689 pRecTerm->selFlags |= SF_Recursive;
148690 if( iRecTab<0 ) iRecTab = pParse->nTab++;
148691 pItem->iCursor = iRecTab;
148694 if( (pRecTerm->selFlags & SF_Recursive)==0 ) break;
148695 pRecTerm = pRecTerm->pPrior;
148698 pCte->zCteErr = "circular reference: %s";
148699 pSavedWith = pParse->pWith;
148700 pParse->pWith = pWith;
148701 if( pSel->selFlags & SF_Recursive ){
148704 assert( (pRecTerm->selFlags & SF_Recursive)==0 );
148705 assert( pRecTerm->pNext!=0 );
148706 assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 );
148707 assert( pRecTerm->pWith==0 );
148708 pRecTerm->pWith = pSel->pWith;
148710 pRecTerm->pWith = 0;
148712 pParse->pWith = pSavedWith;
148717 pParse->pWith = pSavedWith;
148721 pParse->pWith = pWith;
148723 for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
148724 pEList = pLeft->pEList;
148725 if( pCte->pCols ){
148726 if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
148728 pCte->zName, pEList->nExpr, pCte->pCols->nExpr
148730 pParse->pWith = pSavedWith;
148733 pEList = pCte->pCols;
148736 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
148738 if( pSel->selFlags & SF_Recursive ){
148739 pCte->zCteErr = "multiple recursive references: %s";
148741 pCte->zCteErr = "recursive reference in a subquery: %s";
148745 pCte->zCteErr = 0;
148746 pParse->pWith = pSavedWith;
148763 Parse *pParse = pWalker->pParse;
148764 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
148765 With *pWith = findRightmost(p)->pWith;
148767 assert( pParse->pWith==pWith || pParse->nErr );
148768 pParse->pWith = pWith->pOuter;
148776 ** sub-query in the FROM clause of a SELECT statement. This function
148782 Select *pSel = pFrom->pSelect;
148786 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
148788 pTab->nTabRef = 1;
148789 if( pFrom->zAlias ){
148790 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
148792 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
148794 while( pSel->pPrior ){ pSel = pSel->pPrior; }
148795 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
148796 pTab->iPKey = -1;
148797 pTab->eTabType = TABTYP_VIEW;
148798 pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
148800 /* The usual case - do not allow ROWID on a subquery */
148801 pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
148804 pTab->tabFlags |= TF_Ephemeral | sqlite3Config.mNoVisibleRowid;
148806 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
148821 SrcItem *pBase, /* The base SrcItem. Looking at pBase[1] and following */
148825 N--;
148827 if( pBase->fg.isUsing==0 ) continue;
148828 if( NEVER(pBase->u3.pUsing==0) ) continue;
148829 if( sqlite3IdListIndex(pBase->u3.pUsing, zName)>=0 ) return 1;
148842 ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
148844 ** fill pTabList->a[].pSelect with a copy of the SELECT statement
148860 Parse *pParse = pWalker->pParse;
148865 sqlite3 *db = pParse->db;
148867 u16 selFlags = p->selFlags;
148870 p->selFlags |= SF_Expanded;
148871 if( db->mallocFailed ){
148874 assert( p->pSrc!=0 );
148878 if( pWalker->eCode ){
148880 p->selId = ++pParse->nSelect;
148882 pTabList = p->pSrc;
148883 pEList = p->pEList;
148884 if( pParse->pWith && (p->selFlags & SF_View) ){
148885 if( p->pWith==0 ){
148886 p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With));
148887 if( p->pWith==0 ){
148891 p->pWith->bView = 1;
148893 sqlite3WithPush(pParse, p->pWith, 0);
148904 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
148906 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
148907 if( pFrom->pTab ) continue;
148908 assert( pFrom->fg.isRecursive==0 );
148909 if( pFrom->zName==0 ){
148911 Select *pSel = pFrom->pSelect;
148912 /* A sub-query in the FROM clause of a SELECT */
148914 assert( pFrom->pTab==0 );
148921 pTab = pFrom->pTab;
148926 assert( pFrom->pTab==0 );
148927 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
148929 if( pTab->nTabRef>=0xffff ){
148931 pTab->zName);
148932 pFrom->pTab = 0;
148935 pTab->nTabRef++;
148942 u8 eCodeOrig = pWalker->eCode;
148944 assert( pFrom->pSelect==0 );
148946 if( (db->flags & SQLITE_EnableView)==0
148947 && pTab->pSchema!=db->aDb[1].pSchema
148950 pTab->zName);
148952 pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
148956 && pFrom->fg.fromDDL
148957 && ALWAYS(pTab->u.vtab.p!=0)
148958 && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
148961 pTab->zName);
148965 nCol = pTab->nCol;
148966 pTab->nCol = -1;
148967 pWalker->eCode = 1; /* Turn on Select.selId renumbering */
148968 sqlite3WalkSelect(pWalker, pFrom->pSelect);
148969 pWalker->eCode = eCodeOrig;
148970 pTab->nCol = nCol;
148976 if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){
148983 assert( db->mallocFailed==0 || pParse->nErr!=0 );
148984 if( pParse->nErr || sqlite3ProcessJoin(pParse, p) ){
148999 for(k=0; k<pEList->nExpr; k++){
149000 pE = pEList->a[k].pExpr;
149001 if( pE->op==TK_ASTERISK ) break;
149002 assert( pE->op!=TK_DOT || pE->pRight!=0 );
149003 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
149004 if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break;
149005 elistFlags |= pE->flags;
149007 if( k<pEList->nExpr ){
149013 struct ExprList_item *a = pEList->a;
149015 int flags = pParse->db->flags;
149019 for(k=0; k<pEList->nExpr; k++){
149021 elistFlags |= pE->flags;
149022 pRight = pE->pRight;
149023 assert( pE->op!=TK_DOT || pRight!=0 );
149024 if( pE->op!=TK_ASTERISK
149025 && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
149031 pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
149032 pNew->a[pNew->nExpr-1].fg.eEName = a[k].fg.eEName;
149042 if( pE->op==TK_DOT ){
149044 assert( pE->pLeft!=0 );
149045 assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
149046 zTName = pE->pLeft->u.zToken;
149047 assert( ExprUseWOfst(pE->pLeft) );
149048 iErrOfst = pE->pRight->w.iOfst;
149051 iErrOfst = pE->w.iOfst;
149053 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
149055 Table *pTab = pFrom->pTab; /* Table for this data source */
149056 ExprList *pNestedFrom; /* Result-set of a nested FROM clause */
149062 if( (zTabName = pFrom->zAlias)==0 ){
149063 zTabName = pTab->zName;
149065 if( db->mallocFailed ) break;
149066 assert( (int)pFrom->fg.isNestedFrom == IsNestedFrom(pFrom->pSelect) );
149067 if( pFrom->fg.isNestedFrom ){
149068 assert( pFrom->pSelect!=0 );
149069 pNestedFrom = pFrom->pSelect->pEList;
149071 assert( pNestedFrom->nExpr==pTab->nCol );
149078 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
149079 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
149081 if( i+1<pTabList->nSrc
149087 for(ii=0; ii<pUsing->nId; ii++){
149088 const char *zUName = pUsing->a[ii].zName;
149093 struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
149094 assert( pX->zEName==0 );
149095 pX->zEName = sqlite3MPrintf(db,"..%s", zUName);
149096 pX->fg.eEName = ENAME_TAB;
149097 pX->fg.bUsingTerm = 1;
149104 nAdd = pTab->nCol;
149110 if( j==pTab->nCol ){
149114 zName = pTab->aCol[j].zCnName;
149116 /* If pTab is actually an SF_NestedFrom sub-select, do not
149118 if( pNestedFrom && pNestedFrom->a[j].fg.eEName==ENAME_ROWID ){
149124 && sqlite3MatchEName(&pNestedFrom->a[j], 0, zTName, 0, 0)==0
149130 ** result-set list unless the SELECT has the SF_IncludeHidden
149133 if( (p->selFlags & SF_IncludeHidden)==0
149134 && IsHiddenColumn(&pTab->aCol[j])
149138 if( (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0
149149 if( pFrom->fg.isUsing
149150 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0
149158 if( (pTabList->nSrc>1
149159 && ( (pFrom->fg.jointype & JT_LTORJ)==0
149161 || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1)
149169 if( IN_RENAME_OBJECT && pE->pLeft ){
149170 sqlite3RenameTokenRemap(pParse, pLeft, pE->pLeft);
149184 pX = &pNew->a[pNew->nExpr-1];
149185 assert( pX->zEName==0 );
149187 if( pNestedFrom && (!ViewCanHaveRowid || j<pNestedFrom->nExpr) ){
149188 assert( j<pNestedFrom->nExpr );
149189 pX->zEName = sqlite3DbStrDup(db, pNestedFrom->a[j].zEName);
149190 testcase( pX->zEName==0 );
149192 pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
149194 testcase( pX->zEName==0 );
149196 pX->fg.eEName = (j==pTab->nCol ? ENAME_ROWID : ENAME_TAB);
149197 if( (pFrom->fg.isUsing
149198 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
149200 || (j<pTab->nCol && (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND))
149202 pX->fg.bNoExpand = 1;
149205 pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
149206 pX->fg.eEName = ENAME_NAME;
149208 pX->zEName = sqlite3DbStrDup(db, zName);
149209 pX->fg.eEName = ENAME_NAME;
149223 p->pEList = pNew;
149225 if( p->pEList ){
149226 if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
149231 p->selFlags |= SF_ComplexResult;
149236 TREETRACE(0x8,pParse,p,("After result-set wildcard expansion:\n"));
149263 ** The calling function can detect the problem by looking at pParse->nErr
149264 ** and/or pParse->db->mallocFailed.
149270 if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
149287 ** For each FROM-clause subquery, add Column.zType, Column.zColl, and
149302 if( p->selFlags & SF_HasTypeInfo ) return;
149303 p->selFlags |= SF_HasTypeInfo;
149304 pParse = pWalker->pParse;
149305 assert( (p->selFlags & SF_Resolved) );
149306 pTabList = p->pSrc;
149307 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
149308 Table *pTab = pFrom->pTab;
149310 if( (pTab->tabFlags & TF_Ephemeral)!=0 ){
149311 /* A sub-query in the FROM clause of a SELECT */
149312 Select *pSel = pFrom->pSelect;
149324 ** the Table structures of all FROM-clause subqueries in a
149345 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
149346 ** * Ephemeral Table objects are created for all FROM-clause subqueries.
149358 assert( p!=0 || pParse->db->mallocFailed );
149359 assert( pParse->db->pParse==pParse );
149360 if( pParse->db->mallocFailed ) return;
149361 if( p->selFlags & SF_HasTypeInfo ) return;
149363 if( pParse->nErr ) return;
149365 if( pParse->nErr ) return;
149376 pAggInfo->selId, pAggInfo);
149377 for(ii=0; ii<pAggInfo->nColumn; ii++){
149378 struct AggInfo_col *pCol = &pAggInfo->aCol[ii];
149380 "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"
149382 ii, pCol->pTab ? pCol->pTab->zName : "NULL",
149383 pCol->iTable, pCol->iColumn, pAggInfo->iFirstReg+ii,
149384 pCol->iSorterColumn,
149385 ii>=pAggInfo->nAccumulator ? "" : " Accumulator");
149386 sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);
149388 for(ii=0; ii<pAggInfo->nFunc; ii++){
149389 sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",
149390 ii, pAggInfo->iFirstReg+pAggInfo->nColumn+ii);
149391 sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0);
149397 ** Analyze the arguments to aggregate functions. Create new pAggInfo->aCol[]
149419 assert( pAggInfo->iFirstReg==0 );
149420 pNC->ncFlags |= NC_InAggFunc;
149421 for(i=0; i<pAggInfo->nFunc; i++){
149422 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
149423 assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
149425 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
149426 if( pExpr->pLeft ){
149427 assert( pExpr->pLeft->op==TK_ORDER );
149428 assert( ExprUseXList(pExpr->pLeft) );
149429 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
149434 sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);
149438 pNC->ncFlags &= ~NC_InAggFunc;
149452 NameContext *pNC /* Name context used to resolve agg-func args */
149454 assert( pAggInfo->iFirstReg==0 );
149456 assert( pSelect->pGroupBy!=0 );
149457 pAggInfo->nColumn = pAggInfo->nAccumulator;
149458 if( ALWAYS(pAggInfo->nSortingColumn>0) ){
149459 int mx = pSelect->pGroupBy->nExpr - 1;
149461 for(j=0; j<pAggInfo->nColumn; j++){
149462 k = pAggInfo->aCol[j].iSorterColumn;
149465 pAggInfo->nSortingColumn = mx+1;
149474 for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){
149475 printf("data-cursor=%d index={%d,%d}\n",
149476 pIEpr->iDataCur, pIEpr->iIdxCur, pIEpr->iIdxCol);
149477 sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);
149494 if( pExpr->pAggInfo==0 ) return WRC_Continue;
149495 if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;
149496 if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;
149497 if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;
149498 pAggInfo = pExpr->pAggInfo;
149499 if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue;
149500 assert( pExpr->iAgg>=0 );
149501 pCol = &pAggInfo->aCol[pExpr->iAgg];
149502 pExpr->op = TK_AGG_COLUMN;
149503 pExpr->iTable = pCol->iTable;
149504 pExpr->iColumn = pCol->iColumn;
149510 ** Convert every pAggInfo->aFunc[].pExpr such that any node within
149519 for(i=0; i<pAggInfo->nFunc; i++){
149520 sqlite3WalkExpr(&w, pAggInfo->aFunc[i].pFExpr);
149527 ** pAggInfo->aCol[] and pAggInfo->aFunc[] entry in pAggInfo. The first
149528 ** register in this block is stored in pAggInfo->iFirstReg.
149544 assert( pAggInfo->iFirstReg==0 );
149545 pAggInfo->iFirstReg = pParse->nMem + 1;
149546 pParse->nMem += pAggInfo->nColumn + pAggInfo->nFunc;
149558 Vdbe *v = pParse->pVdbe;
149561 int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
149562 assert( pAggInfo->iFirstReg>0 );
149563 assert( pParse->db->pParse==pParse );
149564 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
149566 if( pParse->nErr ) return;
149567 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->iFirstReg,
149568 pAggInfo->iFirstReg+nReg-1);
149569 for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
149570 if( pFunc->iDistinct>=0 ){
149571 Expr *pE = pFunc->pFExpr;
149573 if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
149576 pFunc->iDistinct = -1;
149578 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
149579 pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
149580 pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO);
149581 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
149582 pFunc->pFunc->zName));
149585 if( pFunc->iOBTab>=0 ){
149589 assert( pFunc->pFExpr->pLeft!=0 );
149590 assert( pFunc->pFExpr->pLeft->op==TK_ORDER );
149591 assert( ExprUseXList(pFunc->pFExpr->pLeft) );
149592 assert( pFunc->pFunc!=0 );
149593 pOBList = pFunc->pFExpr->pLeft->x.pList;
149594 if( !pFunc->bOBUnique ){
149597 if( pFunc->bOBPayload ){
149599 assert( ExprUseXList(pFunc->pFExpr) );
149600 nExtra += pFunc->pFExpr->x.pList->nExpr;
149602 if( pFunc->bUseSubtype ){
149603 nExtra += pFunc->pFExpr->x.pList->nExpr;
149606 if( !pFunc->bOBUnique && pParse->nErr==0 ){
149607 pKeyInfo->nKeyField++;
149610 pFunc->iOBTab, pOBList->nExpr+nExtra, 0,
149612 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(ORDER BY)",
149613 pFunc->pFunc->zName));
149623 Vdbe *v = pParse->pVdbe;
149626 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
149628 assert( ExprUseXList(pF->pFExpr) );
149629 pList = pF->pFExpr->x.pList;
149630 if( pF->iOBTab>=0 ){
149632 ** were stored in emphermal table pF->iOBTab. Here, we extract those
149641 assert( pF->pFunc!=0 );
149642 nArg = pList->nExpr;
149645 if( pF->bOBPayload==0 ){
149648 assert( pF->pFExpr->pLeft!=0 );
149649 assert( ExprUseXList(pF->pFExpr->pLeft) );
149650 assert( pF->pFExpr->pLeft->x.pList!=0 );
149651 nKey = pF->pFExpr->pLeft->x.pList->nExpr;
149652 if( ALWAYS(!pF->bOBUnique) ) nKey++;
149654 iTop = sqlite3VdbeAddOp1(v, OP_Rewind, pF->iOBTab); VdbeCoverage(v);
149655 for(j=nArg-1; j>=0; j--){
149656 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, nKey+j, regAgg+j);
149658 if( pF->bUseSubtype ){
149660 int iBaseCol = nKey + nArg + (pF->bOBPayload==0 && pF->bOBUnique==0);
149661 for(j=nArg-1; j>=0; j--){
149662 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, iBaseCol+j, regSubtype);
149668 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149670 sqlite3VdbeAddOp2(v, OP_Next, pF->iOBTab, iTop+1); VdbeCoverage(v);
149675 pList ? pList->nExpr : 0);
149676 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149684 ** If regAcc is non-zero and there are no min() or max() aggregates
149685 ** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
149702 Vdbe *v = pParse->pVdbe;
149709 assert( pAggInfo->iFirstReg>0 );
149710 if( pParse->nErr ) return;
149711 pAggInfo->directMode = 1;
149712 for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
149719 assert( ExprUseXList(pF->pFExpr) );
149720 assert( !IsWindowFunc(pF->pFExpr) );
149721 assert( pF->pFunc!=0 );
149722 pList = pF->pFExpr->x.pList;
149723 if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){
149724 Expr *pFilter = pF->pFExpr->y.pWin->pFilter;
149725 if( pAggInfo->nAccumulator
149726 && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
149732 if( regHit==0 ) regHit = ++pParse->nMem;
149745 if( pF->iOBTab>=0 ){
149751 nArg = pList->nExpr;
149753 assert( pF->pFExpr->pLeft!=0 );
149754 assert( pF->pFExpr->pLeft->op==TK_ORDER );
149755 assert( ExprUseXList(pF->pFExpr->pLeft) );
149756 pOBList = pF->pFExpr->pLeft->x.pList;
149758 assert( pOBList->nExpr>0 );
149759 regAggSz = pOBList->nExpr;
149760 if( !pF->bOBUnique ){
149763 if( pF->bOBPayload ){
149766 if( pF->bUseSubtype ){
149773 jj = pOBList->nExpr;
149774 if( !pF->bOBUnique ){
149775 sqlite3VdbeAddOp2(v, OP_Sequence, pF->iOBTab, regAgg+jj);
149778 if( pF->bOBPayload ){
149783 if( pF->bUseSubtype ){
149785 int regBase = pF->bOBPayload ? regDistinct : regAgg;
149791 nArg = pList->nExpr;
149799 if( pF->iDistinct>=0 && pList ){
149803 pF->iDistinct = codeDistinct(pParse, eDistinctType,
149804 pF->iDistinct, addrNext, pList, regDistinct);
149806 if( pF->iOBTab>=0 ){
149808 sqlite3VdbeAddOp3(v, OP_MakeRecord, regAgg, regAggSz-1,
149809 regAgg+regAggSz-1);
149810 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pF->iOBTab, regAgg+regAggSz-1,
149811 regAgg, regAggSz-1);
149815 if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
149819 assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
149820 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
149821 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
149824 pColl = pParse->db->pDfltColl;
149826 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
149831 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149839 if( regHit==0 && pAggInfo->nAccumulator ){
149845 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
149846 sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));
149849 pAggInfo->directMode = 0;
149865 if( pParse->explain==2 ){
149868 pTab->zName,
149870 bCover ? pIdx->zName : ""
149885 ** sub-expression matches the criteria for being moved to the WHERE
149886 ** clause. If so, add it to the WHERE clause and replace the sub-expression
149890 if( pExpr->op!=TK_AND ){
149891 Select *pS = pWalker->u.pSelect;
149893 ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
149899 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
149901 && pExpr->pAggInfo==0
149903 sqlite3 *db = pWalker->pParse->db;
149906 Expr *pWhere = pS->pWhere;
149908 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
149909 pS->pWhere = pNew;
149910 pWalker->eCode = 1;
149939 sqlite3WalkExpr(&sWalker, p->pHaving);
149949 ** Check to see if the pThis entry of pTabList is a self-join of another view.
149950 ** Search FROM-clause entries in the range of iFirst..iEnd, including iFirst
149953 ** If pThis is a self-join, then return the SrcItem for the first other
149954 ** instance of that view found. If pThis is not a self-join then return 0.
149957 SrcList *pTabList, /* Search for self-joins in this FROM clause */
149959 int iFirst, int iEnd /* Range of FROM-clause entries to search. */
149962 assert( pThis->pSelect!=0 );
149963 if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
149966 pItem = &pTabList->a[iFirst++];
149967 if( pItem->pSelect==0 ) continue;
149968 if( pItem->fg.viaCoroutine ) continue;
149969 if( pItem->zName==0 ) continue;
149970 assert( pItem->pTab!=0 );
149971 assert( pThis->pTab!=0 );
149972 if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
149973 if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
149974 pS1 = pItem->pSelect;
149975 if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
149980 if( pItem->pSelect->selFlags & SF_PushDown ){
149995 sqlite3DbFree(db, p->aCol);
149996 sqlite3DbFree(db, p->aFunc);
150024 if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */
150025 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
150026 if( p->pWhere ) return 0;
150027 if( p->pHaving ) return 0;
150028 if( p->pGroupBy ) return 0;
150029 if( p->pOrderBy ) return 0;
150030 pExpr = p->pEList->a[0].pExpr;
150031 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
150033 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
150035 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
150036 if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */
150038 pSub = p->pSrc->a[0].pSelect;
150040 if( pSub->pPrior==0 ) return 0; /* Must be a compound */
150041 if( pSub->selFlags & SF_CopyCte ) return 0; /* Not a CTE */
150043 if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */
150044 if( pSub->pWhere ) return 0; /* No WHERE clause */
150045 if( pSub->pLimit ) return 0; /* No LIMIT clause */
150046 if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */
150047 assert( pSub->pHaving==0 ); /* Due to the previous */
150048 pSub = pSub->pPrior; /* Repeat over compound */
150053 db = pParse->db;
150056 pSub = p->pSrc->a[0].pSelect;
150057 p->pSrc->a[0].pSelect = 0;
150058 sqlite3SrcListDelete(db, p->pSrc);
150059 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
150062 pPrior = pSub->pPrior;
150063 pSub->pPrior = 0;
150064 pSub->pNext = 0;
150065 pSub->selFlags |= SF_Aggregate;
150066 pSub->selFlags &= ~SF_Compound;
150067 pSub->nSelectRow = 0;
150068 sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric, pSub->pEList);
150070 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
150080 p->pEList->a[0].pExpr = pExpr;
150081 p->selFlags &= ~SF_Aggregate;
150085 TREETRACE(0x200,pParse,p,("After count-of-view optimization:\n"));
150093 ** If any term of pSrc, or any SF_NestedFrom sub-query, is not the same
150099 for(i=0; i<pSrc->nSrc; i++){
150100 SrcItem *p1 = &pSrc->a[i];
150102 if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
150105 if( p1->pSelect
150106 && (p1->pSelect->selFlags & SF_NestedFrom)!=0
150107 && sameSrcAlias(p0, p1->pSelect->pSrc)
150116 ** Return TRUE (non-zero) if the i-th entry in the pTabList SrcList can
150117 ** be implemented as a co-routine. The i-th entry is guaranteed to be
150120 ** The subquery is implemented as a co-routine if all of the following are
150127 ** (b) The subquery is the left-most term and a CROSS JOIN or similar
150130 ** (i) The subquery is the left-most subquery in the FROM clause
150141 ** (5) The subquery is not self-joined
150149 SrcItem *pItem = &pTabList->a[i];
150150 if( pItem->fg.isCte ){
150151 const CteUse *pCteUse = pItem->u2.pCteUse;
150152 if( pCteUse->eM10d==M10d_Yes ) return 0; /* (2a) */
150153 if( pCteUse->nUse>=2 && pCteUse->eM10d!=M10d_No ) return 0; /* (2b) */
150155 if( pTabList->a[0].fg.jointype & JT_LTORJ ) return 0; /* (3) */
150156 if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0; /* (4) */
150157 if( isSelfJoinView(pTabList, pItem, i+1, pTabList->nSrc)!=0 ){
150161 if( pTabList->nSrc==1 ) return 1; /* (1a) */
150162 if( pTabList->a[1].fg.jointype & JT_CROSS ) return 1; /* (1b) */
150163 if( selFlags & SF_UpdateFrom ) return 0; /* (1c-iii) */
150166 if( selFlags & SF_UpdateFrom ) return 0; /* (1c-iii) */
150167 while( 1 /*exit-by-break*/ ){
150168 if( pItem->fg.jointype & (JT_OUTER|JT_CROSS) ) return 0; /* (1c-ii) */
150170 i--;
150171 pItem--;
150172 if( pItem->pSelect!=0 ) return 0; /* (1c-i) */
150185 ** pParse->zErrMsg.
150213 db = pParse->db;
150214 assert( pParse==db->pParse );
150216 if( p==0 || pParse->nErr ){
150219 assert( db->mallocFailed==0 );
150222 TREETRACE(0x1,pParse,p, ("begin processing:\n", pParse->addrExplain));
150232 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
150233 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
150234 assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
150235 assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
150237 assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
150238 pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard ||
150239 pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_DistFifo );
150241 if( p->pOrderBy ){
150245 sqlite3TreeViewExprList(0, p->pOrderBy, 0, "ORDERBY");
150249 p->pOrderBy);
150250 testcase( pParse->earlyCleanup );
150251 p->pOrderBy = 0;
150253 p->selFlags &= ~SF_Distinct;
150254 p->selFlags |= SF_NoopOrderBy;
150257 if( pParse->nErr ){
150260 assert( db->mallocFailed==0 );
150261 assert( p->pEList!=0 );
150271 ** In this case, it is an error if the target object (pSrc->a[0]) name
150272 ** or alias is duplicated within FROM clause (pSrc->a[1..n]).
150278 if( p->selFlags & SF_UFSrcCheck ){
150279 SrcItem *p0 = &p->pSrc->a[0];
150280 if( sameSrcAlias(p0, p->pSrc) ){
150283 p0->zAlias ? p0->zAlias : p0->pTab->zName
150289 ** and leaving this flag set can cause errors if a compound sub-query
150290 ** in p->pSrc is flattened into this query and this function called
150292 p->selFlags &= ~SF_UFSrcCheck;
150295 if( pDest->eDest==SRT_Output ){
150301 assert( pParse->nErr );
150305 if( p->pWin && (sqlite3TreeTrace & 0x40)!=0 ){
150311 pTabList = p->pSrc;
150312 isAgg = (p->selFlags & SF_Aggregate)!=0;
150314 sSort.pOrderBy = p->pOrderBy;
150320 for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
150321 SrcItem *pItem = &pTabList->a[i];
150322 Select *pSub = pItem->pSelect;
150323 Table *pTab = pItem->pTab;
150332 ** LEFT JOIN -> JOIN
150333 ** RIGHT JOIN -> JOIN
150334 ** FULL JOIN -> RIGHT JOIN
150336 ** If terms of the i-th table are used in the WHERE clause in such a
150337 ** way that the i-th table cannot be the NULL row of a join, then
150341 if( (pItem->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
150342 && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor,
150343 pItem->fg.jointype & JT_LTORJ)
150346 if( pItem->fg.jointype & JT_LEFT ){
150347 if( pItem->fg.jointype & JT_RIGHT ){
150349 ("FULL-JOIN simplifies to RIGHT-JOIN on term %d\n",i));
150350 pItem->fg.jointype &= ~JT_LEFT;
150353 ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
150354 pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
150355 unsetJoinExpr(p->pWhere, pItem->iCursor, 0);
150358 if( pItem->fg.jointype & JT_LTORJ ){
150359 for(j=i+1; j<pTabList->nSrc; j++){
150360 SrcItem *pI2 = &pTabList->a[j];
150361 if( pI2->fg.jointype & JT_RIGHT ){
150362 if( pI2->fg.jointype & JT_LEFT ){
150364 ("FULL-JOIN simplifies to LEFT-JOIN on term %d\n",j));
150365 pI2->fg.jointype &= ~JT_RIGHT;
150368 ("RIGHT-JOIN simplifies to JOIN on term %d\n",j));
150369 pI2->fg.jointype &= ~(JT_RIGHT|JT_OUTER);
150370 unsetJoinExpr(p->pWhere, pI2->iCursor, 1);
150374 for(j=pTabList->nSrc-1; j>=0; j--){
150375 pTabList->a[j].fg.jointype &= ~JT_LTORJ;
150376 if( pTabList->a[j].fg.jointype & JT_RIGHT ) break;
150386 if( pTab->nCol!=pSub->pEList->nExpr ){
150388 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
150396 if( pItem->fg.isCte && pItem->u2.pCteUse->eM10d==M10d_Yes ){
150404 ** will be implemented as a co-routine and there is no advantage to
150407 if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
150408 assert( pSub->pGroupBy==0 );
150410 /* If a FROM-clause subquery has an ORDER BY clause that is not
150419 ** (2) The subquery was added to help with window-function
150423 ** the built-in count(), min(), or max().
150432 if( pSub->pOrderBy!=0
150433 && (p->pOrderBy!=0 || pTabList->nSrc>1) /* Condition (5) */
150434 && pSub->pLimit==0 /* Condition (1) */
150435 && (pSub->selFlags & SF_OrderByReqd)==0 /* Condition (2) */
150436 && (p->selFlags & SF_OrderByReqd)==0 /* Condition (3) and (4) */
150440 ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i+1));
150442 pSub->pOrderBy);
150443 pSub->pOrderBy = 0;
150449 ** it will be implemented as a co-routine, then do not flatten. This
150464 if( pSub->pOrderBy!=0
150466 && (p->selFlags & SF_ComplexResult)!=0
150467 && (pTabList->nSrc==1
150468 || (pTabList->a[1].fg.jointype&(JT_OUTER|JT_CROSS))!=0)
150474 if( pParse->nErr ) goto select_end;
150476 i = -1;
150478 pTabList = p->pSrc;
150479 if( db->mallocFailed ) goto select_end;
150481 sSort.pOrderBy = p->pOrderBy;
150490 if( p->pPrior ){
150493 TREETRACE(0x400,pParse,p,("end compound-select processing\n"));
150498 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
150503 /* Do the WHERE-clause constant propagation optimization if this is
150504 ** a join. No need to speed time on this operation for non-join queries
150508 if( p->pWhere!=0
150509 && p->pWhere->op==TK_AND
150526 if( db->mallocFailed ) goto select_end;
150527 pTabList = p->pSrc;
150532 ** (2) Generate code for all sub-queries
150534 for(i=0; i<pTabList->nSrc; i++){
150535 SrcItem *pItem = &pTabList->a[i];
150548 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
150549 ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""
150556 ** assume the column name is non-NULL and segfault. The use of an empty
150559 if( pItem->colUsed==0 && pItem->zName!=0 ){
150560 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
150564 /* Generate code for all sub-queries in the FROM clause
150566 pSub = pItem->pSelect;
150567 if( pSub==0 || pItem->addrFillSub!=0 ) continue;
150570 assert( pItem->addrFillSub==0 );
150575 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
150579 pParse->nHeight += sqlite3SelectExprHeight(p);
150581 /* Make copies of constant WHERE-clause terms in the outer query down
150585 && (pItem->fg.isCte==0
150586 || (pItem->u2.pCteUse->eM10d!=M10d_Yes && pItem->u2.pCteUse->nUse<2))
150587 && pushDownWhereTerms(pParse, pSub, p->pWhere, pTabList, i)
150592 ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
150596 assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
150598 TREETRACE(0x4000,pParse,p,("WHERE-lcause push-down not possible\n"));
150611 pSub->selId));
150617 zSavedAuthContext = pParse->zAuthContext;
150618 pParse->zAuthContext = pItem->zName;
150622 if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){
150623 /* Implement a co-routine that will return a single row of the result
150628 pItem->regReturn = ++pParse->nMem;
150629 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
150631 pItem->addrFillSub = addrTop;
150632 sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
150633 ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
150635 pItem->pTab->nRowLogEst = pSub->nSelectRow;
150636 pItem->fg.viaCoroutine = 1;
150637 pItem->regResult = dest.iSdst;
150638 sqlite3VdbeEndCoroutine(v, pItem->regReturn);
150639 sqlite3VdbeJumpHere(v, addrTop-1);
150641 }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){
150644 ** the make the pItem->iCursor be a copy of the ephemeral table that
150646 CteUse *pCteUse = pItem->u2.pCteUse;
150647 sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
150648 if( pItem->iCursor!=pCteUse->iCur ){
150649 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
150652 pSub->nSelectRow = pCteUse->nRowEst;
150656 if( pPrior->addrFillSub ){
150657 sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
150659 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
150660 pSub->nSelectRow = pPrior->pSelect->nSelectRow;
150671 pItem->regReturn = ++pParse->nMem;
150673 pItem->addrFillSub = topAddr+1;
150674 pItem->fg.isMaterialized = 1;
150675 if( pItem->fg.isCorrelated==0 ){
150684 sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
150688 pItem->pTab->nRowLogEst = pSub->nSelectRow;
150690 sqlite3VdbeAddOp2(v, OP_Return, pItem->regReturn, topAddr+1);
150692 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
150695 if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){
150696 CteUse *pCteUse = pItem->u2.pCteUse;
150697 pCteUse->addrM9e = pItem->addrFillSub;
150698 pCteUse->regRtn = pItem->regReturn;
150699 pCteUse->iCur = pItem->iCursor;
150700 pCteUse->nRowEst = pSub->nSelectRow;
150703 if( db->mallocFailed ) goto select_end;
150704 pParse->nHeight -= sqlite3SelectExprHeight(p);
150705 pParse->zAuthContext = zSavedAuthContext;
150711 pEList = p->pEList;
150712 pWhere = p->pWhere;
150713 pGroupBy = p->pGroupBy;
150714 pHaving = p->pHaving;
150715 sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
150719 TREETRACE(0x8000,pParse,p,("After all FROM-clause analysis:\n"));
150725 ** if the select-list is the same as the ORDER BY list, then this query
150734 ** The second form is preferred as a single index (or temp-table) may be
150736 ** written the query must use a temp-table for at least one of the ORDER
150737 ** BY and DISTINCT, and an index or separate temp-table for the other.
150739 if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
150740 && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0
150742 && p->pWin==0
150745 p->selFlags &= ~SF_Distinct;
150746 pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
150747 p->selFlags |= SF_Aggregate;
150748 /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
150764 ** being unused if the data can be extracted in pre-sorted order.
150773 pParse, sSort.pOrderBy, 0, pEList->nExpr);
150774 sSort.iECursor = pParse->nTab++;
150777 sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0,
150781 sSort.addrSortIndex = -1;
150786 if( pDest->eDest==SRT_EphemTab ){
150787 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
150788 if( p->selFlags & SF_NestedFrom ){
150789 /* Delete or NULL-out result columns that will never be used */
150791 for(ii=pEList->nExpr-1; ii>0 && pEList->a[ii].fg.bUsed==0; ii--){
150792 sqlite3ExprDelete(db, pEList->a[ii].pExpr);
150793 sqlite3DbFree(db, pEList->a[ii].zEName);
150794 pEList->nExpr--;
150796 for(ii=0; ii<pEList->nExpr; ii++){
150797 if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
150805 if( (p->selFlags & SF_FixedLimit)==0 ){
150806 p->nSelectRow = 320; /* 4 billion rows */
150808 if( p->pLimit ) computeLimitRegisters(pParse, p, iEnd);
150809 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
150816 if( p->selFlags & SF_Distinct ){
150817 sDistinct.tabTnct = pParse->nTab++;
150820 (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
150831 | (p->selFlags & SF_FixedLimit);
150833 Window *pWin = p->pWin; /* Main window object (or NULL) */
150844 p->pEList, p, wctrlFlags, p->nSelectRow);
150846 if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
150847 p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
150855 if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
150869 assert( p->pEList==pEList );
150875 int regGosub = ++pParse->nMem;
150881 VdbeNoopComment((v, "inner-loop subroutine"));
150883 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
150886 VdbeComment((v, "end inner-loop subroutine"));
150892 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
150924 for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
150925 pItem->u.x.iAlias = 0;
150927 for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
150928 pItem->u.x.iAlias = 0;
150930 assert( 66==sqlite3LogEst(100) );
150931 if( p->nSelectRow>66 ) p->nSelectRow = 66;
150936 ** in the correct order. It also may not - the GROUP BY might use a
150941 if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){
150944 ** ASC or DESC order - only that each group is returned contiguously.
150948 for(ii=0; ii<pGroupBy->nExpr; ii++){
150950 sortFlags = sSort.pOrderBy->a[ii].fg.sortFlags & KEYINFO_ORDER_DESC;
150951 pGroupBy->a[ii].fg.sortFlags = sortFlags;
150953 if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){
150959 p->nSelectRow = 0;
150972 testcase( pParse->earlyCleanup );
150974 if( db->mallocFailed ){
150977 pAggInfo->selId = p->selId;
150979 pAggInfo->pSelect = p;
150986 pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
150987 pAggInfo->pGroupBy = pGroupBy;
150992 assert( pWhere==p->pWhere );
150993 assert( pHaving==p->pHaving );
150994 assert( pGroupBy==p->pGroupBy );
150996 pWhere = p->pWhere;
151000 pAggInfo->nAccumulator = pAggInfo->nColumn;
151001 if( p->pGroupBy==0 && p->pHaving==0 && pAggInfo->nFunc==1 ){
151002 minMaxFlag = minMaxQuery(db, pAggInfo->aFunc[0].pFExpr, &pMinMaxOrderBy);
151007 if( db->mallocFailed ) goto select_end;
151026 int addr1; /* A-vs-B comparison jump */
151038 if( pAggInfo->nFunc==1
151039 && pAggInfo->aFunc[0].iDistinct>=0
151040 && ALWAYS(pAggInfo->aFunc[0].pFExpr!=0)
151041 && ALWAYS(ExprUseXList(pAggInfo->aFunc[0].pFExpr))
151042 && pAggInfo->aFunc[0].pFExpr->x.pList!=0
151044 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
151056 pAggInfo->sortingIdx = pParse->nTab++;
151058 0, pAggInfo->nColumn);
151060 pAggInfo->sortingIdx, pAggInfo->nSortingColumn,
151065 iUseFlag = ++pParse->nMem;
151066 iAbortFlag = ++pParse->nMem;
151067 regOutputRow = ++pParse->nMem;
151069 regReset = ++pParse->nMem;
151071 iAMem = pParse->nMem + 1;
151072 pParse->nMem += pGroupBy->nExpr;
151073 iBMem = pParse->nMem + 1;
151074 pParse->nMem += pGroupBy->nExpr;
151077 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
151094 if( pParse->pIdxEpr ){
151100 if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
151120 ExplainQueryPlan2(addrExp, (pParse, 0, "USE TEMP B-TREE FOR %s",
151121 (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
151126 nGroupBy = pGroupBy->nExpr;
151129 for(i=0; i<pAggInfo->nColumn; i++){
151130 if( pAggInfo->aCol[i].iSorterColumn>=j ){
151138 pAggInfo->directMode = 1;
151139 for(i=0; i<pAggInfo->nColumn; i++){
151140 struct AggInfo_col *pCol = &pAggInfo->aCol[i];
151141 if( pCol->iSorterColumn>=j ){
151142 sqlite3ExprCode(pParse, pCol->pCExpr, j + regBase);
151146 pAggInfo->directMode = 0;
151150 sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
151151 sqlite3VdbeScanStatusRange(v, addrExp, sqlite3VdbeCurrentAddr(v)-2, -1);
151156 pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
151160 sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
151162 pAggInfo->useSortingIdx = 1;
151163 sqlite3VdbeScanStatusRange(v, addrExp, -1, sortPTab);
151164 sqlite3VdbeScanStatusRange(v, addrExp, -1, pAggInfo->sortingIdx);
151167 /* If there are entries in pAgggInfo->aFunc[] that contain subexpressions
151172 if( pParse->pIdxEpr ){
151188 ** This is an optimization - the correct answer should result regardless.
151205 sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx,
151208 for(j=0; j<pGroupBy->nExpr; j++){
151212 pAggInfo->directMode = 1;
151213 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
151216 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
151230 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
151249 sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
151269 ** is less than or equal to zero, the subroutine is a no-op. If
151286 selectInnerLoop(pParse, p, -1, &sSort,
151292 /* Generate a subroutine that will reset the group-by accumulator
151301 struct AggInfo_func *pF = &pAggInfo->aFunc[0];
151302 fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
151321 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
151322 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
151326 Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */
151329 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
151333 ** (2011-04-15) Do not do a full scan of an unordered index.
151335 ** (2013-10-03) Do not count the entries in a partial index.
151341 if( !p->pSrc->a[0].fg.notIndexed ){
151342 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
151343 if( pIdx->bUnordered==0
151344 && pIdx->szIdxRow<pTab->szTabRow
151345 && pIdx->pPartIdxWhere==0
151346 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
151353 iRoot = pBest->tnum;
151357 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
151360 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
151381 if( pAggInfo->nAccumulator ){
151382 for(i=0; i<pAggInfo->nFunc; i++){
151383 if( ExprHasProperty(pAggInfo->aFunc[i].pFExpr, EP_WinFunc) ){
151386 if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){
151390 if( i==pAggInfo->nFunc ){
151391 regAcc = ++pParse->nMem;
151394 }else if( pAggInfo->nFunc==1 && pAggInfo->aFunc[0].iDistinct>=0 ){
151395 assert( ExprUseXList(pAggInfo->aFunc[0].pFExpr) );
151396 pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList;
151405 assert( p->pGroupBy==0 );
151414 assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
151426 struct AggInfo_func *pF = pAggInfo->aFunc;
151428 fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
151443 selectInnerLoop(pParse, p, -1, 0, 0,
151458 assert( p->pEList==pEList );
151459 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
151468 rc = (pParse->nErr>0);
151474 assert( db->mallocFailed==0 || db->mallocFailed==1 );
151475 assert( db->mallocFailed==0 || pParse->nErr!=0 );
151478 if( pAggInfo && !db->mallocFailed ){
151485 for(i=0; i<pAggInfo->nColumn; i++){
151486 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
151488 assert( pExpr->pAggInfo==pAggInfo );
151489 assert( pExpr->iAgg==i );
151491 for(i=0; i<pAggInfo->nFunc; i++){
151492 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
151494 assert( pExpr->pAggInfo==pAggInfo );
151495 assert( pExpr->iAgg==i );
151555 int need; /* Slots needed in p->azResult[] */
151559 /* Make sure there is enough space in p->azResult to hold everything
151562 if( p->nRow==0 && argv!=0 ){
151567 if( p->nData + need > p->nAlloc ){
151569 p->nAlloc = p->nAlloc*2 + need;
151570 azNew = sqlite3Realloc( p->azResult, sizeof(char*)*p->nAlloc );
151572 p->azResult = azNew;
151578 if( p->nRow==0 ){
151579 p->nColumn = nCol;
151583 p->azResult[p->nData++] = z;
151585 }else if( (int)p->nColumn!=nCol ){
151586 sqlite3_free(p->zErrMsg);
151587 p->zErrMsg = sqlite3_mprintf(
151590 p->rc = SQLITE_ERROR;
151606 p->azResult[p->nData++] = z;
151608 p->nRow++;
151613 p->rc = SQLITE_NOMEM_BKPT;
151653 db->errCode = SQLITE_NOMEM;
151669 db->errCode = res.rc; /* Assume 32-bit assignment is atomic */
151682 db->errCode = SQLITE_NOMEM;
151701 azResult--;
151734 pTriggerStep = pTriggerStep->pNext;
151736 sqlite3ExprDelete(db, pTmp->pWhere);
151737 sqlite3ExprListDelete(db, pTmp->pExprList);
151738 sqlite3SelectDelete(db, pTmp->pSelect);
151739 sqlite3IdListDelete(db, pTmp->pIdList);
151740 sqlite3UpsertDelete(db, pTmp->pUpsert);
151741 sqlite3SrcListDelete(db, pTmp->pFrom);
151742 sqlite3DbFree(db, pTmp->zSpan);
151753 ** are already attached to pTab->pTrigger. But there might be additional
151755 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
151760 ** pTab as well as the triggers lised in pTab->pTrigger.
151767 assert( pParse->disableTriggers==0 );
151768 pTmpSchema = pParse->db->aDb[1].pSchema;
151769 p = sqliteHashFirst(&pTmpSchema->trigHash);
151770 pList = pTab->pTrigger;
151773 if( pTrig->pTabSchema==pTab->pSchema
151774 && pTrig->table
151775 && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
151776 && (pTrig->pTabSchema!=pTmpSchema || pTrig->bReturning)
151778 pTrig->pNext = pList;
151780 }else if( pTrig->op==TK_RETURNING ){
151782 assert( pParse->db->pVtabCtx==0 );
151784 assert( pParse->bReturning );
151785 assert( &(pParse->u1.pReturning->retTrig) == pTrig );
151786 pTrig->table = pTab->zName;
151787 pTrig->pTabSchema = pTab->pSchema;
151788 pTrig->pNext = pList;
151796 printf("Triggers for %s:", pTab->zName);
151797 for(pX=pList; pX; pX=pX->pNext){
151798 printf(" %s", pX->zName);
151811 ** in pParse->pNewTrigger. After the trigger actions have been parsed, the
151830 sqlite3 *db = pParse->db; /* The database connection */
151835 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
151841 if( pName2->n>0 ){
151854 if( !pTableName || db->mallocFailed ){
151858 /* A long-standing parser bug is that this syntax was allowed:
151866 if( db->init.busy && iDb!=1 ){
151867 sqlite3DbFree(db, pTableName->a[0].zDatabase);
151868 pTableName->a[0].zDatabase = 0;
151877 if( db->init.busy==0 && pName2->n==0 && pTab
151878 && pTab->pSchema==db->aDb[1].pSchema ){
151883 if( db->mallocFailed ) goto trigger_cleanup;
151884 assert( pTableName->nSrc==1 );
151898 if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
151907 assert( db->mallocFailed );
151910 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
151915 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
151919 assert( !db->init.busy );
151921 VVA_ONLY( pParse->ifNotExists = 1; )
151928 if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
151938 (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName->a);
151943 " trigger on table: %S", pTableName->a);
151949 int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
151951 const char *zDb = db->aDb[iTabDb].zDbSName;
151952 const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb;
151954 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
151975 pTrigger->zName = zName;
151977 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
151978 pTrigger->pSchema = db->aDb[iDb].pSchema;
151979 pTrigger->pTabSchema = pTab->pSchema;
151980 pTrigger->op = (u8)op;
151981 pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
151983 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
151984 pTrigger->pWhen = pWhen;
151987 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
151989 pTrigger->pColumns = pColumns;
151991 assert( pParse->pNewTrigger==0 );
151992 pParse->pNewTrigger = pTrigger;
151999 if( !pParse->pNewTrigger ){
152002 assert( pParse->pNewTrigger==pTrigger );
152007 if( db->init.iDb==1 ){
152010 ** dropped too. But if a TEMP trigger is created on a non-TEMP table
152014 ** "orphaned trigger" - a trigger whose associated table is missing.
152016 ** 2020-11-05 see also https://sqlite.org/forum/forumpost/157dc791df
152018 db->init.orphanTrigger = 1;
152032 Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
152034 sqlite3 *db = pParse->db; /* The database */
152039 pParse->pNewTrigger = 0;
152040 if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
152041 zName = pTrig->zName;
152042 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
152043 pTrig->step_list = pStepList;
152045 pStepList->pTrig = pTrig;
152046 pStepList = pStepList->pNext;
152048 sqlite3TokenInit(&nameToken, pTrig->zName);
152050 if( sqlite3FixTriggerStep(&sFix, pTrig->step_list)
152051 || sqlite3FixExpr(&sFix, pTrig->pWhen)
152058 assert( !db->init.busy );
152059 pParse->pNewTrigger = pTrig;
152067 if( !db->init.busy ){
152072 ** are read-only, and the trigger makes a change to a shadow table,
152073 ** then raise an error - do not allow the trigger to be created. */
152076 for(pStep=pTrig->step_list; pStep; pStep=pStep->pNext){
152077 if( pStep->zTarget!=0
152078 && sqlite3ShadowTableName(db, pStep->zTarget)
152082 pTrig->zName, pStep->zTarget);
152092 z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
152097 db->aDb[iDb].zDbSName, zName,
152098 pTrig->table, z);
152105 if( db->init.busy ){
152107 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
152113 }else if( pLink->pSchema==pLink->pTabSchema ){
152115 pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
152117 pLink->pNext = pTab->pTrigger;
152118 pTab->pTrigger = pLink;
152124 assert( IN_RENAME_OBJECT || !pParse->pNewTrigger );
152157 pTriggerStep->op = TK_SELECT;
152158 pTriggerStep->pSelect = pSelect;
152159 pTriggerStep->orconf = OE_Default;
152160 pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
152168 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
152177 sqlite3 *db = pParse->db;
152180 if( pParse->nErr ) return 0;
152181 pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
152184 memcpy(z, pName->z, pName->n);
152186 pTriggerStep->zTarget = z;
152187 pTriggerStep->op = op;
152188 pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
152190 sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
152213 sqlite3 *db = pParse->db;
152216 assert(pSelect != 0 || db->mallocFailed);
152221 pTriggerStep->pSelect = pSelect;
152224 pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
152226 pTriggerStep->pIdList = pColumn;
152227 pTriggerStep->pUpsert = pUpsert;
152228 pTriggerStep->orconf = orconf;
152230 sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
152251 SrcList *pFrom, /* FROM clause for an UPDATE-FROM, or NULL */
152258 sqlite3 *db = pParse->db;
152264 pTriggerStep->pExprList = pEList;
152265 pTriggerStep->pWhere = pWhere;
152266 pTriggerStep->pFrom = pFrom;
152271 pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
152272 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
152273 pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
152275 pTriggerStep->orconf = orconf;
152295 sqlite3 *db = pParse->db;
152301 pTriggerStep->pWhere = pWhere;
152304 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
152306 pTriggerStep->orconf = OE_Default;
152316 if( pTrigger==0 || pTrigger->bReturning ) return;
152317 sqlite3DeleteTriggerStep(db, pTrigger->step_list);
152318 sqlite3DbFree(db, pTrigger->zName);
152319 sqlite3DbFree(db, pTrigger->table);
152320 sqlite3ExprDelete(db, pTrigger->pWhen);
152321 sqlite3IdListDelete(db, pTrigger->pColumns);
152338 sqlite3 *db = pParse->db;
152340 if( db->mallocFailed ) goto drop_trigger_cleanup;
152345 assert( pName->nSrc==1 );
152346 zDb = pName->a[0].zDatabase;
152347 zName = pName->a[0].zName;
152349 for(i=OMIT_TEMPDB; i<db->nDb; i++){
152353 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
152358 sqlite3ErrorMsg(pParse, "no such trigger: %S", pName->a);
152362 pParse->checkSchema = 1;
152376 return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table);
152386 sqlite3 *db = pParse->db;
152389 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
152390 assert( iDb>=0 && iDb<db->nDb );
152392 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
152396 const char *zDb = db->aDb[iDb].zDbSName;
152399 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
152411 db->aDb[iDb].zDbSName, pTrigger->zName
152414 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
152426 pHash = &(db->aDb[iDb].pSchema->trigHash);
152429 if( pTrigger->pSchema==pTrigger->pTabSchema ){
152433 for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
152435 *pp = (*pp)->pNext;
152442 db->mDbFlags |= DBFLAG_SchemaChange;
152458 for(e=0; e<pEList->nExpr; e++){
152459 if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1;
152468 if( NEVER(db->aDb[1].pSchema==0) ) return 0;
152469 if( sqliteHashFirst(&db->aDb[1].pSchema->trigHash)==0 ) return 0;
152492 || (pList->bReturning && pList->pNext==0) );
152495 if( (pParse->db->flags & SQLITE_EnableTrigger)==0
152496 && pTab->pTrigger!=0
152501 if( pList==pTab->pTrigger ){
152505 while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext;
152506 p->pNext = 0;
152510 if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
152511 mask |= p->tr_tm;
152512 }else if( p->op==TK_RETURNING ){
152516 p->op = op;
152523 p->tr_tm = TRIGGER_BEFORE;
152525 p->tr_tm = TRIGGER_AFTER;
152527 mask |= p->tr_tm;
152528 }else if( p->bReturning && p->op==TK_INSERT && op==TK_UPDATE
152531 mask |= p->tr_tm;
152533 p = p->pNext;
152550 if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db))
152551 || pParse->disableTriggers
152560 ** Convert the pStep->zTarget string into a SrcList and return a pointer
152573 sqlite3 *db = pParse->db;
152575 char *zName = sqlite3DbStrDup(db, pStep->zTarget);
152577 assert( pSrc==0 || pSrc->nSrc==1 );
152580 Schema *pSchema = pStep->pTrig->pSchema;
152581 pSrc->a[0].zName = zName;
152582 if( pSchema!=db->aDb[1].pSchema ){
152583 pSrc->a[0].pSchema = pSchema;
152585 if( pStep->pFrom ){
152586 SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
152587 if( pDup && pDup->nSrc>1 && !IN_RENAME_OBJECT ){
152613 if( pTerm->op==TK_ASTERISK ) return 1;
152614 if( pTerm->op!=TK_DOT ) return 0;
152615 assert( pTerm->pRight!=0 );
152616 assert( pTerm->pLeft!=0 );
152617 if( pTerm->pRight->op!=TK_ASTERISK ) return 0;
152634 sqlite3 *db = pParse->db;
152637 for(i=0; i<pList->nExpr; i++){
152638 Expr *pOldExpr = pList->a[i].pExpr;
152642 for(jj=0; jj<pTab->nCol; jj++){
152644 if( IsHiddenColumn(pTab->aCol+jj) ) continue;
152645 pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName);
152647 if( !db->mallocFailed ){
152648 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
152649 pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName);
152650 pItem->fg.eEName = ENAME_NAME;
152656 if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){
152657 struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
152658 pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
152659 pItem->fg.eEName = pList->a[i].fg.eEName;
152673 && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
152683 ** If the SELECT references the table pWalker->u.pTab, then do two things:
152686 ** (2) Set pWalker->eCode to non-zero so that the caller will know
152693 pSrc = pSelect->pSrc;
152695 for(i=0; i<pSrc->nSrc; i++){
152696 if( pSrc->a[i].pTab==pWalker->u.pTab ){
152697 testcase( pSelect->selFlags & SF_Correlated );
152698 pSelect->selFlags |= SF_Correlated;
152699 pWalker->eCode = 1;
152735 ** is generated in-line.
152743 Vdbe *v = pParse->pVdbe;
152744 sqlite3 *db = pParse->db;
152751 if( !pParse->bReturning ){
152756 assert( db->pParse==pParse );
152757 pReturning = pParse->u1.pReturning;
152758 if( pTrigger != &(pReturning->retTrig) ){
152764 sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
152768 sFrom.a[0].zName = pTab->zName; /* tag-20240424-1 */
152769 sFrom.a[0].iCursor = -1;
152771 if( pParse->nErr==0 ){
152772 assert( db->mallocFailed==0 );
152776 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
152777 if( pParse->nErr==0 ){
152780 if( pReturning->nRetCol==0 ){
152781 pReturning->nRetCol = pNew->nExpr;
152782 pReturning->iRetCur = pParse->nTab++;
152787 pParse->eTriggerOp = pTrigger->op;
152788 pParse->pTriggerTab = pTab;
152790 && ALWAYS(!db->mallocFailed)
152793 int nCol = pNew->nExpr;
152794 int reg = pParse->nMem+1;
152796 pParse->nMem += nCol+2;
152797 pReturning->iRetReg = reg;
152799 Expr *pCol = pNew->a[i].pExpr;
152800 assert( pCol!=0 ); /* Due to !db->mallocFailed ~9 lines above */
152807 sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
152808 sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
152812 pParse->eTriggerOp = 0;
152813 pParse->pTriggerTab = 0;
152828 Vdbe *v = pParse->pVdbe;
152829 sqlite3 *db = pParse->db;
152831 assert( pParse->pTriggerTab && pParse->pToplevel );
152834 for(pStep=pStepList; pStep; pStep=pStep->pNext){
152845 ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy
152846 ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy
152848 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
152849 assert( pParse->okConstFactor==0 );
152852 if( pStep->zSpan ){
152854 sqlite3MPrintf(db, "-- %s", pStep->zSpan),
152859 switch( pStep->op ){
152863 sqlite3ExprListDup(db, pStep->pExprList, 0),
152864 sqlite3ExprDup(db, pStep->pWhere, 0),
152865 pParse->eOrconf, 0, 0, 0
152873 sqlite3SelectDup(db, pStep->pSelect, 0),
152874 sqlite3IdListDup(db, pStep->pIdList),
152875 pParse->eOrconf,
152876 sqlite3UpsertDup(db, pStep->pUpsert)
152884 sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0
152889 default: assert( pStep->op==TK_SELECT ); {
152891 Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0);
152922 ** Parse context structure pFrom has just been used to create a sub-vdbe
152927 assert( pFrom->zErrMsg==0 || pFrom->nErr );
152928 assert( pTo->zErrMsg==0 || pTo->nErr );
152929 if( pTo->nErr==0 ){
152930 pTo->zErrMsg = pFrom->zErrMsg;
152931 pTo->nErr = pFrom->nErr;
152932 pTo->rc = pFrom->rc;
152934 sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
152939 ** Create and populate a new TriggerPrg object with a sub-program
152949 sqlite3 *db = pParse->db; /* Database handle */
152953 NameContext sNC; /* Name context for sub-vdbe */
152954 SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */
152956 Parse sSubParse; /* Parse context for sub-vdbe */
152958 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
152959 assert( pTop->pVdbe );
152963 ** list of the top-level Parse object sooner rather than later. */
152966 pPrg->pNext = pTop->pTriggerPrg;
152967 pTop->pTriggerPrg = pPrg;
152968 pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
152970 sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
152971 pPrg->pTrigger = pTrigger;
152972 pPrg->orconf = orconf;
152973 pPrg->aColmask[0] = 0xffffffff;
152974 pPrg->aColmask[1] = 0xffffffff;
152977 ** trigger sub-program. */
152983 sSubParse.zAuthContext = pTrigger->zName;
152984 sSubParse.eTriggerOp = pTrigger->op;
152985 sSubParse.nQueryLoop = pParse->nQueryLoop;
152986 sSubParse.prepFlags = pParse->prepFlags;
152991 pTrigger->zName, onErrorText(orconf),
152992 (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
152993 (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
152994 (pTrigger->op==TK_INSERT ? "INSERT" : ""),
152995 (pTrigger->op==TK_DELETE ? "DELETE" : ""),
152996 pTab->zName
152999 if( pTrigger->zName ){
153000 sqlite3VdbeChangeP4(v, -1,
153001 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
153007 ** (or NULL) the sub-vdbe is immediately halted by jumping to the
153009 if( pTrigger->pWhen ){
153010 pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
153011 if( db->mallocFailed==0
153020 /* Code the trigger program into the sub-vdbe. */
153021 codeTriggerProgram(&sSubParse, pTrigger->step_list, orconf);
153023 /* Insert an OP_Halt at the end of the sub-program. */
153028 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
153031 if( pParse->nErr==0 ){
153032 assert( db->mallocFailed==0 );
153033 pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
153035 pProgram->nMem = sSubParse.nMem;
153036 pProgram->nCsr = sSubParse.nTab;
153037 pProgram->token = (void *)pTrigger;
153038 pPrg->aColmask[0] = sSubParse.oldmask;
153039 pPrg->aColmask[1] = sSubParse.newmask;
153051 ** Return a pointer to a TriggerPrg object containing the sub-program for
153065 assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
153071 for(pPrg=pRoot->pTriggerPrg;
153072 pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf);
153073 pPrg=pPrg->pNext
153079 pParse->db->errByteOffset = -1;
153102 assert( pPrg || pParse->nErr );
153105 ** is a pointer to the sub-vdbe containing the trigger program. */
153107 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
153109 sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
153110 (const char *)pPrg->pProgram, P4_SUBPROGRAM);
153112 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
153114 /* Set the P5 operand of the OP_Program instruction to non-zero if
153116 ** invocation is disallowed if (a) the sub-program is really a trigger,
153131 ** operation on pTab, this function is a no-op.
153136 ** (a copy of pTab->nCol), then registers are populated as follows:
153139 ** ------------------------------------------------------
153141 ** reg+1 OLD.* value of left-most column of pTab
153143 ** reg+N OLD.* value of right-most column of pTab
153145 ** reg+N+2 NEW.* value of left-most column of pTab
153147 ** reg+N+N+1 NEW.* value of right-most column of pTab
153180 for(p=pTrigger; p; p=p->pNext){
153185 assert( p->pSchema!=0 );
153186 assert( p->pTabSchema!=0 );
153187 assert( p->pSchema==p->pTabSchema
153188 || p->pSchema==pParse->db->aDb[1].pSchema );
153195 if( (p->op==op || (p->bReturning && p->op==TK_INSERT && op==TK_UPDATE))
153196 && p->tr_tm==tr_tm
153197 && checkColumnOverlap(p->pColumns, pChanges)
153199 if( !p->bReturning ){
153209 ** Triggers may access values stored in the old.* or new.* pseudo-table.
153210 ** This function returns a 32-bit bitmask indicating which columns of the
153215 ** Bit 0 of the returned mask is set if the left-most column of the
153250 for(p=pTrigger; p; p=p->pNext){
153251 if( p->op==op
153252 && (tr_tm&p->tr_tm)
153253 && checkColumnOverlap(p->pColumns,pChanges)
153255 if( p->bReturning ){
153261 mask |= pPrg->aColmask[isNew];
153306 ** i-th column of table pTab. This routine sets the P4 parameter of the
153312 ** command. If the latter, then the row-records in the table btree on disk
153315 ** If the former, then all row-records are guaranteed to include a value
153329 ** If column as REAL affinity and the table is an ordinary b-tree table
153337 assert( pTab->nCol>i );
153338 pCol = &pTab->aCol[i];
153339 if( pCol->iDflt ){
153343 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
153344 assert( i<pTab->nCol );
153347 pCol->affinity, &pValue);
153353 if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){
153362 ** and false if not. This is an optimization. False-positives are a
153363 ** performance degradation, but false-negatives can result in a corrupt
153366 ** aXRef[j] will be non-negative if column j of the original table is
153376 i16 iIdxCol = pIdx->aiColumn[iCol];
153382 assert( pIdx->aColExpr!=0 );
153383 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
153384 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
153392 ** to be unchanged. This is an optimization. False-positives are a
153393 ** performance degradation, but false-negatives can result in a corrupt
153396 ** aXRef[j] will be non-negative if column j of the original table is
153405 if( pIdx->pPartIdxWhere==0 ) return 0;
153406 return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere,
153414 ** table in the source-list (pSrc->a[0]).
153418 if( pRet ) pRet->iColumn = iCol+1;
153426 ** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere
153434 ** SELECT <other-columns>, pChanges FROM pTabList
153436 ** GROUP BY <other-columns>
153442 ** the <other-columns> in the query above are is determined by the type
153443 ** of table pTabList->a[0].pTab.
153446 ** PRIMARY KEY. In this case <other-columns> are the primary key columns
153450 ** If the table is actually a view, then <other-columns> are all columns of
153454 ** If the table is a virtual or ordinary intkey table, then <other-columns>
153457 ** rowid value in <other-columns> is used as the integer key, and the
153477 sqlite3 *db = pParse->db;
153478 Table *pTab = pTabList->a[0].pTab;
153498 assert( pTabList->nSrc>1 );
153500 assert( pSrc->a[0].fg.notCte );
153501 pSrc->a[0].iCursor = -1;
153502 pSrc->a[0].pTab->nTabRef--;
153503 pSrc->a[0].pTab = 0;
153506 for(i=0; i<pPk->nKeyCol; i++){
153507 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
153517 for(i=0; i<pTab->nCol; i++){
153530 assert( pChanges!=0 || pParse->db->mallocFailed );
153532 for(i=0; i<pChanges->nExpr; i++){
153534 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
153542 if( pSelect ) pSelect->selFlags |= SF_OrderByReqd;
153544 dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1);
153577 int iBaseCur; /* Base cursor number */
153582 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
153583 ** an expression for the i-th column of the table.
153584 ** aXRef[i]==-1 if the i-th column is not changed. */
153590 int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */
153592 NameContext sNC; /* The name-context to resolve expressions in */
153614 int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */
153626 db = pParse->db;
153627 assert( db->pParse==pParse );
153628 if( pParse->nErr ){
153631 assert( db->mallocFailed==0 );
153637 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
153659 sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere,
153665 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
153668 nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0;
153693 iBaseCur = iDataCur = pParse->nTab++;
153696 testcase( pPk!=0 && pPk!=pTab->pIndex );
153697 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
153699 iDataCur = pParse->nTab;
153701 pParse->nTab++;
153705 iDataCur = pUpsert->iDataCur;
153706 iIdxCur = pUpsert->iIdxCur;
153707 pParse->nTab = iBaseCur;
153709 pTabList->a[0].iCursor = iDataCur;
153714 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
153716 aRegIdx = aXRef+pTab->nCol;
153720 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
153722 /* Initialize the name-context */
153740 for(i=0; i<pChanges->nExpr; i++){
153741 u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName);
153744 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
153747 for(j=0; j<pTab->nCol; j++){
153748 if( pTab->aCol[j].hName==hCol
153749 && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0
153751 if( j==pTab->iPKey ){
153753 pRowidExpr = pChanges->a[i].pExpr;
153755 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
153759 else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
153760 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
153761 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
153764 pTab->aCol[j].zCnName);
153772 if( j>=pTab->nCol ){
153773 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){
153774 j = -1;
153776 pRowidExpr = pChanges->a[i].pExpr;
153779 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
153780 pParse->checkSchema = 1;
153787 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
153788 j<0 ? "ROWID" : pTab->aCol[j].zCnName,
153789 db->aDb[iDb].zDbSName);
153793 aXRef[j] = -1;
153807 ** is non-negative, so the value of aXRef[] for generated columns can be
153808 ** set to any non-negative number. We use 99999 so that the value is
153811 if( pTab->tabFlags & TF_HasGenerated ){
153813 testcase( pTab->tabFlags & TF_HasVirtual );
153814 testcase( pTab->tabFlags & TF_HasStored );
153817 for(i=0; i<pTab->nCol; i++){
153819 if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
153821 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
153837 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
153846 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
153851 reg = ++pParse->nMem;
153852 pParse->nMem += pIdx->nColumn;
153855 for(i=0; i<pIdx->nKeyCol; i++){
153857 reg = ++pParse->nMem;
153858 pParse->nMem += pIdx->nColumn;
153859 if( onError==OE_Default && pIdx->onError==OE_Replace ){
153869 aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */
153876 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
153885 ** two-pass update algorithm. */
153886 assert( aRegIdx[nAllIdx]==pParse->nMem );
153888 regOldRowid = regNewRowid = ++pParse->nMem;
153890 regOld = pParse->nMem + 1;
153891 pParse->nMem += pTab->nCol;
153894 regNewRowid = ++pParse->nMem;
153896 regNew = pParse->nMem + 1;
153897 pParse->nMem += pTab->nCol;
153902 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
153939 if( (db->flags&SQLITE_CountRows)!=0
153940 && !pParse->pTriggerTab
153941 && !pParse->nested
153942 && !pParse->bReturning
153945 regRowCount = ++pParse->nMem;
153951 iEph = pParse->nTab++;
153955 nPk = pPk ? pPk->nKeyCol : 0;
153956 iPk = pParse->nMem+1;
153957 pParse->nMem += nPk;
153958 pParse->nMem += nChangeFrom;
153959 regKey = ++pParse->nMem;
153961 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
153962 iEph = pParse->nTab++;
153963 if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
153968 pKeyInfo->nAllField = nEphCol;
154002 ** Do not consider a single-pass strategy for a multi-row update if
154012 if( !pParse->nested
154024 /* A one-pass strategy that might update more than one row may not
154040 if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
154050 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
154054 aRegIdx[nAllIdx] = ++pParse->nMem;
154066 assert( pPk->aiColumn[i]>=0 );
154068 pPk->aiColumn[i], iPk+i);
154094 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
154095 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
154098 if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
154176 /* Compute the old pre-UPDATE content of the row being changed, if that
154183 for(i=0; i<pTab->nCol; i++){
154184 u32 colFlags = pTab->aCol[i].colFlags;
154220 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154221 if( i==pTab->iPKey ){
154223 }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
154224 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
154229 int nOff = (isView ? pTab->nCol : nPk);
154233 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
154251 if( pTab->tabFlags & TF_HasGenerated ){
154252 testcase( pTab->tabFlags & TF_HasVirtual );
154253 testcase( pTab->tabFlags & TF_HasStored );
154267 /* The row-trigger may have deleted the row being updated. In this
154269 ** required. This behavior - what happens when the row being updated
154270 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
154281 /* After-BEFORE-trigger-reload-loop:
154287 ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26)
154290 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154291 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
154292 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
154293 }else if( aXRef[i]<0 && i!=pTab->iPKey ){
154298 if( pTab->tabFlags & TF_HasGenerated ){
154299 testcase( pTab->tabFlags & TF_HasVirtual );
154300 testcase( pTab->tabFlags & TF_HasStored );
154332 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
154345 ** to invoke the pre-update hook.
154348 ** pre-update hook. If the caller invokes preupdate_new(), the returned
154362 if( !pParse->nested ){
154405 /* Nothing to do at end-of-loop for a single-pass */
154419 if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
154457 ** There are two possible strategies - the default and the special
154485 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
154488 sqlite3 *db = pParse->db; /* Database connection */
154491 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
154495 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
154504 ephemTab = pParse->nTab++;
154506 regArg = pParse->nMem + 1;
154507 pParse->nMem += nArg;
154508 if( pSrc->nSrc>1 ){
154522 assert( pPk->nKeyCol==1 );
154523 iPk = pPk->aiColumn[0];
154525 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
154532 for(i=0; i<pTab->nCol; i++){
154535 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
154539 if( pRowExpr ) pRowExpr->op2 = OPFLAG_NOCHNG;
154548 regRec = ++pParse->nMem;
154549 regRowid = ++pParse->nMem;
154558 for(i=0; i<pTab->nCol; i++){
154559 assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
154561 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
154579 assert( pPk->nKeyCol==1 );
154580 iPk = pPk->aiColumn[0];
154591 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
154602 ** accept no-change records with serial_type 10 */
154613 if( pSrc->nSrc==1 ){
154646 ** 2018-04-12
154667 Upsert *pNext = p->pNextUpsert;
154668 sqlite3ExprListDelete(db, p->pUpsertTarget);
154669 sqlite3ExprDelete(db, p->pUpsertTargetWhere);
154670 sqlite3ExprListDelete(db, p->pUpsertSet);
154671 sqlite3ExprDelete(db, p->pUpsertWhere);
154672 sqlite3DbFree(db, p->pToFree);
154688 sqlite3ExprListDup(db, p->pUpsertTarget, 0),
154689 sqlite3ExprDup(db, p->pUpsertTargetWhere, 0),
154690 sqlite3ExprListDup(db, p->pUpsertSet, 0),
154691 sqlite3ExprDup(db, p->pUpsertWhere, 0),
154692 sqlite3UpsertDup(db, p->pNextUpsert)
154717 pNew->pUpsertTarget = pTarget;
154718 pNew->pUpsertTargetWhere = pTargetWhere;
154719 pNew->pUpsertSet = pSet;
154720 pNew->pUpsertWhere = pWhere;
154721 pNew->isDoUpdate = pSet!=0;
154722 pNew->pNextUpsert = pNext;
154729 ** symbols in the conflict-target.
154744 ExprList *pTarget; /* The conflict-target clause */
154745 Expr *pTerm; /* One term of the conflict-target clause */
154750 assert( pTabList->nSrc==1 );
154751 assert( pTabList->a[0].pTab!=0 );
154753 assert( pUpsert->pUpsertTarget!=0 );
154755 /* Resolve all symbolic names in the conflict-target clause, which
154756 ** includes both the list of columns and the optional partial-index
154762 for(; pUpsert && pUpsert->pUpsertTarget;
154763 pUpsert=pUpsert->pNextUpsert, nClause++){
154764 rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
154766 rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
154770 pTab = pTabList->a[0].pTab;
154771 pTarget = pUpsert->pUpsertTarget;
154772 iCursor = pTabList->a[0].iCursor;
154774 && pTarget->nExpr==1
154775 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
154776 && pTerm->iColumn==XN_ROWID
154778 /* The conflict-target is the rowid of the primary table */
154779 assert( pUpsert->pUpsertIdx==0 );
154787 ** prior to comparing against the conflict-target expression.
154793 sCol[1].iTable = pTabList->a[0].iCursor;
154796 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
154799 if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
154800 if( pIdx->pPartIdxWhere ){
154801 if( pUpsert->pUpsertTargetWhere==0 ) continue;
154802 if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
154803 pIdx->pPartIdxWhere, iCursor)!=0 ){
154807 nn = pIdx->nKeyCol;
154810 sCol[0].u.zToken = (char*)pIdx->azColl[ii];
154811 if( pIdx->aiColumn[ii]==XN_EXPR ){
154812 assert( pIdx->aColExpr!=0 );
154813 assert( pIdx->aColExpr->nExpr>ii );
154814 assert( pIdx->bHasExpr );
154815 pExpr = pIdx->aColExpr->a[ii].pExpr;
154816 if( pExpr->op!=TK_COLLATE ){
154822 sCol[1].iColumn = pIdx->aiColumn[ii];
154826 if( sqlite3ExprCompare(0,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
154840 pUpsert->pUpsertIdx = pIdx;
154844 ** after multi-CONFLICT upsert was added, and so we silently ignore
154847 pUpsert->isDup = 1;
154851 if( pUpsert->pUpsertIdx==0 ){
154853 if( nClause==0 && pUpsert->pNextUpsert==0 ){
154874 pNext = pUpsert->pNextUpsert;
154875 while( 1 /*exit-by-return*/ ){
154877 if( pNext->pUpsertTarget==0 ) return 1;
154878 if( pNext->pUpsertIdx==0 ) return 1;
154879 if( !pNext->isDup ) return 0;
154880 pNext = pNext->pNextUpsert;
154894 && pUpsert->pUpsertTarget!=0
154895 && pUpsert->pUpsertIdx!=pIdx
154897 pUpsert = pUpsert->pNextUpsert;
154906 ** In this case parameter iCur is a cursor open on the table b-tree that
154912 Parse *pParse, /* The parsing and code-generating context */
154918 Vdbe *v = pParse->pVdbe;
154919 sqlite3 *db = pParse->db;
154927 iDataCur = pUpsert->iDataCur;
154939 int nPk = pPk->nKeyCol;
154940 int iPk = pParse->nMem+1;
154941 pParse->nMem += nPk;
154944 assert( pPk->aiColumn[i]>=0 );
154945 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
154947 VdbeComment((v, "%s.%s", pIdx->zName,
154948 pTab->aCol[pPk->aiColumn[i]].zCnName));
154959 /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does.
154961 pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0);
154963 for(i=0; i<pTab->nCol; i++){
154964 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
154965 sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i);
154968 sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0),
154969 sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert);
155013 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
155085 if( pParse->nErr ) goto build_vacuum_end;
155094 ** to VACUUM are silently ignored. This is a back-out of a bug fix that
155095 ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
155098 iDb = sqlite3FindDb(pParse->db, pNm);
155105 iIntoReg = ++pParse->nMem;
155112 sqlite3ExprDelete(pParse->db, pInto);
155128 u32 saved_mDbFlags; /* Saved value of db->mDbFlags */
155129 u64 saved_flags; /* Saved value of db->flags */
155130 i64 saved_nChange; /* Saved value of db->nChange */
155131 i64 saved_nTotalChange; /* Saved value of db->nTotalChange */
155132 u32 saved_openFlags; /* Saved value of db->openFlags */
155142 if( !db->autoCommit ){
155144 return SQLITE_ERROR; /* IMP: R-12218-18073 */
155146 if( db->nVdbeActive>1 ){
155147 sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
155148 return SQLITE_ERROR; /* IMP: R-15610-35227 */
155150 saved_openFlags = db->openFlags;
155153 sqlite3SetString(pzErrMsg, db, "non-text filename");
155157 db->openFlags &= ~SQLITE_OPEN_READONLY;
155158 db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE;
155164 ** restored before returning. Then set the writable-schema flag, and
155166 saved_flags = db->flags;
155167 saved_mDbFlags = db->mDbFlags;
155168 saved_nChange = db->nChange;
155169 saved_nTotalChange = db->nTotalChange;
155170 saved_mTrace = db->mTrace;
155171 db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
155172 db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum;
155173 db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder
155175 db->mTrace = 0;
155177 zDbMain = db->aDb[iDb].zDbSName;
155178 pMain = db->aDb[iDb].pBt;
155187 ** An optimization would be to use a non-journaled pager.
155195 nDb = db->nDb;
155197 db->openFlags = saved_openFlags;
155199 assert( (db->nDb-1)==nDb );
155200 pDb = &db->aDb[nDb];
155201 assert( strcmp(pDb->zDbSName,"vacuum_db")==0 );
155202 pTemp = pDb->pBt;
155206 if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){
155211 db->mDbFlags |= DBFLAG_VacuumInto;
155213 /* For a VACUUM INTO, the pager-flags are set to the same values as
155216 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
155220 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
155226 ** to ensure that we do not try to change the page-size on a WAL database.
155238 db->nextPagesize = 0;
155242 || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
155243 || NEVER(db->mallocFailed)
155250 sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
155257 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
155271 db->init.iDb = 0;
155284 assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 );
155285 db->mDbFlags &= ~DBFLAG_Vacuum;
155304 ** both transactions are closed by this block - the main database
155358 /* Restore the original value of db->flags */
155359 db->init.iDb = 0;
155360 db->mDbFlags = saved_mDbFlags;
155361 db->flags = saved_flags;
155362 db->nChange = saved_nChange;
155363 db->nTotalChange = saved_nTotalChange;
155364 db->mTrace = saved_mTrace;
155365 sqlite3BtreeSetPageSize(pMain, -1, 0, 1);
155374 db->autoCommit = 1;
155377 sqlite3BtreeClose(pDb->pBt);
155378 pDb->pBt = 0;
155379 pDb->pSchema = 0;
155382 /* This both clears the schemas and reduces the size of the db->aDb[]
155453 pMod->zName = zCopy;
155454 pMod->pModule = pModule;
155455 pMod->pAux = pAux;
155456 pMod->xDestroy = xDestroy;
155457 pMod->pEpoTab = 0;
155458 pMod->nRefModule = 1;
155460 pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
155488 sqlite3_mutex_enter(db->mutex);
155492 sqlite3_mutex_leave(db->mutex);
155498 ** External API function used to create a new virtual-table module.
155513 ** External API function used to create a new virtual-table module.
155529 ** External API to drop all virtual-table modules, except those named
155537 for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
155542 for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
155545 createModule(db, pMod->zName, 0, 0, 0);
155555 assert( pMod->nRefModule>0 );
155556 pMod->nRefModule--;
155557 if( pMod->nRefModule==0 ){
155558 if( pMod->xDestroy ){
155559 pMod->xDestroy(pMod->pAux);
155561 assert( pMod->pEpoTab==0 );
155575 pVTab->nRef++;
155580 ** pTab is a pointer to a Table structure representing a virtual-table.
155582 ** this virtual-table, if one has been created, or NULL otherwise.
155587 for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
155592 ** Decrement the ref-count on a virtual table object. When the ref-count
155596 sqlite3 *db = pVTab->db;
155599 assert( pVTab->nRef>0 );
155600 assert( db->eOpenState==SQLITE_STATE_OPEN
155601 || db->eOpenState==SQLITE_STATE_ZOMBIE );
155603 pVTab->nRef--;
155604 if( pVTab->nRef==0 ){
155605 sqlite3_vtab *p = pVTab->pVtab;
155607 p->pModule->xDisconnect(p);
155609 sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);
155616 ** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated
155619 ** connection db is left in the p->u.vtab.p list.
155626 pVTable = p->u.vtab.p;
155627 p->u.vtab.p = 0;
155633 ** database connection that may have an entry in the p->u.vtab.p list.
155635 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
155638 sqlite3 *db2 = pVTable->db;
155639 VTable *pNext = pVTable->pNext;
155643 p->u.vtab.p = pRet;
155644 pRet->pNext = 0;
155646 pVTable->pNext = db2->pDisconnect;
155647 db2->pDisconnect = pVTable;
155659 ** list in p->pVTab. It also decrements the VTable ref count. This is
155662 ** be being used by other shared-cache connections).
155669 assert( sqlite3_mutex_held(db->mutex) );
155671 for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){
155672 if( (*ppVTab)->db==db ){
155674 *ppVTab = pVTab->pNext;
155686 ** shared b-tree databases opened using connection db are held by the
155696 ** or, if the virtual table is stored in a non-sharable database, then
155700 ** by multiple threads. It is thread-safe.
155703 VTable *p = db->pDisconnect;
155706 assert( sqlite3_mutex_held(db->mutex) );
155709 db->pDisconnect = 0;
155711 VTable *pNext = p->pNext;
155719 ** Clear any and all virtual-table information from the Table record.
155723 ** Since it is a virtual-table, the Table structure contains a pointer
155735 if( db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
155736 if( p->u.vtab.azArg ){
155738 for(i=0; i<p->u.vtab.nArg; i++){
155739 if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]);
155741 sqlite3DbFree(db, p->u.vtab.azArg);
155746 ** Add a new module argument to pTable->u.vtab.azArg[].
155747 ** The string is not copied - the pointer is stored. The
155754 sqlite3 *db = pParse->db;
155757 nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg);
155758 if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
155759 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
155761 azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes);
155765 int i = pTable->u.vtab.nArg++;
155768 pTable->u.vtab.azArg = azModuleArg;
155788 pTable = pParse->pNewTable;
155790 assert( 0==pTable->pIndex );
155791 pTable->eTabType = TABTYP_VTAB;
155793 db = pParse->db;
155795 assert( pTable->u.vtab.nArg==0 );
155798 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
155799 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
155800 || (pParse->sNameToken.z==pName1->z && pName2->z==0)
155802 pParse->sNameToken.n = (int)(
155803 &pModuleName->z[pModuleName->n] - pParse->sNameToken.z
155812 if( pTable->u.vtab.azArg ){
155813 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
155815 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
155816 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
155823 ** in pParse->zArg[] and appends it to the list of arguments on the
155824 ** virtual table currently under construction in pParse->pTable.
155827 if( pParse->sArg.z && pParse->pNewTable ){
155828 const char *z = (const char*)pParse->sArg.z;
155829 int n = pParse->sArg.n;
155830 sqlite3 *db = pParse->db;
155831 addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
155840 Table *pTab = pParse->pNewTable; /* The table being constructed */
155841 sqlite3 *db = pParse->db; /* The database connection */
155846 pParse->sArg.z = 0;
155847 if( pTab->u.vtab.nArg<1 ) return;
155855 if( !db->init.busy ){
155866 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
155868 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
155874 ** The VM register number pParse->regRowid holds the rowid of an
155878 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155883 db->aDb[iDb].zDbSName,
155884 pTab->zName,
155885 pTab->zName,
155887 pParse->regRowid
155893 zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
155897 iReg = ++pParse->nMem;
155898 sqlite3VdbeLoadString(v, iReg, pTab->zName);
155901 /* If we are rereading the sqlite_schema table create the in-memory
155904 Schema *pSchema = pTab->pSchema;
155905 const char *zName = pTab->zName;
155908 pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
155914 pParse->pNewTable = 0;
155924 pParse->sArg.z = 0;
155925 pParse->sArg.n = 0;
155933 Token *pArg = &pParse->sArg;
155934 if( pArg->z==0 ){
155935 pArg->z = p->z;
155936 pArg->n = p->n;
155938 assert(pArg->z <= p->z);
155939 pArg->n = (int)(&p->z[p->n] - pArg->z);
155959 int nArg = pTab->u.vtab.nArg;
155966 azArg = (const char *const*)pTab->u.vtab.azArg;
155968 /* Check that the virtual-table is not already being initialized */
155969 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
155970 if( pCtx->pTab==pTab ){
155972 "vtable constructor called recursively: %s", pTab->zName
155978 zModuleName = sqlite3DbStrDup(db, pTab->zName);
155989 pVTable->db = db;
155990 pVTable->pMod = pMod;
155991 pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;
155993 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155994 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
155997 assert( &db->pVtabCtx );
156001 sCtx.pPrior = db->pVtabCtx;
156003 db->pVtabCtx = &sCtx;
156004 pTab->nTabRef++;
156005 rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
156007 assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
156009 db->pVtabCtx = sCtx.pPrior;
156021 }else if( ALWAYS(pVTable->pVtab) ){
156024 memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0]));
156025 pVTable->pVtab->pModule = pMod->pModule;
156026 pMod->nRefModule++;
156027 pVTable->nRef = 1;
156037 ** into the linked list headed by pTab->u.vtab.p. Then loop through the
156041 pVTable->pNext = pTab->u.vtab.p;
156042 pTab->u.vtab.p = pVTable;
156044 for(iCol=0; iCol<pTab->nCol; iCol++){
156045 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
156051 && (i==0 || zType[i-1]==' ')
156064 assert(zType[i-1]==' ');
156065 zType[i-1] = '\0';
156067 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
156068 pTab->tabFlags |= TF_HasHidden;
156071 pTab->tabFlags |= oooHidden;
156086 ** This call is a no-op if table pTab is not a virtual table.
156089 sqlite3 *db = pParse->db;
156101 zMod = pTab->u.vtab.azArg[0];
156102 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
156105 const char *zModule = pTab->u.vtab.azArg[0];
156110 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
156113 pParse->rc = rc;
156121 ** Grow the db->aVTrans[] array so that there is room for at least one
156122 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
156128 if( (db->nVTrans%ARRAY_INCR)==0 ){
156131 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
156132 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
156136 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
156137 db->aVTrans = aVTrans;
156149 db->aVTrans[db->nVTrans++] = pVTab;
156167 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
156168 assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );
156171 zMod = pTab->u.vtab.azArg[0];
156172 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
156178 if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){
156182 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
156232 sqlite3_mutex_enter(db->mutex);
156233 pCtx = db->pVtabCtx;
156234 if( !pCtx || pCtx->bDeclared ){
156236 sqlite3_mutex_leave(db->mutex);
156240 pTab = pCtx->pTab;
156247 ** schema. Nevertheless, defend against that (turn off db->init.busy)
156249 assert( db->init.busy==0 );
156250 initBusy = db->init.busy;
156251 db->init.busy = 0;
156255 assert( !db->mallocFailed );
156258 if( !pTab->aCol ){
156261 pTab->aCol = pNew->aCol;
156262 sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
156263 pTab->nNVCol = pTab->nCol = pNew->nCol;
156264 pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
156265 pNew->nCol = 0;
156266 pNew->aCol = 0;
156267 assert( pTab->pIndex==0 );
156270 && pCtx->pVTable->pMod->pModule->xUpdate!=0
156271 && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
156273 /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
156274 ** or else must have a single-column PRIMARY KEY */
156277 pIdx = pNew->pIndex;
156279 assert( pIdx->pNext==0 );
156280 pTab->pIndex = pIdx;
156281 pNew->pIndex = 0;
156282 pIdx->pTable = pTab;
156285 pCtx->bDeclared = 1;
156299 db->init.busy = initBusy;
156303 sqlite3_mutex_leave(db->mutex);
156312 ** This call is a no-op if zTab is not a virtual table.
156318 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
156321 && ALWAYS(pTab->u.vtab.p!=0)
156325 for(p=pTab->u.vtab.p; p; p=p->pNext){
156326 assert( p->pVtab );
156327 if( p->pVtab->nRef>0 ){
156332 xDestroy = p->pMod->pModule->xDestroy;
156333 if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
156335 pTab->nTabRef++;
156336 rc = xDestroy(p->pVtab);
156339 assert( pTab->u.vtab.p==p && p->pNext==0 );
156340 p->pVtab = 0;
156341 pTab->u.vtab.p = 0;
156360 if( db->aVTrans ){
156361 VTable **aVTrans = db->aVTrans;
156362 db->aVTrans = 0;
156363 for(i=0; i<db->nVTrans; i++){
156365 sqlite3_vtab *p = pVTab->pVtab;
156368 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
156371 pVTab->iSavepoint = 0;
156375 db->nVTrans = 0;
156384 ** If an error message is available, leave it in p->zErrMsg.
156389 VTable **aVTrans = db->aVTrans;
156391 db->aVTrans = 0;
156392 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
156394 sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
156395 if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
156400 db->aVTrans = aVTrans;
156434 /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
156445 pModule = pVTab->pVtab->pModule;
156447 if( pModule->xBegin ){
156451 for(i=0; i<db->nVTrans; i++){
156452 if( db->aVTrans[i]==pVTab ){
156461 rc = pModule->xBegin(pVTab->pVtab);
156463 int iSvpt = db->nStatement + db->nSavepoint;
156465 if( iSvpt && pModule->xSavepoint ){
156466 pVTab->iSavepoint = iSvpt;
156467 rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);
156494 assert( iSavepoint>=-1 );
156495 if( db->aVTrans ){
156497 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
156498 VTable *pVTab = db->aVTrans[i];
156499 const sqlite3_module *pMod = pVTab->pMod->pModule;
156500 if( pVTab->pVtab && pMod->iVersion>=2 ){
156505 xMethod = pMod->xSavepoint;
156506 pVTab->iSavepoint = iSavepoint+1;
156509 xMethod = pMod->xRollbackTo;
156512 xMethod = pMod->xRelease;
156515 if( xMethod && pVTab->iSavepoint>iSavepoint ){
156516 u64 savedFlags = (db->flags & SQLITE_Defensive);
156517 db->flags &= ~(u64)SQLITE_Defensive;
156518 rc = xMethod(pVTab->pVtab, iSavepoint);
156519 db->flags |= savedFlags;
156557 if( pExpr->op!=TK_COLUMN ) return pDef;
156559 pTab = pExpr->y.pTab;
156562 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
156564 assert( pVtab->pModule!=0 );
156565 pMod = (sqlite3_module *)pVtab->pModule;
156566 if( pMod->xFindFunction==0 ) return pDef;
156572 ** with an all lower-case function name. Continue in this tradition to
156578 for(i=0; pDef->zName[i]; i++){
156579 unsigned char x = (unsigned char)pDef->zName[i];
156584 rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
156592 + sqlite3Strlen30(pDef->zName) + 1);
156597 pNew->zName = (const char*)&pNew[1];
156598 memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);
156599 pNew->xSFunc = xSFunc;
156600 pNew->pUserData = pArg;
156601 pNew->funcFlags |= SQLITE_FUNC_EPHEM;
156606 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
156609 ** is a no-op.
156617 for(i=0; i<pToplevel->nVtabLock; i++){
156618 if( pTab==pToplevel->apVtabLock[i] ) return;
156620 n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
156621 apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n);
156623 pToplevel->apVtabLock = apVtabLock;
156624 pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
156626 sqlite3OomFault(pToplevel->db);
156633 ** exist. Return non-zero if either the eponymous virtual table instance
156640 ** instances always exist. They cannot be DROP-ed.
156646 const sqlite3_module *pModule = pMod->pModule;
156650 sqlite3 *db = pParse->db;
156651 if( pMod->pEpoTab ) return 1;
156652 if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0;
156655 pTab->zName = sqlite3DbStrDup(db, pMod->zName);
156656 if( pTab->zName==0 ){
156660 pMod->pEpoTab = pTab;
156661 pTab->nTabRef = 1;
156662 pTab->eTabType = TABTYP_VTAB;
156663 pTab->pSchema = db->aDb[0].pSchema;
156664 assert( pTab->u.vtab.nArg==0 );
156665 pTab->iPKey = -1;
156666 pTab->tabFlags |= TF_Eponymous;
156667 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156669 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156670 rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
156684 Table *pTab = pMod->pEpoTab;
156689 pTab->tabFlags |= TF_Ephemeral;
156691 pMod->pEpoTab = 0;
156711 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
156712 return (int)aMap[db->vtabOnConflict-1];
156728 sqlite3_mutex_enter(db->mutex);
156729 p = db->pVtabCtx;
156733 assert( p->pTab==0 || IsVirtual(p->pTab) );
156737 p->pVTable->bConstraint = (u8)va_arg(ap, int);
156741 p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low;
156745 p->pVTable->eVtabRisk = SQLITE_VTABRISK_High;
156749 p->pVTable->bAllSchemas = 1;
156761 sqlite3_mutex_leave(db->mutex);
156770 ** 2015-06-06
156783 ** This file was split off from where.c on 2015-06-06 in order to reduce the
156792 ** 2013-11-12
156861 ** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop.
156869 int addrSkip; /* Jump here for next iteration of skip-scan */
156873 int regBignull; /* big-null flag reg. True if a NULL-scan is needed */
156874 int addrBignull; /* Jump here for next part of big-null scan */
156884 union { /* Information that depends on pWLoop->wsFlags */
156890 int iBase; /* Base register of multi-key index record */
156894 } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */
156908 ** prevent a query solution - which is an error) and many terms of the
156910 ** potential way of implementing that FROM-clause term, together with
156926 LogEst rSetup; /* One-time setup cost (ex: create transient index) */
156969 ** correspond to the subquery(s) of OR-clause processing. Only the
156985 ** vector, not a scalar, and because dependencies are many-to-one, not
156986 ** one-to-one as are graph nodes. But it is a useful visualization aid.)
157002 i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */
157015 ** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm
157046 ** spread out over the non-negative integers. For example, the cursor
157065 int iParent; /* Disable pWC->a[iParent] when this term disabled */
157075 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
157088 #define TERM_OK 0x0040 /* Used during OR-clause processing */
157094 #define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */
157101 #define TERM_SLICE 0x8000 /* One slice of a row-value/vector comparison */
157112 int k; /* Resume scanning at this->pWC->a[this->k] */
157118 i16 aiColumn[11]; /* Corresponding column number in the eq-class */
157140 int nBase; /* Number of terms through the last non-Virtual */
157178 ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask
157179 ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A.
157186 ** above, the mapping might go like this: 4->3, 5->1, 8->2, 29->0,
157187 ** 57->5, 73->4. Or one of 719 other combinations might be used. It
157226 ** routine. The limit is high enough that is should not impact real-world
157264 int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
157273 unsigned bOrderedInnerLoop:1;/* True if only the inner-most loop is ordered */
157287 ** Private interfaces - callable only by other where.c routines.
157339 int iLevel, /* Which level of pWInfo->a[] should be coded */
157367 ** OR-ed combination of these values can be used when searching for
157379 #define WO_LT (WO_EQ<<(TK_LT-TK_EQ))
157380 #define WO_LE (WO_EQ<<(TK_LE-TK_EQ))
157381 #define WO_GT (WO_EQ<<(TK_GT-TK_EQ))
157382 #define WO_GE (WO_EQ<<(TK_GE-TK_EQ))
157386 #define WO_OR 0x0200 /* Two or more OR-connected terms */
157387 #define WO_AND 0x0400 /* Two or more AND-connected terms */
157390 #define WO_ROWVAL 0x2000 /* A row-value term */
157393 #define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */
157408 #define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */
157416 #define WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */
157421 #define WHERE_IN_SEEKSCAN 0x00100000 /* Seek-scan optimization for IN */
157423 #define WHERE_BLOOMFILTER 0x00400000 /* Consider using a Bloom-filter */
157426 /* 0x02000000 -- available for reuse */
157427 #define WHERE_EXPRIDX 0x04000000 /* Uses an index-on-expressions */
157437 ** Return the name of the i-th column of the pIdx index.
157440 i = pIdx->aiColumn[i];
157443 return pIdx->pTable->aCol[i].zCnName;
157458 int iTerm, /* Zero-based index of first term. */
157459 int bAnd, /* Non-zero to append " AND " */
157499 Index *pIndex = pLoop->u.btree.pIndex;
157500 u16 nEq = pLoop->u.btree.nEq;
157501 u16 nSkip = pLoop->nSkip;
157504 if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return;
157513 if( pLoop->wsFlags&WHERE_BTM_LIMIT ){
157514 explainAppendTerm(pStr, pIndex, pLoop->u.btree.nBtm, j, i, ">");
157517 if( pLoop->wsFlags&WHERE_TOP_LIMIT ){
157518 explainAppendTerm(pStr, pIndex, pLoop->u.btree.nTop, j, i, "<");
157524 ** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN
157526 ** was defined at compile-time. If it is not a no-op, a single OP_Explain
157540 if( sqlite3ParseToplevel(pParse)->explain==2 || IS_STMT_SCANSTATUS(pParse->db) )
157543 SrcItem *pItem = &pTabList->a[pLevel->iFrom];
157544 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157545 sqlite3 *db = pParse->db; /* Database handle */
157551 char zBuf[100]; /* Initial space for EQP output string */
157553 pLoop = pLevel->pWLoop;
157554 flags = pLoop->wsFlags;
157558 || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0))
157568 assert( pLoop->u.btree.pIndex!=0 );
157569 pIdx = pLoop->u.btree.pIndex;
157571 if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){
157586 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
157592 const Table *pTab = pItem->pTab;
157593 const char *zRowid = pTab->iPKey>=0 ? pTab->aCol[pTab->iPKey].zCnName:
157615 pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
157618 if( pItem->fg.jointype & JT_LEFT ){
157619 sqlite3_str_appendf(&str, " LEFT-JOIN");
157622 if( pLoop->nOut>=10 ){
157624 sqlite3LogEstToInt(pLoop->nOut));
157632 pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
157642 ** required and this routine is a no-op.
157653 SrcItem *pItem = &pWInfo->pTabList->a[pLevel->iFrom];
157654 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157655 sqlite3 *db = pParse->db; /* Database handle */
157660 char zBuf[100]; /* Initial space for EQP output string */
157665 pLoop = pLevel->pWLoop;
157666 if( pLoop->wsFlags & WHERE_IPK ){
157667 const Table *pTab = pItem->pTab;
157668 if( pTab->iPKey>=0 ){
157669 sqlite3_str_appendf(&str, "%s=?", pTab->aCol[pTab->iPKey].zCnName);
157674 for(i=pLoop->nSkip; i<pLoop->u.btree.nEq; i++){
157675 const char *z = explainIndexColumnName(pLoop->u.btree.pIndex, i);
157676 if( i>pLoop->nSkip ) sqlite3_str_append(&str, " AND ", 5);
157683 pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
157685 sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0);
157708 WhereLoop *pLoop = pLvl->pWLoop;
157709 int wsFlags = pLoop->wsFlags;
157712 if( (wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){
157713 zObj = pLoop->u.btree.pIndex->zName;
157715 zObj = pSrclist->a[pLvl->iFrom].zName;
157716 viaCoroutine = pSrclist->a[pLvl->iFrom].fg.viaCoroutine;
157719 v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj
157724 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur);
157727 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);
157730 int addr = pSrclist->a[pLvl->iFrom].addrFillSub;
157731 VdbeOp *pOp = sqlite3VdbeGetOp(v, addr-1);
157732 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
157733 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
157734 sqlite3VdbeScanStatusRange(v, addrExplain, addr, pOp->p2-1);
157781 ** LIKE-optimization loop, when scanning BLOBs instead of strings.
157786 while( (pTerm->wtFlags & TERM_CODED)==0
157787 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
157788 && (pLevel->notReady & pTerm->prereqAll)==0
157790 if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
157791 pTerm->wtFlags |= TERM_LIKECOND;
157793 pTerm->wtFlags |= TERM_CODED;
157797 sqlite3DebugPrintf("DISABLE-");
157798 sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a)));
157801 if( pTerm->iParent<0 ) break;
157802 pTerm = &pTerm->pWC->a[pTerm->iParent];
157804 pTerm->nChild--;
157805 if( pTerm->nChild!=0 ) break;
157812 ** to the n registers starting at base.
157815 ** are no-ops) at the beginning and end of zAff are ignored. If all entries
157821 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
157822 Vdbe *v = pParse->pVdbe;
157824 assert( pParse->db->mallocFailed );
157829 /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE
157834 n--;
157835 base++;
157838 while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){
157839 n--;
157844 sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
157910 sqlite3 *db = pParse->db;
157914 if( db->mallocFailed==0 ){
157915 for(pSelect=pNew->x.pSelect; pSelect; pSelect=pSelect->pPrior){
157923 pOrigRhs = pSelect->pEList;
157924 assert( pNew->pLeft!=0 );
157925 assert( ExprUseXList(pNew->pLeft) );
157926 if( pSelect==pNew->x.pSelect ){
157927 pOrigLhs = pNew->pLeft->x.pList;
157929 for(i=iEq; i<pLoop->nLTerm; i++){
157930 if( pLoop->aLTerm[i]->pExpr==pX ){
157932 assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );
157933 iField = pLoop->aLTerm[i]->u.x.iField - 1;
157934 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
157935 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
157936 pOrigRhs->a[iField].pExpr = 0;
157938 assert( pOrigLhs->a[iField].pExpr!=0 );
157939 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
157940 pOrigLhs->a[iField].pExpr = 0;
157947 pNew->pLeft->x.pList = pLhs;
157949 pSelect->pEList = pRhs;
157950 if( pLhs && pLhs->nExpr==1 ){
157954 Expr *p = pLhs->a[0].pExpr;
157955 pLhs->a[0].pExpr = 0;
157956 sqlite3ExprDelete(db, pNew->pLeft);
157957 pNew->pLeft = p;
157959 if( pSelect->pOrderBy ){
157961 ** iOrderByCol variables. These are set to non-zero when an
157963 ** result-set. Since the result-set of the SELECT statement may
157967 ExprList *pOrderBy = pSelect->pOrderBy;
157968 for(i=0; i<pOrderBy->nExpr; i++){
157969 pOrderBy->a[i].u.x.iOrderByCol = 0;
157997 ** straight-line code. For constraints of the form X IN (...)
158005 int bRev, /* True for reverse-order IN operations */
158008 Expr *pX = pTerm->pExpr;
158009 Vdbe *v = pParse->pVdbe;
158012 assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
158014 if( pX->op==TK_EQ || pX->op==TK_IS ){
158015 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
158016 }else if( pX->op==TK_ISNULL ){
158024 WhereLoop *pLoop = pLevel->pWLoop;
158029 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
158030 && pLoop->u.btree.pIndex!=0
158031 && pLoop->u.btree.pIndex->aSortOrder[iEq]
158037 assert( pX->op==TK_IN );
158041 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
158046 for(i=iEq;i<pLoop->nLTerm; i++){
158047 assert( pLoop->aLTerm[i]!=0 );
158048 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
158052 if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
158055 Expr *pExpr = pTerm->pExpr;
158056 if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
158057 sqlite3 *db = pParse->db;
158059 if( !db->mallocFailed ){
158060 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
158062 pExpr->iTable = iTab;
158066 int n = sqlite3ExprVectorSize(pX->pLeft);
158067 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n));
158081 assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
158082 pLoop->wsFlags |= WHERE_IN_ABLE;
158083 if( pLevel->u.in.nIn==0 ){
158084 pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
158086 if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){
158087 pLoop->wsFlags |= WHERE_IN_EARLYOUT;
158090 i = pLevel->u.in.nIn;
158091 pLevel->u.in.nIn += nEq;
158092 pLevel->u.in.aInLoop =
158093 sqlite3WhereRealloc(pTerm->pWC->pWInfo,
158094 pLevel->u.in.aInLoop,
158095 sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
158096 pIn = pLevel->u.in.aInLoop;
158100 for(i=iEq;i<pLoop->nLTerm; i++){
158101 if( pLoop->aLTerm[i]->pExpr==pX ){
158102 int iOut = iReg + i - iEq;
158104 pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
158107 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
158111 pIn->iCur = iTab;
158112 pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
158114 pIn->iBase = iReg - i;
158115 pIn->nPrefix = i;
158117 pIn->nPrefix = 0;
158120 pIn->eEndLoopOp = OP_Noop;
158126 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0
158127 && (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 );
158129 && (pLoop->wsFlags & (WHERE_IN_SEEKSCAN|WHERE_VIRTUALTABLE))==0
158131 sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq);
158134 pLevel->u.in.nIn = 0;
158136 sqlite3DbFree(pParse->db, aiMap);
158147 ** work, see https://sqlite.org/forum/forumpost/eb8613976a (2021-05-04)
158149 if( (pLevel->pWLoop->wsFlags & WHERE_TRANSCONS)==0
158150 || (pTerm->eOperator & WO_EQUIV)==0
158171 ** of nEq including 0. If nEq==0, this routine is nearly a no-op.
158172 ** The only thing it does is allocate the pLevel->iMem memory cell and
158211 u16 nSkip; /* Number of left-most columns to skip */
158212 Vdbe *v = pParse->pVdbe; /* The vm under construction */
158217 int regBase; /* Base register */
158222 pLoop = pLevel->pWLoop;
158223 assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 );
158224 nEq = pLoop->u.btree.nEq;
158225 nSkip = pLoop->nSkip;
158226 pIdx = pLoop->u.btree.pIndex;
158231 regBase = pParse->nMem + 1;
158233 pParse->nMem += nReg;
158235 zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
158236 assert( zAff!=0 || pParse->db->mallocFailed );
158239 int iIdxCur = pLevel->iIdxCur;
158240 sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1);
158244 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
158246 assert( pLevel->addrSkip==0 );
158247 pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT),
158254 testcase( pIdx->aiColumn[j]==XN_EXPR );
158264 pTerm = pLoop->aLTerm[j];
158268 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
158269 testcase( pTerm->wtFlags & TERM_VIRTUAL );
158279 if( pTerm->eOperator & WO_IN ){
158280 if( pTerm->pExpr->flags & EP_xIsSelect ){
158287 }else if( (pTerm->eOperator & WO_ISNULL)==0 ){
158288 Expr *pRight = pTerm->pExpr->pRight;
158289 if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
158290 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
158293 if( pParse->nErr==0 ){
158294 assert( pParse->db->mallocFailed==0 );
158324 ** becomes a no-op.
158331 if( pTerm->wtFlags & TERM_LIKEOPT ){
158333 assert( pLevel->iLikeRepCntr>0 );
158336 assert( pOp->opcode==OP_String8
158337 || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
158338 pOp->p3 = (int)(pLevel->iLikeRepCntr>>1); /* Register holding counter */
158339 pOp->p5 = (u8)(pLevel->iLikeRepCntr&1); /* ASC or DESC */
158362 ** accessed through the index. If it cannot, then set pWalker->eCode to 1.
158365 struct CCurHint *pHint = pWalker->u.pCCurHint;
158366 assert( pHint->pIdx!=0 );
158367 if( pExpr->op==TK_COLUMN
158368 && pExpr->iTable==pHint->iTabCur
158369 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
158371 pWalker->eCode = 1;
158378 ** should be included in the cursor-hint for a table that is on the rhs
158379 ** of a LEFT JOIN. Set Walker.eCode to non-zero before returning if the
158392 if( pExpr->op==TK_IS
158393 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
158394 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
158396 pWalker->eCode = 1;
158397 }else if( pExpr->op==TK_FUNCTION ){
158400 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
158401 pWalker->eCode = 1;
158429 struct CCurHint *pHint = pWalker->u.pCCurHint;
158430 if( pExpr->op==TK_COLUMN ){
158431 if( pExpr->iTable!=pHint->iTabCur ){
158432 reg = ++pWalker->pParse->nMem; /* Register for column value */
158433 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158434 pExpr->op = TK_REGISTER;
158435 pExpr->iTable = reg;
158436 }else if( pHint->pIdx!=0 ){
158437 pExpr->iTable = pHint->iIdxCur;
158438 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
158439 assert( pExpr->iColumn>=0 );
158441 }else if( pExpr->pAggInfo ){
158443 reg = ++pWalker->pParse->nMem; /* Register for column value */
158444 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158445 pExpr->op = TK_REGISTER;
158446 pExpr->iTable = reg;
158447 }else if( pExpr->op==TK_TRUEFALSE ){
158448 /* Do not walk disabled expressions. tag-20230504-1 */
158461 WhereTerm *pEndRange /* Hint this end-of-scan boundary term if not NULL */
158463 Parse *pParse = pWInfo->pParse;
158464 sqlite3 *db = pParse->db;
158465 Vdbe *v = pParse->pVdbe;
158467 WhereLoop *pLoop = pLevel->pWLoop;
158476 iCur = pLevel->iTabCur;
158477 assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor );
158479 sHint.iIdxCur = pLevel->iIdxCur;
158480 sHint.pIdx = pLoop->u.btree.pIndex;
158484 pWC = &pWInfo->sWC;
158485 for(i=0; i<pWC->nBase; i++){
158486 pTerm = &pWC->a[i];
158487 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
158488 if( pTerm->prereqAll & pLevel->notReady ) continue;
158492 ** from the cursor-hint.
158512 if( pTabItem->fg.jointype & JT_LEFT ){
158513 Expr *pExpr = pTerm->pExpr;
158515 || pExpr->w.iJoin!=pTabItem->iCursor
158519 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
158523 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
158526 /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize
158529 if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){
158530 for(j=0; j<pLoop->nLTerm && pLoop->aLTerm[j]!=pTerm; j++){}
158531 if( j<pLoop->nLTerm ) continue;
158534 /* No subqueries or non-deterministic functions allowed */
158535 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
158542 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
158547 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
158551 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
158558 # define codeCursorHint(A,B,C,D) /* No-op */
158562 ** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains
158573 ** However, if the scan currently being coded is a branch of an OR-loop and
158590 int iCur, /* Cursor for IPK b-tree */
158593 Parse *pParse = pWInfo->pParse; /* Parse context */
158594 Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */
158597 assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
158599 pWInfo->bDeferredSeek = 1;
158601 if( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))
158602 && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
158605 Table *pTab = pIdx->pTable;
158606 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
158608 ai[0] = pTab->nCol;
158609 for(i=0; i<pIdx->nColumn-1; i++){
158611 assert( pIdx->aiColumn[i]<pTab->nCol );
158612 x1 = pIdx->aiColumn[i];
158617 sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
158636 Vdbe *v = pParse->pVdbe;
158638 assert( p->op==TK_SELECT );
158640 sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
158647 pList = p->x.pList;
158648 assert( nReg<=pList->nExpr );
158650 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
158654 assert( nReg==1 || pParse->nErr );
158673 while( pTruth->op==TK_AND ){
158674 whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC);
158675 pTruth = pTruth->pRight;
158677 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
158679 if( pTerm->wtFlags & TERM_CODED ) continue;
158680 pExpr = pTerm->pExpr;
158682 pTerm->wtFlags |= TERM_CODED;
158692 ** inner-loop Bloom filters, then evaluate those filters now, before the
158698 ** WhereLevel.regFilter set. If an inner-loop Bloom filter is checked,
158705 int iLevel, /* Which level of pWInfo->a[] should be coded */
158709 while( ++iLevel < pWInfo->nLevel ){
158710 WhereLevel *pLevel = &pWInfo->a[iLevel];
158711 WhereLoop *pLoop = pLevel->pWLoop;
158712 if( pLevel->regFilter==0 ) continue;
158713 if( pLevel->pWLoop->nSkip ) continue;
158714 /* ,--- Because sqlite3ConstructBloomFilter() has will not have set
158715 ** vvvvv--' pLevel->regFilter if this were true. */
158716 if( NEVER(pLoop->prereq & notReady) ) continue;
158717 assert( pLevel->addrBrk==0 );
158718 pLevel->addrBrk = addrNxt;
158719 if( pLoop->wsFlags & WHERE_IPK ){
158720 WhereTerm *pTerm = pLoop->aLTerm[0];
158723 assert( pTerm->pExpr!=0 );
158724 testcase( pTerm->wtFlags & TERM_VIRTUAL );
158727 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MustBeInt, regRowid, addrNxt);
158728 VdbeCoverage(pParse->pVdbe);
158729 sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter,
158731 VdbeCoverage(pParse->pVdbe);
158733 u16 nEq = pLoop->u.btree.nEq;
158737 assert( pLoop->wsFlags & WHERE_INDEXED );
158738 assert( (pLoop->wsFlags & WHERE_COLUMN_IN)==0 );
158741 sqlite3DbFree(pParse->db, zStartAff);
158742 sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter,
158744 VdbeCoverage(pParse->pVdbe);
158746 pLevel->regFilter = 0;
158747 pLevel->addrBrk = 0;
158757 if( pLoop->u.btree.pIndex->onError
158758 && pLoop->nSkip==0
158759 && pLoop->u.btree.nEq==pLoop->u.btree.pIndex->nKeyCol
158762 for(ii=0; ii<pLoop->u.btree.nEq; ii++){
158763 if( pLoop->aLTerm[ii]->eOperator & (WO_IS|WO_ISNULL) ){
158773 ** Generate code for the start of the iLevel-th loop in the WHERE clause
158780 int iLevel, /* Which level of pWInfo->a[] should be coded */
158801 pWC = &pWInfo->sWC;
158802 db = pParse->db;
158803 pLoop = pLevel->pWLoop;
158804 pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
158805 iCur = pTabItem->iCursor;
158806 pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur);
158807 bRev = (pWInfo->revMask>>iLevel)&1;
158808 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
158812 iLevel, pWInfo->nLevel, (u64)notReady, pLevel->iFrom);
158820 sqlite3TreeViewExpr(0, pWInfo->pWhere, 0);
158822 sqlite3DebugPrintf("All WHERE-clause terms before coding:\n");
158837 addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
158838 addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse);
158844 assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))
158845 || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0
158847 if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
158848 pLevel->iLeftJoin = ++pParse->nMem;
158849 sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
158855 for(j=iLevel; j>0; j--){
158856 if( pWInfo->a[j].iLeftJoin ) break;
158857 if( pWInfo->a[j].pRJ ) break;
158859 addrHalt = pWInfo->a[j].addrBrk;
158861 /* Special case of a FROM clause subquery implemented as a co-routine */
158862 if( pTabItem->fg.viaCoroutine ){
158863 int regYield = pTabItem->regReturn;
158864 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
158865 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
158867 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
158868 pLevel->op = OP_Goto;
158872 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){
158873 /* Case 1: The table is a virtual-table. Use the VFilter and VNext
158878 int nConstraint = pLoop->nLTerm;
158881 addrNotFound = pLevel->addrBrk;
158884 pTerm = pLoop->aLTerm[j];
158886 if( pTerm->eOperator & WO_IN ){
158887 if( SMASKBIT32(j) & pLoop->u.vtab.mHandleIn ){
158888 int iTab = pParse->nTab++;
158889 int iCache = ++pParse->nMem;
158890 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
158894 addrNotFound = pLevel->addrNxt;
158897 Expr *pRight = pTerm->pExpr->pRight;
158899 if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET
158900 && pLoop->u.vtab.bOmitOffset
158902 assert( pTerm->eOperator==WO_AUX );
158903 assert( pWInfo->pSelect!=0 );
158904 assert( pWInfo->pSelect->iOffset>0 );
158905 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWInfo->pSelect->iOffset);
158910 sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
158913 pLoop->u.vtab.idxStr,
158914 pLoop->u.vtab.needFree ? P4_DYNAMIC : P4_STATIC);
158916 pLoop->u.vtab.needFree = 0;
158918 ** the u.vtab.idxStr. NULL it out to prevent a use-after-free */
158919 if( db->mallocFailed ) pLoop->u.vtab.idxStr = 0;
158920 pLevel->p1 = iCur;
158921 pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext;
158922 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
158923 assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
158926 pTerm = pLoop->aLTerm[j];
158927 if( j<16 && (pLoop->u.vtab.omitMask>>j)&1 ){
158931 if( (pTerm->eOperator & WO_IN)!=0
158932 && (SMASKBIT32(j) & pLoop->u.vtab.mHandleIn)==0
158933 && !db->mallocFailed
158938 int iIn; /* IN loop corresponding to the j-th constraint */
158945 for(iIn=0; ALWAYS(iIn<pLevel->u.in.nIn); iIn++){
158946 pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop);
158947 if( (pOp->opcode==OP_Column && pOp->p3==iReg+j+2)
158948 || (pOp->opcode==OP_Rowid && pOp->p2==iReg+j+2)
158950 testcase( pOp->opcode==OP_Rowid );
158951 sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
158960 if( !db->mallocFailed ){
158961 int iFld = pTerm->u.x.iField;
158962 Expr *pLeft = pTerm->pExpr->pLeft;
158965 assert( pLeft->op==TK_VECTOR );
158967 assert( iFld<=pLeft->x.pList->nExpr );
158968 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
158970 pCompare->pLeft = pLeft;
158972 pCompare->pRight = pRight = sqlite3Expr(db, TK_REGISTER, 0);
158974 pRight->iTable = iReg+j+2;
158976 pParse, pCompare, pLevel->addrCont, SQLITE_JUMPIFNULL
158979 pCompare->pLeft = 0;
158987 ** reuse them later) if (pLoop->wsFlags & WHERE_IN_ABLE)==0. But it seems
158995 if( (pLoop->wsFlags & WHERE_IPK)!=0
158996 && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0
159003 assert( pLoop->u.btree.nEq==1 );
159004 pTerm = pLoop->aLTerm[0];
159006 assert( pTerm->pExpr!=0 );
159007 testcase( pTerm->wtFlags & TERM_VIRTUAL );
159008 iReleaseReg = ++pParse->nMem;
159011 addrNxt = pLevel->addrNxt;
159012 if( pLevel->regFilter ){
159015 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
159022 pLevel->op = OP_Noop;
159023 }else if( (pLoop->wsFlags & WHERE_IPK)!=0
159024 && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0
159035 if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++];
159036 if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++];
159062 assert( (pStart->wtFlags & TERM_VNULL)==0 );
159063 testcase( pStart->wtFlags & TERM_VIRTUAL );
159064 pX = pStart->pExpr;
159066 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
159067 if( sqlite3ExprIsVector(pX->pRight) ){
159069 codeExprOrVector(pParse, pX->pRight, r1, 1);
159070 testcase( pX->op==TK_GT );
159071 testcase( pX->op==TK_GE );
159072 testcase( pX->op==TK_LT );
159073 testcase( pX->op==TK_LE );
159074 op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1];
159075 assert( pX->op!=TK_GT || op==OP_SeekGE );
159076 assert( pX->op!=TK_GE || op==OP_SeekGE );
159077 assert( pX->op!=TK_LT || op==OP_SeekLE );
159078 assert( pX->op!=TK_LE || op==OP_SeekLE );
159080 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
159082 op = aMoveOp[(pX->op - TK_GT)];
159086 VdbeCoverageIf(v, pX->op==TK_GT);
159087 VdbeCoverageIf(v, pX->op==TK_LE);
159088 VdbeCoverageIf(v, pX->op==TK_LT);
159089 VdbeCoverageIf(v, pX->op==TK_GE);
159098 pX = pEnd->pExpr;
159100 assert( (pEnd->wtFlags & TERM_VNULL)==0 );
159101 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
159102 testcase( pEnd->wtFlags & TERM_VIRTUAL );
159103 memEndValue = ++pParse->nMem;
159104 codeExprOrVector(pParse, pX->pRight, memEndValue, 1);
159105 if( 0==sqlite3ExprIsVector(pX->pRight)
159106 && (pX->op==TK_LT || pX->op==TK_GT)
159112 if( 0==sqlite3ExprIsVector(pX->pRight) ){
159117 pLevel->op = bRev ? OP_Prev : OP_Next;
159118 pLevel->p1 = iCur;
159119 pLevel->p2 = start;
159120 assert( pLevel->p5==0 );
159122 iRowidReg = ++pParse->nMem;
159131 }else if( pLoop->wsFlags & WHERE_INDEXED ){
159136 ** left-most columns of the index. It may also contain
159139 ** the right-most column can be an inequality - the rest must
159179 u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */
159180 u16 nBtm = pLoop->u.btree.nBtm; /* Length of BTM vector */
159181 u16 nTop = pLoop->u.btree.nTop; /* Length of TOP vector */
159182 int regBase; /* Base register holding constraint values */
159197 int regBignull = 0; /* big-null flag register */
159200 pIdx = pLoop->u.btree.pIndex;
159201 iIdxCur = pLevel->iIdxCur;
159202 assert( nEq>=pLoop->nSkip );
159208 if( pLoop->wsFlags & WHERE_BTM_LIMIT ){
159209 pRangeStart = pLoop->aLTerm[j++];
159210 nExtraReg = MAX(nExtraReg, pLoop->u.btree.nBtm);
159212 assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
159213 (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 );
159215 if( pLoop->wsFlags & WHERE_TOP_LIMIT ){
159216 pRangeEnd = pLoop->aLTerm[j++];
159217 nExtraReg = MAX(nExtraReg, pLoop->u.btree.nTop);
159219 if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){
159221 assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */
159222 pLevel->iLikeRepCntr = (u32)++pParse->nMem;
159223 sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr);
159225 pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v);
159229 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
159231 pLevel->iLikeRepCntr <<=1;
159232 pLevel->iLikeRepCntr |= bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC);
159236 j = pIdx->aiColumn[nEq];
159237 if( (j>=0 && pIdx->pTable->aCol[j].notNull==0) || j==XN_EXPR ){
159242 assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 );
159245 ** a non-default "big-null" sort (either ASC NULLS LAST or DESC NULLS
159248 ** it is not. For an ASC sort, the non-NULL entries are scanned first.
159251 if( (pLoop->wsFlags & (WHERE_TOP_LIMIT|WHERE_BTM_LIMIT))==0
159252 && (pLoop->wsFlags & WHERE_BIGNULL_SORT)!=0
159256 testcase( pLoop->nSkip>0 );
159259 pLevel->regBignull = regBignull = ++pParse->nMem;
159260 if( pLevel->iLeftJoin ){
159263 pLevel->addrBignull = sqlite3VdbeMakeLabel(pParse);
159270 if( (nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) ){
159276 if( iLevel>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 ){
159292 addrNxt = (regBignull ? pLevel->addrBignull : pLevel->addrNxt);
159294 testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );
159295 testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 );
159296 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 );
159297 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 );
159298 startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE);
159299 endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE);
159305 Expr *pRight = pRangeStart->pExpr->pRight;
159308 if( (pRangeStart->wtFlags & TERM_VNULL)==0
159318 testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
159335 codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff);
159336 if( pLoop->nSkip>0 && nConstraint==pLoop->nSkip ){
159337 /* The skip-scan logic inside the call to codeAllEqualityConstraints()
159343 VdbeComment((v, "NULL-scan pass ctr"));
159345 if( pLevel->regFilter ){
159346 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
159354 if( (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 && op==OP_SeekGE ){
159365 (pIdx->aiRowLogEst[0]+9)/10);
159390 nConstraint-startEq);
159404 assert( pLevel->p2==0 );
159406 Expr *pRight = pRangeEnd->pExpr->pRight;
159410 if( (pRangeEnd->wtFlags & TERM_VNULL)==0
159420 assert( pParse->db->mallocFailed );
159423 testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
159441 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
159446 /* Except, skip the end-of-range check while doing the NULL-scan */
159448 VdbeComment((v, "If NULL-scan 2nd pass"));
159460 /* During a NULL-scan, check to see if we have reached the end of
159466 VdbeComment((v, "If NULL-scan 1st pass"));
159477 if( (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0 ){
159482 omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0
159483 && (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0;
159486 }else if( HasRowid(pIdx->pTable) ){
159489 Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
159490 iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
159491 for(j=0; j<pPk->nKeyCol; j++){
159492 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
159496 iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
159499 if( pLevel->iLeftJoin==0 ){
159504 ** 2019-11-02 ticket 623eff57e76d45f6: This optimization does not work
159507 if( pIdx->pPartIdxWhere ){
159508 whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC);
159511 testcase( pIdx->pPartIdxWhere );
159513 ** The OR-optimization doesn't work for the right hand table of
159515 assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0 );
159519 if( (pLoop->wsFlags & WHERE_ONEROW)
159520 || (pLevel->u.in.nIn && regBignull==0 && whereLoopIsOneRow(pLoop))
159522 pLevel->op = OP_Noop;
159524 pLevel->op = OP_Prev;
159526 pLevel->op = OP_Next;
159528 pLevel->p1 = iIdxCur;
159529 pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0;
159530 if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){
159531 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
159533 assert( pLevel->p5==0 );
159539 if( pLoop->wsFlags & WHERE_MULTI_OR ){
159578 ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then
159583 WhereClause *pOrWc; /* The OR-clause broken out into subterms */
159584 SrcList *pOrTab; /* Shortened table list or OR-clause generation */
159586 int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */
159588 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
159596 Table *pTab = pTabItem->pTab;
159598 pTerm = pLoop->aLTerm[0];
159600 assert( pTerm->eOperator & WO_OR );
159601 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
159602 pOrWc = &pTerm->u.pOrInfo->wc;
159603 pLevel->op = OP_Return;
159604 pLevel->p1 = regReturn;
159610 if( pWInfo->nLevel>1 ){
159613 nNotReady = pWInfo->nLevel - iLevel - 1;
159615 sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
159617 pOrTab->nAlloc = (u8)(nNotReady + 1);
159618 pOrTab->nSrc = pOrTab->nAlloc;
159619 memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
159620 origSrc = pWInfo->pTabList->a;
159622 memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
159625 pOrTab = pWInfo->pTabList;
159636 ** correct response for the end-of-loop code (the OP_Return) is to
159640 if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
159642 regRowset = ++pParse->nMem;
159646 regRowset = pParse->nTab++;
159647 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol);
159650 regRowid = ++pParse->nMem;
159660 ** the "interesting" terms of z - terms that did not originate in the
159668 ** 2022-02-04: Do not push down slices of a row-value comparison.
159670 ** the initialization of the right-hand operand of the vector comparison
159674 ** 2022-03-03: Do not push down expressions that involve subqueries.
159675 ** The subquery might get coded as a subroutine. Any table-references
159676 ** in the subquery might be resolved to index-references for the index on
159679 ** index-references will not work. tag-20220303a
159682 if( pWC->nTerm>1 ){
159684 for(iTerm=0; iTerm<pWC->nTerm; iTerm++){
159685 Expr *pExpr = pWC->a[iTerm].pExpr;
159686 if( &pWC->a[iTerm] == pTerm ) continue;
159687 testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
159688 testcase( pWC->a[iTerm].wtFlags & TERM_CODED );
159689 testcase( pWC->a[iTerm].wtFlags & TERM_SLICE );
159690 if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED|TERM_SLICE))!=0 ){
159693 if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
159694 if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */
159702 ** prevents sqlite3PExpr() from applying the AND short-circuit
159710 ** sub-WHERE clause is to to invoke the main loop body as a subroutine.
159712 ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR"));
159713 for(ii=0; ii<pOrWc->nTerm; ii++){
159714 WhereTerm *pOrTerm = &pOrWc->a[ii];
159715 if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){
159716 WhereInfo *pSubWInfo; /* Info for single OR-term scan */
159717 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
159724 if( db->mallocFailed ){
159729 pAndExpr->pLeft = pOrExpr;
159734 WHERETRACE(0xffffffff, ("Subplan for OR-clause:\n"));
159737 assert( pSubWInfo || pParse->nErr );
159741 pParse, pOrTab, &pSubWInfo->a[0], 0
159743 sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain);
159745 /* This is the sub-WHERE clause body. First skip over
159746 ** duplicate rows from prior sub-WHERE clauses, and record the
159748 ** row will be skipped in subsequent sub-WHERE clauses.
159750 if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
159751 int iSet = ((ii==pOrWc->nTerm-1)?-1:ii);
159753 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
159759 int nPk = pPk->nKeyCol;
159766 int iCol = pPk->aiColumn[iPk];
159778 ** the temp table. And if iSet is -1, assume that there is no
159801 ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */
159804 /* The pSubWInfo->untestedTerms flag means that this OR term
159809 if( pSubWInfo->untestedTerms ) untestedTerms = 1;
159811 /* If all of the OR-connected terms are optimized using the same
159817 ** uses an index, and this is either the first OR-connected term
159823 pSubLoop = pSubWInfo->a[0].pWLoop;
159824 assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
159825 if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0
159826 && (ii==0 || pSubLoop->u.btree.pIndex==pCov)
159827 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex))
159829 assert( pSubWInfo->a[0].iIdxCur==iCovCur );
159830 pCov = pSubLoop->u.btree.pIndex;
159835 pWInfo->bDeferredSeek = 1;
159846 assert( pLevel->pWLoop==pLoop );
159847 assert( (pLoop->wsFlags & WHERE_MULTI_OR)!=0 );
159848 assert( (pLoop->wsFlags & WHERE_IN_ABLE)==0 );
159849 pLevel->u.pCoveringIdx = pCov;
159850 if( pCov ) pLevel->iIdxCur = iCovCur;
159852 pAndExpr->pLeft = 0;
159856 sqlite3VdbeGoto(v, pLevel->addrBrk);
159861 ** loop. The byte-code formatter will use that P2 value as a hint to
159863 ** See tag-20220407a in vdbe.c and shell.c */
159864 assert( pLevel->op==OP_Return );
159865 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
159867 if( pWInfo->nLevel>1 ){ sqlite3DbFreeNN(db, pOrTab); }
159879 if( pTabItem->fg.isRecursive ){
159881 ** a pseudo-cursor. No need to Rewind or Next such cursors. */
159882 pLevel->op = OP_Noop;
159885 pLevel->op = aStep[bRev];
159886 pLevel->p1 = iCur;
159887 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
159890 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
159895 pLevel->addrVisit = sqlite3VdbeCurrentAddr(v);
159907 ** sub-queries.
159913 ** more complex one is call the "push-down" optimization in MySQL. Here
159914 ** in SQLite, the name is "MySQL push-down", since there is also another
159915 ** totally unrelated optimization called "WHERE-clause push-down".
159921 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
159924 testcase( pTerm->wtFlags & TERM_VIRTUAL );
159925 testcase( pTerm->wtFlags & TERM_CODED );
159926 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
159927 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
159928 testcase( pWInfo->untestedTerms==0
159929 && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 );
159930 pWInfo->untestedTerms = 1;
159933 pE = pTerm->pExpr;
159935 if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT) ){
159938 ** join processing. tag-20220513a */
159940 }else if( (pTabItem->fg.jointype & JT_LEFT)==JT_LEFT
159944 Bitmask m = sqlite3WhereGetMask(&pWInfo->sMaskSet, pE->w.iJoin);
159945 if( m & pLevel->notReady ){
159951 if( iLoop==1 && !sqlite3ExprCoveredByIndex(pE, pLevel->iTabCur, pIdx) ){
159955 if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){
159960 if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){
159969 u32 x = pLevel->iLikeRepCntr;
159980 pWC->nTerm-j, pTerm, iLoop));
159984 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
159989 pTerm->wtFlags |= TERM_CODED;
160002 for(pTerm=pWC->a, j=pWC->nBase; j>0; j--, pTerm++){
160005 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
160006 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue;
160007 if( (pTerm->eOperator & WO_EQUIV)==0 ) continue;
160008 if( pTerm->leftCursor!=iCur ) continue;
160009 if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT) ) continue;
160010 pE = pTerm->pExpr;
160014 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
160018 assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
160019 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
160020 pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady,
160023 if( pAlt->wtFlags & (TERM_CODED) ) continue;
160024 if( (pAlt->eOperator & WO_IN)
160025 && ExprUseXSelect(pAlt->pExpr)
160026 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
160030 testcase( pAlt->eOperator & WO_EQ );
160031 testcase( pAlt->eOperator & WO_IS );
160032 testcase( pAlt->eOperator & WO_IN );
160034 sEAlt = *pAlt->pExpr;
160035 sEAlt.pLeft = pE->pLeft;
160037 pAlt->wtFlags |= TERM_CODED;
160043 if( pLevel->pRJ ){
160048 WhereRightJoin *pRJ = pLevel->pRJ;
160050 /* pTab is the right-hand table of the RIGHT JOIN. Generate code that
160055 pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab;
160058 sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
160063 nPk = pPk->nKeyCol;
160066 int iCol = pPk->aiColumn[iPk];
160070 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, 0, r+1, nPk);
160072 VdbeComment((v, "match against %s", pTab->zName));
160074 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pRJ->iMatch, r, r+1, nPk);
160075 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pRJ->regBloom, 0, r+1, nPk);
160084 if( pLevel->iLeftJoin ){
160085 pLevel->addrFirst = sqlite3VdbeCurrentAddr(v);
160086 sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
160088 if( pLevel->pRJ==0 ){
160093 if( pLevel->pRJ ){
160096 ** be in-line with the rest of the code. But at the end, a separate
160100 WhereRightJoin *pRJ = pLevel->pRJ;
160101 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pRJ->regReturn);
160102 pRJ->addrSubrtn = sqlite3VdbeCurrentAddr(v);
160103 assert( pParse->withinRJSubrtn < 255 );
160104 pParse->withinRJSubrtn++;
160109 ** appropriate WHERE clause constraint checks. tag-20220513a.
160112 for(pTerm=pWC->a, j=0; j<pWC->nBase; j++, pTerm++){
160113 testcase( pTerm->wtFlags & TERM_VIRTUAL );
160114 testcase( pTerm->wtFlags & TERM_CODED );
160115 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
160116 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
160117 assert( pWInfo->untestedTerms );
160120 if( pTabItem->fg.jointype & JT_LTORJ ) continue;
160121 assert( pTerm->pExpr );
160122 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
160123 pTerm->wtFlags |= TERM_CODED;
160129 sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n",
160135 iLevel, (u64)pLevel->notReady);
160138 return pLevel->notReady;
160142 ** Generate the code for the loop that finds all non-matched terms
160150 Parse *pParse = pWInfo->pParse;
160151 Vdbe *v = pParse->pVdbe;
160152 WhereRightJoin *pRJ = pLevel->pRJ;
160154 WhereClause *pWC = &pWInfo->sWC;
160156 WhereLoop *pLoop = pLevel->pWLoop;
160157 SrcItem *pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
160162 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
160163 sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
160164 pRJ->regReturn);
160168 assert( pWInfo->a[k].pWLoop->iTab == pWInfo->a[k].iFrom );
160169 pRight = &pWInfo->pTabList->a[pWInfo->a[k].iFrom];
160170 mAll |= pWInfo->a[k].pWLoop->maskSelf;
160171 if( pRight->fg.viaCoroutine ){
160173 v, OP_Null, 0, pRight->regResult,
160174 pRight->regResult + pRight->pSelect->pEList->nExpr-1
160177 sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur);
160178 iIdxCur = pWInfo->a[k].iIdxCur;
160183 if( (pTabItem->fg.jointype & JT_LTORJ)==0 ){
160184 mAll |= pLoop->maskSelf;
160185 for(k=0; k<pWC->nTerm; k++){
160186 WhereTerm *pTerm = &pWC->a[k];
160187 if( (pTerm->wtFlags & (TERM_VIRTUAL|TERM_SLICE))!=0
160188 && pTerm->eOperator!=WO_ROWVAL
160192 if( pTerm->prereqAll & ~mAll ) continue;
160193 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
160195 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
160202 assert( pParse->withinRJSubrtn < 100 );
160203 pParse->withinRJSubrtn++;
160207 int iCur = pLevel->iTabCur;
160208 int r = ++pParse->nMem;
160212 Table *pTab = pTabItem->pTab;
160214 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
160219 nPk = pPk->nKeyCol;
160220 pParse->nMem += nPk - 1;
160222 int iCol = pPk->aiColumn[iPk];
160226 jmp = sqlite3VdbeAddOp4Int(v, OP_Filter, pRJ->regBloom, 0, r, nPk);
160228 sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, addrCont, r, nPk);
160231 sqlite3VdbeAddOp2(v, OP_Gosub, pRJ->regReturn, pRJ->addrSubrtn);
160234 sqlite3ExprDelete(pParse->db, pSubWhere);
160236 assert( pParse->withinRJSubrtn>0 );
160237 pParse->withinRJSubrtn--;
160243 ** 2015-06-08
160270 sqlite3WhereClauseClear(&p->wc);
160278 sqlite3WhereClauseClear(&p->wc);
160285 ** The index in pWC->a[] of the new WhereTerm is returned on success.
160288 ** the db->mallocFailed flag so that higher-level functions can detect it.
160290 ** This routine will increase the size of the pWC->a[] array as necessary.
160299 ** the pWC->a[] array.
160305 if( pWC->nTerm>=pWC->nSlot ){
160306 WhereTerm *pOld = pWC->a;
160307 sqlite3 *db = pWC->pWInfo->pParse->db;
160308 pWC->a = sqlite3WhereMalloc(pWC->pWInfo, sizeof(pWC->a[0])*pWC->nSlot*2 );
160309 if( pWC->a==0 ){
160313 pWC->a = pOld;
160316 memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
160317 pWC->nSlot = pWC->nSlot*2;
160319 pTerm = &pWC->a[idx = pWC->nTerm++];
160320 if( (wtFlags & TERM_VIRTUAL)==0 ) pWC->nBase = pWC->nTerm;
160322 pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
160324 pTerm->truthProb = 1;
160326 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
160327 pTerm->wtFlags = wtFlags;
160328 pTerm->pWC = pWC;
160329 pTerm->iParent = -1;
160330 memset(&pTerm->eOperator, 0,
160331 sizeof(WhereTerm) - offsetof(WhereTerm,eOperator));
160353 if( pExpr->pLeft->op==TK_VECTOR
160354 || pExpr->pRight->op==TK_VECTOR
160355 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
160356 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
160358 pExpr->flags ^= EP_Commuted;
160360 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
160361 if( pExpr->op>=TK_GT ){
160366 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
160367 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
160385 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
160386 c = (u16)(WO_EQ<<(op-TK_EQ));
160424 int cnt; /* Number of non-wildcard prefix characters */
160426 sqlite3 *db = pParse->db; /* Database connection */
160438 pList = pExpr->x.pList;
160439 pLeft = pList->a[1].pExpr;
160441 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
160442 op = pRight->op;
160443 if( op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
160444 Vdbe *pReprepare = pParse->pReprepare;
160445 int iCol = pRight->iColumn;
160450 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
160451 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
160454 z = (u8*)pRight->u.zToken;
160466 ** with a wildcard and if (2) the non-wildcard prefix does not end with
160473 if( (cnt>1 || (cnt>0 && z[0]!=wc[3])) && 255!=(u8)z[cnt-1] ){
160485 zNew = pPrefix->u.zToken;
160501 ** 2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1
160502 ** 2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28
160503 ** 2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07
160504 ** 2019-06-14 https://sqlite.org/src/info/ce8717f0885af975
160505 ** 2019-09-03 https://sqlite.org/src/info/0f0428096f17252a
160507 if( pLeft->op!=TK_COLUMN
160510 && ALWAYS(pLeft->y.pTab)
160511 && IsVirtual(pLeft->y.pTab)) /* Might be numeric */
160517 if( iTo==1 && zNew[0]=='-' ){
160520 zNew[iTo-1]++;
160522 zNew[iTo-1]--;
160537 Vdbe *v = pParse->pVdbe;
160538 sqlite3VdbeSetVarmask(v, pRight->iColumn);
160540 if( *pisComplete && pRight->u.zToken[1] ){
160549 sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0);
160571 ** ----------------------- ---------------------------------
160599 if( pExpr->op==TK_FUNCTION ){
160614 pList = pExpr->x.pList;
160615 if( pList==0 || pList->nExpr!=2 ){
160619 /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a
160621 ** the left-hand side operand in their in-fix form.
160626 pCol = pList->a[1].pExpr;
160627 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
160631 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
160633 *ppRight = pList->a[0].pExpr;
160646 ** Historically, xFindFunction expected to see lower-case function
160650 pCol = pList->a[0].pExpr;
160651 assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) );
160652 assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) );
160658 pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
160660 assert( pVtab->pModule!=0 );
160662 pMod = (sqlite3_module *)pVtab->pModule;
160663 if( pMod->xFindFunction!=0 ){
160664 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
160667 *ppRight = pList->a[1].pExpr;
160673 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
160675 Expr *pLeft = pExpr->pLeft;
160676 Expr *pRight = pExpr->pRight;
160677 assert( pLeft->op!=TK_COLUMN || (ExprUseYTab(pLeft) && pLeft->y.pTab!=0) );
160681 assert( pRight==0 || pRight->op!=TK_COLUMN
160682 || (ExprUseYTab(pRight) && pRight->y.pTab!=0) );
160689 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
160690 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
160691 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
160704 pDerived->flags |= pBase->flags & (EP_OuterON|EP_InnerON);
160705 pDerived->w.iJoin = pBase->w.iJoin;
160713 pWC->a[iChild].iParent = iParent;
160714 pWC->a[iChild].truthProb = pWC->a[iParent].truthProb;
160715 pWC->a[iParent].nChild++;
160719 ** Return the N-th AND-connected subterm of pTerm. Or if pTerm is not
160724 if( pTerm->eOperator!=WO_AND ){
160727 if( N<pTerm->u.pAndInfo->wc.nTerm ){
160728 return &pTerm->u.pAndInfo->wc.a[N];
160735 ** two subterms are in disjunction - they are OR-ed together.
160745 ** x<y OR x=y --> x<=y
160746 ** x=y OR x=y --> x=y
160747 ** x<=y OR x<y --> x<=y
160751 ** x<y OR x>y --> x!=y
160759 u16 eOp = pOne->eOperator | pTwo->eOperator;
160765 if( (pOne->wtFlags | pTwo->wtFlags) & TERM_VNULL ) return;
160766 if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
160767 if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
160770 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
160771 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
160772 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
160773 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
160775 if( (eOp & (eOp-1))!=0 ){
160783 db = pWC->pWInfo->pParse->db;
160784 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
160786 for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
160787 pNew->op = op;
160794 ** Analyze a term that consists of two or more OR-connected
160807 ** The term being analyzed must have two or more of OR-connected subterms.
160808 ** A single subterm might be a set of AND-connected sub-subterms.
160846 ** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T
160883 int idxTerm /* Index of the OR-term to be analyzed */
160885 WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */
160886 Parse *pParse = pWInfo->pParse; /* Parser context */
160887 sqlite3 *db = pParse->db; /* Database connection */
160888 WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */
160889 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
160892 WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */
160902 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
160903 assert( pExpr->op==TK_OR );
160904 pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
160906 pTerm->wtFlags |= TERM_ORINFO;
160907 pOrWc = &pOrInfo->wc;
160908 memset(pOrWc->aStatic, 0, sizeof(pOrWc->aStatic));
160912 if( db->mallocFailed ) return;
160913 assert( pOrWc->nTerm>=2 );
160920 for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){
160921 if( (pOrTerm->eOperator & WO_SINGLE)==0 ){
160923 assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
160931 pOrTerm->u.pAndInfo = pAndInfo;
160932 pOrTerm->wtFlags |= TERM_ANDINFO;
160933 pOrTerm->eOperator = WO_AND;
160934 pOrTerm->leftCursor = -1;
160935 pAndWC = &pAndInfo->wc;
160936 memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic));
160937 sqlite3WhereClauseInit(pAndWC, pWC->pWInfo);
160938 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
160940 pAndWC->pOuter = pWC;
160941 if( !db->mallocFailed ){
160942 for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
160943 assert( pAndTerm->pExpr );
160944 if( allowedOp(pAndTerm->pExpr->op)
160945 || pAndTerm->eOperator==WO_AUX
160947 b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor);
160953 }else if( pOrTerm->wtFlags & TERM_COPIED ){
160958 b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor);
160959 if( pOrTerm->wtFlags & TERM_VIRTUAL ){
160960 WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
160961 b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor);
160964 if( (pOrTerm->eOperator & WO_EQ)==0 ){
160976 pOrInfo->indexable = indexable;
160977 pTerm->eOperator = WO_OR;
160978 pTerm->leftCursor = -1;
160980 pWC->hasOr = 1;
160983 /* For a two-way OR, attempt to implementation case 2.
160985 if( indexable && pOrWc->nTerm==2 ){
160988 while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){
160991 while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){
161002 ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means
161005 ** something other than == on a column in the single table. The 1-bit
161009 ** sure the same column is used on all terms. The 2-bit case is when
161020 int iColumn = -1; /* Column index on lhs of IN operator */
161021 int iCursor = -1; /* Table cursor common to all terms */
161032 pOrTerm = pOrWc->a;
161033 for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
161034 assert( pOrTerm->eOperator & WO_EQ );
161035 pOrTerm->wtFlags &= ~TERM_OK;
161036 if( pOrTerm->leftCursor==iCursor ){
161037 /* This is the 2-bit case and we are on the second iteration and
161042 if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet,
161043 pOrTerm->leftCursor))==0 ){
161048 testcase( pOrTerm->wtFlags & TERM_COPIED );
161049 testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
161050 assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
161053 assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
161054 iColumn = pOrTerm->u.x.leftColumn;
161055 iCursor = pOrTerm->leftCursor;
161056 pLeft = pOrTerm->pExpr->pLeft;
161064 assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) );
161072 for(; i>=0 && okToChngToIN; i--, pOrTerm++){
161073 assert( pOrTerm->eOperator & WO_EQ );
161074 assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
161075 if( pOrTerm->leftCursor!=iCursor ){
161076 pOrTerm->wtFlags &= ~TERM_OK;
161077 }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR
161078 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
161083 /* If the right-hand side is also a column, then the affinities
161087 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
161088 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
161092 pOrTerm->wtFlags |= TERM_OK;
161108 for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
161109 if( (pOrTerm->wtFlags & TERM_OK)==0 ) continue;
161110 assert( pOrTerm->eOperator & WO_EQ );
161111 assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
161112 assert( pOrTerm->leftCursor==iCursor );
161113 assert( pOrTerm->u.x.leftColumn==iColumn );
161114 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
161115 pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
161116 pLeft = pOrTerm->pExpr->pLeft;
161125 pNew->x.pList = pList;
161129 /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where reused */
161157 if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;
161158 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
161160 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
161161 aff2 = sqlite3ExprAffinity(pExpr->pRight);
161169 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
161180 SrcList *pSrc = pS->pSrc;
161181 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList);
161182 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy);
161183 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy);
161184 mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere);
161185 mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving);
161188 for(i=0; i<pSrc->nSrc; i++){
161189 mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
161190 if( pSrc->a[i].fg.isUsing==0 ){
161191 mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].u3.pOn);
161193 if( pSrc->a[i].fg.isTabFunc ){
161194 mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
161198 pS = pS->pPrior;
161209 ** of the column that is indexed, or XN_EXPR (-2) if an expression is being
161220 int j /* Start looking with the j-th pFrom entry */
161226 iCur = pFrom->a[j].iCursor;
161227 for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161228 if( pIdx->aColExpr==0 ) continue;
161229 for(i=0; i<pIdx->nKeyCol; i++){
161230 if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
161231 assert( pIdx->bHasExpr );
161232 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
161233 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
161241 }while( ++j < pFrom->nSrc );
161258 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
161260 pExpr = pExpr->x.pList->a[0].pExpr;
161263 if( pExpr->op==TK_COLUMN ){
161264 aiCurCol[0] = pExpr->iTable;
161265 aiCurCol[1] = pExpr->iColumn;
161269 for(i=0; i<pFrom->nSrc; i++){
161271 for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
161272 if( pIdx->aColExpr ){
161304 WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */
161308 Bitmask prereqLeft; /* Prerequisites of the pExpr->pLeft */
161314 int op; /* Top-level operator. pExpr->op */
161315 Parse *pParse = pWInfo->pParse; /* Parsing context */
161316 sqlite3 *db = pParse->db; /* Database connection */
161320 if( db->mallocFailed ){
161323 assert( pWC->nTerm > idxTerm );
161324 pTerm = &pWC->a[idxTerm];
161325 pMaskSet = &pWInfo->sMaskSet;
161326 pExpr = pTerm->pExpr;
161328 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
161329 pMaskSet->bVarSelect = 0;
161330 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
161331 op = pExpr->op;
161333 assert( pExpr->pRight==0 );
161336 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
161338 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
161340 prereqAll = prereqLeft | pTerm->prereqRight;
161342 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
161343 if( pExpr->pLeft==0
161345 || pExpr->x.pList!=0
161349 prereqAll = prereqLeft | pTerm->prereqRight;
161352 if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT;
161363 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
161366 extraRight = x-1; /* ON clause terms may not be used with an index
161379 if( ALWAYS(pSrc->nSrc>0) && (pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){
161386 pTerm->prereqAll = prereqAll;
161387 pTerm->leftCursor = -1;
161388 pTerm->iParent = -1;
161389 pTerm->eOperator = 0;
161392 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
161393 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
161394 u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
161396 if( pTerm->u.x.iField>0 ){
161398 assert( pLeft->op==TK_VECTOR );
161400 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
161404 pTerm->leftCursor = aiCurCol[0];
161405 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
161406 pTerm->u.x.leftColumn = aiCurCol[1];
161407 pTerm->eOperator = operatorMask(op) & opMask;
161409 if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
161416 u16 eExtraOp = 0; /* Extra bits for pNew->eOperator */
161417 assert( pTerm->u.x.iField==0 );
161418 if( pTerm->leftCursor>=0 ){
161421 if( db->mallocFailed ){
161427 pNew = &pWC->a[idxNew];
161429 if( op==TK_IS ) pNew->wtFlags |= TERM_IS;
161430 pTerm = &pWC->a[idxTerm];
161431 pTerm->wtFlags |= TERM_COPIED;
161434 pTerm->eOperator |= WO_EQUIV;
161441 pNew->wtFlags |= exprCommute(pParse, pDup);
161442 pNew->leftCursor = aiCurCol[0];
161443 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
161444 pNew->u.x.leftColumn = aiCurCol[1];
161446 pNew->prereqRight = prereqLeft | extraRight;
161447 pNew->prereqAll = prereqAll;
161448 pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
161455 pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */
161456 pExpr->u.zToken = "false";
161458 pTerm->prereqAll = 0;
161459 pTerm->eOperator = 0;
161479 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
161484 pList = pExpr->x.pList;
161486 assert( pList->nExpr==2 );
161491 sqlite3ExprDup(db, pExpr->pLeft, 0),
161492 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
161497 pTerm = &pWC->a[idxTerm];
161507 else if( pExpr->op==TK_OR ){
161508 assert( pWC->op==TK_AND );
161510 pTerm = &pWC->a[idxTerm];
161519 else if( pExpr->op==TK_NOTNULL ){
161520 if( pExpr->pLeft->op==TK_COLUMN
161521 && pExpr->pLeft->iColumn>=0
161525 Expr *pLeft = pExpr->pLeft;
161536 pNewTerm = &pWC->a[idxNew];
161537 pNewTerm->prereqRight = 0;
161538 pNewTerm->leftCursor = pLeft->iTable;
161539 pNewTerm->u.x.leftColumn = pLeft->iColumn;
161540 pNewTerm->eOperator = WO_GT;
161542 pTerm = &pWC->a[idxTerm];
161543 pTerm->wtFlags |= TERM_COPIED;
161544 pNewTerm->prereqAll = pTerm->prereqAll;
161560 ** for LIKE) then the lower-bound is made all uppercase and the upper-
161564 else if( pExpr->op==TK_FUNCTION
161565 && pWC->op==TK_AND
161569 Expr *pStr2; /* Copy of pStr1 - RHS of LIKE/GLOB operator */
161578 pLeft = pExpr->x.pList->a[1].pExpr;
161584 /* Convert the lower bound to upper-case and the upper bound to
161585 ** lower-case (upper-case is less than lower-case in ASCII) so that
161588 if( noCase && !pParse->db->mallocFailed ){
161591 pTerm->wtFlags |= TERM_LIKE;
161592 for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
161593 pStr1->u.zToken[i] = sqlite3Toupper(c);
161594 pStr2->u.zToken[i] = sqlite3Tolower(c);
161598 if( !db->mallocFailed ){
161600 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
161609 if( c=='A'-1 ) isComplete = 0;
161631 pTerm = &pWC->a[idxTerm];
161639 /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create
161640 ** new terms for each component comparison - "a = ?" and "b = ?". The
161645 ** is not a sub-select.
161647 ** tag-20220128a
161649 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
161650 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
161651 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
161652 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
161653 || (pExpr->pRight->flags & EP_xIsSelect)==0)
161654 && pWC->op==TK_AND
161660 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
161661 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
161663 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
161668 pTerm = &pWC->a[idxTerm];
161669 pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL; /* Disable the original */
161670 pTerm->eOperator = WO_ROWVAL;
161673 /* If there is a vector IN term - e.g. "(a, b) IN (SELECT ...)" - create
161682 else if( pExpr->op==TK_IN
161683 && pTerm->u.x.iField==0
161684 && pExpr->pLeft->op==TK_VECTOR
161686 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
161688 && pExpr->x.pSelect->pWin==0
161690 && pWC->op==TK_AND
161693 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
161696 pWC->a[idxNew].u.x.iField = i+1;
161712 else if( pWC->op==TK_AND ){
161715 while( res-- > 0 ){
161728 pNewExpr->w.iJoin = pExpr->w.iJoin;
161732 pNewTerm = &pWC->a[idxNew];
161733 pNewTerm->prereqRight = prereqExpr;
161734 pNewTerm->leftCursor = pLeft->iTable;
161735 pNewTerm->u.x.leftColumn = pLeft->iColumn;
161736 pNewTerm->eOperator = WO_AUX;
161737 pNewTerm->eMatchOp = eOp2;
161739 pTerm = &pWC->a[idxTerm];
161740 pTerm->wtFlags |= TERM_COPIED;
161741 pNewTerm->prereqAll = pTerm->prereqAll;
161751 testcase( pTerm!=&pWC->a[idxTerm] );
161752 pTerm = &pWC->a[idxTerm];
161753 pTerm->prereqRight |= extraRight;
161780 pWC->op = op;
161783 if( pE2->op!=op ){
161786 sqlite3WhereSplit(pWC, pE2->pLeft, op);
161787 sqlite3WhereSplit(pWC, pE2->pRight, op);
161794 ** where-clause passed as the first argument. The value for the term
161809 Parse *pParse = pWC->pWInfo->pParse;
161810 sqlite3 *db = pParse->db;
161818 pVal->u.iValue = iVal;
161823 pVal->iTable = iReg;
161830 pTerm = &pWC->a[idx];
161831 pTerm->leftCursor = iCsr;
161832 pTerm->eOperator = WO_AUX;
161833 pTerm->eMatchOp = eMatchOp;
161856 assert( p!=0 && p->pLimit!=0 ); /* 1 -- checked by caller */
161857 if( p->pGroupBy==0
161858 && (p->selFlags & (SF_Distinct|SF_Aggregate))==0 /* 2 */
161859 && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab)) /* 3 */
161861 ExprList *pOrderBy = p->pOrderBy;
161862 int iCsr = p->pSrc->a[0].iCursor;
161866 for(ii=0; ii<pWC->nTerm; ii++){
161867 if( pWC->a[ii].wtFlags & TERM_CODED ){
161869 ** other, subsequent terms. It can be ignored. See tag-20220128a */
161870 assert( pWC->a[ii].wtFlags & TERM_VIRTUAL );
161871 assert( pWC->a[ii].eOperator==WO_ROWVAL );
161874 if( pWC->a[ii].nChild ){
161876 ** pWC->a[] array. So this term can be ignored, as a LIMIT clause
161881 if( pWC->a[ii].leftCursor!=iCsr ) return;
161882 if( pWC->a[ii].prereqRight!=0 ) return;
161887 for(ii=0; ii<pOrderBy->nExpr; ii++){
161888 Expr *pExpr = pOrderBy->a[ii].pExpr;
161889 if( pExpr->op!=TK_COLUMN ) return;
161890 if( pExpr->iTable!=iCsr ) return;
161891 if( pOrderBy->a[ii].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) return;
161895 /* All conditions are met. Add the terms to the where-clause object. */
161896 assert( p->pLimit->op==TK_LIMIT );
161897 if( p->iOffset!=0 && (p->selFlags & SF_Compound)==0 ){
161898 whereAddLimitExpr(pWC, p->iOffset, p->pLimit->pRight,
161901 if( p->iOffset==0 || (p->selFlags & SF_Compound)==0 ){
161902 whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
161915 pWC->pWInfo = pWInfo;
161916 pWC->hasOr = 0;
161917 pWC->pOuter = 0;
161918 pWC->nTerm = 0;
161919 pWC->nBase = 0;
161920 pWC->nSlot = ArraySize(pWC->aStatic);
161921 pWC->a = pWC->aStatic;
161930 sqlite3 *db = pWC->pWInfo->pParse->db;
161931 assert( pWC->nTerm>=pWC->nBase );
161932 if( pWC->nTerm>0 ){
161933 WhereTerm *a = pWC->a;
161934 WhereTerm *aLast = &pWC->a[pWC->nTerm-1];
161937 /* Verify that every term past pWC->nBase is virtual */
161938 for(i=pWC->nBase; i<pWC->nTerm; i++){
161939 assert( (pWC->a[i].wtFlags & TERM_VIRTUAL)!=0 );
161943 assert( a->eMatchOp==0 || a->eOperator==WO_AUX );
161944 if( a->wtFlags & TERM_DYNAMIC ){
161945 sqlite3ExprDelete(db, a->pExpr);
161947 if( a->wtFlags & (TERM_ORINFO|TERM_ANDINFO) ){
161948 if( a->wtFlags & TERM_ORINFO ){
161949 assert( (a->wtFlags & TERM_ANDINFO)==0 );
161950 whereOrInfoDelete(db, a->u.pOrInfo);
161952 assert( (a->wtFlags & TERM_ANDINFO)!=0 );
161953 whereAndInfoDelete(db, a->u.pAndInfo);
161968 ** sqlite3WhereExprUsage(MaskSet, Expr) ->
161973 ** sqlite3WhereExprUsageNN(MaskSet, Expr) ->
161978 ** sqlite3WhereExprListUsage(MaskSet, ExprList) ->
161984 ** sqlite3WhereExprUsageFull(MaskSet, ExprList) ->
161991 ** "no-inline" function to avoid the stack push overhead in the
161999 mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0;
162000 if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft);
162001 if( p->pRight ){
162002 mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
162003 assert( p->x.pList==0 );
162005 if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1;
162006 mask |= exprSelectUsage(pMaskSet, p->x.pSelect);
162007 }else if( p->x.pList ){
162008 mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
162011 if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && ExprUseYWin(p) ){
162012 assert( p->y.pWin!=0 );
162013 mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);
162014 mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy);
162015 mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter);
162021 if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
162022 return sqlite3WhereGetMask(pMaskSet, p->iTable);
162024 assert( p->op!=TK_IF_NULL_ROW );
162036 for(i=0; i<pList->nExpr; i++){
162037 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
162057 for(i=pWC->nTerm-1; i>=0; i--){
162063 ** For table-valued-functions, transform the function arguments into
162079 if( pItem->fg.isTabFunc==0 ) return;
162080 pTab = pItem->pTab;
162082 pArgs = pItem->u1.pFuncArg;
162084 for(j=k=0; j<pArgs->nExpr; j++){
162087 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
162088 if( k>=pTab->nCol ){
162089 sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d",
162090 pTab->zName, j);
162093 pColRef = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
162095 pColRef->iTable = pItem->iCursor;
162096 pColRef->iColumn = k++;
162098 pColRef->y.pTab = pTab;
162099 pItem->colUsed |= sqlite3ExprColUsed(pColRef);
162101 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
162103 if( pItem->fg.jointype & (JT_LEFT|JT_RIGHT) ){
162104 testcase( pItem->fg.jointype & JT_LEFT ); /* testtag-20230227a */
162105 testcase( pItem->fg.jointype & JT_RIGHT ); /* testtag-20230227b */
162108 testcase( pItem->fg.jointype & JT_LTORJ ); /* testtag-20230227c */
162111 sqlite3SetJoinExpr(pTerm, pItem->iCursor, joinType);
162167 return pWInfo->nRowOut;
162175 return pWInfo->eDistinct;
162187 return pWInfo->nOBSat<0 ? 0 : pWInfo->nOBSat;
162191 ** In the ORDER BY LIMIT optimization, if the inner-most loop is known
162193 ** inner-most loop did not fit within the sorter, then we can skip all
162196 ** loop - the loop immediately outside the inner-most.
162203 ** be the continuation for the second-inner-most loop. If the ORDER BY
162205 ** be the continuation for the inner-most loop.
162208 ** inner-most loop, in the sense that a correct answer will result.
162215 if( !pWInfo->bOrderedInnerLoop ){
162217 ** continuation of the inner-most loop. */
162218 return pWInfo->iContinue;
162220 pInner = &pWInfo->a[pWInfo->nLevel-1];
162221 assert( pInner->addrNxt!=0 );
162222 return pInner->pRJ ? pWInfo->iContinue : pInner->addrNxt;
162227 ** the aggregate-step call to min() or max(), check to see if any
162239 if( !pWInfo->bOrderedInnerLoop ) return;
162240 if( pWInfo->nOBSat==0 ) return;
162241 for(i=pWInfo->nLevel-1; i>=0; i--){
162242 pInner = &pWInfo->a[i];
162243 if( (pInner->pWLoop->wsFlags & WHERE_COLUMN_IN)!=0 ){
162244 sqlite3VdbeGoto(v, pInner->addrNxt);
162248 sqlite3VdbeGoto(v, pWInfo->iBreak);
162256 assert( pWInfo->iContinue!=0 );
162257 return pWInfo->iContinue;
162265 return pWInfo->iBreak;
162272 ** a single row is to be changed. Return ONEPASS_MULTI (2) if the one-pass
162279 ** Either value may be -1, indicating that cursor is not used.
162282 ** aiCur[0] and aiCur[1] both get -1 if the where-clause logic is
162286 memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);
162288 if( sqlite3WhereTrace && pWInfo->eOnePass!=ONEPASS_OFF ){
162290 pWInfo->eOnePass==ONEPASS_SINGLE ? "ONEPASS_SINGLE" : "ONEPASS_MULTI",
162294 return pWInfo->eOnePass;
162302 return pWInfo->bDeferredSeek;
162309 pDest->n = pSrc->n;
162310 memcpy(pDest->a, pSrc->a, pDest->n*sizeof(pDest->a[0]));
162323 LogEst rRun, /* Run-cost of the new entry */
162328 for(i=pSet->n, p=pSet->a; i>0; i--, p++){
162329 if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){
162332 if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){
162336 if( pSet->n<N_OR_COST ){
162337 p = &pSet->a[pSet->n++];
162338 p->nOut = nOut;
162340 p = pSet->a;
162341 for(i=1; i<pSet->n; i++){
162342 if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i;
162344 if( p->rRun<=rRun ) return 0;
162347 p->prereq = prereq;
162348 p->rRun = rRun;
162349 if( p->nOut>nOut ) p->nOut = nOut;
162359 assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
162360 assert( pMaskSet->n>0 || pMaskSet->ix[0]<0 );
162361 assert( iCursor>=-1 );
162362 if( pMaskSet->ix[0]==iCursor ){
162365 for(i=1; i<pMaskSet->n; i++){
162366 if( pMaskSet->ix[i]==iCursor ){
162377 pBlock = sqlite3DbMallocRawNN(pWInfo->pParse->db, nByte+sizeof(*pBlock));
162379 pBlock->pNext = pWInfo->pMemToFree;
162380 pBlock->sz = nByte;
162381 pWInfo->pMemToFree = pBlock;
162390 pOldBlk--;
162391 assert( pOldBlk->sz<nByte );
162392 memcpy(pNew, pOld, pOldBlk->sz);
162402 ** sqlite3WhereBegin() routine. So we know that the pMaskSet->ix[]
162406 assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
162407 pMaskSet->ix[pMaskSet->n++] = iCursor;
162411 ** If the right-hand branch of the expression is a TK_COLUMN, then return
162412 ** a pointer to the right-hand branch. Otherwise, return NULL.
162415 p = sqlite3ExprSkipCollateAndLikely(p->pRight);
162416 if( ALWAYS(p!=0) && p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
162436 Expr *pX = pTerm->pExpr;
162439 assert( pTerm->eOperator & WO_IN );
162441 if( sqlite3ExprIsVector(pX->pLeft) ){
162442 int iField = pTerm->u.x.iField - 1;
162445 inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
162447 inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
162453 return pRet ? pRet->zName : sqlite3StrBINARY;
162465 i16 iColumn; /* The column on the LHS of the term. -1 for IPK */
162467 WhereClause *pWC; /* Shorthand for pScan->pWC */
162469 int k = pScan->k; /* Where to start scanning */
162471 assert( pScan->iEquiv<=pScan->nEquiv );
162472 pWC = pScan->pWC;
162474 iColumn = pScan->aiColumn[pScan->iEquiv-1];
162475 iCur = pScan->aiCur[pScan->iEquiv-1];
162479 for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
162480 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 || pTerm->leftCursor<0 );
162481 if( pTerm->leftCursor==iCur
162482 && pTerm->u.x.leftColumn==iColumn
162484 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
162485 pScan->pIdxExpr,iCur)==0)
162486 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
162488 if( (pTerm->eOperator & WO_EQUIV)!=0
162489 && pScan->nEquiv<ArraySize(pScan->aiCur)
162490 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
162493 for(j=0; j<pScan->nEquiv; j++){
162494 if( pScan->aiCur[j]==pX->iTable
162495 && pScan->aiColumn[j]==pX->iColumn ){
162499 if( j==pScan->nEquiv ){
162500 pScan->aiCur[j] = pX->iTable;
162501 pScan->aiColumn[j] = pX->iColumn;
162502 pScan->nEquiv++;
162505 if( (pTerm->eOperator & pScan->opMask)!=0 ){
162507 if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){
162509 Parse *pParse = pWC->pWInfo->pParse;
162510 pX = pTerm->pExpr;
162512 if( (pTerm->eOperator & WO_IN) ){
162513 zCollName = indexInAffinityOk(pParse, pTerm, pScan->idxaff);
162517 if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
162520 assert(pX->pLeft);
162522 zCollName = pColl ? pColl->zName : sqlite3StrBINARY;
162525 if( sqlite3StrICmp(zCollName, pScan->zCollName) ){
162529 if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0
162530 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
162531 && pX->op==TK_COLUMN
162532 && pX->iTable==pScan->aiCur[0]
162533 && pX->iColumn==pScan->aiColumn[0]
162535 testcase( pTerm->eOperator & WO_IS );
162538 pScan->pWC = pWC;
162539 pScan->k = k+1;
162543 sqlite3DebugPrintf("SCAN-TERM %p: nEquiv=%d",
162544 pTerm, pScan->nEquiv);
162545 for(ii=0; ii<pScan->nEquiv; ii++){
162547 pScan->aiCur[ii], pScan->aiColumn[ii]);
162556 pWC = pWC->pOuter;
162559 if( pScan->iEquiv>=pScan->nEquiv ) break;
162560 pWC = pScan->pOrigWC;
162562 pScan->iEquiv++;
162569 ** It is factored out into a separate tail-recursion subroutine so that
162570 ** the normal whereScanInit() routine, which is a high-runner, does not
162574 pScan->idxaff = sqlite3ExprAffinity(pScan->pIdxExpr);
162605 pScan->pOrigWC = pWC;
162606 pScan->pWC = pWC;
162607 pScan->pIdxExpr = 0;
162608 pScan->idxaff = 0;
162609 pScan->zCollName = 0;
162610 pScan->opMask = opMask;
162611 pScan->k = 0;
162612 pScan->aiCur[0] = iCur;
162613 pScan->nEquiv = 1;
162614 pScan->iEquiv = 1;
162617 iColumn = pIdx->aiColumn[j];
162618 if( iColumn==pIdx->pTable->iPKey ){
162621 pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
162622 pScan->zCollName = pIdx->azColl[j];
162624 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
162625 pScan->zCollName = pIdx->azColl[j];
162626 pScan->aiColumn[0] = XN_EXPR;
162632 pScan->aiColumn[0] = iColumn;
162643 ** Search for terms matching the iColumn-th column of pIdx
162644 ** rather than the iColumn-th column of table iCur.
162648 ** identified by the WO_EQUIV bit in the pTerm->eOperator field. The
162655 ** then try for the one with no dependencies on <expr> - in other words where
162658 ** the form "X <op> <const-expr>" exist. If no terms with a constant RHS
162676 if( (p->prereqRight & notReady)==0 ){
162677 if( p->prereqRight==0 && (p->eOperator&op)!=0 ){
162678 testcase( p->eOperator & WO_IS );
162689 ** This function searches pList for an entry that matches the iCol-th column
162692 ** If such an expression is found, its index in pList->a[] is returned. If
162693 ** no expression is found, -1 is returned.
162703 const char *zColl = pIdx->azColl[iCol];
162705 for(i=0; i<pList->nExpr; i++){
162706 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
162708 && (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN)
162709 && p->iColumn==pIdx->aiColumn[iCol]
162710 && p->iTable==iBase
162712 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
162713 if( 0==sqlite3StrICmp(pColl->zName, zColl) ){
162719 return -1;
162723 ** Return TRUE if the iCol-th column of index pIdx is NOT NULL
162728 assert( iCol>=0 && iCol<pIdx->nColumn );
162729 j = pIdx->aiColumn[iCol];
162731 return pIdx->pTable->aCol[j].notNull;
162732 }else if( j==(-1) ){
162735 assert( j==(-2) );
162742 ** Return true if the DISTINCT expression-list passed as the third argument
162746 ** DISTINCT list are collectively unique and individually non-null.
162759 /* If there is more than one table or sub-select in the FROM clause of
162762 if( pTabList->nSrc!=1 ) return 0;
162763 iBase = pTabList->a[0].iCursor;
162764 pTab = pTabList->a[0].pTab;
162767 ** true. Note: The (p->iTable==iBase) part of this test may be false if the
162768 ** current SELECT is a correlated sub-query.
162770 for(i=0; i<pDistinct->nExpr; i++){
162771 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
162773 if( p->op!=TK_COLUMN && p->op!=TK_AGG_COLUMN ) continue;
162774 if( p->iTable==iBase && p->iColumn<0 ) return 1;
162785 ** comparison and select-list expressions must match those of the index.
162790 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
162792 if( pIdx->pPartIdxWhere ) continue;
162793 for(i=0; i<pIdx->nKeyCol; i++){
162799 if( i==pIdx->nKeyCol ){
162810 ** Estimate the logarithm of the input value to base 2.
162813 return N<=10 ? 0 : sqlite3LogEst(N) - 33;
162820 ** opcodes into OP_Copy when the table is being accessed via co-routine
162833 int iAutoidxCur /* If non-zero, cursor of autoindex being generated */
162835 Vdbe *v = pParse->pVdbe;
162838 if( pParse->db->mallocFailed ) return;
162840 if( pOp->p1!=iTabCur ) continue;
162841 if( pOp->opcode==OP_Column ){
162843 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
162847 pOp->opcode = OP_Copy;
162848 pOp->p1 = pOp->p2 + iRegister;
162849 pOp->p2 = pOp->p3;
162850 pOp->p3 = 0;
162851 pOp->p5 = 2; /* Cause the MEM_Subtype flag to be cleared */
162852 }else if( pOp->opcode==OP_Rowid ){
162854 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
162858 pOp->opcode = OP_Sequence;
162859 pOp->p1 = iAutoidxCur;
162862 pOp->opcode = OP_Null;
162863 pOp->p3 = 0;
162874 ** are no-ops.
162883 sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
162884 for(i=0; i<p->nConstraint; i++){
162888 p->aConstraint[i].iColumn,
162889 p->aConstraint[i].iTermOffset,
162890 p->aConstraint[i].op,
162891 p->aConstraint[i].usable,
162894 for(i=0; i<p->nOrderBy; i++){
162897 p->aOrderBy[i].iColumn,
162898 p->aOrderBy[i].desc);
162907 sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
162908 for(i=0; i<p->nConstraint; i++){
162911 p->aConstraintUsage[i].argvIndex,
162912 p->aConstraintUsage[i].omit);
162914 sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum);
162915 sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr);
162916 sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed);
162917 sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost);
162918 sqlite3DebugPrintf(" estimatedRows=%lld\n", p->estimatedRows);
162936 ** not-NULL condition on the left table of the RIGHT JOIN.
162942 assert( (pSrc->fg.jointype&(JT_LEFT|JT_LTORJ|JT_RIGHT))!=0 ); /* By caller */
162943 testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LEFT );
162944 testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LTORJ );
162945 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
162946 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
162947 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
162948 || pTerm->pExpr->w.iJoin != pSrc->iCursor
162952 if( (pSrc->fg.jointype & (JT_LEFT|JT_RIGHT))!=0
162953 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
162974 if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
162975 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
162976 assert( (pSrc->fg.jointype & JT_RIGHT)==0 );
162977 if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0
162982 if( (pTerm->prereqRight & notReady)!=0 ) return 0;
162983 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
162984 if( pTerm->u.x.leftColumn<0 ) return 0;
162985 aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity;
162986 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
162987 testcase( pTerm->pExpr->op==TK_IS );
163013 if( IS_STMT_SCANSTATUS(pParse->db) && pParse->explain!=2 ){
163014 Table *pTab = pIdx->pTable;
163018 sqlite3_str *pStr = sqlite3_str_new(pParse->db);
163019 sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName);
163020 assert( pIdx->nColumn>1 );
163021 assert( pIdx->aiColumn[pIdx->nColumn-1]==XN_ROWID );
163022 for(ii=0; ii<(pIdx->nColumn-1); ii++){
163024 int iCol = pIdx->aiColumn[ii];
163026 zName = pTab->aCol[iCol].zCnName;
163032 sqlite3OomFault(pParse->db);
163058 WhereTerm *pWCEnd; /* End of pWC->a[] */
163067 int mxBitCol; /* Maximum column in pSrc->colUsed */
163087 v = pParse->pVdbe;
163094 pTabList = pWC->pWInfo->pTabList;
163095 pSrc = &pTabList->a[pLevel->iFrom];
163096 pTable = pSrc->pTab;
163097 pWCEnd = &pWC->a[pWC->nTerm];
163098 pLoop = pLevel->pWLoop;
163100 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
163101 Expr *pExpr = pTerm->pExpr;
163105 if( (pTerm->wtFlags & TERM_VIRTUAL)==0
163106 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom, 0)
163109 sqlite3ExprDup(pParse->db, pExpr, 0));
163114 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
163115 iCol = pTerm->u.x.leftColumn;
163116 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
163118 testcase( iCol==BMS-1 );
163121 "automatic index on %s(%s)", pTable->zName,
163122 pTable->aCol[iCol].zCnName);
163126 if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){
163129 pLoop->aLTerm[nKeyCol++] = pTerm;
163134 assert( nKeyCol>0 || pParse->db->mallocFailed );
163135 pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol;
163136 pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED
163150 extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1));
163152 mxBitCol = MIN(BMS-1,pTable->nCol);
163153 testcase( pTable->nCol==BMS-1 );
163154 testcase( pTable->nCol==BMS-2 );
163158 if( pSrc->colUsed & MASKBIT(BMS-1) ){
163159 nKeyCol += pTable->nCol - BMS + 1;
163163 pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
163165 pLoop->u.btree.pIndex = pIdx;
163166 pIdx->zName = "auto-index";
163167 pIdx->pTable = pTable;
163170 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
163174 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
163175 iCol = pTerm->u.x.leftColumn;
163176 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
163177 testcase( iCol==BMS-1 );
163180 Expr *pX = pTerm->pExpr;
163182 pIdx->aiColumn[n] = pTerm->u.x.leftColumn;
163184 assert( pColl!=0 || pParse->nErr>0 ); /* TH3 collate01.800 */
163185 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
163187 if( ALWAYS(pX->pLeft!=0)
163188 && sqlite3ExprAffinity(pX->pLeft)!=SQLITE_AFF_TEXT
163200 assert( (u32)n==pLoop->u.btree.nEq );
163206 pIdx->aiColumn[n] = i;
163207 pIdx->azColl[n] = sqlite3StrBINARY;
163211 if( pSrc->colUsed & MASKBIT(BMS-1) ){
163212 for(i=BMS-1; i<pTable->nCol; i++){
163213 pIdx->aiColumn[n] = i;
163214 pIdx->azColl[n] = sqlite3StrBINARY;
163219 pIdx->aiColumn[n] = XN_ROWID;
163220 pIdx->azColl[n] = sqlite3StrBINARY;
163224 assert( pLevel->iIdxCur>=0 );
163225 pLevel->iIdxCur = pParse->nTab++;
163226 sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);
163228 VdbeComment((v, "for %s", pTable->zName));
163229 if( OptimizationEnabled(pParse->db, SQLITE_BloomFilter) && useBloomFilter ){
163230 sqlite3WhereExplainBloomFilter(pParse, pWC->pWInfo, pLevel);
163231 pLevel->regFilter = ++pParse->nMem;
163232 sqlite3VdbeAddOp2(v, OP_Blob, 10000, pLevel->regFilter);
163236 assert( pSrc == &pWC->pWInfo->pTabList->a[pLevel->iFrom] );
163237 if( pSrc->fg.viaCoroutine ){
163238 int regYield = pSrc->regReturn;
163240 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSrc->addrFillSub);
163243 VdbeComment((v, "next row of %s", pSrc->pTab->zName));
163245 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
163250 pLoop->wsFlags |= WHERE_PARTIALIDX;
163254 pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0
163256 if( pLevel->regFilter ){
163257 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0,
163258 regBase, pLoop->u.btree.nEq);
163261 sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
163264 if( pSrc->fg.viaCoroutine ){
163266 testcase( pParse->db->mallocFailed );
163267 assert( pLevel->iIdxCur>0 );
163268 translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
163269 pSrc->regResult, pLevel->iIdxCur);
163271 pSrc->fg.viaCoroutine = 0;
163273 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
163281 sqlite3VdbeScanStatusRange(v, addrExp, addrExp, -1);
163284 sqlite3ExprDelete(pParse->db, pPartial);
163301 ** and skip the subsequence B-Tree seek if the Bloom filter indicates that
163310 int iLevel, /* Index in pWInfo->a[] that is pLevel */
163319 Parse *pParse = pWInfo->pParse; /* Parsing context */
163320 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
163321 WhereLoop *pLoop = pLevel->pWLoop; /* The loop being coded */
163326 saved_pIdxEpr = pParse->pIdxEpr;
163327 saved_pIdxPartExpr = pParse->pIdxPartExpr;
163328 pParse->pIdxEpr = 0;
163329 pParse->pIdxPartExpr = 0;
163333 assert( pLoop->wsFlags & WHERE_BLOOMFILTER );
163334 assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 );
163345 iCur = pLevel->iTabCur;
163346 pLevel->regFilter = ++pParse->nMem;
163349 ** to zero-filled blob of at least 80K bits, but maybe more if the
163351 ** measure the size of the table at run-time using OP_Count with
163356 pTabList = pWInfo->pTabList;
163357 iSrc = pLevel->iFrom;
163358 pItem = &pTabList->a[iSrc];
163360 pTab = pItem->pTab;
163362 sz = sqlite3LogEstToInt(pTab->nRowLogEst);
163368 sqlite3VdbeAddOp2(v, OP_Blob, (int)sz, pLevel->regFilter);
163371 pWCEnd = &pWInfo->sWC.a[pWInfo->sWC.nTerm];
163372 for(pTerm=pWInfo->sWC.a; pTerm<pWCEnd; pTerm++){
163373 Expr *pExpr = pTerm->pExpr;
163374 if( (pTerm->wtFlags & TERM_VIRTUAL)==0
163377 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
163380 if( pLoop->wsFlags & WHERE_IPK ){
163383 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, 1);
163386 Index *pIdx = pLoop->u.btree.pIndex;
163387 int n = pLoop->u.btree.nEq;
163391 assert( pIdx->pTable==pItem->pTab );
163394 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, n);
163398 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
163401 pLoop->wsFlags &= ~WHERE_BLOOMFILTER;
163402 if( OptimizationDisabled(pParse->db, SQLITE_BloomPulldown) ) break;
163403 while( ++iLevel < pWInfo->nLevel ){
163405 pLevel = &pWInfo->a[iLevel];
163406 pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
163407 if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ) ) continue;
163408 pLoop = pLevel->pWLoop;
163410 if( pLoop->prereq & notReady ) continue;
163411 if( (pLoop->wsFlags & (WHERE_BLOOMFILTER|WHERE_COLUMN_IN))
163414 /* This is a candidate for bloom-filter pull-down (early evaluation).
163421 }while( iLevel < pWInfo->nLevel );
163423 pParse->pIdxEpr = saved_pIdxEpr;
163424 pParse->pIdxPartExpr = saved_pIdxPartExpr;
163443 Parse *pParse = pWInfo->pParse;
163454 ExprList *pOrderBy = pWInfo->pOrderBy;
163457 pTab = pSrc->pTab;
163465 for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
163466 pTerm->wtFlags &= ~TERM_OK;
163467 if( pTerm->leftCursor != pSrc->iCursor ) continue;
163468 if( pTerm->prereqRight & mUnusable ) continue;
163469 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
163470 testcase( pTerm->eOperator & WO_IN );
163471 testcase( pTerm->eOperator & WO_ISNULL );
163472 testcase( pTerm->eOperator & WO_IS );
163473 testcase( pTerm->eOperator & WO_ALL );
163474 if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
163475 if( pTerm->wtFlags & TERM_VNULL ) continue;
163477 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
163478 assert( pTerm->u.x.leftColumn>=XN_ROWID );
163479 assert( pTerm->u.x.leftColumn<pTab->nCol );
163480 if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0
163486 pTerm->wtFlags |= TERM_OK;
163495 int n = pOrderBy->nExpr;
163497 Expr *pExpr = pOrderBy->a[i].pExpr;
163506 if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break;
163508 /* First case - a direct column references without a COLLATE operator */
163509 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
163510 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
163514 /* 2nd case - a column reference with a COLLATE operator. Only match
163516 if( pExpr->op==TK_COLLATE
163517 && (pE2 = pExpr->pLeft)->op==TK_COLUMN
163518 && pE2->iTable==pSrc->iCursor
163522 assert( pExpr->u.zToken!=0 );
163523 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
163524 pExpr->iColumn = pE2->iColumn;
163525 if( pE2->iColumn<0 ) continue; /* Collseq does not matter for rowid */
163526 zColl = sqlite3ColumnColl(&pTab->aCol[pE2->iColumn]);
163528 if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue;
163536 if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) && !pSrc->fg.rowidUsed ){
163537 eDistinct = 2 + ((pWInfo->wctrlFlags & WHERE_SORTBYGROUP)!=0);
163538 }else if( pWInfo->wctrlFlags & WHERE_GROUPBY ){
163546 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
163555 pIdxCons = (struct sqlite3_index_constraint*)&pHidden->aRhs[nTerm];
163558 pIdxInfo->aConstraint = pIdxCons;
163559 pIdxInfo->aOrderBy = pIdxOrderBy;
163560 pIdxInfo->aConstraintUsage = pUsage;
163561 pHidden->pWC = pWC;
163562 pHidden->pParse = pParse;
163563 pHidden->eDistinct = eDistinct;
163564 pHidden->mIn = 0;
163565 for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
163567 if( (pTerm->wtFlags & TERM_OK)==0 ) continue;
163568 pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
163570 op = pTerm->eOperator & WO_ALL;
163572 if( (pTerm->wtFlags & TERM_SLICE)==0 ){
163573 pHidden->mIn |= SMASKBIT32(j);
163578 pIdxCons[j].op = pTerm->eMatchOp;
163595 assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
163598 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
163610 pIdxInfo->nConstraint = j;
163612 Expr *pExpr = pOrderBy->a[i].pExpr;
163614 assert( pExpr->op==TK_COLUMN
163615 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
163616 && pExpr->iColumn==pExpr->pLeft->iColumn) );
163617 pIdxOrderBy[j].iColumn = pExpr->iColumn;
163618 pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC;
163621 pIdxInfo->nOrderBy = j;
163636 assert( pHidden->pParse!=0 );
163637 assert( pHidden->pParse->db==db );
163638 for(i=0; i<pIdxInfo->nConstraint; i++){
163639 sqlite3ValueFree(pHidden->aRhs[i]); /* IMP: R-14553-25174 */
163640 pHidden->aRhs[i] = 0;
163658 ** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
163662 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
163666 pParse->db->nSchemaLock++;
163667 rc = pVtab->pModule->xBestIndex(pVtab, p);
163668 pParse->db->nSchemaLock--;
163673 sqlite3OomFault(pParse->db);
163674 }else if( !pVtab->zErrMsg ){
163677 sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
163680 if( pTab->u.vtab.p->bAllSchemas ){
163683 sqlite3_free(pVtab->zErrMsg);
163684 pVtab->zErrMsg = 0;
163699 ** into the aSample[] array - it is an index into a virtual set of samples
163710 IndexSample *aSample = pIdx->aSample;
163724 assert( pIdx->nSample>0 );
163725 assert( pRec->nField>0 );
163741 ** aSample[3] = (c, 100)
163755 ** 7: (c, 100)
163772 if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){
163773 nField = pIdx->nKeyCol;
163775 nField = pIdx->nColumn;
163777 nField = MIN(pRec->nField, nField);
163779 iSample = pIdx->nSample * nField;
163791 if( aSample[iSamp-1].anLt[n-1]!=aSample[iSamp].anLt[n-1] ) break;
163797 pRec->nField = n;
163800 iLower = aSample[iSamp].anLt[n-1] + aSample[iSamp].anEq[n-1];
163803 iLower = aSample[iSamp].anLt[n-1];
163805 res = -1;
163808 iCol = n-1;
163817 if( pParse->db->mallocFailed==0 ){
163820 assert( i<pIdx->nSample );
163821 assert( iCol==nField-1 );
163822 pRec->nField = nField;
163824 || pParse->db->mallocFailed
163827 /* Unless i==pIdx->nSample, indicating that pRec is larger than
163830 assert( i<=pIdx->nSample && i>=0 );
163831 pRec->nField = iCol+1;
163832 assert( i==pIdx->nSample
163834 || pParse->db->mallocFailed );
163839 ** If (i>0), then pRec must also be greater than sample (i-1). */
163841 pRec->nField = iCol;
163843 || pParse->db->mallocFailed || CORRUPT_DB );
163846 pRec->nField = nField;
163847 assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
163848 || pParse->db->mallocFailed || CORRUPT_DB );
163856 assert( iCol==nField-1 );
163861 ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec
163864 if( i>=pIdx->nSample ){
163865 iUpper = pIdx->nRowEst0;
163873 iGap = iUpper - iLower;
163881 aStat[1] = pIdx->aAvgEq[nField-1];
163884 /* Restore the pRec->nField value before returning. */
163885 pRec->nField = nField;
163904 if( pTerm->truthProb<=0 ){
163905 nRet += pTerm->truthProb;
163906 }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){
163907 nRet -= 20; assert( 20==sqlite3LogEst(4) );
163919 assert( iCol>=0 && iCol<pIdx->nColumn );
163920 if( !pIdx->zColAff ){
163923 assert( pIdx->zColAff[iCol]!=0 );
163924 return pIdx->zColAff[iCol];
163932 ** range-scan on a skip-scan index. For example:
163937 ** Value pLoop->nOut is currently set to the estimated number of rows
163948 ** N is the total number of samples, the pLoop->nOut value is adjusted
163951 ** nOut = nOut * ( min(U - L, 1) / N )
163972 Index *p = pLoop->u.btree.pIndex;
163973 int nEq = pLoop->u.btree.nEq;
163974 sqlite3 *db = pParse->db;
163975 int nLower = -1;
163976 int nUpper = p->nSample+1;
163985 pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]);
163987 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
163991 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
163992 nUpper = p2 ? 0 : p->nSample;
163998 for(i=0; rc==SQLITE_OK && i<p->nSample; i++){
163999 rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal);
164009 nDiff = (nUpper - nLower);
164018 int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff));
164019 pLoop->nOut -= nAdjust;
164021 WHERETRACE(0x20, ("range skip-scan regions: %u..%u adjust=%d est=%d\n",
164022 nLower, nUpper, nAdjust*-1, pLoop->nOut));
164052 ** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index
164060 ** left-most column of the index). Or, if the query is:
164085 int nOut = pLoop->nOut;
164089 Index *p = pLoop->u.btree.pIndex;
164090 int nEq = pLoop->u.btree.nEq;
164092 if( p->nSample>0 && ALWAYS(nEq<p->nSampleCol)
164093 && OptimizationEnabled(pParse->db, SQLITE_Stat4)
164095 if( nEq==pBuilder->nRecValid ){
164096 UnpackedRecord *pRec = pBuilder->pRec;
164098 int nBtm = pLoop->u.btree.nBtm;
164099 int nTop = pLoop->u.btree.nTop;
164104 ** key-prefix formed by the nEq values matched against the nEq left-most
164118 ** The number of rows between the two bounds is then just iUpper-iLower.
164122 int iLwrIdx = -2; /* aSample[] for the lower bound */
164123 int iUprIdx = -1; /* aSample[] for the upper bound */
164126 testcase( pRec->nField!=pBuilder->nRecValid );
164127 pRec->nField = pBuilder->nRecValid;
164132 iUpper = p->nRowEst0;
164134 /* Note: this call could be optimized away - since the same values must
164141 assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 );
164142 assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 );
164143 assert( p->aSortOrder!=0 );
164144 if( p->aSortOrder[nEq] ){
164153 Expr *pExpr = pLower->pExpr->pRight;
164160 iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0);
164162 nOut--;
164170 Expr *pExpr = pUpper->pExpr->pRight;
164177 iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0);
164179 nOut--;
164184 pBuilder->pRec = pRec;
164187 nNew = sqlite3LogEst(iUpper - iLower);
164192 if( iLwrIdx==iUprIdx ){ nNew -= 20; }
164214 assert( pUpper==0 || (pUpper->wtFlags & TERM_VNULL)==0 || pParse->nErr>0 );
164219 ** has an application-defined likelihood(), assume the range is
164220 ** reduced by an additional 75%. This means that, by default, an open-ended
164224 if( pLower && pLower->truthProb>0 && pUpper && pUpper->truthProb>0 ){
164225 nNew -= 20;
164228 nOut -= (pLower!=0) + (pUpper!=0);
164232 if( pLoop->nOut>nOut ){
164234 pLoop->nOut, nOut));
164237 pLoop->nOut = (LogEst)nOut;
164245 ** the histogram data. This only works when x is the left-most
164252 ** non-zero.
164265 Index *p = pBuilder->pNew->u.btree.pIndex;
164266 int nEq = pBuilder->pNew->u.btree.nEq;
164267 UnpackedRecord *pRec = pBuilder->pRec;
164273 assert( nEq<=p->nColumn );
164274 assert( p->aSample!=0 );
164275 assert( p->nSample>0 );
164276 assert( pBuilder->nRecValid<nEq );
164280 if( pBuilder->nRecValid<(nEq-1) ){
164286 if( nEq>=p->nColumn ){
164291 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
164292 pBuilder->pRec = pRec;
164295 pBuilder->nRecValid = nEq;
164299 p->zName, nEq-1, (int)a[1]));
164309 ** an IN constraint where the right-hand side of the IN operator
164316 ** non-zero.
164329 Index *p = pBuilder->pNew->u.btree.pIndex;
164330 i64 nRow0 = sqlite3LogEstToInt(p->aiRowLogEst[0]);
164331 int nRecValid = pBuilder->nRecValid;
164337 assert( p->aSample!=0 );
164338 for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
164340 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
164342 pBuilder->nRecValid = nRecValid;
164350 assert( pBuilder->nRecValid==nRecValid );
164362 sqlite3DebugPrintf("TERM-%-3d NULL\n", iTerm);
164367 if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
164368 if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E';
164369 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
164370 if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C';
164371 if( pTerm->eOperator & WO_SINGLE ){
164372 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
164374 pTerm->leftCursor, pTerm->u.x.leftColumn);
164375 }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){
164377 pTerm->u.pOrInfo->indexable);
164379 sqlite3_snprintf(sizeof(zLeft),zLeft,"left=%d", pTerm->leftCursor);
164382 "TERM-%-3d %p %s %-12s op=%03x wtFlags=%04x",
164383 iTerm, pTerm, zType, zLeft, pTerm->eOperator, pTerm->wtFlags);
164387 sqlite3DebugPrintf(" prob=%-3d prereq=%llx,%llx",
164388 pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight);
164390 if( (pTerm->eOperator & (WO_OR|WO_AND))==0 && pTerm->u.x.iField ){
164391 sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField);
164393 if( pTerm->iParent>=0 ){
164394 sqlite3DebugPrintf(" iParent=%d", pTerm->iParent);
164397 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
164408 for(i=0; i<pWC->nTerm; i++){
164409 sqlite3WhereTermPrint(&pWC->a[i], i);
164420 ** .--- Position in WHERE clause rSetup, rRun, nOut ---.
164422 ** | .--- selfMask nTerm ------. |
164424 ** | | .-- prereq Idx wsFlags----. | |
164426 ** | | | __|__ nEq ---. ___|__ | __|__
164432 WhereInfo *pWInfo = pWC->pWInfo;
164433 int nb = 1+(pWInfo->pTabList->nSrc+3)/4;
164434 SrcItem *pItem = pWInfo->pTabList->a + p->iTab;
164435 Table *pTab = pItem->pTab;
164436 Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1;
164437 sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId,
164438 p->iTab, nb, p->maskSelf, nb, p->prereq & mAll);
164440 pItem->zAlias ? pItem->zAlias : pTab->zName);
164443 p->cId, p->iTab, p->maskSelf, p->prereq & 0xfff, p->cId, p->iTab);
164445 if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
164447 if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
164449 int i = sqlite3Strlen30(zName) - 1;
164450 while( zName[i]!='_' ) i--;
164453 sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq);
164459 if( p->u.vtab.idxStr ){
164461 p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask);
164463 z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask);
164465 sqlite3DebugPrintf(" %-19s", z);
164468 if( p->wsFlags & WHERE_SKIPSCAN ){
164469 sqlite3DebugPrintf(" f %06x %d-%d", p->wsFlags, p->nLTerm,p->nSkip);
164471 sqlite3DebugPrintf(" f %06x N %d", p->wsFlags, p->nLTerm);
164473 sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut);
164474 if( p->nLTerm && (sqlite3WhereTrace & 0x4000)!=0 ){
164476 for(i=0; i<p->nLTerm; i++){
164477 sqlite3WhereTermPrint(p->aLTerm[i], i);
164487 p = p->pNextLoop;
164497 p->aLTerm = p->aLTermSpace;
164498 p->nLTerm = 0;
164499 p->nLSlot = ArraySize(p->aLTermSpace);
164500 p->wsFlags = 0;
164507 if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){
164508 if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
164509 sqlite3_free(p->u.vtab.idxStr);
164510 p->u.vtab.needFree = 0;
164511 p->u.vtab.idxStr = 0;
164512 }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
164513 sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
164514 sqlite3DbFreeNN(db, p->u.btree.pIndex);
164515 p->u.btree.pIndex = 0;
164525 if( p->aLTerm!=p->aLTermSpace ){
164526 sqlite3DbFreeNN(db, p->aLTerm);
164527 p->aLTerm = p->aLTermSpace;
164528 p->nLSlot = ArraySize(p->aLTermSpace);
164531 p->nLTerm = 0;
164532 p->wsFlags = 0;
164536 ** Increase the memory allocation for pLoop->aLTerm[] to be at least n.
164540 if( p->nLSlot>=n ) return SQLITE_OK;
164542 paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n);
164544 memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
164545 if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm);
164546 p->aLTerm = paNew;
164547 p->nLSlot = n;
164556 if( pFrom->nLTerm > pTo->nLSlot
164557 && whereLoopResize(db, pTo, pFrom->nLTerm)
164563 memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
164564 if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
164565 pFrom->u.vtab.needFree = 0;
164566 }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){
164567 pFrom->u.btree.pIndex = 0;
164587 sqlite3WhereClauseClear(&pWInfo->sWC);
164588 while( pWInfo->pLoops ){
164589 WhereLoop *p = pWInfo->pLoops;
164590 pWInfo->pLoops = p->pNextLoop;
164593 while( pWInfo->pMemToFree ){
164594 WhereMemBlock *pNext = pWInfo->pMemToFree->pNext;
164595 sqlite3DbNNFreeNN(db, pWInfo->pMemToFree);
164596 pWInfo->pMemToFree = pNext;
164614 ** (1c) Neither X nor Y use skip-scan
164631 if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0; /* (1d) and (2a) */
164632 assert( (pX->wsFlags & WHERE_VIRTUALTABLE)==0 );
164633 assert( (pY->wsFlags & WHERE_VIRTUALTABLE)==0 );
164634 if( pX->u.btree.nEq < pY->u.btree.nEq /* (1b) */
164635 && pX->u.btree.pIndex==pY->u.btree.pIndex /* (1a) */
164636 && pX->nSkip==0 && pY->nSkip==0 /* (1c) */
164640 if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
164643 if( pY->nSkip > pX->nSkip ) return 0; /* (2d) */
164644 for(i=pX->nLTerm-1; i>=0; i--){
164645 if( pX->aLTerm[i]==0 ) continue;
164646 for(j=pY->nLTerm-1; j>=0; j--){
164647 if( pY->aLTerm[j]==pX->aLTerm[i] ) break;
164651 if( (pX->wsFlags&WHERE_IDX_ONLY)!=0
164652 && (pY->wsFlags&WHERE_IDX_ONLY)==0 ){
164673 if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return;
164674 for(; p; p=p->pNextLoop){
164675 if( p->iTab!=pTemplate->iTab ) continue;
164676 if( (p->wsFlags & WHERE_INDEXED)==0 ) continue;
164681 pTemplate->rRun, pTemplate->nOut,
164682 MIN(p->rRun, pTemplate->rRun),
164683 MIN(p->nOut - 1, pTemplate->nOut)));
164684 pTemplate->rRun = MIN(p->rRun, pTemplate->rRun);
164685 pTemplate->nOut = MIN(p->nOut - 1, pTemplate->nOut);
164690 pTemplate->rRun, pTemplate->nOut,
164691 MAX(p->rRun, pTemplate->rRun),
164692 MAX(p->nOut + 1, pTemplate->nOut)));
164693 pTemplate->rRun = MAX(p->rRun, pTemplate->rRun);
164694 pTemplate->nOut = MAX(p->nOut + 1, pTemplate->nOut);
164718 for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){
164719 if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){
164728 assert( p->rSetup==0 || pTemplate->rSetup==0
164729 || p->rSetup==pTemplate->rSetup );
164733 ** rSetup. Call this SETUP-INVARIANT */
164734 assert( p->rSetup>=pTemplate->rSetup );
164736 /* Any loop using an application-defined index (or PRIMARY KEY or
164738 ** than an automatic index. Unless it is a skip-scan. */
164739 if( (p->wsFlags & WHERE_AUTO_INDEX)!=0
164740 && (pTemplate->nSkip)==0
164741 && (pTemplate->wsFlags & WHERE_INDEXED)!=0
164742 && (pTemplate->wsFlags & WHERE_COLUMN_EQ)!=0
164743 && (p->prereq & pTemplate->prereq)==pTemplate->prereq
164753 if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */
164754 && p->rSetup<=pTemplate->rSetup /* (2a) */
164755 && p->rRun<=pTemplate->rRun /* (2b) */
164756 && p->nOut<=pTemplate->nOut /* (2c) */
164766 if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */
164767 && p->rRun>=pTemplate->rRun /* (2a) */
164768 && p->nOut>=pTemplate->nOut /* (2b) */
164770 assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */
164786 ** If pBuilder->pOrSet is not NULL then we care about only the
164788 ** information is gathered in the pBuilder->pOrSet object. This special
164791 ** When accumulating multiple loops (when pBuilder->pOrSet is NULL) we
164803 WhereInfo *pWInfo = pBuilder->pWInfo;
164804 sqlite3 *db = pWInfo->pParse->db;
164808 if( pBuilder->iPlanLimit==0 ){
164810 if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0;
164813 pBuilder->iPlanLimit--;
164815 whereLoopAdjustCost(pWInfo->pLoops, pTemplate);
164817 /* If pBuilder->pOrSet is defined, then only keep track of the costs
164820 if( pBuilder->pOrSet!=0 ){
164821 if( pTemplate->nLTerm ){
164823 u16 n = pBuilder->pOrSet->n;
164826 whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun,
164827 pTemplate->nOut);
164830 sqlite3DebugPrintf(x?" or-%d: ":" or-X: ", n);
164831 sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
164840 ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate);
164848 sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
164864 sqlite3WhereLoopPrint(p, pBuilder->pWC);
164869 sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC);
164877 p->pNextLoop = 0;
164882 WhereLoop **ppTail = &p->pNextLoop;
164889 *ppTail = pToDel->pNextLoop;
164893 sqlite3WhereLoopPrint(pToDel, pBuilder->pWC);
164900 if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
164901 Index *pIndex = p->u.btree.pIndex;
164902 if( pIndex && pIndex->idxType==SQLITE_IDXTYPE_IPK ){
164903 p->u.btree.pIndex = 0;
164922 ** TODO --> Perhaps this is something that could be improved by better
164926 ** value corresponds to -1 in LogEst notation, so this means decrement
164933 ** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the
164934 ** "x" column is boolean or else -1 or 0 or 1 is a common default value
164944 Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf);
164946 LogEst iReduce = 0; /* pLoop->nOut should not exceed nRow-iReduce */
164948 assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 );
164949 for(i=pWC->nBase, pTerm=pWC->a; i>0; i--, pTerm++){
164951 if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
164952 if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue;
164953 if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) continue;
164954 for(j=pLoop->nLTerm-1; j>=0; j--){
164955 pX = pLoop->aLTerm[j];
164958 if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
164961 sqlite3ProgressCheck(pWC->pWInfo->pParse);
164962 if( pLoop->maskSelf==pTerm->prereqAll ){
164966 ** "self-culling".
164968 ** 2022-03-24: Self-culling only applies if either the extra terms
164969 ** are straight comparison operators that are non-true with NULL
164972 if( (pTerm->eOperator & 0x3f)!=0
164973 || (pWC->pWInfo->pTabList->a[pLoop->iTab].fg.jointype
164976 pLoop->wsFlags |= WHERE_SELFCULL;
164979 if( pTerm->truthProb<=0 ){
164982 pLoop->nOut += pTerm->truthProb;
164986 pLoop->nOut--;
164987 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0
164988 && (pTerm->wtFlags & TERM_HIGHTRUTH)==0 /* tag-20200224-1 */
164990 Expr *pRight = pTerm->pExpr->pRight;
164992 testcase( pTerm->pExpr->op==TK_IS );
164993 if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){
164999 pTerm->wtFlags |= TERM_HEURTRUTH;
165006 if( pLoop->nOut > nRow-iReduce ){
165007 pLoop->nOut = nRow - iReduce;
165035 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
165038 nCmp = MIN(nCmp, (pIdx->nColumn - nEq));
165047 assert( ExprUseXList(pTerm->pExpr->pLeft) );
165048 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
165049 pRhs = pTerm->pExpr->pRight;
165051 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
165053 pRhs = pRhs->x.pList->a[i].pExpr;
165060 if( pLhs->op!=TK_COLUMN
165061 || pLhs->iTable!=iCur
165062 || pLhs->iColumn!=pIdx->aiColumn[i+nEq]
165063 || pIdx->aSortOrder[i+nEq]!=pIdx->aSortOrder[nEq]
165068 testcase( pLhs->iColumn==XN_ROWID );
165070 idxaff = sqlite3TableColumnAffinity(pIdx->pTable, pLhs->iColumn);
165075 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
165082 ** compiled with -DSQLITE_ENABLE_COSTMULT
165091 ** We have so far matched pBuilder->pNew->u.btree.nEq terms of the
165094 ** When this function is called, pBuilder->pNew->nOut contains the
165099 ** If pProbe->idxType==SQLITE_IDXTYPE_IPK, that means pIndex is
165108 WhereInfo *pWInfo = pBuilder->pWInfo; /* WHERE analyze context */
165109 Parse *pParse = pWInfo->pParse; /* Parsing context */
165110 sqlite3 *db = pParse->db; /* Database connection malloc context */
165115 Bitmask saved_prereq; /* Original value of pNew->prereq */
165116 u16 saved_nLTerm; /* Original value of pNew->nLTerm */
165117 u16 saved_nEq; /* Original value of pNew->u.btree.nEq */
165118 u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */
165119 u16 saved_nTop; /* Original value of pNew->u.btree.nTop */
165120 u16 saved_nSkip; /* Original value of pNew->nSkip */
165121 u32 saved_wsFlags; /* Original value of pNew->wsFlags */
165122 LogEst saved_nOut; /* Original value of pNew->nOut */
165128 pNew = pBuilder->pNew;
165129 assert( db->mallocFailed==0 || pParse->nErr>0 );
165130 if( pParse->nErr ){
165131 return pParse->rc;
165134 pProbe->pTable->zName,pProbe->zName,
165135 pNew->u.btree.nEq, pNew->nSkip, pNew->rRun));
165137 assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 );
165138 assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 );
165139 if( pNew->wsFlags & WHERE_BTM_LIMIT ){
165142 assert( pNew->u.btree.nBtm==0 );
165145 if( pProbe->bUnordered || pProbe->bLowQual ){
165146 if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
165147 if( pProbe->bLowQual && pSrc->fg.isIndexedBy==0 ){
165152 assert( pNew->u.btree.nEq<pProbe->nColumn );
165153 assert( pNew->u.btree.nEq<pProbe->nKeyCol
165154 || pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY );
165156 saved_nEq = pNew->u.btree.nEq;
165157 saved_nBtm = pNew->u.btree.nBtm;
165158 saved_nTop = pNew->u.btree.nTop;
165159 saved_nSkip = pNew->nSkip;
165160 saved_nLTerm = pNew->nLTerm;
165161 saved_wsFlags = pNew->wsFlags;
165162 saved_prereq = pNew->prereq;
165163 saved_nOut = pNew->nOut;
165164 pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq,
165166 pNew->rSetup = 0;
165167 rSize = pProbe->aiRowLogEst[0];
165170 u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */
165175 int nRecValid = pBuilder->nRecValid;
165177 if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0)
165182 if( pTerm->prereqRight & pNew->maskSelf ) continue;
165186 if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
165188 if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0
165193 if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){
165194 pBuilder->bldFlags1 |= SQLITE_BLDF1_UNIQUE;
165196 pBuilder->bldFlags1 |= SQLITE_BLDF1_INDEXED;
165198 pNew->wsFlags = saved_wsFlags;
165199 pNew->u.btree.nEq = saved_nEq;
165200 pNew->u.btree.nBtm = saved_nBtm;
165201 pNew->u.btree.nTop = saved_nTop;
165202 pNew->nLTerm = saved_nLTerm;
165203 if( pNew->nLTerm>=pNew->nLSlot
165204 && whereLoopResize(db, pNew, pNew->nLTerm+1)
165206 break; /* OOM while trying to enlarge the pNew->aLTerm array */
165208 pNew->aLTerm[pNew->nLTerm++] = pTerm;
165209 pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
165212 || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0
165213 || (pNew->wsFlags & WHERE_COLUMN_IN)!=0
165214 || (pNew->wsFlags & WHERE_SKIPSCAN)!=0
165218 Expr *pExpr = pTerm->pExpr;
165229 for(i=0; i<pNew->nLTerm-1; i++){
165230 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
165232 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
165234 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
165236 if( pProbe->hasStat1 && rLogSize>=10 ){
165243 ** the left-most index column, M==N.
165253 ** with the index, as using an index has better worst-case behavior.
165258 M = pProbe->aiRowLogEst[saved_nEq];
165260 /* TUNING v----- 10 to bias toward indexed IN */
165261 x = M + logK + 10 - (nIn + rLogSize);
165270 " nInMul=%d) prefers skip-scan\n",
165272 pNew->wsFlags |= WHERE_IN_SEEKSCAN;
165281 pNew->wsFlags |= WHERE_COLUMN_IN;
165283 int iCol = pProbe->aiColumn[saved_nEq];
165284 pNew->wsFlags |= WHERE_COLUMN_EQ;
165285 assert( saved_nEq==pNew->u.btree.nEq );
165287 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
165289 if( iCol==XN_ROWID || pProbe->uniqNotNull
165290 || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ)
165292 pNew->wsFlags |= WHERE_ONEROW;
165294 pNew->wsFlags |= WHERE_UNQ_WANTED;
165297 if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS;
165299 pNew->wsFlags |= WHERE_COLUMN_NULL;
165302 pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
165307 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
165308 pNew->u.btree.nBtm = nVecLen;
165311 if( pTerm->wtFlags & TERM_LIKEOPT ){
165315 assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
165316 assert( pTop->wtFlags & TERM_LIKEOPT );
165317 assert( pTop->eOperator==WO_LT );
165318 if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
165319 pNew->aLTerm[pNew->nLTerm++] = pTop;
165320 pNew->wsFlags |= WHERE_TOP_LIMIT;
165321 pNew->u.btree.nTop = 1;
165327 pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT;
165328 pNew->u.btree.nTop = nVecLen;
165330 pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ?
165331 pNew->aLTerm[pNew->nLTerm-2] : 0;
165335 /* At this point pNew->nOut is set to the number of rows expected to
165339 ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */
165340 assert( pNew->nOut==saved_nOut );
165341 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
165346 int nEq = ++pNew->u.btree.nEq;
165349 assert( pNew->nOut==saved_nOut );
165350 if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){
165353 pNew->nOut += pTerm->truthProb;
165354 pNew->nOut -= nIn;
165359 && pProbe->nSample
165360 && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
165361 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
165364 Expr *pExpr = pTerm->pExpr;
165369 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
165371 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
165376 pNew->nOut = sqlite3LogEst(nOut);
165380 ** See tag-202002240-1 */
165381 && pNew->nOut+10 > pProbe->aiRowLogEst[0]
165390 pTerm->wtFlags |= TERM_HIGHTRUTH;
165391 if( pTerm->wtFlags & TERM_HEURTRUTH ){
165395 pBuilder->bldFlags2 |= SQLITE_BLDF2_2NDPASS;
165398 if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut;
165399 pNew->nOut -= nIn;
165405 pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]);
165410 pNew->nOut += 10;
165418 ** 1. The cost of doing one search-by-key to find the first matching
165420 ** 2. Stepping forward in the index pNew->nOut times to find all
165423 assert( pSrc->pTab->szTabRow>0 );
165424 if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
165425 /* The pProbe->szIdxRow is low for an IPK table since the interior
165427 ** But the leaf pages are full-size, so pProbe->szIdxRow would badly
165428 ** under-estimate the scanning cost. */
165429 rCostIdx = pNew->nOut + 16;
165431 rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
165438 ** we also have to add in the cost of doing pNew->nOut searches to
165441 pNew->rRun = rCostIdx;
165442 if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){
165443 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
165445 ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult);
165447 nOutUnadjusted = pNew->nOut;
165448 pNew->rRun += nInMul + nIn;
165449 pNew->nOut += nInMul + nIn;
165450 whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize);
165453 if( pNew->wsFlags & WHERE_COLUMN_RANGE ){
165454 pNew->nOut = saved_nOut;
165456 pNew->nOut = nOutUnadjusted;
165459 if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
165460 && pNew->u.btree.nEq<pProbe->nColumn
165461 && (pNew->u.btree.nEq<pProbe->nKeyCol ||
165462 pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY)
165464 if( pNew->u.btree.nEq>3 ){
165469 pNew->nOut = saved_nOut;
165471 pBuilder->nRecValid = nRecValid;
165474 pNew->prereq = saved_prereq;
165475 pNew->u.btree.nEq = saved_nEq;
165476 pNew->u.btree.nBtm = saved_nBtm;
165477 pNew->u.btree.nTop = saved_nTop;
165478 pNew->nSkip = saved_nSkip;
165479 pNew->wsFlags = saved_wsFlags;
165480 pNew->nOut = saved_nOut;
165481 pNew->nLTerm = saved_nLTerm;
165483 /* Consider using a skip-scan if there are no WHERE clause constraints
165484 ** available for the left-most terms of the index, and if the average
165485 ** number of repeats in the left-most terms is at least 18.
165495 && saved_nEq+1<pProbe->nKeyCol
165496 && saved_nEq==pNew->nLTerm
165497 && pProbe->noSkipScan==0
165498 && pProbe->hasStat1!=0
165500 && pProbe->aiRowLogEst[saved_nEq+1]>=42 /* TUNING: Minimum for skip-scan */
165501 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
165504 pNew->u.btree.nEq++;
165505 pNew->nSkip++;
165506 pNew->aLTerm[pNew->nLTerm++] = 0;
165507 pNew->wsFlags |= WHERE_SKIPSCAN;
165508 nIter = pProbe->aiRowLogEst[saved_nEq] - pProbe->aiRowLogEst[saved_nEq+1];
165509 pNew->nOut -= nIter;
165510 /* TUNING: Because uncertainties in the estimates for skip-scan queries,
165511 ** add a 1.375 fudge factor to make skip-scan slightly less likely. */
165514 pNew->nOut = saved_nOut;
165515 pNew->u.btree.nEq = saved_nEq;
165516 pNew->nSkip = saved_nSkip;
165517 pNew->wsFlags = saved_wsFlags;
165521 pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
165542 if( pIndex->bUnordered ) return 0;
165543 if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0;
165544 for(ii=0; ii<pOB->nExpr; ii++){
165545 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
165547 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
165548 && pExpr->iTable==iCursor
165550 if( pExpr->iColumn<0 ) return 1;
165551 for(jj=0; jj<pIndex->nKeyCol; jj++){
165552 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
165554 }else if( (aColExpr = pIndex->aColExpr)!=0 ){
165555 for(jj=0; jj<pIndex->nKeyCol; jj++){
165556 if( pIndex->aiColumn[jj]!=XN_EXPR ) continue;
165557 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
165580 pParse = pWC->pWInfo->pParse;
165581 while( pWhere->op==TK_AND ){
165582 if( !whereUsablePartialIndex(iTab,jointype,pWC,pWhere->pLeft) ) return 0;
165583 pWhere = pWhere->pRight;
165585 if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
165586 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
165588 pExpr = pTerm->pExpr;
165589 if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab)
165592 && (pTerm->wtFlags & TERM_VNULL)==0
165610 for(i=0; i<pIdx->nColumn; i++){
165611 if( pIdx->aiColumn[i]==XN_EXPR
165612 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
165632 ** Information passed in is pWalk->u.pCovIdxCk. Call it pCk.
165634 ** If the Expr node references the table with cursor pCk->iTabCur, then
165635 ** make sure that column is covered by the index pCk->pIdx. We know that
165636 ** all columns less than 63 (really BMS-1) are covered, so we don't need
165639 ** If the index does not cover the column, then set pWalk->eCode to
165640 ** non-zero and return WRC_Abort to stop the search.
165645 ** If pCk->pIdx contains indexed expressions and one of those expressions
165655 pCk = pWalk->u.pCovIdxCk;
165656 pIdx = pCk->pIdx;
165657 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){
165658 /* if( pExpr->iColumn<(BMS-1) && pIdx->bHasExpr==0 ) return WRC_Continue;*/
165659 if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;
165660 pIdx = pWalk->u.pCovIdxCk->pIdx;
165661 aiColumn = pIdx->aiColumn;
165662 nColumn = pIdx->nColumn;
165664 if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;
165666 pCk->bUnidx = 1;
165668 }else if( pIdx->bHasExpr
165669 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
165670 pCk->bExpr = 1;
165678 ** pIdx is an index that covers all of the low-number columns used by
165679 ** pWInfo->pSelect (columns from 0 through 62) or an index that has
165708 if( pWInfo->pSelect==0 ){
165713 if( pIdx->bHasExpr==0 ){
165714 for(i=0; i<pIdx->nColumn; i++){
165715 if( pIdx->aiColumn[i]>=BMS-1 ) break;
165717 if( i>=pIdx->nColumn ){
165732 sqlite3WalkSelect(&w, pWInfo->pSelect);
165745 ** free the Parse->pIdxEpr list when the Parse object is destroyed.
165751 *pp = p->pIENext;
165752 sqlite3ExprDelete(db, p->pExpr);
165758 ** This function is called for a partial index - one with a WHERE clause - in
165767 ** The "a" in the select-list may be replaced by <expr>, iff:
165792 assert( pItem==0 || (pItem->fg.jointype & JT_RIGHT)==0 );
165795 if( pPart->op==TK_AND ){
165796 wherePartIdxExpr(pParse, pIdx, pPart->pRight, pMask, iIdxCur, pItem);
165797 pPart = pPart->pLeft;
165800 if( (pPart->op==TK_EQ || pPart->op==TK_IS) ){
165801 Expr *pLeft = pPart->pLeft;
165802 Expr *pRight = pPart->pRight;
165805 if( pLeft->op!=TK_COLUMN ) return;
165808 if( pLeft->iColumn<0 ) return;
165809 aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
165812 sqlite3 *db = pParse->db;
165815 int bNullRow = (pItem->fg.jointype&(JT_LEFT|JT_LTORJ))!=0;
165816 p->pExpr = sqlite3ExprDup(db, pRight, 0);
165817 p->iDataCur = pItem->iCursor;
165818 p->iIdxCur = iIdxCur;
165819 p->iIdxCol = pLeft->iColumn;
165820 p->bMaybeNullRow = bNullRow;
165821 p->pIENext = pParse->pIdxPartExpr;
165822 p->aff = aff;
165823 pParse->pIdxPartExpr = p;
165824 if( p->pIENext==0 ){
165825 void *pArg = (void*)&pParse->pIdxPartExpr;
165829 }else if( pLeft->iColumn<(BMS-1) ){
165830 *pMask &= ~((Bitmask)1 << pLeft->iColumn);
165839 ** is identified by pBuilder->pNew->iTab. That table is guaranteed to be
165840 ** a b-tree table, not a virtual table.
165842 ** The costs (WhereLoop.rRun) of the b-tree loops added by this function
165847 ** cost = nRow * 3.0 // full-table scan
165849 ** cost = nRow * (K+3.0) // scan of non-covering index
165856 ** the index b-tree:
165859 ** cost = nSeek * (log(nRow) + (K+3.0) * nVisit) // non-covering index
165863 ** implicit "x IN (SELECT x FROM tbl)" terms are added for skip-scans.
165868 ** log(nRow) factor is omitted from a non-covering index scan in order to
165869 ** bias the scoring in favor of using an index, since the worst-case
165870 ** performance of using an index is far better than the worst-case performance
165881 i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */
165892 pNew = pBuilder->pNew;
165893 pWInfo = pBuilder->pWInfo;
165894 pTabList = pWInfo->pTabList;
165895 pSrc = pTabList->a + pNew->iTab;
165896 pTab = pSrc->pTab;
165897 pWC = pBuilder->pWC;
165898 assert( !IsVirtual(pSrc->pTab) );
165900 if( pSrc->fg.isIndexedBy ){
165901 assert( pSrc->fg.isCte==0 );
165903 pProbe = pSrc->u2.pIBIndex;
165905 pProbe = pTab->pIndex;
165921 aiRowEstPk[0] = pTab->nRowLogEst;
165923 pFirst = pSrc->pTab->pIndex;
165924 if( pSrc->fg.notIndexed==0 ){
165931 rSize = pTab->nRowLogEst;
165935 if( !pBuilder->pOrSet /* Not part of an OR optimization */
165936 && (pWInfo->wctrlFlags & (WHERE_RIGHT_JOIN|WHERE_OR_SUBCLAUSE))==0
165937 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
165938 && !pSrc->fg.isIndexedBy /* Has no INDEXED BY clause */
165939 && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */
165941 && !pSrc->fg.isCorrelated /* Not a correlated subquery */
165942 && !pSrc->fg.isRecursive /* Not a recursive common table expression. */
165943 && (pSrc->fg.jointype & JT_RIGHT)==0 /* Not the right tab of a RIGHT JOIN */
165945 /* Generate auto-index WhereLoops */
165948 WhereTerm *pWCEnd = pWC->a + pWC->nTerm;
165950 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
165951 if( pTerm->prereqRight & pNew->maskSelf ) continue;
165953 pNew->u.btree.nEq = 1;
165954 pNew->nSkip = 0;
165955 pNew->u.btree.pIndex = 0;
165956 pNew->nLTerm = 1;
165957 pNew->aLTerm[0] = pTerm;
165958 /* TUNING: One-time cost for computing the automatic index is
165961 ** tables or 0.5 (LogEst=-10) for views and subqueries. The value
165966 pNew->rSetup = rLogSize + rSize;
165967 if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
165968 pNew->rSetup += 28;
165970 pNew->rSetup -= 25; /* Greatly reduced setup cost for auto indexes
165973 ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
165974 if( pNew->rSetup<0 ) pNew->rSetup = 0;
165979 pNew->nOut = 43; assert( 43==sqlite3LogEst(20) );
165980 pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut);
165981 pNew->wsFlags = WHERE_AUTO_INDEX;
165982 pNew->prereq = mPrereq | pTerm->prereqRight;
165992 pProbe=(pSrc->fg.isIndexedBy ? 0 : pProbe->pNext), iSortIdx++
165994 if( pProbe->pPartIdxWhere!=0
165995 && !whereUsablePartialIndex(pSrc->iCursor, pSrc->fg.jointype, pWC,
165996 pProbe->pPartIdxWhere)
165998 testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */
166001 if( pProbe->bNoQuery ) continue;
166002 rSize = pProbe->aiRowLogEst[0];
166003 pNew->u.btree.nEq = 0;
166004 pNew->u.btree.nBtm = 0;
166005 pNew->u.btree.nTop = 0;
166006 pNew->nSkip = 0;
166007 pNew->nLTerm = 0;
166008 pNew->iSortIdx = 0;
166009 pNew->rSetup = 0;
166010 pNew->prereq = mPrereq;
166011 pNew->nOut = rSize;
166012 pNew->u.btree.pIndex = pProbe;
166013 b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor);
166016 assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 );
166017 if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
166019 pNew->wsFlags = WHERE_IPK;
166022 pNew->iSortIdx = b ? iSortIdx : 0;
166025 ** since index lookups have better worst-case performance if our
166036 pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0);
166038 pNew->rRun = rSize + 16;
166040 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166043 pNew->nOut = rSize;
166047 if( pProbe->isCovering ){
166049 pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
166051 m = pSrc->colUsed & pProbe->colNotIdxed;
166052 if( pProbe->pPartIdxWhere ){
166054 pWInfo->pParse, pProbe, pProbe->pPartIdxWhere, &m, 0, 0
166057 pNew->wsFlags = WHERE_INDEXED;
166058 if( m==TOPBIT || (pProbe->bHasExpr && !pProbe->bHasVCol && m!=0) ){
166059 u32 isCov = whereIsCoveringIndex(pWInfo, pProbe, pSrc->iCursor);
166062 ("-> %s is not a covering index"
166063 " according to whereIsCoveringIndex()\n", pProbe->zName));
166067 pNew->wsFlags |= isCov;
166070 ("-> %s is a covering expression index"
166071 " according to whereIsCoveringIndex()\n", pProbe->zName));
166075 ("-> %s might be a covering expression index"
166076 " according to whereIsCoveringIndex()\n", pProbe->zName));
166080 && (HasRowid(pTab) || pWInfo->pSelect!=0 || sqlite3FaultSim(700))
166083 ("-> %s a covering index according to bitmasks\n",
166084 pProbe->zName, m==0 ? "is" : "is not"));
166085 pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
166092 || pProbe->pPartIdxWhere!=0
166093 || pSrc->fg.isIndexedBy
166095 && pProbe->bUnordered==0
166096 && (pProbe->szIdxRow<pTab->szTabRow)
166097 && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0
166099 && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)
166102 pNew->iSortIdx = b ? iSortIdx : 0;
166107 pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow;
166109 /* If this is a non-covering index scan, add in the cost of
166114 LogEst nLookup = rSize + 16; /* Base cost: N*3 */
166116 int iCur = pSrc->iCursor;
166117 WhereClause *pWC2 = &pWInfo->sWC;
166118 for(ii=0; ii<pWC2->nTerm; ii++){
166119 WhereTerm *pTerm = &pWC2->a[ii];
166120 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
166125 if( pTerm->truthProb<=0 ){
166126 nLookup += pTerm->truthProb;
166128 nLookup--;
166129 if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19;
166133 pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup);
166135 ApplyCostMultiplier(pNew->rRun, pTab->costMult);
166137 if( (pSrc->fg.jointype & JT_RIGHT)!=0 && pProbe->aColExpr ){
166138 /* Do not do an SCAN of a index-on-expression in a RIGHT JOIN
166140 ** positioned to the correct row during the right-join no-match
166145 pNew->nOut = rSize;
166150 pBuilder->bldFlags1 = 0;
166152 if( pBuilder->bldFlags1==SQLITE_BLDF1_INDEXED ){
166153 /* If a non-unique index is used, or if a prefix of the key for
166154 ** unique index is used (making the index functionally non-unique)
166157 pTab->tabFlags |= TF_MaybeReanalyze;
166160 sqlite3Stat4ProbeFree(pBuilder->pRec);
166161 pBuilder->nRecValid = 0;
166162 pBuilder->pRec = 0;
166174 assert( pTerm->eOperator==WO_AUX || pTerm->eMatchOp==0 );
166175 return pTerm->eMatchOp>=SQLITE_INDEX_CONSTRAINT_LIMIT
166176 && pTerm->eMatchOp<=SQLITE_INDEX_CONSTRAINT_OFFSET;
166181 ** marked as in-use (have argvIndex>0). False otherwise.
166196 ** be used by the virtual table identified by pBuilder->pNew->iTab. This
166224 WhereClause *pWC = pBuilder->pWC;
166227 struct sqlite3_index_constraint_usage *pUsage = pIdxInfo->aConstraintUsage;
166231 WhereLoop *pNew = pBuilder->pNew;
166232 Parse *pParse = pBuilder->pWInfo->pParse;
166233 SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
166234 int nConstraint = pIdxInfo->nConstraint;
166238 pNew->prereq = mPrereq;
166242 pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
166244 WhereTerm *pTerm = &pWC->a[pIdxCons->iTermOffset];
166245 pIdxCons->usable = 0;
166246 if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight
166247 && (pTerm->eOperator & mExclude)==0
166250 pIdxCons->usable = 1;
166256 assert( pIdxInfo->needToFreeIdxStr==0 );
166257 pIdxInfo->idxStr = 0;
166258 pIdxInfo->idxNum = 0;
166259 pIdxInfo->orderByConsumed = 0;
166260 pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
166261 pIdxInfo->estimatedRows = 25;
166262 pIdxInfo->idxFlags = 0;
166263 pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
166264 pHidden->mHandleIn = 0;
166267 rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
166274 WHERETRACE(0xffffffff, (" ^^^^--- non-viable plan rejected!\n"));
166280 mxTerm = -1;
166281 assert( pNew->nLSlot>=nConstraint );
166282 memset(pNew->aLTerm, 0, sizeof(pNew->aLTerm[0])*nConstraint );
166283 memset(&pNew->u.vtab, 0, sizeof(pNew->u.vtab));
166284 pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
166287 if( (iTerm = pUsage[i].argvIndex - 1)>=0 ){
166289 int j = pIdxCons->iTermOffset;
166292 || j>=pWC->nTerm
166293 || pNew->aLTerm[iTerm]!=0
166294 || pIdxCons->usable==0
166296 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166297 testcase( pIdxInfo->needToFreeIdxStr );
166300 testcase( iTerm==nConstraint-1 );
166302 testcase( j==pWC->nTerm-1 );
166303 pTerm = &pWC->a[j];
166304 pNew->prereq |= pTerm->prereqRight;
166305 assert( iTerm<pNew->nLSlot );
166306 pNew->aLTerm[iTerm] = pTerm;
166313 pNew->u.vtab.omitMask |= 1<<iTerm;
166317 if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET ){
166318 pNew->u.vtab.bOmitOffset = 1;
166321 if( SMASKBIT32(i) & pHidden->mHandleIn ){
166322 pNew->u.vtab.mHandleIn |= MASKBIT32(iTerm);
166323 }else if( (pTerm->eOperator & WO_IN)!=0 ){
166329 pIdxInfo->orderByConsumed = 0;
166330 pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE;
166334 /* Unless pbRetryLimit is non-NULL, there should be no LIMIT/OFFSET
166337 assert( !isLimitTerm(pTerm) || i>=nConstraint-2 );
166338 assert( !isLimitTerm(pTerm) || i==nConstraint-1 || isLimitTerm(pTerm+1) );
166348 if( pIdxInfo->needToFreeIdxStr ){
166349 sqlite3_free(pIdxInfo->idxStr);
166350 pIdxInfo->idxStr = 0;
166351 pIdxInfo->needToFreeIdxStr = 0;
166359 pNew->nLTerm = mxTerm+1;
166361 if( pNew->aLTerm[i]==0 ){
166362 /* The non-zero argvIdx values must be contiguous. Raise an
166364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166365 testcase( pIdxInfo->needToFreeIdxStr );
166369 assert( pNew->nLTerm<=pNew->nLSlot );
166370 pNew->u.vtab.idxNum = pIdxInfo->idxNum;
166371 pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
166372 pIdxInfo->needToFreeIdxStr = 0;
166373 pNew->u.vtab.idxStr = pIdxInfo->idxStr;
166374 pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ?
166375 pIdxInfo->nOrderBy : 0);
166376 pNew->rSetup = 0;
166377 pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
166378 pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
166382 if( pIdxInfo->idxFlags & SQLITE_INDEX_SCAN_UNIQUE ){
166383 pNew->wsFlags |= WHERE_ONEROW;
166385 pNew->wsFlags &= ~WHERE_ONEROW;
166388 if( pNew->u.vtab.needFree ){
166389 sqlite3_free(pNew->u.vtab.idxStr);
166390 pNew->u.vtab.needFree = 0;
166394 (sqlite3_uint64)(pNew->prereq & ~mPrereq)));
166417 if( iCons>=0 && iCons<pIdxInfo->nConstraint ){
166419 int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
166420 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
166421 if( pX->pLeft ){
166422 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
166424 zRet = (pC ? pC->zName : sqlite3StrBINARY);
166437 if( m & pHidden->mIn ){
166439 pHidden->mHandleIn &= ~m;
166441 pHidden->mHandleIn |= m;
166452 ** on the right-hand-side of constraint iCons.
166462 if( iCons<0 || iCons>=pIdxInfo->nConstraint ){
166463 rc = SQLITE_MISUSE_BKPT; /* EV: R-30545-25046 */
166465 if( pH->aRhs[iCons]==0 ){
166466 WhereTerm *pTerm = &pH->pWC->a[pIdxInfo->aConstraint[iCons].iTermOffset];
166468 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
166469 SQLITE_AFF_BLOB, &pH->aRhs[iCons]
166473 pVal = pH->aRhs[iCons];
166477 if( rc==SQLITE_OK && pVal==0 ){ /* IMP: R-19933-32160 */
166478 rc = SQLITE_NOTFOUND; /* IMP: R-36424-56542 */
166489 assert( pHidden->eDistinct>=0 && pHidden->eDistinct<=3 );
166490 return pHidden->eDistinct;
166496 ** prepared is read-only, then just start read transactions on all
166500 ** This is used by the (built-in) sqlite_dbpage virtual table.
166503 int nDb = pParse->db->nDb;
166508 if( DbMaskNonZero(pParse->writeMask) ){
166517 ** pBuilder->pNew->iTab. That table is guaranteed to be a virtual table.
166538 ** mUnusable should always be configured as "not-usable" for xBestIndex.
166559 pWInfo = pBuilder->pWInfo;
166560 pParse = pWInfo->pParse;
166561 pWC = pBuilder->pWC;
166562 pNew = pBuilder->pNew;
166563 pSrc = &pWInfo->pTabList->a[pNew->iTab];
166564 assert( IsVirtual(pSrc->pTab) );
166567 pNew->rSetup = 0;
166568 pNew->wsFlags = WHERE_VIRTUALTABLE;
166569 pNew->nLTerm = 0;
166570 pNew->u.vtab.needFree = 0;
166571 nConstraint = p->nConstraint;
166572 if( whereLoopResize(pParse->db, pNew, nConstraint) ){
166573 freeIndexInfo(pParse->db, p);
166578 WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
166595 if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
166608 mBestNoIn = pNew->prereq & ~mPrereq;
166623 pWC->a[p->aConstraint[i].iTermOffset].prereqRight & ~mPrereq
166634 if( pNew->prereq==mPrereq ){
166660 if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr);
166661 freeIndexInfo(pParse->db, p);
166662 WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
166676 WhereInfo *pWInfo = pBuilder->pWInfo;
166687 pWC = pBuilder->pWC;
166688 pWCEnd = pWC->a + pWC->nTerm;
166689 pNew = pBuilder->pNew;
166691 pItem = pWInfo->pTabList->a + pNew->iTab;
166692 iCur = pItem->iCursor;
166694 /* The multi-index OR optimization does not work for RIGHT and FULL JOIN */
166695 if( pItem->fg.jointype & JT_RIGHT ) return SQLITE_OK;
166697 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
166698 if( (pTerm->eOperator & WO_OR)!=0
166699 && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
166701 WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
166702 WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm];
166710 WHERETRACE(0x400, ("Begin processing OR-clause %p\n", pTerm));
166711 for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){
166712 if( (pOrTerm->eOperator & WO_AND)!=0 ){
166713 sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc;
166714 }else if( pOrTerm->leftCursor==iCur ){
166715 tempWC.pWInfo = pWC->pWInfo;
166727 WHERETRACE(0x400, ("OR-term %d of %p has %d subterms:\n",
166728 (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm));
166734 if( IsVirtual(pItem->pTab) ){
166765 pNew->nLTerm = 1;
166766 pNew->aLTerm[0] = pTerm;
166767 pNew->wsFlags = WHERE_MULTI_OR;
166768 pNew->rSetup = 0;
166769 pNew->iSortIdx = 0;
166770 memset(&pNew->u, 0, sizeof(pNew->u));
166773 ** of all sub-scans required by the OR-scan. However, due to rounding
166774 ** errors, it may be that the cost of the OR-scan is equal to its
166775 ** most expensive sub-scan. Add the smallest possible penalty
166782 ** the planner may elect to "OR" together a full-table scan and an
166784 pNew->rRun = sSum.a[i].rRun + 1;
166785 pNew->nOut = sSum.a[i].nOut;
166786 pNew->prereq = sSum.a[i].prereq;
166789 WHERETRACE(0x400, ("End processing OR-clause %p\n", pTerm));
166799 WhereInfo *pWInfo = pBuilder->pWInfo;
166803 SrcList *pTabList = pWInfo->pTabList;
166805 SrcItem *pEnd = &pTabList->a[pWInfo->nLevel];
166806 sqlite3 *db = pWInfo->pParse->db;
166814 pNew = pBuilder->pNew;
166817 assert( pNew->nLTerm==0 );
166818 assert( pNew->wsFlags==0 );
166819 assert( pNew->nLSlot>=ArraySize(pNew->aLTermSpace) );
166820 assert( pNew->aLTerm!=0 );
166822 pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT;
166823 for(iTab=0, pItem=pTabList->a; pItem<pEnd; iTab++, pItem++){
166825 pNew->iTab = iTab;
166826 pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR;
166827 pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
166829 || (pItem->fg.jointype & (JT_OUTER|JT_CROSS|JT_LTORJ))!=0
166837 ** prevent FROM-clause terms from moving from the right side of
166841 if( pItem->fg.jointype & JT_LTORJ ) hasRightJoin = 1;
166843 bFirstPastRJ = (pItem->fg.jointype & JT_RIGHT)!=0;
166848 if( IsVirtual(pItem->pTab) ){
166851 if( mUnusable || (p->fg.jointype & (JT_OUTER|JT_CROSS)) ){
166852 mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor);
166861 if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){
166864 mPrior |= pNew->maskSelf;
166865 if( rc || db->mallocFailed ){
166895 ** pOrderBy terms must be matched in strict left-to-right order.
166902 u16 nLoop, /* Number of entries in pPath->aLoop[] */
166903 WhereLoop *pLast, /* Add this WhereLoop to the end of pPath->aLoop[] */
166909 u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */
166925 sqlite3 *db = pWInfo->pParse->db; /* Database connection */
166928 Bitmask orderDistinctMask; /* Mask of all well-ordered loops */
166932 ** We say the WhereLoop is "one-row" if it generates no more than one
166933 ** row of output. A WhereLoop is one-row if all of the following are true:
166936 ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row.
166937 ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags.
166939 ** We say the WhereLoop is "order-distinct" if the set of columns from
166941 ** row of the WhereLoop. Every one-row WhereLoop is automatically
166942 ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause
166943 ** is not order-distinct. To be order-distinct is not quite the same as being
166945 ** are NULL and NULL values are equivalent for the purpose of order-distinct.
166946 ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
166950 ** automatically order-distinct.
166956 nOrderBy = pOrderBy->nExpr;
166957 testcase( nOrderBy==BMS-1 );
166958 if( nOrderBy>BMS-1 ) return 0; /* Cannot optimize overly large ORDER BYs */
166960 obDone = MASKBIT(nOrderBy)-1;
166968 if( iLoop>0 ) ready |= pLoop->maskSelf;
166970 pLoop = pPath->aLoop[iLoop];
166975 if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){
166976 if( pLoop->u.vtab.isOrdered
166983 pLoop->u.btree.nDistinctCol = 0;
166985 iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor;
166994 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
166996 if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue;
166997 if( pOBExpr->iTable!=iCur ) continue;
166998 pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
167001 if( pTerm->eOperator==WO_IN ){
167007 for(j=0; j<pLoop->nLTerm && pTerm!=pLoop->aLTerm[j]; j++){}
167008 if( j>=pLoop->nLTerm ) continue;
167010 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){
167011 Parse *pParse = pWInfo->pParse;
167012 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
167013 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
167015 if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){
167018 testcase( pTerm->pExpr->op==TK_IS );
167023 if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){
167024 if( pLoop->wsFlags & WHERE_IPK ){
167028 }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){
167031 nKeyCol = pIndex->nKeyCol;
167032 nColumn = pIndex->nColumn;
167033 assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
167034 assert( pIndex->aiColumn[nColumn-1]==XN_ROWID
167035 || !HasRowid(pIndex->pTable));
167036 /* All relevant terms of the index must also be non-NULL in order
167039 ** made at tag-20210426-1 below */
167041 && (pLoop->wsFlags & WHERE_SKIPSCAN)==0;
167052 assert( j>=pLoop->u.btree.nEq
167053 || (pLoop->aLTerm[j]==0)==(j<pLoop->nSkip)
167055 if( j<pLoop->u.btree.nEq && j>=pLoop->nSkip ){
167056 u16 eOp = pLoop->aLTerm[j]->eOperator;
167061 ** the loop need to be marked as not order-distinct because it can
167080 ** j<pLoop->u.btree.nEq constraint above. Any equality other
167083 Expr *pX = pLoop->aLTerm[j]->pExpr;
167084 for(i=j+1; i<pLoop->u.btree.nEq; i++){
167085 if( pLoop->aLTerm[i]->pExpr==pX ){
167086 assert( (pLoop->aLTerm[i]->eOperator & WO_IN) );
167095 ** (revIdx) for the j-th column of the index.
167098 iColumn = pIndex->aiColumn[j];
167099 revIdx = pIndex->aSortOrder[j] & KEYINFO_ORDER_DESC;
167100 if( iColumn==pIndex->pTable->iPKey ) iColumn = XN_ROWID;
167107 ** WhereLoop is not well-ordered. tag-20210426-1
167111 && j>=pLoop->u.btree.nEq
167112 && pIndex->pTable->aCol[iColumn].notNull==0
167121 /* Find the ORDER BY term that corresponds to the j-th column
167127 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
167133 if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue;
167134 if( pOBExpr->iTable!=iCur ) continue;
167135 if( pOBExpr->iColumn!=iColumn ) continue;
167137 Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;
167143 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
167144 if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue;
167147 pLoop->u.btree.nDistinctCol = j+1;
167157 != (pOrderBy->a[i].fg.sortFlags&KEYINFO_ORDER_DESC)
167162 rev = revIdx ^ (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC);
167167 if( isMatch && (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL) ){
167168 if( j==pLoop->u.btree.nEq ){
167169 pLoop->wsFlags |= WHERE_BIGNULL_SORT;
167193 } /* end-if not one-row */
167197 orderDistinctMask |= pLoop->maskSelf;
167202 p = pOrderBy->a[i].pExpr;
167203 mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
167210 } /* End the loop over all WhereLoops from outer-most down to inner-most */
167213 for(i=nOrderBy-1; i>0; i--){
167214 Bitmask m = ALWAYS(i<BMS) ? MASKBIT(i) - 1 : 0;
167219 return -1;
167226 ** BY clause - and so any order that groups rows as required satisfies the
167243 ** SELECT * FROM t1 GROUP BY x,y ORDER BY x,y; -- IsSorted()==1
167244 ** SELECT * FROM t1 GROUP BY y,x ORDER BY y,x; -- IsSorted()==0
167247 assert( pWInfo->wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY) );
167248 assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP );
167249 return pWInfo->sorted;
167257 for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; }
167258 if( pLast ) zName[i++] = pLast->cId;
167280 ** Or, if the order-by clause has X terms but only the last Y
167281 ** terms are out of order, then block-sorting will reduce the
167297 assert( pWInfo->pSelect!=0 );
167298 assert( pWInfo->pSelect->pEList!=0 );
167300 nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30);
167304 rSortCost += sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
167312 if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 ){
167317 if( pWInfo->iLimit<nRow ){
167318 nRow = pWInfo->iLimit;
167320 }else if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT) ){
167323 if( nRow>10 ){ nRow -= 10; assert( 10==sqlite3LogEst(2) ); }
167330 ** Given the list of WhereLoop objects at pWInfo->pLoops, this routine
167332 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
167362 pParse = pWInfo->pParse;
167363 nLoop = pWInfo->nLevel;
167365 ** For 2-way joins, the 5 best paths are followed.
167368 assert( nLoop<=pWInfo->pTabList->nSrc );
167369 WHERETRACE(0x002, ("---- begin solver. (nRowEst=%d, nQueryLoop=%d)\n",
167370 nRowEst, pParse->nQueryLoop));
167377 if( pWInfo->pOrderBy==0 || nRowEst==0 ){
167380 nOrderBy = pWInfo->pOrderBy->nExpr;
167386 pSpace = sqlite3StackAllocRawNN(pParse->db, nSpace);
167392 for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){
167393 pFrom->aLoop = pX;
167398 ** is either zero - meaning it has not yet been initialized - or the
167413 aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) );
167421 ** -1, indicating that the result set may or may not be ordered,
167423 aFrom[0].isOrdered = nLoop>0 ? -1 : nOrderBy;
167432 for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
167438 Bitmask revMask; /* Mask of rev-order loops for (..) */
167440 if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue;
167441 if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue;
167442 if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){
167453 rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
167454 rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted);
167455 nOut = pFrom->nRow + pWLoop->nOut;
167456 maskNew = pFrom->maskLoop | pWLoop->maskSelf;
167457 isOrdered = pFrom->isOrdered;
167461 pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags,
167464 revMask = pFrom->revLoop;
167479 ("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",
167480 aSortCost[isOrdered], (nOrderBy-isOrdered), nOrderBy,
167484 rUnsorted -= 2; /* TUNING: Slight bias in favor of no-sort plans */
167488 ** mxChoice best-so-far paths.
167490 ** First look for an existing path among best-so-far paths
167494 ** The term "((pTo->isOrdered^isOrdered)&0x80)==0" is equivalent
167495 ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range
167496 ** of legal values for isOrdered, -1..64.
167499 if( pTo->maskLoop==maskNew
167500 && ((pTo->isOrdered^isOrdered)&0x80)==0
167502 testcase( jj==nTo-1 );
167507 /* None of the existing best-so-far paths match the candidate. */
167512 ** paths currently in the best-so-far buffer. So discard
167516 sqlite3DebugPrintf("Skip %s cost=%-3d,%3d,%3d order=%c\n",
167524 ** needs to be added to the set of best-so-far paths. */
167535 sqlite3DebugPrintf("New %s cost=%-3d,%3d,%3d order=%c\n",
167541 /* Control reaches here if best-so-far path pTo=aTo[jj] covers the
167547 ** (pTo->rCost,pTo->nRow,pTo->rUnsorted) <= (rCost,nOut,rUnsorted)
167549 if( pTo->rCost<rCost
167550 || (pTo->rCost==rCost
167551 && (pTo->nRow<nOut
167552 || (pTo->nRow==nOut && pTo->rUnsorted<=rUnsorted)
167559 "Skip %s cost=%-3d,%3d,%3d order=%c",
167562 sqlite3DebugPrintf(" vs %s cost=%-3d,%3d,%3d order=%c\n",
167563 wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
167564 pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
167568 testcase( pTo->rCost==rCost );
167571 testcase( pTo->rCost==rCost+1 );
167577 "Update %s cost=%-3d,%3d,%3d order=%c",
167580 sqlite3DebugPrintf(" was %s cost=%-3d,%3d,%3d order=%c\n",
167581 wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
167582 pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
167587 pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf;
167588 pTo->revLoop = revMask;
167589 pTo->nRow = nOut;
167590 pTo->rCost = rCost;
167591 pTo->rUnsorted = rUnsorted;
167592 pTo->isOrdered = isOrdered;
167593 memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
167594 pTo->aLoop[iLoop] = pWLoop;
167600 if( pTo->rCost>mxCost
167601 || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted)
167603 mxCost = pTo->rCost;
167604 mxUnsorted = pTo->rUnsorted;
167614 sqlite3DebugPrintf("---- after round %d ----\n", iLoop);
167616 sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
167617 wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
167618 pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
167619 if( pTo->isOrdered>0 ){
167620 sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);
167637 sqlite3StackFreeNN(pParse->db, pSpace);
167644 if( pFrom->rCost>aFrom[ii].rCost ) pFrom = &aFrom[ii];
167646 assert( pWInfo->nLevel==nLoop );
167649 WhereLevel *pLevel = pWInfo->a + iLoop;
167650 pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop];
167651 pLevel->iFrom = pWLoop->iTab;
167652 pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor;
167654 if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0
167655 && (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0
167656 && pWInfo->eDistinct==WHERE_DISTINCT_NOOP
167660 int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
167661 WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used);
167662 if( rc==pWInfo->pResultSet->nExpr ){
167663 pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
167666 pWInfo->bOrderedInnerLoop = 0;
167667 if( pWInfo->pOrderBy ){
167668 pWInfo->nOBSat = pFrom->isOrdered;
167669 if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
167670 if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
167671 pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
167673 /* vvv--- See check-in [12ad822d9b827777] on 2023-03-16 ---vvv */
167674 assert( pWInfo->pSelect->pOrderBy==0
167675 || pWInfo->nOBSat <= pWInfo->pSelect->pOrderBy->nExpr );
167677 pWInfo->revMask = pFrom->revLoop;
167678 if( pWInfo->nOBSat<=0 ){
167679 pWInfo->nOBSat = 0;
167681 u32 wsFlags = pFrom->aLoop[nLoop-1]->wsFlags;
167686 int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, pFrom,
167687 WHERE_ORDERBY_LIMIT, nLoop-1, pFrom->aLoop[nLoop-1], &m);
167690 if( rc==pWInfo->pOrderBy->nExpr ){
167691 pWInfo->bOrderedInnerLoop = 1;
167692 pWInfo->revMask = m;
167697 && pWInfo->nOBSat==1
167698 && (pWInfo->wctrlFlags & (WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX))!=0
167700 pWInfo->bOrderedInnerLoop = 1;
167703 if( (pWInfo->wctrlFlags & WHERE_SORTBYGROUP)
167704 && pWInfo->nOBSat==pWInfo->pOrderBy->nExpr && nLoop>0
167707 int nOrder = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy,
167708 pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask
167710 assert( pWInfo->sorted==0 );
167711 if( nOrder==pWInfo->pOrderBy->nExpr ){
167712 pWInfo->sorted = 1;
167713 pWInfo->revMask = revMask;
167718 pWInfo->nRowOut = pFrom->nRow;
167721 sqlite3StackFreeNN(pParse->db, pSpace);
167738 ** FROM clause term that would try to do a full-table scan. This prevents
167739 ** an index search from being converted into a full-table scan in order to
167741 ** performance using the full-scan without sorting if the output size
167743 ** degradation using the full-scan if the output size estimate is too large.
167746 ** Except, if the first solver() call generated a full-table scan in an outer
167747 ** loop then stop this analysis at the first full-scan, since the second
167748 ** solver() run might try to swap that full-scan for another in order to
167753 ** |-- SCAN t1 |-- SCAN t2
167754 ** |-- SEARCH t2 `-- SEARCH t1
167755 ** `-- SORT USING B-TREE
167760 ** |-- SEARCH t1 |-- SCAN t2 <--- bad!
167761 ** |-- SEARCH t2 `-- SEARCH t1
167762 ** `-- SORT USING B-TREE
167764 ** See test cases in test/whereN.test for the real-world query that
167772 for(i=0; i<pWInfo->nLevel; i++){
167773 WhereLoop *p = pWInfo->a[i].pWLoop;
167775 if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 ) continue;
167776 if( (p->wsFlags & (WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_IN))!=0 ){
167777 u8 iTab = p->iTab;
167779 for(pLoop=pWInfo->pLoops; pLoop; pLoop=pLoop->pNextLoop){
167780 if( pLoop->iTab!=iTab ) continue;
167781 if( (pLoop->wsFlags & (WHERE_CONSTRAINT|WHERE_AUTO_INDEX))!=0 ){
167782 /* Auto-index and index-constrained loops allowed to remain */
167791 sqlite3WhereLoopPrint(pLoop, &pWInfo->sWC);
167794 pLoop->prereq = ALLBITS; /* Prevent 2nd solver() from using this one */
167806 ** general-purpose query planner, and thereby yield faster sqlite3_prepare()
167809 ** Return non-zero on success, if this query can be handled by this
167810 ** no-frills query planner. Return zero if this query needs the
167811 ** general-purpose query planner.
167825 pWInfo = pBuilder->pWInfo;
167826 if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0;
167827 assert( pWInfo->pTabList->nSrc>=1 );
167828 pItem = pWInfo->pTabList->a;
167829 pTab = pItem->pTab;
167831 if( pItem->fg.isIndexedBy || pItem->fg.notIndexed ){
167832 testcase( pItem->fg.isIndexedBy );
167833 testcase( pItem->fg.notIndexed );
167836 iCur = pItem->iCursor;
167837 pWC = &pWInfo->sWC;
167838 pLoop = pBuilder->pNew;
167839 pLoop->wsFlags = 0;
167840 pLoop->nSkip = 0;
167841 pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0);
167842 while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
167844 testcase( pTerm->eOperator & WO_IS );
167845 pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW;
167846 pLoop->aLTerm[0] = pTerm;
167847 pLoop->nLTerm = 1;
167848 pLoop->u.btree.nEq = 1;
167850 pLoop->rRun = 33; /* 33==sqlite3LogEst(10) */
167852 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
167854 assert( pLoop->aLTermSpace==pLoop->aLTerm );
167856 || pIdx->pPartIdxWhere!=0
167857 || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace)
167859 opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ;
167860 for(j=0; j<pIdx->nKeyCol; j++){
167862 while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
167864 testcase( pTerm->eOperator & WO_IS );
167865 pLoop->aLTerm[j] = pTerm;
167867 if( j!=pIdx->nKeyCol ) continue;
167868 pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED;
167869 if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){
167870 pLoop->wsFlags |= WHERE_IDX_ONLY;
167872 pLoop->nLTerm = j;
167873 pLoop->u.btree.nEq = j;
167874 pLoop->u.btree.pIndex = pIdx;
167876 pLoop->rRun = 39; /* 39==sqlite3LogEst(15) */
167880 if( pLoop->wsFlags ){
167881 pLoop->nOut = (LogEst)1;
167882 pWInfo->a[0].pWLoop = pLoop;
167883 assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] );
167884 pLoop->maskSelf = 1; /* sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); */
167885 pWInfo->a[0].iTabCur = iCur;
167886 pWInfo->nRowOut = 1;
167887 if( pWInfo->pOrderBy ) pWInfo->nOBSat = pWInfo->pOrderBy->nExpr;
167888 if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){
167889 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
167891 if( scan.iEquiv>1 ) pLoop->wsFlags |= WHERE_TRANSCONS;
167893 pLoop->cId = '0';
167909 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
167910 pWalker->eCode = 0;
167917 ** Return true if the expression contains no non-deterministic SQL
167918 ** functions. Do not consider non-deterministic SQL functions that are
167919 ** part of sub-select statements.
167942 for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){
167943 p->cId = zLabel[i%(sizeof(zLabel)-1)];
167963 ** 5) The table must not have an inner-join ON or USING clause if there is
167967 ** the right-most table of a subquery that was flattened into the
167968 ** main query and that subquery was the right-hand operand of an
167971 ** 7) The omit-noop-join optimization is enabled.
168002 assert( pWInfo->nLevel>=2 );
168003 assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_OmitNoopJoin) );
168007 assert( pWInfo->pResultSet!=0 );
168008 assert( 0==(pWInfo->wctrlFlags & WHERE_AGG_DISTINCT) );
168010 tabUsed = sqlite3WhereExprListUsage(&pWInfo->sMaskSet, pWInfo->pResultSet);
168011 if( pWInfo->pOrderBy ){
168012 tabUsed |= sqlite3WhereExprListUsage(&pWInfo->sMaskSet, pWInfo->pOrderBy);
168014 hasRightJoin = (pWInfo->pTabList->a[0].fg.jointype & JT_LTORJ)!=0;
168015 for(i=pWInfo->nLevel-1; i>=1; i--){
168019 pLoop = pWInfo->a[i].pWLoop;
168020 pItem = &pWInfo->pTabList->a[pLoop->iTab];
168021 if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ) continue;
168022 if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)==0
168023 && (pLoop->wsFlags & WHERE_ONEROW)==0
168027 if( (tabUsed & pLoop->maskSelf)!=0 ) continue;
168028 pEnd = pWInfo->sWC.a + pWInfo->sWC.nTerm;
168029 for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
168030 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
168031 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
168032 || pTerm->pExpr->w.iJoin!=pItem->iCursor
168038 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
168039 && pTerm->pExpr->w.iJoin==pItem->iCursor
168045 WHERETRACE(0xffffffff, ("-> drop loop %c not used\n", pLoop->cId));
168046 notReady &= ~pLoop->maskSelf;
168047 for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
168048 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
168049 pTerm->wtFlags |= TERM_CODED;
168052 if( i!=pWInfo->nLevel-1 ){
168053 int nByte = (pWInfo->nLevel-1-i) * sizeof(WhereLevel);
168054 memmove(&pWInfo->a[i], &pWInfo->a[i+1], nByte);
168056 pWInfo->nLevel--;
168057 assert( pWInfo->nLevel>0 );
168071 ** (3) Bloom-filter processing is not disabled. (Checked by the
168086 assert( pWInfo->nLevel>=2 );
168087 assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) );
168088 for(i=0; i<pWInfo->nLevel; i++){
168089 WhereLoop *pLoop = pWInfo->a[i].pWLoop;
168091 SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];
168092 Table *pTab = pItem->pTab;
168093 if( (pTab->tabFlags & TF_HasStat1)==0 ) break;
168094 pTab->tabFlags |= TF_MaybeReanalyze;
168096 && (pLoop->wsFlags & reqFlags)==reqFlags
168097 /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */
168098 && ALWAYS((pLoop->wsFlags & (WHERE_IPK|WHERE_INDEXED))!=0)
168100 if( nSearch > pTab->nRowLogEst ){
168101 testcase( pItem->fg.jointype & JT_LEFT );
168102 pLoop->wsFlags |= WHERE_BLOOMFILTER;
168103 pLoop->wsFlags &= ~WHERE_IDX_ONLY;
168105 "-> use Bloom-filter on loop %c because there are ~%.1e "
168107 pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,
168108 (double)sqlite3LogEstToInt(pTab->nRowLogEst)));
168111 nSearch += pLoop->nOut;
168124 ** Assume that every function is able to pass-through a subtype from
168136 if( pExpr->op!=TK_FUNCTION ){
168140 db = pWalker->pParse->db;
168141 n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
168142 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
168143 if( pDef==0 || (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
168144 pWalker->eCode = 1;
168173 ** This routine adds IndexedExpr entries to the Parse->pIdxEpr field for
168179 Parse *pParse, /* Add IndexedExpr entries to pParse->pIdxEpr */
168180 Index *pIdx, /* The index-on-expression that contains the expressions */
168187 assert( pIdx->bHasExpr );
168188 pTab = pIdx->pTable;
168189 for(i=0; i<pIdx->nColumn; i++){
168191 int j = pIdx->aiColumn[i];
168193 pExpr = pIdx->aColExpr->a[i].pExpr;
168194 }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){
168195 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
168200 if( pExpr->op==TK_FUNCTION && sqlite3ExprCanReturnSubtype(pParse,pExpr) ){
168206 p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr));
168208 p->pIENext = pParse->pIdxEpr;
168211 sqlite3DebugPrintf("New pParse->pIdxEpr term {%d,%d}\n", iIdxCur, i);
168215 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
168216 p->iDataCur = pTabItem->iCursor;
168217 p->iIdxCur = iIdxCur;
168218 p->iIdxCol = i;
168219 p->bMaybeNullRow = (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0;
168220 if( sqlite3IndexAffinityStr(pParse->db, pIdx) ){
168221 p->aff = pIdx->zColAff[i];
168224 p->zIdxName = pIdx->zName;
168226 pParse->pIdxEpr = p;
168227 if( p->pIENext==0 ){
168228 void *pArg = (void*)&pParse->pIdxEpr;
168235 ** Set the reverse-scan order mask to one for all tables in the query
168244 for(ii=0; ii<pWInfo->pTabList->nSrc; ii++){
168245 SrcItem *pItem = &pWInfo->pTabList->a[ii];
168246 if( !pItem->fg.isCte
168247 || pItem->u2.pCteUse->eM10d!=M10d_Yes
168248 || NEVER(pItem->pSelect==0)
168249 || pItem->pSelect->pOrderBy==0
168251 pWInfo->revMask |= MASKBIT(ii);
168275 ** foreach row2 in t2 do |-- by sqlite3WhereBegin()
168279 ** end |-- by sqlite3WhereEnd()
168286 ** scanning through all values on the right-hand side of the IN.
168289 ** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor.
168299 ** entire tables. Thus a three-way join is an O(N^3) operation. But if
168309 ** inner loops (or around the "..." if the test occurs within the inner-
168358 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
168362 WhereLevel *pLevel; /* A single level in pWInfo->a[] */
168379 db = pParse->db;
168383 testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
168384 if( pOrderBy && pOrderBy->nExpr>=BMS ){
168387 wctrlFlags |= WHERE_KEEP_ALL_JOINS; /* Disable omit-noop-join opt */
168393 testcase( pTabList->nSrc==BMS );
168394 if( pTabList->nSrc>BMS ){
168404 nTabList = (wctrlFlags & WHERE_OR_SUBCLAUSE) ? 1 : pTabList->nSrc;
168409 ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
168410 ** field (type Bitmask) it must be aligned on an 8-byte boundary on
168415 nByteWInfo = ROUND8P(nByteWInfo + (nTabList-1)*sizeof(WhereLevel));
168418 if( db->mallocFailed ){
168423 pWInfo->pParse = pParse;
168424 pWInfo->pTabList = pTabList;
168425 pWInfo->pOrderBy = pOrderBy;
168427 pWInfo->pWhere = pWhere;
168429 pWInfo->pResultSet = pResultSet;
168430 pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
168431 pWInfo->nLevel = nTabList;
168432 pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse);
168433 pWInfo->wctrlFlags = wctrlFlags;
168434 pWInfo->iLimit = iAuxArg;
168435 pWInfo->savedNQueryLoop = pParse->nQueryLoop;
168436 pWInfo->pSelect = pSelect;
168437 memset(&pWInfo->nOBSat, 0,
168438 offsetof(WhereInfo,sWC) - offsetof(WhereInfo,nOBSat));
168439 memset(&pWInfo->a[0], 0, sizeof(WhereLoop)+nTabList*sizeof(WhereLevel));
168440 assert( pWInfo->eOnePass==ONEPASS_OFF ); /* ONEPASS defaults to OFF */
168441 pMaskSet = &pWInfo->sMaskSet;
168442 pMaskSet->n = 0;
168443 pMaskSet->ix[0] = -99; /* Initialize ix[0] to a value that can never be
168445 ** test for pMaskSet->n==0 in sqlite3WhereGetMask() */
168447 sWLB.pWC = &pWInfo->sWC;
168452 sWLB.pNew->cId = '*';
168458 sqlite3WhereClauseInit(&pWInfo->sWC, pWInfo);
168459 sqlite3WhereSplit(&pWInfo->sWC, pWhere, TK_AND);
168464 if( pOrderBy ) pWInfo->nOBSat = pOrderBy->nExpr;
168468 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
168470 if( ALWAYS(pWInfo->pSelect)
168471 && (pWInfo->pSelect->selFlags & SF_MultiValue)==0
168478 ** The N-th term of the FROM clause is assigned a bitmask of 1<<N.
168481 ** a table T, then X-1 is the bitmask for all other tables to the left of T.
168485 ** Note that bitmasks are created for all pTabList->nSrc tables in
168487 ** equal to pTabList->nSrc but might be shortened to 1 if the
168492 createMask(pMaskSet, pTabList->a[ii].iCursor);
168493 sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC);
168494 }while( (++ii)<pTabList->nSrc );
168498 for(ii=0; ii<pTabList->nSrc; ii++){
168499 Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor);
168508 sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
168509 if( pSelect && pSelect->pLimit ){
168510 sqlite3WhereAddLimit(&pWInfo->sWC, pSelect);
168512 if( pParse->nErr ) goto whereBeginError;
168514 /* The False-WHERE-Term-Bypass optimization:
168523 ** right-hand side of a LEFT or FULL JOIN.
168526 ** (4) If the expression contains non-deterministic functions
168527 ** that are not within a sub-select. This is not required
168531 ** WHERE random()>0; -- eval random() once per row
168532 ** WHERE (SELECT random())>0; -- eval random() just once overall
168540 for(ii=0; ii<sWLB.pWC->nBase; ii++){
168541 WhereTerm *pT = &sWLB.pWC->a[ii]; /* A term of the WHERE clause */
168543 if( pT->wtFlags & TERM_VIRTUAL ) continue;
168544 pX = pT->pExpr;
168546 assert( pT->prereqAll!=0 || !ExprHasProperty(pX, EP_OuterON) );
168547 if( pT->prereqAll==0 /* Conditions (1) and (2) */
168550 && (pTabList->a[0].fg.jointype & JT_LTORJ)!=0 )
168552 sqlite3ExprIfFalse(pParse, pX, pWInfo->iBreak, SQLITE_JUMPIFNULL);
168553 pT->wtFlags |= TERM_CODED;
168562 pWInfo->wctrlFlags &= ~WHERE_WANT_DISTINCT;
168563 }else if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
168565 pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
168568 pWInfo->wctrlFlags |= WHERE_DISTINCTBY;
168569 pWInfo->pOrderBy = pResultSet;
168592 sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n");
168613 while( pWInfo->pLoops ){
168614 WhereLoop *p = pWInfo->pLoops;
168615 pWInfo->pLoops = p->pNextLoop;
168625 if( db->mallocFailed ) goto whereBeginError;
168626 if( pWInfo->pOrderBy ){
168628 wherePathSolver(pWInfo, pWInfo->nRowOut+1);
168629 if( db->mallocFailed ) goto whereBeginError;
168633 ** the output size by a factor of 8 (LogEst -30).
168635 if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0 ){
168637 pWInfo->nRowOut, pWInfo->nRowOut-30));
168638 pWInfo->nRowOut -= 30;
168642 assert( pWInfo->pTabList!=0 );
168643 if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
168646 if( pParse->nErr ){
168649 assert( db->mallocFailed==0 );
168652 sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut);
168653 if( pWInfo->nOBSat>0 ){
168654 sqlite3DebugPrintf(" ORDERBY=%d,0x%llx", pWInfo->nOBSat, pWInfo->revMask);
168656 switch( pWInfo->eDistinct ){
168671 for(ii=0; ii<pWInfo->nLevel; ii++){
168672 sqlite3WhereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC);
168680 ** This query optimization is factored out into a separate "no-inline"
168683 ** some C-compiler optimizers from in-lining the
168685 ** in-line sqlite3WhereCodeOneLoopStart() for performance reasons.
168688 if( pWInfo->nLevel>=2 /* Must be a join, or this opt8n is pointless */
168694 nTabList = pWInfo->nLevel;
168701 if( pWInfo->nLevel>=2
168709 sqlite3DebugPrintf("---- WHERE clause at end of analysis:\n");
168714 pWInfo->pParse->nQueryLoop += pWInfo->nRowOut;
168717 ** to use a one-pass algorithm, determine if this is appropriate.
168719 ** A one-pass approach can be used if the caller has requested one
168723 ** * the caller has indicated that a one-pass approach can be used
168732 ** use a one-pass approach, and this is not set accurately for scans
168735 assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
168737 int wsFlags = pWInfo->a[0].pWLoop->wsFlags;
168739 assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
168742 && !IsVirtual(pTabList->a[0].pTab)
168746 pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
168747 if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
168751 pWInfo->a[0].pWLoop->wsFlags = (wsFlags & ~WHERE_IDX_ONLY);
168759 for(ii=0, pLevel=pWInfo->a; ii<nTabList; ii++, pLevel++){
168764 pTabItem = &pTabList->a[pLevel->iFrom];
168765 pTab = pTabItem->pTab;
168766 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
168767 pLoop = pLevel->pWLoop;
168768 if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){
168772 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){
168774 int iCur = pTabItem->iCursor;
168780 if( ((pLoop->wsFlags & WHERE_IDX_ONLY)==0
168782 || (pTabItem->fg.jointype & (JT_LTORJ|JT_RIGHT))!=0
168785 if( pWInfo->eOnePass!=ONEPASS_OFF ){
168787 pWInfo->aiCurOnePass[0] = pTabItem->iCursor;
168789 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
168790 assert( pTabItem->iCursor==pLevel->iTabCur );
168791 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
168792 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
168793 if( pWInfo->eOnePass==ONEPASS_OFF
168794 && pTab->nCol<BMS
168795 && (pTab->tabFlags & (TF_HasGenerated|TF_WithoutRowid))==0
168796 && (pLoop->wsFlags & (WHERE_AUTO_INDEX|WHERE_BLOOMFILTER))==0
168801 Bitmask b = pTabItem->colUsed;
168804 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32);
168805 assert( n<=pTab->nCol );
168808 if( pLoop->u.btree.pIndex!=0 && (pTab->tabFlags & TF_WithoutRowid)==0 ){
168816 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0,
168817 (const u8*)&pTabItem->colUsed, P4_INT64);
168820 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
168822 if( pLoop->wsFlags & WHERE_INDEXED ){
168823 Index *pIx = pLoop->u.btree.pIndex;
168827 assert( iAuxArg!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 );
168831 /* This is one term of an OR-optimization using the PRIMARY KEY of a
168833 iIndexCur = pLevel->iTabCur;
168835 }else if( pWInfo->eOnePass!=ONEPASS_OFF ){
168836 Index *pJ = pTabItem->pTab->pIndex;
168841 pJ = pJ->pNext;
168844 pWInfo->aiCurOnePass[1] = iIndexCur;
168849 iIndexCur = pParse->nTab++;
168850 if( pIx->bHasExpr && OptimizationEnabled(db, SQLITE_IndexedExpr) ){
168853 if( pIx->pPartIdxWhere && (pTabItem->fg.jointype & JT_RIGHT)==0 ){
168855 pParse, pIx, pIx->pPartIdxWhere, 0, iIndexCur, pTabItem
168859 pLevel->iIdxCur = iIndexCur;
168861 assert( pIx->pSchema==pTab->pSchema );
168864 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
168866 if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0
168867 && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0
168868 && (pLoop->wsFlags & WHERE_BIGNULL_SORT)==0
168869 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0
168870 && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0
168871 && pWInfo->eDistinct!=WHERE_DISTINCT_ORDERED
168875 VdbeComment((v, "%s", pIx->zName));
168880 for(ii=0; ii<pIx->nColumn; ii++){
168881 jj = pIx->aiColumn[ii];
168884 if( (pTabItem->colUsed & MASKBIT(jj))==0 ) continue;
168894 if( (pTabItem->fg.jointype & JT_RIGHT)!=0
168895 && (pLevel->pRJ = sqlite3WhereMalloc(pWInfo, sizeof(WhereRightJoin)))!=0
168897 WhereRightJoin *pRJ = pLevel->pRJ;
168898 pRJ->iMatch = pParse->nTab++;
168899 pRJ->regBloom = ++pParse->nMem;
168900 sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom);
168901 pRJ->regReturn = ++pParse->nMem;
168902 sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn);
168903 assert( pTab==pTabItem->pTab );
168906 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1);
168907 pInfo = sqlite3KeyInfoAlloc(pParse->db, 1, 0);
168909 pInfo->aColl[0] = 0;
168910 pInfo->aSortFlags[0] = 0;
168915 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, pPk->nKeyCol);
168918 pLoop->wsFlags &= ~WHERE_IDX_ONLY;
168922 pWInfo->nOBSat = 0;
168923 pWInfo->eDistinct = WHERE_DISTINCT_UNORDERED;
168926 pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
168927 if( db->mallocFailed ) goto whereBeginError;
168937 if( pParse->nErr ) goto whereBeginError;
168938 pLevel = &pWInfo->a[ii];
168939 wsFlags = pLevel->pWLoop->wsFlags;
168940 pSrc = &pTabList->a[pLevel->iFrom];
168941 if( pSrc->fg.isMaterialized ){
168942 if( pSrc->fg.isCorrelated ){
168943 sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
168946 sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
168950 assert( pTabList == pWInfo->pTabList );
168954 constructAutomaticIndex(pParse, &pWInfo->sWC, notReady, pLevel);
168959 if( db->mallocFailed ) goto whereBeginError;
168964 pLevel->addrBody = sqlite3VdbeCurrentAddr(v);
168966 pWInfo->iContinue = pLevel->addrCont;
168973 VdbeModuleComment((v, "Begin WHERE-core"));
168974 pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v);
168980 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
168998 # define OpcodeRewriteTrace(D,K,P) /* no-op */
169006 if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return;
169016 Parse *pParse = pWInfo->pParse;
169017 Vdbe *v = pParse->pVdbe;
169021 SrcList *pTabList = pWInfo->pTabList;
169022 sqlite3 *db = pParse->db;
169028 VdbeModuleComment((v, "End WHERE-core"));
169029 for(i=pWInfo->nLevel-1; i>=0; i--){
169031 pLevel = &pWInfo->a[i];
169032 if( pLevel->pRJ ){
169035 WhereRightJoin *pRJ = pLevel->pRJ;
169036 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169037 pLevel->addrCont = 0;
169038 pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v);
169039 sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1);
169043 pLoop = pLevel->pWLoop;
169044 if( pLevel->op!=OP_Noop ){
169049 if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED
169050 && i==pWInfo->nLevel-1 /* Ticket [ef9318757b152e3] 2017-10-21 */
169051 && (pLoop->wsFlags & WHERE_INDEXED)!=0
169052 && (pIdx = pLoop->u.btree.pIndex)->hasStat1
169053 && (n = pLoop->u.btree.nDistinctCol)>0
169054 && pIdx->aiRowLogEst[n]>=36
169056 int r1 = pParse->nMem+1;
169059 sqlite3VdbeAddOp3(v, OP_Column, pLevel->iIdxCur, j, r1+j);
169061 pParse->nMem += n+1;
169062 op = pLevel->op==OP_Prev ? OP_SeekLT : OP_SeekGT;
169063 addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n);
169066 sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2);
169070 if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169071 sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
169072 sqlite3VdbeChangeP5(v, pLevel->p5);
169074 VdbeCoverageIf(v, pLevel->op==OP_Next);
169075 VdbeCoverageIf(v, pLevel->op==OP_Prev);
169076 VdbeCoverageIf(v, pLevel->op==OP_VNext);
169077 if( pLevel->regBignull ){
169078 sqlite3VdbeResolveLabel(v, pLevel->addrBignull);
169079 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1);
169085 }else if( pLevel->addrCont ){
169086 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169088 if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){
169091 sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
169092 for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
169093 assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull
169094 || pParse->db->mallocFailed );
169095 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
169096 if( pIn->eEndLoopOp!=OP_Noop ){
169097 if( pIn->nPrefix ){
169099 (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
169100 && (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0;
169101 if( pLevel->iLeftJoin ){
169102 /* For LEFT JOIN queries, cursor pIn->iCur may not have been
169107 ** return the null-row. So, if the cursor is not open yet,
169110 sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur,
169115 sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur,
169117 pIn->iBase, pIn->nPrefix);
169123 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
169126 sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
169128 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev);
169129 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next);
169131 sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
169134 sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
169135 if( pLevel->pRJ ){
169136 sqlite3VdbeAddOp3(v, OP_Return, pLevel->pRJ->regReturn, 0, 1);
169139 if( pLevel->addrSkip ){
169140 sqlite3VdbeGoto(v, pLevel->addrSkip);
169141 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
169142 sqlite3VdbeJumpHere(v, pLevel->addrSkip);
169143 sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
169146 if( pLevel->addrLikeRep ){
169147 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1),
169148 pLevel->addrLikeRep);
169152 if( pLevel->iLeftJoin ){
169153 int ws = pLoop->wsFlags;
169154 addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
169157 SrcItem *pSrc = &pTabList->a[pLevel->iFrom];
169158 assert( pLevel->iTabCur==pSrc->iCursor );
169159 if( pSrc->fg.viaCoroutine ){
169161 n = pSrc->regResult;
169162 assert( pSrc->pTab!=0 );
169163 m = pSrc->pTab->nCol;
169164 sqlite3VdbeAddOp3(v, OP_Null, 0, n, n+m-1);
169166 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
169169 || ((ws & WHERE_MULTI_OR) && pLevel->u.pCoveringIdx)
169172 Index *pIx = pLevel->u.pCoveringIdx;
169173 int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
169174 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
169177 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
169179 if( pLevel->op==OP_Return ){
169180 sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
169182 sqlite3VdbeGoto(v, pLevel->addrFirst);
169186 VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
169187 pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
169190 assert( pWInfo->nLevel<=pTabList->nSrc );
169191 for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
169195 SrcItem *pTabItem = &pTabList->a[pLevel->iFrom];
169196 Table *pTab = pTabItem->pTab;
169198 pLoop = pLevel->pWLoop;
169204 if( pLevel->pRJ ){
169209 /* For a co-routine, change all OP_Column references to the table of
169210 ** the co-routine into OP_Copy of result contained in a register.
169213 if( pTabItem->fg.viaCoroutine ){
169214 testcase( pParse->db->mallocFailed );
169215 assert( pTabItem->regResult>=0 );
169216 translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
169217 pTabItem->regResult, 0);
169232 if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){
169233 pIdx = pLoop->u.btree.pIndex;
169234 }else if( pLoop->wsFlags & WHERE_MULTI_OR ){
169235 pIdx = pLevel->u.pCoveringIdx;
169238 && !db->mallocFailed
169240 if( pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable) ){
169243 last = pWInfo->iEndWhere;
169245 if( pIdx->bHasExpr ){
169246 IndexedExpr *p = pParse->pIdxEpr;
169248 if( p->iIdxCur==pLevel->iIdxCur ){
169251 sqlite3DebugPrintf("Disable pParse->pIdxEpr term {%d,%d}\n",
169252 p->iIdxCur, p->iIdxCol);
169253 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);
169256 p->iDataCur = -1;
169257 p->iIdxCur = -1;
169259 p = p->pIENext;
169262 k = pLevel->addrBody + 1;
169264 if( db->flags & SQLITE_VdbeAddopTrace ){
169265 printf("TRANSLATE cursor %d->%d in opcode range %d..%d\n",
169266 pLevel->iTabCur, pLevel->iIdxCur, k, last-1);
169269 pOp = sqlite3VdbeGetOp(v, k - 1);
169270 assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur );
169271 assert( pOp->opcode!=OP_Rowid || pOp->p1!=pLevel->iTabCur );
169272 assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur );
169275 pLastOp = pOp + (last - k);
169278 if( pOp->p1!=pLevel->iTabCur ){
169279 /* no-op */
169280 }else if( pOp->opcode==OP_Column
169282 || pOp->opcode==OP_Offset
169285 int x = pOp->p2;
169286 assert( pIdx->pTable==pTab );
169288 if( pOp->opcode==OP_Offset ){
169294 x = pPk->aiColumn[x];
169302 pOp->p2 = x;
169303 pOp->p1 = pLevel->iIdxCur;
169307 ** reference. Verify that this is harmless - that the
169310 if( pLoop->wsFlags & WHERE_IDX_ONLY ){
169312 pParse->rc = SQLITE_INTERNAL;
169315 }else if( pOp->opcode==OP_Rowid ){
169316 pOp->p1 = pLevel->iIdxCur;
169317 pOp->opcode = OP_IdxRowid;
169319 }else if( pOp->opcode==OP_IfNullRow ){
169320 pOp->p1 = pLevel->iIdxCur;
169328 if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n");
169336 sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
169340 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
169342 pParse->withinRJSubrtn -= nRJ;
169391 ** the sub-query.
169396 ** select-list and ORDER BY expressions in the parent query are
169397 ** selected by the sub-query. For the purposes of the transformation,
169429 ** sub-query, which is always implemented as a co-routine. It then calls
169434 ** by the sub-query a sub-routine (OP_Gosub) coded by select.c is invoked.
169435 ** When the sub-routine is invoked:
169437 ** * The results of all window-functions for the row are stored
169449 ** BUILT-IN WINDOW FUNCTIONS
169451 ** This implementation features the following built-in window functions:
169465 ** These are the same built-in window functions supported by Postgres.
169468 ** be implemented using an API, built-in window functions are much more
169471 ** As such, some built-in window functions use the same API as aggregate
169482 ** As well as some of the built-in window functions, aggregate window
169489 ** Implementation of built-in window function row_number(). Assumes that the
169520 ** Implementation of built-in window function dense_rank(). Assumes that
169532 if( p ) p->nStep = 1;
169540 if( p->nStep ){
169541 p->nValue++;
169542 p->nStep = 0;
169544 sqlite3_result_int64(pCtx, p->nValue);
169549 ** Implementation of built-in window function nth_value(). This
169550 ** implementation is used in "slow mode" only - when the EXCLUDE clause
169581 p->nStep++;
169582 if( iVal==p->nStep ){
169583 p->pValue = sqlite3_value_dup(apArg[0]);
169584 if( !p->pValue ){
169595 pCtx, "second argument to nth_value must be a positive integer", -1
169601 if( p && p->pValue ){
169602 sqlite3_result_value(pCtx, p->pValue);
169603 sqlite3_value_free(p->pValue);
169604 p->pValue = 0;
169617 if( p && p->pValue==0 ){
169618 p->pValue = sqlite3_value_dup(apArg[0]);
169619 if( !p->pValue ){
169629 if( p && p->pValue ){
169630 sqlite3_result_value(pCtx, p->pValue);
169631 sqlite3_value_free(p->pValue);
169632 p->pValue = 0;
169639 ** Implementation of built-in window function rank(). Assumes that
169652 p->nStep++;
169653 if( p->nValue==0 ){
169654 p->nValue = p->nStep;
169664 sqlite3_result_int64(pCtx, p->nValue);
169665 p->nValue = 0;
169670 ** Implementation of built-in window function percent_rank(). Assumes that
169685 p->nTotal++;
169697 p->nStep++;
169703 p->nValue = p->nStep;
169704 if( p->nTotal>1 ){
169705 double r = (double)p->nValue / (double)(p->nTotal-1);
169715 ** Implementation of built-in window function cume_dist(). Assumes that
169730 p->nTotal++;
169742 p->nStep++;
169748 double r = (double)(p->nStep) / (double)(p->nTotal);
169778 if( p->nTotal==0 ){
169779 p->nParam = sqlite3_value_int64(apArg[0]);
169780 if( p->nParam<=0 ){
169782 pCtx, "argument of ntile must be a positive integer", -1
169786 p->nTotal++;
169798 p->iRow++;
169803 if( p && p->nParam>0 ){
169804 int nSize = (p->nTotal / p->nParam);
169806 sqlite3_result_int64(pCtx, p->iRow+1);
169808 i64 nLarge = p->nTotal - p->nParam*nSize;
169810 i64 iRow = p->iRow;
169812 assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal );
169817 sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
169844 sqlite3_value_free(p->pVal);
169845 p->pVal = sqlite3_value_dup(apArg[0]);
169846 if( p->pVal==0 ){
169849 p->nVal++;
169863 p->nVal--;
169864 if( p->nVal==0 ){
169865 sqlite3_value_free(p->pVal);
169866 p->pVal = 0;
169873 if( p && p->pVal ){
169874 sqlite3_result_value(pCtx, p->pVal);
169880 if( p && p->pVal ){
169881 sqlite3_result_value(pCtx, p->pVal);
169882 sqlite3_value_free(p->pVal);
169883 p->pVal = 0;
169888 ** Static names for the built-in window function names. These static
169893 ** if( pFuncDef->zName==row_valueName ){ ... }
169908 ** No-op implementations of xStep() and xFinalize(). Used as place-holders
169909 ** for built-in window functions that never call those interfaces.
169926 static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
169937 ** no-op routines for their methods */
169955 ** Register those built-in window functions that are not also aggregates.
169980 for(p=pList; p; p=p->pNextWin){
169981 if( sqlite3StrICmp(p->zName, zName)==0 ) break;
170002 ** * If the function is a built-in window function that requires the
170003 ** window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top
170012 if( pWin->zName && pWin->eFrmType==0 ){
170013 Window *p = windowFind(pParse, pList, pWin->zName);
170015 pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0);
170016 pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0);
170017 pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0);
170018 pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0);
170019 pWin->eStart = p->eStart;
170020 pWin->eEnd = p->eEnd;
170021 pWin->eFrmType = p->eFrmType;
170022 pWin->eExclude = p->eExclude;
170026 if( (pWin->eFrmType==TK_RANGE)
170027 && (pWin->pStart || pWin->pEnd)
170028 && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1)
170034 if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){
170035 sqlite3 *db = pParse->db;
170036 if( pWin->pFilter ){
170058 if( pFunc->zName==aUp[i].zFunc ){
170059 sqlite3ExprDelete(db, pWin->pStart);
170060 sqlite3ExprDelete(db, pWin->pEnd);
170061 pWin->pEnd = pWin->pStart = 0;
170062 pWin->eFrmType = aUp[i].eFrmType;
170063 pWin->eStart = aUp[i].eStart;
170064 pWin->eEnd = aUp[i].eEnd;
170065 pWin->eExclude = 0;
170066 if( pWin->eStart==TK_FOLLOWING ){
170067 pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1");
170074 pWin->pWFunc = pFunc;
170087 Select *pSubSelect; /* Current sub-select, if any */
170092 ** this function appends to the output expression-list and updates
170096 struct WindowRewrite *p = pWalker->u.pRewrite;
170097 Parse *pParse = pWalker->pParse;
170099 assert( p->pWin!=0 );
170101 /* If this function is being called from within a scalar sub-select
170105 ** to the scalar sub-select. */
170106 if( p->pSubSelect ){
170107 if( pExpr->op!=TK_COLUMN ){
170110 int nSrc = p->pSrc->nSrc;
170113 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
170119 switch( pExpr->op ){
170126 for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){
170127 if( pExpr->y.pWin==pWin ){
170128 assert( pWin->pOwner==pExpr );
170138 int iCol = -1;
170139 if( pParse->db->mallocFailed ) return WRC_Abort;
170140 if( p->pSub ){
170142 for(i=0; i<p->pSub->nExpr; i++){
170143 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
170150 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
170151 if( pDup && pDup->op==TK_AGG_FUNCTION ) pDup->op = TK_FUNCTION;
170152 p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup);
170154 if( p->pSub ){
170155 int f = pExpr->flags & EP_Collate;
170158 sqlite3ExprDelete(pParse->db, pExpr);
170162 pExpr->op = TK_COLUMN;
170163 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
170164 pExpr->iTable = p->pWin->iEphCsr;
170165 pExpr->y.pTab = p->pTab;
170166 pExpr->flags = f;
170168 if( pParse->db->mallocFailed ) return WRC_Abort;
170172 default: /* no-op */
170179 struct WindowRewrite *p = pWalker->u.pRewrite;
170180 Select *pSave = p->pSubSelect;
170184 p->pSubSelect = pSelect;
170186 p->pSubSelect = pSave;
170193 ** Iterate through each expression in expression-list pEList. For each:
170200 ** Append the node to output expression-list (*ppSub). And replace it
170201 ** with a TK_COLUMN that reads the (N-1)th element of table
170202 ** pWin->iEphCsr, where N is the number of elements in (*ppSub) after
170211 ExprList **ppSub /* IN/OUT: Sub-select expression-list */
170236 ** Append a copy of each expression in expression-list pAppend to
170247 int nInit = pList ? pList->nExpr : 0;
170248 for(i=0; i<pAppend->nExpr; i++){
170249 sqlite3 *db = pParse->db;
170250 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
170251 if( db->mallocFailed ){
170260 pSub->op = TK_NULL;
170261 pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
170262 pSub->u.zToken = 0;
170266 if( pList ) pList->a[nInit+i].fg.sortFlags = pAppend->a[i].fg.sortFlags;
170275 ** then we have to increase the Expr->op2 values of those nodes
170281 if( pExpr->op==TK_AGG_FUNCTION
170282 && pExpr->op2>=pWalker->walkerDepth
170284 pExpr->op2++;
170290 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
170292 sqlite3ErrorMsg(pWalker->pParse,
170293 "misuse of aggregate: %s()", pExpr->u.zToken);
170300 ** any SQL window functions, this function is a no-op. Otherwise, it
170307 if( p->pWin
170308 && p->pPrior==0
170309 && ALWAYS((p->selFlags & SF_WinRewrite)==0)
170313 sqlite3 *db = pParse->db;
170315 SrcList *pSrc = p->pSrc;
170316 Expr *pWhere = p->pWhere;
170317 ExprList *pGroupBy = p->pGroupBy;
170318 Expr *pHaving = p->pHaving;
170321 ExprList *pSublist = 0; /* Expression list for sub-query */
170322 Window *pMWin = p->pWin; /* Main window object */
170327 u32 selFlags = p->selFlags;
170335 if( (p->selFlags & SF_Aggregate)==0 ){
170338 sqlite3WalkExprList(&w, p->pOrderBy);
170341 p->pSrc = 0;
170342 p->pWhere = 0;
170343 p->pGroupBy = 0;
170344 p->pHaving = 0;
170345 p->selFlags &= ~SF_Aggregate;
170346 p->selFlags |= SF_WinRewrite;
170348 /* Create the ORDER BY clause for the sub-select. This is the concatenation
170351 pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1);
170352 pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1);
170353 if( pSort && p->pOrderBy && p->pOrderBy->nExpr<=pSort->nExpr ){
170354 int nSave = pSort->nExpr;
170355 pSort->nExpr = p->pOrderBy->nExpr;
170356 if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){
170357 sqlite3ExprListDelete(db, p->pOrderBy);
170358 p->pOrderBy = 0;
170360 pSort->nExpr = nSave;
170366 pMWin->iEphCsr = pParse->nTab++;
170367 pParse->nTab += 3;
170369 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
170370 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
170371 pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0);
170374 ** sub-select expression list. They are required to figure out where
170376 pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0);
170377 pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0);
170380 ** sub-select expression list. Also allocate two registers for each
170381 ** window function - one for the accumulator, another for interim
170383 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
170385 assert( ExprUseXList(pWin->pOwner) );
170386 assert( pWin->pWFunc!=0 );
170387 pArgs = pWin->pOwner->x.pList;
170388 if( pWin->pWFunc->funcFlags & SQLITE_SUBTYPE ){
170390 pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
170391 pWin->bExprArgs = 1;
170393 pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
170396 if( pWin->pFilter ){
170397 Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0);
170400 pWin->regAccum = ++pParse->nMem;
170401 pWin->regResult = ++pParse->nMem;
170402 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
170421 ("New window-function subquery in FROM clause of (%u/%p)\n",
170422 p->selId, p));
170423 p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
170424 assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside
170427 if( p->pSrc ){
170429 p->pSrc->a[0].pSelect = pSub;
170430 p->pSrc->a[0].fg.isCorrelated = 1;
170431 sqlite3SrcListAssignCursors(pParse, p->pSrc);
170432 pSub->selFlags |= SF_Expanded|SF_OrderByReqd;
170434 pSub->selFlags |= (selFlags & SF_Aggregate);
170437 ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get
170442 pTab->tabFlags |= TF_Ephemeral;
170443 p->pSrc->a[0].pTab = pTab;
170454 if( db->mallocFailed ) rc = SQLITE_NOMEM;
170458 ** result-set or ORDER BY clause of the SELECT statement p. */
170462 assert( rc==SQLITE_OK || pParse->nErr!=0 );
170471 if( p->ppThis ){
170472 *p->ppThis = p->pNextWin;
170473 if( p->pNextWin ) p->pNextWin->ppThis = p->ppThis;
170474 p->ppThis = 0;
170484 sqlite3ExprDelete(db, p->pFilter);
170485 sqlite3ExprListDelete(db, p->pPartition);
170486 sqlite3ExprListDelete(db, p->pOrderBy);
170487 sqlite3ExprDelete(db, p->pEnd);
170488 sqlite3ExprDelete(db, p->pStart);
170489 sqlite3DbFree(db, p->zName);
170490 sqlite3DbFree(db, p->zBase);
170500 Window *pNext = p->pNextWin;
170508 ** value should be a non-negative integer. If the value is not a
170509 ** constant, change it to NULL. The fact that it is then a non-negative
170516 sqlite3ExprDelete(pParse->db, pExpr);
170517 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
170572 pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
170574 pWin->eFrmType = eType;
170575 pWin->eStart = eStart;
170576 pWin->eEnd = eEnd;
170577 if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){
170580 pWin->eExclude = eExclude;
170581 pWin->bImplicitFrame = bImplicitFrame;
170582 pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd);
170583 pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart);
170587 sqlite3ExprDelete(pParse->db, pEnd);
170588 sqlite3ExprDelete(pParse->db, pStart);
170594 ** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the
170595 ** equivalent nul-terminated string.
170605 pWin->pPartition = pPartition;
170606 pWin->pOrderBy = pOrderBy;
170608 pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
170611 sqlite3ExprListDelete(pParse->db, pPartition);
170612 sqlite3ExprListDelete(pParse->db, pOrderBy);
170619 ** is the base window. Earlier windows from the same WINDOW clause are
170620 ** stored in the linked list starting at pWin->pNextWin. This function
170621 ** either updates *pWin according to the base specification, or else
170625 if( pWin->zBase ){
170626 sqlite3 *db = pParse->db;
170627 Window *pExist = windowFind(pParse, pList, pWin->zBase);
170631 if( pWin->pPartition ){
170633 }else if( pExist->pOrderBy && pWin->pOrderBy ){
170635 }else if( pExist->bImplicitFrame==0 ){
170640 "cannot override %s of window: %s", zErr, pWin->zBase
170643 pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0);
170644 if( pExist->pOrderBy ){
170645 assert( pWin->pOrderBy==0 );
170646 pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0);
170648 sqlite3DbFree(db, pWin->zBase);
170649 pWin->zBase = 0;
170660 assert( p->op==TK_FUNCTION );
170663 p->y.pWin = pWin;
170665 pWin->pOwner = p;
170666 if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){
170672 sqlite3WindowDelete(pParse->db, pWin);
170677 ** Possibly link window pWin into the list at pSel->pWin (window functions
170684 if( 0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0) ){
170685 pWin->pNextWin = pSel->pWin;
170686 if( pSel->pWin ){
170687 pSel->pWin->ppThis = &pWin->pNextWin;
170689 pSel->pWin = pWin;
170690 pWin->ppThis = &pSel->pWin;
170692 if( sqlite3ExprListCompare(pWin->pPartition, pSel->pWin->pPartition,-1) ){
170693 pSel->selFlags |= SF_MultiPart;
170712 if( p1->eFrmType!=p2->eFrmType ) return 1;
170713 if( p1->eStart!=p2->eStart ) return 1;
170714 if( p1->eEnd!=p2->eEnd ) return 1;
170715 if( p1->eExclude!=p2->eExclude ) return 1;
170716 if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
170717 if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
170718 if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){
170721 if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){
170725 if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){
170735 ** to begin iterating through the sub-query results. It is used to allocate
170739 int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr;
170740 Window *pMWin = pSelect->pWin;
170744 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
170745 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
170746 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr);
170747 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr);
170751 if( pMWin->pPartition ){
170752 int nExpr = pMWin->pPartition->nExpr;
170753 pMWin->regPart = pParse->nMem+1;
170754 pParse->nMem += nExpr;
170755 sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1);
170758 pMWin->regOne = ++pParse->nMem;
170759 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne);
170761 if( pMWin->eExclude ){
170762 pMWin->regStartRowid = ++pParse->nMem;
170763 pMWin->regEndRowid = ++pParse->nMem;
170764 pMWin->csrApp = pParse->nTab++;
170765 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
170766 sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
170767 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr);
170771 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
170772 FuncDef *p = pWin->pWFunc;
170773 if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){
170783 assert( ExprUseXList(pWin->pOwner) );
170784 pList = pWin->pOwner->x.pList;
170786 pWin->csrApp = pParse->nTab++;
170787 pWin->regApp = pParse->nMem+1;
170788 pParse->nMem += 3;
170789 if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){
170790 assert( pKeyInfo->aSortFlags[0]==0 );
170791 pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC;
170793 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2);
170795 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
170797 else if( p->zName==nth_valueName || p->zName==first_valueName ){
170798 /* Allocate two registers at pWin->regApp. These will be used to
170800 pWin->regApp = pParse->nMem+1;
170801 pWin->csrApp = pParse->nTab++;
170802 pParse->nMem += 2;
170803 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
170805 else if( p->zName==leadName || p->zName==lagName ){
170806 pWin->csrApp = pParse->nTab++;
170807 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
170822 ** code to check that the value is a non-negative integer and throws an
170827 "frame starting offset must be a non-negative integer",
170828 "frame ending offset must be a non-negative integer",
170830 "frame starting offset must be a non-negative number",
170831 "frame ending offset must be a non-negative number",
170869 ** Return the number of arguments passed to the window-function associated
170874 assert( ExprUseXList(pWin->pOwner) );
170875 pList = pWin->pOwner->x.pList;
170876 return (pList ? pList->nExpr : 0);
170899 ** in an array of accumulator registers - one for each window function
170906 ** order to reduce memory requirements - it would always be safe just
170921 ** Consider a window-frame similar to the following:
170941 ** Depending on the window-frame in question, all three cursors may not
170969 Window *pMWin = p->pMWin;
170970 ExprList *pOrderBy = pMWin->pOrderBy;
170972 Vdbe *v = sqlite3GetVdbe(p->pParse);
170973 ExprList *pPart = pMWin->pPartition;
170974 int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0);
170976 for(i=0; i<pOrderBy->nExpr; i++){
170984 ** xInverse (if bInverse is non-zero) for each window function in the
170985 ** linked list starting at pMWin. Or, for built-in window functions
170996 ** already populated with all columns from the current row of the sub-query.
170998 ** If argument regPartSize is non-zero, then it is a register containing the
171008 Parse *pParse = p->pParse;
171011 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171012 FuncDef *pFunc = pWin->pWFunc;
171014 int nArg = pWin->bExprArgs ? 0 : windowArgCount(pWin);
171017 assert( bInverse==0 || pWin->eStart!=TK_UNBOUNDED );
171024 if( i!=1 || pFunc->zName!=nth_valueName ){
171025 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i);
171027 sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i);
171032 if( pMWin->regStartRowid==0
171033 && (pFunc->funcFlags & SQLITE_FUNC_MINMAX)
171034 && (pWin->eStart!=TK_UNBOUNDED)
171039 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1);
171040 sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp);
171041 sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2);
171042 sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2);
171044 sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1);
171046 sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp);
171047 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
171050 }else if( pWin->regApp ){
171051 assert( pFunc->zName==nth_valueName
171052 || pFunc->zName==first_valueName
171055 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1);
171056 }else if( pFunc->xSFunc!=noopStepFunc ){
171058 if( pWin->pFilter ){
171060 assert( ExprUseXList(pWin->pOwner) );
171061 assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr );
171062 assert( pWin->bExprArgs || nArg ||pWin->pOwner->x.pList==0 );
171064 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp);
171070 if( pWin->bExprArgs ){
171074 assert( ExprUseXList(pWin->pOwner) );
171075 nArg = pWin->pOwner->x.pList->nExpr;
171077 sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0);
171081 if( pOp->opcode==OP_Column && pOp->p1==pMWin->iEphCsr ){
171082 pOp->p1 = csr;
171086 if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
171089 assert( ExprUseXList(pWin->pOwner) );
171090 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
171094 bInverse, regArg, pWin->regAccum);
171097 if( pWin->bExprArgs ){
171115 ** pMWin. Or, for built-in window-functions that do not use the standard
171119 Parse *pParse = p->pParse;
171120 Window *pMWin = p->pMWin;
171124 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171125 if( pMWin->regStartRowid==0
171126 && (pWin->pWFunc->funcFlags & SQLITE_FUNC_MINMAX)
171127 && (pWin->eStart!=TK_UNBOUNDED)
171129 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171130 sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
171132 sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
171133 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
171134 }else if( pWin->regApp ){
171135 assert( pMWin->regStartRowid==0 );
171139 sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
171140 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
171141 sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
171142 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171144 sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult);
171145 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
171153 ** p->pMWin list by doing a full scan of the current window frame. Store the
171159 Parse *pParse = p->pParse;
171160 Window *pMWin = p->pMWin;
171161 Vdbe *v = p->pVdbe;
171177 csr = pMWin->csrApp;
171178 nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0);
171190 sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid);
171191 windowReadPeerValues(p, pMWin->iEphCsr, regCPeer);
171193 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171194 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171197 sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid);
171201 sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid);
171204 if( pMWin->eExclude==TK_CURRENT ){
171207 }else if( pMWin->eExclude!=TK_NO ){
171212 if( pMWin->pOrderBy ){
171213 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
171215 if( pMWin->eExclude==TK_TIES ){
171232 windowAggStep(p, pMWin, csr, 0, p->regArg);
171237 sqlite3VdbeJumpHere(v, addrNext-1);
171251 ** Invoke the sub-routine at regGosub (generated by code in select.c) to
171255 ** for per-row processing is only generated for the following built-in window
171264 Window *pMWin = p->pMWin;
171265 Vdbe *v = p->pVdbe;
171267 if( pMWin->regStartRowid ){
171270 Parse *pParse = p->pParse;
171273 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171274 FuncDef *pFunc = pWin->pWFunc;
171275 assert( ExprUseXList(pWin->pOwner) );
171276 if( pFunc->zName==nth_valueName
171277 || pFunc->zName==first_valueName
171279 int csr = pWin->csrApp;
171282 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171284 if( pFunc->zName==nth_valueName ){
171285 sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg);
171290 sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg);
171291 sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg);
171295 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
171299 else if( pFunc->zName==leadName || pFunc->zName==lagName ){
171300 int nArg = pWin->pOwner->x.pList->nExpr;
171301 int csr = pWin->csrApp;
171304 int iEph = pMWin->iEphCsr;
171307 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171309 sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult);
171313 int val = (pFunc->zName==leadName ? 1 : -1);
171316 int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
171318 sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2);
171325 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
171331 sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub);
171337 ** any equivalent initialization required by any built-in window functions
171345 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171346 FuncDef *pFunc = pWin->pWFunc;
171347 assert( pWin->regAccum );
171348 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171350 if( pMWin->regStartRowid==0 ){
171351 if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
171352 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
171353 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
171356 if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){
171357 assert( pWin->eStart!=TK_UNBOUNDED );
171358 sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
171359 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
171363 regArg = pParse->nMem+1;
171364 pParse->nMem += nArg;
171374 if( pMWin->regStartRowid ) return 1;
171375 for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
171376 FuncDef *pFunc = pWin->pWFunc;
171377 if( (pFunc->zName==nth_valueName)
171378 || (pFunc->zName==first_valueName)
171379 || (pFunc->zName==leadName)
171380 || (pFunc->zName==lagName)
171390 ** pOrderBy->nExpr. This function generates code to compare the two
171407 int nVal = pOrderBy->nExpr;
171415 sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
171430 ** operator in the above pseudo-code is replaced with ">" or "<=", respectively.
171432 ** If the sort-order for the ORDER BY term in the window is DESC, then the
171434 ** subtracted. And the comparison operator is inverted to - ">=" becomes "<=",
171438 ** if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl;
171448 int regVal, /* Register containing non-negative number */
171452 Parse *pParse = p->pParse;
171454 ExprList *pOrderBy = p->pMWin->pOrderBy; /* ORDER BY clause for window */
171457 int regString = ++pParse->nMem; /* Reg. for constant value '' */
171463 /* Read the peer-value from each cursor into a register */
171468 assert( pOrderBy && pOrderBy->nExpr==1 );
171469 if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_DESC ){
171479 reg1, (arith==OP_Add ? "+" : "-"), regVal,
171502 if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_BIGNULL ){
171517 default: assert( op==OP_Lt ); /* no-op */ break;
171528 /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
171531 ** then leave reg1 as it is. In pseudo-code, this is implemented as:
171534 ** reg1 = reg1 +/- regVal
171537 ** Since all strings and blobs are greater-than-or-equal-to an empty string,
171554 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
171583 Parse *pParse = p->pParse;
171584 Window *pMWin = p->pMWin;
171586 Vdbe *v = p->pVdbe;
171588 int bPeer = (pMWin->eFrmType!=TK_ROWS);
171593 /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame
171595 if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){
171601 if( pMWin->eFrmType==TK_RANGE ){
171605 if( pMWin->eStart==TK_FOLLOWING ){
171607 p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
171611 p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
171616 p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone
171625 if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){
171636 if( pMWin->eStart==pMWin->eEnd && regCountdown
171637 && pMWin->eFrmType==TK_RANGE
171642 sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
171643 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
171646 }else if( p->regRowid ){
171647 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1);
171648 sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1);
171653 assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING );
171658 csr = p->current.csr;
171659 reg = p->current.reg;
171664 csr = p->start.csr;
171665 reg = p->start.reg;
171666 if( pMWin->regStartRowid ){
171667 assert( pMWin->regEndRowid );