Lines Matching defs:not
5 ** unit. This allows many compilers to do optimizations that would not be
12 ** the programming interface to the SQLite library. (If you do not have
35 ** May you do good and not evil.
59 ** without this option, LFS is enable. But LFS does not exist in the kernel
89 ** May you do good and not evil.
122 ** not have more than a dozen or so columns in any table. And if
134 ** turn the limit off. That is no longer true. It is not possible
147 ** A value of 0 used to mean that the limit was not enforced.
226 ** compiled with the default page-size limit will not be able to rollback
284 ** A value of 1 means that a trigger program will not be able to itself
333 ** Unfortunately, that typedef is not available on all compilers, or
377 ** It determines whether or not the features related to
378 ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
413 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
429 ** not doing a threadsafe build. Ticket #2681.
493 ** to setup for a later assert() statement. We do not want this code to
518 ** not be counted as untested code.
560 ** May you do good and not evil.
567 ** or constant definition does not appear in this file, then it is
568 ** not a published API of SQLite, is subject to change without
569 ** notice, and should not be referenced by programs that use SQLite.
573 ** features recently added to SQLite. We do not anticipate changes
613 ** should not use deprecated interfaces - they are support for backwards
627 ** Ensure these symbols were not defined by some previous header file.
688 ** function is provided for use in DLLs since DLL users usually do not have
740 ** the mutexes are omitted. Without the mutexes, it is not safe
759 ** thread safety, not any run-time changes to that setting made by
839 ** [sqlite3_open_v2()], and not previously closed.
848 ** compatibility and is not documented.
864 ** sqlite3_exec() is not NULL, then it is invoked for each result row
874 ** is not NULL then any error message is written into memory obtained
879 ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
900 ** is not changed.
907 ** <li> The application must not close [database connection] specified by
909 ** <li> The application must not modify the SQL statement text passed into
957 #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
961 #define SQLITE_NOTADB 26 /* File opened that is not a database file */
973 ** these result codes are too coarse-grained. They do not provide as
1102 ** information need not be flushed. If the lower four bits of the flag
1107 ** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
1159 ** and not its inode needs to be synced.
1188 ** return [SQLITE_NOTFOUND] for file control opcodes that they do not
1270 ** current transaction. This hint is not guaranteed to be accurate but it
1293 ** VFSes do not need this signal and should silently ignore this opcode.
1294 ** Applications should not call [sqlite3_file_control()] with this
1310 ** is not changed but instead the prior value of that setting is written
1319 ** close. Persisting the files is useful when other processes that do not
1364 ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1427 ** that does not care about crash recovery or rollback might make
1452 ** It is <i>not</i> used to indicate the file should be opened
1457 ** argument to xOpen. The xOpen method does not have to
1475 ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
1480 ** interfaces are not strictly a part of the filesystem, but they are
1494 ** greater and the function pointer is not NULL) and will fall back
1498 ** are not used by the SQLite core. These optional interfaces are provided
1506 ** from one release to the next. Applications must not attempt to access
1620 ** SQLite normally do not need to invoke either of these routines.
1635 ** is not. The sqlite3_shutdown() interface must only be called from a
1650 ** SQLite interfaces so that an application usually does not need to
1653 ** initialized when [sqlite3_open()] is called if it has not be initialized
1698 ** applications and so this routine is usually not necessary. It is
1701 ** The sqlite3_config() interface is not threadsafe. The application
1791 ** the xInit method, so the xInit method need not be threadsafe. The
1793 ** not need to be threadsafe either. For all other methods, SQLite
1837 ** it is not possible to change the [threading mode] from its default
1852 ** it is not possible to set the Multi-thread [threading mode] and
1868 ** it is not possible to set the Serialized [threading mode] and
1923 ** This configuration should not be used if an application-define page
1950 ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
2007 ** and a pointer to void. ^If the function pointer is not NULL, it is
2017 ** The SQLite logging interface is not reentrant; the logger function
2018 ** supplied by the application must not invoke any SQLite interface.
2028 ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
2080 ** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
2083 ** connection is not currently using lookaside memory, or in other words
2098 ** which case the FK enforcement setting is not reported back. </dd>
2108 ** which case the trigger setting is not reported back. </dd>
2132 ** names are not also used by explicitly declared columns. ^If
2150 ** ^An [INSERT] that fails due to a constraint violation is not a
2151 ** successful [INSERT] and does not change the value returned by this
2155 ** encounters a constraint violation, it does not fail. The
2170 ** unpredictable and might not equal either the old or the new
2183 ** triggers or [foreign key actions] are not counted.)^ Use the
2188 ** are not counted. Only real table changes are counted.
2194 ** mechanisms do not count as direct row changes.)^
2205 ** not create a new trigger context.
2217 ** However, the number returned does not include changes
2225 ** is unpredictable and not meaningful.
2237 ** the count does not include changes used to implement [REPLACE] constraints,
2239 ** count does not include rows of views that fire an [INSTEAD OF trigger],
2251 ** returned is unpredictable and not meaningful.
2266 ** is not safe to call this routine with a [database connection] that
2270 ** sqlite3_interrupt() is called, then it might not have an opportunity
2284 ** not effected by the sqlite3_interrupt().
2302 ** complete if it ends with a semicolon token and is not a prefix of a
2304 ** string literals or quoted identifier names or comments are not
2306 ** embedded) and thus do not count as a statement terminator. ^Whitespace
2312 ** ^These routines do not parse the SQL statements thus
2313 ** will not detect syntactically incorrect SQL.
2315 ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
2319 ** regardless of whether or not the input SQL is complete.)^
2339 ** is not NULL, then the callback might be invoked with two arguments.
2350 ** The presence of a busy handler does not guarantee that it will be invoked
2369 ** changes will not fit into the in-memory cache. SQLite will
2387 ** The busy callback should not take any actions which modify the
2391 ** A busy handler must not close the database connection
2420 ** Use of this interface is not recommended.
2427 ** these numbers are not part of the result table itself. These
2439 ** It is not safe to pass a result table directly to [sqlite3_free()].
2477 ** function must not try to call [sqlite3_free()] directly. Only
2481 ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
2484 ** wrapper layer outside of the internal [sqlite3_exec()] call are not
2602 ** does not include operating-system specific VFS implementation. The
2621 ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
2638 ** is not freed.
2661 ** not yet been released.
2663 ** The application must not read or write any part of
2679 ** of memory currently outstanding (malloced but not freed).
2685 ** but not overhead added by the any underlying system library
2762 ** do not try to access data they are not allowed to see, or that they do not
2766 ** not want the user to be able to make arbitrary changes to the
2781 ** The authorizer callback must not do anything that will modify
2792 ** [sqlite3_prepare()] or its variants. Authorization is not
2808 ** to signal SQLite whether or not the action is permitted. See the
2925 ** The progress handler callback must not do anything that will modify
2953 ** Whether or not an error occurs when it is opened, resources
2967 ** <dd>The database is opened in read-only mode. If the database does not
2977 ** it does not already exist. This is the behavior that is always used for
2981 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
2988 ** mode has not been set at compile-time or start-time. ^If the
2993 ** eligible to use [shared cache mode], regardless of whether or not shared
2995 ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
3030 ** "localhost". ^If the authority is not an empty string or "localhost", an
3036 ** then it is interpreted as an absolute path. ^If the path does not begin
3061 ** "rw", then the database is opened for read-write (but not create)
3062 ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
3079 ** ^Specifying an unknown parameter in the query component of a URI is not an
3095 ** An error. "darkstar" is not a recognized authority.
3099 ** C:. Note that the %20 escaping in this example is not strictly
3104 ** Regardless of whether or not shared-cache mode is enabled by
3109 ** An error. "readonly" is not a valid option for the "mode" parameter.
3122 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3152 ** parameter if it exists. If the parameter does not exist, this routine
3155 ** If the zFilename argument to this function is not a pointer that SQLite
3177 ** The application does not need to worry about freeing the result.
3193 ** error code and message may or may not be set.
3245 ** ^Regardless of whether or not the limit was changed, the
3296 ** used to implement an SQL statement. This limit is not currently
3340 ** [sqlite3_open16()]. The database connection must not have been closed.
3357 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3368 ** ppStmt may not be NULL.
3466 ** But because the [SELECT] statement does not change the database file
3471 ** since the statements themselves do not actually modify the database but
3475 ** change the configuration of a database connection, they do not make
3493 ** whether or not it requires a protected sqlite3_value.
3495 ** The terms "protected" and "unprotected" refer to whether or not
3506 ** sqlite3_value objects even when not strictly required.
3573 ** number of <u>bytes</u> in the value, not the number of characters.)^
3584 ** information is in static, unmanaged space and does not need to be freed.
3604 ** ^Bindings are not cleared by the [sqlite3_reset()] routine.
3658 ** ^The first host parameter has an index of 1, not 0.
3691 ** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
3702 ** statement that does not return data (for example an [UPDATE]).
3762 ** subquery and is not a column value, then all of these functions return
3794 ** returned result set of that [SELECT] is a table column (not an
3812 ** is declared to contain a particular type does not mean that the
3814 ** strongly typed, but the typing is dynamic not static. ^Type
3815 ** is associated with individual values, not with the containers
3844 ** statement. If the statement is not a [COMMIT] and occurs within an
3849 ** successfully. sqlite3_step() should not be called again on this virtual
3859 ** violation) has occurred. sqlite3_step() should not be called again on
3881 ** than returning [SQLITE_MISUSE]. This is not considered a compatibility
3905 ** ^If prepared statement P does not have results ready to return
3932 ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
3961 ** If the SQL statement does not currently point to a valid row, or if the
4002 ** [sqlite3_column_bytes16()] do not include the zero terminators at the end
4005 ** bytes in the string, not the number of characters.
4049 ** and atof(). SQLite does not really use these functions. It has its
4073 ** not invalidate a prior pointer, though of course the content of the buffer
4076 ** are not possible and in those cases prior pointers are invalidated.
4090 ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
4092 ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
4098 ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned
4133 ** to [sqlite3_step()] regardless of whether or not the statement has
4167 ** ^The [sqlite3_reset(S)] interface does not change the values
4194 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
4215 ** If there is only a single implementation which does not care what text
4230 ** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
4256 ** SQLite interfaces. However, such calls must not
4313 ** using these functions, we are not going to tell you what they do.
4407 ** the same aggregate function instance will not resize the memory
4460 ** does not need to be recompiled on each invocation.
4473 ** not been destroyed.
4474 ** ^If it is not NULL, SQLite will invoke the destructor
4500 ** and will never change. It does not need to be destroyed. ^The
4549 ** bytes (not characters) from the 2nd parameter as the error message.
4586 ** is non-negative, then as many bytes (not characters) of the text
4595 ** assumes that the text or BLOB result is in constant space and does not
4702 ** ^The xDestroy callback is <u>not</u> called if the
4778 ** The code to implement this API is not available in the public release
4787 ** Change the key on an open database. If the current database is not
4791 ** The code to implement this API is not available in the public release
4824 ** If the operating system does not support sleep requests with
4831 ** of the default VFS is not implemented correctly, or not implemented at
4847 ** It is not safe to read or modify this variable in more than one
4848 ** thread at a time. It is not safe to read or modify this variable
4873 ** zero if the given database connection is or is not in autocommit mode,
4914 ** connection and in particular must not be a NULL pointer.
4938 ** The callback implementation must not do anything that will modify
4957 ** ^The rollback callback is not invoked if a transaction is
4986 ** ^(The update hook is not invoked when internal system tables are
4990 ** is not invoked when duplication rows are deleted because of an
4996 ** The update hook implementation must not do anything that will modify
5056 ** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5081 ** ^(The soft heap limit is not enforced in the current implementation
5097 ** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
5172 ** not null: 0
5210 ** ^If an error occurs and pzErrMsg is not 0, then the
5226 char **pzErrMsg /* Put error message here if not 0 */
5232 ** ^So as not to open security holes in older applications that are
5292 ** If this is a problem for you, do not use the interface at this time.
5319 ** of this structure must not change while it is registered with
5394 ** virtual table and is not checked again by SQLite.)^
5427 unsigned char omit; /* Do not code a test for this constraint */
5469 ** invoke the destructor function (if it is not NULL) when SQLite
5559 ** the new function is not good for anything by itself. Its only
5569 ** If this is a problem for you, do not use the interface at this time.
5602 ** ^It is not possible to open a column that is part of an index or primary
5604 ** not possible to open a column that is part of a [child key] for writing.
5606 ** ^Note that the database name is not the filename that contains
5628 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
5633 ** the opened blob. ^The size of a blob may not be changed by this
5667 ** the nominated column.)^ ^If the new row is not present in the table, or if
5668 ** it does not contain a blob or text value, or if another error occurs, an
5712 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5738 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5753 ** ^If the [BLOB handle] passed as the first argument was not opened for
5758 ** not possible to increase the size of a BLOB using this API.
5767 ** before the [BLOB handle] expired are not rolled back by the
5776 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5853 ** that means that a mutex could not be allocated. ^SQLite
5871 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
5872 ** The mutex implementation does not need to make a distinction
5874 ** not want to. ^SQLite will only request a recursive mutex in
5896 ** dynamic mutex that it allocates. The dynamic mutexes must not be in
5914 ** ^(Some systems (for example, Windows 95) do not support the operation
5921 ** is undefined if the mutex is not currently entered by the
5922 ** calling thread or is not currently allocated. SQLite will
5946 ** does not provide a suitable implementation. In this case, the user
5982 ** by this structure are not required to handle this case, the results
5992 ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
5993 ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
6025 ** defined and if NDEBUG is not defined.
6028 ** is held or not held, respectively, by the calling thread.
6030 ** ^The implementation is not required to provided versions of these
6031 ** routines that actually work. If the implementation does not provide working
6033 ** return true so that one does not get spurious assertion failures.
6037 ** clearly the mutex cannot be held if it does not exist. But
6038 ** the reason the mutex does not exist is because the build is not
6039 ** using mutexes. And we do not want the assert() containing the
6100 ** case is a short-circuit path which does not actually invoke the
6103 ** ^If the second parameter (zDbName) does not match the name of any
6105 ** code is not remembered and will not be recalled by [sqlite3_errcode()]
6123 ** This interface is not for use by applications. It exists solely
6125 ** on how the SQLite library is compiled, this interface might not exist.
6129 ** Unlike most of the SQLite API, this function is not guaranteed to
6142 ** Applications should not use any of these parameters or the
6174 ** *pHighwater is written. ^(Some parameters do not record the highest
6177 ** ^(Other parameters record only the highwater mark and not the current
6183 ** This routine is threadsafe but is not atomic. This routine can be
6209 ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
6228 ** value returned is in pages, not in bytes.</dd>)^
6233 ** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
6249 ** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not
6256 ** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
6432 ** improvement performance by adding permanent indices that do not
6497 ** so the xInit method need not be threadsafe. ^The
6499 ** not need to be threadsafe either. All other methods must be threadsafe
6508 ** though this is not guaranteed. ^The
6510 ** be allocated by the cache. ^szPage will not be a power of two. ^szPage
6522 ** does not have to do anything special based with the value of bPurgeable;
6535 ** parameter, the implementation is not required to do anything with this
6552 ** intact. If the requested page is not already in the cache, then the
6557 ** <tr><th> createFlag <th> Behaviour when page is not already in cache
6558 ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
6580 ** The cache must not perform any reference counting. A single
6588 ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
6601 ** handle invalid, and will not use it with any other sqlite3_pcache_methods
6643 ** it is not locked continuously for the entire backup operation.
6729 ** on the destination file. ^The exclusive lock is not released until either
6734 ** ^Because the source database is not locked between calls to
6751 ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
6754 ** and may not be used following a call to sqlite3_backup_finish().
6757 ** sqlite3_backup_step() errors occurred, regardless or whether or not
6764 ** is not a permanent error and does not affect the return value of
6778 ** operation, then the values are not updated to account for any extra
6791 ** [database connection] is not passed to any other API (by any thread) after
6793 ** sqlite3_backup_finish(). SQLite does not currently check to see
6801 ** is not accessed while the backup is running. In practice this means
6803 ** backed up to is not accessed by any connection within the process,
6804 ** not just the specific connection that was passed to sqlite3_backup_init().
6809 ** APIs are not strictly speaking threadsafe. If they are invoked at the
6872 ** The unlock-notify callback is not reentrant. If an application invokes
6968 ** The zFormat string must not be NULL.
6971 ** will not use dynamically allocated memory. The log message is stored in
7003 ** that does not correspond to any valid SQLite error code, the results
7052 ** connection D. ^If the database connection D is not in
7083 ** but not database readers.
7091 ** but not database readers.
7094 ** If pnLog is not NULL, then *pnLog is set to the total number of frames in
7095 ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7105 ** busy-handler configured, it will not be invoked in this case.
7129 ** If database zDb is the name of an attached database that is not in WAL
7131 ** zDb is not NULL (or a zero length string) and is not the name of any
7182 ** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not
7204 ** return SQLITE_OK. Or, if this is not possible, it may return
7261 ** May you do good and not evil.
7322 ** May you do good and not evil.
7339 ** code should not attempt to access or modify the fields of this structure
7634 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
7642 ** GCC does not define the offsetof() macro so we'll have to do it
7651 ** not, there are still machines out there that use EBCDIC.)
7823 ** not support Writable Static Data (WSD) such as global and static variables.
7852 ** implementation of an SQL aggregate step callback may not use the
7856 ** When a function parameter is not used at all within the body of a function,
7859 ** parameters that may or may not be used depending on compilation options.
7926 ** May you do good and not evil.
7951 #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
7978 #define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */
8122 ** If we are not using shared cache, then there is no need to
8172 ** May you do good and not evil.
8269 #define P4_NOTUSED 0 /* The P4 parameter is not used */
8292 ** function should *not* try to free the KeyInfo.
8330 /* Automatically generated. Do not edit */
8600 ** May you do good and not evil.
8624 ** is called page 1. 0 is used to represent "not a page".
8653 #define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */
8786 ** May you do good and not evil.
8817 ** and should not be accessed by other modules.
8832 #define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */
8947 ** May you do good and not evil.
9043 /* If the SET_FULLSYNC macro is not defined above, then make it
9075 ** enough to know that calling the developer will not help get rid
9094 ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
9109 ** those functions are not available. So we use only LockFile() and
9112 ** LockFile() prevents not just writing but also reading by other processes.
9154 ** file format. Depending on how it is changed, you might not notice
9231 ** May you do good and not evil.
9242 ** NOTE: source files should *not* #include this header file directly.
9311 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
9394 ** lookaside allocations are not used to construct the schema objects.
9425 ** insert statement. Inserts on views do not affect its value. Each
9431 ** The sqlite.nChange does not count changes within triggers and keeps no
9437 ** within a trigger is not seen outside the trigger. Changes to views do not
9460 u8 suppressErr; /* Do not issue error messages if true */
9535 int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
9539 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
9578 #define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */
9645 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
9777 ** collating sequence may not be read or written.
9846 ** implementation. sqlite3_vtab* handles can not be shared between
9865 ** schema is being reloaded for some reason), the VTable objects are not
9866 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
9895 ** CREATE TABLE statement is stored, but case is not significant for
9915 ** refers VDBE cursor number that holds the table open, not to the root
9922 int iPKey; /* If not negative, use aCol[iPKey] as the primary key */
9963 ** Test to see whether or not a table is a virtual table. This is
9991 ** which is attached to the from-table. The to-table need not exist when
9992 ** the from-table is created. The existence of the to-table is not checked.
10017 ** but the transaction is not rolled back. FAIL processing means that
10019 ** changes due to the same operation are not backed out and no rollback
10021 ** error is not inserted or updated. Processing continues and no error
10040 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
10115 ** The Index.onError field determines whether or not the indexed columns
10116 ** must be unique and what to do if they are not. When Index.onError=OE_None,
10117 ** it means this is not a unique index. Otherwise it is a unique index
10158 ** may contain random values. Do not make any assumptions about Token.dyn
10177 ** fields do not need to be freed when deallocating the AggInfo structure.
10288 ** allocated, regardless of whether or not EP_Reduced is set.
10292 char affinity; /* The affinity of the column or 0 if not a column */
10341 #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */
10351 #define EP_Static 0x4000 /* Held in memory not obtained from malloc() */
10363 ** so as not to burden production code.
10401 ** field is not used.
10552 ** is intended to be private the the where.c module and should not be
10584 /* The following field is really not part of the current level. But
10604 #define WHERE_FORCE_TABLE 0x0040 /* Do not use an index-only search */
10675 ** limit and nOffset to the value of the offset (or 0 if there is not
10683 ** as the OP_OpenEphm instruction is coded because not
10702 Expr *pLimit; /* LIMIT expression. NULL means not used. */
10703 Expr *pOffset; /* OFFSET expression. NULL means not used. */
10728 #define SRT_Exists 3 /* Store 1 if the result is not empty */
10729 #define SRT_Discard 4 /* Do not save the results anywhere */
10759 ** information in case inserts are down within triggers. Triggers do not
11048 ** do not necessarily know how big the string will be in the end.
11753 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
11787 ** is not defined.
11875 ** that allocations that might have been satisfied by lookaside are not
11896 #define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */
11908 ** May you do good and not evil.
11920 ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
11986 ** non-ASCII UTF character. Hence the test for whether or not a character is
12130 ** May you do good and not evil.
12494 ** was used and false if not.
12497 ** is not required for a match.
12534 ** May you do good and not evil.
12551 ** May you do good and not evil.
12646 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
12705 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
12733 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
12754 ** Return true if a memory cell is not marked as invalid. This macro
12856 int iStatement; /* Statement number (or 0 if has not opened stmt) */
12866 FILE *trace; /* Write an execution trace here, if not NULL */
13059 ** 32-bit integer is an atomic operation. If that assumption is not true,
13060 ** then this routine is not threadsafe.
13215 ** May you do good and not evil.
13341 ** A missing specifier is not considered an error.
13463 ** on success and 1 if the input string is not a well-formed
13613 ** If the user has not indicated to use localtime_r() or localtime_s()
14342 ** May you do good and not evil.
14355 ** The default SQLite sqlite3_vfs implementations do not allocate
14522 ** (if iVersion is 2 or greater and the function pointer is not NULL) and
14675 ** May you do good and not evil.
14688 ** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily
14690 ** is completely recoverable simply by not carrying out the resize. The
14764 ** May you do good and not evil.
14772 ** here always fail. SQLite will not operate with these drivers. These
14825 ** May you do good and not evil.
14977 ** May you do good and not evil.
15080 int disallow; /* Do not allow memory allocation */
15507 ** May you do good and not evil.
15529 ** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
15550 ** a header that is not returned to the user.
15562 ** not be read or written.
15625 ** of the current master. iMaster is 0 if there is not master chunk.
15626 ** The master chunk is not in either the aiHash[] or aiSmall[].
15717 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
15767 ** is not large enough, return 0.
15809 ** linked into the hash tables. That is not the normal state of
16113 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
16170 ** is not required to be threadsafe (it is not).
16196 ** May you do good and not evil.
16264 ** it is not actually possible to reach this limit.
16272 #define CTRL_FREE 0x20 /* True if not checked out */
16374 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
16455 ** block. If not, then split a block of the next larger power of
16640 ** This routine is not threadsafe. The caller must be holding a mutex
16662 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
16779 ** May you do good and not evil.
16806 /* If the xMutexAlloc method has not been set, then the user did not
16902 ** is not currently entered. If a NULL pointer is passed as an argument
16934 ** May you do good and not evil.
16941 ** This implementation in this file does not provide any mutual
16999 ** and debugging purposes. The mutexes still do not provide any
17033 ** that means that a mutex could not be allocated.
17095 ** is undefined if the mutex is not currently entered or
17096 ** is not currently allocated. SQLite will never do either.
17142 ** May you do good and not evil.
17188 ** that means that a mutex could not be allocated.
17205 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17206 ** The mutex implementation does not need to make a distinction
17208 ** not want to. But SQLite will only request a recursive mutex in
17377 ** is undefined if the mutex is not currently entered or
17378 ** is not currently allocated. SQLite will never do either.
17418 ** May you do good and not evil.
17471 ** not an atomic operation, then these routines might delivery
17474 ** told that HPUX is not such a platform. If so, then these routines
17475 ** will not always work correctly on HPUX.
17477 ** On those platforms where pthread_equal() is not atomic, SQLite
17500 ** that means that a mutex could not be allocated. SQLite
17517 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17518 ** The mutex implementation does not need to make a distinction
17520 ** not want to. But SQLite will only request a recursive mutex in
17554 /* If recursive mutexes are not available, we will have to
17622 /* If recursive mutexes are not available, then we have to grow
17626 ** that are not equal to self while the comparison is taking place.
17630 ** are not met, then the mutexes will fail and problems will result.
17665 /* If recursive mutexes are not available, then we have to grow
17669 ** that are not equal to self while the comparison is taking place.
17673 ** are not met, then the mutexes will fail and problems will result.
17714 ** is undefined if the mutex is not currently entered or
17715 ** is not currently allocated. SQLite will never do either.
17771 ** May you do good and not evil.
17812 ** WinNT/2K/XP so that we will know whether or not we can safely call
17870 ** processing, the "interlocked" magic is probably not
17910 ** that means that a mutex could not be allocated. SQLite
17927 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17928 ** The mutex implementation does not need to make a distinction
17930 ** not want to. But SQLite will only request a recursive mutex in
18055 ** is undefined if the mutex is not currently entered or
18056 ** is not currently allocated. SQLite will never do either.
18105 ** May you do good and not evil.
18118 ** cache database pages that are not currently in use.
18125 ** is a no-op returning zero if SQLite is not compiled with
18440 ** This routine is similar to alloca() in that it is not intended
18443 ** structures that would not normally fit on the stack of an
18858 ** If the first argument, db, is not NULL and a malloc() error has occurred,
18863 /* If the db handle is not NULL, then we must hold the connection handle
18944 /* The rest are extensions, not normally found in printf() */
19474 ** Note that the number is in the usual order, not reversed as with
19480 ** set and we are not left justified */
19563 ** consume, not the length of the output...
19815 ** are not able to use a "," as the decimal point in place of "." as
19877 ** The printf() built into some versions of windows does not understand %lld
19915 ** May you do good and not evil.
19941 ** Why not just use a library random generator like lrand48() for this?
19944 ** well be good enough. But maybe not. Or maybe lrand48() has some
19950 ** (Later): Actually, OP_NewRowid does not depend on a good source of
19973 ** not need to contain a lot of randomness since we are not
19978 ** number generator) not as an encryption device.
20062 ** May you do good and not evil.
20205 ** for unicode values 0x80 and greater. It do not change over-length
20255 ** encoding, or if *pMem does not contain a string value.
20395 ** the encoding of the Mem adjusted. This routine does not do any
20434 ** return the number of unicode characters in pZ up to (but not including)
20435 ** the first 0x00 byte. If nByte is not less than zero, return the
20456 /* This test function is not currently used by the automated test-suite.
20623 ** May you do good and not evil.
20662 ** found that many systems do not have a working isnan() function so
20683 # error SQLite will not work correctly with the -ffast-math option of GCC.
20715 ** If it is not NULL, string zFormat specifies the format of the
20785 ** input does not begin with a quote character, then this routine
20859 ** The string z[] is length bytes in length (bytes, not characters) and
20860 ** uses the encoding enc. The string is not necessarily zero-terminated.
20887 int eValid = 1; /* True exponent is either not used or is well-formed */
21068 ** If zNum is too big for a 64-bit integer and is not
21071 ** length is the number of bytes in the string (bytes, not characters).
21072 ** The string is not necessarily zero-terminated. The encoding is
21181 ** string is not an integer, just return 0.
21556 ** file. In that case we are not in any hurry. Use the (relatively
21642 ** not have been used. The "type" of connection pointer is given as the
21653 ** Check to make sure we have a valid db pointer. This test is not
21657 ** 1 it means that the db pointer is valid and 0 if it should not be
21663 ** open properly and is not fit for general use but which can be
21805 ** May you do good and not evil.
21898 ** Return TRUE if the resize occurs and false if not.
21912 ** a performance hit but it is not a fatal error. So mark the
21939 int nKey, /* Bytes in key (not counting zero terminator) */
22024 ** The key is not copied in this instance. If a malloc fails, then
22078 /* Automatically generated. Do not edit */
22246 ** May you do good and not evil.
22264 ** malloc failures happen frequently. OS/2 does not typically run on
22266 ** problems to worry about than running out of memory. So there is not
22269 ** But there is a good reason to not use the wrappers. If we use the
22273 ** the OS driver, but the code to deal with those failure would not
22274 ** be exercised on Linux (which does not need to malloc() in the driver)
22281 ** desktops but not so well in embedded systems.
22285 ** Macros used to determine whether or not to use threads.
22302 ** May you do good and not evil.
22312 ** This file should be #included by the os_*.c files only. It is not a
22320 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
22355 ** May you do good and not evil.
22760 ** It is not possible to lower the locking level one step at a time. You
22804 /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
22942 ** It is not possible for this routine to fail if the second argument
23322 ** Find an os2ShmNode in global list or allocate a new one, if not found.
23324 ** This is not a VFS shared-memory method; it is a utility function called
23429 ** This is not a VFS shared-memory method; it is a utility function called
23502 ** region has not been allocated (by any client, including one running in a
23504 ** bExtend is non-zero and the requested shared-memory region has not yet
23509 ** address space (if it is not already), *pp is set to point to the mapped
23628 ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n",
23650 ** not go from shared to exclusive or from exclusive to shared.
23855 * Trailing spaces are not allowed, either. */
23988 ** The handle should not be inherited by child processes and we don't
23999 /* Creates a new file, only if it does not already exist. */
24095 ** as if it does not exist.
24137 ** os2Dlopen returns zero if DosLoadModule is not successful.
24147 /* if the symbol itself was not found, search again for the same
24219 ** might be greater than or equal to the argument, but not less
24310 ** then it is not necessary to include the nul-terminator character
24380 ** May you do good and not evil.
24411 ** * sqlite3_file methods not associated with locking.
24467 ** without this option, LFS is enable. But LFS does not exist in the kernel
24551 ** Only set the lastErrno if the error code is a real error and not
24602 /* The next group of variables are used to track whether or not the
24644 ** May you do good and not evil.
24654 ** This file should be #included by the os_*.c files only. It is not a
24662 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
24697 ** May you do good and not evil.
24917 ** that always succeeds. This means that locking does not occur under
25037 ** Return the value of a system call. Return NULL if zName is not a
25057 ** is the last system call or if zName is not the name of a valid
25211 /* At one point this code was not commented out. In theory, this branch
25236 /* EACCES is like EAGAIN during locking operations, but not any other time*/
25274 #ifdef ESTALE /* ESTALE is not defined on Interix systems */
25291 ** the device number and the inode number. But this does not work on VxWorks.
25300 ** There are never very many files open at one time and lookups are not
25431 ** by the same process. It does not explicitly say so, but this implies
25443 ** But not so. Since both locks came from the same process, the
25449 ** to synchronize access for threads in separate processes, but not
25461 ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
25494 ** Yet another problem: LinuxThreads do not play well with posix locks.
25497 ** not posix compliant. Under LinuxThreads, a lock created by thread
25504 ** compile-time whether or not thread A can override locks on thread B.
25512 ** do not move across threads.
25588 /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
25615 /* This is a threadsafe build, but strerror_r() is not available. */
25640 ** Note that it is not safe to retry close() after EINTR since the
25735 ** around this problem (we consider it a bug in OS X, not SQLite)
25844 ** operating system does not participate.
25929 ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
25940 ** range' is that some versions of windows do not support read-locks. By
26098 ** write operation (not a hot journal rollback).
26182 ** file changed. If the transaction counter is not updated,
26183 ** other connections to the same file might not realize that
26184 ** the file has changed and hence might not know to flush their
26261 ** indicates that the other process is not following the locking
26340 ** It is *not* necessary to hold the mutex when this routine is called,
26380 /* If there are outstanding locks, do not actually close the file just
26471 ** In dotfile locking, either a lock exists or it does not. So in this
27388 ** file changed. If the transaction counter is not updated,
27389 ** other connections to the same file might not realize that
27390 ** the file has changed and hence might not know to flush their
27466 /* If there are outstanding locks, do not actually close the file just
27484 ** to MacOSX and does not work on other unix platforms. No alternative
27486 ** VFS is not available.
27509 ** to MacOSX and does not work on other unix platforms. No alternative
27531 ** one system to another. Since SQLite does not define USE_PREAD
27532 ** any any form by default, we will not attempt to define _XOPEN_SOURCE.
27586 /* If this is a database file (not a journal, master-journal or temp
27602 pFile->lastErrno = 0; /* not a system error */
27666 /* If this is a database file (not a journal, master-journal or temp
27710 pFile->lastErrno = 0; /* not a system error */
27728 ** We do not trust systems to provide a working fdatasync(). Some do.
27738 ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
27750 ** The fsync() system call does not work as advertised on many
27756 ** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
27762 ** to disk, not the inode. We only set dataOnly if the file size is
27766 ** and fsync(), Ted tells us, is that fdatasync() will not flush the
27768 ** We only care about the file size, not the other file attributes, so
27850 ** are flushed to disk. Such fsyncs are not needed on newer
27894 ** If we do not do this and we encounter a power failure, the directory
27895 ** entry for the journal might not exist after we reboot. The next
27896 ** SQLite to access the file will not know that the journal exists (because
27898 ** will not roll back - possibly leading to database corruption.
27913 ** line is to test that doing so does not cause any problems.
28047 /* If the OS does not have posix_fallocate(), fake it. First use
28051 ** on systems that do not have a real fallocate() system call.
28169 ** every open file that does not use shared memory (in other words, most
28312 ** This is not a VFS shared-memory method; it is a utility function called
28354 ** meaning that their memory would not really be shared - resulting
28371 ** that case, we do not really need shared memory. No shared memory
28454 ** If not, truncate the file to zero length.
28508 ** region has not been allocated (by any client, including one running in a
28510 ** bExtend is non-zero and the requested shared-memory region has not yet
28515 ** address space (if it is not already), *pp is set to point to the mapped
28530 /* If the shared-memory file has not yet been opened, open it now. */
28552 /* The requested region is not mapped into this processes address space.
28562 /* The requested memory region does not exist. If bExtend is set to
28627 ** not go from shared to exclusive or from exclusive to shared.
29009 ** that does not need to be locked. */
29062 ** that does not need to be locked. */
29121 /* Usually the path zFilename should not be a relative pathname. The
29189 ** If scenario (a) caused the error then things are not so safe. The
29210 ** according to requirement F11141. So we do not need to make a
29338 ** name. If it is not, return SQLITE_ERROR.
29367 ** file (not a journal or master-journal file) identified by pathname
29372 ** but the associated file descriptor could not be closed because some
29384 /* Do not search for an unused file descriptor on vxworks. Not because
29385 ** vxworks would not benefit from the change (it might, we're not sure),
29387 ** not to risk breaking vxworks support for the sake of such an obscure
29399 ** not searching for a resusable file descriptor are not dire. */
29428 ** returned and the value of *pMode is not modified.
29443 ** FAT filesystems and permissions do not matter there, so just use
29602 ** open(). These must be calculated even if open() is not called, as
29695 ** not while other file descriptors opened by the same process on
29885 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
29898 ** other hand, dlsym() will not work on such a system either, so we have
29899 ** not really lost anything.
29964 ** might be greater than or equal to the argument, but not less
30097 ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
30133 ** Once a lock proxy is configured for a database connection, it can not
30135 ** the above APIs (assuming the conch file is not being held by another
30156 ** If the conch file does not exist, or it's contents do not match the
30168 ** Requesting the lock proxy does not immediately take the conch, it is
30171 ** opening a connection to a database file does not take a lock on it.
30201 ** lock proxy files, only used when LOCKPROXYDIR is not set.
30209 ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
30316 ** The caller is responsible not only for closing the file descriptor
30333 ** 2. if that fails, and this is a lock file (not-conch), try creating
30719 /* If we created a new conch file (not just updated the contents of a
30977 /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
31045 *(const char **)pArg = ":auto: (not held)";
31058 /* turn off proxy locking - not supported */
31245 ** single thread. The memory allocation and mutex subsystems have not
31247 ** should not be used.
31343 ** to release dynamically allocated objects. But not on unix.
31360 ** May you do good and not evil.
31377 ** malloc failures happen frequently. Win32 does not typically run on
31379 ** problems to worry about than running out of memory. So there is not
31382 ** But there is a good reason to not use the wrappers. If we use the
31386 ** the OS driver, but the code to deal with those failure would not
31387 ** be exercised on Linux (which does not need to malloc() in the driver)
31394 ** desktops but not so well in embedded systems.
31404 ** Macros used to determine whether or not to use threads.
31421 ** May you do good and not evil.
31431 ** This file should be #included by the os_*.c files only. It is not a
31439 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
31474 ** May you do good and not evil.
31787 ** WinNT/2K/XP so that we will know whether or not we can safely call
31965 ** is not required to be threadsafe (it is not).
32146 ** Since the ASCII version of these Windows API do not exist for WINCE,
32147 ** it's important to not reference them for WINCE builds.
32271 ** WindowsCE does not have a localtime() function. So create a
32381 /* If shared memory could not be created, then close the mutex and fail */
32633 ** for being unreasonable so I do not doubt that it might happen. If
32810 ** Used only when SQLITE_NO_SYNC is not defined.
32817 ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or
32834 ** line is to test that doing so does not cause any problems.
32895 ** Different API routines are called depending on whether or not this
32968 ** It is not possible to lower the locking level one step at a time. You
33011 OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
33123 ** It is not possible for this routine to fail if the second argument
33416 ** This is not a VFS shared-memory method; it is a utility function called
33527 ** If not, truncate the file to zero length.
33732 /* MemoryBarrier(); // does not work -- do not know why not */
33746 ** region has not been allocated (by any client, including one running in a
33748 ** isWrite is non-zero and the requested shared-memory region has not yet
33753 ** address space (if it is not already), *pp is set to point to the mapped
33785 /* The requested region is not mapped into this processes address space.
33796 /* The requested memory region does not exist. If isWrite is set to
33963 ** Since the ASCII version of these Windows API do not exist for WINCE,
33964 ** it's important to not reference them for WINCE builds.
33982 ** name. If it is not, return SQLITE_ERROR.
34113 /* Creates a new file, only if it does not already exist. */
34153 ** Since the ASCII version of these Windows API do not exist for WINCE,
34154 ** it's important to not reference them for WINCE builds.
34226 ** Note that windows does not allow a file to be deleted if some other
34257 ** Since the ASCII version of these Windows API do not exist for WINCE,
34258 ** it's important to not reference them for WINCE builds.
34306 ** as if it does not exist.
34326 ** Since the ASCII version of these Windows API do not exist for WINCE,
34327 ** it's important to not reference them for WINCE builds.
34412 ** Since the ASCII version of these Windows API do not exist for WINCE,
34413 ** it's important to not reference them for WINCE builds.
34449 /* GetDiskFreeSpace is not supported under WINCE */
34529 ** Since the ASCII version of these Windows API do not exist for WINCE,
34530 ** it's important to not reference them for WINCE builds.
34697 ** then it is not necessary to include the nul-terminator character
34773 ** May you do good and not evil.
34891 ** If p is NULL (if the bitmap has not been created) or if
34961 /* in hash, if not, try to find a spot for it */
35084 ** 5 N S X Set N bits from S increment X in array only, not in bitvec
35088 ** Opcode 5 works on the linear array only, not on the Bitvec.
35183 ** May you do good and not evil.
35225 ** is not, either fail an assert or return zero. Otherwise, return
35382 int createFlag, /* If true, create page if it does not exist already */
35392 /* If the pluggable cache (sqlite3_pcache*) has not been allocated,
35416 ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
35417 ** cleared), but if that is not possible settle for any other
35590 ** the page object is not dropped.
35634 ** Do not both fixing the pDirtyPrev pointers.
35779 ** May you do good and not evil.
35814 ** Mode 1 uses more memory (since PCache instances are not able to rob
35831 int isBusy; /* Do not run ReleaseMemory() if true */
35846 ** This size (pgsz+200) bytes is not allocated efficiently by some
35853 ** are not allocated directly. Instead, blocks of roughly M*(pgsz+200) bytes
35952 ** fixed at sqlite3_initialize() time and do not require mutex protection.
35974 ** compiling for systems that do not support real WSD.
36068 /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get
36131 ** The block pBlock belongs to list pList but is not currently linked in.
36264 ** this mutex is not held. */
36303 ** Or if it is not completely empty, re-insert it at the start of the
36365 ** for all page cache needs and we should not need to spill the
36429 ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
36552 ** not need to be freed.
36648 ** Whether or not a new page may be allocated by this function depends on
36649 ** the value of the createFlag argument. 0 means do not allocate a new
36664 ** 2. If createFlag==0 and the page is not already in the cache, NULL is
36667 ** 3. If createFlag is 1, and the page is not already in the cache, then
36668 ** return NULL (do not allocate a new page) if any of the following
36769 /* Step 5. If a usable page buffer has still not been found,
36912 ** install the default pluggable cache module, assuming the user has not
36995 ** May you do good and not evil.
37034 ** value added by the INSERT will not be visible to the second TEST.
37107 ** It must be the case that N is sufficient to make a Rowset. If not
37345 ** Convert the list in p->pEntry into a sorted list if it is not
37367 ** routine may not be called again.
37419 ** May you do good and not evil.
37442 ** May you do good and not evil.
37503 /* If the WAL is not empty, return the size of the database. */
37510 /* Undo any frames written (but not committed) to the log */
37565 ** journal. These invariants do not apply for journal_mode=WAL,
37570 ** Otherwise, the page is not synced until the xSync method of the VFS
37626 ** method is a no-op, but that does not change the fact the SQLite will
37634 ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
37711 ** state - the file may or may not be locked and the database size is
37712 ** unknown. The database may not be read or written.
37716 ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
37736 ** transaction is not active). The dbOrigSize and dbFileSize variables
37737 ** may not be trusted at this point.
37739 ** * Even if a read-transaction is not open, it is guaranteed that
37751 ** moving to this state, but the journal file is not written to or opened
37767 ** * The contents of the pager cache have not been modified.
37768 ** * The journal file may or may not be open.
37769 ** * Nothing (not even the first header) has been written to the journal.
37775 ** is opened (if it is not already open) and a header written to the
37776 ** start of it. The database file on disk has not been modified.
37781 ** to it, but the header has not been synced to disk.
37788 ** never enter this state (since they do not modify the database file,
37800 ** It is not possible for a WAL connection to enter this state.
37806 ** not possible to modify the database further. At this point, the upper
37863 ** code were simply returned to the user, the b-tree layer would not
37871 ** * The pager is not an in-memory pager.
37903 ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
38020 ** not updated more often than necessary.
38036 ** (or may not) specify a master-journal name to be written into the
38039 ** Whether or not a journal file contains a master-journal pointer affects
38042 ** If a journal file does not contain a master-journal pointer, it is
38071 ** is permitted, but syncing the journal file is not. This flag is set
38094 ** is not an integer multiple of the page-size, the value stored in
38108 ** and to determine whether or not pages need to be journalled before
38122 ** dbFileSize is not used when rolling back a transaction. In this case
38124 ** a call to xFilesize() that is not strictly required). In either case,
38151 u8 noReadlock; /* Do not bother to obtain readlocks */
38152 u8 noSync; /* Do not sync the journal if true */
38162 ** routine opertion. Class members not in this block are either fixed
38173 u8 doNotSpill; /* Do not spill the cache when non-zero */
38174 u8 doNotSyncSpill; /* Do not do a spill that requires jrnl sync */
38230 ** testing purposes only. These variables do not exist in
38231 ** a non-testing build. These variables are not thread-safe.
38302 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
38360 ** And if the journal-mode is "OFF", the journal file must not be open.
38370 ** is therefore not possible for an in-memory pager to enter the ERROR
38525 ** * The bit corresponding to the page-number is not set in
38582 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
38586 ** called, do not modify it. See the comment above the #define of
38612 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
38631 ** This function determines whether or not the atomic-write optimization
38697 ** is defined, and NDEBUG is not defined, an assert() statement checks
38807 ** This function is a no-op if the journal file has not been written to
38813 ** if the pager is not in no-sync mode, sync the journal file immediately
38820 ** not need to be synced following this operation.
38940 /* Initializing the tail of the buffer is not necessary. Everything
38957 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
39015 /* Read in the first 8 bytes of the journal header. If they do not match
39062 ** of two greater than or equal to 512 or 32, and not greater than their
39168 ** will not be able to find the master-journal name to determine
39169 ** whether or not the journal is hot.
39184 ** a pointer to the page or NULL if the requested page is not
39190 /* It is not possible for a call to PcacheFetch() with createFlag==0 to
39208 ** if it is open and the pager is not in exclusive mode.
39245 ** This function is a no-op if the pager is in exclusive mode and not
39249 ** If the pager is not in exclusive-access mode, the database file is
39251 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
39257 ** or not, any journal file left in the file-system will be treated
39382 ** file has been finalized it is not possible to use it to roll back a
39385 ** depends on whether or not the pager is running in exclusive mode and
39416 ** tries to unlock the database file if not in exclusive mode. If the
39425 /* Do nothing if the pager does not have an open write transaction
39523 ** If the pager has already entered the ERROR state, do not attempt
39531 ** If the pager has not already entered the ERROR state, but an IO or
39556 ** This is not a real checksum. It is really just the sum of the
39592 # define pagerReportSize(X) /* No-op if we do not support a codec */
39602 ** not.
39608 ** If pDone is not NULL, then it is a record of pages that have already
39624 ** and the checksum field does not match the record content.
39660 ** only reads from the main journal, not the sub-journal.
39713 ** not the database file. The page is left marked dirty in this case.
39717 ** not be in the pager cache. Later: if a malloc() or IO error occurs
39718 ** during a Movepage() call, then the page may not be in the cache
39719 ** either. So the condition described in the above paragraph is not
39724 ** not dirty. Since this code is only executed in PAGER_OPEN state for
39732 ** statement we must not write to the original database unless we know
39739 ** in the main journal either because the page is not in cache or else
39743 ** is possible to fail a statement on a database that does not yet exist.
39744 ** Do not attempt to write if database file has never been opened.
39779 /* If this is a rollback of a savepoint and data was not written to
39780 ** the database and the page is not in-memory, there is a potential
39782 ** will be read from the database file, which may or may not be
39825 ** unsynced portion of the main journal file, then it is not safe
39831 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
39860 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
39966 /* We have a match. Do not delete the master journal file. */
39992 ** If the main database file is not open, or the pager is not in either
40059 ** may not have been opened yet, in which case the OsSectorSize()
40104 ** the extra entries had not yet made it safely to disk. In such a case,
40114 ** If the file opened as the journal file is not a well-formed
40120 ** If an I/O or malloc() error occurs, the journal-file is not deleted
40151 ** If a master journal file name is specified, but the file is not
40152 ** present on disk, then the journal is not hot and does not need to be
40179 ** not enough bytes left in the journal file for a complete header, or
40203 ** that this part of the journal was being filled but has not yet been
40248 ** not completely written and synced prior to a crash. In that
40282 ** mode, then subsequent transactions performed by the connection will not
40445 ** database. This is not generally possible with a WAL database, as
40464 ** been written (but not committed) to the log file, do one of the
40560 /* sqlite3WalEndReadTransaction() was not called for the previous
40589 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
40590 ** if the database size is not available. The database size is not
40598 /* If the database size was not available from the WAL sub-system,
40600 ** of the database file is not an integer multiple of the page-size,
40634 ** exists if the database is not empy, or verify that the *-wal file does
40635 ** not exist (by deleting it) if the database file is empty.
40637 ** If the database is not empty and the *-wal file exists, open the pager
40639 ** if no error occurs, make sure Pager.journalMode is not set to
40688 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
40697 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
40853 ** assurance that the journal will not be corrupted to the
40865 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
40950 ** lock. It does *not* invoke the busy handler when upgrading from
40989 ** * the database is either not an in-memory database or it is
40999 ** If the page size is not changed, either because one of the enumerated
41000 ** conditions above is not true, the pager was in error state when this
41007 /* It is not possible to do a full assert_pager_state() here, as this
41085 ** errors in places where we do not care about errors.
41126 ** the Pager object. There has not been an opportunity to transition
41161 ** the busy callback if the lock is currently not available. Repeat
41195 ** b) if the page content were written at this time, it would not
41199 ** If the condition asserted by this function were not true, and the
41201 ** routine, pagerStress() would not write the current page content to
41204 ** content of the page. However, since this content is not present in either
41206 ** sub-journal rolled back the content could not be restored and the
41224 ** function does not actually modify the database file on disk. It
41292 ** If this is not done, then an unsynced portion of the open journal
41355 ** * Otherwise, if the device does not support the SAFE_APPEND property,
41361 ** * If the device does not support the SEQUENTIAL property, then
41441 ** This is not required if the persistent media supports the
41442 ** SAFE_APPEND property. Because in this case it is not possible
41502 ** is not yet open, it is created and opened before any data is
41529 /* If the file is a temp-file has not yet been opened, open it now. It
41530 ** is not possible for rc to be other than SQLITE_OK if this branch
41553 ** make the file smaller (presumably by auto-vacuum code). Do not write
41556 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
41639 /* Open the sub-journal, if it has not already been opened */
41675 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
41689 ** is returned by sqlite3PcacheMakeClean() is not called.
41699 ** journal (and adding a new header) is not allowed. This occurs
41704 ** or not a sync is required. This is set during a rollback.
41739 ** This is because the call to pager_write_pagelist() below will not
41752 ** If (X>Y), then when pagerStress is called page X will not be written
41756 ** was when the transaction started, not as it was when "SAVEPOINT sp"
41760 ** sub-journal file now (if it is not already there), so that it will
41890 ** as it will not be possible to open the journal file or even
41999 /* If a temporary file is requested, it is not opened immediately.
42101 ** * The first byte of the journal file exists and is not 0x00.
42109 ** This routine does not check if there is a master journal filename
42111 ** does not exist, then the journal file is not really hot. In this
42113 ** routine will discover that the journal file is not really hot and
42114 ** will not roll it back.
42119 ** to determine whether or not a hot-journal file exists, the IO error
42174 ** If there is, then we consider this journal to be hot. If not,
42198 ** with it under an EXCLUSIVE lock where we do not need to
42277 ** important that a RESERVED lock is not obtained on the way to the
42283 ** Because the intermediate RESERVED lock is not requested, any
42296 /* If it is not already open and the file exists on disk, open the
42303 ** If the journal does not exist, it usually means that some
42307 ** function was called and the journal file does not exist.
42332 ** probably did not sync it and we are required to always sync
42355 ** PAGER_ERROR now. This is not actually counted as a transition
42359 ** assert_pager_state() would fail now, as it should not be possible
42388 ** There is a vanishingly small chance that a change will not be
42447 ** the rollback journal, the unlock is not performed and there is
42464 ** choose not to allocate a new page object and may reuse an existing
42474 ** requested page is not already stored in the cache, then no
42478 ** If noContent is true, it means that we do not care about the contents
42493 ** will not be journaled. This saves IO.
42499 ** to find a page in the in-memory cache first. If the page is not already
42510 int noContent /* Do not bother reading content from disk if true */
42570 ** page that does not need to be journaled. Nevertheless, be sure
42610 ** not read the page from disk. Return a pointer to the page,
42611 ** or 0 if the page is not in cache.
42615 ** in the page if the page is not already in cache. This routine
42616 ** returns NULL if the page is not in cache or if a disk I/O error
42653 ** opened to write a rollback log for a transaction. It is not used
42660 ** Whether or not the journal file is opened by this function, the
42686 /* Open the journal file if it is not already open. */
42745 ** running in exclusive mode) or if the transaction does not require a
42762 ** exclusive lock on the database is not already held, obtain it now.
42774 ** The busy-handler is not invoked if another connection already
42782 ** lock, but not when obtaining the RESERVED lock.
42828 /* This routine is not called unless a write-transaction has already
42829 ** been started. The journal file may or may not be open at this point.
42839 ** again. This should not happen, but the check provides robustness. */
42842 /* Higher-level routines never call this function if database is not
42850 ** rollback journal might not yet be open. Open it now if this is the case.
42874 ** the transaction journal if it is not there already.
42885 ** that we do not. */
42936 /* If the statement journal is open and the page is not in it,
42957 ** of this function and be careful not to change any page data unless
43071 ** A call to this routine tells the pager that it is not necessary to
43079 ** that it does not get written to disk.
43129 ** The idea is that if the atomic-write optimization is not
43151 /* If page one was fetched successfully, and this function is not
43152 ** operating in direct-mode, make page 1 writable. When not in
43208 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
43247 ** Note that if zMaster==NULL, this does not overwrite a previous value
43251 ** is not synced. The caller must call sqlite3PagerSync() directly to
43257 const char *zMaster, /* If not NULL, the master journal name */
43307 ** does this depends on whether or not the atomic-update optimization
43313 ** * This commit is not part of a multi-file transaction, and
43316 ** If the optimization was not enabled at compile time, then the
43319 ** is not applicable to this transaction, call sqlite3JournalCreate()
43398 ** If the atomic-update optimization is being used, this sync will not
43405 ** not the case. In this case it is likely enough that the redundant
43418 /* If the file on disk is not the same size as the database image,
43462 /* This routine should not be called if a prior error has occurred.
43473 /* An optimization. If the database was not actually modified during
43513 ** 2) It finalizes the journal file, so that it is not used for hot
43529 ** the pager is already in the ERROR state, the rollback is not
43546 ** state to indicate that the contents of the cache may not be trusted.
43689 ** The savepoint to release or rollback need not be the most recently
43705 ** sqlite3PagerRollback() because this function does not terminate
43751 ** not yet been opened. In this case there have been no changes to
43781 ** not yet been opened.
43831 ** in cache. If the page previously located at pgno is not already
43832 ** in the rollback journal, it is not put there by by this routine.
43839 ** required that a statement transaction was not active, but this restriction
43846 ** pPg refers to will not be written to again within this transaction.
43871 /* If the page being moved is dirty and has not been saved by the latest
43881 ** If page X were not written to the sub-journal here, it would not
43905 ** can be written to. The caller has already promised not to write to it.
43924 /* Do not discard pages from an in-memory database since we might
43959 ** the journal file twice, but that is not a problem.
43998 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
44093 ** not possible, then that is not a problem. Deleting the journal file
44097 ** database file. This ensures that the journal file is not deleted
44265 ** file (not a temp file or an in-memory database), and the WAL file
44266 ** is not already open, make an attempt to open it now. If successful,
44268 ** not support the xShmXXX() methods, return an error code. *pbOpen is
44269 ** not modified in either case.
44311 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
44312 ** If successful, the EXCLUSIVE lock is not released before returning.
44319 /* If the log file is not already open, but does exist in the file-system,
44377 ** May you do good and not evil.
44501 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
44509 ** use an architecture-specific format; it does not have to be cross-platform.
44543 ** depending on the contents of the WAL file. This does not change the
44579 ** no hash slot such that aHash[i]==p) then page P is not in the
44592 ** WAL or to establish that the frame does not exist in the WAL. This
44630 ** values in the wal-header are correct and (b) the version field is not
44634 ** checksum test is successful) and finds that the version field is not
44715 ** is not already an aReadMark[] equal to mxFrame. The exception to the
44741 ** only support mandatory file-locks, we do not read or write data
44840 int iNext; /* Next slot in aIndex[] not yet returned */
45057 ** *pnTruncate and return true. Return if the frame is not valid.
45062 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
45111 ** Names of locks. This routine is used to provide debugging output and is not
45393 ** thing to check, so only do this occasionally - not on every
45430 /* Obtain an exclusive lock on all byte in the locking range not already
45472 /* If the database page size is not a power of two, or is greater than
45682 ** has not been returned by any prior invocation of this method on the
45953 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
46003 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
46125 /* Reset the return code so as not to report a checkpoint failure
46172 ** The EXCLUSIVE lock is not released before returning.
46249 return 1; /* Checksum does not match */
46327 ** sure the wal-index was not constructed with some future format that
46367 ** and is not honoring the locking protocol. There is a vanishingly small
46375 ** that means the Wal does not hold any read lock. The reader must not
46406 ** locks are held, so the locks should not be held for very long. But
46432 /* If there is not a recovery running in another thread or process
46445 ** code that determines whether or not the shared-memory region
46470 /* It is not safe to allow the reader to continue here if frames
46479 ** is obtained, that is not necessarily true. A checkpointer may
46496 ** but not exceeding pWal->hdr.mxFrame and lock that entry.
46538 ** It is necessary to check that the wal-index header did not change
46548 ** This does not guarantee that the copy of the wal-index header is up to
46549 ** date before proceeding. That would not be possible without somehow
46552 ** WAL_READ_LOCK(mxI)) has not occurred since the snapshot was valid.
46613 ** has been loaded. Or *pInWal is set to 0 if the page was not in
46747 ** the read transaction was started, then it is not possible for this
46799 ** If any data has been written (but not committed) to the log file, this
46804 ** other than SQLITE_OK, it is not invoked again and the error code is
46807 ** Otherwise, if the callback function does not return an error, this
46834 ** committed. As a result, the call to xUndo may not fail.
46899 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
46964 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
47104 /* Append data to the wal-index. It is not necessary to lock the
47148 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
47185 ** run instead. Since the checkpointer is not holding the writer lock,
47271 ** not actually change anything. The pager uses this to see if it
47331 ** May you do good and not evil.
47350 ** May you do good and not evil.
47446 ** not specified in the header.
47509 ** that immediately follows the page header. Cells is not necessarily
47516 ** appears first. A variable-length integer may not be more than 9 bytes long.
47584 ** the header, then your custom library will not be able to read
47586 ** will not be able to read databases created by your custom library.
47628 struct _OvflCell { /* Cells that will not fit on aData[] */
47679 ** The pBt pointer itself may not be changed while there exists cursors
47723 ** may not be modified once it is initially set as long as nRef>0.
47760 u8 doNotUseWAL; /* If true, do not open write-ahead-log file */
47832 sqlite3_int64 cachedRowid; /* Next rowid cache. 0 means not valid */
47857 ** Cursor does not point to a valid entry. This can happen (for example)
47858 ** because the table is empty or because BtreeCursorFirst() has not been
47909 ** to any page that is not part of the pointer map itself.) Each pointer map
47918 ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
47922 ** is not used in this case.
47951 ** if the database supports auto-vacuum or not. Because it is used
47953 ** (sqliteMallocRaw), it is not possible to use conditional compilation.
48025 ** If the object is not sharable, then no mutex is ever required
48068 ** procedure that follows. Just be sure not to block.
48113 ** B-Tree is not marked as sharable.
48132 ** omitted if that module is not used.
48147 ** against all schemas and we do not want those schemas being
48178 ** no lock is ever required since it is not sharable.
48217 ** If pSchema is not NULL, then iDb is computed from pSchema and
48267 ** May you do good and not evil.
48344 ** of each BtShared structure and so this locking is not necessary.
48362 ** table with root page iRoot. Return 1 if it does and 0 if not.
48390 /* If this database is not shareable, or if the client is reading
48401 ** not loaded, then it is too difficult to actually check to see if
48402 ** the correct locks are held. So do not bother - just return true.
48403 ** This case does not come up very often anyhow.
48479 ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
48497 /* This routine is a no-op if the shared-cache is not enabled */
48503 ** requested lock may not be obtained.
48581 /* If the above search did not find a BtLock struct associating Btree p
48614 ** transaction. If it does not, then the BtShared.isPending variable
48647 ** transaction. If there currently exists a writer, and p is not
48652 ** If there is not currently a writer, then BtShared.isPending must
48759 ** a free-list leaf page, the page is not written to the database
48761 ** such a page is not even journalled (as it will not be modified,
48764 ** 2) When a free-list leaf page is reused, its content is not read
48766 ** be, if it is not at all meaningful?).
48771 ** transaction, a problem comes up. If the page is not journalled when
48772 ** it is moved to the free-list and it is also not journalled when it
48774 ** may be lost. In the event of a rollback, it may not be possible
48839 ** all that is required. Otherwise, if pCur is not open on an intKey
48967 ** Determine whether or not a cursor has moved from the position it
48972 ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
48996 ** Return 0 (not a valid page) for pgno==1 since there is
49118 ** This routine works only for pages that do not contain overflow cells.
49195 /* If the payload will not fit completely on the local page, we have
49235 ** data header and the local payload, but not any overflow page or
49246 ** this function verifies that this invariant is not violated. */
49482 ** the allocation. If not, defragment.
49534 ** btreeInitPage() did not detect overlapping cells or
49636 ** not contain a well-formed database page, then return
49637 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
49800 ** If the noContent flag is set, it means that we do not care about
49801 ** the content of the page at this time. So do not go to the disk
49811 int noContent /* Do not load page content if true */
49824 ** Retrieve a page from the pager cache. If the requested page is not
49915 /* pPage might not be a btree page; it might be an overflow page
50065 ** even when they are not. This exercises the locking code and
50116 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
50207 ** do not change the pager-cache size.
50341 ** operate asynchronously - it will not stop to do fsync()s
50348 ** Synchronous is on by default so database corruption is not
50406 ** size supplied does not meet this constraint then the page size is not
50550 ** SQLITE_OK is returned on success. If the file is not a
50602 ** in WAL mode. If the log is not already open, open it now. Then
50606 ** may not be the latest version - there may be a newer one in the log
50698 ** If there are no outstanding cursors and we are not in the middle
50766 ** to access the database. A preexisting transaction may not be
50784 ** if there is one. But if there was previously a read-lock, do not
50792 ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
50812 /* Write transactions are not possible on a read-only database */
50853 ** file is not pBt->pageSize. In this case lockBtree() will update
50919 ** the sub-journal is not already open, then it will be opened here.
51043 ** can be written to. The caller has already promised not to write to that
51137 ** which may or may not empty the freelist. A full autovacuum
51166 /* Remove the page from the files free-list. This is not required
51246 ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
51296 /* It is not possible to create a database for which the final page
51341 ** causes a rollback journal to be created (if it does not already exist)
51348 ** disk and we are still holding all locks, so the transaction has not
51492 ** in assert() expressions, so it is only compiled if NDEBUG is not
51497 ** originally opened for writing and the cursor has not be disabled
51523 ** or moved root pages, so it is not sufficient to
51564 ** the cache may be internally inconsistent (not contain valid trees) so
51690 ** but which are not in the READ_UNCOMMITTED state may not have
51695 ** 3: The database must be writable (not on read-only media)
51700 ** root page of a b-tree. If it is not, then the cursor acquired
51701 ** will not work correctly.
51786 ** do not need to be zeroed and they are large, so we can save a lot
51803 ** or negative rowids are very uncommon so this should not be a problem.
51855 ** BtCursor.info structure. If it is not already valid, call
51865 ** compiler is not doing agressive inlining.) So we use a real function
51890 #else /* if not _MSC_VER */
51915 ** the key for the current entry. If the cursor is not pointing
51919 ** itself, not the number of bytes in the key.
51945 ** Failure is not possible. This function always returns SQLITE_OK.
51969 ** If ppPage is not NULL, and a reference to the MemPage object corresponding
52145 ** has not been allocated, allocate it now. The array is sized at
52148 ** etc. A value of 0 in the aOverflow[] array means "not yet known"
52185 ** data is not required. So first try to lookup the overflow
52279 ** into *pAmt. If *pAmt==0, then the value returned will not be
52370 ** the new child page does not match the flags field of the parent (i.e.
52459 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
52500 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
52502 ** NULL, the caller expects a table b-tree. If this is not the case,
52513 ** if the assumption were not true, and it is not possible for the flags
52659 ** If an exact match is not found, then the cursor is always
52730 ** not run. If this is not the root-page, then the moveToChild() routine
52858 ** Return TRUE if the cursor is not pointing at an entry of the table.
53011 ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
53013 ** If the "nearby" parameter is not 0, then a (feeble) effort is made to
53018 ** If the "exact" parameter is not 0, and the page-number nearby exists
53076 ** is not true. Otherwise, it runs once for each trunk-page on the
53099 /* The trunk has no leaves and the list is not being searched.
53291 ** It is assumed that the page is not already a part of the free-list.
53299 ** its reference count is not altered by this function.
53372 ** Note that the trunk page is not really full until it contains
53373 ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
53397 /* If control flows to this point, then it was not possible to add the
53457 /* 0 is not a legal page number and page 1 cannot be an
53473 ** must not really be an overflow page and the database must be corrupt.
53501 ** Note that pCell does not necessary need to point to the pPage->aData
53529 /* pPage is not necessarily writeable since pCell might be auxiliary
53606 /* If pToRelease is not zero than pPrior points into the data area
53626 /* If pToRelease is not zero than pPayload points into the data area
53658 ** The cell content is not freed or deallocated. It is assumed that
53709 ** will not fit, then make a copy of the cell content into pTemp if
53710 ** pTemp is not null. Regardless of pTemp, allocate a new entry
53716 ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
53718 ** nSkip is non-zero, then pCell may not point to an invalid memory location
53973 ** This function does not contribute anything to the operation of SQLite.
54015 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
54022 ** MemPage.aOvfl[] array), they are not copied to pTo.
54026 ** The performance of this function is not critical. It is only used by
54082 ** one or two in an effort to keep pages nearly full but not over full.
54085 ** might not actually be stored in MemPage.aData[]. This can happen
54125 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
54172 ** way, the remainder of the function does not have to deal with any
54219 ** four bytes of it, and this function does not need the first
54274 ** child pointers. If siblings are not leaves, then all cell in
54278 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
54336 /* Do not allow any cells smaller than 4 bytes. */
54385 ** sibling might be completely empty. This adjustment is not optional.
54453 /* Free any old pages that were not reused as new pages.
54472 ** not be a problem.
54519 /* If the sibling page assembled above was not the right-most sibling,
54608 ** many have not. The following is a summary:
54610 ** 1) The entries associated with new sibling pages that were not
54620 ** 3) If the sibling pages are not leaves, then the child pages of
54623 ** 4) If the sibling pages are not internal intkey nodes, then any
54627 ** 5) If the sibling pages are not leaves, then the pointer-map
54647 ** sibling page j. If the siblings are not leaf pages of an
54670 ** sibling page k. If the siblings are not leaf pages of an
54678 /* If the cell was originally divider cell (and is not now) or
54858 ** function. If this were not verified, a subtle bug involving reuse
54886 /* If pFree is not NULL, it points to the pSpace buffer used
54973 ** operation - if it is not, the following is a no-op). */
54987 ** not to clear the cursor here.
55112 /* If the page containing the entry to delete is not a leaf page, move
55138 /* If the cell deleted was not located on a leaf page, then the cursor
55197 ** flags might not work:
55237 /* The new root-page may not be allocated on a pointer-map page, or the
55257 ** the new table (assuming an error did not occur). But we were
55258 ** allocated pgnoMove. If required (i.e. if it was not allocated
55403 ** If pnChange is not NULL, then table iTable must be an intkey table. The
55414 ** is the root of a table b-tree - if it is not, the following call is
55434 ** If AUTOVACUUM is enabled and the page at iTable is not the last
55496 /* The table being dropped does not have the largest root-page
55569 ** free pages is not visible. So Cookie[0] is the same as Meta[1].
55593 ** read-only and may not be written.
55639 ** page in the B-Tree structure (not including overflow pages).
55645 /* If this is a leaf page or the tree is not an int-key tree, then
55656 ** the next page in the tree that has not yet been visited. The
55756 ** page iParent, pointer type ptrType. If not, append an error message
55840 /* If this database supports auto-vacuum and iPage is not the last
55864 ** 1. Make sure that cells and freeblocks do not overlap
56179 /* Make sure this analysis did not leave any unref() pages.
56219 ** has been created or not.
56288 ** If the nBytes parameter is 0 and the blob of memory has not yet been
56294 ** blob of allocated memory. The xFree function should not call sqlite3_free()
56355 ** Only the data content may only be modified, it is not possible to
56422 /* If setting the version fields to 1, do not automatically open the
56454 ** May you do good and not evil.
56512 ** backup_pagecount() are not thread-safe functions. If they are called
56520 ** Non-sharable Btrees (in-memory databases for example), do not have
56592 ** handle is not locked in this routine, but it is locked in
56629 /* One (or both) of the named databases did not exist or an OOM
56688 /* Backup is not possible if the page size of the destination is changing
56695 /* Backup is not possible if the number of bytes of reserve space differ
56697 ** fix the destination to agree with the source. If that is not possible,
56740 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
56800 /* Lock the destination database, if it is not locked already. */
56817 /* Do not allow backup if the destination database is in WAL mode
57092 ** valid and which are not, so the entire process needs to be restarted.
57124 ** from this function, not directly by the user.
57160 ** May you do good and not evil.
57183 ** If pMem is not a string object, or the encoding of the string
57187 ** SQLITE_OK is returned if the conversion is successful (or not required).
57205 ** then the encoding of the value may not have changed.
57226 ** not set, Mem.n is zeroed.
57346 ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
57421 ** does not free any Mem.zMalloc buffer.
57461 ** Because we do not completely understand the problem, we will
57471 ** Many compilers we encounter do not define constants for the
57473 ** inconsistently. And many do not understand the "LL" notation.
57483 /* minInt is correct here - not maxInt. It turns out that assigning
57610 ** is a string that does not look completely like a number. Convert
57740 ** copies are not misused.
57756 ** Size of struct Mem not including the Mem.zMalloc member.
57762 ** pTo are freed. The pFrom->z field is not duplicated. If
57940 /* If one value is a number and the other is not, the number is less.
57992 ** compiled (this was not always the case).
58049 int key, /* If true, retrieve from the btree key, not data. */
58092 /* This function is only available internally, it is not part of the
58314 ** May you do good and not evil.
58655 ** throw an ABORT exception (causing the statement, but not entire transaction
58696 ** If malloc failed, then the while() loop above may not have iterated
58783 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
58890 ** the FuncDef is not ephermal, then do nothing.
58951 ** opcodes contained within. If aOp is not NULL it is assumed to contain
59006 ** caller should not free the allocation, it will be freed when the Vdbe is
59124 ** is readable but not writable, though it is cast to a writable value.
59291 ** If SQLite is not threadsafe but does support shared-cache mode, then
59296 ** If SQLite is not threadsafe and does not support shared-cache mode, this
59302 ** this routine is N*N. But as N is rarely more than 1, this should not
59456 /* Even though this opcode does not use dynamic strings for
59539 ** has not already been seen.
59674 ** receive the new memory. pBuf is normally NULL. If pBuf is not
59676 ** this routine should not allocate any new memory. When pBuf is not
59859 p->nMem = nMem; /* not from 0..nMem-1 */
60031 ** A read or write transaction may or may not be active on database handle
60044 ** SQLITE_OK so p is not used.
60058 ** (b) how many database files have open write transactions, not
60083 /* The simple case - no more than one database file (not counting the
60089 ** that case we do not support atomic multi-file commits, so use the
60185 ** flag is set this is not required.
60199 ** an error occurs here, do not delete the master journal file.
60259 ** currently active. An assertion fails if the two counts do not match.
60260 ** This is an internal self-check only - it is not an essential processing
60297 ** reorder rootpages. So it is not sufficient just to save
60407 ** Return an error code. If the commit could not complete because of
60409 ** means the close did not happen and needs to be repeated.
60618 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
60632 /* If the VM did not run to completion or if it encountered an
60633 ** error, then it might not have been halted properly. So halt
60640 ** if the VDBE has just been set to run but has not actually executed any
60792 ** not been deleted out from under the cursor, then this routine is a no-op.
60862 ** of SQLite will not understand those serial types.
60929 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
60932 ** ever since. The blame is not necessarily with GCC, though.
61228 ** Key1 and Key2 do not have to contain the same number of fields.
61272 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
61432 ** of the keys prior to the final rowid, not the entire key.
61553 ** May you do good and not evil.
61579 ** Check on a Vdbe to make sure it has not been finalized. Log
61895 ** This "automatic-reset" change is not technically an incompatibility,
61918 /* Check that malloc() has not failed. If it has, return early. */
61933 ** from interrupting a statement that has not yet started.
62199 ** This function is deprecated. Do not use it for new code. It is
62232 ** If iCol is not valid, return a pointer to a Mem which has a value
62392 ** If the result is not a simple column reference (if it is an expression
62442 ** not define OMIT_DECLTYPE.
62445 # error "Must not define both SQLITE_OMIT_DECLTYPE \
62470 ** anything else which is not an unabiguous reference to a database column.
62486 ** anything else which is not an unabiguous reference to a database column.
62502 ** anything else which is not an unabiguous reference to a database column.
62784 ** will not bother to check for that condition.
62817 ** Return true if the prepared statement is guaranteed to not modify the
62860 ** May you do good and not evil.
63015 ** May you do good and not evil.
63051 ** in this file for details. If in doubt, do not deviate from existing
63058 ** not misused.
63082 ** This facility is used for testing purposes only. It does not function
63092 ** sorting is occurring or not occurring at appropriate times. This variable
63118 ** is executed. This is used to test whether or not the foreign key
63149 ** does not control the string, it might be deleted without the register
63260 ** looks like a number, convert it into a number. If it does not
63288 ** is not possible. Note that the integer representation is
63305 ** representation (blob and NULL do not get converted) but no string
63339 ** not the internal Mem* type.
63484 ** May you do good and not evil.
64259 ** Do not deviate from the formatting style currently in use.
64325 ** value in register P3 is not NULL, then this routine is a no-op.
64341 ** whether or not to rollback the current transaction. Do not rollback
64344 ** VDBE, but do not rollback the transaction.
64346 ** If P4 is not null then it is an error message string.
64595 ** Thus the program must guarantee that the original will not change
64629 ** not return the number of rows modified. And do not RELEASE the statement
64644 ** ensure that statement-transactions are always nested, not overlapping.
64645 ** If the open statement-transaction is not closed here, then the user
64860 ** to retrieve the collation sequence set by this opcode is not available
64873 ** Register P3 must not be one of the function inputs.
64875 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
65086 ** in P1 is not an integer and cannot be converted into an integer
65133 ** A NULL value is not changed by this routine. It remains NULL.
65156 ** A NULL value is not changed by this routine. It remains NULL.
65180 ** A NULL value is not changed by this routine. It remains NULL.
65196 ** A NULL value is not changed by this routine. It remains NULL.
65214 ** A NULL value is not changed by this routine. It remains NULL.
65247 ** P4 is used to do the comparison. If P4 is not specified then
65253 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
65259 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
65319 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
65320 ** or not both operands are null.
65562 ** Jump to P2 if the value in register P1 is a not null or zero. If
65566 ** When P1 is not used otherwise in a program, this opcode falls through
65625 ** Jump to P2 if the value in register P1 is not NULL.
65698 ** might be available in the u.am.pC->aRow cache. Or it might not be.
65800 /* Make sure a corrupt database has not given us an oversize header.
65825 ** not exceeded even for corrupt database files.
65832 ** record header if the record header does not fit on a single page
65872 ** table. Set the u.am.offset for any extra columns not present in
65897 ** then there are not enough fields in the record to satisfy the
66058 ** We do not allow blobs with a prefix and a zero-filled tail. */
66076 ** the new record. The output register (pOp->p3) is not allowed to
66175 ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
66223 /* It is not possible to release (commit) a savepoint if there are
66224 ** active write statements. It is not possible to rollback a savepoint
66234 /* Determine whether or not this is a transaction savepoint. If so,
66397 ** connection is currently not in autocommit mode, or if there are other
66561 ** not reload the schema from the database file.
66563 ** If virtual-tables are in use, this is not just an optimization.
66566 ** prepared queries. If such a query is out-of-date, we do not want to
66589 ** values need not be contiguous but all P1 values should be small integers.
66592 ** If P5!=0 then use the content of register P2 as the root page, not
66627 ** cursors or a single read/write cursor but not both.
66705 ** and report database corruption if they were not, but this check has
66721 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
66847 ** Close a cursor previously opened as P1. If P1 is not
66866 ** greater than or equal to the key and P2 is not zero, then jump to P2.
66879 ** the key and P2 is not zero, then jump to P2.
66892 ** the key and P2 is not zero, then jump to P2.
66905 ** less than or equal to the key and P2 is not zero, then jump to P2.
66943 /* If the P3 value could not be converted into an integer without
66948 ** then the seek is not possible, so jump to P2 */
67109 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
67191 ** or may not be the same as R.
67198 ** of the index entry is not R. If there is no such entry, control jumps
67271 ** with that key does not exist in table of P1, then jump to P2.
67341 ** The record number is not previously used as a key in the database
67379 ** it already exists in the table. If it does not exist, we have
67453 ** it finds one that is not previously used. */
67498 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
67504 ** operation will not attempt to find the appropriate row before doing
67516 ** may be NULL. If it is not NULL, then the update-hook
67522 ** value of register P2 will then change. Make sure this does not
67531 ** integer value P3, not the value of the integer stored in register P3.
67613 ** incremented (otherwise not).
67615 ** P1 must not be pseudo-table. It has to be a real table with
67618 ** If P4 is not NULL, then it is the name of the table that P1 is
67620 ** If P4 is not NULL then the P1 cursor must have been positioned
67732 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67733 ** of a real table, not a pseudo-table.
67742 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67743 ** of a real table, not a pseudo-table.
67887 ** If P2 is 0 or if the table or index is not empty, fall through
67926 ** regression tests can determine whether or not the optimizer is
67946 ** If P2 is 0 or if the table or index is not empty, fall through
67987 ** The P1 cursor must be for a real table, not a pseudo-table.
68004 ** The P1 cursor must be for a real table, not a pseudo-table.
68311 ** in the database file is given by P1. But, unlike Destroy, do not
68319 ** intkey table (an SQL table, not an index). In this case the row change
68516 ** If P5 is not zero, the check is done on the auxiliary database
68517 ** file, not the main database file.
68569 ** An assertion fails if P2 is not an integer.
68624 ** the rowset object for P3, as it is guaranteed not to contain it,
68702 ** is really a trigger, not a foreign key action, and the flag set
68857 ** This instruction throws an error if the memory cell is not initially
68887 ** not contain an integer. An assertion fault will result if you try.
68903 ** not contain an integer. An assertion fault will result if you try.
68920 ** not contain an integer. An assertion fault will result if you try.
68998 ** argument is not used by this opcode. It is only there to disambiguate
69001 ** the step function was not previously called.
69025 ** Checkpoint database P1. This is a no-op if P1 is not currently in
69028 ** SQLITE_BUSY or not, respectively. Write the number of pages in the
69100 /* Do not allow a transition to journal_mode=WAL for a database
69101 ** in temporary storage or if the VFS does not support shared memory
69168 ** machines to be created and run. It may not be called from within
69257 ** Also, whether or not P4 is set, check that this is not being called from
69458 ** do this regardless of whether or not an error occurred to ensure any
69638 ** Do not let the maximum page count fall below the current page count and
69639 ** do not change the maximum page count value if P3==0.
69816 ** May you do good and not evil.
69849 ** If an error occurs, or if the specified row does not exist or does not
70020 ** column is not indexed, and that it is not part of a foreign key.
70028 /* Check that the column is not part of an FK child key definition. It
70029 ** is not necessary to check if it is part of a parent key, as parent
70240 ** If an error occurs, or if the specified row does not exist or does not
70286 ** May you do good and not evil.
70819 ** in the PMA (not including the varint itself).
70836 /* If the first temporary PMA file has not been opened, open it now. */
70975 /* If no data has been written to disk, then do not do so now. Instead,
71023 /* Open the second temp file, if it is not already open. */
71169 ** May you do good and not evil.
71183 ** on disk is not created or populated until either:
71209 ** If it does not already exists, create and populate the on-disk file
71383 ** file has not yet been created, create it now.
71409 ** May you do good and not evil.
71529 ** access writes are not required by sqlite.
71670 ** May you do good and not evil.
71692 ** WRC_Prune Do not descend into child nodes. But allow
71737 ** not invoke the SELECT callback on p, but do (of course) invoke
71754 ** FROM clause of SELECT statement p. Do not invoke the select
71783 ** If the Walker does not have an xSelectCallback() then this routine
71808 ** May you do good and not evil.
71846 ** then again, we might not...
72027 /* If we have not already resolved the name, then maybe
72089 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
72134 ** case, we need to return right away and not make any changes to
72138 ** fields are not changed in any context.
72147 ** cnt==0 means there was not match. cnt>1 means there were two or
72345 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
72418 ** no match, or if pE is not a simple identifier, then this routine
72421 ** pEList has been resolved. pE has not.
72446 ** ORDER BY of a compound SELECT. The expression has not been
72450 ** ORDER BY term is not an integer index into the result set. That
72607 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
72768 ** are not allowed to refer to any names, so pass an empty NameContext.
72822 ** expression, do not allow aggregates in any of the other expressions.
72854 /* The ORDER BY and GROUP BY clauses may not refer to terms in
72873 ** the GROUP BY clause does not contain aggregate functions.
72883 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
73028 ** May you do good and not evil.
73168 /* One side is a column, the other is not. Use the columns affinity. */
73232 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
73233 ** it is not considered.
73284 ** expression depth allowed. If it is not, leave an error message in
73388 ** parameter is ignored if pToken is NULL or if the token does not
73393 ** can be translated into a 32-bit integer, then the token is not
73557 ** sure "nnn" is not too be to avoid a denial of service attack when
73696 ** off if the expression is reduced. Note also that it does not work to
73744 ** and Expr.pRight variables (but not for any structures pointed to or
73760 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
73857 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
73860 ** Any tables that the SrcList might point to are not duplicated.
74128 ** not constant.
74221 ** in *pValue. If the expression is not an integer or if it is too big
74383 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
74386 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
74387 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
74421 ** If the prNotFound parameter is not 0, then the b-tree will be used
74427 ** needs to know whether or not the structure contains an SQL NULL
74435 ** its initial value is NULL. If the (...) does not remain constant
74501 ** it is not, it is not possible to use any index.
74533 /* Could not found an existing table or index to use as the RHS b-tree.
74576 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
74687 ** that columns affinity when building index keys. If <expr> is not
74708 /* If the expression is not constant then we will need to
74749 ** an integer 0 (not exists) or 1 (exists) into a memory cell
74803 ** if the LHS is NULL or if the LHS is not contained within the RHS and the
74806 ** This routine generates code will jump to destIfFalse if the LHS is not
74814 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
74844 ** on whether the RHS is empty or not, respectively.
74891 ** then the presence of NULLs in the RHS does not matter, so jump
74896 /* Here we begin generating code that runs if the LHS is not
74909 /* Jump to the appropriate target depending on whether or not
74943 ** The z[] string will probably not be zero-terminated. But the
74944 ** z[n] character is guaranteed to be something that does not look
75167 ** not guaranteed. The location of the column value is returned.
75254 ** and does not appear in a normal build.
75608 ** second argument, not the first, as the argument to test to
75811 ** So make sure that the regFree1 register is not reused for other
75883 ** then write its number into *pReg. If the result register is not
75960 ** or OP_Variable that does not need to be placed in a
76070 ** obtained for queries regardless of whether or not constants are
76448 ** returns 2, then you do not really know for certain if the two
76451 ** this routine is used, it does not hurt to get an extra 2 - that
76576 ** is not an entry there already.
76785 ** May you do good and not evil.
76795 ** The code in this file only exists if we are not omitting the
76932 ** TRIGGER, not CREATE INDEX and CREATE TABLE.
77036 ** If argument zWhere is not NULL, then the string returned is
77080 /* If the table is not located in the temp-db (in which case NULL is
77082 ** that is not part of the temp-db schema, add a clause to the WHERE
77141 /* Now, if the table is not stored in the temp database, reload any temp
77154 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
77156 ** Or, if zName is not a system table, zero is returned.
77160 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
77204 /* Check that a table or index named 'zName' does not already exist
77213 /* Make sure it is not a system table being altered, or a reserved name
77225 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
77440 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
77442 ** column must not be NULL.
77464 ** can handle (i.e. not CURRENT_TIME etc.)
77500 ** format to 2. If the default value of the new column is not NULL,
77542 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
77547 /* Make sure this is not an attempt to ALTER a view. */
77562 ** prefix, we insure that the name will not collide with an existing
77563 ** table because user table are not allowed to have the "sqlite_"
77613 ** May you do good and not evil.
77628 ** If the sqlite_stat1 tables does not previously exist, it is created.
77629 ** Similarly, if the sqlite_stat2 table does not exist and the library
77633 ** or it may be a NULL pointer. If it is not NULL, then all entries in
77671 /* The sqlite_stat[12] table does not exist. Create it. Note that a
77681 /* The table already exists. If zWhere is not NULL, delete all entries
77712 Index *pOnlyIdx, /* If not NULL, only analyze this one index */
77747 /* Do not gather statistics on views or virtual tables */
77751 /* Do not gather statistics on system tables */
77794 ** not been populated. In this case populate it now. */
77895 ** out-of-bounds write if SQLITE_DEBUG is not defined). */
78009 ** a database. If pOnlyIdx is not NULL then it is a single index
78063 if( i==1 ) continue; /* Do not analyze the TEMP database */
78165 ** If the Index.aSample variable is not NULL, delete the aSample[] array
78192 ** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR
78198 ** sqlite_stat2 table is not present in the database, SQLITE_ERROR is
78203 ** This means if the caller does not care about other errors, the return
78334 ** May you do good and not evil.
78346 ** identifiers are treated as strings, not possible column names or aliases.
78455 ** or may not be initialised.
78746 ** The return value indicates whether or not fixation is required. TRUE
78747 ** means we do need to fix the database references, FALSE means we do not.
78775 ** view in one database does not refer to objects in a different database.
78893 ** May you do good and not evil.
78900 ** systems that do not need this facility may omit it by recompiling
78980 ** callback has been registered (i.e. that sqlite3.xAuth is not NULL).
78982 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
79098 sqlite3ErrorMsg(pParse, "not authorized");
79144 ** May you do good and not evil.
79357 ** this way, the final OP_Halt is not appended and other initialization
79394 ** database containing the table. Return NULL if not found.
79424 ** database containing the table. Return NULL if not found. Also leave an
79429 ** sqlite3FindTable() does not.
79462 ** Return NULL if not found.
79582 ** schema hash tables and therefore do not have to make any changes
79637 ** This routine just deletes the data structure. It does not unlink
79647 /* Do not delete the table until the reference count reaches zero. */
79714 ** are not \000 terminated and are not persistent. The returned string
79767 ** does not exist.
79784 ** the table name is not fully qualified, i.e.:
79879 ** the table name is not fully qualified, i.e.:
79893 /* If creating a temp table, the name may not be qualified. Unless
79934 /* Make sure the new table name does not collide with an existing
80008 /* If the file format and encoding in the database have not been set,
80026 ** The record created does not contain anything yet. It will be replaced
80064 ** WARNING: This macro is not compatible with the strcmp() family. It
80223 ** is not the case.
80236 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
80268 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
80390 ** If the requested collation sequence is not available, or not available
80392 ** request it. If the collation factory does not supply such a sequence,
80431 ** it checks the cookie to make sure the schema has not changed
80434 ** This plan is not completely bullet-proof. It is possible for
80453 ** but does not include the null terminator.
80475 ** characters, does not begin with a digit and is not an SQL keyword,
80584 ** the sqlite_master table. We do not want to create it again.
80586 ** If the pSelect argument is not NULL, it means that this routine
80635 ** So do not write to the disk again. Extract the root page number
80643 /* If not initializing, then create a record for the new table
80684 ** A shared-cache write-lock is not required to write to the new table,
80818 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
80924 ** to the elements of the FROM clause. But we do not want these changes
81002 ** or tables and not the table/index that is actually being moved.
81076 ** is not defined), then it is important to call OP_Destroy on the
81211 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
81216 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
81348 "number of columns in foreign key does not match the number of "
81453 ** if memRootPage is not negative, it means that the index is newly
81524 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC
81549 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
81619 ** Find the table that is to be indexed. Return early if not found.
81633 ** is a temp table. If so, set the database to 1. Do not do this
81667 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
81672 sqlite3ErrorMsg(pParse, "views may not be indexed");
81678 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
81684 ** Find the name of the index. Make sure there is not already another
81812 ** if any column is not found.
81814 ** TODO: Add a test to make sure that the same column is not named
81838 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
82051 ** to be used when we have not run the ANALYZE command.
82054 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
82241 ** if not found.
82328 ** If pDatabase is not null, it means that the table has an optional
82711 ** This routine starts a new transaction if we are not already within
82718 ** necessary to undo a write and the checkpoint should not be set.
82775 ** true if it does and false if it does not.
82947 ** May you do good and not evil.
83000 pColl->xDel = 0; /* Do not copy the destructor */
83010 ** requested collation sequence is not available in the desired encoding.
83012 ** If it is not NULL, then pColl must point to the database native encoding
83051 ** that have not been defined by sqlite3_create_collation() etc.
83077 ** specified by zName and nName is not found and parameter 'create' is
83131 ** If the entry specified is not found and 'create' is true, then create a
83248 ** NULL if the function does not exist.
83261 ** number of arguments may be returned even if the eTextRep flag does not
83270 int createFlag /* Create new entry if true and does not otherwise exist */
83303 ** So we must not search for built-ins when creating a new function.
83319 /* If the createFlag parameter is true and the search did not reveal an
83341 ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
83345 ** The Schema.cache_size variable is not cleared.
83406 ** May you do good and not evil.
83421 ** name is not found or if any other error occurs.
83446 ** Check to make sure the given table is writable. If it is not
83451 /* A table is not writable under the following circumstances:
83455 ** 2) It is a system table (i.e. sqlite_master), this call is not
83456 ** part of a nested parse and writable_schema pragma has not
83467 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
83835 ** generating code because of a call to sqlite3NestedParse(), do not
83897 ** not attempt to delete it or fire any DELETE triggers. */
83932 ** being deleted. Do not attempt to delete the row a second time, and
83933 ** do not fire AFTER triggers. */
83938 ** are not violated by deleting this row. */
84060 ** May you do good and not evil.
84201 /* Because sqlite3_value_double() returns 0.0 if the argument is not
84381 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
84401 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
84420 ** do not have to be computed. This legacy implementation is retained as
84588 ** [^...] Matches one character not in the enclosed list.
84633 assert( esc==0 ); /* This is GLOB, not LIKE */
84663 assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
84755 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
84897 ** EXPERIMENTAL - This is not an official function. The interface may
84898 ** change. This function may disappear. Do not write code that depends
85023 ** must be exact. Collating sequences are not used.
85480 ** This routine only deals with those that are not global.
85504 ** parameter determines whether or not the LIKE operator is case
85527 ** return TRUE. If the function is not a LIKE-style function then
85667 ** May you do good and not evil.
85700 ** there is no way to tell which foreign constraint is not satisfied,
85701 ** or which row it is not satisfied for.
85724 ** deleted row in the child table. If such a row is not found,
85754 ** an INSERT does not open a statement transaction.
85764 ** for those two operations needs to know whether or not the operation
85812 ** is not a composite foreign key), output variable *paiCol is set to NULL.
85823 ** 1) The named parent key columns do not exist, or
85825 ** 2) The named parent key columns do exist, but are not subject to a
85829 ** foreign key definition, and the parent table does not have a
85864 ** Non-composite foreign keys do not require the aiCol array.
85958 ** special action is taken. Otherwise, if the parent row can *not* be
85991 ** outstanding constraints to resolve. If there are not, there is no need
86016 ** will have INTEGER affinity applied to it, which may not be correct. */
86022 ** then check if the row being inserted matches itself. If so, do not
86048 ** then check if the row being inserted matches itself. If so, do not
86085 ** generated for will not open a statement transaction. */
86220 ** clause. If the constraint is not deferred, throw an exception for
86292 ** DELETE, but foreign key actions are not.
86323 ** transactions are not able to rollback schema changes. */
86450 ** If the parent does not exist, removing the child row resolves an
86545 ** If the i'th column is not modified by the UPDATE, then the corresponding
86888 ** May you do good and not evil.
87116 assert( v ); /* We failed long ago if this is not so */
87260 ** The 3rd template is for when the second template does not apply
87261 ** and the SELECT clause does not read from <table> at any time.
87400 ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
87408 * (a) the table is not read-only,
87587 ** the index of the primary key as it appears in IDLIST, not as
87633 /* If this is not a view, open the table and and all indices */
87695 ** we do not know what the unique ID will be (because the insert has
87696 ** not happened yet) so we substitute a rowid of -1
87740 ** do not attempt any conversions before assembling the record.
87912 ** generating code because of a call to sqlite3NestedParse(), do not
87964 ** computed automatically in an insert or that the rowid value is not
87985 ** only (do not do a complete rollback) then
87991 ** transaction is not rolled back and any
88016 ** cursors do not need to be open for indices where aRegIdx[i]==0.
88026 int overrideError, /* Override onError to this if not OE_Default */
88044 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
88074 zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
88112 ** of the new record does not previously exist. Except, if this
88113 ** is an UPDATE and the primary key is not changing, that is OK.
88146 ** flag is not set, but the table has one or more indexes, call
88191 ** index and making sure that duplicate entries do not already exist.
88219 continue; /* pIdx is not a UNIQUE index */
88239 /* Generate code that executes if the new index entry is not unique */
88261 pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
88324 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
88475 ** (6) The SELECT statement is a simple (not a compound) select that
88479 ** tab2 over to tab1. The columns are not decoded. Raw records from
88484 ** of the conditions above fail so that the optimization should not
88514 return 0; /* tab1 must not have triggers */
88518 return 0; /* tab1 must not be a virtual table */
88535 return 0; /* SELECT may not have a WHERE clause */
88538 return 0; /* SELECT may not have an ORDER BY clause */
88540 /* Do not need to test for a HAVING clause. If HAVING is present but
88543 return 0; /* SELECT may not have a GROUP BY clause */
88546 return 0; /* SELECT may not have a LIMIT clause */
88550 return 0; /* SELECT may not be a compound query */
88553 return 0; /* SELECT may not be DISTINCT */
88572 return 0; /* FROM clause does not contain a real table */
88575 return 0; /* tab1 and tab2 may not be the same table */
88579 return 0; /* tab2 must not be a virtual table */
88583 return 0; /* tab2 may not be a view */
88624 ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
88650 /* If tables do not have an INTEGER PRIMARY KEY and there
88651 ** are indices to be copied and the destination is not empty,
88655 ** Or if the destination has a UNIQUE index and is not empty,
88733 ** May you do good and not evil.
88740 ** other files are for internal use by SQLite and should not be
88880 ** May you do good and not evil.
88900 ** May you do good and not evil.
88923 ** versions of SQLite will not be able to load each others' shared
89117 ** (part of the main SQLite library - not an extension) so that
89119 ** definition. But the main library does not want to redefine
89429 ** not NULL before calling it.
89565 ** of the APIs above provided that the pointer is not NULL. But
89692 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
89700 char **pzErrMsg /* Put error message here if not 0 */
89719 *pzErrMsg = sqlite3_mprintf("not authorized");
89780 char **pzErrMsg /* Put error message here if not 0 */
89805 ** default so as not to open security holes in older applications.
89821 ** The auto-extension code added regardless of whether or not extension
89823 ** code if regular extension loading is not available. This is that
89967 ** May you do good and not evil.
90122 ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
90178 /* Foreign key support may not be enabled or disabled while not
90365 ** the database has not yet been created.
90515 /* If the "=MODE" part does not match any known journal mode,
90648 ** page cache size value. It does not change the persistent
90670 ** the local value does not make changes to the disk file and the default
90710 sqlite3ErrorMsg(pParse, "not a writable directory");
90785 ** the local value does not make changes to the disk file and the
90796 "Safety level may not be changed inside a transaction");
91007 ** used will be case sensitive or not depending on the RHS.
91189 ** database. If the database is not initialized, it is initialized now.
91192 ** has not already been initialized. In this case it sets the default
91199 ** the main database has not been initialized and/or created when ATTACH
91233 /* Only change the value of sqlite.enc if the database handle is not
91235 ** will be overwritten when the schema is next loaded. If it does not
91279 ** The user-version is not used internally by SQLite. It may be used by
91495 ** May you do good and not evil.
91705 /* If there is not already a read-only (or read-write) transaction opened
91742 ** For an attached db, it is an error if the encoding is not the same
91792 ** not downgrade the database and thus invalidate any descending
91944 /* If there is not already a read-only (or read-write) transaction opened
91956 /* Read the schema cookie from the database. If it does not match the
92047 ** is not possible for another thread to start a new schema change
92048 ** while this routine is running. Hence, we do not need to hold
92053 ** but it does *not* override schema lock detection, so this all still
92234 ** version, the original SQL text is not saved in the prepared statement
92314 ** version, the original SQL text is not saved in the prepared statement
92355 ** May you do good and not evil.
92366 ** Delete all the content of a Select structure but do not deallocate
92406 Expr *pLimit, /* LIMIT value. NULL means not used */
92523 "RIGHT and FULL OUTER JOINs are not currently supported");
92531 ** is not contained in the table.
92548 ** If not found, return FALSE.
92625 ** join restriction specified in the ON or USING clause and not a part
92631 ** expression depends on table iRightJoinTable even if that table is not
92639 ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
92691 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
92730 ** not contained in both tables to be joined.
92746 "not present in both tables", zName);
92828 ** stack if the top N elements are not distinct.
92833 int addrRepeat, /* Jump to here if not distinct */
92887 ExprList *pOrderBy, /* If not NULL, sort results using this key */
92930 ** values returned by the SELECT are not required.
92938 ** and this row has been seen before, then do not make this row
93006 ** does not matter. But there might be a LIMIT clause, in which
93068 ** user-defined functions that have side effects. We do not care
93168 ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
93397 ** This is not a problem, as the column type of "t1.col" is never
93641 /* Make sure the column name is unique. If the name is not unique,
93675 ** The column list has only names, not types or collations. This
93780 ** (usually but not always -1) prior to calling this routine.
93927 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
93933 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
93957 " do not have the same number of result columns", selectOpName(p->op));
94487 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
94488 ** actually called using Gosub and they do not Return. EofA and EofB loop
94623 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
94961 ** (1) The subquery and the outer query do not both use aggregates.
94963 ** (2) The subquery is not an aggregate or the outer query is not a join.
94965 ** (3) The subquery is not the right operand of a left outer join
94968 ** (4) The subquery is not DISTINCT.
94974 ** (6) The subquery does not use aggregates or the outer query is not
94979 ** (8) The subquery does not use LIMIT or the outer query is not a join.
94981 ** (9) The subquery does not use LIMIT or the outer query does not use
94984 ** (10) The subquery does not use aggregates or the outer query does not
94987 ** (11) The subquery and the outer query do not both have ORDER BY clauses.
94992 ** (13) The subquery and outer query do not both use LIMIT.
94994 ** (14) The subquery does not use OFFSET.
94996 ** (15) The outer query is not part of a compound select or the
94997 ** subquery does not have a LIMIT clause.
95000 ** (16) The outer query is not an aggregate or the subquery does
95001 ** not contain ORDER BY. (Ticket #2942) This used to not matter
95004 ** (17) The sub-query is not a compound select, or it is a UNION ALL
95008 ** * is not itself part of a compound select,
95009 ** * is not an aggregate or DISTINCT query, and
95020 ** (19) The subquery does not use LIMIT or the outer query does not
95023 ** (20) If the sub-query is a compound select, then it must not use
95029 ** (21) The subquery does not use LIMIT or the outer query is not
95036 ** If flattening is not attempted, this routine is a no-op and returns 0.
95062 /* Check to see if flattening is permitted. Return 0 if not.
95078 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
95106 ** not used as the right operand of an outer join. Examples of why this
95107 ** is not allowed:
95115 ** which is not at all the same thing.
95120 ** An examples of why this is not allowed:
95134 ** subquery is the right term of a LEFT JOIN, then do not flatten.
95397 ** does not work if either limit is negative.
95452 ** where table is a database table, not a sub-select or view. If the query
95644 /* This particular expression does not need to be expanded.
95685 ** for virtual tables), do not include it in the expanded
95795 ** at that point because identifiers had not yet been resolved. This
96062 ** set is not empty.
96191 /* If the subquery is no correlated and if we are not inside of
96260 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
96288 ** we figure out that the sorting index is not needed. The addrSortIndex
96342 ** instruction ended up not being needed, then change the OP_OpenEphemeral
96475 ** that we do not need it after all, the OP_SorterOpen instruction
96511 ** we do not have to sort. The OP_OpenEphemeral table will be
96708 ** (2011-04-15) Do not do a full scan of an unordered index.
96710 ** In practice the KeyInfo structure will not be used. It is only
96751 ** where.c should not iterate over any values with a NULL value
96843 ** that follows does not appear in normal builds.
96850 ** These routine are not called anywhere from within the normal
96943 ** May you do good and not evil.
96952 ** These routines are in a separate files so that they will not be linked
96953 ** if they are not used.
97141 ** May you do good and not evil.
97235 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
97240 /* If TEMP was specified, then the trigger name may not be qualified. */
97242 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
97273 ** If sqlite3SrcListLookup() returns 0, indicating the table does not
97291 /* The table does not exist. */
97297 ** trigger is not visible to the database connection that does the
97310 /* Check that the trigger name is not reserved and that no trigger of the
97328 /* Do not create a trigger on a system table */
97433 /* if we are not initializing,
97913 ** program. It is not used in production code, only for debugging.
98080 /* If an existing TriggerPrg could not be located, create a new one. */
98120 ** not a foreign key action, and (b) the flag to enable recursive triggers
98153 ** never be accessed by the trigger program, so they are not allocated or
98156 ** are never accessed, and so are not allocated by the caller. So, for an
98158 ** is not a readable register, although registers (reg+N) through
98216 ** It is not possible to determine if the old.rowid or new.rowid column is
98267 ** May you do good and not evil.
98299 ** may not contain a value for the column and the default value, taken
98302 ** for the column and the P4 value is not required.
98315 ** If parameter iReg is not negative, code an OP_RealAffinity instruction
98367 ** aXRef[i]==-1 if the i-th column is not changed. */
98433 ** The index cursors might not be used, but if they are used they
98637 ** this record does not exist for some reason (deleted by a trigger,
98642 ** contain the new value. If the record number is not being modified,
98675 ** If there are one or more BEFORE triggers, then do not populate the
98676 ** registers associated with columns that are (a) not modified by
98677 ** this UPDATE statement and (b) not accessed by new.* references. The
98678 ** values for registers not modified by the UPDATE must be reloaded from
98680 ** may have modified them). So not loading those that are not going to
98694 /* This branch loads the value of a column that will not be changed
98724 /* If it did not delete it, the row-trigger may still have modified
98726 ** all columns not modified by the update statement into their
98807 ** generating code because of a call to sqlite3NestedParse(), do not
98939 ** May you do good and not evil.
99063 ** can be set to 'off' for this file, as it is not recovered if a crash
99109 /* Do not attempt to change the page size for a WAL database */
99197 ** transaction open on the vacuum database, but not on the main database.
99285 ** May you do good and not evil.
99425 ** Except, if argument db is not NULL, then the entry associated with
99525 ** The string is not copied - the pointer is stored. The
99669 ** record of the table. The xConnect() method is not called until
99770 const char *zFormat = "vtable constructor did not declare schema: %s";
99825 ** This call is a no-op if table pTab is not a virtual table.
99911 ** invoke it now. If the module has not been registered, return an
99999 ** This call is a no-op if zTab is not a virtual table.
100101 ** not currently open, invoke the xBegin method now.
100353 ** May you do good and not evil.
100417 ** If a term in the WHERE clause does not match either of the two previous
100460 #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */
100469 # define TERM_VNULL 0x00 /* Disabled if not using stat2 */
100514 ** clause, the cursor numbers might not begin with 0 and they might
100527 ** Note that the mapping is not necessarily ordered. In the example
100530 ** does not really matter. What is important is that sparse cursor
100564 #define WO_NOOP 0x800 /* This term does not restrict search space */
100579 ** ISNULL constraints will then not be used on the right table of a left
100589 #define WHERE_NOT_FULLSCAN 0x100f3000 /* Does not do a full table scan */
100640 ** itself is not freed. This routine is the inverse of whereClauseInit().
100665 ** 0 is returned if the new WhereTerm could not be added due to a memory
100744 ** iCursor is not in the set.
100868 ** is not commuted.
100918 ** Return a pointer to the term. Return 0 if not found.
100924 Bitmask notReady, /* RHS must not overlap with this mask */
100926 Index *pIdx /* Must be compatible with this index, if not NULL */
100989 ** so and false if not.
100992 ** literal that does not begin with a wildcard.
101087 ** If it is then return TRUE. If not, return FALSE.
101175 ** This analysis does not consider whether or not the index exists; that
101181 ** always prefer case 1, so in that case we pretend that case 2 is not
101195 ** zero. This term is not useful for search.
101321 ** will be recorded in iCursor and iColumn. There might not be any
101323 ** and column is found but leave okToChngToIN false if not found.
101338 ** chngToIN set but t1 is not. This term will be either preceeded
101491 extraRight = x-1; /* ON clause terms may not be used with an index
101655 ** virtual tables. The native query optimizer does not attempt
101691 ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a
101695 ** TERM_VNULL tag will suppress the not-null check at the beginning
101696 ** of the loop. Without the TERM_VNULL flag, the not-null check at
101792 ** DISTINCT qualifier. In other words, it tests whether or not using this
101817 ** are not simple column references, return early. Otherwise, test if the
101819 ** can be ignored. If it does not, and the column does not belong to the
101867 ** this query, then it will not be possible to show that the DISTINCT
101926 ** index do not need to satisfy this constraint.) The *pbRev value is
101976 /* Can not use an index sort on anything that is not a column in the
101997 /* Term j of the ORDER BY clause does not match column i of the index */
102007 /* If an index column fails to match and is not constrained by ==
102052 ** condition is IS NULL then the result is not necessarily unique
102061 ** The results need not be exact. This is only used for estimating
102138 Bitmask notReady, /* Mask of cursors not available for indexing */
102139 Bitmask notValid, /* Cursors not available for any purpose */
102252 Bitmask notReady, /* Mask of cursors that are not available */
102323 Bitmask notReady, /* Mask of cursors that are not available */
102377 ** be a covering index because the index will not be updated if the
102583 ** Whether or not an error is returned, it is the responsibility of the
102640 Bitmask notReady, /* Mask of cursors not available for index */
102641 Bitmask notValid, /* Cursors not valid for any purpose */
102662 /* If the sqlite3_index_info structure has not been previously
102741 ** does not satisfy it, increase the cost of the scan accordingly. This
102749 /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the
102935 ** If either of the upper or lower bound is not present, then NULL is passed in
103130 int nNotFound = 0; /* Count of values that are not constants */
103191 ** * Whether or not sorting must occur.
103193 ** * Whether or not there must be separate lookups in the
103211 Bitmask notReady, /* Mask of cursors not available for indexing */
103212 Bitmask notValid, /* Cursors not available for any purpose */
103231 /* If the pSrc table is the right table of a LEFT JOIN then we may not
103233 ** because columns might end up being NULL if the table does not match -
103318 ** IN operator must be a SELECT, not a value list, for this variable
103332 ** external sort (i.e. scanning the index being evaluated will not
103337 ** visited. In other words, true if this is not a covering index.
103344 ** of column c, but the first does not because columns a and b are
103357 int bLookup = 0; /* True if not a covering index */
103436 /* If currently calculating the cost of using an index (not the IPK
103459 ** constraint, do not let the estimate exceed half the rows in the table.
103469 ** and we do not think that values of x are unique and if histogram
103500 ** not give us data on the relative sizes of table and index records.
103560 ** matters if the current index is the least costly, so do not bother
103561 ** with this step if we already know this index will not be chosen.
103568 ** tables that are not in outer loops. If notReady is used here instead
103683 Bitmask notReady, /* Mask of cursors not available for indexing */
103684 Bitmask notValid, /* Cursors not available for any purpose */
103704 ** Disable a term in the WHERE clause. Except, do not disable the term
103705 ** if it controls a LEFT OUTER JOIN and it did not originate in the ON
103715 ** in the ON clause. The term is disabled in (3) because it is not part
103716 ** of a LEFT OUTER JOIN. In (1), the term is not disabled.
103721 ** Disabling a term causes that term to not be tested in the inner loop
103892 Bitmask notReady, /* Which parts of FROM have not yet been coded */
104139 int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
104388 ** should not have a NULL value stored in 'x'. If column 'x' is
104521 ** of the table column that the inequality contrains is not NULL.
104605 int untestedTerms = 0; /* Some terms not completely tested */
104680 ** terms from the notReady table could not be tested and will
104835 ** Note that the loops might not be nested in the order in which they
104910 Bitmask notReady; /* Cursors that are not yet positioned */
104996 ** the OR-to-IN transformation in exprAnalyzeOrTerm(). It is not helpful
105000 ** pTabList, not just the first nTabList tables. nTabList is normally
105025 ** add new virtual terms onto the end of the WHERE clause. We do not
105093 ** not be as small as it would be if the table really were the innermost
105095 ** that do not use indices. But this nRow reduction only happens if the
105112 ** is not possible to determine this with a simple greedy algorithm.
105121 Bitmask mask; /* Mask of tables not yet ready */
105123 int doNotReorder; /* True if this table should not be reordered */
105168 ** (1) The table must not depend on other tables that have not
105234 ** used for the scan. If not, then query compilation has failed.
105351 ** is not used, its name is just '{}'. If no index is used
105580 int not; /* True if the NOT keyword is present */
105699 ** original value of the token will not parse.
105718 ** YYERRORSYMBOL is the code number of the error symbol. If not
105761 /* Define the yytestcase() macro to be a no-op if is not already defined
105800 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
105801 ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
106297 ** but it does not parse, the type of the token is changed to ID and
106921 ** which appear on the RHS of the rule, but which are not used
107039 /* In SQLite, we never try to destroy a parser that was not successfully
107592 ** not set the value of its left-hand side nonterminal. Leaving the
107598 ** without this code, their parser segfaults. I'm not sure what there
107601 ** that it has not been previously stressed... (SQLite ticket #2172)
108244 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
108248 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
108256 if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108269 if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108552 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
108559 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
108566 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
108722 /* If we are not debugging and the reduce action popped at least
108879 ** The response to an error depends upon whether or not the
108933 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
108944 #else /* YYERRORSYMBOL is not defined */
108945 /* This is what we do if the grammar does not define ERROR:
108977 ** May you do good and not evil.
109026 ** returned. If the input is not a keyword, TK_ID is returned.
109043 ** or not a given identifier is really an SQL keyword. The same thing
109322 ** Ticket #1066. the SQL standard does not allow '$' in the
109559 /* Fall through into the next case if the '#' is not followed by
109744 /* If the pParse->declareVtab flag is set, do not delete any table
109779 ** May you do good and not evil.
109789 ** static links that do not use it.
109831 ** (0) INVALID We have not yet seen a non-whitespace character.
109873 ** is look for a semicolon that is not part of an string or comment.
109896 /* If triggers are not supported by this compile then the statement machine
110030 ** above, except that the parameter is required to be UTF-16 encoded, not
110064 ** May you do good and not evil.
110071 ** other files are for internal use by SQLite and should not be
110084 ** May you do good and not evil.
110116 ** May you do good and not evil.
110148 ** May you do good and not evil.
110204 ** If the following function pointer is not NULL and if
110226 ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
110239 ** calls to this routine should not block, of course. Otherwise the
110265 ** must be complete. So isInit must not be set until the very end
110273 ** there is not much SQLite is going to be able to do.
110285 ** mutex must not require support from the malloc subsystem.
110308 /* If rc is not SQLITE_OK at this point, then either the malloc
110309 ** subsystem could not be initialized or the system failed to allocate
110322 ** to the xInit method, so the xInit method need not be threadsafe.
110395 ** Undo the effects of sqlite3_initialize(). Must not be called while
110398 ** routine is not threadsafe. But it is safe to invoke this routine
110429 ** database connections or memory allocations. This routine is not
110547 /* The heap pointer is not NULL, then install one of the
110605 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
110733 ** If the padFlag argument is not NULL then space padding at the end
110803 ** database handle object, it does not close any savepoints that may be open
110819 ** if this is not the last copy of the function, do not invoke it. Multiple
110853 ** will not have called the xDisconnect() method on any virtual
110896 ** locks and does not require any further unlock-notify callbacks.
110946 ** So it needs to be freed here. Todo: Why not roll the temp schema into
111002 /* SQLITE_OK */ "not an error",
111028 /* SQLITE_NOTADB */ "file is encrypted or is not a database",
111201 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
111347 ** this routine is a no-op. If the function does not exist, then create
111595 ** not currently open in WAL mode.
111598 ** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
111788 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
111814 ** sqlite3_create_collation, and not generated by synthCollSeq(),
111875 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
111893 # error SQLITE_MAX_COLUMN must not exceed 32767
111906 ** A new lower limit does not shrink existing constructs.
111953 ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
112141 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
112202 ** do not block illegal combinations here, it could trigger
112356 /* Register all built-in functions, but do not attempt to read the
112608 ** Test to see whether or not the database connection is in autocommit
112609 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
112734 ** 2. The table is not a view and the column name identified an
112938 ** This action provides a run-time test to see whether or not
113021 ** number of keywords. Or if zWord is not a keyword, return 0.
113024 ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
113085 ** parameter if it exists. If the parameter does not exist, this routine
113107 ** May you do good and not evil.
113117 /* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
113135 ** is not NULL. This variable may only accessed while the STATIC_MASTER
113151 ** 3) If the argument db is not NULL, then none of the entries in the
113179 ** db is not currently a part of the list, this function is a no-op.
113194 ** that it is not already a part of the list.
113293 ** to the user because it requires a lock that will not be available
113440 ** May you do good and not evil.
113453 ** (in which case SQLITE_CORE is not defined), or
113462 ** bottom up in optimal fashion and are not updatable. Since trees
113482 ** the encoding is not the same. SQLite varints are big-endian
113525 ** The positions numbers are not stored literally but rather as two more
113736 ** May you do good and not evil.
113761 /* If not building as part of the core, include sqlite3ext.h. */
113839 ** sqlite3_tokenizer.pModule variable should not be initialised by
113930 ** May you do good and not evil.
113949 ** code should not attempt to access or modify the fields of this structure
114071 ** from that used by SQLite, so the maximum length is 10, not 9.
114206 ** pending data, including hash table overhead, but not malloc overhead.
114228 ** values do not contribution to the FTS computation; they are used for
114342 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
114597 ** input does not begin with a quote character, then this routine
114792 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
114885 ** There may not be whitespace surrounding the "=" character. The <value>
114886 ** term may be quoted, but the <key> may not.
114971 ** from left to write. If parameter zFunc is not NULL, then instead of
114982 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
115011 ** If argument zFunc is not NULL, then all but the first question mark
115021 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
115053 ** If *pp does not being with a decimal digit SQLITE_ERROR is returned and
115085 ** Regardless of whether or not an error is returned, it is the responsibility
115577 ** If piFirst is not NULL, then this function sets *piFirst to the blockid
115580 ** If piLast is not NULL, then *piLast is set to the right-most child node
115607 ** varints from the buffer) does not risk an overread. If zNode is a
115609 ** not make this guarantee explicitly, but in practice there are always
115692 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
115694 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
115698 ** It is possible that the range of returned leaf nodes does not contain
115702 ** never loads leaf nodes into memory), it is not possible to be sure.
115774 ** If pp is not NULL, then the contents of the position list are copied
115784 ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
115787 ** The following while-loop moves pEnd to point to the first byte that is not
115820 ** If pp is not NULL, then the contents of the column-list are copied
115823 ** is not copied into *pp.
115830 ** not part of a multi-byte varint.
115848 ** it is not possible to have a document with 2^31 terms.
115883 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
115888 ** returning (do not modify it if iCol==0). Return the total number of bytes
115994 ** when the *pp1 token appears before the *pp2 token, but not more than nToken
116127 ** entries that are not sufficiently NEAR entries in *pp1 removed.
116180 ** If *pp does not point to or past pEnd, then a single varint is read
116570 /* If iLevel is less than 0 and this is not a scan, include a seg-reader
116572 ** made by an fts4aux module, not an FTS table. In this case calling
116574 ** fts4aux are not completely populated. So it's easiest to filter these
116599 /* If zTerm is not NULL, and this segment is not stored entirely on its
116828 ** subsequently to determine whether or not an EOF was hit.
117518 ** segment b-tree (if the term is not a prefix or it is a prefix for which
117619 ** does not take deferred tokens into account.
117654 ** means that the phrase does not appear in the current row, doclist.pList
117760 ** If parameter bOptOk is true, then the phrase may (or may not) use the
117914 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
117931 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
117940 ** may be loaded incrementally, meaning doclist.aAll/nAll is not available.
117975 ** to phrases that are connected only by AND and NEAR operators (not OR or
117993 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
118049 ** of each doclist, has not yet been determined. Read the required
118154 ** one or more tokens will not be deferred.
118294 ** All positions in the pPhrase position list that are not sufficiently
118348 ** If the expression is of type FTSQUERY_PHRASE, and the expression is not
118358 ** 1. Deferred tokens are not taken into account. If a phrase consists
118360 ** the db. In this case the position-list is not populated at all.
118487 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
118497 ** constraints. In this case it returns 1. If the NEAR expression does not
118498 ** match the current row, 0 is returned. The position lists may or may not
118573 ** currently points to, or zero if it does not.
118575 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
118582 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
118596 /* If the NEAR expression does not match any rows, zero the doclist for
118598 ** offsets() and matchinfo() functions are not supposed to recognize
118608 ** then any snippet() should ony highlight the "a" term, not the "b"
118673 ** * Deferred tokens have not yet been considered.
118675 ** If *pRc is not SQLITE_OK when this function is called, it immediately
118676 ** returns 0. Otherwise, it tests whether or not after considering NEAR
118683 ** it is determined that the row does *not* match the query.
118742 ** fts3EvalNext() visits the first row. Do not allow incremental
118822 ** If it is not already allocated and populated, this function allocates and
118897 ** do loop can not be written:
118987 ** This function works regardless of whether or not the phrase is deferred,
119070 ** May you do good and not evil.
119351 ** integer encountered in state 1 is not 0 or 1, then we need to
119546 ** May you do good and not evil.
119565 ** a) The new syntax supports parenthesis. The old does not.
119567 ** b) The new syntax supports the AND and NOT operators. The old does not.
119569 ** c) The old syntax supports the "-" token qualifier. This is not
119584 ** generator. This module does not use actually lemon, it uses a
120009 ** TODO: Strangely, it is not possible to associate a column specifier
120262 ** column to match against for tokens for which a column name is not explicitly
120359 ** If the second argument is not NULL, then its contents are prepended to
120512 ** May you do good and not evil.
120526 ** (in which case SQLITE_CORE is not defined), or
120822 ** The key is not copied in this instance. If a malloc fails, then
120896 ** May you do good and not evil.
120909 ** (in which case SQLITE_CORE is not defined), or
121131 ** is not 'w', 'x', or 'y'.
121152 ** Return TRUE if zFrom matches. Return FALSE if zFrom does not
121159 const char *zTo, /* ... change the ending to this (not reversed) */
121220 ** If the input word contains not digits but does characters not
121245 /* The use of a character not in [a-zA-Z] means that we fallback
121542 ** May you do good and not evil.
121556 ** (in which case SQLITE_CORE is not defined), or
121578 ** to the string <key-name>. If <pointer> is not specified, then
121582 ** Whether or not the <pointer> argument is specified, the value returned
121909 ** This function is used for testing only, it is not included in the
122033 ** May you do good and not evil.
122046 ** (in which case SQLITE_CORE is not defined), or
122267 ** May you do good and not evil.
122381 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
122499 ** If argument apVal is not NULL, then it must point to an array with
122658 ** data from the fts3 table. If this lock is not acquired first, then
122668 ** not what users expect when they get SQLITE_LOCKED_SHAREDCACHE. It can
122947 /* Add the term to each of the prefix indexes that it is not too
123212 ** specific row is identified by the iBlockid parameter. If paBlob is not
123215 ** identified table row is. Whether or not paBlob is NULL, *pnBlob is set
123218 ** If an error occurs, or the table does not contain the specified row,
123430 /* Check that the doclist does not appear to extend past the end of the
123472 ** If arguments ppOffsetList and pnOffsetList are not NULL, then
123476 ** lists, not including the nul-terminator byte. For example:
123785 ** 1) EOF is greater than not EOF.
123820 ** 1) EOF (end of doclist in this case) is greater than not EOF.
124014 ** and the static node buffer (p->nNodeSize bytes) is not large
124018 ** this is not expected to be a serious problem.
124057 /* If control flows to here, it was not possible to append zTerm to the
124061 ** Otherwise, the term is not added to the new node, it is left empty for
124115 ** Except, if pTree is a root node, do not write it to the database. Instead,
124403 ** Return SQLITE_OK if successful, or an SQLite error code if not.
124489 ** a position list that may (or may not) feature multiple columns. This
124776 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
124780 ** of segment apSegment[0] is not a match, exit early.
125238 ** table, not for all rows.
125344 ** SQLite value pRowid contains the rowid of a row that may or may not be
125440 /* The new rowid is not NULL (in this case the rowid will be
125446 ** Or, if the conflict mode is not REPLACE, insert the new record into
125455 ** docid=$pNewRowid if $pNewRowid is not an integer value).
125537 ** May you do good and not evil.
125730 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
125733 ** pnToken is not NULL, then it is set to the number of tokens in all
125920 ** the snippet for which the corresponding mCovered bit is not set.
126056 ** This is done as part of extracting the snippet text, not when selecting
126058 ** is no way for fts3BestSnippet() to know whether or not the document
126192 ** required. They are required if (a) this is not the first fragment,
126193 ** or (b) this fragment does not begin at position 0 of its column.
126277 ** not available for deferred tokens.
126472 int nLive = 0; /* Number of iterators in aIter not at EOF */
126524 ** If it is false, then assume that those fields that do not change between
126649 ** cache does not match the format string for this request, discard
127038 ** May you do good and not evil.
127061 ** table. For each node that is not the root node of the r-tree, there is
127163 /* Size of hash table Rtree.aHash. This hash table is not expected to
127471 ** indicating that node has not yet been assigned a node number. It is
127612 ** If there is not enough free space in pNode, return SQLITE_FULL.
127881 ** Return non-zero if the cursor does not currently point to a valid
127967 ** returning. If the cell is not filtered (excluded) by the constraints,
128118 /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
128360 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
129327 ** If node pLeaf is not the root of the r-tree and its pParent pointer is
129348 /* Before setting pChild->pParent, test that we are not creating a
129458 /* If the node is not the tree root and now has less than the minimum
129818 /* If azData[0] is not an SQL NULL value, it is the rowid of a
129983 ** code is returned and the value of *piVal after returning is not defined.
130319 ** May you do good and not evil.
130601 ** pointer. This is not really necessary, but it is tidier than
130821 ** May you do good and not evil.