Lines Matching refs:then
228 ** or constant definition does not appear in this file, then it is
419 ** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
496 ** statements or unfinished sqlite3_backup objects then sqlite3_close()
499 ** and/or unfinished sqlite3_backups, then the database connection becomes
512 ** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation
550 ** sqlite3_exec() is not NULL, then it is invoked for each result row
554 ** is NULL, then no callback is ever invoked and result rows are
558 ** sqlite3_exec(), then execution of the current statement stops and
560 ** is not NULL then any error message is written into memory obtained
566 ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
577 ** result row is NULL then the corresponding string pointer for the
585 ** SQL comments, then no SQL statements are evaluated and the database
768 ** first then the size of the file is extended, never the other
865 ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
934 ** first then the size of the file is extended, never the other
1050 ** integer is the delay. If either integer is negative, then the setting
1067 ** WAL mode. If the integer is -1, then it is overwritten with the current
1077 ** mode. If the integer is -1, then it is overwritten with the current
1110 ** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal
1112 ** file control returns [SQLITE_OK], then the parser assumes that the
1131 ** the array as the only argument. If it returns non-zero, then the operation
1282 ** If the zFilename parameter to xOpen is a NULL pointer then xOpen
1289 ** or [sqlite3_open16()] is used, then flags includes at least
1291 ** If xOpen() opens a file read-only then it sets *pOutFlags to
1538 ** compile-time option, then the automatic calls to sqlite3_initialize()
1592 ** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
1604 ** then this routine returns a non-zero [error code].
1683 ** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
1722 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1737 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1753 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1805 ** scratch memory beyond what is provided by this configuration option, then
1836 ** page cache memory is needed beyond what is provided by this option, then
1850 ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
1853 ** memory pointer is not NULL then the alternative memory
1867 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1880 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1928 ** If non-zero, then URI handling is globally enabled. If the parameter is zero,
1929 ** then URI handling is globally disabled.)^ ^If URI handling is globally
1966 ** fourth parameter. If the fourth parameter is 0, then the database connection
1969 ** fourth parameter is 1, then the SQL statement that the third parameter
1970 ** points to has just been executed. Or, if the fourth parameter is 2, then
1987 ** ^If either argument to this option is negative, then that argument is
2125 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
2134 ** then sqlite3_last_insert_rowid(D) returns zero.
2137 ** method, then this routine will return the [rowid] of the inserted
2162 ** then the value returned by [sqlite3_last_insert_rowid()] is
2216 ** while [sqlite3_changes()] is running then the value returned
2240 ** while [sqlite3_total_changes()] is running then the value
2261 ** sqlite3_interrupt() is called, then it might not have an opportunity
2266 ** that is inside an explicit transaction, then the entire transaction
2281 ** is running then bad things will likely happen.
2301 ** memory allocation fails, then SQLITE_NOMEM is returned.
2307 ** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
2309 ** then the return value from sqlite3_complete16() will be non-zero
2334 ** ^If the busy callback is NULL, then [SQLITE_BUSY]
2336 ** is not NULL, then the callback might be invoked with two arguments.
2342 ** busy callback returns 0, then no additional attempts are made to
2345 ** ^If the callback returns non-zero, then another attempt
2445 ** in an array names azResult. Then azResult holds this content:
2609 ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
2630 ** is a NULL pointer then its behavior is identical to calling
2633 ** negative then the behavior is exactly the same as calling
2637 ** ^If M is the size of the prior allocation, then min(N,M) bytes
2640 ** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the
2648 ** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then
2651 ** of bytes requested when X was allocated. ^If X is a NULL pointer then
2654 ** valid memory allocation that has now been freed, then the behavior
2731 ** call had N less than one or a NULL pointer for P, then the PRNG is
2735 ** non-NULL P then the pseudo-randomness is generated
2758 ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
2775 ** and the callback returns [SQLITE_IGNORE] then the
2782 ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
2792 ** database. An authorizer could then be put in place while the
2944 ** invocations of the callback X. ^If N is less than one then the progress
2976 ** object.)^ ^(If the database is opened (and/or created) successfully, then
3017 ** then the behavior is undefined.
3019 ** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
3022 ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
3034 ** a NULL pointer then the default [sqlite3_vfs] object is used.
3036 ** ^If the filename is ":memory:", then a private, temporary in-memory database
3044 ** ^If the filename is an empty string, then a private, temporary
3051 ** begins with "file:", then the filename is interpreted as a URI. ^URI
3062 ** authority, then it must be either an empty string or the string
3069 ** then it is interpreted as an absolute path. ^If the path does not begin
3071 ** then the path is interpreted as a relative path.
3087 ** present, then the VFS specified by the option takes precedence over
3093 ** ^If "ro" is specified, then the database is opened for read-only
3096 ** "rw", then the database is opened for read-write (but not create)
3100 ** set to "memory" then a pure [in-memory database] that never reads
3217 ** P is the name of the query parameter, then
3221 ** has no explicit value, then sqlite3_uri_parameter(F,P) returns
3233 ** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0).
3237 ** exist. If the value of P is something other than an integer, then
3240 ** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
3243 ** VFS method, then the behavior of this routine is undefined and probably
3256 ** [database connection] D failed, then the sqlite3_errcode(D) interface
3260 ** then the return value from sqlite3_errcode() is undefined.
3317 ** <li> Reset the prepared statement using [sqlite3_reset()] then go back
3453 ** ^If the nByte argument is negative, then zSql is read up to the
3454 ** first zero terminator. ^If nByte is positive, then it is the
3455 ** number of bytes read from zSql. ^If nByte is zero, then no prepared
3457 ** If the caller knows that the supplied string is nul-terminated, then
3462 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3470 ** string or a comment) then *ppStmt is set to NULL.
3506 ** then the statement will be automatically recompiled, as if there had been
3566 ** calls [sqlite3_exec()], then the following SQL statement would
3598 ** object, then the behavior is undefined and probably undesirable.
3632 ** then there is no distinction between protected and unprotected
3702 ** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter
3709 ** is negative, then the length of the string is
3711 ** If the fourth parameter to sqlite3_bind_blob() is negative, then
3714 ** or sqlite3_bind_text16() or sqlite3_bind_text64() then
3718 ** the value of the fourth parameter then the resulting string value will
3727 ** the special value [SQLITE_STATIC], then SQLite assumes that the
3729 ** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
3738 ** from the encoding specified by the sixth parameter, then the behavior
3752 ** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_()
3823 ** nameless, then NULL is returned. ^The returned string is
3892 ** (for example during a conversion from UTF-8 to UTF-16) then a
3897 ** then the name of the column is unspecified and may change from
3929 ** subquery and is not a column value, then all of these functions return
3941 ** prepared statement and column at the same time then the results are
3947 ** at the same time then the results are undefined.
3963 ** expression or subquery) then the declared type of the table
3965 ** expression or subquery, then a NULL pointer is returned.
4012 ** or occurs outside of an explicit transaction, then you can retry the
4014 ** explicit transaction then you should rollback the transaction before
4022 ** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
4064 ** then the more specific [error codes] are returned directly
4077 ** interfaces) then sqlite3_data_count(P) returns 0.
4146 ** are pending, then the results are undefined.
4158 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
4160 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
4161 ** the string to UTF-8 and then returns the number of bytes.
4162 ** ^If the result is a numeric value then sqlite3_column_bytes() uses
4165 ** ^If the result is NULL, then sqlite3_column_bytes() returns zero.
4167 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
4169 ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
4170 ** the string to UTF-16 and then returns the number of bytes.
4171 ** ^If the result is a numeric value then sqlite3_column_bytes16() uses
4174 ** ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
4259 ** into the desired format, then invoke sqlite3_column_bytes() or
4295 ** or if the statement is never been evaluated, then sqlite3_finalize() returns
4296 ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
4333 ** then [sqlite3_reset(S)] returns [SQLITE_OK].
4336 ** [prepared statement] S indicated an error, then
4361 ** connection then application-defined SQL functions must be added
4373 ** aggregate takes. ^If this parameter is -1, then the SQL function or
4376 ** parameter is less than -1 or greater than 127 then the behavior is
4413 ** then it is destructor for the application data pointer.
4551 ** then the conversion is performed. Otherwise no conversion occurs.
4604 ** then sqlite3_value_free(V) is a harmless no-op.
4622 ** called once for each invocation of the xStep callback and then one
4692 ** Then as long as the pattern string remains the same,
4788 ** or sqlite3_result_error16() is negative then SQLite takes as the error
4791 ** sqlite3_result_error16() is non-negative then SQLite takes that many
4830 ** is negative, then SQLite takes result text from the 2nd parameter
4833 ** is non-negative, then as many bytes (not characters) of the text
4835 ** function result. If the 3rd parameter is non-negative, then it
4839 ** parameter, then the resulting string will contain embedded NULs and the
4842 ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
4846 ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
4852 ** then SQLite makes a copy of the result into space obtained from
4941 ** ^If the xCallback argument is NULL then the collating function is
4952 ** to the same collation name (using different eTextRep values) then all
4958 ** <li> If A==B then B==A.
4959 ** <li> If A==B and B==C then A==C.
4960 ** <li> If A<B THEN B>A.
4961 ** <li> If A<B and B<C then A<C.
4965 ** collating function is registered and used, then the behavior of SQLite
5019 ** then it is passed the names of undefined collation sequences as strings
5109 ** millisecond time resolution, then the time will be rounded up to
5116 ** all, then the behavior of sqlite3_sleep() may deviate from the description
5125 ** the name of a folder (a.k.a. directory), then all temporary files
5128 ** is a NULL pointer, then SQLite performs a search for an appropriate
5183 ** the name of a folder (a.k.a. directory), then all database files
5187 ** pointer, then SQLite assumes that all database files specified
5229 ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
5235 ** connection while this routine is running, then the return value
5260 ** connection D, or if database N is a temporary or in-memory database, then
5286 ** then this interface returns a pointer to the first prepared statement
5310 ** then the commit is converted into a rollback.
5331 ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
5483 ** then no change is made to the soft heap limit. Hence, the current
5487 ** ^If the argument N is zero then the soft heap limit is disabled.
5543 ** NULL pointer, then this routine simply checks for the existance of the
5550 ** table or NULL.)^ ^If it is NULL, then all attached databases are searched
5581 ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
5583 ** [INTEGER PRIMARY KEY] column, then the outputs
5620 ** So for example, if "samplelib" cannot be loaded, then names like
5633 ** ^If an error occurs and pzErrMsg is not 0, then the
5827 ** about what parameters to pass to xFilter. ^If argvIndex>0 then
5830 ** is true, then the constraint is assumed to be fully handled by the
5856 ** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then
5859 ** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback
6086 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
6119 ** then the BLOB handle is marked as "expired".
6299 ** ^If zVfsName is NULL then the default VFS is returned.
6308 ** then the behavior is undefined.
6344 ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
6395 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
6427 ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
6536 ** If the argument to sqlite3_mutex_held() is a NULL pointer then
6584 ** ^If the [threading mode] is Single-thread or Multi-thread then this
6613 ** open database file, then SQLITE_ERROR is returned. ^This error
6688 ** resetFlag is true, then the highest record value is reset after
6699 ** be represented by a 32-bit integer, then the values returned by
6821 ** the resetFlg is true, then the highest instantaneous value is
6954 ** ^If the resetFlg is true, then the counter is reset to zero after this
6994 ** then the value returned by this statement status code is undefined.
7064 ** ^(If the xInit() method is NULL, then the
7131 ** If the requested page is already in the page cache, then the page cache
7133 ** intact. If the requested page is not already in the cache, then the
7155 ** then the page must be evicted from the cache.
7157 ** zero, then the page may be discarded or retained at the discretion of
7290 ** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
7308 ** are still more pages to be copied, then the function returns [SQLITE_OK].
7310 ** from source to destination, then it returns [SQLITE_DONE].
7312 ** then an [error code] is returned. ^As well as [SQLITE_OK] and
7326 ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
7329 ** busy-handler returns non-zero before the lock is available, then
7334 ** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
7337 ** [SQLITE_READONLY] is returned, then
7353 ** used by the backup operation, then the backup will be automatically
7356 ** by the backup operation, then the backup database is automatically
7366 ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
7375 ** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
7402 ** connections, then the source database connection may be used concurrently
7471 ** If this happens, then the specified callback is invoked immediately,
7476 ** a read-lock on the same table, then SQLite arbitrarily selects one of
7482 ** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
7483 ** called with a NULL pointer as its second argument, then any existing
7507 ** same callback function, then instead of invoking the callback function
7517 ** action (a reasonable assumption), then using this API may cause the
7520 ** Y is waiting on connection X's transaction, then neither connection
7525 ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
7545 ** invoked immediately. If the application then re-attempts the "DROP TABLE"
7549 ** by an sqlite3_step() call. ^(If there is a blocking connection, then the
7695 ** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()]
7715 ** readers or writers to finish, then sync the database file if all frames
7725 ** snapshot. ^It then checkpoints all frames in the log file and syncs the
7744 ** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in
7747 ** NULL,then *pnCkpt is set to the total number of checkpointed frames in the
7770 ** ^If parameter zDb is NULL or points to a zero length string, then the
7813 #define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */
7825 ** xCreate virtual table method then the behavior is undefined.
7844 ** where X is an integer. If X is zero, then the [virtual table] whose
7847 ** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire
7852 ** If X is non-zero, then the virtual table implementation guarantees
7929 ** then this value will approximate the quotient NVISIT/NLOOP and the
8284 ** "auxiliary data". The pointer may then be retrieved by the current or any
8290 ** more than once for a single FTS query, then all invocations share a
8294 ** invoked, then it is replaced by the new pointer. If an xDelete callback
8312 ** If the bClear argument is non-zero, then the auxiliary data is cleared
8464 ** If an xToken() callback returns any value other than SQLITE_OK, then
8489 ** "first" and "place". If the user then queries for '1st + place',
8496 ** FTS5 then queries the index for each synonym individually. For
8551 ** token "first" is subsituted for "1st" by the tokenizer, then the query:
8816 ** with a page-size of 65536 bytes crashes, then an instance of SQLite
9015 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
9035 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
9700 ** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
9755 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
10227 ** If we are not using shared cache, then there is no need to
10573 #define OP_IfPos 138 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
10574 #define OP_SetIfNotPos 139 /* synopsis: if r[P1]<=0 then r[P2]=P3 */
10575 #define OP_IfNotZero 140 /* synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2 */
10744 ** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and
10745 ** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch()
11137 ** If no global maximum is configured, then the system attempts to limit
11260 /* If the SET_FULLSYNC macro is not defined above, then make it
11283 ** 2006-10-31: The default prefix used to be "sqlite_". But then
11286 ** This annoyed many windows users. Those users would then do a
11956 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
12132 ** If the database schema is shared, then there is one instance of this
12141 ** then be used by the virtual table implementation to access real tables
12159 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
12328 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
12344 ** are nField slots for the columns of an index then one extra slot
12488 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
12501 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
12568 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
12569 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
12571 ** then Expr.token contains the name of the function.
12580 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
12587 ** expression is used as a result in an aggregate SELECT, then the
12592 ** character '?' in the original SQL) then the Expr.iTable holds the index
12595 ** If the expression is a subquery then Expr.iColumn holds an integer
12597 ** subquery gives a constant result, then iTable is -1. If the subquery
12599 ** then iTable is the address of a subroutine that computes the subquery.
12602 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
12614 ** an Expr object is truncated. When EP_Reduced is set, then all
12629 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
12641 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
12742 ** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
12790 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
12829 ** now be identified by a database name, a dot, then the table name: ID.ID.
13050 ** in register pDest->iSDParm then abandon the rest
13398 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
13401 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
13404 * statement, then this stores the column-names to be
14120 ** macros handle the common case without a procedure call, but then call
14454 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
14600 ** If x is a lower-case ASCII character, then its upper-case equivalent
15448 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
15451 ** If the MEM_Str flag is set then Mem.z points at a string representation.
15454 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
16511 ** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this
16575 ** range, do the calculation, then map the year back.
16632 ** is in a system call (i.e. localtime()), then an error message is written
16839 ** then assume a default value of "now" for argv[0].
18264 /* If memory status is enabled, then the malloc.c wrapper will already
18664 ** freelist. If the previous chunk is checked out, then
18915 ** chunk before invoking this routine, then must unlink the (possibly
19004 ** Then try again to satisfy the allocation by carving a piece off
19029 /* If none of the above worked, then we fail. */
19324 ** then the two blocks are coalesced into the single larger block.
19541 ** block. If not, then split a block of the next larger power of
19907 /* If the xMutexAlloc method has not been set, then the user did not
20068 ** If compiled with SQLITE_DEBUG, then additional logic is inserted
20251 ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
20325 ** not an atomic operation, then these routines might delivery
20328 ** told that HPUX is not such a platform. If so, then these routines
20407 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
20508 /* If recursive mutexes are not available, then we have to grow
20516 ** are not met, then the mutexes will fail and problems will result.
20551 /* If recursive mutexes are not available, then we have to grow
20559 ** are not met, then the mutexes will fail and problems will result.
20816 ** If we compile with the SQLITE_TEST macro set, then the following block
21148 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
21622 ** First make sure the memory subsystem is initialized, then do the
21934 ** failure on the same database connection) then always return 0.
22024 ** Attempt to reallocate p. If the reallocation fails, then free p
22097 ** If an OOM as occurred, then the connection error-code (the value
22218 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
22224 ** Return the ascii code for the leading digit of *val, then
22600 ** If the field type is etGENERIC, then convert to either etEXP
22916 then do the append.
22996 ** n then no memory allocations ever occur.
22997 ** mx: Maximum number of bytes to accumulate. If mx==0 then no memory
23553 /* If the opcode is TK_TRIGGER, then the expression is a reference
24189 ** 0xd800 and 0xe000 then it is rendered as 0xfffd.
24269 /* If the translation is between UTF-16 little and big endian, then
24772 ** input does not begin with a quote character, then this routine
25078 ** integer, then write that value into *pNum and return 0.
25086 ** then return 1.
25196 ** If zNum represents an integer that will fit in 32-bits, then set
25516 ** integer, then set *v to 0xffffffff.
25871 ** three characters, then shorten the suffix on z[] to be the last three
25874 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
26042 /* Link pNew element into the hash table pH. If pEntry!=0 then also
26201 ** If no element exists with a matching key, then a new
26204 ** If another element already exists with the same key, then the
26206 ** The key is not copied in this instance. If a malloc fails, then
26209 ** If the "data" parameter to this function is NULL, then the
26395 /* 138 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
26396 /* 139 */ "SetIfNotPos" OpHelp("if r[P1]<=0 then r[P2]=P3"),
26397 /* 140 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]-=P3, goto P2"),
26837 ** If we compile with the SQLITE_TEST macro set, then the following block
27157 ** then return the name of the first system call. Return NULL if zName
27189 ** If the file creation mode "m" is 0 then set it to the default for
27191 ** 0644) as modified by the system umask. If m is not 0, then
27198 ** transaction crashes and leaves behind hot journals, then any
27596 ** one is a hard or symbolic link to the other) then if you set
27597 ** an exclusive lock on fd1, then try to get an exclusive lock
27745 /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
28056 ** If the pFile was opened read/write from unix-excl, then the only lock
28209 ** has a SHARED or RESERVED lock, then increment reference counts and
28246 /* If control gets to this point, then actually go ahead and make
28365 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
28366 ** the byte range is divided into 2 parts and the first part is unlocked then
28367 ** set to a read lock, then the other part is simply unlocked. This works
28756 /* If we have any lock, then the lock file already exists. All we have
29359 /* if we failed to get the lock then someone else must have it */
29444 ** has a SHARED or RESERVED lock, then increment reference counts and
29473 /* If control gets to this point, then actually go ahead and make
29709 ** is available. If you don't compile for a mac, then the "unix-afp"
29750 ** Seek to the offset passed as the second argument, then read cnt
29753 ** NB: If you define USE_PREAD or USE_PREAD64, then it might also
29869 ** absolute offset iOff, then attempt to write nBuf bytes of data from
29914 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
29952 ** normal database file) then record the fact that the database
30022 ** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC
30091 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
30176 ** If dataOnly==0 then both the file itself and its metadata (file
30177 ** size, access time, etc) are synced. If dataOnly!=0 then only the
30349 ** within the extended region. Then, if required, a single byte
30393 ** If *pArg is initially negative then this is a query. Set *pArg to
30396 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
30591 ** then it isn't valid.*/
30857 ** is "/home/user1/config.db" then the file that is created and mmapped
30862 ** from the database file is used, then differing access permissions
30876 ** file are currently open, in this process or in other processes, then
31023 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
31028 ** this call as described above, then it is mapped into this processes
31258 /* Get the exclusive locks at the system level. Then if successful
31294 ** If there is no shared memory associated with the connection then this
31325 /* If pShmNode->nRef has reached 0, then close the underlying
31458 ** If parameter nByte is non-negative, then it is the requested size of
31459 ** the mapping to create. Otherwise, if nByte is less than zero, then the
31533 ** If the third argument is non-NULL, then this function releases a
31538 ** Or, if the third argument is NULL, then this function is being called
31547 /* If p==0 (unmap the entire file) then there must be no outstanding
31549 ** then there must be at least one outstanding. */
31757 ** for the database file "filePath". It then returns the sqlite3_io_methods
31823 ** locking works. If it does, then that is what is used. If it does not
31824 ** work, then fallback to named semaphore locking.
31952 ** descriptors on this file, then no malloc would be required by
31957 ** If scenario (a) caused the error then things are not so safe. The
32150 ** If a suitable file descriptor is found, then it is returned. If no
32197 ** to create new files with. If no error occurs, then SQLITE_OK is returned
32205 ** But if the file being opened is a WAL or regular journal file, then
32211 ** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the
32339 ** (b) if CREATE is set, then READWRITE must also be set, and
32340 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
32341 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
32715 ** (That assignment requires a cast.) Then we call the function that
32719 ** you really cannot cast a function pointer into void*. But then, on the
32986 ** host ID and/or proxy path, then the lock is escalated to an exclusive
33164 ** the parent directories and then try again.
33281 ** Takes an open conch file, copies the contents to a new path and then moves
33644 ** If pFile holds a lock on a conch file, then release that lock.
33810 ** (c) the file system is read-only, then enable no-locking access.
33842 ** switch the locking context and pMethod then return.
33891 ** switching proxy locking mode off then it will need to fail if
34050 /* restore the original locking context and pMethod then close it */
34357 ** If we compile with the SQLITE_TEST macro set, then the following block
35551 ** then return the name of the first system call. Return NULL if zName
36498 /* If shared memory could not be created, then close the mutex and fail */
36599 /* If no pending lock has been acquired, then acquire it */
37182 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
37500 /* If we are holding a PENDING lock that ought to be released, then
37507 /* Update the state of the lock has held in the file descriptor then
37562 ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
37599 ** If *pArg is initially negative then this is a query. Set *pArg to
37602 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
37973 ** file are currently open, in this process or in other processes, then
38112 /* If pShmNode->nRef has reached 0, then close the underlying
38213 /* Get the exclusive locks at the system level. Then if successful
38256 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
38261 ** this call as described above, then it is mapped into this processes
38445 ** If parameter nByte is non-negative, then it is the requested size of
38446 ** the mapping to create. Otherwise, if nByte is less than zero, then the
38584 ** If the third argument is non-NULL, then this function releases a
38589 ** Or, if the third argument is NULL, then this function is being called
38597 /* If p==0 (unmap the entire file) then there must be no outstanding
38599 ** then there must be at least one outstanding. */
38612 ** file while a mapping is held, then the following winUnmapfile() call
39040 ** (b) if CREATE is set, then READWRITE must also be set, and
39041 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
39042 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
39919 ** then it is not necessary to include the nul-terminator character
40110 ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
40113 ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
40158 ** i is out of range, then return false.
40220 /* completely fill the hash, then just add it without */
40330 ** Then the following macros can be used to set, clear, or test
40564 /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the
40568 /* IMPLEMENTATION-OF: R-61436-13639 If the argument N is negative, then
40582 /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
40660 ** If the createFlag is 0, then NULL is always returned if the page
40661 ** is not already in the cache. If createFlag is 1, then a new page
40702 ** size limit has been reached, then this routine can be invoked to
40704 ** callback to spill dirty pages to the journal. It will then try to
40805 ** reference count drops to 0, then it is made eligible for recycling.
40916 ** function is 0, then the data area associated with page 1 is zeroed, but
41134 ** If the default page cache implementation is overridden, then neither of
41160 ** If SQLITE_PCACHE_SEPARATE_HEADER is defined, then the extension is obtained
41188 ** If N is positive, then N pages worth of memory are allocated using a single
41190 ** Or if N is negative, then -1024*N bytes of memory are allocated and used
41607 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
41614 ** under memory pressure, then again it is desirable to avoid
41672 ** LRU list, then this function is a no-op.
42039 ** 3. If createFlag is 1, and the page is not already in the cache, then
42063 ** then attempt to recycle a page from the LRU list. If it is the right
42086 /* Step 2: If the page was found in the hash table, then return it.
42401 ** two TESTs where the TESTs have the same batch nubmer, then the
42683 ** list contains too few elements, then construct an incomplete tree
42803 ** on pRowSet->pEntry, then sort those entries into the forest at
43005 ** the last call, then return 0.
43081 ** (6) If a master journal file is used, then all writes to the database file
43210 ** * If the database is a WAL database, then the WAL connection is open.
43330 ** layer then attempts a rollback operation. If the error condition
43433 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
43447 ** the savepoint is active, then iHdrOffset is set to the byte offset
43559 ** This is a boolean variable. If true, then any required sub-journal
43560 ** is opened as an in-memory journal file. If false, then in-memory
43602 ** to measure the database file on disk, and then truncates it if required.
43748 ** file after power is restored. If an attempt is then made
44154 ** then the value returned is the size of the journal file when it
44182 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
44235 ** nul-terminator), then this is handled as if no master journal name
44239 ** file, then it is copied into the buffer pointed to by zMaster. A
44276 /* If the checksum doesn't add up, then one or more of the disk sectors
44322 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
44329 ** journal file in bytes is larger than this value, then truncate the
44460 ** journal header consumes to the journal file here. Then increment the
44581 ** invalid, then the process that wrote the journal-header must have
44597 ** created by a process other than this one, then this routine
44675 /* If the pager is in peristent-journal mode, then the physical
44785 /* If the operating system support deletion of open files, then
44855 ** the persistent error occurred, then the rollback journal may need
44889 ** If the journal file is open, then it is "finalized". Once a journal
44922 ** database then the IO error code is returned to the user. If the
44923 ** operation to finalize the journal file fails, then the code still
44925 ** unlock operation fails as well, then the first error code related
44942 ** lock switches back to locking_mode=normal and then executes a
45064 ** malloc error occurs during a rollback, then this will itself cause
45151 ** is greater than the current value of Pager.dbSize, then playback is
45154 ** If pDone is not NULL, then it is a record of pages that have already
45156 ** (if the corresponding pDone bit is set) then skip the playback.
45161 ** and played back, then SQLITE_OK is returned. If an IO error occurs
45163 ** to the database file, then the IO error code is returned. If data
45174 ** If this is a savepoint rollback, then memory may have to be dynamically
45244 ** rollback, then don't bother to play it back again.
45257 /* If the pager is in CACHEMOD state, then there must be a copy of this
45262 ** and a page is moved during an incremental vacuum then the page may
45264 ** during a Movepage() call, then the page may not be in the cache
45268 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
45269 ** pager cache if it exists and the main file. The page is then marked
45277 ** then changed again within the statement. When rolling back such a
45333 ** if the page is on the free-list at the start of the transaction, then
45334 ** populated, then moved using sqlite3PagerMovepage().
45338 ** and if the pager requires a journal-sync, then mark the page as
45364 ** journal file, then its content must be as they were when the
45371 ** unsynced portion of the main journal file, then it is not safe
45377 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
45387 /* If this was page 1, then restore the value of Pager.dbFileVers.
45541 ** If the file on disk is currently larger than nPage pages, then use the VFS
45614 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
45647 ** in the journal. If this value is 0xffffffff, then compute the
45681 ** journal file then all pages up to the first corrupted page are rolled
45683 ** is then deleted and SQLITE_OK returned, just as if no corruption had
45719 ** present on disk, then the journal is not hot and does not need to be
45747 ** it is corrupted, then a process must have failed while writing it.
45758 /* If nRec is 0xffffffff, then this journal was created by a process
45769 ** process and if this is the final header in the journal, then it means
45849 ** before the transaction was committed, then the change-counter
45851 ** mode, then subsequent transactions performed by the connection will not
45898 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
45901 ** If an IO error occurs, then the IO error is returned to the caller.
46259 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
46265 ** being rolled back), then the rollback consists of up to three stages,
46273 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
46277 ** * Pages are then played back from the sub-journal file, starting
46286 ** If pSavepoint is NULL, then pages are only played back from the main
46461 ** single disk sector is atomic, then this mode provides
46579 ** retried. If it returns zero, then the SQLITE_BUSY error is
46616 ** then the pager object page size is set to *pPageSize.
46618 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
46626 ** then *pPageSize is set to the old, retained page size before returning.
46774 ** However, if the file is between 1 and <page-size> bytes in size, then
46860 ** then continue writing to the database.
46881 ** syncs the journal file to disk, then sets pPager->journalHdr to the
47011 ** If this is not done, then an unsynced portion of the open journal
47067 ** If the Pager.noSync flag is set, then this function is a no-op.
47075 ** then the nRec field of the most recently written journal header
47078 ** mode, then the journal file is synced before this field is updated.
47080 ** * If the device does not support the SEQUENTIAL property, then
47095 ** error is encountered, then the IO error code is returned to the caller.
47118 ** mode, then the journal file may at this point actually be larger
47124 ** transaction), then SQLite may become confused when doing the
47126 ** of this connections data, then proceed to rolling back the old,
47130 ** a valid header following Pager.journalOff, then write a 0x00
47232 ** is updated accordingly. If page 1 is written out, then the value cached
47415 ** made clean for some other reason, but no error occurs, then SQLITE_OK
47491 ** If zFilename is NULL then a randomly-named temporary file is created
47493 ** automatically when they are closed. If zFilename is ":memory:" then
47856 ** does not exist, then the journal file is not really hot. In this
47890 ** call above, but then delete the journal and drop the lock before
47921 ** If there is, then we consider this journal to be hot. If not,
47943 ** This might be a false positive. But if it is, then the
47968 ** on the database file), then an attempt is made to obtain a
47978 ** then an attempt is made to clear the error state by discarding
48011 ** database file, then it either needs to be played back or deleted.
48099 ** the file. If the unlock attempt fails, then Pager.eLock must be
48123 /* The shared-lock has just been acquired then check to
48159 ** may have truncated the database file and then extended it back
48227 ** already in the cache when this function is called, then the extra
48232 ** requested page is not already stored in the cache, then no
48245 ** If noContent is true, then the data returned is zeroed instead of
48460 ** If the number of references to the page drop to zero, then the
48492 ** then this function just writes a journal header to the start of the
48578 ** If the exFlag argument is false, then acquire at least a RESERVED
48579 ** lock on the database file. If exFlag is true, then acquire at least
48583 ** If the subjInMemory argument is non-zero, then any sub-journal opened
48587 ** sub-journal. If the subjInMemory argument is zero, then any required
48621 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
48681 ** then corruption may follow.
48739 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
48755 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
48785 ** then write the page into the statement journal.
48868 ** starting at pg1, then it needs to be set for all of them. Because
48966 ** If the isDirectMode flag is zero, then this is done by calling
48967 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
48973 ** if isDirect is non-zero, then the database file is updated directly
48986 ** atomic-write optimization is enabled in this build, then isDirect
49120 ** If the final parameter - noSync - is true, then the database file itself
49184 ** If the optimization was not enabled at compile time, then the
49188 ** to make sure the journal file has actually been created, then call
49193 ** then call pager_incr_changecounter() to update the change-counter
49210 ** to include the updated change counter and then write page 1
49228 ** or if zMaster is NULL (no master journal), then this call is a no-op.
49256 ** image was extended as part of the current transaction and then the
49314 ** using persistent journals, then this function is a no-op.
49339 ** If a write transaction is open, then all changes made within the
49362 ** WAL files. The WAL transaction is then closed.
49499 ** currently less than nSavepoints open, then open one or more savepoints
49501 ** equal to nSavepoint, then this function is a no-op.
49504 ** occurs while opening the sub-journal file, then an IO error code is
49570 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
49571 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
49578 ** (Pager.nSavepoint-1), then this function is a no-op.
49580 ** If a negative value is passed to this function, then the current
49588 ** then savepoint iSavepoint is also destroyed.
49605 ** operation. Store this value in nNew. Then free resources associated
49644 ** Except, if the pager is in-memory only, then return an empty string if
49747 ** If the fourth argument, isCommit, is non-zero, then this page is being
49776 ** savepoint, then save the current contents of the page into the
49780 ** <journal page X, then modify it in memory>
49851 /* If needSyncPgno is non-zero, then the journal file needs to be
49914 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
50009 ** not possible, then that is not a problem. Deleting the journal file
50328 ** WAL can fill up with frames and then be checkpointed and then new
50389 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
50390 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
50403 ** first checks the WAL to see if it contains page P. If so, then the
50407 ** frame or are followed by a commit frame, then page P is read from
50502 ** Then start scanning entries of the hash table, starting with iKey
50510 ** no hash slot such that aHash[i]==p) then page P is not in the
50567 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
50629 ** holds read-lock K, then the value in aReadMark[K] is no greater than
50649 ** in the WAL has been backfilled into the database) then new readers
50657 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
50691 ** If the LSB is set, then the checksums for each frame within the WAL
50817 ** then an SQLite error code is returned and *ppPage is set to 0.
51300 /* If the entry in aPgno[] is already set, then the previous writer
51637 ** number larger than *piPage, then return 1.
51906 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
52129 ** entire wal file has been copied into the database file, then block
52264 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
52284 ** When reading, read [0] first then [1]. Writes are in the reverse order.
52406 ** checkpointed. If useWal==0 then this routine calls walIndexReadHdr()
52431 ** Or if pWal->readLock==0, then the reader will ignore the WAL
52433 ** If the useWal parameter is 1 then the WAL will never be ignored and
52485 ** then convert BUSY errors to WAL_RETRY. If recovery is known to
52596 ** happened, then reading the database with the current value of
52615 ** frame pWal->hdr.mxFrame - then the client would incorrectly assume
52645 ** transaction, then *pChanged is set to 1 before returning. The
52696 /* If the "last page" field of the wal-index header snapshot is 0, then
52699 ** then the WAL is ignored by the reader so return early, as if the
52820 ** the read transaction was started, then it is not possible for this
52847 ** time the read transaction on this connection was started, then
52901 ** (b) has an outstanding reference, then xUndo is either a no-op
52988 ** readers are currently using the WAL), then the transactions
53035 ** first write the part before iSyncPoint, then sync, then write the
53109 /* If this frame set completes a transaction, then nTruncate>0. If
53110 ** nTruncate==0 then this frame set does not complete the transaction. */
53193 /* If this is the end of a transaction, then we might need to pad
53198 ** or synchronous==OFF, then no padding or syncing are needed.
53200 ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
53201 ** needed and only the sync is done. If padding is needed, then the
53223 ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
53276 ** Obtain a CHECKPOINT lock and then backfill as much information as
53369 ** performed, then the pager-cache associated with pWal is now
53388 ** the last call, then return 0.
53403 ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE
53406 ** or if the acquisition of the lock fails, then return 0. If the
53411 ** If op is one, then change from locking_mode=NORMAL into
53418 ** If op is negative, then do a dry-run of the op==1 case but do
53542 ** page. If the payload is larger than the preset amount then surplus
53599 ** If the payload for a cell is larger than the max payload, then extra
53747 ** the header, then your custom library will not be able to read
54099 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
54257 ** If the object is not sharable, then no mutex is ever required
54266 ** p, then first unlock all of the others on p->pNext, then wait
54267 ** for the lock to become available on p, then relock all of the
54288 /* Unless the database is sharable and unlocked, then BtShared.db
54318 ** BtShared address. Then acquire our lock. Then reacquire
54458 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
54460 ** If pSchema is not NULL, then iDb is computed from pSchema and
54483 ** If shared cache is disabled, then all btree mutex routines, including
54606 ** shared-cache feature disabled, then there is only ever one user
54654 ** and has the read-uncommitted flag set, then no lock is required.
54664 ** not loaded, then it is too difficult to actually check to see if
54722 ** read-uncommitted flag set, then it is OK for the other object to
54759 /* If requesting a write-lock, then the Btree must have an open write
54785 ** since we know that if eLock==WRITE_LOCK, then no other connection
54883 ** transaction. If it does not, then the BTS_PENDING flag
54916 ** that writer, then the number of locks held by connections other
54920 ** If there is not currently a writer, then BTS_PENDING must
54982 ** If argument isClearTable is true, then the entire contents of the
54986 ** Otherwise, if argument isClearTable is false, then the row with
55035 ** a page is moved to the free-list and then reused within the same
55038 ** is extracted from the free-list and reused, then the original data
55104 ** If the cursor is open on an intkey table, then the integer key
55106 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
55119 /* If this is an intKey table, then the above call to BtreeKeySize()
55122 ** table, then malloc space for and store the pCur->nKey bytes of key
55182 ** If there are two or more cursors on the same btree, then all such
55188 ** then the BTCF_Multiple flag on pExpect is cleared, to avoid another
55247 ** record and then call BtreeMovetoUnpacked() to do the work.
55394 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
55898 ** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned.
55987 ** then the cell content offset of an empty page wants to be 65536.
56001 ** array entry offset, and if the freelist is not empty, then search the
56112 ** pointer in the page header) then check to see if iStart should be
56212 ** not contain a well-formed database page, then return
56266 ** possible for a root page of a table that contains no rows) then the
56331 ** of the page, then the page must be corrupted. This check also
56454 ** If pCur!=0 then the page is being fetched as part of a moveToChild()
56461 ** If an error occurs, then *ppPage is undefined. It
56601 ** then an ephemeral database is created. The ephemeral database might
56606 ** If zFilename is ":memory:" then an in-memory database is created
56613 ** and we are in shared cache mode, then the open will fail with an
56789 /* If the magic name ":memory:" will create an in-memory database, then
56792 ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
56841 /* If the new Btree uses a sharable pBtShared, then link the new
57119 ** size supplied does not meet this constraint then the page size is not
57127 ** If parameter nReserve is less than zero, then the number of reserved
57130 ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
57193 ** If SQLITE_HAS_MUTEX is defined then the number returned is the
57224 ** then make no changes. Always return the value of the BTS_SECURE_DELETE
57242 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
57292 ** well-formed database file, then SQLITE_CORRUPT is returned.
57346 ** in WAL mode. If the log is not already open, open it now. Then
57416 ** be less than 480. In other words, if the page size is 512, then the
57469 ** false then all cursors are counted.
57488 ** of a transaction but there is a read lock on the database, then
57507 ** If pBt points to an empty file then convert that empty file
57586 ** and the database was previously unlocked, then invoke the busy handler
57727 ** the sub-journal is not already open, then it will be opened here.
57883 /* If pDbPage was a btree-page, then it may have child pages and/or cells
57887 ** If pDbPage is an overflow page, then the first 4 bytes may store a
57888 ** pointer to a subsequent overflow page. If this is the case, then
58003 ** On the other hand, if bCommit is greater than zero, then keep
58108 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
58171 ** the journal. Then the contents of the journal are flushed out to
58270 ** is non-zero then this b-tree transaction is part of a multi-file
58327 ** references. Or if the writeOnly flag is set to 1, then only
58335 ** flag is true, then only write-cursors need be tripped - read-only
58385 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
58488 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
58522 ** on the database already. If a write-cursor is requested, then
58525 ** If wrFlag==0, then the cursor can only be used for reading.
58526 ** If wrFlag==1, then the cursor can be used for reading or for
58544 ** root page of a b-tree. If it is not, then the cursor acquired
58595 /* If there are two or more cursors on the same btree, then all such
58781 ** to page number pOvfl was obtained, then *ppPage is set to point to that
58784 ** the pointer-map was used to obtain the value for *pPgnoNext), then
58848 ** If argument eOp is false, then nByte bytes of data are copied
58850 ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
59013 ** page-list cache, if any, then fall back to the getOverflowPage()
59017 ** here. If eOp==2, then offset==0 and this branch is never taken.
59051 ** then data can be read directly from the database file into the
59152 ** key/data is written into *pAmt. If *pAmt==0, then the value
59159 ** onto overflow pages, then accessPayload() must be used to reassemble
59262 ** right-most child page then pCur->idx is set to one more than
59284 ** If the table has a virtual root page, then the cursor is moved to point
59340 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
59499 ** If an exact match is not found, then the cursor is always
59536 ** to move to, then just return without doing any work */
59583 ** not run. If this is not the root-page, then the moveToChild() routine
59754 ** successful then set *pRes=0. If the cursor
59756 ** this routine was called, then set *pRes=1.
59864 ** successful then set *pRes=0. If the cursor
59866 ** this routine was called, then set *pRes=1.
59971 ** If the "nearby" parameter is not 0, then an effort is made to
59977 ** anywhere on the free-list, then it is guaranteed to be returned. If
59978 ** eMode is BTALLOC_LT then the page returned will be less than or equal
59979 ** to nearby if any such page exists. If eMode is BTALLOC_ANY then there
60015 ** shows that the page 'nearby' is somewhere on the free-list, then
60231 ** steps, then the page we are about to allocate may contain content
60331 /* If the secure_delete option is enabled, then
60352 ** trunk page in the free-list is full, then this page will become a
60406 /* If control flows to this point, then it was not possible to add the
60490 ** So if there exists more than one reference to this page, then it
60521 ** be constructed in this temporary area then copied into pPage->aData
60636 ** If this is the first overflow page, then write a partial entry
60638 ** then the optimistic overflow chain processing in clearCell()
60659 /* If pPrior is part of the data area of pPage, then make sure pPage
60679 /* If pPayload is part of the data area of pPage, then make sure pPage
60759 ** If the cell content will fit on the page, then put it there. If it
60760 ** will not fit, then make a copy of the cell content into pTemp if
60791 ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
60980 ** cells in apCell[], then the cells do not fit and non-zero is returned.
61346 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
61349 ** any cells with overflow page pointers, then the corresponding pointer
61409 ** is a root page or a child of a root page) then all available siblings
61508 ** has NB or fewer children then all children of pParent are taken.
61614 ** If the siblings are on leaf pages, then the child pointers of the
61617 ** child pointers. If siblings are not leaves, then all cell in
61955 ** If the sibling pages are not leaves, then the pointer map entry
62019 ** then there is no divider cell in b.apCell[]. Instead, the divider
62033 ** bytes, then it may actually be smaller than this
62060 ** then it is not safe to update page apNew[iPg] until after
62064 ** then it is not safe to update page apNew[iPg] until after
62070 ** to 0, then back up to nNew-1 again, thus making two passes over
62132 ** copied into the parent, because if the parent is page 1 then it will
62201 ** page is then overwritten to make it an empty page with the right-child
62253 /* Zero the contents of pRoot. Then install pChild as the right-child. */
62395 ** If the seekResult parameter is non-zero, then a successful call to
62402 ** If the seekResult parameter is non-zero, then the caller guarantees that
62404 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
62438 ** expecting an index b-tree, then the caller should be inserting blob
62449 ** integer key to use. It then calls this function to actually insert the
62561 ** If the second parameter is zero, then the cursor is left pointing at an
62562 ** arbitrary location after the delete. If it is non-zero, then the cursor
62618 /* If the bPreserve flag is set to true, then the cursor position must
62620 ** will cause a b-tree rebalance, then this is done by saving the cursor
62624 ** Or, if the current delete will not cause a rebalance, then the cursor
62640 /* Make the page containing the entry to be deleted writable. Then free any
62649 /* If the cell deleted was not located on a leaf page, then the cursor
62673 ** then the cursor still points to that page. In this case the first
62677 ** Otherwise, if the entry deleted was on an internal node page, then
62946 ** If pnChange is not NULL, then
62987 ** root page in the database file, then the last root page
63210 /* If this is a leaf page or the tree is not an int-key tree, then
63456 ** and then
63769 ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
64438 ** then the backup cannot proceed.
64463 ** Then clear the Btree layer MemPage.isInit flag. Both this module
64482 ** If pFile is currently larger than iSize bytes, then truncate it to
64483 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
64555 ** one now. If a transaction is opened here, then it will be closed
64731 /* If bCloseTrans is true, then this function opened a read transaction
64838 ** copied into the destination database, then the data written to the
64989 /* If MEM_Dyn is set then Mem.xDel!=0.
64995 ** ensure that if Mem.szMalloc>0 then it is safe to do
65034 ** representation is already stored using the requested encoding, then this
65057 ** then the encoding of the value may not have changed.
65071 ** If the bPreserve argument is true, then copy of the content of
65080 /* If the bPreserve flag is set to true, then the memory cell must already
65260 ** string representation of the value. Then, if the required encoding
65312 ** invoking the external callback in Mem.xDel, then this routine
65379 ** If the double is out of range of a 64-bit signed integer then
65410 ** If pMem is an integer, then the value is exact. If pMem is
65411 ** a floating-point then the value returned is the integer part.
65412 ** If pMem is a string or blob, then we make an attempt to convert
65637 ** to a value change. So invoke the destructor, then set the value to
65737 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
65803 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
65809 ** size limit) then no memory allocation occurs. If the string can be
65810 ** stored without allocating memory, then it is. If a memory allocation
65811 ** is required to store the string, then value of pMem is unchanged. In
65912 ** to read from the disk) then the pMem is left in an inconsistent state.
66021 ** If that is the case, then the result must be aligned on an even byte
66066 ** Otherwise, if the second argument is non-zero, then this function is
66069 ** that function will return to its caller here. Then return a pointer to
66121 ** then this routine attempts to invoke the SQL function. Assuming no
66360 ** be converted directly into a value, then the value is allocated and
66363 ** cannot be converted to a value, then *ppVal is set to NULL.
66434 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
66568 ** the column value into *ppVal. If *ppVal is initially NULL then a new
66571 ** If *ppVal is initially NULL then the caller is responsible for
67141 ** Then check that the value of Parse.mayAbort is true if an
67178 ** If malloc failed, then the while() loop above may not have iterated
67415 ** If the input FuncDef structure is ephemeral, then free it. If
67416 ** the FuncDef is not ephermal, then do nothing.
67518 ** then remove it. Return true if and only if an opcode was removed.
67535 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
67538 ** first null byte. If n>0 then copy n+1 bytes of zP4.
67544 ** If addr<0 then change P4 on the most recently inserted instruction.
67652 ** Return the opcode for a given address. If the address is -1, then
67656 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
67914 ** If SQLite is not threadsafe but does support shared-cache mode, then
67924 ** corresponding to btrees that use shared cache. Then the runtime of
68071 ** When p->explain==1, first the main program is listed, then each of
68317 ** request, then increment *pnByte by the amount of the request.
68455 ** requirements by reusing the opcode array tail, then the second
68659 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
68746 ** simple case then too.
68873 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
68962 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
68963 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
68973 /* If p->iStatement is greater than zero, then this Vdbe opened a
69032 ** and write an error message to it. Then return SQLITE_ERROR.
69051 ** has made changes and is in autocommit mode, then commit those
69052 ** changes. If a rollback is needed, then do the rollback.
69077 ** Then the internal cache might have been left in an inconsistent
69140 ** VM, then we do either a commit or rollback of the current transaction.
69195 /* If eStatementOp is non-zero, then a statement transaction needs to
69198 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
69247 /* If the auto-commit flag is set to true, then any locks that were held
69330 ** error, then it might not have been halted properly. So halt
69335 /* If the VDBE has be run even partially, then transfer the error code
69416 ** If parameter iOp is less than zero, then invoke the destructor for
69420 ** Or, if iOp is greater than or equal to zero, then the destructor is
69423 ** VM pVdbe, and only then if:
69562 ** If a MoveTo operation is pending on the given cursor, then do that
69568 ** not been deleted out from under the cursor, then this routine is a no-op.
69683 ** points (ex: ARM7) then swap the lower 4 bytes with the
69925 ** stack space). If the former, then *ppFree is set to a pointer that should
70185 ** If one blob is a prefix of the other, then the shorter is the lessor.
70336 ** fields that appear in both keys are equal, then pPKey2->default_rc is
70359 /* If bSkip is true, then the caller has already determined that the first
71233 ** then sets the error code to SQLITE_TOOBIG
71504 /* If there are no other statements currently running, then
71574 ** error has occurred, then return the error code in p->rc to the
71926 ** sqlite3_column_XXX API, then set the return code of the statement to
72005 ** xFunc() then return that string. If N is out of range, return 0.
72017 ** or a constant) then useTypes 2, 3, and 4 return NULL.
72073 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
72156 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
72188 /* If the bit corresponding to this variable in Vdbe.expmask is set, then
72193 ** for a statement, then the statement will be automatically recompiled,
72462 ** If the two statements contain a different number of bindings, then
72669 ** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the
72672 ** then the returned string holds a copy of zRawSql with "-- " prepended
72675 ** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
72676 ** then long strings and blobs are truncated to that many bytes. This
72688 ** parameter index is known, locate the value in p->aVar[]. Then render
73043 ** If the bTryForInt flag is true, then extra effort is made to give
73048 ** If bTryForInt is false, then if the input string contains a decimal
73675 ** and then jump to address P2.
73711 ** If P2!=0 then the coroutine implementation immediately follows
73756 ** Yield or Return then continue to the next instruction. But if
73758 ** EndCoroutine, then jump to P2 rather than continuing with the
73778 ** Check the value in register P3. If it is NULL then Halt using
73780 ** value in register P3 is not NULL, then this routine is a no-op.
73796 ** For errors, it can be some other value. If P1!=0 then P2 will determine
73799 ** then back out all changes that have occurred during this execution of the
73802 ** If P4 is not null then it is an error message string.
73812 ** If P5 is not zero and P4 is NULL, then everything after the ":" is
73837 ** instruction is set to OE_Ignore, then the sub-program is throwing
73968 ** If P5!=0 and the content of register P3 is greater than zero, then
73994 ** Write a NULL into registers P2. If P3 greater than P2, then also write
73996 ** is less than P2 (typically P3 is zero) then only register P2 is
73999 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
74055 ** If the parameter is named, then its name appears in P4.
74149 ** is a string or blob, then the copy is only a pointer to the
74204 /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
74212 ** If the open statement-transaction is not closed here, then the user
74255 ** If either the P1 or P2 text are NULL then store NULL in P3.
74325 ** register P1 is zero, then the result is NULL. If either input is
74432 ** If P1 is not zero, then it is a register that a subsequent min() or
74458 ** argument was constant then bit 0 of P1 is set. This is used to determine
74475 ** argument was constant then bit 0 of P1 is set. This is used to determine
74662 ** without data loss, then jump immediately to P2, or if P2==0
74737 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
74741 ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
74742 ** bit is clear then fall through if either operand is NULL.
74747 ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
74753 ** the values are compared. If both values are blobs then memcmp() is
74755 ** are text, then the appropriate collating function specified in
74756 ** P4 is used to do the comparison. If P4 is not specified then
74758 ** numeric, then a numeric comparison is used. If the two values
74759 ** are of different types, then numbers are considered less than
74762 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
74765 ** If the SQLITE_NULLEQ bit is set in P5, then NULL values are considered
74776 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
74777 ** true or false and is never NULL. If both operands are NULL then the result
74778 ** of comparison is false. If either operand is NULL then the result is true.
74789 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
74790 ** true or false and is never NULL. If both operands are NULL then the result
74791 ** of comparison is true. If either operand is NULL then the result is false.
74835 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
74851 ** then the result is always NULL.
74957 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
74959 ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
75040 ** If either P1 or P2 is 0 (false) then the result is 0 even if
75050 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
75093 ** NULL, then a NULL is stored in P2.
75111 ** a NULL then store a NULL in P2.
75150 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
75156 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
75218 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
75223 ** then the cache of the cursor is reset prior to extracting the column.
75334 ** the complete header, then set it to zero, forcing the header to be
75532 ** If P4 is NULL then all index fields have the affinity BLOB.
75717 ** transaction, then there cannot be any savepoints.
75752 /* If there is no open transaction, then mark this as a special
75771 /* Find the named savepoint. If there is no such savepoint, then an
75793 ** and this is a RELEASE command, then the current transaction
75846 /* If it is a RELEASE, then destroy the savepoint being operated on
75847 ** too. If it is a ROLLBACK TO, then set the number of deferred
75876 ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
75940 ** If P2 is non-zero, then a write-transaction is started, or if a
75942 ** If P2 is zero, then a read-transaction is started.
75959 ** If P5!=0 then this opcode also checks the schema cookie against P3
75966 ** generation counter, then an SQLITE_SCHEMA error is raised and execution
75967 ** halts. The sqlite3_step() wrapper function might then reprepare the
76139 ** If P5!=0 then use the content of register P2 as the root page, not
76144 ** then a read lock is acquired as part of this instruction. A read
76153 ** structure, then said structure defines the content and collating
76182 ** structure, then said structure defines the content and collating
76211 ** index, then fall through into OP_OpenRead to force a reopen */
76374 ** If argument P3 is non-zero, then it indicates that the sorter may
76477 ** to an SQL index, then P3 is the first in an array of P4 registers
76482 ** greater than or equal to the key and P2 is not zero, then jump to P2.
76495 ** to an SQL index, then P3 is the first in an array of P4 registers
76500 ** the key and P2 is not zero, then jump to P2.
76513 ** to an SQL index, then P3 is the first in an array of P4 registers
76518 ** the key and P2 is not zero, then jump to P2.
76531 ** to an SQL index, then P3 is the first in an array of P4 registers
76536 ** less than or equal to the key and P2 is not zero, then jump to P2.
76597 ** loss of information, then special processing is required... */
76601 ** then the seek is not possible, so jump to P2 */
76727 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76728 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76732 ** is a prefix of any entry in P1 then a jump is made to P2 and
76744 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76745 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76749 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
76750 ** does contain an entry whose prefix matches the P3/P4 record then control
76763 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76764 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76769 ** record are not-NULL then a check is done to determine if any row in the
76870 ** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an
76871 ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then
76948 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
77047 ** largest possible integer (9223372036854775807) then the database
77082 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
77084 ** then rowid is stored for subsequent return by the
77088 ** the last seek operation (OP_NotExists) was a success, then this
77095 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
77096 ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
77101 ** may be NULL. If it is not NULL, then the update-hook
77105 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
77107 ** value of register P2 will then change. Make sure this does not
77191 ** pointing at the next record, then the next Next instruction will be a
77193 ** Next loop. If P5 is zero, then the cursor is left in an undefined state.
77195 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
77201 ** If P4 is not NULL, then it is the name of the table that P1 is
77203 ** If P4 is not NULL then the P1 cursor must have been positioned
77248 ** Then the VMs internal change counter resets to 0.
77266 ** fields (not counting the P4 fields at the end which are ignored) then
77293 ** Then clear the column header cache on cursor P3.
77362 ** generator) then the fix would be to insert a call to
77477 ** If the table or index is empty and P2>0, then jump immediately to P2.
77518 ** then rewinding that index and playing it back from beginning to
77577 ** table or index. If there are no more key/value pairs then fall through
77596 ** If P5 is positive and the jump is taken, then event counter
77609 ** table or index. If there is no previous key/value pairs then fall through
77619 ** not open then the behavior is undefined.
77629 ** If P5 is positive and the jump is taken, then event counter
77702 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
77704 ** then the change counter is unchanged.
77706 ** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have
77834 ** then jump to P2. Otherwise fall through to the next instruction.
77845 ** then jump to P2. Otherwise fall through to the next instruction.
77855 ** If the P1 index entry is less than the key value then jump to P2.
77866 ** If the P1 index entry is less than or equal to the key value then jump
77919 ** P3==1 then the table to be clear is in the auxiliary database file
77922 ** If AUTOVACUUM is enabled then it is possible that another root page
77928 ** the last one in the database) then a zero is stored in register P2.
77929 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
77969 ** P2==1 then the table to be clear is in the auxiliary database file
77972 ** If the P3 value is non-zero, then the table referred to must be an
77975 ** If P3 is greater than zero, then the value stored in register P3 is
78077 ** then runs the new virtual machine. It is thus a re-entrant opcode.
78359 ** If P5 is non-zero, then recursive program invocation is enabled.
78375 /* If the p5 flag is clear, then recursive invocation of triggers is
78400 ** the trigger program. If this trigger has been fired before, then pRt
78525 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
78574 ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
78580 ** If the initial value of register P1 is less than 1, then the
78595 ** Synopsis: if r[P1]<=0 then r[P2]=P3
78598 ** If the value of register P1 is not positive (if it is less than 1) then
78612 ** Synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2
78615 ** initially nonzero, then subtract P3 from the value in register P1 and
78634 ** then jump to P2 if the new value is exactly zero.
78650 ** zero, then jump to P2. Increment register P1 regardless of whether or
78977 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
78978 ** then only the currently executing statement is expired.
79242 ** the end of its result set, then fall through to the next instruction.
79323 ** is the rowid of a row to delete. If argv[0] is NULL then no
79329 ** If P2==1 then no insert is performed. argv[0] is the rowid of
79333 ** is successful, then the value returned by sqlite3_last_insert_rowid()
79437 ** If tracing is enabled (by the sqlite3_trace()) interface, then
79643 ** blob handle was opened, then an error code is returned and *pzErr may
79648 ** If an error does occur, then the b-tree cursor is closed. All subsequent
79725 ** Code external to the Vdbe then "borrows" the b-tree cursor and
79985 /* If there is no statement handle, then the blob-handle has
80040 ** contain a blob or text value, then an error code is returned and the
80041 ** database handle error code and message set. If this happens, then all
80055 /* If there is no statement handle, then the blob-handle has
80157 ** threshold, then the set of records currently in memory are sorted and
80169 ** If the sorter is running in single-threaded mode, then all PMAs generated
80171 ** multi-threaded mode then up to (N+1) temporary files may be opened, where
80188 ** sorter is running in single-threaded mode, then these PMAs are merged
80193 ** Or, if running in multi-threaded mode, then a background thread is
80203 ** Rewind() is called, then a hierarchy of incremental-merges is used.
80205 ** disk are merged together. Then T bytes of data from the second set, and
80210 ** SORTER_MAX_MERGE_COUNT PMAs on disk when Rewind() is called, then more
80259 ** If aMemory==0 then each object is allocated separately and the objects
80260 ** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects
80355 ** Before a background thread is launched, variable bDone is set to 0. Then,
80423 ** contain a contiguous representation of the key, then aAlloc is allocated
80454 ** pMerger to populate aFile[0]. It then sets variables within the
80460 ** background thread has finished populating aFile[1]. It then exchanges
80508 ** (VdbeSorter.list.aMemory==0), then the list is always connected using the
80512 ** then while records are being accumulated the list is linked using the
80612 ** range into. Then return a copy of pointer p->aAlloc to the caller. */
80799 ** If the pnByte parameter is NULL, then it is assumed that the file
81714 ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
81720 ** was actually called above, then pTask->pUnpacked now contains
81724 ** If the two values were equal, then the value from the oldest
81856 ** If using the single large allocation mode (pSorter->aMemory!=0), then
82004 ** background thread is finished (if it is not already) and then swap
82156 ** If argument eMode is INCRINIT_ROOT, then it is assumed that any IncrMerge
82163 ** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use
82213 ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders
82214 ** in the sub-tree headed by pReadr are also initialized. Data is then
82218 ** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed
82282 ** then this function is already running in background thread
82285 ** If this is the INCRINIT_ROOT object, then it is running in the
82319 ** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes
82324 ** then a background thread is launched to call vdbePmaReaderIncrMergeInit().
82355 ** PMA before returning. If an error does occur, then the final value of
82480 /* If the sorter uses more than one task, then create the top-level
82638 /* If no data has been written to disk, then do not do so now. Instead,
83454 ** If the Walker does not have an xSelectCallback() then this routine
83533 ** If the reference is followed by a COLLATE operator, then make sure
83611 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
83759 ** USING clause, then skip this match.
83786 /* If we have not already resolved the name, then maybe
83856 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
83909 ** supplied) and the value of Z is enclosed in double-quotes, then
83941 /* If a column from a table in pSrcList is referenced, then record
83945 ** then set the high-order bit of the bitmask.
84271 ** no match, or if pE is not a simple identifier, then this routine
84480 ** field) then convert that term into a copy of the corresponding result set
84526 ** number of columns in the result set of the SELECT) then the expression
84529 ** a result-set expression, then the term resolves to a copy of the
84533 ** This routine returns the number of errors. If errors occur, then
84646 /* If the SF_Converted flags is set, then this Select object was
84671 ** pItem->pSelect, check if this value has changed. If so, then
84709 /* If a HAVING clause is present, then there must be a GROUP BY clause.
84721 ** Minor point: If this is the case, then the expression will be
84761 ** than the right-most term, then that is a syntax error. But the error
84855 ** If the function is an aggregate function, then the NC_HasAgg flag is
84857 ** If an expression contains aggregate functions then the EP_Agg
85003 ** or a sub-select with a column as the return value, then the
85243 ** If the left hand expression has a collating sequence type, then it is
85319 ** to by pnHeight, the second parameter, then set *pnHeight to that
85417 ** If dequote is true, then the token (if it exists) is dequoted.
85421 ** then the EP_DblQuoted flag is set on the expression node.
85424 ** can be translated into a 32-bit integer, then the token is not
85548 ** then return 1. If one cannot determine the truth value of the
85557 ** LEFT JOIN, then we cannot determine at compile-time whether or not
85575 ** NULL, then just return the other expression.
85577 ** If one side or the other of the AND is known to be false, then instead
85812 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
85830 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
85959 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
85996 ** the build, then none of the following routines, except for
86102 ** initially NULL, then create a new expression list.
86105 ** NULL is returned. If non-NULL is returned, then it is guaranteed
86286 /* If pWalker->eCode is 2 then any term of the expression that comes from
86410 ** integer, then the EP_IntValue flag will have already been set */
86634 ** If the RHS of the IN operator is a list or a more complex subquery, then
86635 ** an ephemeral table might need to be generated from the RHS and then
86641 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a
86647 ** through the set members) then the b-tree must not contain duplicates.
86653 ** for fast set membership tests) then an epheremal table must
86658 ** if the RHS of the IN operator is a list (not a subquery) then this
86668 ** runtime, then a register is allocated and the register number written
86670 ** NULL value, then *prRhsHasNull is left unchanged.
86672 ** If a register is allocated and its location stored in *prRhsHasNull, then
86766 ** then it is not worth creating an ephemeral table to evaluate
86814 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
86849 ** If all of the above are false, then we can run this code just once
86881 ** statement returns a column value, then the affinity of that
86883 ** SELECT... statement are columns, then numeric affinity is used
86885 ** 'x' nor the SELECT... statement are columns, then numeric affinity
86924 ** store it in the temporary table. If <expr> is a column, then use
86949 /* If the expression is not constant then we will need to
87056 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
87057 ** within the RHS then fall through.
87094 ** suitable for evaluating the IN operator, then evaluate using a
87136 /* If the LHS is NULL, then the result is either false or NULL depending
87164 /* If the set membership test fails, then the result of the
87166 ** contains no NULL values, then the result is 0. If the set
87167 ** contains one or more NULL values, then the result of the
87189 ** then the answer is TRUE the presence of NULLs in the RHS does
87190 ** not matter. If the LHS is not contained in the RHS, then the
87471 ** is called. If iColumn<0 then code is generated that extracts the rowid.
88018 /* If the opcode is TK_TRIGGER, then the expression is a reference
88037 ** Then p1 is interpreted as follows:
88076 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
88079 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
88082 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
88083 ** WHEN x=eN THEN rN ELSE y END
88088 ** is even, then Y is omitted and the "otherwise" result is NULL.
88218 ** then write its number into *pReg. If the result register is not
88219 ** a temporary, then set *pReg to zero.
88221 ** If pExpr is a constant, then this routine might generate this
88281 ** in register target. If the expression is constant, then this routine
88429 ** If the expression evaluates to NULL (neither true nor false), then
88559 ** If the expression evaluates to NULL (neither true nor false) then
88731 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
88735 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
88740 ** returns 2, then you do not really know for certain if the two
88741 ** expressions are the same. But if you get a 0 or 1 return, then you
88794 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
88833 ** Expr.iTable<0 then assume a table number given by iTab.
89133 ** If a register is currently being used by the column cache, then
89440 ** If argument zWhere is NULL, then a pointer string containing the text
89446 ** If argument zWhere is not NULL, then the string returned is
89660 ** Then modify the schema cookie (since the ALTER TABLE modifies the
89711 "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
89716 "WHEN type='table' THEN %Q "
89717 "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
89730 /* If the sqlite_sequence table exists in this database, then update
89844 ** literal NULL, then set pDflt to 0. This simplifies checking
89852 ** If there is a NOT NULL constraint, then the default value for the
89913 /* If the default value of the new column is NULL, then set the file
90056 ** are both enabled, then STAT4 takes precedence.
90075 ** the index is unique, then the last integer will be 1.
90080 ** "unordered" keyword is present, then the query planner assumes that
90083 ** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat
90101 ** Then the sampled rows are given by:
90128 ** index. If the idx and tbl columns are the same, then the sample is
90188 ** or it may be a NULL pointer. If it is not NULL, then all entries in
90190 ** If zWhere==0, then code is generated to delete all stat table entries.
90824 ** If neither STAT3 nor STAT4 are enabled, then J is always
90858 ** "100 10 2", then SQLite estimates that:
90865 ** rows, then each estimate is computed as:
91335 ** a database. If pOnlyIdx is not NULL then it is a single index
91605 /* If this is stat4 data, then calculate aAvgEq[] values for all
92117 ** If this fails, or if opening the file failed, then close the file and
92601 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
92602 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
92640 ** then generate an error.
92696 ** is returned, then the error count and error message in pParse are
93070 ** names is done.) The search order is TEMP first, then MAIN, then any
93128 ** CREATE, then check to see if it is the name of an virtual table that
93186 ** TEMP first, then MAIN, then any auxiliary databases added
93225 ** unlike that index from its Table then remove the index from
93299 /* If any database other than TEMP is reset, then also reset TEMP
93519 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
93524 ** Then pName1 is set to "yyy" and pName2 is "".
93633 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
93638 ** Then pName1 is set to "yyy" and pName2 is "".
93733 ** then record a pointer to this table in the main database structure
93834 ** first to get things going. Then this routine is called for each
93873 ** 'BLOB'. If there is a type specified, then sqlite3AddColumnType() will
94064 ** of columns that form the primary key. If pList is NULL, then the
94068 ** a primary key (and this is the second primary key) then create an
94072 ** then we will try to use that column as the rowid. Set the Table.iPKey
94077 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
94196 ** then an index may have been created on this column before the
94217 ** and the sequence is available in another text encoding, then that is
94297 ** then it is copied to the output buffer exactly as it is. Otherwise,
94679 /* If not initializing, then create a record for the new table
95102 ** is non-zero, then it is the root page number of a table moved to
95133 ** is not defined), then it is important to call OP_Destroy on the
95144 ** database, then root page 5 would be moved to page 4 by the
95377 ** in the current table point to the foreign key. If pFromCol==0 then
95528 ** root page number of the index. If memRootPage is negative, then
95783 ** index, then we will continue to process this index.
96012 ** the constraint occur in different orders, then the constraints are
96076 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
96397 ** If the iStart argument had been 1 instead of 2, then the result
96399 ** the iStart value would be 0. The result then would
96459 ** a new one. If an OOM error does occurs, then the prior value of pList
96474 ** Then B is a table name and the database name is unspecified. If called
96479 ** Then C is the table name and B is the database name. If C is defined
96480 ** then so is B. In other words, we never have a case where:
96565 ** usual case. If the term has an alias, then pAlias points to the
96566 ** alias token. If the term is a subquery, then pSubquery is the
96815 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
96834 ** a transaction. If we are already within a transaction, then a checkpoint
96851 ** more than one entry (example: deleting one row then inserting another,
96853 ** If an abort occurs after some of these writes have completed, then it will
96980 ** If pColl==0 then recompute all indices of pTab.
96998 ** indices use the collating sequence pColl. If pColl==0 then recompute
97270 ** If it is not NULL, then pColl must point to the database native encoding
97338 ** true, then create a new entry. Otherwise return NULL.
97391 ** If the entry specified is not found and 'create' is true, then create a
97443 ** If nArg==(-2) then any function with a non-null xStep or xFunc is
97529 ** If the createFlag argument is true, then a new (blank) FuncDef
97533 ** If nArg is -2, then the first valid function found is returned. A
97536 ** of arguments. If nArg is -2, then createFlag must be 0.
97538 ** If createFlag is false, then a function with the required name and
97573 ** If the SQLITE_PreferBuiltin flag is set, then search the built-in
97598 ** exact match for the name, number of arguments and encoding, then add a
98152 ** deleting from and all its indices. If this is a view, then the
98291 ** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor
98293 ** then this function must seek iDataCur to the entry identified by iPk
98296 ** If eMode is ONEPASS_MULTI, then this call is being made as part
98298 ** iIdxNoSeek is a valid cursor number (>=0), then its position should
98304 ** If iIdxNoSeek is a valid cursor number (>=0), then it identifies an
98375 /* If any BEFORE triggers were coded, then seek the cursor to the
98479 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then
98496 ** avoid unnecessary register loads. If pPrior is not NULL, then it is
98500 ** a column in common, then the register corresponding to that column already
98544 /* If the column affinity is REAL but the number is an integer, then it
98546 ** representation) then converted to REAL by an OP_RealAffinity opcode.
98561 ** because it was a partial index, then this routine should be called to
98716 ** then abs(X) throws an integer overflow error since there is no
98752 ** If both haystack and needle are BLOBs, then the result is one more than
98826 ** of x. If x is text, then we actually count UTF-8 characters.
98827 ** If x is a blob, then we count bytes.
98829 ** If p1 is negative, then we begin abs(p1) from the end of x[].
98869 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
98966 ** If nByte is larger than the maximum string or blob length, then
99055 ** values, resulting in a positive value. Then take the
99165 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
99941 ** A function that loads a shared-library extension then returns NULL.
100218 ** then set aWc[0] through aWc[2] to the wildcard characters and
100219 ** return TRUE. If the function is not a LIKE-style function then
100224 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
100521 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
100550 ** then non-zero is returned, and a "foreign key mismatch" error loaded
100602 ** column of pFKey, then this index is a winner. */
100605 /* If zKey is NULL, then this foreign key is implicitly mapped to
100616 /* If zKey is non-NULL, then this foreign key was declared to
100669 ** affected - once to "delete" the old row, and then again to "insert" the
100707 /* If nIncr is less than zero, then check at runtime if there are any
100712 ** any are, then the constraint is considered satisfied. No need to
100725 /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
100731 ** apply the affinity of the parent key). If this fails, then there
100741 ** then check if the row being inserted matches itself. If so, do not
100767 ** then check if the row being inserted matches itself. If so, do not
100770 ** If any of the parent-key values are NULL, then the row cannot match
100964 /* If the child table is the same as the parent table, then add terms
101072 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
101086 ** generating any VDBE code. If one can be found, then jump over
101107 ** If the SQLITE_DeferFKs flag is set, then this is not required, as
101223 ** described for DELETE. Then again after the original record is deleted
101280 /* If isIgnoreErrors is true, then a table is being dropped. In this
101341 ** foreign key, then omit this scan altogether. As all child key
101393 ** action applies, then any foreign key violations caused by
101397 ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the
101454 ** row contained in table pTab. If the operation is a DELETE, then
101457 ** If the i'th column is not modified by the UPDATE, then the corresponding
101500 ** If the current operation is an UPDATE, then the pChanges parameter is
101506 ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
101516 ** then the returned trigger structure is equivalent to:
101804 ** (1) acquire a lock for table pTab then
101807 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
101859 ** required, it is allocated and populated here. It is then stored as
101899 ** if iReg>0 then code an OP_Affinity opcode that will set the affinities
101901 ** then just set the P4 operand of the previous opcode (which should be
102076 ** larger than the maximum rowid in the memId memory cell, then the
102119 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
102144 ** then a list of all (non-hidden) columns for the table is substituted.
102172 ** schemas, including all the same indices, then a special optimization
102287 ** single row (the common case) then keep that one row of values
102357 ** Then special optimizations can be applied that make the transfer
102385 /* If the INSERT statement included an IDLIST term, then make sure
102390 ** is named in the IDLIST, then record in the ipkColumn variable
102427 ** is coming from a SELECT statement, then generate a co-routine that
102681 /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
102861 ** might be modified by the UPDATE. If pkChng is false, then the key of
102887 ** then the appropriate action is performed. There are five possible
102897 ** only (do not do a complete rollback) then
102921 ** Or if overrideError==OE_Default, then the pParse->onError parameter
102922 ** is used. Or if pParse->onError==OE_Default then the onError value
103075 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
103219 ** primary key, then no collision is possible. The collision detection
103423 ** If iBase is negative, then allocate the next available cursor.
103430 ** If pTab is a virtual table, then this routine is a no-op and the
103553 /* If no test above fails then the indices must be compatible */
103770 ** that determination. If SQLITE_Vacuum is set, then the destination
103833 ** collation sequence BINARY, then it can also be assumed that the
103842 ** might change the definition of a collation sequence and then run
103905 ** If the SQL is a query, then for each row in the query result
103907 ** argument to xCallback(). If xCallback=NULL then no callback
103980 ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
104077 ** interfaces in the middle of this structure, then older different
104989 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
105062 ** entry point name "sqlite3_extension_init" was not found, then
105259 ** is currently on the list. If xInit is not on the list, then this
106098 ** identifier, or a number. If minusFlag is true, then the value is
106101 ** If the left side is "database.id" then pId1 is the database name
106102 ** and pId2 is the id. If the left side is just "id" then pId1 is the
106157 ** connection. If it returns SQLITE_OK, then assume that the VFS
106423 ** then do a query */
106543 ** page cache size value. If N is positive then that is the
106544 ** number of pages in the cache. If N is negative, then the
106567 ** database file. If this parameter is set to zero, then memory mapping
106568 ** is not used at all. If N is negative, then the default memory map
106573 ** as little or as much as it wants. Except, if N is set to 0 then the
106633 ** If temporary directory is changed, then invalidateTempStorage.
107186 ** then iDb is set to the index of the database identified by <db>.
107191 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
107398 ** is created. If an existing main database file is opened, then the
107605 ** then 0 is returned. Setting the busy_timeout to 0 or negative
108094 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
108131 ** file was of zero-length, then the DB_Empty flag is also set.
108249 /* If pSchema is NULL, then return -1000000. This happens when code in
108318 ** back and different changes are made in their place, then when this
108560 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
108589 ** characters between zSql8 and zTail8, and then returning a pointer
108825 ** If an illegal or unsupported join type is seen, then still return
109089 ** A and B and the USING clause names X, Y, and Z, then add this
109295 ** If srcTab is negative, then the pEList expressions
109297 ** zero or more, then data is pulled from srcTab and pEList is used only
109370 ** and this row has been seen before, then do not make this row
109469 /* If the destination is DistFifo, then cursor (iParm+1) is open
109496 ** then there should be a single item on the stack. Write this
109527 /* If this is a scalar select that is part of an expression, then
109563 ** pSO->nExpr columns, then make sure all keys are unique by adding a
109579 /* If the destination is DistQueue, then cursor (iParm+1) is open
109686 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
109689 ** then the KeyInfo structure is appropriate for initializing a virtual
109810 ** then the results were placed in a sorter. After the loop is terminated
110006 ** cause this condition to run. Since then, we have restructured how
110032 /* If iCol is less than zero, then the expression requests the
110431 ** the limit and offset. If there is no limit and/or offset, then
110574 ** one. Each row extracted from Queue is output to pDest. Then the single
110577 ** is added back into the Queue table. Then another row is extracted from Queue
110580 ** If the compound query operator is UNION then no duplicate rows are ever
110583 ** discarded. If the operator is UNION ALL, then duplicates are allowed.
110585 ** If the query has an ORDER BY, then entries in the Queue table are kept in
110589 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
110592 ** with a positive value, then the first OFFSET outputs are discarded rather
110802 ** So if this routine is called with p equal to the t3 query, then
111143 /* If [0] is unused then [1] is also unused. So we can
111189 ** If regPrev>0 then it is the first register in a vector that
111191 ** if there has been no previous output. If regPrev>0 then code is
111252 ** then there should be a single item on the stack. Write this
111268 /* If this is a scalar select that is part of an expression, then
111281 ** starting at pDest->iSdst. Then the co-routine yields.
111293 /* If none of the above, then the result destination must be
111298 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
111333 ** co-routines. Then run the co-routines in parallel and merge the results
111382 ** subroutines first, then put the control logic at the bottom. Like this:
111405 ** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
111818 ** subquery first and store the results in a temporary table, then
111908 ** (18) If the sub-query is a compound select, then all terms of the
111915 ** (20) If the sub-query is a compound select, then it must not use
112056 ** subquery is the right term of a LEFT JOIN, then do not flatten.
112062 /* Restriction 17: If the sub-query is a compound SELECT, then it must
112107 /* If the sub-query is a compound SELECT statement, then (by restrictions
112210 ** then this loop only runs once.
112241 ** then expand the outer query to make space for it to hold all elements
112437 ** If all of the above are true, then WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX
112477 ** does match this pattern, then a pointer to the Table object representing
112506 ** INDEXED BY clause, then try to locate the specified index. If there
112605 ** then return a pointer to the CTE definition for that table. Otherwise
112636 ** onto the top of the stack. If argument bFree is true, then this
112686 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
112688 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
112846 ** then create a transient table structure to describe the subquery.
113086 then expression trees
113088 ** when this routine is used for Walker.xExprCallback then
113392 ** encountered, then an appropriate error message is left in
113447 /* If ORDER BY makes no difference in the output then neither does
113617 ** a trigger, then we only need to compute the value of the subquery
113655 ** if the select-list is the same as the ORDER BY list, then this query
113680 /* If there is an ORDER BY clause, then create an ephemeral index to
113683 ** If that is the case, then the OP_OpenEphemeral instruction will be
113753 ** instruction ended up not being needed, then change the OP_OpenEphemeral
113803 ** identical, then it may be possible to disable the ORDER BY clause
113905 ** then loop over the sorting index in order to get the output
113977 ** Then compare the current GROUP BY terms against the GROUP BY terms
114004 ** over to a0,a1,a2. It then calls the output subroutine
114080 /* If isSimpleCount() returns a pointer to a Table structure, then
114143 ** If it is, then ask the code in where.c to attempt to sort results
114145 ** If where.c is able to produce results sorted in this order, then
114154 ** + If the query is a "SELECT min(x)", then the loop coded by
114217 /* If there is an ORDER BY clause, then we need to sort the results
114322 /* If this is the first row, then generate an extra row containing
114565 /* If TEMP was specified, then the trigger name may not be qualified. */
114597 ** then set iDb to 1 to create the trigger in the temporary database.
115075 ** then return TRUE. If pIdList==NULL, then it is considered a
115076 ** wildcard that matches anything. Likewise if pEList==NULL then
115171 ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
115393 ** process of being coded). If this is the case, then an entry with
115451 ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
115460 ** (a copy of pTab->nCol), then registers are populated as follows:
115540 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
115620 ** command. If the latter, then the row-records in the table btree on disk
115623 ** If the former, then all row-records are guaranteed to include a value
115996 ** action, then we need to open all indices because we might need
116044 ** then regNewRowid is the same register as regOldRowid, which is
116080 ** If there are one or more BEFORE triggers, then do not populate the
116279 ** Then loop through the contents of this ephemeral table executing a
116311 /* Allocate nArg registers to martial the arguments to VUpdate. Then
116531 ** restored before returning. Then set the writable-schema flag, and
116926 ** Except, if argument db is not NULL, then the entry associated with
117001 ** or, if the virtual table is stored in a non-sharable database, then
117148 ** created now instead of just being read out of sqlite_master) then
117326 ** into the linked list headed by pTab->pVTable. Then loop through the
117650 ** sqlite3.aVTrans array. Then clear the array itself.
117659 ** sqlite3.aVTrans array. Then clear the array itself.
117679 ** than zero, then this function is being called from within a
117723 ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
117767 ** If pExpr is a column in a virtual table, then let the virtual
118109 ** objects, then computing a particular sequence of WhereLoop objects, with
118177 ** Then a WherePath object is a path through the graph that visits some
118181 ** 1. Then using those as a basis to compute the N best WherePath objects
118212 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
118227 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
118362 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
118581 ** is run and there is an index on (a, b), then this function returns a
118776 ** If all the children of a term are disabled, then that term is also
118786 ** the virtual child terms are valid, then testing of the parent can be
118790 ** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead.
118821 ** SQLITE_AFF_BLOB, then no code gets generated.
118965 ** key value of the loop. If one or more IN operators appear, then
119010 /* Figure out how many memory cells we will need then allocate them.
119084 ** that originated from the LIKE optimization, then change the P3 to be
119354 ** index is on (x,y,z), then the following clauses are all
119369 ** If there are no inequality constraints, then N is at
119415 ** query, then the caller will only allow the loop to run for
119644 ** Then, for each indexed term, the following. The arguments to
119666 ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then
119744 ** Then for every term xN, evaluate as the subexpression: xN AND z
119978 ** then we cannot use the "t1.a=t2.b" constraint, but we can code
120086 ** If the wtFlags argument includes TERM_DYNAMIC, then responsibility
120148 ** collating sequence, then COLLATE operators are adjusted to ensure
120290 ** function, then no OP_Variable will be added to the program.
120317 ** If it is then return TRUE. If not, return FALSE.
120343 ** a join, then transfer the appropriate markings over to derived.
120363 ** a conjunction, then return just pTerm when N==0. If N is exceeds
120382 ** compatible (if one is = and the other is <, for example) then
120463 ** a single table T (as shown in example B above) then create a new virtual
120469 ** then create a new virtual term like this:
120476 ** has x=A (for the same x and A) then add a new virtual conjunct term to the
120485 ** If all subterms are indexable by a single table T, then set
120519 ** If none of cases 1, 2, or 3 apply, then leave the eOperator set to
120711 /* If the right-hand side is also a column, then the affinities
120780 ** returned when it should not be, then incorrect answers might result.
120841 ** If pExpr is a TK_COLUMN column reference, then this routine always returns
120888 ** columns, then the original expression is unchanged and a new virtual
121056 ** for LIKE) then the lower-bound is made all uppercase and the upper-
121453 ** then also write the indices of open cursors used by ONEPASS
121641 ** form X=Y then this routine might also return terms of the form
121645 ** If X is not the INTEGER PRIMARY KEY then X must be compatible with
121689 ** If pIdx!=0 then search for terms matching the iColumn-th column of pIdx
121701 ** then try for the one with no dependencies on <expr> - in other words where
121805 ** this query, then it will not be possible to show that the DISTINCT
121811 /* If any of the expressions is an IPK column on table iBase, then return
121865 ** If the bIncrRowid parameter is 0, then any OP_Rowid instructions on
121867 ** then each OP_Rowid is transformed into an instruction to increment the
121904 ** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines
122214 ** virtual table then allocate space for the aOrderBy part of
122381 ** If pRec contains N fields, where N is more than one, then as well as the
122392 ** Then the search space should ideally be the samples above and the
122462 /* If (res==0) is true, then pRec must be equal to sample i. */
122479 /* if i==0 and iCol==0, then record pRec is smaller than all samples
122480 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
122482 ** If (i>0), then pRec must also be greater than sample (i-1). */
122504 ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec
122540 ** then the return value is the likelihood multiplied by the number of
122691 ** If either of the upper or lower bound is not present, then NULL is passed in
122701 ** then nEq is set to 1 (as the range restricted column, b, is the second
122706 ** then nEq is set to 0.
122710 ** considering the range constraints. If nEq is 0, then *pnOut is the number of
122757 ** The number of rows between the two bounds is then just iUpper-iLower.
122825 ** sample, then assume they are 4x more selective. This brings
123178 ** If X is a proper subset of Y then Y is a better choice and ought
123251 ** If pX is a WhereLoop that pTemplate can supplant, then return the
123255 ** to be added to the list, then return a pointer to the tail of the list.
123265 ** then those WhereLoops need to be considered separately. Neither is
123305 /* If pTemplate is always better than p, then cause p to be overwritten
123330 ** If pBuilder->pOrSet is not NULL then we care about only the
123350 /* If pBuilder->pOrSet is defined, then only keep track of the costs
123391 ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new
123462 ** form "x==EXPR" and EXPR is not a constant 0 or 1, then make sure the
123465 ** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the
123494 ** then use the probability provided by the application. */
123737 ** seek only. Then, if this is a non-covering index, add the cost of
124113 /* If there was an INDEXED BY clause, then only that one index is
124137 ** then mExtra corresponds to (t1, t2) and mUnusable to (t5, t6).
124773 ** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then
124782 ** then
124822 ** terms are out of order, then block-sorting will reduce the
124847 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
124928 ** rows, then do not use the automatic index. */
124933 /* If nLoop is zero, then there are no FROM terms in the query. Since
125294 ** Then the code generated is conceptually like the following:
125345 ** if flag==0 then
125356 ** is called from an UPDATE or DELETE statement, then pOrderBy is NULL.
125361 ** specific cursor. If WHERE_ONEPASS_DESIRED is set, then iIdxCur is
125418 ** pTabList. But if the WHERE_ONETABLE_ONLY flag is set, then we should
125490 ** a table T, then X-1 is the bitmask for all other tables to the left of T.
126037 ** Then the "b" IdList records the list "a,b,c".
126209 ** defined, then do no error processing.
126285 ** Suppose the action integer is N. Then the action is determined as
126291 ** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
126316 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
126778 ** appears in the grammar, then ID becomes a fallback token for X, Y,
126916 ** If NULL, then tracing is turned off.
126918 ** line of trace output. If NULL, then tracing is
126971 "CASE", "WHEN", "THEN", "ELSE",
127238 /* 230 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
127239 /* 231 */ "case_exprlist ::= WHEN expr THEN expr",
127494 ** is popped from the stack, then call it.
127559 ** If the look-ahead token is YYNOCODE, then check to see if the action is
127624 ** If the look-ahead token is YYNOCODE, then check to see if the action is
128478 ** then extract the first few alphanumeric characters from within that
129055 case 230: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
129061 case 231: /* case_exprlist ::= WHEN expr THEN expr */
129358 ** one element off the stack, then we can push the new element back
129524 ** it is legal to shift the error symbol, then shift
129570 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
129586 ** * If the input token is $, then fail the parse.
129674 ** named keywordhash.h and then included into this source file by
129841 testcase( i==21 ); /* THEN */
129959 ** If X is a character that can be used in an identifier then
130273 ** then an and attempt is made to write an error message into
130547 /* If triggers are not supported by this compile then the statement machine
130885 ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
130894 ** name of a directory, then that directory will be used to store
130903 ** name of a directory, then that directory will be used to store
130924 ** thread has finished the initialization process, then the subsequent
130932 ** thread. Then while the initial invocation of this routine by X is
130960 /* If SQLite is already completely initialized, then this call
131005 /* If rc is not SQLITE_OK at this point, then either the malloc
131100 ** when this routine is invoked, then this routine is a harmless no-op.
131320 ** is NULL, then SQLite reverts to using its default memory allocator
131329 /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
131371 ** argument of type int. If non-zero, then URI handling is globally
131372 ** enabled. If the parameter is zero, then URI handling is globally
131404 ** negative, then that argument is changed to its compile-time default.
131453 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
131614 ** If the padFlag argument is not NULL then space padding at the end
131829 /* Convert the connection into a zombie and then close it.
131855 ** finished, then free all resources.
131863 ** then just leave the mutex and return.
131975 ** Rollback all database files. If tripCode is not SQLITE_OK, then
131991 ** here, then another shared-cache connection might sneak in between
132398 ** and there are active VMs, then return SQLITE_BUSY. If a function
132529 ** If the function already exists as a regular global function, then
132530 ** this routine is a no-op. If the function does not exist, then create
132618 ** If the invoked function returns non-zero, then the commit becomes a
132848 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
132977 ** above. If this is the case, then the db->mallocFailed flag needs to
133066 ** then any copies made by synthCollSeq() need to be invalidated.
133227 ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
134211 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
134310 ** is enabled, then the return value is true. If X is true and
134311 ** assert() is disabled, then the return value is zero. If X is
134312 ** false and assert() is enabled, then the assertion fires and the
134313 ** process aborts. If X is false and assert() is disabled, then the
134334 ** default setting. If the return value is 1, then ALWAYS() is either
134405 ** If zWord is a keyword recognized by the parser, then return the
134423 ** If sz>0 then allocate a scratch buffer into pNew.
134500 ** Enable imposter mode only when the schema has already been parsed. Then
134502 ** the parsed schema. Then turn imposter mode back off again.
134504 ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
134675 ** 3) If the argument db is not NULL, then none of the entries in the
134760 ** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
134767 ** on the same "db". If xNotify==0 then any prior callbacks are immediately
134838 ** set to db, then set pBlockingConnection=0.
134841 ** set to db, then invoke the configured unlock-notify callback and
134903 ** array already accumulated. We can then clear the array and
135062 ** (72-2) and then terminates with the 0 at K.
135183 ** If the root node is a leaf node, then start_block,
135313 ** If tokenizers are to be allowed to call sqlite3_*() functions, then
135356 ** then argc is set to 2, and the argv[] array contains pointers
135360 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
135852 ** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index
135862 ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
135930 ** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist
136263 ** input does not begin with a quote character, then this routine
136282 /* If the first byte was a '[', then the close-quote character is a ']' */
136377 ** and then evaluate those statements. The success code is written
136380 ** If *pRc is initially non-zero then this routine is a no-op.
136489 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
136675 ** from left to write. If parameter zFunc is not NULL, then instead of
136733 ** If argument zFunc is not NULL, then all but the first question mark
136772 ** value. It reads the integer and sets *pnOut to the value read, then
137554 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
137597 /* If no row was found and no error has occurred, then the %_content
137619 ** If piFirst is not NULL, then this function sets *piFirst to the blockid
137622 ** If piLast is not NULL, then *piLast is set to the right-most child node
137645 ** interior node. Then load the blockid of the left-child of the b-tree
137650 ** root node, then the buffer comes from a SELECT statement. SQLite does
137654 ** table, then there are always 20 bytes of zeroed padding following the
137698 ** to the term from the interior node, then all terms on the sub-tree
137702 ** If the interior node term is larger than the specified term, then
137735 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
137737 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
137817 ** If pp is not NULL, then the contents of the position list are copied
137827 ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
137831 ** immediately preceded by a byte with the 0x80 bit set. Then increments
137863 ** If pp is not NULL, then the contents of the column-list are copied
138027 ** Then the position list for this row for token 'b' would consist of:
138214 ** called, if *pp points to pEnd or greater, then the end of the buffer
138217 ** If *pp does not point to or past pEnd, then a single varint is read
138218 ** from *pp. *pp is then set to point 1 byte past the end of the read varint.
138251 ** If *pbFirst is non-zero when this function is called, then the value
138282 ** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2).
138326 ** then the first docid in each list is simply encoded as a varint. For
138342 ** then the encoding of the first docid from the 'other' input list may
138686 ** for the pending-terms. If this is a scan, then this call must be being
138919 ** If the isPoslist argument is true, then it is assumed that the doclist
138981 ** If the numeric type of argument pVal is "integer", then return it
139000 ** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against
139003 ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
139006 ** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The
139354 ** set. So to find the start of the poslist, skip forward 2 bytes then
139376 ** sizeof(Fts3Cursor*), then the blob contents are copied to the
139721 ** of the sqlite library, then this function is called directly by
139831 ** there exists prefix b-tree of the right length) then it may be traversed
139833 ** doclist and then traversed.
140083 ** If parameter bOptOk is true, then the phrase may (or may not) use the
140270 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
140347 ** If there is no "next" entry and no error occurs, then *pbEof is set to
140450 ** If there is no "next" entry and no error occurs, then *pbEof is set to
140484 ** If parameter bOptOk is zero, then it is guaranteed that the
140487 ** Or, if bOptOk is non-zero, then one or more tokens within the expression
140597 ** this database, then the average docsize is 1. Otherwise, it is 1 plus
140719 ** Then, for each token, defer it if loading the doclist would result in
140864 ** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to
140922 ** at EOF, then the following variables are populated with the position list
140936 ** more non-deferred tokens, then the expression is advanced to the
141077 ** cluster, then this function returns 1 immediately.
141204 ** then any snippet() should ony highlight the "a" term, not the "b"
141294 ** token. Then, see if this row is really a match, considering deferred
141438 ** of a NEAR expression, then it also allocates and populates the same array
141543 ** * If a phrase consists entirely of deferred tokens, then all output
141552 ** * If the phrase is part of a NEAR expression, then only phrase instances
141638 ** itself is not EOF, then it may point to an earlier entry. */
142098 ** integer encountered in state 1 is not 0 or 1, then we need to
142357 ** is defined, then it uses the new syntax. The differences between
142371 ** If compiled with SQLITE_TEST defined, then this module exports the
142586 ** then free the old allocation.
142814 /* See if we are dealing with a quoted phrase. If this is the case, then
143341 ** If parameter n is a negative number, then z is assumed to point to a
143479 ** If the second argument is not NULL, then its contents are prepended to
143480 ** the returned expression text and then freed using sqlite3_free().
143958 ** If no element exists with a matching key, then a new
143962 ** If another element already exists with the same key, then the
143964 ** The key is not copied in this instance. If a malloc fails, then
143967 ** If the "data" parameter to this function is NULL, then the
144202 ** C be sequence of one or more consonants. Then every word can be
144290 ** of the word that preceeds the zFrom ending, then change the
144322 ** it contains digits) then word is truncated to 20 or 6 bytes
144365 ** in [a-zA-Z] then no stemming is attempted and this routine just
144740 ** to the string <key-name>. If <pointer> is not specified, then
145266 ** track such information in the database, then we'd only want this
145529 ** single block of memory. It then dequotes any of the strings that appear
145920 ** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer
146169 ** If argument apVal is not NULL, then it must point to an array with
146397 ** writing data to the fts3 table. If this lock is not acquired first, then
147059 ** NULL, then a buffer is allocated using sqlite3_malloc() and populated
147066 ** paBlob is non-NULL, then it is the responsibility of the caller to
147290 ** of these statements is untrue, then the data structure is corrupt.
147330 ** If arguments ppOffsetList and pnOffsetList are not NULL, then
147548 ** If the isPrefixIter parameter is zero, then the returned SegReader iterates
147552 ** "firebird", then the iterator visits the following 'terms' (in the order
148006 ** database. Then call this function recursively to write the parent of
148198 ** If the isCopyTerm parameter is true, then the buffer pointed to by
148457 ** If there are no entries in the input position list for column iCol, then
148460 ** If parameter bZero is non-zero, then any part of the input list following
148603 ** for, then advance each segment iterator until it points to a term of
148686 ** then the entire doclist for the term is available in
148736 ** forward. Then sort the list in order of current term again.
148758 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
148973 /* If nSize==0, then the %_segdir.end_block field does not not
149251 ** two. If nCol is the number of user defined columns, then values of the
149375 ** created using the content=xxx option, then the new index is based on
149729 ** Then allocate a new, empty sibling node. The key will be written
149762 ** If the size of the value in blob pPrev is zero, then this is the first
149901 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
150022 ** is, then a NULL entry has been inserted into the %_segments table
150662 ** and then remove the entry. Write the two values read to *piAbsLevel and
150758 /* If nSeg is less that zero, then there is no level with at least
151454 ** value, then this operation requires constraint handling.
151458 ** if the on-conflict mode is other than REPLACE, then this method must
151476 ** rowid column. So if the conflict mode is REPLACE, then delete any
151874 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
151877 ** pnToken is not NULL, then it is set to the number of tokens in all
152109 /* Initialize the contents of the SnippetIter object. Then iterate through
152156 ** If nAppend is negative, then the length of the string zAppend is
152339 ** Then break out of the loop. */
152493 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
152756 ** If bGlobal is true, then populate all fields of the matchinfo() output.
152757 ** If it is false, then assume that those fields that do not change between
152902 /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the
153907 ** If the least significant bit in flags is clear, then the rule applies
153909 ** need to be folded). Or, if it is set, then the rule only applies to
153913 ** array. If a specific codepoint C does require folding, then its lower
154080 ** 1. If the node is the root node (node 1), then the first 2 bytes
154197 ** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will
154742 ** an internal node, then the 64-bit integer is a child page number.
155142 ** If the rScore is a tie, then use iLevel as the tie breaker with smaller
155144 ** SearchPoints, then iLevel becomes the deciding factor and the result
155685 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
155747 ** and then a linear search of an R-Tree node. This should be
156285 ** all cells from node pLeft. Then zero the original node.
156868 ** In the first case, if the conflict-handling mode is REPLACE, then
157160 ** If this function is being called as part of an xConnect(), then the rtree
157447 ** parameters to this function, then return that RtreeMatchArg object
157782 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
157806 ** then the result is also NULL.
158442 then a
158511 ** Then the RBU database should contain:
158539 ** then the RBU database should contain:
158654 ** apply the update to the target database, then the RBU database
158679 ** If an RBU update is started and then suspended before it is completed,
158680 ** then an external client writes to the database, then attempting to resume
158820 ** then the new RBU VFS uses the default system VFS to access the file-system.
159243 ** then this routine returns -1.
159426 ** If an error has occurred, then set *pzErrmsg to point to a buffer
159666 ** than SQLITE_OK), then this function returns NULL without modifying the
159815 ** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
159816 ** if the table does have an external primary key index, then *piPk
160451 ** then the imposter table schema is:
160831 ** If the zMask string does not specify any columns to update, then this
160961 ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use.
160980 ** three characters, then shorten the suffix on z[] to be the last three
160983 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
161036 ** If argument pState is not NULL, then the incremental checkpoint is
161039 ** object, then the rbu handle is set to DONE state. This occurs if some
161045 /* If pState is NULL, then the wal file may not have been opened and
161204 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
161287 ** If RBU_UPDATE is returned, then output variable *pzMask is set to
161955 ** then edit any error message string so as to remove all occurrences of
162078 ** Then, when xOpen() is called to open the *-wal file associated with
162903 ** If the paths are sorted using the BINARY collation sequence, then
164473 ** If pApnd!=0, then try to append new nodes to complete zPath if it is
164627 ** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
164806 ** PATH element. If there are multiple PATHs, then return a JSON array
165768 ** "auxiliary data". The pointer may then be retrieved by the current or any
165774 ** more than once for a single FTS query, then all invocations share a
165778 ** invoked, then it is replaced by the new pointer. If an xDelete callback
165796 ** If the bClear argument is non-zero, then the auxiliary data is cleared
165948 ** If an xToken() callback returns any value other than SQLITE_OK, then
165973 ** "first" and "place". If the user then queries for '1st + place',
165980 ** FTS5 then queries the index for each synonym individually. For
166035 ** token "first" is subsituted for "1st" by the tokenizer, then the query:
166227 ** then an object of the following type is used to record the set of columns.
166945 ** defined, then do no error processing.
167009 ** Suppose the action integer is N. Then the action is determined as
167015 ** N between fts5YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
167040 ** a reduce action) then the fts5yy_reduce_ofst[] array is used in place of
167104 ** appears in the grammar, then ID becomes a fallback token for X, Y,
167172 ** If NULL, then tracing is turned off.
167174 ** line of trace output. If NULL, then tracing is
167346 ** is popped from the stack, then call it.
167411 ** If the look-ahead token is fts5YYNOCODE, then check to see if the action is
167476 ** If the look-ahead token is fts5YYNOCODE, then check to see if the action is
167782 ** one element off the stack, then we can push the new element back
167948 ** it is legal to shift the error symbol, then shift
167994 /* If the fts5YYNOERRORRECOVERY macro is defined, then do not attempt to
168010 ** * If the input token is $, then fail the parse.
168694 ** the printf() style processing, then appends the results to buffer pBuf.
168849 ** is non-negative, then it is the length of the string in bytes. Otherwise,
169075 ** input does not begin with a quote character, then this routine
170608 ** the maximum rowid. Or, if the iterator is "ORDER BY rowid DESC", then it
170818 ** This means that if the iteration order is ASC, then numerically larger
170834 ** bFromValid is zero, then pNode is advanced exactly once. Or, if argument
170835 ** bFromValid is non-zero, then pNode is advanced until it is at or past
171032 ** then the first document visited must have a rowid smaller than or
171117 ** If argument pNear is NULL, then a new Fts5ExprNearset object is allocated
172557 ** Then, for each level from 0 to nMax:
172569 ** The first value is the number of rows in the index. Then, for each column
172627 ** footer is 0 bytes in size, then this field is the same as the
173587 ** the next populated level, then that segment, and any other adjacent
174335 /* If this condition is true then the largest rowid for the current
174362 /* If pLast is NULL at this point, then the last rowid for this doclist
174367 ** Or, if pLast is non-NULL, then it is the page that contains the last
174427 ** If the specified term is found on the page, then the iterator is left
174431 ** If bGe is non-zero and the specified term is not found, then the
174791 ** If the returned value is non-zero, then it is the index of an entry
175092 ** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
175690 /* Append the number of bytes of new data, then the term data itself
176077 /* If nBest is still 0, then the index must be empty. */
176519 ** the position list contains entries for column iCol, then (*pa) is set
176562 ** If argument pColset is NULL, then the position list is filtered according
177079 /* If the QUERY_TEST_NOIDX flag was specified, then this must be a
178364 ** then this variable contains the result of the query.
178954 ** is using. Then attempt to move the cursor to a rowid equal to or laster
179328 /* If pSortCsr is non-NULL, then this call is being made as part of
180672 ** defined), then sqlite3_open() will call sqlite3Fts5Init() directly.
182225 ** then the next token. */
183289 ** If the least significant bit in flags is clear, then the rule applies
183291 ** need to be folded). Or, if it is set, then the rule only applies to
183295 ** array. If a specific codepoint C does require folding, then its lower
183890 ** then:
