Lines Matching +defs:op +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
38 ** May you do good and not evil.
62 ** without this option, LFS is enable. But LFS does not exist in the kernel
92 ** May you do good and not evil.
125 ** not have more than a dozen or so columns in any table. And if
137 ** turn the limit off. That is no longer true. It is not possible
150 ** A value of 0 used to mean that the limit was not enforced.
221 ** limit will not be able to rollback the aborted transaction. This could
278 ** A value of 1 means that a trigger program will not be able to itself
321 ** A simple compiler pragma or casting sequence could not be found
325 ** case, but that type is not available on all compilers, or
363 ** It determines whether or not the features related to
364 ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
398 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
414 ** not doing a threadsafe build. Ticket #2681.
474 ** to setup for a later assert() statement. We do not want this code to
499 ** not be counted as untested code.
534 ** May you do good and not evil.
541 ** or constant definition does not appear in this file, then it is
542 ** not a published API of SQLite, is subject to change without
543 ** notice, and should not be referenced by programs that use SQLite.
547 ** features recently added to SQLite. We do not anticipate changes
585 ** These no-op macros are used in front of interfaces to mark those
587 ** should not use deprecated interfaces - they are support for backwards
601 ** Ensure these symbols were not defined by some previous header file.
662 ** function is provided for use in DLLs since DLL users usually do not have
687 ** the mutexes are omitted. Without the mutexes, it is not safe
706 ** thread safety, not any run-time changes to that setting made by
786 ** [sqlite3_open_v2()], and not previously closed.
788 ** harmless no-op.
795 ** compatibility and is not documented.
811 ** sqlite3_exec() is not NULL, then it is invoked for each result row
821 ** is not NULL then any error message is written into memory obtained
826 ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
847 ** is not changed.
854 ** <li> The application must not close [database connection] specified by
856 ** <li> The application must not modify the SQL statement text passed into
893 #define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */
903 #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
907 #define SQLITE_NOTADB 26 /* File opened that is not a database file */
919 ** these result codes are too coarse-grained. They do not provide as
1033 ** information need not be flushed. If the lower four bits of the flag
1077 ** and not its inode needs to be synced.
1095 ** [sqlite3_file_control()] interface. The second "op" argument is an
1157 int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1206 ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1263 ** that does not care about crash recovery or rollback might make
1264 ** the open of a journal file a no-op. Writes to this journal would
1287 ** It is <i>not</i> used to indicate the file should be opened
1292 ** argument to xOpen. The xOpen method does not have to
1309 ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
1314 ** are not strictly a part of the filesystem, but they are
1374 ** SQLite normally do not need to invoke either of these routines.
1389 ** is not. The sqlite3_shutdown() interface must only be called from a
1404 ** SQLite interfaces so that an application usually does not need to
1407 ** initialized when [sqlite3_open()] is called if it has not be initialized
1453 ** applications and so this routine is usually not necessary. It is
1456 ** The sqlite3_config() interface is not threadsafe. The application
1500 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
1532 ** xRealloc must be a no-op - it must not perform any allocation or
1559 ** the xInit method, so the xInit method need not be threadsafe. The
1561 ** not need to be threadsafe either. For all other methods, SQLite
1605 ** it is not possible to change the [threading mode] from its default
1620 ** it is not possible to set the Multi-thread [threading mode] and
1636 ** it is not possible to set the Serialized [threading mode] and
1692 ** This configuration should not be used if an application-define page
1720 ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
1817 ** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
1841 ** names are not also used by explicitly declared columns. ^If
1855 ** ^An [INSERT] that fails due to a constraint violation is not a
1856 ** successful [INSERT] and does not change the value returned by this
1860 ** encounters a constraint violation, it does not fail. The
1875 ** unpredictable and might not equal either the old or the new
1888 ** triggers or [foreign key actions] are not counted.)^ Use the
1893 ** are not counted. Only real table changes are counted.
1899 ** mechanisms do not count as direct row changes.)^
1910 ** not create a new trigger context.
1922 ** However, the number returned does not include changes
1930 ** is unpredictable and not meaningful.
1942 ** the count does not include changes used to implement [REPLACE] constraints,
1944 ** count does not include rows of views that fire an [INSTEAD OF trigger],
1956 ** returned is unpredictable and not meaningful.
1971 ** is not safe to call this routine with a [database connection] that
1975 ** sqlite3_interrupt() is called, then it might not have an opportunity
1989 ** not effected by the sqlite3_interrupt().
1991 ** SQL statements is a no-op and has no effect on SQL statements
2007 ** complete if it ends with a semicolon token and is not a prefix of a
2009 ** string literals or quoted identifier names or comments are not
2011 ** embedded) and thus do not count as a statement terminator. ^Whitespace
2017 ** ^These routines do not parse the SQL statements thus
2018 ** will not detect syntactically incorrect SQL.
2020 ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
2024 ** regardless of whether or not the input SQL is complete.)^
2044 ** is not NULL, then the callback might be invoked with two arguments.
2055 ** The presence of a busy handler does not guarantee that it will be invoked
2074 ** changes will not fit into the in-memory cache. SQLite will
2092 ** The busy callback should not take any actions which modify the
2096 ** A busy handler must not close the database connection
2129 ** these numbers are not part of the result table itself. These
2141 ** It is not safe to pass a result table directly to [sqlite3_free()].
2179 ** function must not try to call [sqlite3_free()] directly. Only
2183 ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
2186 ** wrapper layer outside of the internal [sqlite3_exec()] call are not
2301 ** does not include operating-system specific VFS implementation. The
2314 ** a no-op if is called with a NULL pointer. Passing a NULL pointer
2320 ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
2337 ** is not freed.
2358 ** not yet been released.
2360 ** The application must not read or write any part of
2376 ** of memory currently outstanding (malloced but not freed).
2382 ** but not overhead added by the any underlying system library
2459 ** do not try to access data they are not allowed to see, or that they do not
2463 ** not want the user to be able to make arbitrary changes to the
2478 ** The authorizer callback must not do anything that will modify
2489 ** [sqlite3_prepare()] or its variants. Authorization is not
2505 ** to signal SQLite whether or not the action is permitted. See the
2603 ** The progress handler must not do anything that will modify
2631 ** Whether or not an error occurs when it is opened, resources
2645 ** <dd>The database is opened in read-only mode. If the database does not
2655 ** it does not already exist. This is the behavior that is always used for
2659 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
2667 ** mode has not been set at compile-time or start-time. ^If the
2672 ** eligible to use [shared cache mode], regardless of whether or not shared
2674 ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
2695 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
2730 ** The application does not need to worry about freeing the result.
2746 ** error code and message may or may not be set.
2885 ** [sqlite3_open16()]. The database connection must not have been closed.
2902 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
2913 ** ppStmt may not be NULL.
2933 ** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the
3007 ** whether or not it requires a protected sqlite3_value.
3009 ** The terms "protected" and "unprotected" refer to whether or not
3020 ** sqlite3_value objects even when not strictly required.
3087 ** number of <u>bytes</u> in the value, not the number of characters.)^
3095 ** information is in static, unmanaged space and does not need to be freed.
3115 ** ^Bindings are not cleared by the [sqlite3_reset()] routine.
3169 ** ^The first host parameter has an index of 1, not 0.
3202 ** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
3213 ** statement that does not return data (for example an [UPDATE]).
3267 ** subquery and is not a column value, then all of these functions return
3299 ** returned result set of that [SELECT] is a table column (not an
3317 ** is declared to contain a particular type does not mean that the
3319 ** strongly typed, but the typing is dynamic not static. ^Type
3320 ** is associated with individual values, not with the containers
3349 ** statement. If the statement is not a [COMMIT] and occurs within a
3354 ** successfully. sqlite3_step() should not be called again on this virtual
3364 ** violation) has occurred. sqlite3_step() should not be called again on
3419 ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
3448 ** If the SQL statement does not currently point to a valid row, or if the
3477 ** ^The value returned does not include the zero terminator at the end
3479 ** bytes in the string, not the number of characters.
3488 ** ^The zero terminator is not included in this count.
3528 ** and atof(). SQLite does not really use these functions. It has its
3552 ** not invalidate a prior pointer, though of course the content of the buffer
3555 ** are not possible and in those cases prior pointers are invalidated.
3569 ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
3571 ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
3577 ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned
3602 ** ^If the statement was executed successfully or not executed at all, then
3607 ** [prepared statement]. ^If the virtual machine has not
3637 ** ^The [sqlite3_reset(S)] interface does not change the values
3662 ** the zero-terminator. Note that the name length limit is in bytes, not
3683 ** If there is only a single implementation which does not care what text
3718 ** SQLite interfaces. However, such calls must not
3764 ** using these functions, we are not going to tell you what they do.
3858 ** the same aggregate function instance will not resize the memory
3911 ** does not need to be recompiled on each invocation.
3924 ** not been destroyed.
3925 ** ^If it is not NULL, SQLite will invoke the destructor
3951 ** and will never change. It does not need to be destroyed. ^The
4000 ** bytes (not characters) from the 2nd parameter as the error message.
4037 ** is non-negative, then as many bytes (not characters) of the text
4046 ** assumes that the text or BLOB result is in constant space and does not
4195 ** The code to implement this API is not available in the public release
4204 ** Change the key on an open database. If the current database is not
4208 ** The code to implement this API is not available in the public release
4222 ** ^If the operating system does not support sleep requests with
4242 ** It is not safe to read or modify this variable in more than one
4243 ** thread at a time. It is not safe to read or modify this variable
4268 ** zero if the given database connection is or is not in autocommit mode,
4309 ** connection and in particular must not be a NULL pointer.
4333 ** The callback implementation must not do anything that will modify
4352 ** ^The rollback callback is not invoked if a transaction is
4354 ** ^The rollback callback is not invoked if a transaction is
4383 ** ^(The update hook is not invoked when internal system tables are
4387 ** is not invoked when duplication rows are deleted because of an
4393 ** The update hook implementation must not do anything that will modify
4536 ** not null: 0
4574 ** ^If an error occurs and pzErrMsg is not 0, then the
4590 char **pzErrMsg /* Put error message here if not 0 */
4596 ** ^So as not to open security holes in older applications that are
4645 ** If this is a problem for you, do not use the interface at this time.
4673 ** of this structure must not change while it is registered with
4722 ** stored in aConstraint[].op.)^ ^(The index of the column is stored in
4741 ** virtual table and is not checked again by SQLite.)^
4762 unsigned char op; /* Constraint operator */
4774 unsigned char omit; /* Do not code a test for this constraint */
4808 ** invoke the destructor function (if it is not NULL) when SQLite
4900 ** the new function is not good for anything by itself. Its only
4910 ** If this is a problem for you, do not use the interface at this time.
4945 ** ^It is not possible to open a column that is part of an index or primary
4947 ** not possible to open a column that is part of a [child key] for writing.
4949 ** ^Note that the database name is not the filename that contains
4971 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
4976 ** the opened blob. ^The size of a blob may not be changed by this
5018 ** by a failed call to [sqlite3_blob_open()]) is a harmless no-op.
5031 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5057 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5072 ** ^If the [BLOB handle] passed as the first argument was not opened for
5077 ** not possible to increase the size of a BLOB using this API.
5086 ** before the [BLOB handle] expired are not rolled back by the
5095 ** by a prior successful call to [sqlite3_blob_open()] and which has not
5172 ** that means that a mutex could not be allocated. ^SQLite
5190 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
5191 ** The mutex implementation does not need to make a distinction
5193 ** not want to. ^SQLite will only request a recursive mutex in
5215 ** dynamic mutex that it allocates. The dynamic mutexes must not be in
5233 ** ^(Some systems (for example, Windows 95) do not support the operation
5240 ** is undefined if the mutex is not currently entered by the
5241 ** calling thread or is not currently allocated. SQLite will
5266 ** does not provide a suitable implementation. In this case, the user
5302 ** by this structure are not required to handle this case, the results
5312 ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
5313 ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
5345 ** defined and if NDEBUG is not defined.
5348 ** is held or not held, respectively, by the calling thread.
5350 ** ^The implementation is not required to provided versions of these
5351 ** routines that actually work. If the implementation does not provide working
5353 ** return true so that one does not get spurious assertion failures.
5357 ** clearly the mutex cannot be held if it does not exist. But the
5358 ** the reason the mutex does not exist is because the build is not
5359 ** using mutexes. And we do not want the assert() containing the
5416 ** ^If the second parameter (zDbName) does not match the name of any
5418 ** code is not remembered and will not be recalled by [sqlite3_errcode()]
5426 SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
5436 ** This interface is not for use by applications. It exists solely
5438 ** on how the SQLite library is compiled, this interface might not exist.
5442 ** Unlike most of the SQLite API, this function is not guaranteed to
5445 SQLITE_API int sqlite3_test_control(int op, ...);
5455 ** Applications should not use any of these parameters or the
5485 ** *pHighwater is written. ^(Some parameters do not record the highest
5488 ** ^(Other parameters record only the highwater mark and not the current
5494 ** This routine is threadsafe but is not atomic. This routine can be
5503 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
5520 ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
5535 ** value returned is in pages, not in bytes.</dd>)^
5539 ** allocation which could not be statisfied by the [SQLITE_CONFIG_PAGECACHE]
5555 ** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not
5562 ** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH]
5611 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
5659 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
5732 ** the xInit method, so the xInit method need not be threadsafe. ^The
5734 ** not need to be threadsafe either. All other methods must be threadsafe
5742 ** though this is not guaranteed. ^The
5744 ** be allocated by the cache. ^szPage will not be a power of two. ^szPage
5754 ** does not have to do anything special based with the value of bPurgeable;
5764 ** parameter, the implementation is not required to do anything with this
5778 ** intact. ^(If the requested page is not already in the cache, then the
5783 ** <tr><th> createFlag <th> Behaviour when page is not already in cache
5784 ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
5806 ** ^(The cache is not required to perform any reference counting. A single
5813 ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
5825 ** handle invalid, and will not use it with any other sqlite3_pcache_methods
5868 ** read-locked while it is actually being read; it is not locked
5950 ** on the destination file. ^The exclusive lock is not released until either
5955 ** ^Because the source database is not locked between calls to
5972 ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
5975 ** and may not be used following a call to sqlite3_backup_finish().
5978 ** sqlite3_backup_step() errors occurred, regardless or whether or not
5985 ** is not a permanent error and does not affect the return value of
5998 ** operation, then the values are not updated to account for any extra
6011 ** [database connection] is not passed to any other API (by any thread) after
6013 ** sqlite3_backup_finish(). SQLite does not currently check to see
6021 ** is not accessed while the backup is running. In practice this means
6023 ** backed up to is not accessed by any connection within the process,
6024 ** not just the specific connection that was passed to sqlite3_backup_init().
6029 ** APIs are not strictly speaking threadsafe. If they are invoked at the
6093 ** The unlock-notify callback is not reentrant. If an application invokes
6201 ** May you do good and not evil.
6218 ** code should not attempt to access or modify the fields of this structure
6494 ** distinct when determining whether or not two entries are the same
6522 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
6530 ** GCC does not define the offsetof() macro so we'll have to do it
6539 ** not, there are still machines out there that use EBCDIC.)
6711 ** not support Writable Static Data (WSD) such as global and static variables.
6740 ** implementation of an SQL aggregate step callback may not use the
6744 ** When a function parameter is not used at all within the body of a function,
6747 ** parameters that may or may not be used depending on compilation options.
6812 ** May you do good and not evil.
6837 #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
6875 #define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */
6880 #define BTREE_CREATE 32 /* Create the database if it does not exist */
7006 ** If we are not using shared cache, then there is no need to
7058 ** May you do good and not evil.
7153 #define P4_NOTUSED 0 /* The P4 parameter is not used */
7175 ** function should *not* try to free the KeyInfo.
7213 /* Automatically generated. Do not edit */
7473 ** May you do good and not evil.
7497 ** is called page 1. 0 is used to represent "not a page".
7526 #define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */
7599 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
7643 ** May you do good and not evil.
7674 ** and should not be accessed by other modules.
7689 #define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */
7804 ** May you do good and not evil.
7900 /* If the SET_FULLSYNC macro is not defined above, then make it
7901 ** a no-op
7932 ** enough to know that calling the developer will not help get rid
7951 ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
7966 ** those functions are not available. So we use only LockFile() and
7969 ** LockFile() prevents not just writing but also reading by other processes.
8011 ** file format. Depending on how it is changed, you might not notice
8080 ** May you do good and not evil.
8091 ** NOTE: source files should *not* #include this header file directly.
8132 ** If this is a no-op implementation, implement everything as macros.
8160 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
8239 ** lookaside allocations are not used to construct the schema objects.
8269 ** insert statement. Inserts on views do not affect its value. Each
8275 ** The sqlite.nChange does not count changes within triggers and keeps no
8281 ** within a trigger is not seen outside the trigger. Changes to views do not
8376 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
8415 #define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */
8585 ** collating sequence may not be read or written.
8654 ** implementation. sqlite3_vtab* handles can not be shared between
8673 ** schema is being reloaded for some reason), the VTable objects are not
8674 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
8701 ** CREATE TABLE statement is stored, but case is not significant for
8721 ** refers VDBE cursor number that holds the table open, not to the root
8729 int iPKey; /* If not negative, use aCol[iPKey] as the primary key */
8769 ** Test to see whether or not a table is a virtual table. This is
8797 ** which is attached to the from-table. The to-table need not exist when
8798 ** the from-table is created. The existence of the to-table is not checked.
8823 ** but the transaction is not rolled back. FAIL processing means that
8825 ** changes due to the same operation are not backed out and no rollback
8827 ** error is not inserted or updated. Processing continues and no error
8846 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
8921 ** The Index.onError field determines whether or not the indexed columns
8922 ** must be unique and what to do if they are not. When Index.onError=OE_None,
8923 ** it means this is not a unique index. Otherwise it is a unique index
8963 ** may contain random values. Do not make any assumptions about Token.dyn
8975 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
8982 ** fields do not need to be freed when deallocating the AggInfo structure.
9035 ** Expr.op is the opcode. The integer parser token codes are reused
9058 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
9092 ** allocated, regardless of whether or not EP_Reduced is set.
9095 u8 op; /* Operation performed by this node */
9096 char affinity; /* The affinity of the column or 0 if not a column */
9129 u8 op2; /* If a TK_REGISTER, the original value of Expr.op */
9145 #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */
9155 #define EP_Static 0x4000 /* Held in memory not obtained from malloc() */
9167 ** so as not to burden production code.
9205 ** field is not used.
9347 ** is intended to be private the the where.c module and should not be
9367 u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */
9379 /* The following field is really not part of the current level. But
9392 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
9399 #define WHERE_FORCE_TABLE 0x0040 /* Do not use an index-only search */
9464 ** limit and nOffset to the value of the offset (or 0 if there is not
9472 ** as the OP_OpenEphm instruction is coded because not
9480 u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
9491 Expr *pLimit; /* LIMIT expression. NULL means not used. */
9492 Expr *pOffset; /* OFFSET expression. NULL means not used. */
9515 #define SRT_Exists 3 /* Store 1 if the result is not empty */
9516 #define SRT_Discard 4 /* Do not save the results anywhere */
9546 ** information in case inserts are down within triggers. Triggers do not
9734 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
9764 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
9766 * value of "op" as follows:
9768 * (op == TK_INSERT)
9779 * (op == TK_DELETE)
9784 * (op == TK_UPDATE)
9794 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
9821 ** do not necessarily know how big the string will be in the end.
10489 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
10491 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
10525 ** is not defined.
10603 ** May you do good and not evil.
10615 ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
10681 ** non-ASCII UTF character. Hence the test for whether or not a character is
10808 ** May you do good and not evil.
10845 SQLITE_PRIVATE int sqlite3StatusValue(int op){
10847 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
10848 return wsdStat.nowValue[op];
10855 SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
10857 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
10858 wsdStat.nowValue[op] += N;
10859 if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
10860 wsdStat.mxValue[op] = wsdStat.nowValue[op];
10867 SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
10869 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
10870 wsdStat.nowValue[op] = X;
10871 if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
10872 wsdStat.mxValue[op] = wsdStat.nowValue[op];
10880 ** 32-bit integer is an atomic operation. If that assumption is not true,
10881 ** then this routine is not threadsafe.
10883 SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
10885 if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
10888 *pCurrent = wsdStat.nowValue[op];
10889 *pHighwater = wsdStat.mxValue[op];
10891 wsdStat.mxValue[op] = wsdStat.nowValue[op];
10901 int op, /* Status verb */
10906 switch( op ){
10930 ** May you do good and not evil.
10981 ** If the user has not indicated to use localtime_r() or localtime_s()
11076 ** A missing specifier is not considered an error.
11198 ** on success and 1 if the input string is not a well-formed
11494 ** date is already on the appropriate weekday, this is a no-op.
12036 ** May you do good and not evil.
12049 ** The default SQLite sqlite3_vfs implementations do not allocate
12119 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
12120 return id->pMethods->xFileControl(id, op, pArg);
12274 /* No-op */
12335 ** May you do good and not evil.
12348 ** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily
12350 ** is completely recoverable simply by not carrying out the resize. The
12424 ** May you do good and not evil.
12430 ** This file contains a no-op memory allocation drivers for use when
12432 ** here always fail. SQLite will not operate with these drivers. These
12445 ** No-op versions of all memory allocation routines
12485 ** May you do good and not evil.
12630 ** May you do good and not evil.
12731 int disallow; /* Do not allow memory allocation */
13099 ** May you do good and not evil.
13121 ** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
13142 ** a header that is not returned to the user.
13154 ** not be read or written.
13217 ** of the current master. iMaster is 0 if there is not master chunk.
13218 ** The master chunk is not in either the aiHash[] or aiSmall[].
13309 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
13359 ** is not large enough, return 0.
13401 ** linked into the hash tables. That is not the normal state of
13705 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
13762 ** is not required to be threadsafe (it is not).
13788 ** May you do good and not evil.
13856 ** it is not actually possible to reach this limit.
13864 #define CTRL_FREE 0x20 /* True if not checked out */
13966 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
14047 ** block. If not, then split a block of the next larger power of
14228 ** This routine is not threadsafe. The caller must be holding a mutex
14250 assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
14366 ** May you do good and not evil.
14394 /* If the xMutexAlloc method has not been set, then the user did not
14486 ** is not currently entered. If a NULL pointer is passed as an argument
14487 ** this function is a no-op.
14518 ** May you do good and not evil.
14525 ** This implementation in this file does not provide any mutual
14578 ** and debugging purposes. The mutexes still do not provide any
14610 ** that means that a mutex could not be allocated.
14669 ** is undefined if the mutex is not currently entered or
14670 ** is not currently allocated. SQLite will never do either.
14704 ** May you do good and not evil.
14745 ** that means that a mutex could not be allocated.
14759 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
14760 ** The mutex implementation does not need to make a distinction
14762 ** not want to. But SQLite will only request a recursive mutex in
14934 ** is undefined if the mutex is not currently entered or
14935 ** is not currently allocated. SQLite will never do either.
14977 ** May you do good and not evil.
15020 ** not an atomic operation, then these routines might delivery
15023 ** told that HPUX is not such a platform. If so, then these routines
15024 ** will not always work correctly on HPUX.
15026 ** On those platforms where pthread_equal() is not atomic, SQLite
15049 ** that means that a mutex could not be allocated. SQLite
15066 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
15067 ** The mutex implementation does not need to make a distinction
15069 ** not want to. But SQLite will only request a recursive mutex in
15103 /* If recursive mutexes are not available, we will have to
15165 /* If recursive mutexes are not available, then we have to grow
15169 ** that are not equal to self while the comparison is taking place.
15173 ** are not met, then the mutexes will fail and problems will result.
15205 /* If recursive mutexes are not available, then we have to grow
15209 ** that are not equal to self while the comparison is taking place.
15213 ** are not met, then the mutexes will fail and problems will result.
15252 ** is undefined if the mutex is not currently entered or
15253 ** is not currently allocated. SQLite will never do either.
15306 ** May you do good and not evil.
15338 ** WinNT/2K/XP so that we will know whether or not we can safely call
15385 ** processing, the "interlocked" magic is probably not
15425 ** that means that a mutex could not be allocated. SQLite
15442 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
15443 ** The mutex implementation does not need to make a distinction
15445 ** not want to. But SQLite will only request a recursive mutex in
15549 ** is undefined if the mutex is not currently entered or
15550 ** is not currently allocated. SQLite will never do either.
15590 ** May you do good and not evil.
15642 ** cache database pages that are not currently in use.
15888 ** This routine is similar to alloca() in that it is not intended
15891 ** structures that would not normally fit on the stack of an
16275 ** If the first argument, db, is not NULL and a malloc() error has occurred,
16280 /* If the db handle is not NULL, then we must hold the connection handle
16361 /* The rest are extensions, not normally found in printf() */
16885 ** Note that the number is in the usual order, not reversed as with
16891 ** set and we are not left justified */
16974 ** consume, not the length of the output...
17213 ** are not able to use a "," as the decimal point in place of "." as
17236 ** The printf() built into some versions of windows does not understand %lld
17274 ** May you do good and not evil.
17300 ** Why not just use a library random generator like lrand48() for this?
17303 ** well be good enough. But maybe not. Or maybe lrand48() has some
17309 ** (Later): Actually, OP_NewRowid does not depend on a good source of
17332 ** not need to contain a lot of randomness since we are not
17337 ** number generator) not as an encryption device.
17421 ** May you do good and not evil.
17458 ** May you do good and not evil.
17605 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
17635 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
17769 int iStatement; /* Statement number (or 0 if has not opened stmt) */
17771 FILE *trace; /* Write an execution trace here, if not NULL */
17981 ** for unicode values 0x80 and greater. It do not change over-length
18031 ** encoding, or if *pMem does not contain a string value.
18171 ** the encoding of the Mem adjusted. This routine does not do any
18210 ** return the number of unicode characters in pZ up to (but not including)
18211 ** the first 0x00 byte. If nByte is not less than zero, return the
18232 /* This test function is not currently used by the automated test-suite.
18397 ** May you do good and not evil.
18434 ** found that many systems do not have a working isnan() function so
18455 # error SQLite will not work correctly with the -ffast-math option of GCC.
18486 ** If it is not NULL, string zFormat specifies the format of the
18559 ** input does not begin with a quote character, then this routine
18560 ** is a no-op.
18625 ** *realnum unchanged if the string contains any character which is not
18631 ** false does not mean that the number can be successfully converted into
18667 ** is not, the result is undefined.
18827 ** the value of the integer into *pNum. If zNum is not an integer
19302 ** file. In that case we are not in any hurry. Use the (relatively
19391 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
19396 ** open and is not being used by another thread. By changing the value
19403 ** condition so it is possible that the error is not detected.
19408 ** Ticket #202: If db->magic is not a valid open value, take care not
19412 ** not want to write into deallocated memory.
19430 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
19448 ** Check to make sure we have a valid db pointer. This test is not
19452 ** 1 it means that the db pointer is valid and 0 if it should not be
19458 ** open properly and is not fit for general use but which can be
19492 ** May you do good and not evil.
19584 ** Return TRUE if the resize occurs and false if not.
19598 ** a performance hit but it is not a fatal error. So mark the
19625 int nKey, /* Bytes in key (not counting zero terminator) */
19710 ** The key is not copied in this instance. If a malloc fails, then
19764 /* Automatically generated. Do not edit */
19927 ** May you do good and not evil.
19945 ** malloc failures happen frequently. OS/2 does not typically run on
19947 ** problems to worry about than running out of memory. So there is not
19950 ** But there is a good reason to not use the wrappers. If we use the
19954 ** the OS driver, but the code to deal with those failure would not
19955 ** be exercised on Linux (which does not need to malloc() in the driver)
19962 ** desktops but not so well in embedded systems.
19966 ** Macros used to determine whether or not to use threads.
19983 ** May you do good and not evil.
19993 ** This file should be #included by the os_*.c files only. It is not a
20001 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
20047 ** May you do good and not evil.
20204 char* pathToDel; /* Name of file to delete on close, NULL if not */
20336 ** no-op
20423 ** It is not possible to lower the locking level one step at a time. You
20467 /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
20602 ** the requested locking level, this routine is a no-op.
20604 ** It is not possible for this routine to fail if the second argument
20663 static int os2FileControl(sqlite3_file *id, int op, void *pArg){
20664 switch( op ){
20832 * Trailing spaces are not allowed, either. */
21071 ** A no-op since the error code is returned on the DosLoadModule call.
21072 ** os2Dlopen returns zero if DosLoadModule is not successful.
21075 /* no-op */
21082 /* if the symbol itself was not found, search again for the same
21169 ** might be greater than or equal to the argument, but not less
21273 ** May you do good and not evil.
21299 ** + for no-op locks
21304 ** * sqlite3_file methods not associated with locking.
21360 ** without this option, LFS is enable. But LFS does not exist in the kernel
21427 ** Only set the lastErrno if the error code is a real error and not
21473 /* The next group of variables are used to track whether or not the
21508 ** May you do good and not evil.
21518 ** This file should be #included by the os_*.c files only. It is not a
21526 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
21572 ** May you do good and not evil.
21741 ** that always succeeds. This means that locking does not occur under
21813 static int lockTrace(int fd, int op, struct flock *p){
21817 if( op==F_GETLK ){
21819 }else if( op==F_SETLK ){
21822 s = fcntl(fd, op, p);
21823 sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
21836 s = fcntl(fd, op, p);
21841 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
21890 /* EACCES is like EAGAIN during locking operations, but not any other time*/
21936 ** the device number and the inode number. But this does not work on VxWorks.
21945 ** There are never very many files open at one time and lookups are not
22076 ** by the same process. It does not explicitly say so, but this implies
22088 ** But not so. Since both locks came from the same process, the
22094 ** to synchronize access for threads in separate processes, but not
22106 ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
22140 ** Yet another problem: LinuxThreads do not play well with posix locks.
22143 ** not posix compliant. Under LinuxThreads, a lock created by thread
22150 ** compile-time whether or not thread A can override locks on thread B.
22167 ** not allow locks to be overridden by other threads and that restriction
22214 pthread_t tid; /* Thread ID of lock owner. Zero if not using LinuxThreads */
22263 ** never exceeds a few thousand. And lookup is not on a critical
22270 ** This variable remembers whether or not threads can override each others
22315 ** The write-lock is not actually acquired, as this is not possible if
22328 ** This procedure attempts to determine whether or not threads
22414 /* If pOpen->pUnused is not null, then memory and file-descriptors
22467 ** around this problem (we consider it a bug in OS X, not SQLite)
22570 /* Ownership transfers not needed on this system */
22597 #else /* if not SQLITE_THREADSAFE */
22598 /* On single-threaded builds, ownership transfer is a no-op */
22652 ** The "op" parameter should be one of F_RDLCK, F_WRLCK, or F_UNLCK.
22659 ** bytes from 0 up to but not including PENDING_BYTE, and all bytes
22676 static int rangeLock(unixFile *pFile, int op, int *pErrcode){
22679 lock.l_type = op;
22690 if( NEVER(op==F_UNLCK) || rc!=(-1) ){
22694 if( ALWAYS(op!=F_UNLCK) && rc==(-1) ){
22754 ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
22765 ** range' is that some versions of windows do not support read-locks. By
22933 ** write operation (not a hot journal rollback).
22968 ** not deleted and SQLITE_IOERR_CLOSE returned.
23009 ** the requested locking level, this routine is a no-op.
23044 ** file changed. If the transaction counter is not updated,
23045 ** other connections to the same file might not realize that
23046 ** the file has changed and hence might not know to flush their
23135 ** It is *not* necessary to hold the mutex when this routine is called,
23185 /* If there are outstanding locks, do not actually close the file just
23204 ****************************** No-op Locking **********************************
23241 /******************* End of the no-op lock implementation *********************
23278 ** In dotfile locking, either a lock exists or it does not. So in this
23382 ** the requested locking level, this routine is a no-op.
23395 /* no-op if possible */
23588 ** the requested locking level, this routine is a no-op.
23598 /* no-op if possible */
23763 ** the requested locking level, this routine is a no-op.
23775 /* no-op if possible */
24114 ** the requested locking level, this routine is a no-op.
24181 /* If there are outstanding locks, do not actually close the file just
24199 ** to MacOSX and does not work on other unix platforms. No alternative
24201 ** VFS is not available.
24223 ** one system to another. Since SQLite does not define USE_PREAD
24224 ** any any form by default, we will not attempt to define _XOPEN_SOURCE.
24276 /* If this is a database file (not a journal, master-journal or temp
24290 pFile->lastErrno = 0; /* not a system error */
24349 /* If this is a database file (not a journal, master-journal or temp
24390 pFile->lastErrno = 0; /* not a system error */
24407 ** We do not trust systems to provide a working fdatasync(). Some do.
24417 ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
24429 ** The fsync() system call does not work as advertised on many
24435 ** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
24441 ** to disk, not the inode. We only set dataOnly if the file size is
24445 ** and fsync(), Ted tells us, is that fdatasync() will not flush the
24447 ** We only care about the file size, not the other file attributes, so
24480 ** no-op
24524 ** If we do not do this and we encounter a power failure, the directory
24525 ** entry for the journal might not exist after we reboot. The next
24526 ** SQLite to access the file will not know that the journal exists (because
24528 ** will not roll back - possibly leading to database corruption.
24543 ** line is to test that doing so does not cause any problems.
24568 ** A failed directory sync is not a big deal. So it seems
24654 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
24655 switch( op ){
24678 return proxyFileControl(id,op,pArg);
24909 ** that does not need to be locked. */
24959 ** that does not need to be locked. */
25062 ** If scenario (a) caused the error then things are not so safe. The
25083 ** according to requirement F11141. So we do not need to make a
25226 ** name. If it is not, return SQLITE_ERROR.
25255 ** file (not a journal or master-journal file) identified by pathname
25260 ** but the associated file descriptor could not be closed because some
25272 /* Do not search for an unused file descriptor on vxworks. Not because
25273 ** vxworks would not benefit from the change (it might, we're not sure),
25275 ** not to risk breaking vxworks support for the sake of such an obscure
25287 ** not searching for a resusable file descriptor are not dire. */
25418 ** open(). These must be calculated even if open() is not called, as
25470 /* It is safe to close fd at this point, because it is guaranteed not
25472 ** it would not be safe to close as this would release any locks held
25503 ** not while other file descriptors opened by the same process on
25678 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
25691 ** other hand, dlsym() will not work on such a system either, so we have
25692 ** not really lost anything.
25757 ** might be greater than or equal to the argument, but not less
25875 ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
25911 ** Once a lock proxy is configured for a database connection, it can not
25913 ** the above APIs (assuming the conch file is not being held by another
25934 ** If the conch file does not exist, or it's contents do not match the
25951 ** Requesting the lock proxy does not immediately take the conch, it is
25954 ** opening a connection to a database file does not take a lock on it.
25988 ** lock proxy files, only used when LOCKPROXYDIR is not set.
25996 ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
26089 ** user-specific tmp directory, create the ID if it's not there already
26198 ** The caller is responsible not only for closing the file descriptor
26215 ** necessary as other file types do not necessarily support locking. It
26218 ** make sure a call to close() does not cause the system to discard
26592 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
26593 switch( op ){
26602 *(const char **)pArg = ":auto: (not held)";
26615 /* turn off proxy locking - not supported */
26715 ** the requested locking level, this routine is a no-op.
26790 ** single thread. The memory allocation and mutex subsystems have not
26792 ** should not be used.
26879 ** to release dynamically allocated objects. But not on unix.
26880 ** This routine is a no-op for unix.
26896 ** May you do good and not evil.
26913 ** malloc failures happen frequently. Win32 does not typically run on
26915 ** problems to worry about than running out of memory. So there is not
26918 ** But there is a good reason to not use the wrappers. If we use the
26922 ** the OS driver, but the code to deal with those failure would not
26923 ** be exercised on Linux (which does not need to malloc() in the driver)
26930 ** desktops but not so well in embedded systems.
26940 ** Macros used to determine whether or not to use threads.
26957 ** May you do good and not evil.
26967 ** This file should be #included by the os_*.c files only. It is not a
26975 ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
27021 ** May you do good and not evil.
27254 ** WinNT/2K/XP so that we will know whether or not we can safely call
27405 ** WindowsCE does not have a localtime() function. So create a
27512 /* If shared memory could not be created, then close the mutex and fail */
27727 ** for being unreasonable so I do not doubt that it might happen. If
27905 ** no-op
27950 ** Different API routines are called depending on whether or not this
28021 ** It is not possible to lower the locking level one step at a time. You
28064 OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);
28172 ** the requested locking level, this routine is a no-op.
28174 ** It is not possible for this routine to fail if the second argument
28211 static int winFileControl(sqlite3_file *id, int op, void *pArg){
28212 switch( op ){
28320 ** Since the ASCII version of these Windows API do not exist for WINCE,
28321 ** it's important to not reference them for WINCE builds.
28381 ** Since the ASCII version of these Windows API do not exist for WINCE,
28382 ** it's important to not reference them for WINCE builds.
28467 /* Creates a new file, only if it does not already exist. */
28505 ** Since the ASCII version of these Windows API do not exist for WINCE,
28506 ** it's important to not reference them for WINCE builds.
28564 ** Note that windows does not allow a file to be deleted if some other
28597 ** Since the ASCII version of these Windows API do not exist for WINCE,
28598 ** it's important to not reference them for WINCE builds.
28635 ** Since the ASCII version of these Windows API do not exist for WINCE,
28636 ** it's important to not reference them for WINCE builds.
28704 ** Since the ASCII version of these Windows API do not exist for WINCE,
28705 ** it's important to not reference them for WINCE builds.
28741 /* GetDiskFreeSpace is not supported under WINCE */
28819 ** Since the ASCII version of these Windows API do not exist for WINCE,
28820 ** it's important to not reference them for WINCE builds.
28977 ** then it is not necessary to include the nul-terminator character
29041 ** May you do good and not evil.
29099 ** no fewer collisions than the no-op *1. */
29159 ** If p is NULL (if the bitmap has not been created) or if
29229 /* in hash, if not, try to find a spot for it */
29352 ** 5 N S X Set N bits from S increment X in array only, not in bitvec
29356 ** Opcode 5 works on the linear array only, not on the Bitvec.
29370 int i, nx, pc, op;
29387 while( (op = aOp[pc])!=0 ){
29388 switch( op ){
29408 if( (op & 1)!=0 ){
29410 if( op!=5 ){
29451 ** May you do good and not evil.
29493 ** is not, either fail an assert or return zero. Otherwise, return
29569 ** being used for an in-memory database, this function is a no-op.
29645 int createFlag, /* If true, create page if it does not exist already */
29655 /* If the pluggable cache (sqlite3_pcache*) has not been allocated,
29679 ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
29680 ** cleared), but if that is not possible settle for any other
29843 ** the page object is not dropped.
29882 ** Do not both fixing the pDirtyPrev pointers.
30027 ** May you do good and not evil.
30114 ** compiling for systems that do not support real WSD.
30322 ** global LRU list, if is part of it. If pPage is not part of the global
30323 ** LRU list, then this function is a no-op.
30433 ** not need to be freed.
30496 ** Whether or not a new page may be allocated by this function depends on
30497 ** the value of the createFlag argument. 0 means do not allocate a new
30512 ** 2. If createFlag==0 and the page is not already in the cache, NULL is
30515 ** 3. If createFlag is 1, and the page is not already in the cache,
30588 /* Step 5. If a usable page buffer has still not been found,
30730 ** install the default pluggable cache module, assuming the user has not
30808 ** May you do good and not evil.
30847 ** value added by the INSERT will not be visible to the second TEST.
30920 ** It must be the case that N is sufficient to make a Rowset. If not
31158 ** Convert the list in p->pEntry into a sorted list if it is not
31180 ** routine may not be called again.
31232 ** May you do good and not evil.
31274 ** PAGER_UNLOCK The page cache is not currently reading or
31280 ** Writing is not permitted. There can be
31285 ** but has not yet made any changes. Only one process
31287 ** database file has not been modified so other
31378 ** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
31388 ** if some pages have been appended to the database image but not yet written
31401 ** not updated more often than necessary.
31429 ** do not need the PGHDR_NEED_SYNC flag set, as they do not need
31469 u8 noReadlock; /* Do not bother to obtain readlocks */
31470 u8 noSync; /* Do not sync the journal if true */
31494 u8 doNotSync; /* Boolean. While true, do not spill the cache */
31543 ** testing purposes only. These variables do not exist in
31544 ** a non-testing build. These variables are not thread-safe.
31637 ** * The bit corresponding to the page-number is not set in
31693 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
31716 ** This function determines whether or not the atomic-write optimization
31782 ** is defined, and NDEBUG is not defined, an assert() statement checks
31891 ** This function is a no-op if the journal file has not been written to
31897 ** if the pager is not in no-sync mode, sync the journal file immediately
31904 ** not need to be synced following this operation.
32024 /* Initializing the tail of the buffer is not necessary. Everything
32041 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
32098 /* Read in the first 8 bytes of the journal header. If they do not match
32138 ** of two greater than or equal to 512 or 32, and not greater than their
32193 ** this call is a no-op.
32243 ** will not be able to find the master-journal name to determine
32244 ** whether or not the journal is hot.
32259 ** a pointer to the page or NULL if the requested page is not
32265 /* It is not possible for a call to PcacheFetch() with createFlag==0 to
32274 ** the pager is in error-state, then this call is a no-op.
32276 ** TODO: Why can we not reset the pager while in error state?
32289 ** if it is open and the pager is not in exclusive mode.
32326 ** Unlock the database file. This function is a no-op if the pager
32415 ** If the pager has already entered the error state, do not attempt
32423 ** If the pager has not already entered the error state, but an IO or
32445 ** routine is called, it is a no-op (returns SQLITE_OK).
32450 ** file has been finalized it is not possible to use it to roll back a
32453 ** depends on whether or not the pager is running in exclusive mode and
32488 ** tries to unlock the database file if not in exclusive mode. If the
32560 ** when the database file is not unlocked? */
32575 ** This is not a real checksum. It is really just the sum of the
32607 ** checksums - the statement journal does not.
32613 ** If pDone is not NULL, then it is a record of pages that have already
32629 ** and the checksum field does not match the record content.
32698 ** not the database file. The page is left marked dirty in this case.
32702 ** not be in the pager cache. Later: if a malloc() or IO error occurs
32703 ** during a Movepage() call, then the page may not be in the cache
32704 ** either. So the condition described in the above paragraph is not
32708 ** and the main file. The page is then marked not dirty.
32714 ** statement we must not write to the original database unless we know
32721 ** in the main journal either because the page is not in cache or else
32725 ** is possible to fail a statement on a database that does not yet exist.
32726 ** Do not attempt to write if database file has never been opened.
32750 /* If this is a rollback of a savepoint and data was not written to
32751 ** the database and the page is not in-memory, there is a potential
32753 ** will be read from the database file, which may or may not be
32792 ** unsynced portion of the main journal file, then it is not safe
32798 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
32827 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
32933 /* We have a match. Do not delete the master journal file. */
32961 ** If the main database file is not open, or an exclusive lock is not
32962 ** held, this function is a no-op. Otherwise, the size of the file is
33016 ** may not have been opened yet, in which case the OsSectorSize()
33061 ** the extra entries had not yet made it safely to disk. In such a case,
33071 ** If the file opened as the journal file is not a well-formed
33077 ** If an I/O or malloc() error occurs, the journal-file is not deleted
33108 ** If a master journal file name is specified, but the file is not
33109 ** present on disk, then the journal is not hot and does not need to be
33138 ** not enough bytes left in the journal file for a complete header, or
33162 ** that this part of the journal was being filled but has not yet been
33234 ** mode, then subsequent transactions performed by the connection will not
33272 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
33281 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
33425 ** assurance that the journal will not be corrupted to the
33488 ** lock. It does *not* invoke the busy handler when upgrading from
33524 # define pagerReportSize(X) /* No-op if we do not support a codec */
33532 ** is a no-op. The value returned is the error state error code (i.e.
33542 ** * the database is either not an in-memory database or it is
33552 ** If the page size is not changed, either because one of the enumerated
33553 ** conditions above is not true, the pager was in error state when this
33617 ** errors in places where we do not care about errors.
33731 ** a similar or greater lock is already held, this function is a no-op
33735 ** the busy callback if the lock is currently not available. Repeat
33752 ** must not have been modified at this point.
33757 /* Check that this is either a no-op (because the requested lock is
33788 ** b) if the page content were written at this time, it would not
33792 ** If the condition asserted by this function were not true, and the
33794 ** routine, pagerStress() would not write the current page content to
33797 ** content of the page. However, since this content is not present in either
33799 ** sub-journal rolled back the content could not be restored and the
33817 ** function does not actually modify the database file on disk. It
33854 ** is not -1, then the unsynced portion of an open journal file may
33901 ** If the Pager.needSync flag is not set, then this function is a
33902 ** no-op. Otherwise, the actions required depend on the journal-mode
33908 ** * Otherwise, if the device does not support the SAFE_APPEND property,
33914 ** * If the device does not support the SEQUENTIAL property, then
33987 ** This is not required if the persistent media supports the
33988 ** SAFE_APPEND property. Because in this case it is not possible
34031 ** a no-op.
34039 ** is not yet open, it is created and opened before any data is
34067 ** call is a no-op.
34084 /* If the file is a temp-file has not yet been opened, open it now. It
34085 ** is not possible for rc to be other than SQLITE_OK if this branch
34086 ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
34098 ** make the file smaller (presumably by auto-vacuum code). Do not write
34101 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
34189 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
34203 ** is returned by sqlite3PcacheMakeClean() is not called.
34214 ** on the same disk sector. Syncing the journal is not allowed while
34222 ** Similarly, if the pager has already entered the error state, do not
34245 ** This is because the call to pager_write_pagelist() below will not
34258 ** If (X>Y), then when pagerStress is called page X will not be written
34262 ** was when the transaction started, not as it was when "SAVEPOINT sp"
34266 ** sub-journal file now (if it is not already there), so that it will
34388 ** as it will not be possible to open the journal file or even
34485 /* If a temporary file is requested, it is not opened immediately.
34584 ** * The first byte of the journal file exists and is not 0x00.
34592 ** This routine does not check if there is a master journal filename
34594 ** does not exist, then the journal file is not really hot. In this
34596 ** routine will discover that the journal file is not really hot and
34597 ** will not roll it back.
34602 ** to determine whether or not a hot-journal file exists, the IO error
34652 ** If there is, then we consider this journal to be hot. If not,
34672 ** with it under an EXCLUSIVE lock where we do not need to
34735 ** this function is called, it is a no-op.
34754 ** If the operation described by (2) above is not attempted, and if the
34813 ** important that a RESERVED lock is not obtained on the way to the
34819 ** Because the intermediate RESERVED lock is not requested, any
34854 /* If the journal does not exist, it usually means that some
34858 ** function was called and the journal file does not exist. */
34903 ** There is a vanishingly small chance that a change will not be
34935 /* pager_unlock() is a no-op for exclusive mode and in-memory databases. */
34946 ** the rollback journal, the unlock is not performed and there is
34947 ** nothing to rollback, so this routine is a no-op.
34965 ** choose not to allocate a new page object and may reuse an existing
34975 ** requested page is not already stored in the cache, then no
34979 ** If noContent is true, it means that we do not care about the contents
34994 ** will not be journaled. This saves IO.
35000 ** to find a page in the in-memory cache first. If the page is not already
35011 int noContent /* Do not bother reading content from disk if true */
35077 ** page that does not need to be journaled. Nevertheless, be sure
35119 ** not read the page from disk. Return a pointer to the page,
35120 ** or 0 if the page is not in cache. Also, return 0 if the
35126 ** in the page if the page is not already in cache. This routine
35127 ** returns NULL if the page is not in cache or if a disk I/O error
35158 ** sub-journal file is open too. If the main journal is not open,
35159 ** this function is a no-op.
35185 ** opened to write a rollback log for a transaction. It is not used
35192 ** Whether or not the journal file is opened by this function, the
35208 /* If already in the error state, this function is a no-op. But on
35213 /* TODO: Is it really possible to get here with dbSizeValid==0? If not,
35224 /* Open the journal file if it is not already open. */
35274 ** write-transaction has already been opened, this function is a no-op.
35281 ** If this is not a temporary or in-memory file and, the journal file is
35282 ** opened if it has not been already. For a temporary file, the opening
35292 ** running in exclusive mode) or if the transaction does not require a
35308 ** lock, but not when obtaining the RESERVED lock.
35343 ** sub-system. It doesn't matter if the journal-file is not properly
35344 ** finalized at this point (since it is not a valid journal file anyway).
35363 /* This routine is not called unless a transaction has already been
35368 /* If an error has been previously detected, we should not be
35373 /* Higher-level routines never call this function if database is not
35410 ** the transaction journal if it is not there already.
35419 ** that we do not. */
35480 /* If the statement journal is open and the page is not in it,
35502 ** of this function and be careful not to change any page data unless
35614 ** A call to this routine tells the pager that it is not necessary to
35622 ** that it does not get written to disk.
35664 ** The idea is that if the atomic-write optimization is not
35688 /* If page one was fetched successfully, and this function is not
35689 ** operating in direct-mode, make page 1 writable. When not in
35723 ** Sync the pager file to disk. This is a no-op for in-memory files
35726 ** If successful, or called on a pager for which it is a no-op, this
35758 ** Note that if zMaster==NULL, this does not overwrite a previous value
35762 ** is not synced. The caller must call sqlite3PagerSync() directly to
35768 const char *zMaster, /* If not NULL, the master journal name */
35776 /* If a prior error occurred, this routine should not be called. ROLLBACK
35777 ** is the appropriate response to an error, not COMMIT. Guard against
35786 ** function has already been called, it is mostly a no-op. However, any
35793 ** does this depends on whether or not the atomic-update optimization
35799 ** * This commit is not part of a multi-file transaction, and
35802 ** If the optimization was not enabled at compile time, then the
35805 ** is not applicable to this transaction, call sqlite3JournalCreate()
35878 ** or if zMaster is NULL (no master journal), then this call is a no-op.
35884 ** used, this call will not create the journal file or perform any
35898 /* If the file on disk is not the same size as the database image,
35940 /* This routine should not be called if a prior error has occurred.
35945 /* This function should not be called if the pager is not in at least
35951 /* An optimization. If the database was not actually modified during
35953 ** using persistent journals, then this function is a no-op.
35983 ** 2) It finalizes the journal file, so that it is not used for hot
35988 ** * If the journal file is not yet open when this function is called,
35998 ** or not (1) is succussful, also attempt (2). If successful, return
36013 ** playback operation did not succeed it would not be safe to finalize
36107 ** equal to nSavepoint, then this function is a no-op.
36156 /* Open the sub-journal, if it is not already opened. */
36166 ** The savepoint to release or rollback need not be the most recently
36169 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
36178 ** (Pager.nSavepoint-1), then this function is a no-op.
36182 ** sqlite3PagerRollback() because this function does not terminate
36187 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
36194 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
36197 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
36198 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
36202 int nNew; /* Number of remaining savepoints after this op. */
36208 nNew = iSavepoint + (op==SAVEPOINT_ROLLBACK);
36216 ** not yet been opened. In this case there have been no changes to
36219 if( op==SAVEPOINT_ROLLBACK && isOpen(pPager->jfd) ){
36227 if( nNew==0 && op==SAVEPOINT_RELEASE && isOpen(pPager->sjfd) ){
36253 ** not yet been opened.
36303 ** in cache. If the page previously located at pgno is not already
36304 ** in the rollback journal, it is not put there by by this routine.
36311 ** required that a statement transaction was not active, but this restriction
36318 ** pPg refers to will not be written to again within this transaction.
36339 /* If the page being moved is dirty and has not been saved by the latest
36349 ** If page X were not written to the sub-journal here, it would not
36373 ** can be written to. The caller has already promised not to write to it.
36393 /* Do not discard pages from an in-memory database since we might
36420 ** the journal file twice, but that is not a problem.
36475 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
36504 ** If the parameter is not _QUERY, then the journal_mode is set to the
36511 ** * The journal mode may not be changed while a transaction is active.
36541 ** An attempt to set a limit smaller than -1 is a no-op.
36570 ** May you do good and not evil.
36589 ** May you do good and not evil.
36685 ** not specified in the header.
36748 ** that immediately follows the page header. Cells is not necessarily
36755 ** appears first. A variable-length integer may not be more than 9 bytes long.
36823 ** the header, then your custom library will not be able to read
36825 ** will not be able to read databases created by your custom library.
36867 struct _OvflCell { /* Cells that will not fit on aData[] */
36918 ** The pBt pointer itself may not be changed while there exists cursors
36962 ** may not be modified once it is initially set as long as nRef>0.
37066 sqlite3_int64 cachedRowid; /* Next rowid cache. 0 means not valid */
37091 ** Cursor does not point to a valid entry. This can happen (for example)
37092 ** because the table is empty or because BtreeCursorFirst() has not been
37143 ** to any page that is not part of the pointer map itself.) Each pointer map
37152 ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
37156 ** is not used in this case.
37185 ** if the database supports auto-vacuum or not. Because it is used
37187 ** (sqliteMallocRaw), it is not possible to use conditional compilation.
37258 ** If the object is not sharable, then no mutex is ever required
37259 ** and this routine is a no-op. The underlying mutex is non-recursive.
37301 ** procedure that follows. Just be sure not to block.
37346 ** B-Tree is not marked as sharable.
37365 ** omitted if that module is not used.
37380 ** against all schemas and we do not want those schemas being
37572 ** May you do good and not evil.
37640 ** of each BtShared structure and so this locking is not necessary.
37658 ** table with root page iRoot. Return 1 if it does and 0 if not.
37686 /* If this database is not shareable, or if the client is reading
37697 ** not loaded, then it is too difficult to actually check to see if
37698 ** the correct locks are held. So do not bother - just return true.
37699 ** This case does not come up very often anyhow.
37775 ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
37793 /* This routine is a no-op if the shared-cache is not enabled */
37799 ** requested lock may not be obtained.
37877 /* If the above search did not find a BtLock struct associating Btree p
37910 ** transaction. If it does not, then the BtShared.isPending variable
37943 ** transaction. If there currently exists a writer, and p is not
37948 ** If there is not currently a writer, then BtShared.isPending must
38055 ** a free-list leaf page, the page is not written to the database
38057 ** such a page is not even journalled (as it will not be modified,
38060 ** 2) When a free-list leaf page is reused, its content is not read
38062 ** be, if it is not at all meaningful?).
38067 ** transaction, a problem comes up. If the page is not journalled when
38068 ** it is moved to the free-list and it is also not journalled when it
38070 ** may be lost. In the event of a rollback, it may not be possible
38138 ** all that is required. Otherwise, if pCur is not open on an intKey
38263 ** Determine whether or not a cursor has moved from the position it
38268 ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
38312 ** a no-op. If an error occurs, the appropriate error code is written
38403 ** This routine works only for pages that do not contain overflow cells.
38483 /* If the payload will not fit completely on the local page, we have
38523 ** data header and the local payload, but not any overflow page or
38534 ** this function verifies that this invariant is not violated. */
38770 ** the allocation. If not, defragment.
38822 ** btreeInitPage() did not detect overlapping cells or
38924 ** not contain a well-formed database page, then return
38925 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
39088 ** If the noContent flag is set, it means that we do not care about
39089 ** the content of the page at this time. So do not go to the disk
39099 int noContent /* Do not load page content if true */
39112 ** Retrieve a page from the pager cache. If the requested page is not
39206 /* pPage might not be a btree page; it might be an overflow page
39331 ** even when they are not. This exercises the locking code and
39378 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
39595 ** operate asynchronously - it will not stop to do fsync()s
39602 ** Synchronous is on by default so database corruption is not
39655 ** size supplied does not meet this constraint then the page size is not
39781 ** SQLITE_OK is returned on success. If the file is not a
39889 ** If there are no outstanding cursors and we are not in the middle
39894 ** If there is a transaction in progress, this routine is a no-op.
39956 ** to access the database. A preexisting transaction may not be
39974 ** if there is one. But if there was previously a read-lock, do not
39982 ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
39996 ** is requested, this is a no-op.
40002 /* Write transactions are not possible on a read-only database */
40042 ** file is not pBt->pageSize. In this case lockBtree() will update
40094 ** the sub-journal is not already open, then it will be opened here.
40217 ** can be written to. The caller has already promised not to write to that
40311 ** which may or may not empty the freelist. A full autovacuum
40340 /* Remove the page from the files free-list. This is not required
40419 ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
40465 /* It is not possible to create a database for which the final page
40509 ** causes a rollback journal to be created (if it does not already exist)
40516 ** disk and we are still holding all locks, so the transaction has not
40520 ** This call is a no-op if no write-transaction is currently active on pBt.
40648 ** in assert() expressions, so it is only compiled if NDEBUG is not
40653 ** originally opened for writing and the cursor has not be disabled
40679 ** or moved root pages, so it is not sufficient to
40720 ** the cache may be internally inconsistent (not contain valid trees) so
40795 ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK
40798 ** of op.
40800 ** Normally, iSavepoint is greater than or equal to zero. However, if op is
40806 SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
40810 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
40811 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
40813 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
40838 ** but which are not in the READ_UNCOMMITTED state may not have
40843 ** 3: The database must be writable (not on read-only media)
40848 ** root page of a b-tree. If it is not, then the cursor acquired
40849 ** will not work correctly.
40933 ** do not need to be zeroed and they are large, so we can save a lot
40950 ** or negative rowids are very uncommon so this should not be a problem.
41002 ** BtCursor.info structure. If it is not already valid, call
41012 ** compiler is not doing agressive inlining.) So we use a real function
41037 #else /* if not _MSC_VER */
41062 ** the key for the current entry. If the cursor is not pointing
41066 ** itself, not the number of bytes in the key.
41092 ** Failure is not possible. This function always returns SQLITE_OK.
41116 ** If ppPage is not NULL, and a reference to the MemPage object corresponding
41292 ** has not been allocated, allocate it now. The array is sized at
41295 ** etc. A value of 0 in the aOverflow[] array means "not yet known"
41332 ** data is not required. So first try to lookup the overflow
41426 ** into *pAmt. If *pAmt==0, then the value returned will not be
41517 ** the new child page does not match the flags field of the parent (i.e.
41606 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
41644 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
41646 ** NULL, the caller expects a table b-tree. If this is not the case,
41657 ** if the assumption were not true, and it is not possible for the flags
41767 /* If the cursor already points to the last entry, this is a no-op. */
41804 ** If an exact match is not found, then the cursor is always
41875 ** not run. If this is not the root-page, then the moveToChild() routine
42003 ** Return TRUE if the cursor is not pointing at an entry of the table.
42156 ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
42158 ** If the "nearby" parameter is not 0, then a (feeble) effort is made to
42163 ** If the "exact" parameter is not 0, and the page-number nearby exists
42221 ** is not true. Otherwise, it runs once for each trunk-page on the
42244 /* The trunk has no leaves and the list is not being searched.
42436 ** It is assumed that the page is not already a part of the free-list.
42444 ** its reference count is not altered by this function.
42517 ** Note that the trunk page is not really full until it contains
42518 ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
42544 /* If control flows to this point, then it was not possible to add the
42601 /* 0 is not a legal page number and page 1 cannot be an
42627 ** Note that pCell does not necessary need to point to the pPage->aData
42655 /* pPage is not necessarily writeable since pCell might be auxiliary
42732 /* If pToRelease is not zero than pPrior points into the data area
42752 /* If pToRelease is not zero than pPayload points into the data area
42784 ** The cell content is not freed or deallocated. It is assumed that
42833 ** will not fit, then make a copy of the cell content into pTemp if
42834 ** pTemp is not null. Regardless of pTemp, allocate a new entry
42840 ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
42842 ** nSkip is non-zero, then pCell may not point to an invalid memory location
43090 ** This function does not contribute anything to the operation of SQLite.
43132 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
43139 ** MemPage.aOvfl[] array), they are not copied to pTo.
43143 ** The performance of this function is not critical. It is only used by
43199 ** one or two in an effort to keep pages nearly full but not over full.
43202 ** might not actually be stored in MemPage.aData[]. This can happen
43242 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
43289 ** way, the remainder of the function does not have to deal with any
43336 ** four bytes of it, and this function does not need the first
43384 ** child pointers. If siblings are not leaves, then all cell in
43388 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
43434 /* Do not allow any cells smaller than 4 bytes. */
43483 ** sibling might be completely empty. This adjustment is not optional.
43551 /* Free any old pages that were not reused as new pages.
43570 ** not be a problem.
43619 /* If the sibling page assembled above was not the right-most sibling,
43708 ** many have not. The following is a summary:
43710 ** 1) The entries associated with new sibling pages that were not
43720 ** 3) If the sibling pages are not leaves, then the child pages of
43723 ** 4) If the sibling pages are not internal intkey nodes, then any
43727 ** 5) If the sibling pages are not leaves, then the pointer-map
43747 ** sibling page j. If the siblings are not leaf pages of an
43770 ** sibling page k. If the siblings are not leaf pages of an
43778 /* If the cell was originally divider cell (and is not now) or
43958 ** function. If this were not verified, a subtle bug involving reuse
43986 /* If pFree is not NULL, it points to the pSpace buffer used
44073 ** operation - if it is not, the following is a no-op). */
44080 ** In some cases, the call to btreeMoveto() below is a no-op. For
44087 ** not to clear the cursor here.
44212 /* If the page containing the entry to delete is not a leaf page, move
44238 /* If the cell deleted was not located on a leaf page, then the cursor
44297 ** flags might not work:
44336 /* The new root-page may not be allocated on a pointer-map page, or the
44356 ** the new table (assuming an error did not occur). But we were
44357 ** allocated pgnoMove. If required (i.e. if it was not allocated
44490 ** If pnChange is not NULL, then table iTable must be an intkey table. The
44501 ** is the root of a table b-tree - if it is not, the following call is
44502 ** a no-op). */
44521 ** If AUTOVACUUM is enabled and the page at iTable is not the last
44583 /* The table being dropped does not have the largest root-page
44656 ** free pages is not visible. So Cookie[0] is the same as Meta[1].
44680 ** read-only and may not be written.
44721 ** page in the B-Tree structure (not including overflow pages).
44727 /* If this is a leaf page or the tree is not an int-key tree, then
44738 ** the next page in the tree that has not yet been visited. The
44838 ** page iParent, pointer type ptrType. If not, append an error message
44922 /* If this database supports auto-vacuum and iPage is not the last
44946 ** 1. Make sure that cells and freeblocks do not overlap
45209 /* Make sure this analysis did not leave any unref() pages.
45249 ** has been created or not.
45293 ** If the nBytes parameter is 0 and the blob of memory has not yet been
45299 ** blob of allocated memory. This function should not call sqlite3_free()
45360 ** Only the data content may only be modified, it is not possible to
45425 ** May you do good and not evil.
45483 ** backup_pagecount() are not thread-safe functions. If they are called
45491 ** Non-sharable Btrees (in-memory databases for example), do not have
45553 ** handle is not locked in this routine, but it is locked in
45587 /* One (or both) of the named databases did not exist. An error has
45673 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
45674 ** this function is a no-op.
45730 /* Lock the destination database, if it is not locked already. */
45986 ** valid and which are not, so the entire process needs to be restarted.
46018 ** from this function, not directly by the user.
46054 ** May you do good and not evil.
46077 ** If pMem is not a string object, or the encoding of the string
46079 ** routine is a no-op.
46081 ** SQLITE_OK is returned if the conversion is successful (or not required).
46099 ** then the encoding of the value may not have changed.
46120 ** not set, Mem.n is zeroed.
46235 ** is a no-op.
46237 ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
46312 ** does not free any Mem.zMalloc buffer.
46358 ** Because we do not completely understand the problem, we will
46364 ** Many compilers we encounter do not define constants for the
46366 ** inconsistently. And many do not understand the "LL" notation.
46376 /* minInt is correct here - not maxInt. It turns out that assigning
46466 ** (1) the round-trip conversion real->int->real is a no-op, and
46630 ** Size of struct Mem not including the Mem.zMalloc member.
46636 ** pTo are freed. The pFrom->z field is not duplicated. If
46814 /* If one value is a number and the other is not, the number is less.
46866 ** compiled (this was not always the case).
46923 int key, /* If true, retrieve from the btree key, not data. */
46966 /* This function is only available internally, it is not part of the
47042 int op;
47050 op = pExpr->op;
47051 if( op==TK_REGISTER ){
47052 op = pExpr->op2; /* This only happens with SQLITE_ENABLE_STAT2 */
47055 if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
47064 if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;
47066 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
47074 }else if( op==TK_UMINUS ) {
47082 else if( op==TK_BLOB ){
47156 ** May you do good and not evil.
47250 ** Resize the Vdbe.aOp array so that it is at least one op larger than
47277 ** op The opcode for this instruction
47285 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
47291 assert( op>0 && op<0xff );
47299 pOp->opcode = (u8)op;
47317 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
47318 return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
47320 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
47321 return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
47323 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
47324 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
47333 int op, /* The new opcode */
47340 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
47350 int op, /* The new opcode */
47356 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
47477 ** throw an ABORT exception (causing the statement, but not entire transaction
47518 ** If malloc failed, then the while() loop above may not have iterated
47599 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
47708 ** the FuncDef is not ephermal, then do nothing.
47761 ** opcodes contained within. If aOp is not NULL it is assumed to contain
47839 ** caller should not free the allocation, it will be freed when the Vdbe is
47918 ** insert a No-op and add the comment to that new instruction. This
48212 /* Even though this opcode does not use dynamic strings for
48295 ** has not already been seen.
48432 ** receive the new memory. pBuf is normally NULL. If pBuf is not
48434 ** this routine should not allocate any new memory. When pBuf is not
48519 ** first time this function is called for a given VDBE, not when it is
48571 p->nMem = nMem; /* not from 0..nMem-1 */
48762 ** A read or write transaction may or may not be active on database handle
48775 ** SQLITE_OK so p is not used.
48792 ** (b) how many database files have open write transactions, not
48815 /* The simple case - no more than one database file (not counting the
48821 ** that case we do not support atomic multi-file commits, so use the
48915 ** flag is set this is not required.
48929 ** an error occurs here, do not delete the master journal file.
48988 ** currently active. An assertion fails if the two counts do not match.
48989 ** This is an internal self-check only - it is not an essential processing
48992 ** This is a no-op if NDEBUG is defined.
49026 ** reorder rootpages. So it is not sufficient just to save
49102 ** If SQLite is not threadsafe but does support shared-cache mode, then
49109 ** If SQLite is not threadsafe and does not support shared-cache mode, this
49110 ** function is a no-op.
49154 ** Return an error code. If the commit could not complete because of
49156 ** means the close did not happen and needs to be repeated.
49345 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
49359 /* If the VM did not run to completion or if it encountered an
49360 ** error, then it might not have been halted properly. So halt
49369 ** if the VDBE has just been set to run but has not actually executed any
49500 ** not been deleted out from under the cursor, then this routine is a no-op.
49573 ** of SQLite will not understand those serial types.
49631 ** For most architectures, this is a no-op.
49634 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
49637 ** ever since. The blame is not necessarily with GCC, though.
49849 ** not big enough, space is obtained from sqlite3_malloc().
49943 ** Key1 and Key2 do not have to contain the same number of fields.
49987 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
50147 ** of the keys prior to the final rowid, not the entire key.
50268 ** May you do good and not evil.
50560 /* Assert that malloc() has not failed */
50580 ** from interrupting a statement that has not yet started.
50827 ** This function is deprecated. Do not use it for new code. It is
50860 ** If iCol is not valid, return a pointer to a Mem which has a value
50917 ** But not for sqlite3_column_blob(), which never calls malloc().
51019 ** If the result is not a simple column reference (if it is an expression
51069 ** not define OMIT_DECLTYPE.
51072 # error "Must not define both SQLITE_OMIT_DECLTYPE \
51097 ** anything else which is not an unabiguous reference to a database column.
51113 ** anything else which is not an unabiguous reference to a database column.
51129 ** anything else which is not an unabiguous reference to a database column.
51339 ** in the Vdbe.azVar[] array, if such a mapping does not already
51427 ** will not bother to check for that condition.
51480 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
51482 int v = pVdbe->aCounter[op-1];
51483 if( resetFlag ) pVdbe->aCounter[op-1] = 0;
51495 ** May you do good and not evil.
51638 ** May you do good and not evil.
51674 ** in this file for details. If in doubt, do not deviate from existing
51694 ** This facility is used for testing purposes only. It does not function
51704 ** sorting is occurring or not occurring at appropriate times. This variable
51730 ** is executed. This is used to test whether or not the foreign key
51761 ** does not control the string, it might be deleted without the register
51865 ** looks like a number, convert it into a number. If it does not
51894 ** is not possible. Note that the integer representation is
51902 ** No-op. pRec is unchanged.
51911 ** representation (blob and NULL do not get converted) but no string
51945 ** not the internal Mem* type.
52090 ** May you do good and not evil.
52193 /* If we are currently testing IO errors, then do not call OsAccess() to
52195 ** occurs here will not be reported, causing the test to fail.
52497 int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
52854 ** Do not deviate from the formatting style currently in use.
52919 ** value in register P3 is not NULL, then this routine is a no-op.
52935 ** whether or not to rollback the current transaction. Do not rollback
52938 ** VDBE, but do not rollback the transaction.
52940 ** If P4 is not null then it is an error message string.
53078 ** blob in register P2. This instruction is not coded directly
53191 ** Thus the program must guarantee that the original will not change
53222 ** not return the number of rows modified. And do not RELEASE the statement
53237 ** ensure that statement-transactions are always nested, not overlapping.
53238 ** If the open statement-transaction is not closed here, then the user
53450 ** to retrieve the collation sequence set by this opcode is not available
53463 ** Register P3 must not be one of the function inputs.
53465 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
53645 ** in P1 is not an integer and cannot be converted into an integer
53690 ** A NULL value is not changed by this routine. It remains NULL.
53712 ** A NULL value is not changed by this routine. It remains NULL.
53736 ** A NULL value is not changed by this routine. It remains NULL.
53754 ** A NULL value is not changed by this routine. It remains NULL.
53772 ** A NULL value is not changed by this routine. It remains NULL.
53804 ** P4 is used to do the comparison. If P4 is not specified then
53810 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
53816 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
53872 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
53873 ** or not both operands are null.
54154 ** Jump to P2 if the value in register P1 is not NULL.
54226 ** might be available in the u.am.pC->aRow cache. Or it might not be.
54326 /* Make sure a corrupt database has not given us an oversize header.
54351 ** not exceeded even for corrupt database files.
54358 ** record header if the record header does not fit on a single page
54388 ** table. Set the u.am.offset for any extra columns not present in
54413 ** then there are not enough fields in the record to satisfy the
54571 ** We do not allow blobs with a prefix and a zero-filled tail. */
54589 ** the new record. The output register (pOp->p3) is not allowed to
54727 /* It is not possible to release (commit) a savepoint if there are
54728 ** active write statements. It is not possible to rollback a savepoint
54738 /* Determine whether or not this is a transaction savepoint. If so,
54895 ** connection is currently not in autocommit mode, or if there are other
55048 ** not reload the schema from the database file.
55050 ** If virtual-tables are in use, this is not just an optimization.
55053 ** prepared queries. If such a query is out-of-date, we do not want to
55076 ** values need not be contiguous but all P1 values should be small integers.
55079 ** If P5!=0 then use the content of register P2 as the root page, not
55114 ** cursors or a single read/write cursor but not both.
55194 ** and report database corruption if they were not, but this check has
55210 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
55298 ** Close a cursor previously opened as P1. If P1 is not
55299 ** currently open, this instruction is a no-op.
55317 ** greater than or equal to the key and P2 is not zero, then jump to P2.
55330 ** the key and P2 is not zero, then jump to P2.
55343 ** the key and P2 is not zero, then jump to P2.
55356 ** less than or equal to the key and P2 is not zero, then jump to P2.
55393 /* If the P3 value could not be converted into an integer without
55398 ** then the seek is not possible, so jump to P2 */
55556 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
55634 ** or may not be the same as R.
55641 ** of the index entry is not R. If there is no such entry, control jumps
55711 ** with that key does not exist in table of P1, then jump to P2.
55781 ** The record number is not previously used as a key in the database
55819 ** it already exists in the table. If it does not exist, we have
55892 ** that is not previously used.
55930 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
55936 ** operation will not attempt to find the appropriate row before doing
55948 ** may be NULL. If it is not NULL, then the update-hook
55954 ** value of register P2 will then change. Make sure this does not
55963 ** integer value P3, not the value of the integer stored in register P3.
55976 int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
56025 u.bf.op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
56027 db->xUpdateCallback(db->pUpdateArg, u.bf.op, u.bf.zDb, u.bf.zTbl, u.bf.iKey);
56039 ** the next Next instruction will be a no-op. Hence it is OK to delete
56043 ** incremented (otherwise not).
56045 ** P1 must not be pseudo-table. It has to be a real table with
56048 ** If P4 is not NULL, then it is the name of the table that P1 is
56050 ** If P4 is not NULL then the P1 cursor must have been positioned
56078 ** below is always a no-op and cannot fail. We will run it anyhow, though,
56119 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
56120 ** of a real table, not a pseudo-table.
56129 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
56130 ** of a real table, not a pseudo-table.
56158 ** a no-op and can never fail. But we leave it in place as a safety.
56274 ** If P2 is 0 or if the table or index is not empty, fall through
56313 ** regression tests can determine whether or not the optimizer is
56329 ** If P2 is 0 or if the table or index is not empty, fall through
56366 ** The P1 cursor must be for a real table, not a pseudo-table.
56377 ** The P1 cursor must be for a real table, not a pseudo-table.
56653 ** in the database file is given by P1. But, unlike Destroy, do not
56661 ** intkey table (an SQL table, not an index). In this case the row change
56738 ** no-op if the schema is not currently loaded. In other words, if P2
56769 ** sqlite3BtreeEnterAll(). If all mutexes are not already held, the
56773 ** will not be reloaded becuase the db->init.busy flag is set. This
56876 ** If P5 is not zero, the check is done on the auxiliary database
56877 ** file, not the main database file.
56929 ** An assertion fails if P2 is not an integer.
56984 ** the rowset object for P3, as it is guaranteed not to contain it,
57061 ** is really a trigger, not a foreign key action, and the flag set
57216 ** This instruction throws an error if the memory cell is not initially
57245 ** not contain an integer. An assertion fault will result if you try.
57261 ** not contain an integer. An assertion fault will result if you try.
57278 ** not contain an integer. An assertion fault will result if you try.
57352 ** argument is not used by this opcode. It is only there to disambiguate
57355 ** the step function was not previously called.
57381 ** machines to be created and run. It may not be called from within
57472 ** Also, whether or not P4 is set, check that this is not being called from
57686 ** do this regardless of whether or not an error occurred to ensure any
57910 ** the same as a no-op. This opcodesnever appears in a real VM program.
58028 ** May you do good and not evil.
58164 ** column is not indexed, and that it is not part of a foreign key.
58172 /* Check that the column is not part of an FK child key definition. It
58173 ** is not necessary to check if it is part of a parent key, as parent
58421 ** May you do good and not evil.
58435 ** on disk is not created or populated until either:
58461 ** If it does not already exists, create and populate the on-disk file
58631 ** file has not yet been created, create it now.
58657 ** May you do good and not evil.
58777 ** access writes are not required by sqlite.
58843 ** Syncing an in-memory journal is a no-op. And, in fact, this routine
58916 ** May you do good and not evil.
58936 ** WRC_Prune Do not descend into child nodes. But allow
58981 ** not invoke the SELECT callback on p, but do (of course) invoke
58998 ** FROM clause of SELECT statement p. Do not invoke the select
59027 ** If the Walker does not have an xSelectCallback() then this routine
59028 ** is a no-op returning WRC_Continue.
59052 ** May you do good and not evil.
59088 ** then again, we might not...
59106 if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){
59156 ** pExpr->op Set to TK_COLUMN.
59269 /* If we have not already resolved the name, then maybe
59273 int op = pParse->eTriggerOp;
59275 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
59276 if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
59279 }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
59331 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
59376 ** case, we need to return right away and not make any changes to
59380 ** fields are not changed in any context.
59383 pExpr->op = TK_STRING;
59389 ** cnt==0 means there was not match. cnt>1 means there were two or
59427 pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
59498 switch( pExpr->op ){
59510 pExpr->op = TK_COLUMN;
59536 if( pRight->op==TK_ID ){
59541 assert( pRight->op==TK_DOT );
59564 testcase( pExpr->op==TK_CONST_FUNC );
59584 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
59588 pExpr->op = TK_NULL;
59606 pExpr->op = TK_AGG_FUNCTION;
59619 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
59622 testcase( pExpr->op==TK_IN );
59657 ** no match, or if pE is not a simple identifier, then this routine
59660 ** pEList has been resolved. pE has not.
59671 if( pE->op==TK_ID ){
59685 ** ORDER BY of a compound SELECT. The expression has not been
59689 ** ORDER BY term is not an integer index into the result set. That
59841 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
60002 ** are not allowed to refer to any names, so pass an empty NameContext.
60042 ** expression, do not allow aggregates in any of the other expressions.
60074 /* The ORDER BY and GROUP BY clauses may not refer to terms in
60093 ** the GROUP BY clause does not contain aggregate functions.
60103 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
60145 ** Expr.op Changed to TK_COLUMN
60248 ** May you do good and not evil.
60274 int op = pExpr->op;
60275 if( op==TK_SELECT ){
60280 if( op==TK_CAST ){
60285 if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
60288 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
60329 int op;
60332 op = p->op;
60334 op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
60336 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
60348 if( op!=TK_CAST && op!=TK_UPLUS ){
60381 /* One side is a column, the other is not. Use the columns affinity. */
60393 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
60394 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
60395 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
60445 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
60446 ** it is not considered.
60501 ** expression depth allowed. If it is not, leave an error message in
60605 ** parameter is ignored if pToken is NULL or if the token does not
60609 ** Special case: If op==TK_INTEGER and pToken points to a string that
60610 ** can be translated into a 32-bit integer, then the token is not
60617 int op, /* Expression opcode */
60626 if( op!=TK_INTEGER || pToken->z==0
60633 pNew->op = (u8)op;
60664 int op, /* Expression opcode */
60670 return sqlite3ExprAlloc(db, op, &x, 0);
60717 int op, /* Expression opcode */
60722 Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
60770 ** sure "nnn" is not too be to avoid a denial of service attack when
60906 ** off if the expression is reduced. Note also that it does not work to
60954 ** and Expr.pRight variables (but not for any structures pointed to or
60970 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
61067 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
61070 ** Any tables that the SrcList might point to are not duplicated.
61180 pNew->op = p->op;
61336 ** not constant.
61355 switch( pExpr->op ){
61365 testcase( pExpr->op==TK_ID );
61366 testcase( pExpr->op==TK_COLUMN );
61367 testcase( pExpr->op==TK_AGG_FUNCTION );
61368 testcase( pExpr->op==TK_AGG_COLUMN );
61372 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
61373 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
61429 ** in *pValue. If the expression is not an integer or if it is too big
61438 switch( p->op ){
61461 p->op = TK_INTEGER;
61483 u8 op;
61484 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
61485 op = p->op;
61486 if( op==TK_REGISTER ) op = p->op2;
61487 switch( op ){
61527 u8 op;
61529 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
61530 op = p->op;
61531 if( op==TK_REGISTER ) op = p->op2;
61532 switch( op ){
61597 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
61600 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
61601 if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
61604 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
61635 ** If the prNotFound parameter is not 0, then the b-tree will be used
61641 ** needs to know whether or not the structure contains an SQL NULL
61649 ** its initial value is NULL. If the (...) does not remain constant
61670 assert( pX->op==TK_IN );
61716 ** it is not, it is not possible to use any index.
61749 /* Could not found an existing table or index to use as the RHS b-tree.
61786 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
61830 switch( pExpr->op ){
61887 ** that columns affinity when building index keys. If <expr> is not
61908 /* If the expression is not constant then we will need to
61949 ** an integer 0 (not exists) or 1 (exists) into a memory cell
61956 testcase( pExpr->op==TK_EXISTS );
61957 testcase( pExpr->op==TK_SELECT );
61958 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
61963 if( pExpr->op==TK_SELECT ){
62002 ** if the LHS is NULL or if the LHS is not contained within the RHS and the
62005 ** This routine generates code will jump to destIfFalse if the LHS is not
62013 int destIfFalse, /* Jump here if LHS is not contained in the RHS */
62078 ** then the presence of NULLs in the RHS does not matter, so jump
62083 /* Here we begin generating code that runs if the LHS is not
62096 /* Jump to the appropriate target depending on whether or not
62129 ** The z[] string will probably not be zero-terminated. But the
62130 ** z[n] character is guaranteed to be something that does not look
62150 ** The z[] string will probably not be zero-terminated. But the
62151 ** z[n] character is guaranteed to be something that does not look
62326 ** not guaranteed. The location of the column value is returned.
62353 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
62354 sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
62419 ** and does not appear in a normal build.
62466 ** alias has not yet been computed.
62512 int op; /* The opcode being coded */
62526 op = TK_NULL;
62528 op = pExpr->op;
62530 switch( op ){
62663 testcase( op==TK_LT );
62664 testcase( op==TK_LE );
62665 testcase( op==TK_GT );
62666 testcase( op==TK_GE );
62667 testcase( op==TK_EQ );
62668 testcase( op==TK_NE );
62671 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
62679 testcase( op==TK_IS );
62680 testcase( op==TK_ISNOT );
62683 op = (op==TK_IS) ? TK_EQ : TK_NE;
62684 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
62713 testcase( op==TK_AND );
62714 testcase( op==TK_OR );
62715 testcase( op==TK_PLUS );
62716 testcase( op==TK_MINUS );
62717 testcase( op==TK_REM );
62718 testcase( op==TK_BITAND );
62719 testcase( op==TK_BITOR );
62720 testcase( op==TK_SLASH );
62721 testcase( op==TK_LSHIFT );
62722 testcase( op==TK_RSHIFT );
62723 testcase( op==TK_CONCAT );
62726 sqlite3VdbeAddOp3(v, op, r2, r1, target);
62734 if( pLeft->op==TK_FLOAT ){
62737 }else if( pLeft->op==TK_INTEGER ){
62753 testcase( op==TK_BITNOT );
62754 testcase( op==TK_NOT );
62758 sqlite3VdbeAddOp2(v, op, r1, inReg);
62766 testcase( op==TK_ISNULL );
62767 testcase( op==TK_NOTNULL );
62771 addr = sqlite3VdbeAddOp1(v, op, r1);
62799 testcase( op==TK_CONST_FUNC );
62800 testcase( op==TK_FUNCTION );
62849 ** second argument, not the first, as the argument to test to
62886 testcase( op==TK_EXISTS );
62887 testcase( op==TK_SELECT );
63018 default: assert( op==TK_CASE ); {
63040 testcase( pX->op==TK_COLUMN );
63041 testcase( pX->op==TK_REGISTER );
63044 cacheX.op = TK_REGISTER;
63045 opCompare.op = TK_EQ;
63058 testcase( pTest->op==TK_COLUMN );
63060 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
63061 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
63117 ** then write its number into *pReg. If the result register is not
63172 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
63177 pExpr->op2 = pExpr->op;
63178 pExpr->op = TK_REGISTER;
63190 ** or OP_Variable that does not need to be placed in a
63207 while( p->op==TK_UPLUS ) p = p->pLeft;
63208 switch( p->op ){
63217 testcase( p->op==TK_BLOB );
63218 testcase( p->op==TK_VARIABLE );
63219 testcase( p->op==TK_INTEGER );
63220 testcase( p->op==TK_FLOAT );
63221 testcase( p->op==TK_NULL );
63222 testcase( p->op==TK_STRING );
63230 if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
63250 switch( pExpr->op ){
63279 pExpr->op2 = pExpr->op;
63280 pExpr->op = TK_REGISTER;
63362 exprAnd.op = TK_AND;
63365 compLeft.op = TK_GE;
63368 compRight.op = TK_LE;
63372 exprX.op = TK_REGISTER;
63407 int op = 0;
63415 op = pExpr->op;
63416 switch( op ){
63450 testcase( op==TK_LT );
63451 testcase( op==TK_LE );
63452 testcase( op==TK_GT );
63453 testcase( op==TK_GE );
63454 testcase( op==TK_EQ );
63455 testcase( op==TK_NE );
63459 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63467 testcase( op==TK_IS );
63468 testcase( op==TK_ISNOT );
63471 op = (op==TK_IS) ? TK_EQ : TK_NE;
63472 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63482 testcase( op==TK_ISNULL );
63483 testcase( op==TK_NOTNULL );
63485 sqlite3VdbeAddOp2(v, op, r1, dest);
63525 int op = 0;
63534 /* The value of pExpr->op and op are related as follows:
63536 ** pExpr->op op
63547 ** For other values of pExpr->op, op is undefined and unused.
63552 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
63556 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
63557 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
63558 assert( pExpr->op!=TK_NE || op==OP_Eq );
63559 assert( pExpr->op!=TK_EQ || op==OP_Ne );
63560 assert( pExpr->op!=TK_LT || op==OP_Ge );
63561 assert( pExpr->op!=TK_LE || op==OP_Gt );
63562 assert( pExpr->op!=TK_GT || op==OP_Le );
63563 assert( pExpr->op!=TK_GE || op==OP_Lt );
63565 switch( pExpr->op ){
63593 testcase( op==TK_LT );
63594 testcase( op==TK_LE );
63595 testcase( op==TK_GT );
63596 testcase( op==TK_GE );
63597 testcase( op==TK_EQ );
63598 testcase( op==TK_NE );
63602 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63610 testcase( pExpr->op==TK_IS );
63611 testcase( pExpr->op==TK_ISNOT );
63614 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
63615 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63623 testcase( op==TK_ISNULL );
63624 testcase( op==TK_NOTNULL );
63626 sqlite3VdbeAddOp2(v, op, r1, dest);
63664 ** returns false, then you do not really know for certain if the two
63667 ** this routine is used, it does not hurt to get an extra FALSE - that
63682 if( pA->op!=pB->op ) return 0;
63702 }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
63760 switch( pExpr->op ){
63763 testcase( pExpr->op==TK_AGG_COLUMN );
63764 testcase( pExpr->op==TK_COLUMN );
63777 ** is not an entry there already.
63804 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
63822 pExpr->op = TK_AGG_COLUMN;
63986 ** May you do good and not evil.
63996 ** The code in this file only exists if we are not omitting the
64133 ** TRIGGER, not CREATE INDEX and CREATE TABLE.
64231 ** If argument zWhere is not NULL, then the string returned is
64275 /* If the table is not located in the temp-db (in which case NULL is
64277 ** that is not part of the temp-db schema, add a clause to the WHERE
64331 /* Now, if the table is not stored in the temp database, reload any temp
64375 /* Check that a table or index named 'zName' does not already exist
64384 /* Make sure it is not a system table being altered, or a reserved name
64390 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
64399 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
64609 if( pDflt && pDflt->op==TK_NULL ){
64613 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
64615 ** column must not be NULL.
64637 ** can handle (i.e. not CURRENT_TIME etc.)
64670 ** format to 2. If the default value of the new column is not NULL,
64712 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
64717 /* Make sure this is not an attempt to ALTER a view. */
64729 ** prefix, we insure that the name will not collide with an existing
64730 ** table because user table are not allowed to have the "sqlite_"
64781 ** May you do good and not evil.
64796 ** If the sqlite_stat1 tables does not previously exist, it is created.
64797 ** Similarly, if the sqlite_stat2 table does not exist and the library
64801 ** or it may be a NULL pointer. If it is not NULL, then all entries in
64838 /* The sqlite_stat[12] table does not exist. Create it. Note that a
64848 /* The table already exists. If zWhere is not NULL, delete all entries
64950 ** not been populated. In this case populate it now. */
65045 ** out-of-bounds write if SQLITE_DEBUG is not defined). */
65180 if( i==1 ) continue; /* Do not analyze the TEMP database */
65263 ** If the Index.aSample variable is not NULL, delete the aSample[] array
65291 ** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR
65297 ** sqlite_stat2 table is not present in the database, SQLITE_ERROR is
65302 ** This means if the caller does not care about other errors, the return
65434 ** May you do good and not evil.
65446 ** identifiers are treated as strings, not possible column names or aliases.
65465 if( pExpr->op!=TK_ID ){
65472 pExpr->op = TK_STRING;
65551 ** or may not be initialised.
65824 ** The return value indicates whether or not fixation is required. TRUE
65825 ** means we do need to fix the database references, FALSE means we do not.
65853 ** view in one database does not refer to objects in a different database.
65971 ** May you do good and not evil.
65978 ** systems that do not need this facility may omit it by recompiling
66058 ** callback has been registered (i.e. that sqlite3.xAuth is not NULL).
66060 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
66118 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
66119 if( pExpr->op==TK_TRIGGER ){
66144 pExpr->op = TK_NULL;
66176 sqlite3ErrorMsg(pParse, "not authorized");
66188 ** popped. Or if pParse==0, this routine is a no-op.
66222 ** May you do good and not evil.
66388 ** obtain the required table-locks. This is a no-op unless the
66434 ** this way, the final OP_Halt is not appended and other initialization
66471 ** database containing the table. Return NULL if not found.
66498 ** database containing the table. Return NULL if not found. Also leave an
66503 ** sqlite3FindTable() does not.
66536 ** Return NULL if not found.
66576 ** it is not unlinked from the Table that it indexes.
66654 ** schema hash tables and therefore do not have to make any changes
66712 ** This routine just deletes the data structure. It does not unlink
66725 /* Do not delete the table until the reference count reaches zero. */
66785 ** are not \000 terminated and are not persistent. The returned string
66838 ** does not exist.
66855 ** the table name is not fully qualified, i.e.:
66950 ** the table name is not fully qualified, i.e.:
66964 /* If creating a temp table, the name may not be qualified */
67004 /* Make sure the new table name does not collide with an existing
67073 /* If the file format and encoding in the database have not been set,
67091 ** The record created does not contain anything yet. It will be replaced
67129 ** WARNING: This macro is not compatible with the strcmp() family. It
67288 ** is not the case.
67301 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
67333 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
67455 ** If the requested collation sequence is not available, or not available
67457 ** request it. If the collation factory does not supply such a sequence,
67496 ** it checks the cookie to make sure the schema has not changed
67499 ** This plan is not completely bullet-proof. It is possible for
67517 ** but does not include the null terminator.
67539 ** characters, does not begin with a digit and is not an SQL keyword,
67648 ** the sqlite_master table. We do not want to create it again.
67650 ** If the pSelect argument is not NULL, it means that this routine
67699 ** So do not write to the disk again. Extract the root page number
67707 /* If not initializing, then create a record for the new table
67748 ** A shared-cache write-lock is not required to write to the new table,
67880 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
67891 ** there could not have been an error */
67988 ** to the elements of the FROM clause. But we do not want these changes
68062 ** or tables and not the table/index that is actually being moved.
68133 ** is not defined), then it is important to call OP_Destroy on the
68245 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
68250 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
68389 "number of columns in foreign key does not match the number of "
68493 ** if memRootPage is not negative, it means that the index is newly
68556 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
68623 ** Find the table that is to be indexed. Return early if not found.
68637 ** is a temp table. If so, set the database to 1. Do not do this
68671 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
68676 sqlite3ErrorMsg(pParse, "views may not be indexed");
68682 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
68688 ** Find the name of the index. Make sure there is not already another
68812 ** if any column is not found.
68814 ** TODO: Add a test to make sure that the same column is not named
68837 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
69049 ** to be used when we have not run the ANALYZE command.
69052 ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
69243 ** if not found.
69330 ** If pDatabase is not null, it means that the table has an optional
69595 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
69603 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
69607 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
69693 ** This routine starts a new transaction if we are not already within
69700 ** necessary to undo a write and the checkpoint should not be set.
69757 ** true if it does and false if it does not.
69928 ** May you do good and not evil.
69981 pColl->xDel = 0; /* Do not copy the destructor */
69991 ** requested collation sequence is not available in the desired encoding.
69993 ** If it is not NULL, then pColl must point to the database native encoding
70032 ** that have not been defined by sqlite3_create_collation() etc.
70058 ** specified by zName and nName is not found and parameter 'create' is
70112 ** If the entry specified is not found and 'create' is true, then create a
70229 ** NULL if the function does not exist.
70242 ** number of arguments may be returned even if the eTextRep flag does not
70251 int createFlag /* Create new entry if true and does not otherwise exist */
70280 ** So we must not search for built-ins when creating a new function.
70295 /* If the createFlag parameter is true and the search did not reveal an
70317 ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
70321 ** The Schema.cache_size variable is not cleared.
70380 ** May you do good and not evil.
70390 ** Look up every table that is named in pSrc. If any table is not found,
70411 ** Check to make sure the given table is writable. If it is not
70416 /* A table is not writable under the following circumstances:
70420 ** 2) It is a system table (i.e. sqlite_master), this call is not
70421 ** part of a nested parse and writable_schema pragma has not
70432 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
70797 ** generating code because of a call to sqlite3NestedParse(), do not
70859 ** not attempt to delete it or fire any DELETE triggers. */
70896 ** being deleted. Do not attempt to delete the row a second time, and
70897 ** do not fire AFTER triggers. */
70902 ** are not violated by deleting this row. */
71018 ** May you do good and not evil.
71157 /* Because sqlite3_value_double() returns 0.0 if the argument is not
71327 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
71347 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
71366 ** do not have to be computed. This legacy implementation is retained as
71526 ** [^...] Matches one character not in the enclosed list.
71571 assert( esc==0 ); /* This is GLOB, not LIKE */
71601 assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
71693 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
71770 ** EXPERIMENTAL - This is not an official function. The interface may
71771 ** change. This function may disappear. Do not write code that depends
71896 ** must be exact. Collating sequences are not used.
72387 ** parameter determines whether or not the LIKE operator is case
72410 ** return TRUE. If the function is not a LIKE-style function then
72415 if( pExpr->op!=TK_FUNCTION
72542 ** May you do good and not evil.
72575 ** there is no way to tell which foreign constraint is not satisfied,
72576 ** or which row it is not satisfied for.
72599 ** deleted row in the child table. If such a row is not found,
72629 ** an INSERT does not open a statement transaction.
72639 ** for those two operations needs to know whether or not the operation
72687 ** is not a composite foreign key), output variable *paiCol is set to NULL.
72698 ** 1) The named parent key columns do not exist, or
72700 ** 2) The named parent key columns do exist, but are not subject to a
72704 ** foreign key definition, and the parent table does not have a
72739 ** Non-composite foreign keys do not require the aiCol array.
72833 ** special action is taken. Otherwise, if the parent row can *not* be
72866 ** outstanding constraints to resolve. If there are not, there is no need
72891 ** will have INTEGER affinity applied to it, which may not be correct. */
72897 ** then check if the row being inserted matches itself. If so, do not
72923 ** then check if the row being inserted matches itself. If so, do not
72948 ** generated for will not open a statement transaction. */
73082 ** clause. If the constraint is not deferred, throw an exception for
73154 ** DELETE, but foreign key actions are not.
73185 ** transactions are not able to rollback schema changes. */
73233 /* If foreign-keys are disabled, this function is a no-op. */
73297 ** If the parent does not exist, removing the child row resolves an
73392 ** If the i'th column is not modified by the UPDATE, then the corresponding
73601 ** tables do not have foreign key constraints. Hence, pTab->dbMem
73641 pStep->op = TK_SELECT;
73645 pStep->op = TK_DELETE;
73649 pStep->op = TK_UPDATE;
73655 pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
73736 ** May you do good and not evil.
73964 assert( v ); /* We failed long ago if this is not so */
74106 ** The 3rd template is for when the second template does not apply
74107 ** and the SELECT clause does not read from <table> at any time.
74247 ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
74255 * (a) the table is not read-only,
74434 ** the index of the primary key as it appears in IDLIST, not as
74480 /* If this is not a view, open the table and and all indices */
74543 ** we do not know what the unique ID will be (because the insert has
74544 ** not happened yet) so we substitute a rowid of -1
74588 ** do not attempt any conversions before assembling the record.
74759 ** generating code because of a call to sqlite3NestedParse(), do not
74811 ** computed automatically in an insert or that the rowid value is not
74832 ** only (do not do a complete rollback) then
74838 ** transaction is not rolled back and any
74863 ** cursors do not need to be open for indices where aRegIdx[i]==0.
74873 int overrideError, /* Override onError to this if not OE_Default */
74891 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
74921 zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
74958 ** of the new record does not previously exist. Except, if this
74959 ** is an UPDATE and the primary key is not changing, that is OK.
74992 ** flag is not set, call GenerateRowIndexDelete(). This removes
75023 ** index and making sure that duplicate entries do not already exist.
75051 continue; /* pIdx is not a UNIQUE index */
75071 /* Generate code that executes if the new index entry is not unique */
75093 pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
75156 assert( pTab->pSelect==0 ); /* This table is not a VIEW */
75200 int op /* OP_OpenRead or OP_OpenWrite */
75211 sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
75215 sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
75307 ** (6) The SELECT statement is a simple (not a compound) select that
75311 ** tab2 over to tab1. The columns are not decoded. Raw records from
75316 ** of the conditions above fail so that the optimization should not
75346 return 0; /* tab1 must not have triggers */
75350 return 0; /* tab1 must not be a virtual table */
75367 return 0; /* SELECT may not have a WHERE clause */
75370 return 0; /* SELECT may not have an ORDER BY clause */
75372 /* Do not need to test for a HAVING clause. If HAVING is present but
75375 return 0; /* SELECT may not have a GROUP BY clause */
75378 return 0; /* SELECT may not have a LIMIT clause */
75382 return 0; /* SELECT may not be a compound query */
75385 return 0; /* SELECT may not be DISTINCT */
75393 if( pEList->a[0].pExpr->op!=TK_ALL ){
75404 return 0; /* FROM clause does not contain a real table */
75407 return 0; /* tab1 and tab2 may not be the same table */
75411 return 0; /* tab2 must not be a virtual table */
75415 return 0; /* tab2 may not be a view */
75470 /* If tables do not have an INTEGER PRIMARY KEY and there
75471 ** are indices to be copied and the destination is not empty,
75475 ** Or if the destination has a UNIQUE index and is not empty,
75553 ** May you do good and not evil.
75560 ** other files are for internal use by SQLite and should not be
75699 ** May you do good and not evil.
75719 ** May you do good and not evil.
75742 ** versions of SQLite will not be able to load each others' shared
75912 ** (part of the main SQLite library - not an extension) so that
75914 ** definition. But the main library does not want to redefine
76191 ** not NULL before calling it.
76327 ** of the APIs above provided that the pointer is not NULL. But
76411 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
76419 char **pzErrMsg /* Put error message here if not 0 */
76438 *pzErrMsg = sqlite3_mprintf("not authorized");
76503 char **pzErrMsg /* Put error message here if not 0 */
76528 ** default so as not to open security holes in older applications.
76544 ** The auto-extension code added regardless of whether or not extension
76546 ** code if regular extension loading is not available. This is that
76690 ** May you do good and not evil.
76843 ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
76895 /* Foreign key support may not be enabled or disabled while not
77060 ** the database has not yet been created.
77339 ** page cache size value. It does not change the persistent
77361 ** the local value does not make changes to the disk file and the default
77401 sqlite3ErrorMsg(pParse, "not a writable directory");
77476 ** the local value does not make changes to the disk file and the
77487 "Safety level may not be changed inside a transaction");
77698 ** used will be case sensitive or not depending on the RHS.
77879 ** database. If the database is not initialized, it is initialized now.
77881 ** The second form of this pragma is a no-op if the main database file
77882 ** has not already been initialized. In this case it sets the default
77889 ** the main database has not been initialized and/or created when ATTACH
77923 /* Only change the value of sqlite.enc if the database handle is not
77925 ** will be overwritten when the schema is next loaded. If it does not
77969 ** The user-version is not used internally by SQLite. It may be used by
78127 ** May you do good and not evil.
78336 /* If there is not already a read-only (or read-write) transaction opened
78373 ** For an attached db, it is an error if the encoding is not the same
78424 ** not downgrade the database and thus invalidate any descending
78542 ** This routine is a no-op if the database schema is already initialised.
78578 /* If there is not already a read-only (or read-write) transaction opened
78590 /* Read the schema cookie from the database. If it does not match the
78684 ** is not possible for another thread to start a new schema change
78685 ** while this routine is running. Hence, we do not need to hold
78690 ** but it does *not* override schema lock detection, so this all still
78879 ** version, the original SQL text is not saved in the prepared statement
78959 ** version, the original SQL text is not saved in the prepared statement
79000 ** May you do good and not evil.
79011 ** Delete all the content of a Select structure but do not deallocate
79051 Expr *pLimit, /* LIMIT value. NULL means not used */
79073 pNew->op = TK_SELECT;
79166 "RIGHT and FULL OUTER JOINs are not currently supported");
79174 ** is not contained in the table.
79191 ** If not found, return FALSE.
79268 ** join restriction specified in the ON or USING clause and not a part
79274 ** expression depends on table iRightJoinTable even if that table is not
79282 ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
79334 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
79373 ** not contained in both tables to be joined.
79389 "not present in both tables", zName);
79466 ** stack if the top N elements are not distinct.
79471 int addrRepeat, /* Jump to here if not distinct */
79522 ExprList *pOrderBy, /* If not NULL, sort results using this key */
79565 ** values returned by the SELECT are not required.
79573 ** and this row has been seen before, then do not make this row
79645 ** does not matter. But there might be a LIMIT clause, in which
79707 ** user-defined functions that have side effects. We do not care
79902 switch( pExpr->op ){
79912 testcase( pExpr->op==TK_AGG_COLUMN );
79913 testcase( pExpr->op==TK_COLUMN );
79939 ** This is not a problem, as the column type of "t1.col" is never
80085 }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
80178 while( pColExpr->op==TK_DOT ) pColExpr = pColExpr->pRight;
80179 if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
80186 }else if( pColExpr->op==TK_ID ){
80199 /* Make sure the column name is unique. If the name is not unique,
80233 ** The column list has only names, not types or collations. This
80338 ** (usually but not always -1) prior to calling this routine.
80452 ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
80479 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
80480 selectOpName(p->op));
80485 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
80486 selectOpName(p->op));
80508 " do not have the same number of result columns", selectOpName(p->op));
80521 switch( p->op ){
80552 u8 op = 0; /* One of the SRT_ operations to apply to self */
80558 testcase( p->op==TK_EXCEPT );
80559 testcase( p->op==TK_UNION );
80594 if( p->op==TK_EXCEPT ){
80595 op = SRT_Except;
80597 assert( p->op==TK_UNION );
80598 op = SRT_Union;
80605 uniondest.eDest = op;
80646 default: assert( p->op==TK_INTERSECT ); {
81020 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
81021 ** actually called using Gosub and they do not Return. EofA and EofB loop
81059 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
81078 op = p->op;
81089 if( op!=TK_ALL ){
81152 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
81154 if( op==TK_ALL ){
81185 if( p->iLimit && op==TK_ALL ){
81252 if( op==TK_ALL || op==TK_UNION ){
81263 if( op==TK_EXCEPT || op==TK_INTERSECT ){
81275 if( op==TK_INTERSECT ){
81295 if( op==TK_ALL ){
81297 }else if( op==TK_INTERSECT ){
81312 if( op==TK_ALL || op==TK_UNION ){
81393 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
81395 pExpr->op = TK_NULL;
81486 ** (1) The subquery and the outer query do not both use aggregates.
81488 ** (2) The subquery is not an aggregate or the outer query is not a join.
81490 ** (3) The subquery is not the right operand of a left outer join
81493 ** (4) The subquery is not DISTINCT or the outer query is not a join.
81495 ** (5) The subquery is not DISTINCT or the outer query does not use
81498 ** (6) The subquery does not use aggregates or the outer query is not
81503 ** (8) The subquery does not use LIMIT or the outer query is not a join.
81505 ** (9) The subquery does not use LIMIT or the outer query does not use
81508 ** (10) The subquery does not use aggregates or the outer query does not
81511 ** (11) The subquery and the outer query do not both have ORDER BY clauses.
81516 ** (13) The subquery and outer query do not both use LIMIT
81518 ** (14) The subquery does not use OFFSET
81520 ** (15) The outer query is not part of a compound select or the
81521 ** subquery does not have both an ORDER BY and a LIMIT clause.
81524 ** (16) The outer query is not an aggregate or the subquery does
81525 ** not contain ORDER BY. (Ticket #2942) This used to not matter
81528 ** (17) The sub-query is not a compound select, or it is a UNION ALL
81532 ** * is not itself part of a compound select,
81533 ** * is not an aggregate or DISTINCT query, and
81544 ** (19) The subquery does not use LIMIT or the outer query does not
81547 ** (20) If the sub-query is a compound select, then it must not use
81557 ** If flattening is not attempted, this routine is a no-op and returns 0.
81583 /* Check to see if flattening is permitted. Return 0 if not.
81599 ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
81624 ** not used as the right operand of an outer join. Examples of why this
81625 ** is not allowed:
81633 ** which is not at all the same thing.
81638 ** An examples of why this is not allowed:
81652 ** subquery is the right term of a LEFT JOIN, then do not flatten.
81674 || (pSub1->pPrior && pSub1->op!=TK_ALL)
81743 p->op = TK_ALL;
81915 ** does not work if either limit is negative.
81949 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
81953 if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
81970 ** where table is a database table, not a sub-select or view. If the query
81990 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
82140 if( pE->op==TK_ALL ) break;
82141 assert( pE->op!=TK_DOT || pE->pRight!=0 );
82142 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
82143 if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break;
82159 assert( pE->op!=TK_DOT || pE->pRight!=0 );
82160 if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pE->pRight->op!=TK_ALL) ){
82161 /* This particular expression does not need to be expanded.
82176 if( pE->op==TK_DOT ){
82202 ** for virtual tables), do not include it in the expanded
82266 ** No-op routine for the parse-tree walker.
82312 ** at that point because identifiers had not yet been resolved. This
82540 ** set is not empty.
82704 ** we figure out that the sorting index is not needed. The addrSortIndex
82752 ** instruction ended up not being needed, then change the OP_OpenEphemeral
82838 ** that we do not need it after all, the OpenEphemeral instruction
82874 ** we do not have to sort. The OP_OpenEphemeral table will be
82996 ** is less than or equal to zero, the subroutine is a no-op. If
83040 ** is better to execute the op on an index, as indexes are almost
83061 ** In practice the KeyInfo structure will not be used. It is only
83101 ** where.c should not iterate over any values with a NULL value
83117 pMinMax->a[0].pExpr->op = TK_COLUMN;
83187 ** that follows does not appear in normal builds.
83194 ** These routine are not called anywhere from within the normal
83202 sqlite3DebugPrintf("(%d", p->op);
83287 ** May you do good and not evil.
83296 ** These routines are in a separate files so that they will not be linked
83297 ** if they are not used.
83483 ** May you do good and not evil.
83560 int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
83576 assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
83578 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
83579 assert( op>0 && op<0xff );
83581 /* If TEMP was specified, then the trigger name may not be qualified. */
83583 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
83598 ** If sqlite3SrcListLookup() returns 0, indicating the table does not
83618 /* The table does not exist. */
83624 ** trigger is not visible to the database connection that does the
83637 /* Check that the trigger name is not reserved and that no trigger of the
83651 /* Do not create a trigger on a system table */
83705 pTrigger->op = (u8)op;
83757 /* if we are not initializing, and this trigger is not on a TEMP table,
83815 pTriggerStep->op = TK_SELECT;
83829 u8 op, /* Trigger opcode */
83840 pTriggerStep->op = op;
84089 ** one trigger that must be fired when an operation of type 'op' is
84096 int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
84105 if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
84178 switch( pStep->op ){
84205 default: assert( pStep->op==TK_SELECT ); {
84214 if( pStep->op!=TK_SELECT ){
84225 ** program. It is not used in production code, only for debugging.
84303 pSubParse->eTriggerOp = pTrigger->op;
84310 (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
84311 (pTrigger->op==TK_INSERT ? "INSERT" : ""),
84312 (pTrigger->op==TK_DELETE ? "DELETE" : ""),
84390 /* If an existing TriggerPrg could not be located, create a new one. */
84429 ** not a foreign key action, and (b) the flag to enable recursive triggers
84438 ** is given by the op paramater. The tr_tm parameter determines whether the
84443 ** operation on pTab, this function is a no-op.
84462 ** never be accessed by the trigger program, so they are not allocated or
84465 ** are never accessed, and so are not allocated by the caller. So, for an
84467 ** is not a readable register, although registers (reg+N) through
84478 int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
84488 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
84490 assert( (op==TK_UPDATE)==(pChanges!=0) );
84503 if( p->op==op
84525 ** It is not possible to determine if the old.rowid or new.rowid column is
84546 const int op = pChanges ? TK_UPDATE : TK_DELETE;
84552 if( p->op==op && (tr_tm&p->tr_tm)
84576 ** May you do good and not evil.
84607 ** may not contain a value for the column and the default value, taken
84610 ** for the column and the P4 value is not required.
84623 ** If parameter iReg is not negative, code an OP_RealAffinity instruction
84675 ** aXRef[i]==-1 if the i-th column is not changed. */
84742 ** The index cursors might not be used, but if they are used they
84944 ** this record does not exist for some reason (deleted by a trigger,
84949 ** contain the new value. If the record number is not being modified,
84983 ** If there are one or more BEFORE triggers, then do not populate the
84984 ** registers associated with columns that are (a) not modified by
84985 ** this UPDATE statement and (b) not accessed by new.* references. The
84986 ** values for registers not modified by the UPDATE must be reloaded from
84988 ** may have modified them). So not loading those that are not going to
85002 /* This branch loads the value of a column that will not be changed
85032 /* If it did not delete it, the row-trigger may still have modified
85034 ** all columns not modified by the update statement into their
85115 ** generating code because of a call to sqlite3NestedParse(), do not
85244 ** May you do good and not evil.
85303 ** become a no-op.
85349 ** can be set to 'off' for this file, as it is not recovered if a crash
85471 ** transaction open on the vacuum database, but not on the main database.
85555 ** May you do good and not evil.
85692 ** Except, if argument db is not NULL, then the entry associated with
85793 ** The string is not copied - the pointer is stored. The
85937 ** record of the table. The xConnect() method is not called until
86037 const char *zFormat = "vtable constructor did not declare schema: %s";
86093 ** This call is a no-op if table pTab is not a virtual table.
86172 ** invoke it now. If the module has not been registered, return an
86257 ** This call is a no-op if zTab is not a virtual table.
86367 ** not currently open, invoke the xBegin method now.
86441 if( pExpr->op!=TK_COLUMN ) return pDef;
86486 ** is a no-op.
86517 ** May you do good and not evil.
86563 ** X <op> <expr>
86565 ** where X is a column name and <op> is one of certain operators,
86568 ** the <op> using a bitmask encoding defined by WO_xxx below. The
86574 ** (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR ....
86580 ** If a term in the WHERE clause does not match either of the two previous
86605 int leftCursor; /* Cursor number of X in "X <op> <expr>" */
86607 int leftColumn; /* Column number of X in "X <op> <expr>" */
86611 u16 eOperator; /* A WO_xx value describing <op> */
86623 #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */
86638 u8 op; /* Split operator. TK_AND or TK_OR */
86672 ** clause, the cursor numbers might not begin with 0 and they might
86685 ** Note that the mapping is not necessarily ordered. In the example
86688 ** does not really matter. What is important is that sparse cursor
86736 ** the "op" parameter to findTerm when we are resolving equality constraints.
86737 ** ISNULL constraints will then not be used on the right table of a left
86794 ** itself is not freed. This routine is the inverse of whereClauseInit().
86819 ** 0 is returned if the new WhereTerm could not be added due to a memory
86865 ** operator specified in the op parameter. The WhereClause structure
86879 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
86880 pWC->op = (u8)op;
86882 if( pExpr->op!=op ){
86885 whereSplit(pWC, pExpr->pLeft, op);
86886 whereSplit(pWC, pExpr->pRight, op);
86897 ** iCursor is not in the set.
86942 if( p->op==TK_COLUMN ){
86983 static int allowedOp(int op){
86988 return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL;
86997 ** Commute a comparison operator. Expressions of the form "X op Y"
86998 ** are converted into "Y op X".
87002 ** the commutation. So "Y collate NOCASE op X" becomes
87003 ** "X collate NOCASE op Y". This is because any collation sequence on
87006 ** is not commuted.
87011 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
87018 if( pExpr->op>=TK_GT ){
87023 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
87024 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
87031 static u16 operatorMask(int op){
87033 assert( allowedOp(op) );
87034 if( op==TK_IN ){
87036 }else if( op==TK_ISNULL ){
87039 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
87040 c = (u16)(WO_EQ<<(op-TK_EQ));
87042 assert( op!=TK_ISNULL || c==WO_ISNULL );
87043 assert( op!=TK_IN || c==WO_IN );
87044 assert( op!=TK_EQ || c==WO_EQ );
87045 assert( op!=TK_LT || c==WO_LT );
87046 assert( op!=TK_LE || c==WO_LE );
87047 assert( op!=TK_GT || c==WO_GT );
87048 assert( op!=TK_GE || c==WO_GE );
87053 ** Search for a term in the WHERE clause that is of the form "X <op> <expr>"
87054 ** where X is a reference to the iColumn of table iCur and <op> is one of
87055 ** the WO_xx operator codes specified by the op parameter.
87056 ** Return a pointer to the term. Return 0 if not found.
87062 Bitmask notReady, /* RHS must not overlap with this mask */
87063 u32 op, /* Mask of WO_xx values describing operator */
87064 Index *pIdx /* Must be compatible with this index, if not NULL */
87069 op &= WO_ALL;
87074 && (pTerm->eOperator & op)!=0
87127 ** so and false if not.
87130 ** literal that does not begin with a wildcard.
87148 int op; /* Opcode of pRight */
87158 if( pLeft->op!=TK_COLUMN || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT ){
87179 op = pRight->op;
87180 if( op==TK_REGISTER ){
87181 op = pRight->op2;
87183 if( op==TK_VARIABLE ){
87190 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
87191 }else if( op==TK_STRING ){
87205 if( op==TK_VARIABLE ){
87238 ** If it is then return TRUE. If not, return FALSE.
87245 if( pExpr->op!=TK_FUNCTION ){
87255 if( pList->a[1].pExpr->op != TK_COLUMN ){
87317 ** "T.C <op> <expr>" where C is any column of table T and
87318 ** <op> is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN".
87326 ** This analysis does not consider whether or not the index exists; that
87332 ** always prefer case 1, so in that case we pretend that case 2 is not
87346 ** zero. This term is not useful for search.
87371 assert( pExpr->op==TK_OR );
87410 if( allowedOp(pAndTerm->pExpr->op) ){
87472 ** will be recorded in iCursor and iColumn. There might not be any
87474 ** and column is found but leave okToChngToIN false if not found.
87489 ** chngToIN set but t1 is not. This term will be either preceeded
87586 ** If the expression is of the form "<expr> <op> X" it gets commuted
87587 ** to the standard form of "X <op> <expr>".
87589 ** If the expression is of the form "X <op> Y" where both X and Y are
87591 ** term of the form "Y <op> X" is added to the WHERE clause and
87612 int op; /* Top-level operator. pExpr->op */
87623 op = pExpr->op;
87624 if( op==TK_IN ){
87631 }else if( op==TK_ISNULL ){
87640 extraRight = x-1; /* ON clause terms may not be used with an index
87647 if( allowedOp(op) && (pTerm->prereqRight & prereqLeft)==0 ){
87650 if( pLeft->op==TK_COLUMN ){
87653 pTerm->eOperator = operatorMask(op);
87655 if( pRight && pRight->op==TK_COLUMN ){
87682 pNew->eOperator = operatorMask(pDup->op);
87702 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
87728 else if( pExpr->op==TK_OR ){
87729 assert( pWC->op==TK_AND );
87746 if( pWC->op==TK_AND
87796 ** virtual tables. The native query optimizer does not attempt
87870 ** index do not need to satisfy this constraint.) The *pbRev value is
87915 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
87916 /* Can not use an index sort on anything that is not a column in the
87937 /* Term j of the ORDER BY clause does not match column i of the index */
87947 /* If an index column fails to match and is not constrained by ==
87998 ** The results need not be exact. This is only used for estimating
88024 sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n",
88028 p->aConstraint[i].op,
88074 Bitmask notReady, /* Mask of cursors that are not available */
88110 tempWC.op = TK_AND;
88188 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
88229 pIdxCons[j].op = (u8)pTerm->eOperator;
88261 ** Whether or not an error is returned, it is the responsibility of the
88320 Bitmask notReady, /* Mask of cursors that are not available */
88340 /* If the sqlite3_index_info structure has not been previously
88418 /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the
88563 assert( pExpr->op!=TK_VARIABLE );
88564 if( pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE ){
88586 ** If either of the upper or lower bound is not present, then NULL is passed in
88701 ** * Whether or not sorting must occur.
88703 ** * Whether or not there must be separate lookups in the
88721 Bitmask notReady, /* Mask of cursors that are not available */
88739 /* If the pSrc table is the right table of a LEFT JOIN then we may not
88741 ** because columns might end up being NULL if the table does not match -
88772 ** available. If not available, assume the table 1 million rows in size.
88840 ** external sort (i.e. scanning the index being evaluated will not
88850 ** two queries requires table b-tree lookups, but the first does not.
88924 /* If currently calculating the cost of using an index (not the IPK
88948 ** do not let the estimate exceed half the rows in the table.
89045 Bitmask notReady, /* Mask of cursors that are not available */
89065 ** Disable a term in the WHERE clause. Except, do not disable the term
89066 ** if it controls a LEFT OUTER JOIN and it did not originate in the ON
89076 ** in the ON clause. The term is disabled in (3) because it is not part
89077 ** of a LEFT OUTER JOIN. In (1), the term is not disabled.
89079 ** Disabling a term causes that term to not be tested in the inner loop
89164 if( pX->op==TK_EQ ){
89166 }else if( pX->op==TK_ISNULL ){
89175 assert( pX->op==TK_IN );
89220 ** of nEq including 0. If nEq==0, this routine is nearly a no-op.
89250 Bitmask notReady, /* Which parts of FROM have not yet been coded */
89339 int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
89411 pLevel->op = OP_VNext;
89437 pLevel->op = OP_Noop;
89475 sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1);
89490 if( pX->op==TK_LT || pX->op==TK_GT ){
89498 pLevel->op = bRev ? OP_Prev : OP_Next;
89569 int op; /* Instruction opcode */
89580 ** should not have a NULL value stored in 'x'. If column 'x' is
89656 op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
89657 assert( op!=0 );
89658 testcase( op==OP_Rewind );
89659 testcase( op==OP_Last );
89660 testcase( op==OP_SeekGt );
89661 testcase( op==OP_SeekGe );
89662 testcase( op==OP_SeekLe );
89663 testcase( op==OP_SeekLt );
89664 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
89695 op = aEndOp[(pRangeEnd || nEq) * (1 + bRev)];
89696 testcase( op==OP_Noop );
89697 testcase( op==OP_IdxGE );
89698 testcase( op==OP_IdxLT );
89699 if( op!=OP_Noop ){
89700 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
89705 ** of the table column that the inequality contrains is not NULL.
89730 pLevel->op = bRev ? OP_Prev : OP_Next;
89784 int untestedTerms = 0; /* Some terms not completely tested */
89793 pLevel->op = OP_Return;
89857 ** terms from the notReady table could not be tested and will
89884 pLevel->op = aStep[bRev];
90003 ** Note that the loops might not be nested in the order in which they
90077 Bitmask notReady; /* Cursors that are not yet positioned */
90155 ** the OR-to-IN transformation in exprAnalyzeOrTerm(). It is not helpful
90159 ** pTabList, not just the first nTabList tables. nTabList is normally
90184 ** add new virtual terms onto the end of the WHERE clause. We do not
90250 ** is not possible to determine this with a simple greedy algorithm.
90260 int doNotReorder; /* True if this table should not be reordered */
90313 ** used for the scan. If not, then query compilation has failed.
90402 int op = pWInfo->okOnePass ? OP_OpenWrite : OP_OpenRead;
90403 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
90443 ** is not used, its name is just '{}'. If no index is used
90518 if( pLevel->op!=OP_Noop ){
90519 sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
90545 if( pLevel->op==OP_Return ){
90664 int not; /* True if the NOT keyword is present */
90697 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
90698 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
90709 int op, /* The binary operation */
90713 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
90723 int op, /* The operator */
90727 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
90734 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
90736 if( db->mallocFailed==0 && pY->op==TK_NULL ){
90737 pA->op = (u8)op;
90748 int op, /* The operator */
90752 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
90783 ** original value of the token will not parse.
90802 ** YYERRORSYMBOL is the code number of the error symbol. If not
90845 /* Define the yytestcase() macro to be a no-op if is not already defined
90884 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
90885 ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
91380 ** but it does not parse, the type of the token is changed to ID and
92005 ** which appear on the RHS of the rule, but which are not used
92124 /* In SQLite, we never try to destroy a parser that was not successfully
92678 ** not set the value of its left-hand side nonterminal. Leaving the
92684 ** without this code, their parser segfaults. I'm not sure what there
92687 ** that it has not been previously stressed... (SQLite ticket #2172)
92994 yymsp[0].minor.yy3->op = (u8)yymsp[-1].minor.yy328;
93314 yygotominor.yy346.pExpr->op = TK_CONST_FUNC;
93331 {yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 0;}
93335 {yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 1;}
93349 if( yymsp[-2].minor.yy96.not ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93619 "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
93626 "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
93633 "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
93789 /* If we are not debugging and the reduce action popped at least
93946 ** The response to an error depends upon whether or not the
94000 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
94011 #else /* YYERRORSYMBOL is not defined */
94012 /* This is what we do if the grammar does not define ERROR:
94044 ** May you do good and not evil.
94092 ** returned. If the input is not a keyword, TK_ID is returned.
94109 ** or not a given identifier is really an SQL keyword. The same thing
94388 ** Ticket #1066. the SQL standard does not allow '$' in the
94625 /* Fall through into the next case if the '#' is not followed by
94811 /* If the pParse->declareVtab flag is set, do not delete any table
94845 ** May you do good and not evil.
94855 ** static links that do not use it.
94897 ** (0) INVALID We have not yet seen a non-whitespace character.
94939 ** is look for a semicolon that is not part of an string or comment.
94962 /* If triggers are not supported by this compile then the statement machine
95096 ** above, except that the parameter is required to be UTF-16 encoded, not
95130 ** May you do good and not evil.
95137 ** other files are for internal use by SQLite and should not be
95150 ** May you do good and not evil.
95182 ** May you do good and not evil.
95214 ** May you do good and not evil.
95252 ** If the following function pointer is not NULL and if
95274 ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
95278 ** This routine is a no-op except on its very first call for the process,
95287 ** calls to this routine should not block, of course. Otherwise the
95312 ** to sqlite3_initialize() should be a no-op. But the initialization
95313 ** must be complete. So isInit must not be set until the very end
95321 ** there is not much SQLite is going to be able to do.
95333 ** mutex must not require support from the malloc subsystem.
95356 /* If rc is not SQLITE_OK at this point, then either the malloc
95357 ** subsystem could not be initialized or the system failed to allocate
95426 ** Undo the effects of sqlite3_initialize(). Must not be called while
95429 ** routine is not threadsafe. But it is safe to invoke this routine
95431 ** when this routine is invoked, then this routine is a harmless no-op.
95460 ** database connections or memory allocations. This routine is not
95464 SQLITE_API int sqlite3_config(int op, ...){
95472 va_start(ap, op);
95473 switch( op ){
95571 /* The heap pointer is not NULL, then install one of the
95609 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
95675 SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
95678 va_start(ap, op);
95679 switch( op ){
95709 ** If the padFlag argument is not NULL then space padding at the end
95779 ** database handle object, it does not close any savepoints that may be open
95811 ** will not have called the xDisconnect() method on any virtual
95854 ** locks and does not require any further unlock-notify callbacks.
95903 ** So it needs to be freed here. Todo: Why not roll the temp schema into
95959 /* SQLITE_OK */ "not an error",
95985 /* SQLITE_NOTADB */ "file is encrypted or is not a database",
96157 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
96262 ** this routine is a no-op. If the function does not exist, then create
96434 int omitJournal, /* if TRUE then do not journal this file */
96463 ** open on an existing shared pager-cache, do not change the pager-cache
96589 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
96615 ** sqlite3_create_collation, and not generated by synthCollSeq(),
96677 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
96695 # error SQLITE_MAX_COLUMN must not exceed 32767
96708 ** A new lower limit does not shrink existing constructs.
96880 /* Register all built-in functions, but do not attempt to read the
97131 ** Test to see whether or not the database connection is in autocommit
97132 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
97159 ** no-op. It is retained for historical compatibility.
97235 ** 2. The table is not a view and the column name identified an
97309 SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
97331 rc = sqlite3OsFileControl(fd, op, pArg);
97343 SQLITE_API int sqlite3_test_control(int op, ...){
97347 va_start(ap, op);
97348 switch( op ){
97431 ** This action provides a run-time test to see whether or not
97456 ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
97467 ** // ALWAYS() and NEVER() are no-op pass-through macros
97514 ** number of keywords. Or if zWord is not a keyword, return 0.
97517 ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
97542 ** May you do good and not evil.
97552 /* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
97570 ** is not NULL. This variable may only accessed while the STATIC_MASTER
97586 ** 3) If the argument db is not NULL, then none of the entries in the
97614 ** db is not currently a part of the list, this function is a no-op.
97629 ** that it is not already a part of the list.
97727 ** to the user because it requires a lock that will not be available
97770 for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){
97874 ** May you do good and not evil.
97887 ** (in which case SQLITE_CORE is not defined), or
97899 ** bottom up in optimal fashion and are not updatable. Since trees
98156 ** May you do good and not evil.
98244 ** sqlite3_tokenizer.pModule variable should not be initialised by
98335 ** May you do good and not evil.
98354 ** code should not attempt to access or modify the fields of this structure
98471 ** from that used by SQLite, so the maximum length is 10, not 9.
98543 ** pending data, including hash table overhead, but not malloc overhead.
98602 int isNot; /* Phrase prefixed by unary not (-) operator */
98799 ** input does not begin with a quote character, then this routine
98800 ** is a no-op.
99174 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ
99191 if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH
99298 ** one level high (i.e. the root node is not also a leaf). If successful,
99303 ** It is possible that the returned leaf node does not contain the specified
99306 ** segment nodes (and never loads leaf nodes into memory), it is not possible
99415 ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
99418 ** The following block moves pEnd to point to the first byte that is not
99454 ** it is not possible to have a document with 2^31 terms.
99482 ** If parameter iCol is not 0, write an 0x01 byte followed by the value of
99486 ** returning (do not modify it if iCol==0). Return the total number of bytes
99940 /* The output buffer is not empty. Merge doclist aDoclist with the
100002 ** The code in this loop does not actually load any leaves into memory
100013 ** leaf). Do not bother inspecting any data in this case, just
100028 ** not reset here, then it may remain classified as an active statement
100128 ** last term in the phrase, and positions are not required in the
100435 ** Implementation of xBegin() method. This is a no-op.
100444 ** Implementation of xCommit() method. This is a no-op. The contents of
100915 ** May you do good and not evil.
100934 ** a) The new syntax supports parenthesis. The old does not.
100936 ** b) The new syntax supports the AND and NOT operators. The old does not.
100938 ** c) The old syntax supports the "-" token qualifier. This is not
100953 ** generator. This module does not use actually lemon, it uses a
101340 ** TODO: Strangely, it is not possible to associate a column specifier
101596 ** column to match against for tokens for which a column name is not explicitly
101837 ** May you do good and not evil.
101851 ** (in which case SQLITE_CORE is not defined), or
102144 ** The key is not copied in this instance. If a malloc fails, then
102218 ** May you do good and not evil.
102231 ** (in which case SQLITE_CORE is not defined), or
102450 ** is not 'w', 'x', or 'y'.
102471 ** Return TRUE if zFrom matches. Return FALSE if zFrom does not
102478 const char *zTo, /* ... change the ending to this (not reversed) */
102539 ** If the input word contains not digits but does characters not
102564 /* The use of a character not in [a-zA-Z] means that we fallback
102859 ** May you do good and not evil.
102873 ** (in which case SQLITE_CORE is not defined), or
102897 ** to the string <key-name>. If <pointer> is not specified, then
102901 ** Whether or not the <pointer> argument is specified, the value returned
103238 ** This function is used for testing only, it is not included in the
103354 ** May you do good and not evil.
103367 ** (in which case SQLITE_CORE is not defined), or
103580 ** May you do good and not evil.
103731 ** If argument apVal is not NULL, then it must point to an array with
103836 ** does not exist, return SQLITE_CORRUPT. If some other error (malloc, IO
104376 ** If arguments ppOffsetList and pnOffsetList are not NULL, then
104380 ** lists, not including the nul-terminator byte. For example:
104477 ** set of entries in the %_segments table has not yet been composed,
104670 ** 1) EOF is greater than not EOF.
104705 ** 1) EOF (end of doclist in this case) is greater than not EOF.
104887 ** and the static node buffer (p->nNodeSize bytes) is not large
104891 ** this is not expected to be a serious problem.
104930 /* If control flows to here, it was not possible to append zTerm to the
104934 ** Otherwise, the term is not added to the new node, it is left empty for
104988 ** Except, if pTree is a root node, do not write it to the database. Instead,
105273 ** Return SQLITE_OK if successful, or an SQLite error code if not.
105294 ** Return SQLITE_OK if successful, or an SQLite error code if not.
105363 ** a position list that may (or may not) feature multiple columns. This
105479 /* If there are zero segments, this function is a no-op. This scenario
105508 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
105512 ** of segment apSegment[0] is not a match, exit early.
105598 /* If there is a term specified to filter on, and this is not a prefix
105910 ** May you do good and not evil.
105944 /* It is not safe to call isspace(), tolower(), or isalnum() on
105961 int nUsed; /* Number bytes of z[] used, not counting \000 terminator */
106214 ** This function removes any entries that should not be present after
106226 ** is not near enough to an E).
106340 ** If the offsets have already been computed, this routine is a no-op.
107253 ** May you do good and not evil.
107325 /* Size of hash table Rtree.aHash. This hash table is not expected to
107422 int op; /* Constraining operation */
107426 /* Possible values for RtreeConstraint.op */
107607 ** indicating that node has not yet been assigned a node number. It is
107722 ** If there is not enough free space in pNode, return SQLITE_FULL.
107973 ** Return non-zero if the cursor does not currently point to a valid
107998 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
107999 || p->op==RTREE_GT || p->op==RTREE_EQ
108002 switch( p->op ){
108030 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
108031 || p->op==RTREE_GT || p->op==RTREE_EQ
108033 switch( p->op ){
108273 p->op = idxStr[ii*2];
108320 ** If strategy 1 or 3 is used, then idxStr is not meaningful. If strategy
108354 if( p->usable && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
108375 u8 op = 0;
108376 switch( p->op ){
108377 case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break;
108378 case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break;
108379 case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break;
108380 case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break;
108381 case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break;
108383 if( op ){
108384 /* Make sure this particular constraint has not been used before.
108401 opmsk = compatible[op & 7];
108404 op = 0;
108409 if( op ){
108411 zIdxStr[iIdx++] = op;
109377 /* If the node is not the tree root and now has less than the minimum
109602 /* If azData[0] is not an SQL NULL value, it is the rowid of a
110114 ** May you do good and not evil.
110393 ** pointer. This is not really necessary, but it is tidier than
110613 ** May you do good and not evil.