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
326 ** Unfortunately, that typedef is not available on all compilers, or
378 ** It determines whether or not the features related to
379 ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
414 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
430 ** not doing a threadsafe build. Ticket #2681.
490 ** to setup for a later assert() statement. We do not want this code to
515 ** not be counted as untested code.
557 ** May you do good and not evil.
564 ** or constant definition does not appear in this file, then it is
565 ** not a published API of SQLite, is subject to change without
566 ** notice, and should not be referenced by programs that use SQLite.
570 ** features recently added to SQLite. We do not anticipate changes
610 ** should not use deprecated interfaces - they are support for backwards
624 ** Ensure these symbols were not defined by some previous header file.
685 ** function is provided for use in DLLs since DLL users usually do not have
737 ** the mutexes are omitted. Without the mutexes, it is not safe
756 ** thread safety, not any run-time changes to that setting made by
836 ** [sqlite3_open_v2()], and not previously closed.
845 ** compatibility and is not documented.
861 ** sqlite3_exec() is not NULL, then it is invoked for each result row
871 ** is not NULL then any error message is written into memory obtained
876 ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
897 ** is not changed.
904 ** <li> The application must not close [database connection] specified by
906 ** <li> The application must not modify the SQL statement text passed into
954 #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
958 #define SQLITE_NOTADB 26 /* File opened that is not a database file */
970 ** these result codes are too coarse-grained. They do not provide as
1104 ** information need not be flushed. If the lower four bits of the flag
1109 ** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
1161 ** and not its inode needs to be synced.
1190 ** return [SQLITE_NOTFOUND] for file control opcodes that they do not
1272 ** current transaction. This hint is not guaranteed to be accurate but it
1295 ** VFSes do not need this signal and should silently ignore this opcode.
1296 ** Applications should not call [sqlite3_file_control()] with this
1312 ** is not changed but instead the prior value of that setting is written
1321 ** close. Persisting the files is useful when other processes that do not
1352 ** pointer in case this file-control is not implemented. This file-control
1393 ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1456 ** that does not care about crash recovery or rollback might make
1481 ** It is <i>not</i> used to indicate the file should be opened
1486 ** argument to xOpen. The xOpen method does not have to
1504 ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
1509 ** interfaces are not strictly a part of the filesystem, but they are
1523 ** greater and the function pointer is not NULL) and will fall back
1527 ** are not used by the SQLite core. These optional interfaces are provided
1535 ** from one release to the next. Applications must not attempt to access
1649 ** SQLite normally do not need to invoke either of these routines.
1664 ** is not. The sqlite3_shutdown() interface must only be called from a
1679 ** SQLite interfaces so that an application usually does not need to
1682 ** initialized when [sqlite3_open()] is called if it has not be initialized
1727 ** applications and so this routine is usually not necessary. It is
1730 ** The sqlite3_config() interface is not threadsafe. The application
1820 ** the xInit method, so the xInit method need not be threadsafe. The
1822 ** not need to be threadsafe either. For all other methods, SQLite
1866 ** it is not possible to change the [threading mode] from its default
1881 ** it is not possible to set the Multi-thread [threading mode] and
1897 ** it is not possible to set the Serialized [threading mode] and
1952 ** This configuration should not be used if an application-define page
1979 ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
2036 ** and a pointer to void. ^If the function pointer is not NULL, it is
2046 ** The SQLite logging interface is not reentrant; the logger function
2047 ** supplied by the application must not invoke any SQLite interface.
2057 ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
2066 ** <dd> These options are obsolete and should not be used by new code.
2116 ** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
2119 ** connection is not currently using lookaside memory, or in other words
2134 ** which case the FK enforcement setting is not reported back. </dd>
2144 ** which case the trigger setting is not reported back. </dd>
2168 ** names are not also used by explicitly declared columns. ^If
2186 ** ^An [INSERT] that fails due to a constraint violation is not a
2187 ** successful [INSERT] and does not change the value returned by this
2191 ** encounters a constraint violation, it does not fail. The
2206 ** unpredictable and might not equal either the old or the new
2219 ** triggers or [foreign key actions] are not counted.)^ Use the
2224 ** are not counted. Only real table changes are counted.
2230 ** mechanisms do not count as direct row changes.)^
2241 ** not create a new trigger context.
2253 ** However, the number returned does not include changes
2261 ** is unpredictable and not meaningful.
2273 ** the count does not include changes used to implement [REPLACE] constraints,
2275 ** count does not include rows of views that fire an [INSTEAD OF trigger],
2287 ** returned is unpredictable and not meaningful.
2302 ** is not safe to call this routine with a [database connection] that
2306 ** sqlite3_interrupt() is called, then it might not have an opportunity
2320 ** not effected by the sqlite3_interrupt().
2338 ** complete if it ends with a semicolon token and is not a prefix of a
2340 ** string literals or quoted identifier names or comments are not
2342 ** embedded) and thus do not count as a statement terminator. ^Whitespace
2348 ** ^These routines do not parse the SQL statements thus
2349 ** will not detect syntactically incorrect SQL.
2351 ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
2355 ** regardless of whether or not the input SQL is complete.)^
2375 ** is not NULL, then the callback might be invoked with two arguments.
2386 ** The presence of a busy handler does not guarantee that it will be invoked
2405 ** changes will not fit into the in-memory cache. SQLite will
2423 ** The busy callback should not take any actions which modify the
2427 ** A busy handler must not close the database connection
2456 ** Use of this interface is not recommended.
2463 ** these numbers are not part of the result table itself. These
2475 ** It is not safe to pass a result table directly to [sqlite3_free()].
2513 ** function must not try to call [sqlite3_free()] directly. Only
2517 ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
2520 ** wrapper layer outside of the internal [sqlite3_exec()] call are not
2638 ** does not include operating-system specific VFS implementation. The
2657 ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
2674 ** is not freed.
2697 ** not yet been released.
2699 ** The application must not read or write any part of
2715 ** of memory currently outstanding (malloced but not freed).
2721 ** but not overhead added by the any underlying system library
2798 ** do not try to access data they are not allowed to see, or that they do not
2802 ** not want the user to be able to make arbitrary changes to the
2817 ** The authorizer callback must not do anything that will modify
2828 ** [sqlite3_prepare()] or its variants. Authorization is not
2844 ** to signal SQLite whether or not the action is permitted. See the
2961 ** The progress handler callback must not do anything that will modify
2989 ** Whether or not an error occurs when it is opened, resources
3003 ** <dd>The database is opened in read-only mode. If the database does not
3013 ** it does not already exist. This is the behavior that is always used for
3017 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
3024 ** mode has not been set at compile-time or start-time. ^If the
3029 ** eligible to use [shared cache mode], regardless of whether or not shared
3031 ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
3066 ** "localhost". ^If the authority is not an empty string or "localhost", an
3072 ** then it is interpreted as an absolute path. ^If the path does not begin
3097 ** "rw", then the database is opened for read-write (but not create)
3098 ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
3115 ** ^Specifying an unknown parameter in the query component of a URI is not an
3131 ** An error. "darkstar" is not a recognized authority.
3135 ** C:. Note that the %20 escaping in this example is not strictly
3140 ** Regardless of whether or not shared-cache mode is enabled by
3145 ** An error. "readonly" is not a valid option for the "mode" parameter.
3158 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3190 ** parameter if it exists or a NULL pointer if P does not appear as a
3198 ** a non-zero number and is false otherwise. If P is not a query parameter
3202 ** 64-bit signed integer and returns that integer, or D if P does not
3207 ** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and
3208 ** is not a database file pathname pointer that SQLite passed into the xOpen
3232 ** The application does not need to worry about freeing the result.
3248 ** error code and message may or may not be set.
3300 ** ^Regardless of whether or not the limit was changed, the
3351 ** used to implement an SQL statement. This limit is not currently
3395 ** [sqlite3_open16()]. The database connection must not have been closed.
3413 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3424 ** ppStmt may not be NULL.
3522 ** But because the [SELECT] statement does not change the database file
3527 ** since the statements themselves do not actually modify the database but
3531 ** change the configuration of a database connection, they do not make
3541 ** [sqlite3_step(S)] but has not run to completion and/or has not
3543 ** interface returns false if S is a NULL pointer. If S is not a
3544 ** NULL pointer and is not a pointer to a valid [prepared statement]
3568 ** whether or not it requires a protected sqlite3_value.
3570 ** The terms "protected" and "unprotected" refer to whether or not
3581 ** sqlite3_value objects even when not strictly required.
3648 ** number of <u>bytes</u> in the value, not the number of characters.)^
3666 ** information is in static, unmanaged space and does not need to be freed.
3686 ** ^Bindings are not cleared by the [sqlite3_reset()] routine.
3740 ** ^The first host parameter has an index of 1, not 0.
3773 ** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
3784 ** statement that does not return data (for example an [UPDATE]).
3844 ** subquery and is not a column value, then all of these functions return
3876 ** returned result set of that [SELECT] is a table column (not an
3894 ** is declared to contain a particular type does not mean that the
3896 ** strongly typed, but the typing is dynamic not static. ^Type
3897 ** is associated with individual values, not with the containers
3926 ** statement. If the statement is not a [COMMIT] and occurs within an
3931 ** successfully. sqlite3_step() should not be called again on this virtual
3941 ** violation) has occurred. sqlite3_step() should not be called again on
3963 ** than returning [SQLITE_MISUSE]. This is not considered a compatibility
3987 ** ^If prepared statement P does not have results ready to return
4020 ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
4049 ** If the SQL statement does not currently point to a valid row, or if the
4090 ** [sqlite3_column_bytes16()] do not include the zero terminators at the end
4093 ** bytes in the string, not the number of characters.
4137 ** and atof(). SQLite does not really use these functions. It has its
4161 ** not invalidate a prior pointer, though of course the content of the buffer
4164 ** are not possible and in those cases prior pointers are invalidated.
4178 ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
4180 ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
4186 ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned
4221 ** to [sqlite3_step()] regardless of whether or not the statement has
4255 ** ^The [sqlite3_reset(S)] interface does not change the values
4282 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
4303 ** If there is only a single implementation which does not care what text
4318 ** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
4344 ** SQLite interfaces. However, such calls must not
4401 ** using these functions, we are not going to tell you what they do.
4495 ** the same aggregate function instance will not resize the memory
4548 ** does not need to be recompiled on each invocation.
4561 ** not been destroyed.
4562 ** ^If it is not NULL, SQLite will invoke the destructor
4588 ** and will never change. It does not need to be destroyed. ^The
4637 ** bytes (not characters) from the 2nd parameter as the error message.
4674 ** is non-negative, then as many bytes (not characters) of the text
4688 ** assumes that the text or BLOB result is in constant space and does not
4795 ** ^The xDestroy callback is <u>not</u> called if the
4871 ** The code to implement this API is not available in the public release
4880 ** Change the key on an open database. If the current database is not
4884 ** The code to implement this API is not available in the public release
4917 ** If the operating system does not support sleep requests with
4924 ** of the default VFS is not implemented correctly, or not implemented at
4940 ** It is not safe to read or modify this variable in more than one
4941 ** thread at a time. It is not safe to read or modify this variable
4966 ** zero if the given database connection is or is not in autocommit mode,
5023 ** connection and in particular must not be a NULL pointer.
5047 ** The commit and rollback hook callbacks are not reentrant.
5048 ** The callback implementation must not do anything that will modify
5068 ** ^The rollback callback is not invoked if a transaction is
5097 ** ^(The update hook is not invoked when internal system tables are
5101 ** is not invoked when duplication rows are deleted because of an
5107 ** The update hook implementation must not do anything that will modify
5167 ** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5208 ** ^(The soft heap limit is not enforced in the current implementation
5224 ** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
5299 ** not null: 0
5337 ** ^If an error occurs and pzErrMsg is not 0, then the
5353 char **pzErrMsg /* Put error message here if not 0 */
5359 ** ^So as not to open security holes in older applications that are
5419 ** If this is a problem for you, do not use the interface at this time.
5446 ** of this structure must not change while it is registered with
5521 ** virtual table and is not checked again by SQLite.)^
5554 unsigned char omit; /* Do not code a test for this constraint */
5596 ** invoke the destructor function (if it is not NULL) when SQLite
5686 ** the new function is not good for anything by itself. Its only
5696 ** If this is a problem for you, do not use the interface at this time.
5729 ** ^It is not possible to open a column that is part of an index or primary
5731 ** not possible to open a column that is part of a [child key] for writing.
5733 ** ^Note that the database name is not the filename that contains
5755 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
5760 ** the opened blob. ^The size of a blob may not be changed by this
5794 ** the nominated column.)^ ^If the new row is not present in the table, or if
5795 ** it does not contain a blob or text value, or if another error occurs, an
5839 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5865 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5880 ** ^If the [BLOB handle] passed as the first argument was not opened for
5885 ** not possible to increase the size of a BLOB using this API.
5894 ** before the [BLOB handle] expired are not rolled back by the
5903 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5980 ** that means that a mutex could not be allocated. ^SQLite
5998 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
5999 ** The mutex implementation does not need to make a distinction
6001 ** not want to. ^SQLite will only request a recursive mutex in
6023 ** dynamic mutex that it allocates. The dynamic mutexes must not be in
6041 ** ^(Some systems (for example, Windows 95) do not support the operation
6048 ** is undefined if the mutex is not currently entered by the
6049 ** calling thread or is not currently allocated. SQLite will
6073 ** does not provide a suitable implementation. In this case, the user
6109 ** by this structure are not required to handle this case, the results
6119 ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
6120 ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
6152 ** defined and if NDEBUG is not defined.
6155 ** is held or not held, respectively, by the calling thread.
6157 ** ^The implementation is not required to provide versions of these
6158 ** routines that actually work. If the implementation does not provide working
6160 ** return true so that one does not get spurious assertion failures.
6164 ** clearly the mutex cannot be held if it does not exist. But
6165 ** the reason the mutex does not exist is because the build is not
6166 ** using mutexes. And we do not want the assert() containing the
6227 ** case is a short-circuit path which does not actually invoke the
6230 ** ^If the second parameter (zDbName) does not match the name of any
6232 ** code is not remembered and will not be recalled by [sqlite3_errcode()]
6250 ** This interface is not for use by applications. It exists solely
6252 ** on how the SQLite library is compiled, this interface might not exist.
6256 ** Unlike most of the SQLite API, this function is not guaranteed to
6269 ** Applications should not use any of these parameters or the
6301 ** *pHighwater is written. ^(Some parameters do not record the highest
6304 ** ^(Other parameters record only the highwater mark and not the current
6310 ** This routine is threadsafe but is not atomic. This routine can be
6336 ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
6355 ** value returned is in pages, not in bytes.</dd>)^
6360 ** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
6376 ** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not
6383 ** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
6573 ** improvement performance by adding permanent indices that do not
6653 ** so the xInit method need not be threadsafe. ^The
6655 ** not need to be threadsafe either. All other methods must be threadsafe
6664 ** though this is not guaranteed. ^The
6676 ** does not have to do anything special based with the value of bPurgeable;
6689 ** parameter, the implementation is not required to do anything with this
6711 ** intact. If the requested page is not already in the cache, then the
6716 ** <tr><th> createFlag <th> Behaviour when page is not already in cache
6717 ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
6739 ** The cache must not perform any reference counting. A single
6747 ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
6760 ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
6766 ** is not obligated to free any memory, but well-behaved implementations should
6789 ** by sqlite3_pcache_methods2. This object is not used by SQLite. It is
6832 ** it is not locked continuously for the entire backup operation.
6918 ** on the destination file. ^The exclusive lock is not released until either
6923 ** ^Because the source database is not locked between calls to
6940 ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
6943 ** and may not be used following a call to sqlite3_backup_finish().
6946 ** sqlite3_backup_step() errors occurred, regardless or whether or not
6953 ** is not a permanent error and does not affect the return value of
6967 ** operation, then the values are not updated to account for any extra
6980 ** [database connection] is not passed to any other API (by any thread) after
6982 ** sqlite3_backup_finish(). SQLite does not currently check to see
6990 ** is not accessed while the backup is running. In practice this means
6992 ** backed up to is not accessed by any connection within the process,
6993 ** not just the specific connection that was passed to sqlite3_backup_init().
6998 ** APIs are not strictly speaking threadsafe. If they are invoked at the
7061 ** The unlock-notify callback is not reentrant. If an application invokes
7157 ** The zFormat string must not be NULL.
7160 ** will not use dynamically allocated memory. The log message is stored in
7192 ** that does not correspond to any valid SQLite error code, the results
7241 ** connection D. ^If the database connection D is not in
7272 ** but not database readers.
7280 ** but not database readers.
7283 ** If pnLog is not NULL, then *pnLog is set to the total number of frames in
7284 ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7294 ** busy-handler configured, it will not be invoked in this case.
7318 ** If database zDb is the name of an attached database that is not in WAL
7320 ** zDb is not NULL (or a zero length string) and is not the name of any
7371 ** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not
7393 ** return SQLITE_OK. Or, if this is not possible, it may return
7450 ** May you do good and not evil.
7511 ** May you do good and not evil.
7528 ** code should not attempt to access or modify the fields of this structure
7832 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
7840 ** GCC does not define the offsetof() macro so we'll have to do it
7849 ** not, there are still machines out there that use EBCDIC.)
8033 ** not support Writable Static Data (WSD) such as global and static variables.
8062 ** implementation of an SQL aggregate step callback may not use the
8066 ** When a function parameter is not used at all within the body of a function,
8069 ** parameters that may or may not be used depending on compilation options.
8136 ** May you do good and not evil.
8161 #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
8188 #define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */
8332 ** If we are not using shared cache, then there is no need to
8382 ** May you do good and not evil.
8480 #define P4_NOTUSED 0 /* The P4 parameter is not used */
8503 ** function should *not* try to free the KeyInfo.
8541 /* Automatically generated. Do not edit */
8811 ** May you do good and not evil.
8835 ** is called page 1. 0 is used to represent "not a page".
8864 #define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */
9000 ** May you do good and not evil.
9032 ** and should not be accessed by other modules.
9047 #define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */
9165 ** May you do good and not evil.
9269 /* If the SET_FULLSYNC macro is not defined above, then make it
9301 ** enough to know that calling the developer will not help get rid
9320 ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
9335 ** those functions are not available. So we use only LockFile() and
9338 ** LockFile() prevents not just writing but also reading by other processes.
9380 ** file format. Depending on how it is changed, you might not notice
9459 ** May you do good and not evil.
9470 ** NOTE: source files should *not* #include this header file directly.
9542 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
9625 ** lookaside allocations are not used to construct the schema objects.
9656 ** insert statement. Inserts on views do not affect its value. Each
9662 ** The sqlite.nChange does not count changes within triggers and keeps no
9668 ** within a trigger is not seen outside the trigger. Changes to views do not
9691 u8 suppressErr; /* Do not issue error messages if true */
9766 int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
9770 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
9809 #define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */
9876 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
10008 ** collating sequence may not be read or written.
10068 ** implementation. sqlite3_vtab* handles can not be shared between
10087 ** schema is being reloaded for some reason), the VTable objects are not
10088 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
10117 ** CREATE TABLE statement is stored, but case is not significant for
10137 ** refers VDBE cursor number that holds the table open, not to the root
10144 int iPKey; /* If not negative, use aCol[iPKey] as the primary key */
10185 ** Test to see whether or not a table is a virtual table. This is
10213 ** which is attached to the from-table. The to-table need not exist when
10214 ** the from-table is created. The existence of the to-table is not checked.
10239 ** but the transaction is not rolled back. FAIL processing means that
10241 ** changes due to the same operation are not backed out and no rollback
10243 ** error is not inserted or updated. Processing continues and no error
10262 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
10334 ** The Index.onError field determines whether or not the indexed columns
10335 ** must be unique and what to do if they are not. When Index.onError=OE_None,
10336 ** it means this is not a unique index. Otherwise it is a unique index
10358 tRowcnt avgEq; /* Average nEq value for key values not in aSample */
10386 ** may contain random values. Do not make any assumptions about Token.dyn
10405 ** fields do not need to be freed when deallocating the AggInfo structure.
10516 ** allocated, regardless of whether or not EP_Reduced is set.
10520 char affinity; /* The affinity of the column or 0 if not a column */
10569 #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */
10579 #define EP_Static 0x8000 /* Held in memory not obtained from malloc() */
10591 ** so as not to burden production code.
10629 ** field is not used.
10780 ** is intended to be private the the where.c module and should not be
10812 /* The following field is really not part of the current level. But
10831 #define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */
10903 ** limit and nOffset to the value of the offset (or 0 if there is not
10911 ** as the OP_OpenEphm instruction is coded because not
10930 Expr *pLimit; /* LIMIT expression. NULL means not used. */
10931 Expr *pOffset; /* OFFSET expression. NULL means not used. */
10956 #define SRT_Exists 3 /* Store 1 if the result is not empty */
10957 #define SRT_Discard 4 /* Do not save the results anywhere */
10987 ** information in case inserts are down within triggers. Triggers do not
11274 ** do not necessarily know how big the string will be in the end.
12007 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
12041 ** is not defined.
12129 ** that allocations that might have been satisfied by lookaside are not
12150 #define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */
12162 ** May you do good and not evil.
12174 ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
12240 ** non-ASCII UTF character. Hence the test for whether or not a character is
12384 ** May you do good and not evil.
12745 ** was used and false if not.
12748 ** is not required for a match.
12785 ** May you do good and not evil.
12802 ** May you do good and not evil.
12900 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
12961 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
12989 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
13010 ** Return true if a memory cell is not marked as invalid. This macro
13124 int iStatement; /* Statement number (or 0 if has not opened stmt) */
13134 FILE *trace; /* Write an execution trace here, if not NULL */
13336 ** 32-bit integer is an atomic operation. If that assumption is not true,
13337 ** then this routine is not threadsafe.
13514 ** May you do good and not evil.
13640 ** A missing specifier is not considered an error.
13762 ** on success and 1 if the input string is not a well-formed
13917 ** If the user has not indicated to use localtime_r() or localtime_s()
14644 ** May you do good and not evil.
14657 ** The default SQLite sqlite3_vfs implementations do not allocate
14740 ** when simply tossing information over the wall to the VFS and we do not
14849 ** (if iVersion is 2 or greater and the function pointer is not NULL) and
15002 ** May you do good and not evil.
15015 ** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily
15017 ** is completely recoverable simply by not carrying out the resize. The
15091 ** May you do good and not evil.
15099 ** here always fail. SQLite will not operate with these drivers. These
15152 ** May you do good and not evil.
15196 #else /* if not __APPLE__ */
15212 #endif /* __APPLE__ or not __APPLE__ */
15338 /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
15401 ** May you do good and not evil.
15504 int disallow; /* Do not allow memory allocation */
15931 ** May you do good and not evil.
15953 ** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
15974 ** a header that is not returned to the user.
15986 ** not be read or written.
16049 ** of the current master. iMaster is 0 if there is not master chunk.
16050 ** The master chunk is not in either the aiHash[] or aiSmall[].
16141 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
16191 ** is not large enough, return 0.
16233 ** linked into the hash tables. That is not the normal state of
16537 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
16594 ** is not required to be threadsafe (it is not).
16620 ** May you do good and not evil.
16688 ** it is not actually possible to reach this limit.
16696 #define CTRL_FREE 0x20 /* True if not checked out */
16798 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
16879 ** block. If not, then split a block of the next larger power of
17064 ** This routine is not threadsafe. The caller must be holding a mutex
17086 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
17203 ** May you do good and not evil.
17230 /* If the xMutexAlloc method has not been set, then the user did not
17326 ** is not currently entered. If a NULL pointer is passed as an argument
17358 ** May you do good and not evil.
17365 ** This implementation in this file does not provide any mutual
17423 ** and debugging purposes. The mutexes still do not provide any
17457 ** that means that a mutex could not be allocated.
17519 ** is undefined if the mutex is not currently entered or
17520 ** is not currently allocated. SQLite will never do either.
17566 ** May you do good and not evil.
17612 ** that means that a mutex could not be allocated.
17629 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17630 ** The mutex implementation does not need to make a distinction
17632 ** not want to. But SQLite will only request a recursive mutex in
17801 ** is undefined if the mutex is not currently entered or
17802 ** is not currently allocated. SQLite will never do either.
17842 ** May you do good and not evil.
17895 ** not an atomic operation, then these routines might delivery
17898 ** told that HPUX is not such a platform. If so, then these routines
17899 ** will not always work correctly on HPUX.
17901 ** On those platforms where pthread_equal() is not atomic, SQLite
17924 ** that means that a mutex could not be allocated. SQLite
17941 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17942 ** The mutex implementation does not need to make a distinction
17944 ** not want to. But SQLite will only request a recursive mutex in
17978 /* If recursive mutexes are not available, we will have to
18046 /* If recursive mutexes are not available, then we have to grow
18050 ** that are not equal to self while the comparison is taking place.
18054 ** are not met, then the mutexes will fail and problems will result.
18089 /* If recursive mutexes are not available, then we have to grow
18093 ** that are not equal to self while the comparison is taking place.
18097 ** are not met, then the mutexes will fail and problems will result.
18138 ** is undefined if the mutex is not currently entered or
18139 ** is not currently allocated. SQLite will never do either.
18195 ** May you do good and not evil.
18236 ** WinNT/2K/XP so that we will know whether or not we can safely call
18294 ** processing, the "interlocked" magic is probably not
18334 ** that means that a mutex could not be allocated. SQLite
18351 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
18352 ** The mutex implementation does not need to make a distinction
18354 ** not want to. But SQLite will only request a recursive mutex in
18479 ** is undefined if the mutex is not currently entered or
18480 ** is not currently allocated. SQLite will never do either.
18529 ** May you do good and not evil.
18542 ** cache database pages that are not currently in use.
18549 ** is a no-op returning zero if SQLite is not compiled with
18865 ** This routine is similar to alloca() in that it is not intended
18868 ** structures that would not normally fit on the stack of an
19283 ** If the first argument, db, is not NULL and a malloc() error has occurred,
19288 /* If the db handle is not NULL, then we must hold the connection handle
19331 /* The rest are extensions, not normally found in printf() */
19840 ** Note that the number is in the usual order, not reversed as with
19846 ** set and we are not left justified */
19929 ** consume, not the length of the output...
20181 ** are not able to use a "," as the decimal point in place of "." as
20243 ** The printf() built into some versions of windows does not understand %lld
20281 ** May you do good and not evil.
20307 ** Why not just use a library random generator like lrand48() for this?
20310 ** well be good enough. But maybe not. Or maybe lrand48() has some
20316 ** (Later): Actually, OP_NewRowid does not depend on a good source of
20339 ** not need to contain a lot of randomness since we are not
20344 ** number generator) not as an encryption device.
20428 ** May you do good and not evil.
20571 ** for unicode values 0x80 and greater. It do not change over-length
20621 ** encoding, or if *pMem does not contain a string value.
20761 ** the encoding of the Mem adjusted. This routine does not do any
20800 ** return the number of unicode characters in pZ up to (but not including)
20801 ** the first 0x00 byte. If nByte is not less than zero, return the
20822 /* This test function is not currently used by the automated test-suite.
20989 ** May you do good and not evil.
21028 ** found that many systems do not have a working isnan() function so
21049 # error SQLite will not work correctly with the -ffast-math option of GCC.
21081 ** If it is not NULL, string zFormat specifies the format of the
21151 ** input does not begin with a quote character, then this routine
21225 ** The string z[] is length bytes in length (bytes, not characters) and
21226 ** uses the encoding enc. The string is not necessarily zero-terminated.
21253 int eValid = 1; /* True exponent is either not used or is well-formed */
21443 ** If zNum is too big for a 64-bit integer and is not
21446 ** length is the number of bytes in the string (bytes, not characters).
21447 ** The string is not necessarily zero-terminated. The encoding is
21556 ** string is not an integer, just return 0.
21931 ** file. In that case we are not in any hurry. Use the (relatively
22017 ** not have been used. The "type" of connection pointer is given as the
22028 ** Check to make sure we have a valid db pointer. This test is not
22032 ** 1 it means that the db pointer is valid and 0 if it should not be
22038 ** open properly and is not fit for general use but which can be
22179 ** May you do good and not evil.
22272 ** Return TRUE if the resize occurs and false if not.
22286 ** a performance hit but it is not a fatal error. So mark the
22313 int nKey, /* Bytes in key (not counting zero terminator) */
22398 ** The key is not copied in this instance. If a malloc fails, then
22452 /* Automatically generated. Do not edit */
22620 ** May you do good and not evil.
22638 ** malloc failures happen frequently. OS/2 does not typically run on
22640 ** problems to worry about than running out of memory. So there is not
22643 ** But there is a good reason to not use the wrappers. If we use the
22647 ** the OS driver, but the code to deal with those failure would not
22648 ** be exercised on Linux (which does not need to malloc() in the driver)
22655 ** desktops but not so well in embedded systems.
22659 ** Macros used to determine whether or not to use threads.
22676 ** May you do good and not evil.
22686 ** This file should be #included by the os_*.c files only. It is not a
22694 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
22729 ** May you do good and not evil.
23134 ** It is not possible to lower the locking level one step at a time. You
23178 /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
23316 ** It is not possible for this routine to fail if the second argument
23696 ** Find an os2ShmNode in global list or allocate a new one, if not found.
23698 ** This is not a VFS shared-memory method; it is a utility function called
23803 ** This is not a VFS shared-memory method; it is a utility function called
23876 ** region has not been allocated (by any client, including one running in a
23878 ** bExtend is non-zero and the requested shared-memory region has not yet
23883 ** address space (if it is not already), *pp is set to point to the mapped
24002 ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n",
24024 ** not go from shared to exclusive or from exclusive to shared.
24229 * Trailing spaces are not allowed, either. */
24362 ** The handle should not be inherited by child processes and we don't
24373 /* Creates a new file, only if it does not already exist. */
24469 ** as if it does not exist.
24511 ** os2Dlopen returns zero if DosLoadModule is not successful.
24521 /* if the symbol itself was not found, search again for the same
24593 ** might be greater than or equal to the argument, but not less
24684 ** then it is not necessary to include the nul-terminator character
24754 ** May you do good and not evil.
24785 ** * sqlite3_file methods not associated with locking.
24841 ** without this option, LFS is enable. But LFS does not exist in the kernel
24926 ** Only set the lastErrno if the error code is a real error and not
24977 /* The next group of variables are used to track whether or not the
25023 ** May you do good and not evil.
25033 ** This file should be #included by the os_*.c files only. It is not a
25041 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
25076 ** May you do good and not evil.
25296 ** that always succeeds. This means that locking does not occur under
25422 ** Return the value of a system call. Return NULL if zName is not a
25442 ** is the last system call or if zName is not the name of a valid
25596 /* At one point this code was not commented out. In theory, this branch
25621 /* EACCES is like EAGAIN during locking operations, but not any other time*/
25659 #ifdef ESTALE /* ESTALE is not defined on Interix systems */
25676 ** the device number and the inode number. But this does not work on VxWorks.
25685 ** There are never very many files open at one time and lookups are not
25816 ** by the same process. It does not explicitly say so, but this implies
25828 ** But not so. Since both locks came from the same process, the
25834 ** to synchronize access for threads in separate processes, but not
25846 ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
25879 ** Yet another problem: LinuxThreads do not play well with posix locks.
25882 ** not posix compliant. Under LinuxThreads, a lock created by thread
25889 ** compile-time whether or not thread A can override locks on thread B.
25897 ** do not move across threads.
25973 /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
26000 /* This is a threadsafe build, but strerror_r() is not available. */
26025 ** Note that it is not safe to retry close() after EINTR since the
26120 ** around this problem (we consider it a bug in OS X, not SQLite)
26229 ** operating system does not participate.
26314 ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
26325 ** range' is that some versions of windows do not support read-locks. By
26483 ** write operation (not a hot journal rollback).
26562 ** file changed. If the transaction counter is not updated,
26563 ** other connections to the same file might not realize that
26564 ** the file has changed and hence might not know to flush their
26636 ** indicates that the other process is not following the locking
26712 ** It is *not* necessary to hold the mutex when this routine is called,
26752 /* If there are outstanding locks, do not actually close the file just
26843 ** In dotfile locking, either a lock exists or it does not. So in this
27761 ** file changed. If the transaction counter is not updated,
27762 ** other connections to the same file might not realize that
27763 ** the file has changed and hence might not know to flush their
27839 /* If there are outstanding locks, do not actually close the file just
27857 ** to MacOSX and does not work on other unix platforms. No alternative
27859 ** VFS is not available.
27882 ** to MacOSX and does not work on other unix platforms. No alternative
27904 ** one system to another. Since SQLite does not define USE_PREAD
27905 ** any any form by default, we will not attempt to define _XOPEN_SOURCE.
27972 /* If this is a database file (not a journal, master-journal or temp
27988 pFile->lastErrno = 0; /* not a system error */
28052 /* If this is a database file (not a journal, master-journal or temp
28096 pFile->lastErrno = 0; /* not a system error */
28114 ** We do not trust systems to provide a working fdatasync(). Some do.
28124 ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
28136 ** The fsync() system call does not work as advertised on many
28142 ** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
28148 ** to disk, not the inode. We only set dataOnly if the file size is
28152 ** and fsync(), Ted tells us, is that fdatasync() will not flush the
28154 ** We only care about the file size, not the other file attributes, so
28236 ** are flushed to disk. Such fsyncs are not needed on newer
28280 ** If we do not do this and we encounter a power failure, the directory
28281 ** entry for the journal might not exist after we reboot. The next
28282 ** SQLite to access the file will not know that the journal exists (because
28284 ** will not roll back - possibly leading to database corruption.
28299 ** line is to test that doing so does not cause any problems.
28433 /* If the OS does not have posix_fallocate(), fake it. First use
28437 ** on systems that do not have a real fallocate() system call.
28461 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
28553 ** file system does not always provide powersafe overwrites. (In other
28583 ** every open file that does not use shared memory (in other words, most
28726 ** This is not a VFS shared-memory method; it is a utility function called
28768 ** meaning that their memory would not really be shared - resulting
28785 ** that case, we do not really need shared memory. No shared memory
28865 ** If not, truncate the file to zero length.
28919 ** region has not been allocated (by any client, including one running in a
28921 ** bExtend is non-zero and the requested shared-memory region has not yet
28926 ** address space (if it is not already), *pp is set to point to the mapped
28941 /* If the shared-memory file has not yet been opened, open it now. */
28963 /* The requested region is not mapped into this processes address space.
28973 /* The requested memory region does not exist. If bExtend is set to
29038 ** not go from shared to exclusive or from exclusive to shared.
29420 ** that does not need to be locked. */
29473 ** that does not need to be locked. */
29524 /* Usually the path zFilename should not be a relative pathname. The
29593 ** If scenario (a) caused the error then things are not so safe. The
29614 ** according to requirement F11141. So we do not need to make a
29743 ** name. If it is not, return SQLITE_ERROR.
29773 ** file (not a journal or master-journal file) identified by pathname
29778 ** but the associated file descriptor could not be closed because some
29790 /* Do not search for an unused file descriptor on vxworks. Not because
29791 ** vxworks would not benefit from the change (it might, we're not sure),
29793 ** not to risk breaking vxworks support for the sake of such an obscure
29805 ** not searching for a resusable file descriptor are not dire. */
29834 ** returned and the value of *pMode is not modified.
29849 ** FAT filesystems and permissions do not matter there, so just use
30007 /* Database filenames are double-zero terminated if they are not
30027 ** open(). These must be calculated even if open() is not called, as
30127 ** not while other file descriptors opened by the same process on
30316 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
30329 ** other hand, dlsym() will not work on such a system either, so we have
30330 ** not really lost anything.
30395 ** might be greater than or equal to the argument, but not less
30534 ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
30570 ** Once a lock proxy is configured for a database connection, it can not
30572 ** the above APIs (assuming the conch file is not being held by another
30593 ** If the conch file does not exist, or it's contents do not match the
30605 ** Requesting the lock proxy does not immediately take the conch, it is
30608 ** opening a connection to a database file does not take a lock on it.
30638 ** lock proxy files, only used when LOCKPROXYDIR is not set.
30646 ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
30753 ** The caller is responsible not only for closing the file descriptor
30770 ** 2. if that fails, and this is a lock file (not-conch), try creating
31156 /* If we created a new conch file (not just updated the contents of a
31414 /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
31482 *(const char **)pArg = ":auto: (not held)";
31495 /* turn off proxy locking - not supported */
31682 ** single thread. The memory allocation and mutex subsystems have not
31684 ** should not be used.
31780 ** to release dynamically allocated objects. But not on unix.
31797 ** May you do good and not evil.
31822 ** May you do good and not evil.
31832 ** This file should be #included by the os_*.c files only. It is not a
31840 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
31875 ** May you do good and not evil.
32188 ** These macros are necessary because Windows CE does not natively support the
32660 ** Return the value of a system call. Return NULL if zName is not a
32680 ** is the last system call or if zName is not the name of a valid
32706 ** WinNT/2K/XP so that we will know whether or not we can safely call
32884 ** is not required to be threadsafe (it is not).
33083 ** Since the ANSI version of these Windows API do not exist for WINCE,
33084 ** it's important to not reference them for WINCE builds.
33217 ** Windows CE does not have a localtime() function. So create a
33327 /* If shared memory could not be created, then close the mutex and fail */
33583 ** for being unreasonable so I do not doubt that it might happen. If
33767 ** Used only when SQLITE_NO_SYNC is not defined.
33774 ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or
33791 ** line is to test that doing so does not cause any problems.
33854 ** Different API routines are called depending on whether or not this
33929 ** It is not possible to lower the locking level one step at a time. You
33972 ** If you are using this code as a model for alternative VFSes, do not
33975 OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
34087 ** It is not possible for this routine to fail if the second argument
34124 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
34398 ** This is not a VFS shared-memory method; it is a utility function called
34510 ** If not, truncate the file to zero length.
34716 /* MemoryBarrier(); // does not work -- do not know why not */
34730 ** region has not been allocated (by any client, including one running in a
34732 ** isWrite is non-zero and the requested shared-memory region has not yet
34737 ** address space (if it is not already), *pp is set to point to the mapped
34769 /* The requested region is not mapped into this processes address space.
34781 /* The requested memory region does not exist. If isWrite is set to
34950 ** Since the ANSI version of these Windows API do not exist for WINCE,
34951 ** it's important to not reference them for WINCE builds.
34969 ** name. If it is not, return SQLITE_ERROR.
35085 /* Database filenames are double-zero terminated if they are not
35109 /* Creates a new file, only if it does not already exist. */
35149 ** Since the ANSI version of these Windows API do not exist for WINCE,
35150 ** it's important to not reference them for WINCE builds.
35224 ** Note that Windows does not allow a file to be deleted if some other
35256 ** Since the ANSI version of these Windows API do not exist for WINCE,
35257 ** it's important to not reference them for WINCE builds.
35307 ** as if it does not exist.
35327 ** Since the ANSI version of these Windows API do not exist for WINCE,
35328 ** it's important to not reference them for WINCE builds.
35416 ** Since the ANSI version of these Windows API do not exist for WINCE,
35417 ** it's important to not reference them for WINCE builds.
35463 ** Since the ANSI version of these Windows API do not exist for WINCE,
35464 ** it's important to not reference them for WINCE builds.
35625 ** then it is not necessary to include the nul-terminator character
35704 ** May you do good and not evil.
35822 ** If p is NULL (if the bitmap has not been created) or if
35892 /* in hash, if not, try to find a spot for it */
36015 ** 5 N S X Set N bits from S increment X in array only, not in bitvec
36019 ** Opcode 5 works on the linear array only, not on the Bitvec.
36114 ** May you do good and not evil.
36156 ** is not, either fail an assert or return zero. Otherwise, return
36324 int createFlag, /* If true, create page if it does not exist already */
36335 /* If the pluggable cache (sqlite3_pcache*) has not been allocated,
36359 ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
36360 ** cleared), but if that is not possible settle for any other
36536 ** the page object is not dropped.
36580 ** Do not both fixing the pDirtyPrev pointers.
36735 ** May you do good and not evil.
36767 ** Mode 1 uses more memory (since PCache instances are not able to rob
36849 ** fixed at sqlite3_initialize() time and do not require mutex protection.
36871 ** compiling for systems that do not support real WSD.
36939 /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get
37010 ** this mutex is not held. */
37084 ** for all page cache needs and we should not need to spill the
37148 ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
37271 ** not need to be freed.
37390 ** Whether or not a new page may be allocated by this function depends on
37391 ** the value of the createFlag argument. 0 means do not allocate a new
37406 ** 2. If createFlag==0 and the page is not already in the cache, NULL is
37409 ** 3. If createFlag is 1, and the page is not already in the cache, then
37410 ** return NULL (do not allocate a new page) if any of the following
37522 /* Step 5. If a usable page buffer has still not been found,
37671 ** install the default pluggable cache module, assuming the user has not
37756 ** May you do good and not evil.
37795 ** value added by the INSERT will not be visible to the second TEST.
37868 ** It must be the case that N is sufficient to make a Rowset. If not
38106 ** Convert the list in p->pEntry into a sorted list if it is not
38128 ** routine may not be called again.
38180 ** May you do good and not evil.
38203 ** May you do good and not evil.
38270 /* If the WAL is not empty, return the size of the database. */
38277 /* Undo any frames written (but not committed) to the log */
38332 ** journal. These invariants do not apply for journal_mode=WAL,
38337 ** Otherwise, the page is not synced until the xSync method of the VFS
38393 ** method is a no-op, but that does not change the fact the SQLite will
38401 ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
38478 ** state - the file may or may not be locked and the database size is
38479 ** unknown. The database may not be read or written.
38483 ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
38503 ** transaction is not active). The dbOrigSize and dbFileSize variables
38504 ** may not be trusted at this point.
38506 ** * Even if a read-transaction is not open, it is guaranteed that
38518 ** moving to this state, but the journal file is not written to or opened
38534 ** * The contents of the pager cache have not been modified.
38535 ** * The journal file may or may not be open.
38536 ** * Nothing (not even the first header) has been written to the journal.
38542 ** is opened (if it is not already open) and a header written to the
38543 ** start of it. The database file on disk has not been modified.
38548 ** to it, but the header has not been synced to disk.
38555 ** never enter this state (since they do not modify the database file,
38567 ** It is not possible for a WAL connection to enter this state.
38573 ** not possible to modify the database further. At this point, the upper
38630 ** code were simply returned to the user, the b-tree layer would not
38638 ** * The pager is not an in-memory pager.
38670 ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
38787 ** not updated more often than necessary.
38803 ** (or may not) specify a master-journal name to be written into the
38806 ** Whether or not a journal file contains a master-journal pointer affects
38809 ** If a journal file does not contain a master-journal pointer, it is
38838 ** is permitted, but syncing the journal file is not. This flag is set
38861 ** is not an integer multiple of the page-size, the value stored in
38875 ** and to determine whether or not pages need to be journalled before
38889 ** dbFileSize is not used when rolling back a transaction. In this case
38891 ** a call to xFilesize() that is not strictly required). In either case,
38918 u8 noReadlock; /* Do not bother to obtain readlocks */
38919 u8 noSync; /* Do not sync the journal if true */
38930 ** routine opertion. Class members not in this block are either fixed
38941 u8 doNotSpill; /* Do not spill the cache when non-zero */
38942 u8 doNotSyncSpill; /* Do not do a spill that requires jrnl sync */
38998 ** testing purposes only. These variables do not exist in
38999 ** a non-testing build. These variables are not thread-safe.
39070 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
39128 ** And if the journal-mode is "OFF", the journal file must not be open.
39138 ** is therefore not possible for an in-memory pager to enter the ERROR
39293 ** * The bit corresponding to the page-number is not set in
39350 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
39354 ** called, do not modify it. See the comment above the #define of
39380 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
39399 ** This function determines whether or not the atomic-write optimization
39465 ** is defined, and NDEBUG is not defined, an assert() statement checks
39575 ** This function is a no-op if the journal file has not been written to
39581 ** if the pager is not in no-sync mode, sync the journal file immediately
39588 ** not need to be synced following this operation.
39708 /* Initializing the tail of the buffer is not necessary. Everything
39725 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
39783 /* Read in the first 8 bytes of the journal header. If they do not match
39830 ** of two greater than or equal to 512 or 32, and not greater than their
39936 ** will not be able to find the master-journal name to determine
39937 ** whether or not the journal is hot.
39952 ** a pointer to the page or NULL if the requested page is not
39958 /* It is not possible for a call to PcacheFetch() with createFlag==0 to
39976 ** if it is open and the pager is not in exclusive mode.
40013 ** This function is a no-op if the pager is in exclusive mode and not
40017 ** If the pager is not in exclusive-access mode, the database file is
40019 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
40025 ** or not, any journal file left in the file-system will be treated
40150 ** file has been finalized it is not possible to use it to roll back a
40153 ** depends on whether or not the pager is running in exclusive mode and
40184 ** tries to unlock the database file if not in exclusive mode. If the
40193 /* Do nothing if the pager does not have an open write transaction
40291 ** If the pager has already entered the ERROR state, do not attempt
40299 ** If the pager has not already entered the ERROR state, but an IO or
40324 ** This is not a real checksum. It is really just the sum of the
40360 # define pagerReportSize(X) /* No-op if we do not support a codec */
40370 ** not.
40376 ** If pDone is not NULL, then it is a record of pages that have already
40392 ** and the checksum field does not match the record content.
40428 ** only reads from the main journal, not the sub-journal.
40481 ** not the database file. The page is left marked dirty in this case.
40485 ** not be in the pager cache. Later: if a malloc() or IO error occurs
40486 ** during a Movepage() call, then the page may not be in the cache
40487 ** either. So the condition described in the above paragraph is not
40492 ** not dirty. Since this code is only executed in PAGER_OPEN state for
40500 ** statement we must not write to the original database unless we know
40507 ** in the main journal either because the page is not in cache or else
40511 ** is possible to fail a statement on a database that does not yet exist.
40512 ** Do not attempt to write if database file has never been opened.
40547 /* If this is a rollback of a savepoint and data was not written to
40548 ** the database and the page is not in-memory, there is a potential
40550 ** will be read from the database file, which may or may not be
40593 ** unsynced portion of the main journal file, then it is not safe
40599 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
40628 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
40734 /* We have a match. Do not delete the master journal file. */
40760 ** If the main database file is not open, or the pager is not in either
40838 ** may not have been opened yet, in which case the OsSectorSize()
40884 ** the extra entries had not yet made it safely to disk. In such a case,
40894 ** If the file opened as the journal file is not a well-formed
40900 ** If an I/O or malloc() error occurs, the journal-file is not deleted
40931 ** If a master journal file name is specified, but the file is not
40932 ** present on disk, then the journal is not hot and does not need to be
40959 ** not enough bytes left in the journal file for a complete header, or
40983 ** that this part of the journal was being filled but has not yet been
41027 ** not completely written and synced prior to a crash. In that
41062 ** mode, then subsequent transactions performed by the connection will not
41225 ** database. This is not generally possible with a WAL database, as
41244 ** been written (but not committed) to the log file, do one of the
41340 /* sqlite3WalEndReadTransaction() was not called for the previous
41369 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
41370 ** if the database size is not available. The database size is not
41378 /* If the database size was not available from the WAL sub-system,
41380 ** of the database file is not an integer multiple of the page-size,
41411 ** exists if the database is not empy, or verify that the *-wal file does
41412 ** not exist (by deleting it) if the database file is empty.
41414 ** If the database is not empty and the *-wal file exists, open the pager
41416 ** if no error occurs, make sure Pager.journalMode is not set to
41465 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
41474 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
41637 ** assurance that the journal will not be corrupted to the
41649 ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
41738 ** lock. It does *not* invoke the busy handler when upgrading from
41777 ** * the database is either not an in-memory database or it is
41787 ** If the page size is not changed, either because one of the enumerated
41788 ** conditions above is not true, the pager was in error state when this
41795 /* It is not possible to do a full assert_pager_state() here, as this
41873 ** errors in places where we do not care about errors.
41914 ** the Pager object. There has not been an opportunity to transition
41949 ** the busy callback if the lock is currently not available. Repeat
41983 ** b) if the page content were written at this time, it would not
41987 ** If the condition asserted by this function were not true, and the
41989 ** routine, pagerStress() would not write the current page content to
41992 ** content of the page. However, since this content is not present in either
41994 ** sub-journal rolled back the content could not be restored and the
42012 ** function does not actually modify the database file on disk. It
42080 ** If this is not done, then an unsynced portion of the open journal
42143 ** * Otherwise, if the device does not support the SAFE_APPEND property,
42149 ** * If the device does not support the SEQUENTIAL property, then
42229 ** This is not required if the persistent media supports the
42230 ** SAFE_APPEND property. Because in this case it is not possible
42290 ** is not yet open, it is created and opened before any data is
42317 /* If the file is a temp-file has not yet been opened, open it now. It
42318 ** is not possible for rc to be other than SQLITE_OK if this branch
42341 ** make the file smaller (presumably by auto-vacuum code). Do not write
42344 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
42427 /* Open the sub-journal, if it has not already been opened */
42463 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
42477 ** is returned by sqlite3PcacheMakeClean() is not called.
42487 ** journal (and adding a new header) is not allowed. This occurs
42492 ** or not a sync is required. This is set during a rollback.
42527 ** This is because the call to pager_write_pagelist() below will not
42540 ** If (X>Y), then when pagerStress is called page X will not be written
42544 ** was when the transaction started, not as it was when "SAVEPOINT sp"
42548 ** sub-journal file now (if it is not already there), so that it will
42679 ** as it will not be possible to open the journal file or even
42788 /* If a temporary file is requested, it is not opened immediately.
42898 ** * The first byte of the journal file exists and is not 0x00.
42906 ** This routine does not check if there is a master journal filename
42908 ** does not exist, then the journal file is not really hot. In this
42910 ** routine will discover that the journal file is not really hot and
42911 ** will not roll it back.
42916 ** to determine whether or not a hot-journal file exists, the IO error
42971 ** If there is, then we consider this journal to be hot. If not,
42995 ** with it under an EXCLUSIVE lock where we do not need to
43074 ** important that a RESERVED lock is not obtained on the way to the
43080 ** Because the intermediate RESERVED lock is not requested, any
43093 /* If it is not already open and the file exists on disk, open the
43100 ** If the journal does not exist, it usually means that some
43104 ** function was called and the journal file does not exist.
43129 ** probably did not sync it and we are required to always sync
43152 ** PAGER_ERROR now. This is not actually counted as a transition
43156 ** assert_pager_state() would fail now, as it should not be possible
43185 ** There is a vanishingly small chance that a change will not be
43244 ** the rollback journal, the unlock is not performed and there is
43261 ** choose not to allocate a new page object and may reuse an existing
43271 ** requested page is not already stored in the cache, then no
43275 ** If noContent is true, it means that we do not care about the contents
43290 ** will not be journaled. This saves IO.
43296 ** to find a page in the in-memory cache first. If the page is not already
43307 int noContent /* Do not bother reading content from disk if true */
43366 ** page that does not need to be journaled. Nevertheless, be sure
43407 ** not read the page from disk. Return a pointer to the page,
43408 ** or 0 if the page is not in cache.
43412 ** in the page if the page is not already in cache. This routine
43413 ** returns NULL if the page is not in cache or if a disk I/O error
43450 ** opened to write a rollback log for a transaction. It is not used
43457 ** Whether or not the journal file is opened by this function, the
43483 /* Open the journal file if it is not already open. */
43542 ** running in exclusive mode) or if the transaction does not require a
43559 ** exclusive lock on the database is not already held, obtain it now.
43571 ** The busy-handler is not invoked if another connection already
43579 ** lock, but not when obtaining the RESERVED lock.
43625 /* This routine is not called unless a write-transaction has already
43626 ** been started. The journal file may or may not be open at this point.
43636 ** again. This should not happen, but the check provides robustness. */
43639 /* Higher-level routines never call this function if database is not
43647 ** rollback journal might not yet be open. Open it now if this is the case.
43671 ** the transaction journal if it is not there already.
43682 ** that we do not. */
43733 /* If the statement journal is open and the page is not in it,
43754 ** of this function and be careful not to change any page data unless
43868 ** A call to this routine tells the pager that it is not necessary to
43876 ** that it does not get written to disk.
43926 ** The idea is that if the atomic-write optimization is not
43948 /* If page one was fetched successfully, and this function is not
43949 ** operating in direct-mode, make page 1 writable. When not in
44008 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
44047 ** Note that if zMaster==NULL, this does not overwrite a previous value
44051 ** is not synced. The caller must call sqlite3PagerSync() directly to
44057 const char *zMaster, /* If not NULL, the master journal name */
44105 ** does this depends on whether or not the atomic-update optimization
44111 ** * This commit is not part of a multi-file transaction, and
44114 ** If the optimization was not enabled at compile time, then the
44117 ** is not applicable to this transaction, call sqlite3JournalCreate()
44196 ** If the atomic-update optimization is being used, this sync will not
44203 ** not the case. In this case it is likely enough that the redundant
44216 /* If the file on disk is not the same size as the database image,
44260 /* This routine should not be called if a prior error has occurred.
44271 /* An optimization. If the database was not actually modified during
44311 ** 2) It finalizes the journal file, so that it is not used for hot
44327 ** the pager is already in the ERROR state, the rollback is not
44344 ** state to indicate that the contents of the cache may not be trusted.
44513 ** The savepoint to release or rollback need not be the most recently
44529 ** sqlite3PagerRollback() because this function does not terminate
44575 ** not yet been opened. In this case there have been no changes to
44605 ** not yet been opened.
44655 ** in cache. If the page previously located at pgno is not already
44656 ** in the rollback journal, it is not put there by by this routine.
44663 ** required that a statement transaction was not active, but this restriction
44670 ** pPg refers to will not be written to again within this transaction.
44695 /* If the page being moved is dirty and has not been saved by the latest
44705 ** If page X were not written to the sub-journal here, it would not
44729 ** can be written to. The caller has already promised not to write to it.
44748 /* Do not discard pages from an in-memory database since we might
44783 ** the journal file twice, but that is not a problem.
44822 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
44917 ** not possible, then that is not a problem. Deleting the journal file
44921 ** database file. This ensures that the journal file is not deleted
45098 ** file (not a temp file or an in-memory database), and the WAL file
45099 ** is not already open, make an attempt to open it now. If successful,
45101 ** not support the xShmXXX() methods, return an error code. *pbOpen is
45102 ** not modified in either case.
45144 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
45145 ** If successful, the EXCLUSIVE lock is not released before returning.
45152 /* If the log file is not already open, but does exist in the file-system,
45210 ** May you do good and not evil.
45334 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
45342 ** use an architecture-specific format; it does not have to be cross-platform.
45376 ** depending on the contents of the WAL file. This does not change the
45412 ** no hash slot such that aHash[i]==p) then page P is not in the
45425 ** WAL or to establish that the frame does not exist in the WAL. This
45463 ** values in the wal-header are correct and (b) the version field is not
45467 ** checksum test is successful) and finds that the version field is not
45548 ** is not already an aReadMark[] equal to mxFrame. The exception to the
45574 ** only support mandatory file-locks, we do not read or write data
45678 int iNext; /* Next slot in aIndex[] not yet returned */
45895 ** *pnTruncate and return true. Return if the frame is not valid.
45900 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
45949 ** Names of locks. This routine is used to provide debugging output and is not
46231 ** thing to check, so only do this occasionally - not on every
46268 /* Obtain an exclusive lock on all byte in the locking range not already
46311 /* If the database page size is not a power of two, or is greater than
46528 ** has not been returned by any prior invocation of this method on the
46799 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
46849 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
46971 /* Reset the return code so as not to report a checkpoint failure
47036 ** The EXCLUSIVE lock is not released before returning.
47053 ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
47130 return 1; /* Checksum does not match */
47208 ** sure the wal-index was not constructed with some future format that
47248 ** and is not honoring the locking protocol. There is a vanishingly small
47256 ** that means the Wal does not hold any read lock. The reader must not
47287 ** locks are held, so the locks should not be held for very long. But
47313 /* If there is not a recovery running in another thread or process
47326 ** code that determines whether or not the shared-memory region
47351 /* It is not safe to allow the reader to continue here if frames
47360 ** is obtained, that is not necessarily true. A checkpointer may
47377 ** but not exceeding pWal->hdr.mxFrame and lock that entry.
47419 ** It is necessary to check that the wal-index header did not change
47429 ** This does not guarantee that the copy of the wal-index header is up to
47430 ** date before proceeding. That would not be possible without somehow
47433 ** WAL_READ_LOCK(mxI)) has not occurred since the snapshot was valid.
47494 ** has been loaded. Or *pInWal is set to 0 if the page was not in
47563 /* assert( iFrame>iRead ); -- not true if there is corruption */
47628 ** the read transaction was started, then it is not possible for this
47681 ** If any data has been written (but not committed) to the log file, this
47686 ** other than SQLITE_OK, it is not invoked again and the error code is
47689 ** Otherwise, if the callback function does not return an error, this
47716 ** committed. As a result, the call to xUndo may not fail.
47782 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
47830 assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
47931 ** nTruncate==0 then this frame set does not complete the transaction. */
48021 ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
48056 /* Append data to the wal-index. It is not necessary to lock the
48100 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
48137 ** run instead. Since the checkpointer is not holding the writer lock,
48223 ** not actually change anything. The pager uses this to see if it
48283 ** May you do good and not evil.
48302 ** May you do good and not evil.
48398 ** not specified in the header.
48461 ** that immediately follows the page header. Cells is not necessarily
48468 ** appears first. A variable-length integer may not be more than 9 bytes long.
48536 ** the header, then your custom library will not be able to read
48538 ** will not be able to read databases created by your custom library.
48581 struct _OvflCell { /* Cells that will not fit on aData[] */
48634 ** The pBt pointer itself may not be changed while there exists cursors
48678 ** may not be modified once it is initially set as long as nRef>0.
48741 #define BTS_NO_WAL 0x0010 /* Do not open write-ahead-log files */
48793 sqlite3_int64 cachedRowid; /* Next rowid cache. 0 means not valid */
48818 ** Cursor does not point to a valid entry. This can happen (for example)
48819 ** because the table is empty or because BtreeCursorFirst() has not been
48870 ** to any page that is not part of the pointer map itself.) Each pointer map
48879 ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
48883 ** is not used in this case.
48912 ** if the database supports auto-vacuum or not. Because it is used
48914 ** (sqliteMallocRaw), it is not possible to use conditional compilation.
48986 ** If the object is not sharable, then no mutex is ever required
49029 ** procedure that follows. Just be sure not to block.
49074 ** B-Tree is not marked as sharable.
49093 ** omitted if that module is not used.
49108 ** against all schemas and we do not want those schemas being
49139 ** no lock is ever required since it is not sharable.
49178 ** If pSchema is not NULL, then iDb is computed from pSchema and
49228 ** May you do good and not evil.
49305 ** of each BtShared structure and so this locking is not necessary.
49323 ** table with root page iRoot. Return 1 if it does and 0 if not.
49351 /* If this database is not shareable, or if the client is reading
49362 ** not loaded, then it is too difficult to actually check to see if
49363 ** the correct locks are held. So do not bother - just return true.
49364 ** This case does not come up very often anyhow.
49440 ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
49458 /* This routine is a no-op if the shared-cache is not enabled */
49464 ** requested lock may not be obtained.
49542 /* If the above search did not find a BtLock struct associating Btree p
49575 ** transaction. If it does not, then the BTS_PENDING flag
49607 ** transaction. If there currently exists a writer, and p is not
49612 ** If there is not currently a writer, then BTS_PENDING must
49718 ** a free-list leaf page, the page is not written to the database
49720 ** such a page is not even journalled (as it will not be modified,
49723 ** 2) When a free-list leaf page is reused, its content is not read
49725 ** be, if it is not at all meaningful?).
49730 ** transaction, a problem comes up. If the page is not journalled when
49731 ** it is moved to the free-list and it is also not journalled when it
49733 ** may be lost. In the event of a rollback, it may not be possible
49798 ** all that is required. Otherwise, if pCur is not open on an intKey
49926 ** Determine whether or not a cursor has moved from the position it
49931 ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
49955 ** Return 0 (not a valid page) for pgno==1 since there is
50077 ** This routine works only for pages that do not contain overflow cells.
50154 /* If the payload will not fit completely on the local page, we have
50194 ** data header and the local payload, but not any overflow page or
50205 ** this function verifies that this invariant is not violated. */
50441 ** the allocation. If not, defragment.
50493 ** btreeInitPage() did not detect overlapping cells or
50596 ** not contain a well-formed database page, then return
50597 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
50764 ** If the noContent flag is set, it means that we do not care about
50765 ** the content of the page at this time. So do not go to the disk
50775 int noContent /* Do not load page content if true */
50788 ** Retrieve a page from the pager cache. If the requested page is not
50879 /* pPage might not be a btree page; it might be an overflow page
51036 ** even when they are not. This exercises the locking code and
51087 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
51178 ** do not change the pager-cache size.
51312 ** operate asynchronously - it will not stop to do fsync()s
51319 ** Synchronous is on by default so database corruption is not
51377 ** size supplied does not meet this constraint then the page size is not
51522 ** SQLITE_OK is returned on success. If the file is not a
51574 ** in WAL mode. If the log is not already open, open it now. Then
51578 ** may not be the latest version - there may be a newer one in the log
51675 ** If there are no outstanding cursors and we are not in the middle
51743 ** to access the database. A preexisting transaction may not be
51761 ** if there is one. But if there was previously a read-lock, do not
51769 ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
51789 /* Write transactions are not possible on a read-only database */
51833 ** file is not pBt->pageSize. In this case lockBtree() will update
51900 ** the sub-journal is not already open, then it will be opened here.
52024 ** can be written to. The caller has already promised not to write to that
52118 ** which may or may not empty the freelist. A full autovacuum
52147 /* Remove the page from the files free-list. This is not required
52227 ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
52277 /* It is not possible to create a database for which the final page
52322 ** causes a rollback journal to be created (if it does not already exist)
52329 ** disk and we are still holding all locks, so the transaction has not
52473 ** in assert() expressions, so it is only compiled if NDEBUG is not
52478 ** originally opened for writing and the cursor has not be disabled
52504 ** or moved root pages, so it is not sufficient to
52545 ** the cache may be internally inconsistent (not contain valid trees) so
52673 ** but which are not in the READ_UNCOMMITTED state may not have
52678 ** 3: The database must be writable (not on read-only media)
52683 ** root page of a b-tree. If it is not, then the cursor acquired
52684 ** will not work correctly.
52769 ** do not need to be zeroed and they are large, so we can save a lot
52786 ** or negative rowids are very uncommon so this should not be a problem.
52838 ** BtCursor.info structure. If it is not already valid, call
52848 ** compiler is not doing agressive inlining.) So we use a real function
52873 #else /* if not _MSC_VER */
52898 ** the key for the current entry. If the cursor is not pointing
52902 ** itself, not the number of bytes in the key.
52928 ** Failure is not possible. This function always returns SQLITE_OK.
52952 ** If ppPage is not NULL, and a reference to the MemPage object corresponding
53128 ** has not been allocated, allocate it now. The array is sized at
53131 ** etc. A value of 0 in the aOverflow[] array means "not yet known"
53168 ** data is not required. So first try to lookup the overflow
53198 ** 5) the database is not a WAL database,
53296 ** into *pAmt. If *pAmt==0, then the value returned will not be
53387 ** the new child page does not match the flags field of the parent (i.e.
53486 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
53527 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
53529 ** NULL, the caller expects a table b-tree. If this is not the case,
53540 ** if the assumption were not true, and it is not possible for the flags
53686 ** If an exact match is not found, then the cursor is always
53757 ** not run. If this is not the root-page, then the moveToChild() routine
53889 ** Return TRUE if the cursor is not pointing at an entry of the table.
54048 ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
54050 ** If the "nearby" parameter is not 0, then a (feeble) effort is made to
54055 ** If the "exact" parameter is not 0, and the page-number nearby exists
54113 ** is not true. Otherwise, it runs once for each trunk-page on the
54138 /* The trunk has no leaves and the list is not being searched.
54330 ** It is assumed that the page is not already a part of the free-list.
54338 ** its reference count is not altered by this function.
54411 ** Note that the trunk page is not really full until it contains
54412 ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
54436 /* If control flows to this point, then it was not possible to add the
54496 /* 0 is not a legal page number and page 1 cannot be an
54512 ** must not really be an overflow page and the database must be corrupt.
54540 ** Note that pCell does not necessary need to point to the pPage->aData
54568 /* pPage is not necessarily writeable since pCell might be auxiliary
54645 /* If pToRelease is not zero than pPrior points into the data area
54665 /* If pToRelease is not zero than pPayload points into the data area
54697 ** The cell content is not freed or deallocated. It is assumed that
54748 ** will not fit, then make a copy of the cell content into pTemp if
54749 ** pTemp is not null. Regardless of pTemp, allocate a new entry
54755 ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
54757 ** nSkip is non-zero, then pCell may not point to an invalid memory location
55012 ** This function does not contribute anything to the operation of SQLite.
55054 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55061 ** MemPage.aOvfl[] array), they are not copied to pTo.
55065 ** The performance of this function is not critical. It is only used by
55121 ** one or two in an effort to keep pages nearly full but not over full.
55124 ** might not actually be stored in MemPage.aData[]. This can happen
55164 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
55211 ** way, the remainder of the function does not have to deal with any
55258 ** four bytes of it, and this function does not need the first
55262 ** But not if we are in secure-delete mode. In secure-delete mode,
55315 ** child pointers. If siblings are not leaves, then all cell in
55319 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
55377 /* Do not allow any cells smaller than 4 bytes. */
55426 ** sibling might be completely empty. This adjustment is not optional.
55453 ** UPDATE: The assert() below is not necessarily true if the database
55500 /* Free any old pages that were not reused as new pages.
55519 ** not be a problem.
55566 /* If the sibling page assembled above was not the right-most sibling,
55655 ** many have not. The following is a summary:
55657 ** 1) The entries associated with new sibling pages that were not
55667 ** 3) If the sibling pages are not leaves, then the child pages of
55670 ** 4) If the sibling pages are not internal intkey nodes, then any
55674 ** 5) If the sibling pages are not leaves, then the pointer-map
55694 ** sibling page j. If the siblings are not leaf pages of an
55718 ** sibling page k. If the siblings are not leaf pages of an
55726 /* If the cell was originally divider cell (and is not now) or
55906 ** function. If this were not verified, a subtle bug involving reuse
55934 /* If pFree is not NULL, it points to the pSpace buffer used
56022 ** operation - if it is not, the following is a no-op). */
56036 ** not to clear the cursor here.
56161 /* If the page containing the entry to delete is not a leaf page, move
56187 /* If the cell deleted was not located on a leaf page, then the cursor
56246 ** flags might not work:
56286 /* The new root-page may not be allocated on a pointer-map page, or the
56306 ** the new table (assuming an error did not occur). But we were
56307 ** allocated pgnoMove. If required (i.e. if it was not allocated
56452 ** If pnChange is not NULL, then table iTable must be an intkey table. The
56463 ** is the root of a table b-tree - if it is not, the following call is
56483 ** If AUTOVACUUM is enabled and the page at iTable is not the last
56545 /* The table being dropped does not have the largest root-page
56618 ** free pages is not visible. So Cookie[0] is the same as Meta[1].
56644 ** read-only and may not be written.
56690 ** page in the B-Tree structure (not including overflow pages).
56696 /* If this is a leaf page or the tree is not an int-key tree, then
56707 ** the next page in the tree that has not yet been visited. The
56807 ** page iParent, pointer type ptrType. If not, append an error message
56891 /* If this database supports auto-vacuum and iPage is not the last
56915 ** 1. Make sure that cells and freeblocks do not overlap
57230 /* Make sure this analysis did not leave any unref() pages.
57270 ** has been created or not.
57339 ** If the nBytes parameter is 0 and the blob of memory has not yet been
57345 ** blob of allocated memory. The xFree function should not call sqlite3_free()
57406 ** Only the data content may only be modified, it is not possible to
57474 /* If setting the version fields to 1, do not automatically open the
57507 ** May you do good and not evil.
57565 ** backup_pagecount() are not thread-safe functions. If they are called
57573 ** Non-sharable Btrees (in-memory databases for example), do not have
57645 ** handle is not locked in this routine, but it is locked in
57682 /* One (or both) of the named databases did not exist or an OOM
57741 /* Backup is not possible if the page size of the destination is changing
57748 /* Backup is not possible if the number of bytes of reserve space differ
57750 ** fix the destination to agree with the source. If that is not possible,
57793 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
57853 /* Lock the destination database, if it is not locked already. */
57870 /* Do not allow backup if the destination database is in WAL mode
58145 ** valid and which are not, so the entire process needs to be restarted.
58187 ** from this function, not directly by the user.
58227 ** May you do good and not evil.
58244 ** If pMem is not a string object, or the encoding of the string
58248 ** SQLITE_OK is returned if the conversion is successful (or not required).
58266 ** then the encoding of the value may not have changed.
58287 ** not set, Mem.n is zeroed.
58407 ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
58482 ** does not free any Mem.zMalloc buffer.
58522 ** Because we do not completely understand the problem, we will
58532 ** Many compilers we encounter do not define constants for the
58534 ** inconsistently. And many do not understand the "LL" notation.
58544 /* minInt is correct here - not maxInt. It turns out that assigning
58671 ** is a string that does not look completely like a number. Convert
58801 ** copies are not misused.
58817 ** Size of struct Mem not including the Mem.zMalloc member.
58823 ** pTo are freed. The pFrom->z field is not duplicated. If
59001 /* If one value is a number and the other is not, the number is less.
59053 ** compiled (this was not always the case).
59110 int key, /* If true, retrieve from the btree key, not data. */
59153 /* This function is only available internally, it is not part of the
59375 ** May you do good and not evil.
59717 ** throw an ABORT exception (causing the statement, but not entire transaction
59758 ** If malloc failed, then the while() loop above may not have iterated
59845 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
59952 ** the FuncDef is not ephermal, then do nothing.
60013 ** opcodes contained within. If aOp is not NULL it is assumed to contain
60068 ** caller should not free the allocation, it will be freed when the Vdbe is
60185 ** is readable but not writable, though it is cast to a writable value.
60354 ** If SQLite is not threadsafe but does support shared-cache mode, then
60359 ** If SQLite is not threadsafe and does not support shared-cache mode, this
60365 ** this routine is N*N. But as N is rarely more than 1, this should not
60519 /* Even though this opcode does not use dynamic strings for
60603 ** has not already been seen.
60739 ** receive the new memory. pBuf is normally NULL. If pBuf is not
60741 ** this routine should not allocate any new memory. When pBuf is not
60929 p->nMem = nMem; /* not from 0..nMem-1 */
61105 ** A read or write transaction may or may not be active on database handle
61118 ** SQLITE_OK so p is not used.
61132 ** (b) how many database files have open write transactions, not
61157 /* The simple case - no more than one database file (not counting the
61163 ** that case we do not support atomic multi-file commits, so use the
61274 ** flag is set this is not required.
61288 ** an error occurs here, do not delete the master journal file.
61348 ** currently active. An assertion fails if the two counts do not match.
61349 ** This is an internal self-check only - it is not an essential processing
61386 ** reorder rootpages. So it is not sufficient just to save
61496 ** Return an error code. If the commit could not complete because of
61498 ** means the close did not happen and needs to be repeated.
61712 ** This function does not clear the VDBE error code or message, just
61732 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
61746 /* If the VM did not run to completion or if it encountered an
61747 ** error, then it might not have been halted properly. So halt
61754 ** if the VDBE has just been set to run but has not actually executed any
61901 ** not been deleted out from under the cursor, then this routine is a no-op.
61971 ** of SQLite will not understand those serial types.
62038 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
62041 ** ever since. The blame is not necessarily with GCC, though.
62337 ** Key1 and Key2 do not have to contain the same number of fields.
62372 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
62529 ** of the keys prior to the final rowid, not the entire key.
62650 ** May you do good and not evil.
62676 ** Check on a Vdbe to make sure it has not been finalized. Log
62992 ** This "automatic-reset" change is not technically an incompatibility,
63015 /* Check that malloc() has not failed. If it has, return early. */
63030 ** from interrupting a statement that has not yet started.
63296 ** This function is deprecated. Do not use it for new code. It is
63329 ** If iCol is not valid, return a pointer to a Mem which has a value
63489 ** If the result is not a simple column reference (if it is an expression
63539 ** not define OMIT_DECLTYPE.
63542 # error "Must not define both SQLITE_OMIT_DECLTYPE \
63567 ** anything else which is not an unabiguous reference to a database column.
63583 ** anything else which is not an unabiguous reference to a database column.
63599 ** anything else which is not an unabiguous reference to a database column.
63881 ** will not bother to check for that condition.
63914 ** Return true if the prepared statement is guaranteed to not modify the
63965 ** May you do good and not evil.
64169 ** Append a '\n' if there is not already one.
64237 ** May you do good and not evil.
64273 ** in this file for details. If in doubt, do not deviate from existing
64280 ** not misused.
64304 ** This facility is used for testing purposes only. It does not function
64314 ** sorting is occurring or not occurring at appropriate times. This variable
64340 ** is executed. This is used to test whether or not the foreign key
64371 ** does not control the string, it might be deleted without the register
64476 ** looks like a number, convert it into a number. If it does not
64504 ** is not possible. Note that the integer representation is
64521 ** representation (blob and NULL do not get converted) but no string
64555 ** not the internal Mem* type.
64700 ** May you do good and not evil.
65478 ** Do not deviate from the formatting style currently in use.
65545 ** value in register P3 is not NULL, then this routine is a no-op.
65561 ** whether or not to rollback the current transaction. Do not rollback
65564 ** VDBE, but do not rollback the transaction.
65566 ** If P4 is not null then it is an error message string.
65830 ** Thus the program must guarantee that the original will not change
65864 ** not return the number of rows modified. And do not RELEASE the statement
65879 ** ensure that statement-transactions are always nested, not overlapping.
65880 ** If the open statement-transaction is not closed here, then the user
66095 ** to retrieve the collation sequence set by this opcode is not available
66108 ** Register P3 must not be one of the function inputs.
66110 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
66321 ** in P1 is not an integer and cannot be converted into an integer
66368 ** A NULL value is not changed by this routine. It remains NULL.
66391 ** A NULL value is not changed by this routine. It remains NULL.
66415 ** A NULL value is not changed by this routine. It remains NULL.
66431 ** A NULL value is not changed by this routine. It remains NULL.
66449 ** A NULL value is not changed by this routine. It remains NULL.
66482 ** P4 is used to do the comparison. If P4 is not specified then
66488 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
66494 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
66554 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
66555 ** or not both operands are null.
66860 ** Jump to P2 if the value in register P1 is not NULL.
66933 ** might be available in the u.an.pC->aRow cache. Or it might not be.
67035 /* Make sure a corrupt database has not given us an oversize header.
67060 ** not exceeded even for corrupt database files.
67067 ** record header if the record header does not fit on a single page
67107 ** table. Set the u.an.offset for any extra columns not present in
67132 ** then there are not enough fields in the record to satisfy the
67293 ** We do not allow blobs with a prefix and a zero-filled tail. */
67311 ** the new record. The output register (pOp->p3) is not allowed to
67410 ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
67458 /* It is not possible to release (commit) a savepoint if there are
67459 ** active write statements. It is not possible to rollback a savepoint
67469 /* Determine whether or not this is a transaction savepoint. If so,
67632 ** connection is currently not in autocommit mode, or if there are other
67796 ** not reload the schema from the database file.
67798 ** If virtual-tables are in use, this is not just an optimization.
67801 ** prepared queries. If such a query is out-of-date, we do not want to
67824 ** values need not be contiguous but all P1 values should be small integers.
67827 ** If P5!=0 then use the content of register P2 as the root page, not
67862 ** cursors or a single read/write cursor but not both.
67940 ** and report database corruption if they were not, but this check has
67956 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
68082 ** Close a cursor previously opened as P1. If P1 is not
68101 ** greater than or equal to the key and P2 is not zero, then jump to P2.
68114 ** the key and P2 is not zero, then jump to P2.
68127 ** the key and P2 is not zero, then jump to P2.
68140 ** less than or equal to the key and P2 is not zero, then jump to P2.
68178 /* If the P3 value could not be converted into an integer without
68183 ** then the seek is not possible, so jump to P2 */
68344 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
68426 ** or may not be the same as R.
68433 ** of the index entry is not R. If there is no such entry, control jumps
68506 ** with that key does not exist in table of P1, then jump to P2.
68576 ** The record number is not previously used as a key in the database
68614 ** it already exists in the table. If it does not exist, we have
68688 ** it finds one that is not previously used. */
68733 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
68739 ** operation will not attempt to find the appropriate row before doing
68751 ** may be NULL. If it is not NULL, then the update-hook
68757 ** value of register P2 will then change. Make sure this does not
68766 ** integer value P3, not the value of the integer stored in register P3.
68848 ** incremented (otherwise not).
68850 ** P1 must not be pseudo-table. It has to be a real table with
68853 ** If P4 is not NULL, then it is the name of the table that P1 is
68855 ** If P4 is not NULL then the P1 cursor must have been positioned
68967 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
68968 ** of a real table, not a pseudo-table.
68977 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
68978 ** of a real table, not a pseudo-table.
69122 ** If P2 is 0 or if the table or index is not empty, fall through
69160 ** regression tests can determine whether or not the optimizer is
69180 ** If P2 is 0 or if the table or index is not empty, fall through
69221 ** The P1 cursor must be for a real table, not a pseudo-table.
69238 ** The P1 cursor must be for a real table, not a pseudo-table.
69545 ** in the database file is given by P1. But, unlike Destroy, do not
69553 ** intkey table (an SQL table, not an index). In this case the row change
69750 ** If P5 is not zero, the check is done on the auxiliary database
69751 ** file, not the main database file.
69803 ** An assertion fails if P2 is not an integer.
69858 ** the rowset object for P3, as it is guaranteed not to contain it,
69935 ** is really a trigger, not a foreign key action, and the flag set
70097 ** This instruction throws an error if the memory cell is not initially
70127 ** not contain an integer. An assertion fault will result if you try.
70143 ** not contain an integer. An assertion fault will result if you try.
70160 ** not contain an integer. An assertion fault will result if you try.
70238 ** argument is not used by this opcode. It is only there to disambiguate
70241 ** the step function was not previously called.
70265 ** Checkpoint database P1. This is a no-op if P1 is not currently in
70268 ** SQLITE_BUSY or not, respectively. Write the number of pages in the
70340 /* Do not allow a transition to journal_mode=WAL for a database
70341 ** in temporary storage or if the VFS does not support shared memory
70408 ** machines to be created and run. It may not be called from within
70497 ** Also, whether or not P4 is set, check that this is not being called from
70698 ** do this regardless of whether or not an error occurred to ensure any
70883 ** Do not let the maximum page count fall below the current page count and
70884 ** do not change the maximum page count value if P3==0.
71061 ** May you do good and not evil.
71094 ** If an error occurs, or if the specified row does not exist or does not
71265 ** column is not indexed, and that it is not part of a foreign key.
71273 /* Check that the column is not part of an FK child key definition. It
71274 ** is not necessary to check if it is part of a parent key, as parent
71485 ** If an error occurs, or if the specified row does not exist or does not
71531 ** May you do good and not evil.
72064 ** in the PMA (not including the varint itself).
72081 /* If the first temporary PMA file has not been opened, open it now. */
72220 /* If no data has been written to disk, then do not do so now. Instead,
72268 /* Open the second temp file, if it is not already open. */
72414 ** May you do good and not evil.
72428 ** on disk is not created or populated until either:
72454 ** If it does not already exists, create and populate the on-disk file
72628 ** file has not yet been created, create it now.
72654 ** May you do good and not evil.
72774 ** access writes are not required by sqlite.
72915 ** May you do good and not evil.
72937 ** WRC_Prune Do not descend into child nodes. But allow
72982 ** not invoke the SELECT callback on p, but do (of course) invoke
72999 ** FROM clause of SELECT statement p. Do not invoke the select
73028 ** If the Walker does not have an xSelectCallback() then this routine
73053 ** May you do good and not evil.
73091 ** then again, we might not...
73150 ** Return FALSE if the USING clause is NULL or if it does not contain
73277 /* If we have not already resolved the name, then maybe
73339 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
73384 ** case, we need to return right away and not make any changes to
73388 ** fields are not changed in any context.
73397 ** cnt==0 means there was not match. cnt>1 means there were two or
73595 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
73668 ** no match, or if pE is not a simple identifier, then this routine
73671 ** pEList has been resolved. pE has not.
73696 ** ORDER BY of a compound SELECT. The expression has not been
73700 ** ORDER BY term is not an integer index into the result set. That
73857 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
74018 ** are not allowed to refer to any names, so pass an empty NameContext.
74072 ** expression, do not allow aggregates in any of the other expressions.
74104 /* The ORDER BY and GROUP BY clauses may not refer to terms in
74123 ** the GROUP BY clause does not contain aggregate functions.
74133 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
74278 ** May you do good and not evil.
74418 /* One side is a column, the other is not. Use the columns affinity. */
74482 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
74483 ** it is not considered.
74534 ** expression depth allowed. If it is not, leave an error message in
74638 ** parameter is ignored if pToken is NULL or if the token does not
74643 ** can be translated into a 32-bit integer, then the token is not
74808 ** sure "nnn" is not too be to avoid a denial of service attack when
74947 ** off if the expression is reduced. Note also that it does not work to
74995 ** and Expr.pRight variables (but not for any structures pointed to or
75011 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
75108 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
75111 ** Any tables that the SrcList might point to are not duplicated.
75381 ** not constant.
75474 ** in *pValue. If the expression is not an integer or if it is too big
75636 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
75639 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
75640 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
75683 ** If the prNotFound parameter is not 0, then the b-tree will be used
75689 ** needs to know whether or not the structure contains an SQL NULL
75697 ** its initial value is NULL. If the (...) does not remain constant
75770 ** it is not, it is not possible to use any index.
75802 /* Could not found an existing table or index to use as the RHS b-tree.
75846 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
75956 ** that columns affinity when building index keys. If <expr> is not
75977 /* If the expression is not constant then we will need to
76018 ** an integer 0 (not exists) or 1 (exists) into a memory cell
76072 ** if the LHS is NULL or if the LHS is not contained within the RHS and the
76075 ** This routine generates code will jump to destIfFalse if the LHS is not
76083 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
76113 ** on whether the RHS is empty or not, respectively.
76160 ** then the presence of NULLs in the RHS does not matter, so jump
76165 /* Here we begin generating code that runs if the LHS is not
76178 /* Jump to the appropriate target depending on whether or not
76212 ** The z[] string will probably not be zero-terminated. But the
76213 ** z[n] character is guaranteed to be something that does not look
76436 ** not guaranteed. The location of the column value is returned.
76523 ** and does not appear in a normal build.
76877 ** second argument, not the first, as the argument to test to
77080 ** So make sure that the regFree1 register is not reused for other
77152 ** then write its number into *pReg. If the result register is not
77487 ** or OP_Variable that does not need to be placed in a
77597 ** obtained for queries regardless of whether or not constants are
77975 ** returns 2, then you do not really know for certain if the two
77978 ** this routine is used, it does not hurt to get an extra 2 - that
78103 ** is not an entry there already.
78320 ** May you do good and not evil.
78330 ** The code in this file only exists if we are not omitting the
78467 ** TRIGGER, not CREATE INDEX and CREATE TABLE.
78571 ** If argument zWhere is not NULL, then the string returned is
78615 /* If the table is not located in the temp-db (in which case NULL is
78617 ** that is not part of the temp-db schema, add a clause to the WHERE
78676 /* Now, if the table is not stored in the temp database, reload any temp
78689 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
78691 ** Or, if zName is not a system table, zero is returned.
78695 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
78739 /* Check that a table or index named 'zName' does not already exist
78748 /* Make sure it is not a system table being altered, or a reserved name
78760 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
78975 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
78977 ** column must not be NULL.
78999 ** can handle (i.e. not CURRENT_TIME etc.)
79035 ** format to 2. If the default value of the new column is not NULL,
79077 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
79082 /* Make sure this is not an attempt to ALTER a view. */
79097 ** prefix, we insure that the name will not collide with an existing
79098 ** table because user table are not allowed to have the "sqlite_"
79148 ** May you do good and not evil.
79166 ** The sqlite_stat2 table is not created or used unless the SQLite version
79193 ** the index is unordered and will not use the index for a range query.
79221 ** version of SQLite does not support sqlite_stat2. It neither reads nor
79254 ** the key space, though not uniformly, and which include samples with
79265 ** If the sqlite_stat1 tables does not previously exist, it is created.
79266 ** Similarly, if the sqlite_stat3 table does not exist and the library
79270 ** or it may be a NULL pointer. If it is not NULL, then all entries in
79304 /* Create new statistic tables if they do not exist, or clear them
79311 /* The sqlite_stat[12] table does not exist. Create it. Note that a
79321 /* The table already exists. If zWhere is not NULL, delete all entries
79430 ** decision about whether or not to retain this key for the sqlite_stat3
79572 Index *pOnlyIdx, /* If not NULL, only analyze this one index */
79614 /* Do not gather statistics on views or virtual tables */
79618 /* Do not gather statistics on system tables */
79880 ** a database. If pOnlyIdx is not NULL then it is a single index
79934 if( i==1 ) continue; /* Do not analyze the TEMP database */
80036 ** If the Index.aSample variable is not NULL, delete the aSample[] array
80195 ** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR
80201 ** sqlite_stat3 table is not present in the database, SQLITE_ERROR is
80206 ** This means if the caller does not care about other errors, the return
80271 ** May you do good and not evil.
80283 ** identifiers are treated as strings, not possible column names or aliases.
80392 ** or may not be initialised.
80683 ** The return value indicates whether or not fixation is required. TRUE
80684 ** means we do need to fix the database references, FALSE means we do not.
80712 ** view in one database does not refer to objects in a different database.
80830 ** May you do good and not evil.
80837 ** systems that do not need this facility may omit it by recompiling
80917 ** callback has been registered (i.e. that sqlite3.xAuth is not NULL).
80919 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
81035 sqlite3ErrorMsg(pParse, "not authorized");
81081 ** May you do good and not evil.
81294 ** this way, the final OP_Halt is not appended and other initialization
81331 ** database containing the table. Return NULL if not found.
81361 ** database containing the table. Return NULL if not found. Also leave an
81366 ** sqlite3FindTable() does not.
81399 ** Return NULL if not found.
81519 ** schema hash tables and therefore do not have to make any changes
81574 ** This routine just deletes the data structure. It does not unlink
81584 /* Do not delete the table until the reference count reaches zero. */
81651 ** are not \000 terminated and are not persistent. The returned string
81704 ** does not exist.
81721 ** the table name is not fully qualified, i.e.:
81816 ** the table name is not fully qualified, i.e.:
81830 /* If creating a temp table, the name may not be qualified. Unless
81871 /* Make sure the new table name does not collide with an existing
81945 /* If the file format and encoding in the database have not been set,
81963 ** The record created does not contain anything yet. It will be replaced
82001 ** WARNING: This macro is not compatible with the strcmp() family. It
82160 ** is not the case.
82173 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
82205 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
82327 ** If the requested collation sequence is not available, or not available
82329 ** request it. If the collation factory does not supply such a sequence,
82368 ** it checks the cookie to make sure the schema has not changed
82371 ** This plan is not completely bullet-proof. It is possible for
82390 ** but does not include the null terminator.
82412 ** characters, does not begin with a digit and is not an SQL keyword,
82521 ** the sqlite_master table. We do not want to create it again.
82523 ** If the pSelect argument is not NULL, it means that this routine
82572 ** So do not write to the disk again. Extract the root page number
82580 /* If not initializing, then create a record for the new table
82621 ** A shared-cache write-lock is not required to write to the new table,
82755 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
82861 ** to the elements of the FROM clause. But we do not want these changes
82939 ** or tables and not the table/index that is actually being moved.
83013 ** is not defined), then it is important to call OP_Destroy on the
83220 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
83225 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
83300 "number of columns in foreign key does not match the number of "
83405 ** if memRootPage is not negative, it means that the index is newly
83479 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC
83506 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
83576 ** Find the table that is to be indexed. Return early if not found.
83591 ** is a temp table. If so, set the database to 1. Do not do this
83626 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
83631 sqlite3ErrorMsg(pParse, "views may not be indexed");
83637 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
83643 ** Find the name of the index. Make sure there is not already another
83776 ** if any column is not found.
83778 ** TODO: Add a test to make sure that the same column is not named
83802 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
84015 ** to be used when we have not run the ANALYZE command.
84018 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
84205 ** if not found.
84292 ** If pDatabase is not null, it means that the table has an optional
84669 ** This routine starts a new transaction if we are not already within
84676 ** necessary to undo a write and the checkpoint should not be set.
84733 ** true if it does and false if it does not.
84905 ** May you do good and not evil.
84958 pColl->xDel = 0; /* Do not copy the destructor */
84968 ** requested collation sequence is not available in the desired encoding.
84970 ** If it is not NULL, then pColl must point to the database native encoding
85009 ** that have not been defined by sqlite3_create_collation() etc.
85035 ** specified by zName and nName is not found and parameter 'create' is
85089 ** If the entry specified is not found and 'create' is true, then create a
85206 ** NULL if the function does not exist.
85219 ** number of arguments may be returned even if the eTextRep flag does not
85228 int createFlag /* Create new entry if true and does not otherwise exist */
85261 ** So we must not search for built-ins when creating a new function.
85277 /* If the createFlag parameter is true and the search did not reveal an
85299 ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
85303 ** The Schema.cache_size variable is not cleared.
85364 ** May you do good and not evil.
85379 ** name is not found or if any other error occurs.
85404 ** Check to make sure the given table is writable. If it is not
85409 /* A table is not writable under the following circumstances:
85413 ** 2) It is a system table (i.e. sqlite_master), this call is not
85414 ** part of a nested parse and writable_schema pragma has not
85425 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
85792 ** generating code because of a call to sqlite3NestedParse(), do not
85854 ** not attempt to delete it or fire any DELETE triggers. */
85889 ** being deleted. Do not attempt to delete the row a second time, and
85890 ** do not fire AFTER triggers. */
85895 ** are not violated by deleting this row. */
86017 ** May you do good and not evil.
86158 /* Because sqlite3_value_double() returns 0.0 if the argument is not
86338 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86357 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86375 ** do not have to be computed. This legacy implementation is retained as
86543 ** [^...] Matches one character not in the enclosed list.
86588 assert( esc==0 ); /* This is GLOB, not LIKE */
86618 assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
86710 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
86852 ** EXPERIMENTAL - This is not an official function. The interface may
86853 ** change. This function may disappear. Do not write code that depends
86978 ** must be exact. Collating sequences are not used.
87435 ** This routine only deals with those that are not global.
87459 ** parameter determines whether or not the LIKE operator is case
87482 ** return TRUE. If the function is not a LIKE-style function then
87622 ** May you do good and not evil.
87655 ** there is no way to tell which foreign constraint is not satisfied,
87656 ** or which row it is not satisfied for.
87679 ** deleted row in the child table. If such a row is not found,
87709 ** an INSERT does not open a statement transaction.
87719 ** for those two operations needs to know whether or not the operation
87767 ** is not a composite foreign key), output variable *paiCol is set to NULL.
87778 ** 1) The named parent key columns do not exist, or
87780 ** 2) The named parent key columns do exist, but are not subject to a
87784 ** foreign key definition, and the parent table does not have a
87819 ** Non-composite foreign keys do not require the aiCol array.
87913 ** special action is taken. Otherwise, if the parent row can *not* be
87946 ** outstanding constraints to resolve. If there are not, there is no need
87971 ** will have INTEGER affinity applied to it, which may not be correct. */
87977 ** then check if the row being inserted matches itself. If so, do not
88003 ** then check if the row being inserted matches itself. If so, do not
88040 ** generated for will not open a statement transaction. */
88175 ** clause. If the constraint is not deferred, throw an exception for
88247 ** DELETE, but foreign key actions are not.
88278 ** transactions are not able to rollback schema changes. */
88405 ** If the parent does not exist, removing the child row resolves an
88500 ** If the i'th column is not modified by the UPDATE, then the corresponding
88844 ** May you do good and not evil.
89072 assert( v ); /* We failed long ago if this is not so */
89217 ** The 3rd template is for when the second template does not apply
89218 ** and the SELECT clause does not read from <table> at any time.
89357 ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
89365 * (a) the table is not read-only,
89544 ** the index of the primary key as it appears in IDLIST, not as
89590 /* If this is not a view, open the table and and all indices */
89652 ** we do not know what the unique ID will be (because the insert has
89653 ** not happened yet) so we substitute a rowid of -1
89697 ** do not attempt any conversions before assembling the record.
89869 ** generating code because of a call to sqlite3NestedParse(), do not
89921 ** computed automatically in an insert or that the rowid value is not
89942 ** only (do not do a complete rollback) then
89948 ** transaction is not rolled back and any
89973 ** cursors do not need to be open for indices where aRegIdx[i]==0.
89983 int overrideError, /* Override onError to this if not OE_Default */
90001 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
90031 zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
90069 ** of the new record does not previously exist. Except, if this
90070 ** is an UPDATE and the primary key is not changing, that is OK.
90103 ** flag is not set, but the table has one or more indexes, call
90148 ** index and making sure that duplicate entries do not already exist.
90176 continue; /* pIdx is not a UNIQUE index */
90196 /* Generate code that executes if the new index entry is not unique */
90218 pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
90281 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
90419 ** Columns are not decoded and reassemblied, which greatly improves
90465 return 0; /* tab1 must not have triggers */
90469 return 0; /* tab1 must not be a virtual table */
90484 return 0; /* SELECT may not have a WHERE clause */
90487 return 0; /* SELECT may not have an ORDER BY clause */
90489 /* Do not need to test for a HAVING clause. If HAVING is present but
90492 return 0; /* SELECT may not have a GROUP BY clause */
90495 return 0; /* SELECT may not have a LIMIT clause */
90499 return 0; /* SELECT may not be a compound query */
90502 return 0; /* SELECT may not be DISTINCT */
90521 return 0; /* FROM clause does not contain a real table */
90524 return 0; /* tab1 and tab2 may not be the same table */
90528 return 0; /* tab2 must not be a virtual table */
90532 return 0; /* tab2 may not be a view */
90573 ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
90580 return 0; /* xfer opt does not play well with PRAGMA count_changes */
90607 ** (If the destination is not initially empty, the rowid fields
90688 ** May you do good and not evil.
90695 ** other files are for internal use by SQLite and should not be
90835 ** May you do good and not evil.
90855 ** May you do good and not evil.
90878 ** versions of SQLite will not be able to load each others' shared
91093 ** (part of the main SQLite library - not an extension) so that
91095 ** definition. But the main library does not want to redefine
91405 ** not NULL before calling it.
91541 ** of the APIs above provided that the pointer is not NULL. But
91668 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
91676 char **pzErrMsg /* Put error message here if not 0 */
91695 *pzErrMsg = sqlite3_mprintf("not authorized");
91757 char **pzErrMsg /* Put error message here if not 0 */
91782 ** default so as not to open security holes in older applications.
91798 ** The auto-extension code added regardless of whether or not extension
91800 ** code if regular extension loading is not available. This is that
91945 ** May you do good and not evil.
92100 ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
92156 /* Foreign key support may not be enabled or disabled while not
92345 ** the database has not yet been created.
92502 /* If the "=MODE" part does not match any known journal mode,
92654 ** the local value does not make changes to the disk file and the default
92694 sqlite3ErrorMsg(pParse, "not a writable directory");
92769 ** the local value does not make changes to the disk file and the
92780 "Safety level may not be changed inside a transaction");
92991 ** used will be case sensitive or not depending on the RHS.
93173 ** database. If the database is not initialized, it is initialized now.
93176 ** has not already been initialized. In this case it sets the default
93183 ** the main database has not been initialized and/or created when ATTACH
93217 /* Only change the value of sqlite.enc if the database handle is not
93219 ** will be overwritten when the schema is next loaded. If it does not
93263 ** The user-version is not used internally by SQLite. It may be used by
93489 ** May you do good and not evil.
93699 /* If there is not already a read-only (or read-write) transaction opened
93736 ** For an attached db, it is an error if the encoding is not the same
93790 ** not downgrade the database and thus invalidate any descending
93942 /* If there is not already a read-only (or read-write) transaction opened
93954 /* Read the schema cookie from the database. If it does not match the
94045 ** is not possible for another thread to start a new schema change
94046 ** while this routine is running. Hence, we do not need to hold
94051 ** but it does *not* override schema lock detection, so this all still
94232 ** version, the original SQL text is not saved in the prepared statement
94312 ** version, the original SQL text is not saved in the prepared statement
94353 ** May you do good and not evil.
94364 ** Delete all the content of a Select structure but do not deallocate
94404 Expr *pLimit, /* LIMIT value. NULL means not used */
94523 "RIGHT and FULL OUTER JOINs are not currently supported");
94531 ** is not contained in the table.
94548 ** If not found, return FALSE.
94625 ** join restriction specified in the ON or USING clause and not a part
94631 ** expression depends on table iRightJoinTable even if that table is not
94639 ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
94691 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
94730 ** not contained in both tables to be joined.
94746 "not present in both tables", zName);
94828 ** stack if the top N elements are not distinct.
94833 int addrRepeat, /* Jump to here if not distinct */
94887 ExprList *pOrderBy, /* If not NULL, sort results using this key */
94930 ** values returned by the SELECT are not required.
94938 ** and this row has been seen before, then do not make this row
95006 ** does not matter. But there might be a LIMIT clause, in which
95068 ** user-defined functions that have side effects. We do not care
95168 ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
95397 ** This is not a problem, as the column type of "t1.col" is never
95644 /* Make sure the column name is unique. If the name is not unique,
95678 ** The column list has only names, not types or collations. This
95783 ** (usually but not always -1) prior to calling this routine.
95930 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
95936 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
95960 " do not have the same number of result columns", selectOpName(p->op));
96490 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
96491 ** actually called using Gosub and they do not Return. EofA and EofB loop
96626 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
96963 ** (1) The subquery and the outer query do not both use aggregates.
96965 ** (2) The subquery is not an aggregate or the outer query is not a join.
96967 ** (3) The subquery is not the right operand of a left outer join
96970 ** (4) The subquery is not DISTINCT.
96976 ** (6) The subquery does not use aggregates or the outer query is not
96984 ** (8) The subquery does not use LIMIT or the outer query is not a join.
96986 ** (9) The subquery does not use LIMIT or the outer query does not use
96989 ** (10) The subquery does not use aggregates or the outer query does not
96992 ** (11) The subquery and the outer query do not both have ORDER BY clauses.
96997 ** (13) The subquery and outer query do not both use LIMIT.
96999 ** (14) The subquery does not use OFFSET.
97001 ** (15) The outer query is not part of a compound select or the
97002 ** subquery does not have a LIMIT clause.
97005 ** (16) The outer query is not an aggregate or the subquery does
97006 ** not contain ORDER BY. (Ticket #2942) This used to not matter
97009 ** (17) The sub-query is not a compound select, or it is a UNION ALL
97013 ** * is not itself part of a compound select,
97014 ** * is not an aggregate or DISTINCT query, and
97015 ** * is not a join
97028 ** (19) The subquery does not use LIMIT or the outer query does not
97031 ** (20) If the sub-query is a compound select, then it must not use
97037 ** (21) The subquery does not use LIMIT or the outer query is not
97044 ** If flattening is not attempted, this routine is a no-op and returns 0.
97070 /* Check to see if flattening is permitted. Return 0 if not.
97086 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
97114 ** not used as the right operand of an outer join. Examples of why this
97115 ** is not allowed:
97123 ** which is not at all the same thing.
97128 ** An examples of why this is not allowed:
97142 ** subquery is the right term of a LEFT JOIN, then do not flatten.
97407 ** does not work if either limit is negative.
97462 ** where table is a database table, not a sub-select or view. If the query
97654 /* This particular expression does not need to be expanded.
97695 ** for virtual tables), do not include it in the expanded
97805 ** at that point because identifiers had not yet been resolved. This
98072 ** set is not empty.
98201 /* If the subquery is no correlated and if we are not inside of
98269 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
98297 ** we figure out that the sorting index is not needed. The addrSortIndex
98351 ** instruction ended up not being needed, then change the OP_OpenEphemeral
98484 ** that we do not need it after all, the OP_SorterOpen instruction
98521 ** we do not have to sort. The OP_OpenEphemeral table will be
98718 ** (2011-04-15) Do not do a full scan of an unordered index.
98720 ** In practice the KeyInfo structure will not be used. It is only
98761 ** where.c should not iterate over any values with a NULL value
98953 ** May you do good and not evil.
98962 ** These routines are in a separate files so that they will not be linked
98963 ** if they are not used.
99151 ** May you do good and not evil.
99245 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
99250 /* If TEMP was specified, then the trigger name may not be qualified. */
99252 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
99283 ** If sqlite3SrcListLookup() returns 0, indicating the table does not
99301 /* The table does not exist. */
99307 ** trigger is not visible to the database connection that does the
99320 /* Check that the trigger name is not reserved and that no trigger of the
99338 /* Do not create a trigger on a system table */
99443 /* if we are not initializing,
99923 ** program. It is not used in production code, only for debugging.
100091 /* If an existing TriggerPrg could not be located, create a new one. */
100131 ** not a foreign key action, and (b) the flag to enable recursive triggers
100164 ** never be accessed by the trigger program, so they are not allocated or
100167 ** are never accessed, and so are not allocated by the caller. So, for an
100169 ** is not a readable register, although registers (reg+N) through
100227 ** It is not possible to determine if the old.rowid or new.rowid column is
100278 ** May you do good and not evil.
100310 ** may not contain a value for the column and the default value, taken
100313 ** for the column and the P4 value is not required.
100326 ** If parameter iReg is not negative, code an OP_RealAffinity instruction
100378 ** aXRef[i]==-1 if the i-th column is not changed. */
100444 ** The index cursors might not be used, but if they are used they
100649 ** this record does not exist for some reason (deleted by a trigger,
100654 ** contain the new value. If the record number is not being modified,
100687 ** If there are one or more BEFORE triggers, then do not populate the
100688 ** registers associated with columns that are (a) not modified by
100689 ** this UPDATE statement and (b) not accessed by new.* references. The
100690 ** values for registers not modified by the UPDATE must be reloaded from
100692 ** may have modified them). So not loading those that are not going to
100707 /* This branch loads the value of a column that will not be changed
100737 /* If it did not delete it, the row-trigger may still have modified
100739 ** all columns not modified by the update statement into their
100821 ** generating code because of a call to sqlite3NestedParse(), do not
100953 ** May you do good and not evil.
101077 ** can be set to 'off' for this file, as it is not recovered if a crash
101123 /* Do not attempt to change the page size for a WAL database */
101297 ** May you do good and not evil.
101437 ** Except, if argument db is not NULL, then the entry associated with
101537 ** The string is not copied - the pointer is stored. The
101681 ** record of the table. The xConnect() method is not called until
101782 const char *zFormat = "vtable constructor did not declare schema: %s";
101837 ** This call is a no-op if table pTab is not a virtual table.
101923 ** invoke it now. If the module has not been registered, return an
102011 ** This call is a no-op if zTab is not a virtual table.
102113 ** not currently open, invoke the xBegin method now.
102365 ** May you do good and not evil.
102429 ** If a term in the WHERE clause does not match either of the two previous
102472 #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */
102481 # define TERM_VNULL 0x00 /* Disabled if not using stat3 */
102536 ** clause, the cursor numbers might not begin with 0 and they might
102549 ** Note that the mapping is not necessarily ordered. In the example
102552 ** does not really matter. What is important is that sparse cursor
102586 #define WO_NOOP 0x800 /* This term does not restrict search space */
102601 ** ISNULL constraints will then not be used on the right table of a left
102611 #define WHERE_NOT_FULLSCAN 0x100f3000 /* Does not do a full table scan */
102665 ** itself is not freed. This routine is the inverse of whereClauseInit().
102690 ** 0 is returned if the new WhereTerm could not be added due to a memory
102769 ** iCursor is not in the set.
102893 ** is not commuted.
102943 ** Return a pointer to the term. Return 0 if not found.
102949 Bitmask notReady, /* RHS must not overlap with this mask */
102951 Index *pIdx /* Must be compatible with this index, if not NULL */
103016 ** so and false if not.
103019 ** literal that does not begin with a wildcard.
103114 ** If it is then return TRUE. If not, return FALSE.
103202 ** This analysis does not consider whether or not the index exists; that
103208 ** always prefer case 1, so in that case we pretend that case 2 is not
103222 ** zero. This term is not useful for search.
103349 ** will be recorded in iCursor and iColumn. There might not be any
103351 ** and column is found but leave okToChngToIN false if not found.
103366 ** chngToIN set but t1 is not. This term will be either preceeded
103519 extraRight = x-1; /* ON clause terms may not be used with an index
103683 ** virtual tables. The native query optimizer does not attempt
103719 ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a
103723 ** TERM_VNULL tag will suppress the not-null check at the beginning
103724 ** of the loop. Without the TERM_VNULL flag, the not-null check at
103820 ** DISTINCT qualifier. In other words, it tests whether or not using this
103845 ** are not simple column references, return early. Otherwise, test if the
103847 ** can be ignored. If it does not, and the column does not belong to the
103895 ** this query, then it will not be possible to show that the DISTINCT
103954 ** index do not need to satisfy this constraint.) The *pbRev value is
104004 /* Can not use an index sort on anything that is not a column in the
104025 /* Term j of the ORDER BY clause does not match column i of the index */
104035 /* If an index column fails to match and is not constrained by ==
104080 ** condition is IS NULL then the result is not necessarily unique
104089 ** The results need not be exact. This is only used for estimating
104166 Bitmask notReady, /* Mask of cursors not available for indexing */
104167 Bitmask notValid, /* Cursors not available for any purpose */
104285 Bitmask notReady, /* Mask of cursors that are not available */
104356 Bitmask notReady, /* Mask of cursors that are not available */
104408 ** be a covering index because the index will not be updated if the
104614 ** Whether or not an error is returned, it is the responsibility of the
104671 Bitmask notReady, /* Mask of cursors not available for index */
104672 Bitmask notValid, /* Cursors not valid for any purpose */
104693 /* If the sqlite3_index_info structure has not been previously
104772 ** does not satisfy it, increase the cost of the scan accordingly. This
104780 /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the
105015 ** If either of the upper or lower bound is not present, then NULL is passed in
105214 ** * Whether or not sorting must occur.
105216 ** * Whether or not there must be separate lookups in the
105234 Bitmask notReady, /* Mask of cursors not available for indexing */
105235 Bitmask notValid, /* Cursors not available for any purpose */
105254 /* If the pSrc table is the right table of a LEFT JOIN then we may not
105256 ** because columns might end up being NULL if the table does not match -
105341 ** IN operator must be a SELECT, not a value list, for this variable
105353 ** external sort (i.e. scanning the index being evaluated will not
105358 ** visited. In other words, true if this is not a covering index.
105365 ** of column c, but the first does not because columns a and b are
105378 int bLookup = 0; /* True if not a covering index */
105468 /* If currently calculating the cost of using an index (not the IPK
105491 ** constraint, do not let the estimate exceed half the rows in the table.
105501 ** and we do not think that values of x are unique and if histogram
105534 ** not give us data on the relative sizes of table and index records.
105594 ** matters if the current index is the least costly, so do not bother
105595 ** with this step if we already know this index will not be chosen.
105602 ** tables that are not in outer loops. If notReady is used here instead
105717 Bitmask notReady, /* Mask of cursors not available for indexing */
105718 Bitmask notValid, /* Cursors not available for any purpose */
105738 ** Disable a term in the WHERE clause. Except, do not disable the term
105739 ** if it controls a LEFT OUTER JOIN and it did not originate in the ON
105749 ** in the ON clause. The term is disabled in (3) because it is not part
105750 ** of a LEFT OUTER JOIN. In (1), the term is not disabled.
105755 ** Disabling a term causes that term to not be tested in the inner loop
105926 Bitmask notReady, /* Which parts of FROM have not yet been coded */
106176 int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
106425 ** should not have a NULL value stored in 'x'. If column 'x' is
106560 ** of the table column that the inequality contrains is not NULL.
106644 int untestedTerms = 0; /* Some terms not completely tested */
106735 ** terms from the notReady table could not be tested and will
106891 ** Note that the loops might not be nested in the order in which they
106966 Bitmask notReady; /* Cursors that are not yet positioned */
107052 ** the OR-to-IN transformation in exprAnalyzeOrTerm(). It is not helpful
107056 ** pTabList, not just the first nTabList tables. nTabList is normally
107081 ** add new virtual terms onto the end of the WHERE clause. We do not
107149 ** not be as small as it would be if the table really were the innermost
107151 ** that do not use indices. But this nRow reduction only happens if the
107168 ** is not possible to determine this with a simple greedy algorithm.
107177 Bitmask mask; /* Mask of tables not yet ready */
107179 int doNotReorder; /* True if this table should not be reordered */
107224 ** (1) The table must not depend on other tables that have not
107291 ** used for the scan. If not, then query compilation has failed.
107408 ** is not used, its name is just '{}'. If no index is used
107637 int not; /* True if the NOT keyword is present */
107756 ** original value of the token will not parse.
107775 ** YYERRORSYMBOL is the code number of the error symbol. If not
107818 /* Define the yytestcase() macro to be a no-op if is not already defined
107857 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
107858 ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
108354 ** but it does not parse, the type of the token is changed to ID and
108978 ** which appear on the RHS of the rule, but which are not used
109096 /* In SQLite, we never try to destroy a parser that was not successfully
109648 ** not set the value of its left-hand side nonterminal. Leaving the
109654 ** without this code, their parser segfaults. I'm not sure what there
109657 ** that it has not been previously stressed... (SQLite ticket #2172)
110303 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
110307 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
110315 if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110328 if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110611 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
110618 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
110625 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
110781 /* If we are not debugging and the reduce action popped at least
110940 ** The response to an error depends upon whether or not the
110994 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
111005 #else /* YYERRORSYMBOL is not defined */
111006 /* This is what we do if the grammar does not define ERROR:
111038 ** May you do good and not evil.
111087 ** returned. If the input is not a keyword, TK_ID is returned.
111104 ** or not a given identifier is really an SQL keyword. The same thing
111383 ** Ticket #1066. the SQL standard does not allow '$' in the
111620 /* Fall through into the next case if the '#' is not followed by
111805 /* If the pParse->declareVtab flag is set, do not delete any table
111840 ** May you do good and not evil.
111850 ** static links that do not use it.
111892 ** (0) INVALID We have not yet seen a non-whitespace character.
111934 ** is look for a semicolon that is not part of an string or comment.
111957 /* If triggers are not supported by this compile then the statement machine
112091 ** above, except that the parameter is required to be UTF-16 encoded, not
112125 ** May you do good and not evil.
112132 ** other files are for internal use by SQLite and should not be
112145 ** May you do good and not evil.
112177 ** May you do good and not evil.
112209 ** May you do good and not evil.
112265 ** If the following function pointer is not NULL and if
112287 ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
112300 ** calls to this routine should not block, of course. Otherwise the
112326 ** must be complete. So isInit must not be set until the very end
112334 ** there is not much SQLite is going to be able to do.
112346 ** mutex must not require support from the malloc subsystem.
112369 /* If rc is not SQLITE_OK at this point, then either the malloc
112370 ** subsystem could not be initialized or the system failed to allocate
112383 ** to the xInit method, so the xInit method need not be threadsafe.
112456 ** Undo the effects of sqlite3_initialize(). Must not be called while
112459 ** routine is not threadsafe. But it is safe to invoke this routine
112494 ** database connections or memory allocations. This routine is not
112621 /* The heap pointer is not NULL, then install one of the
112679 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
112827 ** If the padFlag argument is not NULL then space padding at the end
112897 ** database handle object, it does not close any savepoints that may be open
112913 ** if this is not the last copy of the function, do not invoke it. Multiple
112947 ** will not have called the xDisconnect() method on any virtual
112990 ** locks and does not require any further unlock-notify callbacks.
113040 ** So it needs to be freed here. Todo: Why not roll the temp schema into
113096 /* SQLITE_OK */ "not an error",
113122 /* SQLITE_NOTADB */ "file is encrypted or is not a database",
113295 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
113441 ** this routine is a no-op. If the function does not exist, then create
113689 ** not currently open in WAL mode.
113692 ** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
113881 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
113907 ** sqlite3_create_collation, and not generated by synthCollSeq(),
113967 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
113985 # error SQLITE_MAX_COLUMN must not exceed 32767
113998 ** A new lower limit does not shrink existing constructs.
114045 ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
114233 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
114294 ** do not block illegal combinations here, it could trigger
114443 /* Register all built-in functions, but do not attempt to read the
114699 ** Test to see whether or not the database connection is in autocommit
114700 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
114825 ** 2. The table is not a view and the column name identified an
115029 ** This action provides a run-time test to see whether or not
115112 ** number of keywords. Or if zWord is not a keyword, return 0.
115115 ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
115183 ** parameter if it exists. If the parameter does not exist, this routine
115244 ** May you do good and not evil.
115254 /* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
115272 ** is not NULL. This variable may only accessed while the STATIC_MASTER
115288 ** 3) If the argument db is not NULL, then none of the entries in the
115316 ** db is not currently a part of the list, this function is a no-op.
115331 ** that it is not already a part of the list.
115430 ** to the user because it requires a lock that will not be available
115577 ** May you do good and not evil.
115590 ** (in which case SQLITE_CORE is not defined), or
115599 ** bottom up in optimal fashion and are not updatable. Since trees
115619 ** the encoding is not the same. SQLite varints are big-endian
115662 ** The positions numbers are not stored literally but rather as two more
115873 ** May you do good and not evil.
115898 /* If not building as part of the core, include sqlite3ext.h. */
115976 ** sqlite3_tokenizer.pModule variable should not be initialised by
116067 ** May you do good and not evil.
116086 ** code should not attempt to access or modify the fields of this structure
116208 ** from that used by SQLite, so the maximum length is 10, not 9.
116351 ** pending data, including hash table overhead, but not malloc overhead.
116373 ** values do not contribution to the FTS computation; they are used for
116488 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
116744 ** input does not begin with a quote character, then this routine
116943 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
117040 ** There may not be whitespace surrounding the "=" character. The <value>
117041 ** term may be quoted, but the <key> may not.
117127 ** from left to write. If parameter zFunc is not NULL, then instead of
117138 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
117179 ** If argument zFunc is not NULL, then all but the first question mark
117189 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
117221 ** If *pp does not being with a decimal digit SQLITE_ERROR is returned and
117253 ** Regardless of whether or not an error is returned, it is the responsibility
117825 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
117890 ** If piFirst is not NULL, then this function sets *piFirst to the blockid
117893 ** If piLast is not NULL, then *piLast is set to the right-most child node
117920 ** varints from the buffer) does not risk an overread. If zNode is a
117922 ** not make this guarantee explicitly, but in practice there are always
118006 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
118008 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
118012 ** It is possible that the range of returned leaf nodes does not contain
118016 ** never loads leaf nodes into memory), it is not possible to be sure.
118088 ** If pp is not NULL, then the contents of the position list are copied
118098 ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
118101 ** The following while-loop moves pEnd to point to the first byte that is not
118134 ** If pp is not NULL, then the contents of the column-list are copied
118137 ** is not copied into *pp.
118144 ** not part of a multi-byte varint.
118162 ** it is not possible to have a document with 2^31 terms.
118197 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
118202 ** returning (do not modify it if iCol==0). Return the total number of bytes
118308 ** when the *pp1 token appears before the *pp2 token, but not more than nToken
118435 ** entries that are not sufficiently NEAR entries in *pp1 removed.
118488 ** If *pp does not point to or past pEnd, then a single varint is read
118928 /* If iLevel is less than 0 and this is not a scan, include a seg-reader
118930 ** made by an fts4aux module, not an FTS table. In this case calling
118932 ** fts4aux are not completely populated. So it's easiest to filter these
118957 /* If zTerm is not NULL, and this segment is not stored entirely on its
119187 ** subsequently to determine whether or not an EOF was hit.
119885 ** segment b-tree (if the term is not a prefix or it is a prefix for which
119986 ** does not take deferred tokens into account.
120021 ** means that the phrase does not appear in the current row, doclist.pList
120126 ** If parameter bOptOk is true, then the phrase may (or may not) use the
120281 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
120298 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120307 ** may be loaded incrementally, meaning doclist.aAll/nAll is not available.
120342 ** to phrases that are connected only by AND and NEAR operators (not OR or
120360 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120421 ** of each doclist, has not yet been determined. Read the required
120496 ** option. The reason being that it is not guaranteed that the content
120535 ** one or more tokens will not be deferred.
120679 ** All positions in the pPhrase position list that are not sufficiently
120733 ** If the expression is of type FTSQUERY_PHRASE, and the expression is not
120743 ** 1. Deferred tokens are not taken into account. If a phrase consists
120745 ** the db. In this case the position-list is not populated at all.
120872 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
120882 ** constraints. In this case it returns 1. If the NEAR expression does not
120883 ** match the current row, 0 is returned. The position lists may or may not
120961 ** currently points to, or zero if it does not.
120963 ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120970 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
120984 /* If the NEAR expression does not match any rows, zero the doclist for
120986 ** offsets() and matchinfo() functions are not supposed to recognize
120996 ** then any snippet() should ony highlight the "a" term, not the "b"
121061 ** * Deferred tokens have not yet been considered.
121063 ** If *pRc is not SQLITE_OK when this function is called, it immediately
121064 ** returns 0. Otherwise, it tests whether or not after considering NEAR
121071 ** it is determined that the row does *not* match the query.
121130 ** fts3EvalNext() visits the first row. Do not allow incremental
121210 ** If it is not already allocated and populated, this function allocates and
121285 ** do loop can not be written:
121375 ** This function works regardless of whether or not the phrase is deferred,
121467 ** May you do good and not evil.
121748 ** integer encountered in state 1 is not 0 or 1, then we need to
121943 ** May you do good and not evil.
121962 ** a) The new syntax supports parenthesis. The old does not.
121964 ** b) The new syntax supports the AND and NOT operators. The old does not.
121966 ** c) The old syntax supports the "-" token qualifier. This is not
121981 ** generator. This module does not use actually lemon, it uses a
122424 ** TODO: Strangely, it is not possible to associate a column specifier
122677 ** column to match against for tokens for which a column name is not explicitly
122776 ** If the second argument is not NULL, then its contents are prepended to
122929 ** May you do good and not evil.
122943 ** (in which case SQLITE_CORE is not defined), or
123239 ** The key is not copied in this instance. If a malloc fails, then
123313 ** May you do good and not evil.
123326 ** (in which case SQLITE_CORE is not defined), or
123548 ** is not 'w', 'x', or 'y'.
123569 ** Return TRUE if zFrom matches. Return FALSE if zFrom does not
123576 const char *zTo, /* ... change the ending to this (not reversed) */
123637 ** If the input word contains not digits but does characters not
123662 /* The use of a character not in [a-zA-Z] means that we fallback
123959 ** May you do good and not evil.
123973 ** (in which case SQLITE_CORE is not defined), or
123995 ** to the string <key-name>. If <pointer> is not specified, then
123999 ** Whether or not the <pointer> argument is specified, the value returned
124326 ** This function is used for testing only, it is not included in the
124450 ** May you do good and not evil.
124463 ** (in which case SQLITE_CORE is not defined), or
124684 ** May you do good and not evil.
124798 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
124916 ** If argument apVal is not NULL, then it must point to an array with
125075 ** data from the fts3 table. If this lock is not acquired first, then
125085 ** not what users expect when they get SQLITE_LOCKED_SHAREDCACHE. It can
125089 ** This reasoning does not apply to a content=xxx table.
125371 /* Add the term to each of the prefix indexes that it is not too
125650 ** specific row is identified by the iBlockid parameter. If paBlob is not
125653 ** identified table row is. Whether or not paBlob is NULL, *pnBlob is set
125656 ** If an error occurs, or the table does not contain the specified row,
125868 /* Check that the doclist does not appear to extend past the end of the
125910 ** If arguments ppOffsetList and pnOffsetList are not NULL, then
125914 ** lists, not including the nul-terminator byte. For example:
126189 ** within this entire function, not just this "else{...}" block.
126222 ** 1) EOF is greater than not EOF.
126257 ** 1) EOF (end of doclist in this case) is greater than not EOF.
126451 ** and the static node buffer (p->nNodeSize bytes) is not large
126455 ** this is not expected to be a serious problem.
126494 /* If control flows to here, it was not possible to append zTerm to the
126498 ** Otherwise, the term is not added to the new node, it is left empty for
126552 ** Except, if pTree is a root node, do not write it to the database. Instead,
126846 ** Return SQLITE_OK if successful, or an SQLite error code if not.
126932 ** a position list that may (or may not) feature multiple columns. This
127220 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
127224 ** of segment apSegment[0] is not a match, exit early.
127777 ** table, not for all rows.
127884 ** SQLite value pRowid contains the rowid of a row that may or may not be
127983 /* The new rowid is not NULL (in this case the rowid will be
127989 ** Or, if the conflict mode is not REPLACE, insert the new record into
127998 ** docid=$pNewRowid if $pNewRowid is not an integer value).
128082 ** May you do good and not evil.
128275 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
128278 ** pnToken is not NULL, then it is set to the number of tokens in all
128466 ** the snippet for which the corresponding mCovered bit is not set.
128602 ** This is done as part of extracting the snippet text, not when selecting
128604 ** is no way for fts3BestSnippet() to know whether or not the document
128738 ** required. They are required if (a) this is not the first fragment,
128739 ** or (b) this fragment does not begin at position 0 of its column.
128823 ** not available for deferred tokens.
129018 int nLive = 0; /* Number of iterators in aIter not at EOF */
129070 ** If it is false, then assume that those fields that do not change between
129195 ** cache does not match the format string for this request, discard
129584 ** May you do good and not evil.
129607 ** table. For each node that is not the root node of the r-tree, there is
129709 /* Size of hash table Rtree.aHash. This hash table is not expected to
130017 ** indicating that node has not yet been assigned a node number. It is
130158 ** If there is not enough free space in pNode, return SQLITE_FULL.
130427 ** Return non-zero if the cursor does not currently point to a valid
130513 ** returning. If the cell is not filtered (excluded) by the constraints,
130664 /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
130907 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
131878 ** If node pLeaf is not the root of the r-tree and its pParent pointer is
131899 /* Before setting pChild->pParent, test that we are not creating a
132009 /* If the node is not the tree root and now has less than the minimum
132369 /* If azData[0] is not an SQL NULL value, it is the rowid of a
132534 ** code is returned and the value of *piVal after returning is not defined.
132870 ** May you do good and not evil.
133152 ** pointer. This is not really necessary, but it is tidier than
133372 ** May you do good and not evil.