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"),
26844 ** If we compile with the SQLITE_TEST macro set, then the following block
27175 ** then return the name of the first system call. Return NULL if zName
27207 ** If the file creation mode "m" is 0 then set it to the default for
27209 ** 0644) as modified by the system umask. If m is not 0, then
27216 ** transaction crashes and leaves behind hot journals, then any
27614 ** one is a hard or symbolic link to the other) then if you set
27615 ** an exclusive lock on fd1, then try to get an exclusive lock
27763 /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
28074 ** If the pFile was opened read/write from unix-excl, then the only lock
28227 ** has a SHARED or RESERVED lock, then increment reference counts and
28264 /* If control gets to this point, then actually go ahead and make
28383 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
28384 ** the byte range is divided into 2 parts and the first part is unlocked then
28385 ** set to a read lock, then the other part is simply unlocked. This works
28774 /* If we have any lock, then the lock file already exists. All we have
29377 /* if we failed to get the lock then someone else must have it */
29462 ** has a SHARED or RESERVED lock, then increment reference counts and
29491 /* If control gets to this point, then actually go ahead and make
29727 ** is available. If you don't compile for a mac, then the "unix-afp"
29768 ** Seek to the offset passed as the second argument, then read cnt
29771 ** NB: If you define USE_PREAD or USE_PREAD64, then it might also
29887 ** absolute offset iOff, then attempt to write nBuf bytes of data from
29932 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
29970 ** normal database file) then record the fact that the database
30040 ** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC
30109 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
30194 ** If dataOnly==0 then both the file itself and its metadata (file
30195 ** size, access time, etc) are synced. If dataOnly!=0 then only the
30367 ** within the extended region. Then, if required, a single byte
30411 ** If *pArg is initially negative then this is a query. Set *pArg to
30414 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
30609 ** then it isn't valid.*/
30875 ** is "/home/user1/config.db" then the file that is created and mmapped
30880 ** from the database file is used, then differing access permissions
30894 ** file are currently open, in this process or in other processes, then
31041 ** separate process), then
31046 ** this call as described above, then it is mapped into this processes
31276 /* Get the exclusive locks at the system level. Then if successful
31312 ** If there is no shared memory associated with the connection then this
31343 /* If pShmNode->nRef has reached 0, then close the underlying
31476 ** If parameter nByte is non-negative, then it is the requested size of
31477 ** the mapping to create. Otherwise, if nByte is less than zero, then the
31551 ** If the third argument is non-NULL, then this function releases a
31556 ** Or, if the third argument is NULL, then this function is being called
31565 /* If p==0 (unmap the entire file) then there must be no outstanding
31567 ** then there must be at least one outstanding. */
31775 ** for the database file "filePath". It then returns the sqlite3_io_methods
31841 ** locking works. If it does, then that is what is used. If it does not
31842 ** work, then fallback to named semaphore locking.
31970 ** descriptors on this file, then no malloc would be required by
31975 ** If scenario (a) caused the error then things are not so safe. The
32168 ** If a suitable file descriptor is found, then it is returned. If no
32215 ** to create new files with. If no error occurs, then SQLITE_OK is returned
32223 ** But if the file being opened is a WAL or regular journal file, then
32229 ** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the
32357 ** (b) if CREATE is set, then READWRITE must also be set, and
32358 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
32359 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
32733 ** (That assignment requires a cast.) Then we call the function that
32737 ** you really cannot cast a function pointer into void*. But then, on the
33004 ** host ID and/or proxy path, then the lock is escalated to an exclusive
33182 ** the parent directories and then try again.
33299 ** Takes an open conch file, copies the contents to a new path and then moves
33662 ** If pFile holds a lock on a conch file, then release that lock.
33828 ** (c) the file system is read-only, then enable no-locking access.
33860 ** switch the locking context and pMethod then return.
33909 ** switching proxy locking mode off then it will need to fail if
34068 /* restore the original locking context and pMethod then close it */
34375 ** If we compile with the SQLITE_TEST macro set, then the following block
35569 ** then return the name of the first system call. Return NULL if zName
36516 /* If shared memory could not be created, then close the mutex and fail */
36617 /* If no pending lock has been acquired, then acquire it */
37200 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
37518 /* If we are holding a PENDING lock that ought to be released, then
37525 /* Update the state of the lock has held in the file descriptor then
37580 ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
37617 ** If *pArg is initially negative then this is a query. Set *pArg to
37620 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
37991 ** file are currently open, in this process or in other processes, then
38130 /* If pShmNode->nRef has reached 0, then close the underlying
38231 /* Get the exclusive locks at the system level. Then if successful
38274 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
38279 ** this call as described above, then it is mapped into this processes
38463 ** If parameter nByte is non-negative, then it is the requested size of
38464 ** the mapping to create. Otherwise, if nByte is less than zero, then the
38602 ** If the third argument is non-NULL, then this function releases a
38607 ** Or, if the third argument is NULL, then this function is being called
38615 /* If p==0 (unmap the entire file) then there must be no outstanding
38617 ** then there must be at least one outstanding. */
38630 ** file while a mapping is held, then the following winUnmapfile() call
39058 ** (b) if CREATE is set, then READWRITE must also be set, and
39059 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
39060 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
39937 ** then it is not necessary to include the nul-terminator character
40128 ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
40131 ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
40176 ** i is out of range, then return false.
40238 /* completely fill the hash, then just add it without */
40348 ** Then the following macros can be used to set, clear, or test
40582 /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the
40586 /* IMPLEMENTATION-OF: R-61436-13639 If the argument N is negative, then
40600 /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
40678 ** If the createFlag is 0, then NULL is always returned if the page
40679 ** is not already in the cache. If createFlag is 1, then a new page
40720 ** size limit has been reached, then this routine can be invoked to
40722 ** callback to spill dirty pages to the journal. It will then try to
40823 ** reference count drops to 0, then it is made eligible for recycling.
40934 ** function is 0, then the data area associated with page 1 is zeroed, but
41152 ** If the default page cache implementation is overridden, then neither of
41178 ** If SQLITE_PCACHE_SEPARATE_HEADER is defined, then the extension is obtained
41206 ** If N is positive, then N pages worth of memory are allocated using a single
41208 ** Or if N is negative, then -1024*N bytes of memory are allocated and used
41625 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
41632 ** under memory pressure, then again it is desirable to avoid
41690 ** LRU list, then this function is a no-op.
42057 ** 3. If createFlag is 1, and the page is not already in the cache, then
42081 ** then attempt to recycle a page from the LRU list. If it is the right
42104 /* Step 2: If the page was found in the hash table, then return it.
42419 ** two TESTs where the TESTs have the same batch nubmer, then the
42701 ** list contains too few elements, then construct an incomplete tree
42821 ** on pRowSet->pEntry, then sort those entries into the forest at
43023 ** the last call, then return 0.
43099 ** (6) If a master journal file is used, then all writes to the database file
43228 ** * If the database is a WAL database, then the WAL connection is open.
43348 ** layer then attempts a rollback operation. If the error condition
43451 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
43465 ** the savepoint is active, then iHdrOffset is set to the byte offset
43577 ** This is a boolean variable. If true, then any required sub-journal
43578 ** is opened as an in-memory journal file. If false, then in-memory
43620 ** to measure the database file on disk, and then truncates it if required.
43766 ** file after power is restored. If an attempt is then made
44172 ** then the value returned is the size of the journal file when it
44200 ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
44253 ** nul-terminator), then this is handled as if no master journal name
44257 ** file, then it is copied into the buffer pointed to by zMaster. A
44294 /* If the checksum doesn't add up, then one or more of the disk sectors
44340 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
44347 ** journal file in bytes is larger than this value, then truncate the
44478 ** journal header consumes to the journal file here. Then increment the
44599 ** invalid, then the process that wrote the journal-header must have
44615 ** created by a process other than this one, then this routine
44693 /* If the pager is in peristent-journal mode, then the physical
44803 /* If the operating system support deletion of open files, then
44873 ** the persistent error occurred, then the rollback journal may need
44907 ** If the journal file is open, then it is "finalized". Once a journal
44940 ** database then the IO error code is returned to the user. If the
44941 ** operation to finalize the journal file fails, then the code still
44943 ** unlock operation fails as well, then the first error code related
44960 ** lock switches back to locking_mode=normal and then executes a
45082 ** malloc error occurs during a rollback, then this will itself cause
45169 ** is greater than the current value of Pager.dbSize, then playback is
45172 ** If pDone is not NULL, then it is a record of pages that have already
45174 ** (if the corresponding pDone bit is set) then skip the playback.
45179 ** and played back, then SQLITE_OK is returned. If an IO error occurs
45181 ** to the database file, then the IO error code is returned. If data
45192 ** If this is a savepoint rollback, then memory may have to be dynamically
45262 ** rollback, then don't bother to play it back again.
45275 /* If the pager is in CACHEMOD state, then there must be a copy of this
45280 ** and a page is moved during an incremental vacuum then the page may
45282 ** during a Movepage() call, then the page may not be in the cache
45286 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
45287 ** pager cache if it exists and the main file. The page is then marked
45295 ** then changed again within the statement. When rolling back such a
45351 ** if the page is on the free-list at the start of the transaction, then
45352 ** populated, then moved using sqlite3PagerMovepage().
45356 ** and if the pager requires a journal-sync, then mark the page as
45382 ** journal file, then its content must be as they were when the
45389 ** unsynced portion of the main journal file, then it is not safe
45395 ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
45405 /* If this was page 1, then restore the value of Pager.dbFileVers.
45559 ** If the file on disk is currently larger than nPage pages, then use the VFS
45632 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
45665 ** in the journal. If this value is 0xffffffff, then compute the
45699 ** journal file then all pages up to the first corrupted page are rolled
45701 ** is then deleted and SQLITE_OK returned, just as if no corruption had
45737 ** present on disk, then the journal is not hot and does not need to be
45765 ** it is corrupted, then a process must have failed while writing it.
45776 /* If nRec is 0xffffffff, then this journal was created by a process
45787 ** process and if this is the final header in the journal, then it means
45867 ** before the transaction was committed, then the change-counter
45869 ** mode, then subsequent transactions performed by the connection will not
45916 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
45919 ** If an IO error occurs, then the IO error is returned to the caller.
46277 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
46283 ** being rolled back), then the rollback consists of up to three stages,
46291 ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
46295 ** * Pages are then played back from the sub-journal file, starting
46304 ** If pSavepoint is NULL, then pages are only played back from the main
46479 ** single disk sector is atomic, then this mode provides
46597 ** retried. If it returns zero, then the SQLITE_BUSY error is
46634 ** then the pager object page size is set to *pPageSize.
46636 ** If the page size is changed, then this function uses sqlite3PagerMalloc()
46644 ** then *pPageSize is set to the old, retained page size before returning.
46792 ** However, if the file is between 1 and <page-size> bytes in size, then
46878 ** then continue writing to the database.
46899 ** syncs the journal file to disk, then sets pPager->journalHdr to the
47029 ** If this is not done, then an unsynced portion of the open journal
47085 ** If the Pager.noSync flag is set, then this function is a no-op.
47093 ** then the nRec field of the most recently written journal header
47096 ** mode, then the journal file is synced before this field is updated.
47098 ** * If the device does not support the SEQUENTIAL property, then
47113 ** error is encountered, then the IO error code is returned to the caller.
47136 ** mode, then the journal file may at this point actually be larger
47142 ** transaction), then SQLite may become confused when doing the
47144 ** of this connections data, then proceed to rolling back the old,
47148 ** a valid header following Pager.journalOff, then write a 0x00
47250 ** is updated accordingly. If page 1 is written out, then the value cached
47433 ** made clean for some other reason, but no error occurs, then SQLITE_OK
47509 ** If zFilename is NULL then a randomly-named temporary file is created
47511 ** automatically when they are closed. If zFilename is ":memory:" then
47874 ** does not exist, then the journal file is not really hot. In this
47908 ** call above, but then delete the journal and drop the lock before
47939 ** If there is, then we consider this journal to be hot. If not,
47961 ** This might be a false positive. But if it is, then the
47986 ** on the database file), then an attempt is made to obtain a
47996 ** then an attempt is made to clear the error state by discarding
48029 ** database file, then it either needs to be played back or deleted.
48117 ** the file. If the unlock attempt fails, then Pager.eLock must be
48141 /* The shared-lock has just been acquired then check to
48177 ** may have truncated the database file and then extended it back
48245 ** already in the cache when this function is called, then the extra
48250 ** requested page is not already stored in the cache, then no
48263 ** If noContent is true, then the data returned is zeroed instead of
48478 ** If the number of references to the page drop to zero, then the
48510 ** then this function just writes a journal header to the start of the
48596 ** If the exFlag argument is false, then acquire at least a RESERVED
48597 ** lock on the database file. If exFlag is true, then acquire at least
48601 ** If the subjInMemory argument is non-zero, then any sub-journal opened
48605 ** sub-journal. If the subjInMemory argument is zero, then any required
48639 ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
48699 ** then corruption may follow.
48757 ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
48773 ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC.
48803 ** then write the page into the statement journal.
48886 ** starting at pg1, then it needs to be set for all of them. Because
48984 ** If the isDirectMode flag is zero, then this is done by calling
48985 ** sqlite3PagerWrite() on page 1, then modifying the contents of the
48991 ** if isDirect is non-zero, then the database file is updated directly
49004 ** atomic-write optimization is enabled in this build, then isDirect
49138 ** If the final parameter - noSync - is true, then the database file itself
49202 ** If the optimization was not enabled at compile time, then the
49206 ** to make sure the journal file has actually been created, then call
49211 ** then call pager_incr_changecounter() to update the change-counter
49228 ** to include the updated change counter and then write page 1
49246 ** or if zMaster is NULL (no master journal), then this call is a no-op.
49274 ** image was extended as part of the current transaction and then the
49332 ** using persistent journals, then this function is a no-op.
49357 ** If a write transaction is open, then all changes made within the
49380 ** WAL files. The WAL transaction is then closed.
49517 ** currently less than nSavepoints open, then open one or more savepoints
49519 ** equal to nSavepoint, then this function is a no-op.
49522 ** occurs while opening the sub-journal file, then an IO error code is
49588 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
49589 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
49596 ** (Pager.nSavepoint-1), then this function is a no-op.
49598 ** If a negative value is passed to this function, then the current
49606 ** then savepoint iSavepoint is also destroyed.
49623 ** operation. Store this value in nNew. Then free resources associated
49662 ** Except, if the pager is in-memory only, then return an empty string if
49765 ** If the fourth argument, isCommit, is non-zero, then this page is being
49794 ** savepoint, then save the current contents of the page into the
49798 ** <journal page X, then modify it in memory>
49869 /* If needSyncPgno is non-zero, then the journal file needs to be
49932 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
50027 ** not possible, then that is not a problem. Deleting the journal file
50346 ** WAL can fill up with frames and then be checkpointed and then new
50407 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
50408 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
50421 ** first checks the WAL to see if it contains page P. If so, then the
50425 ** frame or are followed by a commit frame, then page P is read from
50520 ** Then start scanning entries of the hash table, starting with iKey
50528 ** no hash slot such that aHash[i]==p) then page P is not in the
50585 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
50647 ** holds read-lock K, then the value in aReadMark[K] is no greater than
50667 ** in the WAL has been backfilled into the database) then new readers
50675 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
50709 ** If the LSB is set, then the checksums for each frame within the WAL
50835 ** then an SQLite error code is returned and *ppPage is set to 0.
51318 /* If the entry in aPgno[] is already set, then the previous writer
51655 ** number larger than *piPage, then return 1.
51924 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
52147 ** entire wal file has been copied into the database file, then block
52282 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
52302 ** When reading, read [0] first then [1]. Writes are in the reverse order.
52424 ** checkpointed. If useWal==0 then this routine calls walIndexReadHdr()
52449 ** Or if pWal->readLock==0, then the reader will ignore the WAL
52451 ** If the useWal parameter is 1 then the WAL will never be ignored and
52503 ** then convert BUSY errors to WAL_RETRY. If recovery is known to
52614 ** happened, then reading the database with the current value of
52633 ** frame pWal->hdr.mxFrame - then the client would incorrectly assume
52663 ** transaction, then *pChanged is set to 1 before returning. The
52714 /* If the "last page" field of the wal-index header snapshot is 0, then
52717 ** then the WAL is ignored by the reader so return early, as if the
52838 ** the read transaction was started, then it is not possible for this
52865 ** time the read transaction on this connection was started, then
52919 ** (b) has an outstanding reference, then xUndo is either a no-op
53006 ** readers are currently using the WAL), then the transactions
53053 ** first write the part before iSyncPoint, then sync, then write the
53127 /* If this frame set completes a transaction, then nTruncate>0. If
53128 ** nTruncate==0 then this frame set does not complete the transaction. */
53211 /* If this is the end of a transaction, then we might need to pad
53216 ** or synchronous==OFF, then no padding or syncing are needed.
53218 ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
53219 ** needed and only the sync is done. If padding is needed, then the
53241 ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
53294 ** Obtain a CHECKPOINT lock and then backfill as much information as
53387 ** performed, then the pager-cache associated with pWal is now
53406 ** the last call, then return 0.
53421 ** If op is zero, then
53424 ** or if the acquisition of the lock fails, then return 0. If the
53429 ** If op is one, then change from locking_mode=NORMAL into
53436 ** If op is negative, then do a dry-run of the op==1 case but do
53560 ** page. If the payload is larger than the preset amount then surplus
53617 ** If the payload for a cell is larger than the max payload, then extra
53765 ** the header, then your custom library will not be able to read
54117 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
54275 ** If the object is not sharable, then no mutex is ever required
54284 ** p, then first unlock all of the others on p->pNext, then wait
54285 ** for the lock to become available on p, then relock all of the
54306 /* Unless the database is sharable and unlocked, then BtShared.db
54336 ** BtShared address. Then acquire our lock. Then reacquire
54476 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
54478 ** If pSchema is not NULL, then iDb is computed from pSchema and
54501 ** If shared cache is disabled, then all btree mutex routines, including
54624 ** shared-cache feature disabled, then there is only ever one user
54672 ** and has the read-uncommitted flag set, then no lock is required.
54682 ** not loaded, then it is too difficult to actually check to see if
54740 ** read-uncommitted flag set, then it is OK for the other object to
54777 /* If requesting a write-lock, then the Btree must have an open write
54803 ** since we know that if eLock==WRITE_LOCK, then no other connection
54901 ** transaction. If it does not, then the BTS_PENDING flag
54934 ** that writer, then the number of locks held by connections other
54938 ** If there is not currently a writer, then BTS_PENDING must
55000 ** If argument isClearTable is true, then the entire contents of the
55004 ** Otherwise, if argument isClearTable is false, then the row with
55053 ** a page is moved to the free-list and then reused within the same
55056 ** is extracted from the free-list and reused, then the original data
55122 ** If the cursor is open on an intkey table, then the integer key
55124 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
55137 /* If this is an intKey table, then the above call to BtreeKeySize()
55140 ** table, then malloc space for and store the pCur->nKey bytes of key
55200 ** If there are two or more cursors on the same btree, then all such
55206 ** then the BTCF_Multiple flag on pExpect is cleared, to avoid another
55265 ** record and then call BtreeMovetoUnpacked() to do the work.
55412 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
55916 ** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned.
56005 ** then the cell content offset of an empty page wants to be 65536.
56019 ** array entry offset, and if the freelist is not empty, then search the
56130 ** pointer in the page header) then check to see if iStart should be
56230 ** not contain a well-formed database page, then return
56284 ** possible for a root page of a table that contains no rows) then the
56349 ** of the page, then the page must be corrupted. This check also
56472 ** If pCur!=0 then the page is being fetched as part of a moveToChild()
56479 ** If an error occurs, then *ppPage is undefined. It
56619 ** then an ephemeral database is created. The ephemeral database might
56624 ** If zFilename is ":memory:" then an in-memory database is created
56631 ** and we are in shared cache mode, then the open will fail with an
56807 /* If the magic name ":memory:" will create an in-memory database, then
56810 ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
56859 /* If the new Btree uses a sharable pBtShared, then link the new
57137 ** size supplied does not meet this constraint then the page size is not
57145 ** If parameter nReserve is less than zero, then the number of reserved
57148 ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
57211 ** If SQLITE_HAS_MUTEX is defined then the number returned is the
57242 ** then make no changes. Always return the value of the BTS_SECURE_DELETE
57260 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
57310 ** well-formed database file, then SQLITE_CORRUPT is returned.
57364 ** in WAL mode. If the log is not already open, open it now. Then
57434 ** be less than 480. In other words, if the page size is 512, then the
57487 ** false then all cursors are counted.
57506 ** of a transaction but there is a read lock on the database, then
57525 ** If pBt points to an empty file then convert that empty file
57604 ** and the database was previously unlocked, then invoke the busy handler
57745 ** the sub-journal is not already open, then it will be opened here.
57901 /* If pDbPage was a btree-page, then it may have child pages and/or cells
57905 ** If pDbPage is an overflow page, then the first 4 bytes may store a
57906 ** pointer to a subsequent overflow page. If this is the case, then
58021 ** On the other hand, if bCommit is greater than zero, then keep
58126 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
58189 ** the journal. Then the contents of the journal are flushed out to
58288 ** is non-zero then this b-tree transaction is part of a multi-file
58345 ** references. Or if the writeOnly flag is set to 1, then only
58353 ** flag is true, then only write-cursors need be tripped - read-only
58403 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
58506 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
58540 ** on the database already. If a write-cursor is requested, then
58543 ** If wrFlag==0, then the cursor can only be used for reading.
58544 ** If wrFlag==1, then the cursor can be used for reading or for
58562 ** root page of a b-tree. If it is not, then the cursor acquired
58613 /* If there are two or more cursors on the same btree, then all such
58799 ** to page number pOvfl was obtained, then *ppPage is set to point to that
58802 ** the pointer-map was used to obtain the value for *pPgnoNext), then
58866 ** If argument eOp is false, then nByte bytes of data are copied
58868 ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
59031 ** page-list cache, if any, then fall back to the getOverflowPage()
59035 ** here. If eOp==2, then offset==0 and this branch is never taken.
59069 ** then data can be read directly from the database file into the
59170 ** key/data is written into *pAmt. If *pAmt==0, then the value
59177 ** onto overflow pages, then accessPayload() must be used to reassemble
59280 ** right-most child page then pCur->idx is set to one more than
59302 ** If the table has a virtual root page, then the cursor is moved to point
59358 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
59517 ** If an exact match is not found, then the cursor is always
59554 ** to move to, then just return without doing any work */
59601 ** not run. If this is not the root-page, then the moveToChild() routine
59772 ** successful then set *pRes=0. If the cursor
59774 ** this routine was called, then set *pRes=1.
59882 ** successful then set *pRes=0. If the cursor
59884 ** this routine was called, then set *pRes=1.
59989 ** If the "nearby" parameter is not 0, then an effort is made to
59995 ** anywhere on the free-list, then it is guaranteed to be returned. If
59996 ** eMode is BTALLOC_LT then the page returned will be less than or equal
59997 ** to nearby if any such page exists. If eMode is BTALLOC_ANY then there
60033 ** shows that the page 'nearby' is somewhere on the free-list, then
60249 ** steps, then the page we are about to allocate may contain content
60349 /* If the secure_delete option is enabled, then
60370 ** trunk page in the free-list is full, then this page will become a
60424 /* If control flows to this point, then it was not possible to add the
60508 ** So if there exists more than one reference to this page, then it
60539 ** be constructed in this temporary area then copied into pPage->aData
60654 ** If this is the first overflow page, then write a partial entry
60656 ** then the optimistic overflow chain processing in clearCell()
60677 /* If pPrior is part of the data area of pPage, then make sure pPage
60697 /* If pPayload is part of the data area of pPage, then make sure pPage
60777 ** If the cell content will fit on the page, then put it there. If it
60778 ** will not fit, then make a copy of the cell content into pTemp if
60809 ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
60998 ** cells in apCell[], then the cells do not fit and non-zero is returned.
61364 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
61367 ** any cells with overflow page pointers, then the corresponding pointer
61427 ** is a root page or a child of a root page) then all available siblings
61526 ** has NB or fewer children then all children of pParent are taken.
61632 ** If the siblings are on leaf pages, then the child pointers of the
61635 ** child pointers. If siblings are not leaves, then all cell in
61973 ** If the sibling pages are not leaves, then the pointer map entry
62037 ** then there is no divider cell in b.apCell[]. Instead, the divider
62051 ** bytes, then it may actually be smaller than this
62078 ** then it is not safe to update page apNew[iPg] until after
62082 ** then it is not safe to update page apNew[iPg] until after
62088 ** to 0, then back up to nNew-1 again, thus making two passes over
62150 ** copied into the parent, because if the parent is page 1 then it will
62219 ** page is then overwritten to make it an empty page with the right-child
62271 /* Zero the contents of pRoot. Then install pChild as the right-child. */
62413 ** If the seekResult parameter is non-zero, then a successful call to
62420 ** If the seekResult parameter is non-zero, then the caller guarantees that
62422 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
62456 ** expecting an index b-tree, then the caller should be inserting blob
62467 ** integer key to use. It then calls this function to actually insert the
62579 ** If the second parameter is zero, then the cursor is left pointing at an
62580 ** arbitrary location after the delete. If it is non-zero, then the cursor
62636 /* If the bPreserve flag is set to true, then the cursor position must
62638 ** will cause a b-tree rebalance, then this is done by saving the cursor
62642 ** Or, if the current delete will not cause a rebalance, then the cursor
62658 /* Make the page containing the entry to be deleted writable. Then free any
62667 /* If the cell deleted was not located on a leaf page, then the cursor
62691 ** then the cursor still points to that page. In this case the first
62695 ** Otherwise, if the entry deleted was on an internal node page, then
62964 ** If pnChange is not NULL, then table iTable must be an intkey table. The
63005 ** root page in the database file, then the last root page
63228 /* If this is a leaf page or the tree is not an int-key tree, then
63474 ** and then moves other nodes around as necessary to preserve the heap
63787 ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
64456 ** then the backup cannot proceed.
64481 ** Then clear the Btree layer MemPage.isInit flag. Both this module
64500 ** If pFile is currently larger than iSize bytes, then truncate it to
64501 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
64573 ** one now. If a transaction is opened here, then it will be closed
64749 /* If bCloseTrans is true, then this function opened a read transaction
64856 ** copied into the destination database, then the data written to the
65007 /* If MEM_Dyn is set then Mem.xDel!=0.
65013 ** ensure that if Mem.szMalloc>0 then it is safe to do
65052 ** representation is already stored using the requested encoding, then this
65075 ** then the encoding of the value may not have changed.
65089 ** If the bPreserve argument is true, then copy of the content of
65098 /* If the bPreserve flag is set to true, then the memory cell must already
65278 ** string representation of the value. Then, if the required encoding
65330 ** invoking the external callback in Mem.xDel, then this routine
65397 ** If the double is out of range of a 64-bit signed integer then
65428 ** If pMem is an integer, then the value is exact. If pMem is
65429 ** a floating-point then the value returned is the integer part.
65430 ** If pMem is a string or blob, then we make an attempt to convert
65655 ** to a value change. So invoke the destructor, then set the value to
65755 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
65821 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
65827 ** size limit) then no memory allocation occurs. If the string can be
65828 ** stored without allocating memory, then it is. If a memory allocation
65829 ** is required to store the string, then value of pMem is unchanged. In
65930 ** to read from the disk) then the pMem is left in an inconsistent state.
66039 ** If that is the case, then the result must be aligned on an even byte
66084 ** Otherwise, if the second argument is non-zero, then this function is
66087 ** that function will return to its caller here. Then return a pointer to
66139 ** then this routine attempts to invoke the SQL function. Assuming no
66378 ** be converted directly into a value, then
66381 ** cannot be converted to a value, then *ppVal is set to NULL.
66452 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
66586 ** the column value into *ppVal. If *ppVal is initially NULL then a new
66589 ** If *ppVal is initially NULL then the caller is responsible for
67159 ** Then check that the value of Parse.mayAbort is true if an
67196 ** If malloc failed, then the while() loop above may not have iterated
67433 ** If the input FuncDef structure is ephemeral, then free it. If
67434 ** the FuncDef is not ephermal, then do nothing.
67536 ** then remove it. Return true if and only if an opcode was removed.
67553 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
67556 ** first null byte. If n>0 then copy n+1 bytes of zP4.
67562 ** If addr<0 then change P4 on the most recently inserted instruction.
67670 ** Return the opcode for a given address. If the address is -1, then
67674 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
67932 ** If SQLite is not threadsafe but does support shared-cache mode, then
67942 ** corresponding to btrees that use shared cache. Then the runtime of
68089 ** When p->explain==1, first the main program is listed, then each of
68335 ** request, then increment *pnByte by the amount of the request.
68473 ** requirements by reusing the opcode array tail, then the second
68677 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
68764 ** simple case then too.
68891 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
68980 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
68981 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
68991 /* If p->iStatement is greater than zero, then this Vdbe opened a
69050 ** and write an error message to it. Then return SQLITE_ERROR.
69069 ** has made changes and is in autocommit mode, then commit those
69070 ** changes. If a rollback is needed, then do the rollback.
69095 ** Then the internal cache might have been left in an inconsistent
69158 ** VM, then we do either a commit or rollback of the current transaction.
69213 /* If eStatementOp is non-zero, then a statement transaction needs to
69216 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
69265 /* If the auto-commit flag is set to true, then any locks that were held
69348 ** error, then it might not have been halted properly. So halt
69353 /* If the VDBE has be run even partially, then transfer the error code
69434 ** If parameter iOp is less than zero, then invoke the destructor for
69438 ** Or, if iOp is greater than or equal to zero, then the destructor is
69441 ** VM pVdbe, and only then if:
69580 ** If a MoveTo operation is pending on the given cursor, then do that
69586 ** not been deleted out from under the cursor, then this routine is a no-op.
69701 ** points (ex: ARM7) then swap the lower 4 bytes with the
69943 ** stack space). If the former, then *ppFree is set to a pointer that should
70203 ** If one blob is a prefix of the other, then the shorter is the lessor.
70354 ** fields that appear in both keys are equal, then pPKey2->default_rc is
70377 /* If bSkip is true, then the caller has already determined that the first
71251 ** then sets the error code to SQLITE_TOOBIG
71522 /* If there are no other statements currently running, then
71592 ** error has occurred, then return the error code in p->rc to the
71944 ** sqlite3_column_XXX API, then set the return code of the statement to
72023 ** xFunc() then return that string. If N is out of range, return 0.
72035 ** or a constant) then useTypes 2, 3, and 4 return NULL.
72091 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
72174 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
72206 /* If the bit corresponding to this variable in Vdbe.expmask is set, then
72211 ** for a statement, then the statement will be automatically recompiled,
72480 ** If the two statements contain a different number of bindings, then
72687 ** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the
72690 ** then the returned string holds a copy of zRawSql with "-- " prepended
72693 ** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
72694 ** then long strings and blobs are truncated to that many bytes. This
72706 ** parameter index is known, locate the value in p->aVar[]. Then render
73061 ** If the bTryForInt flag is true, then extra effort is made to give
73066 ** If bTryForInt is false, then if the input string contains a decimal
73693 ** and then jump to address P2.
73729 ** If P2!=0 then the coroutine implementation immediately follows
73774 ** Yield or Return then continue to the next instruction. But if
73776 ** EndCoroutine, then jump to P2 rather than continuing with the
73796 ** Check the value in register P3. If it is NULL then Halt using
73798 ** value in register P3 is not NULL, then this routine is a no-op.
73814 ** For errors, it can be some other value. If P1!=0 then P2 will determine
73817 ** then back out all changes that have occurred during this execution of the
73820 ** If P4 is not null then it is an error message string.
73830 ** If P5 is not zero and P4 is NULL, then everything after the ":" is
73855 ** instruction is set to OE_Ignore, then the sub-program is throwing
73986 ** If P5!=0 and the content of register P3 is greater than zero, then
74012 ** Write a NULL into registers P2. If P3 greater than P2, then also write
74014 ** is less than P2 (typically P3 is zero) then only register P2 is
74017 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
74073 ** If the parameter is named, then its name appears in P4.
74167 ** is a string or blob, then the copy is only a pointer to the
74222 /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
74230 ** If the open statement-transaction is not closed here, then the user
74273 ** If either the P1 or P2 text are NULL then store NULL in P3.
74343 ** register P1 is zero, then the result is NULL. If either input is
74450 ** If P1 is not zero, then it is a register that a subsequent min() or
74476 ** argument was constant then bit 0 of P1 is set. This is used to determine
74493 ** argument was constant then bit 0 of P1 is set. This is used to determine
74680 ** without data loss, then jump immediately to P2, or if P2==0
74755 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
74759 ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
74760 ** bit is clear then fall through if either operand is NULL.
74765 ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
74771 ** the values are compared. If both values are blobs then memcmp() is
74773 ** are text, then the appropriate collating function specified in
74774 ** P4 is used to do the comparison. If P4 is not specified then
74776 ** numeric, then a numeric comparison is used. If the two values
74777 ** are of different types, then numbers are considered less than
74780 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
74783 ** If the SQLITE_NULLEQ bit is set in P5, then NULL values are considered
74794 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
74795 ** true or false and is never NULL. If both operands are NULL then the result
74796 ** of comparison is false. If either operand is NULL then the result is true.
74807 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
74808 ** true or false and is never NULL. If both operands are NULL then the result
74809 ** of comparison is true. If either operand is NULL then the result is false.
74853 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
74869 ** then the result is always NULL.
74975 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
74977 ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
75058 ** If either P1 or P2 is 0 (false) then the result is 0 even if
75068 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
75111 ** NULL, then a NULL is stored in P2.
75129 ** a NULL then store a NULL in P2.
75168 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
75174 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
75236 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
75241 ** then the cache of the cursor is reset prior to extracting the column.
75352 ** the complete header, then set it to zero, forcing the header to be
75550 ** If P4 is NULL then all index fields have the affinity BLOB.
75735 ** transaction, then there cannot be any savepoints.
75770 /* If there is no open transaction, then mark this as a special
75789 /* Find the named savepoint. If there is no such savepoint, then an
75811 ** and this is a RELEASE command, then the current transaction
75864 /* If it is a RELEASE, then destroy the savepoint being operated on
75865 ** too. If it is a ROLLBACK TO, then set the number of deferred
75894 ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
75958 ** If P2 is non-zero, then a write-transaction is started, or if a
75960 ** If P2 is zero, then a read-transaction is started.
75977 ** If P5!=0 then this opcode also checks the schema cookie against P3
75984 ** generation counter, then an SQLITE_SCHEMA error is raised and execution
75985 ** halts. The sqlite3_step() wrapper function might then reprepare the
76157 ** If P5!=0 then use the content of register P2 as the root page, not
76162 ** then a read lock is acquired as part of this instruction. A read
76171 ** structure, then said structure defines the content and collating
76200 ** structure, then said structure defines the content and collating
76229 ** index, then fall through into OP_OpenRead to force a reopen */
76392 ** If argument P3 is non-zero, then it indicates that the sorter may
76495 ** to an SQL index, then P3 is the first in an array of P4 registers
76500 ** greater than or equal to 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 ** the key and P2 is not zero, then jump to P2.
76549 ** to an SQL index, then P3 is the first in an array of P4 registers
76554 ** less than or equal to the key and P2 is not zero, then jump to P2.
76615 ** loss of information, then special processing is required... */
76619 ** then the seek is not possible, so jump to P2 */
76745 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76746 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76750 ** is a prefix of any entry in P1 then a jump is made to P2 and
76762 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76763 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76767 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
76768 ** does contain an entry whose prefix matches the P3/P4 record then control
76781 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
76782 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
76787 ** record are not-NULL then a check is done to determine if any row in the
76888 ** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an
76889 ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then
76966 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
77065 ** largest possible integer (9223372036854775807) then the database
77100 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
77102 ** then rowid is stored for subsequent return by the
77106 ** the last seek operation (OP_NotExists) was a success, then this
77113 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
77114 ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
77119 ** may be NULL. If it is not NULL, then the update-hook
77123 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
77125 ** value of register P2 will then change. Make sure this does not
77209 ** pointing at the next record, then the next Next instruction will be a
77211 ** Next loop. If P5 is zero, then the cursor is left in an undefined state.
77213 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
77219 ** If P4 is not NULL, then it is the name of the table that P1 is
77221 ** If P4 is not NULL then the P1 cursor must have been positioned
77266 ** Then the VMs internal change counter resets to 0.
77284 ** fields (not counting the P4 fields at the end which are ignored) then
77311 ** Then clear the column header cache on cursor P3.
77380 ** generator) then the fix would be to insert a call to
77495 ** If the table or index is empty and P2>0, then jump immediately to P2.
77536 ** then rewinding that index and playing it back from beginning to
77595 ** table or index. If there are no more key/value pairs then fall through
77614 ** If P5 is positive and the jump is taken, then event counter
77627 ** table or index. If there is no previous key/value pairs then fall through
77637 ** not open then the behavior is undefined.
77647 ** If P5 is positive and the jump is taken, then event counter
77720 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
77722 ** then the change counter is unchanged.
77724 ** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have
77852 ** then jump to P2. Otherwise fall through to the next instruction.
77863 ** then jump to P2. Otherwise fall through to the next instruction.
77873 ** If the P1 index entry is less than the key value then jump to P2.
77884 ** If the P1 index entry is less than or equal to the key value then jump
77937 ** P3==1 then the table to be clear is in the auxiliary database file
77940 ** If AUTOVACUUM is enabled then it is possible that another root page
77946 ** the last one in the database) then a zero is stored in register P2.
77947 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
77987 ** P2==1 then the table to be clear is in the auxiliary database file
77990 ** If the P3 value is non-zero, then the table referred to must be an
77993 ** If P3 is greater than zero, then the value stored in register P3 is
78095 ** then runs the new virtual machine. It is thus a re-entrant opcode.
78377 ** If P5 is non-zero, then recursive program invocation is enabled.
78393 /* If the p5 flag is clear, then recursive invocation of triggers is
78418 ** the trigger program. If this trigger has been fired before, then pRt
78543 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
78592 ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
78598 ** If the initial value of register P1 is less than 1, then the
78613 ** Synopsis: if r[P1]<=0 then r[P2]=P3
78616 ** If the value of register P1 is not positive (if it is less than 1) then
78630 ** Synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2
78633 ** initially nonzero, then subtract P3 from the value in register P1 and
78652 ** then jump to P2 if the new value is exactly zero.
78668 ** zero, then jump to P2. Increment register P1 regardless of whether or
78995 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
78996 ** then only the currently executing statement is expired.
79260 ** the end of its result set, then fall through to the next instruction.
79341 ** is the rowid of a row to delete. If argv[0] is NULL then no
79347 ** If P2==1 then no insert is performed. argv[0] is the rowid of
79351 ** is successful, then the value returned by sqlite3_last_insert_rowid()
79455 ** If tracing is enabled (by the sqlite3_trace()) interface, then
79661 ** blob handle was opened, then an error code is returned and *pzErr may
79666 ** If an error does occur, then the b-tree cursor is closed. All subsequent
79743 ** Code external to the Vdbe then "borrows" the b-tree cursor and
80003 /* If there is no statement handle, then the blob-handle has
80058 ** contain a blob or text value, then an error code is returned and the
80059 ** database handle error code and message set. If this happens, then all
80073 /* If there is no statement handle, then the blob-handle has
80175 ** threshold, then the set of records currently in memory are sorted and
80187 ** If the sorter is running in single-threaded mode, then all PMAs generated
80189 ** multi-threaded mode then up to (N+1) temporary files may be opened, where
80206 ** sorter is running in single-threaded mode, then these PMAs are merged
80211 ** Or, if running in multi-threaded mode, then a background thread is
80221 ** Rewind() is called, then a hierarchy of incremental-merges is used.
80223 ** disk are merged together. Then T bytes of data from the second set, and
80228 ** SORTER_MAX_MERGE_COUNT PMAs on disk when Rewind() is called, then more
80277 ** If aMemory==0 then each object is allocated separately and the objects
80278 ** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects
80373 ** Before a background thread is launched, variable bDone is set to 0. Then,
80441 ** contain a contiguous representation of the key, then aAlloc is allocated
80472 ** pMerger to populate aFile[0]. It then sets variables within the
80478 ** background thread has finished populating aFile[1]. It then exchanges
80526 ** (VdbeSorter.list.aMemory==0), then the list is always connected using the
80530 ** then while records are being accumulated the list is linked using the
80630 ** range into. Then return a copy of pointer p->aAlloc to the caller. */
80817 ** If the pnByte parameter is NULL, then it is assumed that the file
81732 ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
81738 ** was actually called above, then pTask->pUnpacked now contains
81742 ** If the two values were equal, then the value from the oldest
81874 ** If using the single large allocation mode (pSorter->aMemory!=0), then
82022 ** background thread is finished (if it is not already) and then swap
82174 ** If argument eMode is INCRINIT_ROOT, then it is assumed that any IncrMerge
82181 ** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use
82231 ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders
82232 ** in the sub-tree headed by pReadr are also initialized. Data is then
82236 ** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed
82300 ** then this function is already running in background thread
82303 ** If this is the INCRINIT_ROOT object, then it is running in the
82337 ** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes
82342 ** then a background thread is launched to call vdbePmaReaderIncrMergeInit().
82373 ** PMA before returning. If an error does occur, then the final value of
82498 /* If the sorter uses more than one task, then create the top-level
82656 /* If no data has been written to disk, then do not do so now. Instead,
83472 ** If the Walker does not have an xSelectCallback() then this routine
83551 ** If the reference is followed by a COLLATE operator, then make sure
83629 ** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will
83777 ** USING clause, then skip this match.
83804 /* If we have not already resolved the name, then maybe
83874 ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
83927 ** supplied) and the value of Z is enclosed in double-quotes, then
83959 /* If a column from a table in pSrcList is referenced, then record
83963 ** then set the high-order bit of the bitmask.
84289 ** no match, or if pE is not a simple identifier, then this routine
84498 ** field) then convert that term into a copy of the corresponding result set
84544 ** number of columns in the result set of the SELECT) then the expression
84547 ** a result-set expression, then the term resolves to a copy of the
84551 ** This routine returns the number of errors. If errors occur, then
84664 /* If the SF_Converted flags is set, then this Select object was
84689 ** pItem->pSelect, check if this value has changed. If so, then
84727 /* If a HAVING clause is present, then there must be a GROUP BY clause.
84739 ** Minor point: If this is the case, then the expression will be
84779 ** than the right-most term, then that is a syntax error. But the error
84873 ** If the function is an aggregate function, then the NC_HasAgg flag is
84875 ** If an expression contains aggregate functions then the EP_Agg
85021 ** or a sub-select with a column as the return value, then the
85261 ** If the left hand expression has a collating sequence type, then it is
85337 ** to by pnHeight, the second parameter, then set *pnHeight to that
85435 ** If dequote is true, then the token (if it exists) is dequoted.
85439 ** then the EP_DblQuoted flag is set on the expression node.
85442 ** can be translated into a 32-bit integer, then the token is not
85566 ** then return 1. If one cannot determine the truth value of the
85575 ** LEFT JOIN, then we cannot determine at compile-time whether or not
85593 ** NULL, then just return the other expression.
85595 ** If one side or the other of the AND is known to be false, then instead
85830 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
85848 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
85977 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
86014 ** the build, then none of the following routines, except for
86120 ** initially NULL, then create a new expression list.
86123 ** NULL is returned. If non-NULL is returned, then it is guaranteed
86304 /* If pWalker->eCode is 2 then any term of the expression that comes from
86428 ** integer, then the EP_IntValue flag will have already been set */
86652 ** If the RHS of the IN operator is a list or a more complex subquery, then
86653 ** an ephemeral table might need to be generated from the RHS and then
86659 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a
86665 ** through the set members) then the b-tree must not contain duplicates.
86671 ** for fast set membership tests) then an epheremal table must
86676 ** if the RHS of the IN operator is a list (not a subquery) then this
86686 ** runtime, then a register is allocated and the register number written
86688 ** NULL value, then *prRhsHasNull is left unchanged.
86690 ** If a register is allocated and its location stored in *prRhsHasNull, then
86784 ** then it is not worth creating an ephemeral table to evaluate
86832 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
86867 ** If all of the above are false, then we can run this code just once
86899 ** statement returns a column value, then the affinity of that
86901 ** SELECT... statement are columns, then numeric affinity is used
86903 ** 'x' nor the SELECT... statement are columns, then numeric affinity
86942 ** store it in the temporary table. If <expr> is a column, then use
86967 /* If the expression is not constant then we will need to
87074 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
87075 ** within the RHS then fall through.
87112 ** suitable for evaluating the IN operator, then evaluate using a
87154 /* If the LHS is NULL, then the result is either false or NULL depending
87182 /* If the set membership test fails, then the result of the
87184 ** contains no NULL values, then the result is 0. If the set
87185 ** contains one or more NULL values, then the result of the
87207 ** then the answer is TRUE the presence of NULLs in the RHS does
87208 ** not matter. If the LHS is not contained in the RHS, then the
87489 ** is called. If iColumn<0 then code is generated that extracts the rowid.
88036 /* If the opcode is TK_TRIGGER, then the expression is a reference
88055 ** Then p1 is interpreted as follows:
88094 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
88097 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
88100 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
88101 ** WHEN x=eN THEN rN ELSE y END
88106 ** is even, then Y is omitted and the "otherwise" result is NULL.
88236 ** then write its number into *pReg. If the result register is not
88237 ** a temporary, then set *pReg to zero.
88239 ** If pExpr is a constant, then this routine might generate this
88299 ** in register target. If the expression is constant, then this routine
88447 ** If the expression evaluates to NULL (neither true nor false), then
88577 ** If the expression evaluates to NULL (neither true nor false) then
88749 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
88753 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
88758 ** returns 2, then you do not really know for certain if the two
88759 ** expressions are the same. But if you get a 0 or 1 return, then you
88812 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
88851 ** Expr.iTable<0 then assume a table number given by iTab.
89151 ** If a register is currently being used by the column cache, then
89458 ** If argument zWhere is NULL, then a pointer string containing the text
89464 ** If argument zWhere is not NULL, then the string returned is
89678 ** Then modify the schema cookie (since the ALTER TABLE modifies the
89729 "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
89734 "WHEN type='table' THEN %Q "
89735 "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
89748 /* If the sqlite_sequence table exists in this database, then update
89862 ** literal NULL, then set pDflt to 0. This simplifies checking
89870 then the default value for the
89931 /* If the default value of the new column is NULL, then set the file
90074 ** are both enabled, then STAT4 takes precedence.
90093 ** the index is unique, then the last integer will be 1.
90098 ** "unordered" keyword is present, then the query planner assumes that
90101 ** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat
90119 ** Then the sampled rows are given by:
90146 ** index. If the idx and tbl columns are the same, then the sample is
90206 ** or it may be a NULL pointer. If it is not NULL, then all entries in
90208 ** If zWhere==0, then code is generated to delete all stat table entries.
90842 ** If neither STAT3 nor STAT4 are enabled, then J is always
90876 ** "100 10 2", then SQLite estimates that:
90883 ** rows, then each estimate is computed as:
91353 ** a database. If pOnlyIdx is not NULL then it is a single index
91623 /* If this is stat4 data, then calculate aAvgEq[] values for all
92135 ** If this fails, or if opening the file failed, then close the file and
92619 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
92620 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
92658 ** then generate an error.
92714 ** is returned, then the error count and error message in pParse are
93088 ** names is done.) The search order is TEMP first, then MAIN, then any
93146 ** CREATE, then check to see if it is the name of an virtual table that
93204 ** TEMP first, then MAIN, then any auxiliary databases added
93243 ** unlike that index from its Table then remove the index from
93317 /* If any database other than TEMP is reset, then also reset TEMP
93537 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
93542 ** Then pName1 is set to "yyy" and pName2 is "".
93651 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
93656 ** Then pName1 is set to "yyy" and pName2 is "".
93751 ** then record a pointer to this table in the main database structure
93852 ** first to get things going. Then this routine is called for each
93891 ** 'BLOB'. If there is a type specified, then sqlite3AddColumnType() will
94082 ** of columns that form the primary key. If pList is NULL, then the
94086 ** a primary key (and this is the second primary key) then create an
94090 ** then we will try to use that column as the rowid. Set the Table.iPKey
94095 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
94214 ** then an index may have been created on this column before the
94235 ** and the sequence is available in another text encoding, then that is
94315 ** then it is copied to the output buffer exactly as it is. Otherwise,
94697 /* If not initializing, then create a record for the new table
95120 ** is non-zero, then it is the root page number of a table moved to
95151 ** is not defined), then it is important to call OP_Destroy on the
95162 ** database, then root page 5 would be moved to page 4 by the
95395 ** in the current table point to the foreign key. If pFromCol==0 then
95546 ** root page number of the index. If memRootPage is negative, then
95801 ** index, then we will continue to process this index.
96030 ** the constraint occur in different orders, then the constraints are
96094 ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
96415 ** If the iStart argument had been 1 instead of 2, then the result
96417 ** the iStart value would be 0. The result then would
96477 ** a new one. If an OOM error does occurs, then the prior value of pList
96492 ** Then B is a table name and the database name is unspecified. If called
96497 ** Then C is the table name and B is the database name. If C is defined
96498 ** then so is B. In other words, we never have a case where:
96583 ** usual case. If the term has an alias, then pAlias points to the
96584 ** alias token. If the term is a subquery, then pSubquery is the
96833 ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
96852 ** a transaction. If we are already within a transaction, then a checkpoint
96869 ** more than one entry (example: deleting one row then inserting another,
96871 ** If an abort occurs after some of these writes have completed, then it will
96998 ** If pColl==0 then recompute all indices of pTab.
97016 ** indices use the collating sequence pColl. If pColl==0 then recompute
97288 ** If it is not NULL, then pColl must point to the database native encoding
97356 ** true, then create a new entry. Otherwise return NULL.
97409 ** If the entry specified is not found and 'create' is true, then create a
97461 ** If nArg==(-2) then any function with a non-null xStep or xFunc is
97547 ** If the createFlag argument is true, then a new (blank) FuncDef
97551 ** If nArg is -2, then the first valid function found is returned. A
97554 ** of arguments. If nArg is -2, then createFlag must be 0.
97556 ** If createFlag is false, then a function with the required name and
97591 ** If the SQLITE_PreferBuiltin flag is set, then search the built-in
97616 ** exact match for the name, number of arguments and encoding, then add a
98170 ** deleting from and all its indices. If this is a view, then the
98309 ** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor
98311 ** then this function must seek iDataCur to the entry identified by iPk
98314 ** If eMode is ONEPASS_MULTI, then this call is being made as part
98316 ** iIdxNoSeek is a valid cursor number (>=0), then its position should
98322 ** If iIdxNoSeek is a valid cursor number (>=0), then it identifies an
98393 /* If any BEFORE triggers were coded, then seek the cursor to the
98497 ** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then
98514 ** avoid unnecessary register loads. If pPrior is not NULL, then it is
98518 ** a column in common, then the register corresponding to that column already
98562 /* If the column affinity is REAL but the number is an integer, then it
98564 ** representation) then converted to REAL by an OP_RealAffinity opcode.
98579 ** because it was a partial index, then this routine should be called to
98734 ** then abs(X) throws an integer overflow error since there is no
98770 ** If both haystack and needle are BLOBs, then the result is one more than
98844 ** of x. If x is text, then we actually count UTF-8 characters.
98845 ** If x is a blob, then we count bytes.
98847 ** If p1 is negative, then we begin abs(p1) from the end of x[].
98887 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
98984 ** If nByte is larger than the maximum string or blob length, then
99073 ** values, resulting in a positive value. Then take the
99183 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
99959 ** A function that loads a shared-library extension then returns NULL.
100236 ** then set aWc[0] through aWc[2] to the wildcard characters and
100237 ** return TRUE. If the function is not a LIKE-style function then
100242 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
100539 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
100568 ** then non-zero is returned, and a "foreign key mismatch" error loaded
100620 ** column of pFKey, then this index is a winner. */
100623 /* If zKey is NULL, then this foreign key is implicitly mapped to
100634 /* If zKey is non-NULL, then this foreign key was declared to
100687 ** affected - once to "delete" the old row, and then again to "insert" the
100725 /* If nIncr is less than zero, then check at runtime if there are any
100730 ** any are, then the constraint is considered satisfied. No need to
100743 /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
100749 ** apply the affinity of the parent key). If this fails, then there
100759 ** then check if the row being inserted matches itself. If so, do not
100785 ** then check if the row being inserted matches itself. If so, do not
100788 ** If any of the parent-key values are NULL, then the row cannot match
100982 /* If the child table is the same as the parent table, then add terms
101090 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
101104 ** generating any VDBE code. If one can be found, then jump over
101125 ** If the SQLITE_DeferFKs flag is set, then this is not required, as
101241 ** described for DELETE. Then again after the original record is deleted
101298 /* If isIgnoreErrors is true, then a table is being dropped. In this
101359 ** foreign key, then omit this scan altogether. As all child key
101411 ** action applies, then any foreign key violations caused by
101415 ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the
101472 ** row contained in table pTab. If the operation is a DELETE, then
101475 ** If the i'th column is not modified by the UPDATE, then the corresponding
101518 ** If the current operation is an UPDATE, then the pChanges parameter is
101524 ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
101534 ** then the returned trigger structure is equivalent to:
101822 ** (1) acquire a lock for table pTab then
101825 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
101877 ** required, it is allocated and populated here. It is then stored as
101917 ** if iReg>0 then code an OP_Affinity opcode that will set the affinities
101919 ** then just set the P4 operand of the previous opcode (which should be
102094 ** larger than the maximum rowid in the memId memory cell, then the
102137 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
102162 ** then a list of all (non-hidden) columns for the table is substituted.
102190 ** schemas, including all the same indices, then a special optimization
102305 ** single row (the common case) then keep that one row of values
102375 ** Then special optimizations can be applied that make the transfer
102403 /* If the INSERT statement included an IDLIST term, then make sure
102408 ** is named in the IDLIST, then record in the ipkColumn variable
102445 ** is coming from a SELECT statement, then generate a co-routine that
102699 /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
102879 ** might be modified by the UPDATE. If pkChng is false, then the key of
102905 ** then the appropriate action is performed. There are five possible
102915 ** only (do not do a complete rollback) then
102939 ** Or if overrideError==OE_Default, then the pParse->onError parameter
102940 ** is used. Or if pParse->onError==OE_Default then the onError value
103093 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
103237 ** primary key, then no collision is possible. The collision detection
103441 ** If iBase is negative, then allocate the next available cursor.
103448 ** If pTab is a virtual table, then this routine is a no-op and the
103571 /* If no test above fails then the indices must be compatible */
103788 ** that determination. If SQLITE_Vacuum is set, then the destination
103851 ** collation sequence BINARY, then it can also be assumed that the
103860 ** might change the definition of a collation sequence and then run
103923 ** If the SQL is a query, then for each row in the query result
103925 ** argument to xCallback(). If xCallback=NULL then no callback
103998 ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
104095 ** interfaces in the middle of this structure, then older different
105007 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
105080 ** entry point name "sqlite3_extension_init" was not found, then
105277 ** is currently on the list. If xInit is not on the list, then this
106116 ** identifier, or a number. If minusFlag is true, then the value is
106119 ** If the left side is "database.id" then pId1 is the database name
106120 ** and pId2 is the id. If the left side is just "id" then pId1 is the
106175 ** connection. If it returns SQLITE_OK, then assume that the VFS
106441 ** then do a query */
106561 ** page cache size value. If N is positive then that is the
106562 ** number of pages in the cache. If N is negative, then the
106585 ** database file. If this parameter is set to zero, then memory mapping
106586 ** is not used at all. If N is negative, then the default memory map
106591 ** as little or as much as it wants. Except, if N is set to 0 then the
106651 ** If temporary directory is changed, then invalidateTempStorage.
107204 ** then iDb is set to the index of the database identified by <db>.
107209 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
107416 ** is created. If an existing main database file is opened, then the
107623 ** then 0 is returned. Setting the busy_timeout to 0 or negative
108112 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
108149 ** file was of zero-length, then the DB_Empty flag is also set.
108267 /* If pSchema is NULL, then return -1000000. This happens when code in
108336 ** back and different changes are made in their place, then when this
108578 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
108607 ** characters between zSql8 and zTail8, and then returning a pointer
108843 ** If an illegal or unsupported join type is seen, then still return
109107 ** A and B and the USING clause names X, Y, and Z, then add this
109313 ** If srcTab is negative, then the pEList expressions
109315 ** zero or more, then data is pulled from srcTab and pEList is used only
109388 ** and this row has been seen before, then do not make this row
109487 /* If the destination is DistFifo, then cursor (iParm+1) is open
109514 ** then there should be a single item on the stack. Write this
109545 /* If this is a scalar select that is part of an expression, then
109581 ** pSO->nExpr columns, then make sure all keys are unique by adding a
109597 /* If the destination is DistQueue, then cursor (iParm+1) is open
109704 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
109707 ** then the KeyInfo structure is appropriate for initializing a virtual
109828 ** then the results were placed in a sorter. After the loop is terminated
110024 ** cause this condition to run. Since then, we have restructured how
110050 /* If iCol is less than zero, then the expression requests the
110449 ** the limit and offset. If there is no limit and/or offset, then
110592 ** one. Each row extracted from Queue is output to pDest. Then the single
110595 ** is added back into the Queue table. Then another row is extracted from Queue
110598 ** If the compound query operator is UNION then no duplicate rows are ever
110601 ** discarded. If the operator is UNION ALL, then duplicates are allowed.
110603 ** If the query has an ORDER BY, then entries in the Queue table are kept in
110607 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
110610 ** with a positive value, then the first OFFSET outputs are discarded rather
110820 ** So if this routine is called with p equal to the t3 query, then
111161 /* If [0] is unused then [1] is also unused. So we can
111207 ** If regPrev>0 then it is the first register in a vector that
111209 ** if there has been no previous output. If regPrev>0 then code is
111270 ** then there should be a single item on the stack. Write this
111286 /* If this is a scalar select that is part of an expression, then
111299 ** starting at pDest->iSdst. Then the co-routine yields.
111311 /* If none of the above, then
111316 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
111351 ** co-routines. Then run the co-routines in parallel and merge the results
111400 ** subroutines first, then put the control logic at the bottom. Like this:
111423 ** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
111836 ** subquery first and store the results in a temporary table, then
111926 ** (18) If the sub-query is a compound select, then all terms of the
111933 ** (20) If the sub-query is a compound select, then it must not use
112074 ** subquery is the right term of a LEFT JOIN, then do not flatten.
112080 /* Restriction 17: If the sub-query is a compound SELECT, then it must
112125 /* If the sub-query is a compound SELECT statement, then (by restrictions
112228 ** then this loop only runs once.
112259 ** then expand the outer query to make space for it to hold all elements
112455 ** If all of the above are true, then WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX
112495 ** does match this pattern, then a pointer to the Table object representing
112524 ** INDEXED BY clause, then try to locate the specified index. If there
112623 then return a pointer to the CTE definition for that table. Otherwise
112654 ** onto the top of the stack. If argument bFree is true, then this
112704 /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
112706 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
112864 ** then create a transient table structure to describe the subquery.
113104 ** When this routine is the Walker.xExprCallback then expression trees
113106 ** when this routine is used for Walker.xExprCallback then
113410 ** encountered, then an appropriate error message is left in
113465 /* If ORDER BY makes no difference in the output then neither does
113635 ** a trigger, then we only need to compute the value of the subquery
113673 ** if the select-list is the same as the ORDER BY list, then this query
113698 /* If there is an ORDER BY clause, then create an ephemeral index to
113701 ** If that is the case, then the OP_OpenEphemeral instruction will be
113771 ** instruction ended up not being needed, then change the OP_OpenEphemeral
113821 ** identical, then it may be possible to disable the ORDER BY clause
113923 ** then loop over the sorting index in order to get the output
113995 ** Then compare the current GROUP BY terms against the GROUP BY terms
114022 ** over to a0,a1,a2. It then calls the output subroutine
114098 /* If isSimpleCount() returns a pointer to a Table structure, then
114161 ** If it is, then ask the code in where.c to attempt to sort results
114163 ** If where.c is able to produce results sorted in this order, then
114172 ** + If the query is a "SELECT min(x)", then the loop coded by
114235 /* If there is an ORDER BY clause, then we need to sort the results
114340 /* If this is the first row, then generate an extra row containing
114583 /* If TEMP was specified, then the trigger name may not be qualified. */
114615 ** then set iDb to 1 to create the trigger in the temporary database.
115093 ** then return TRUE. If pIdList==NULL, then it is considered a
115094 ** wildcard that matches anything. Likewise if pEList==NULL then
115189 ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
115411 ** process of being coded). If this is the case, then an entry with
115469 ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
115478 ** (a copy of pTab->nCol), then registers are populated as follows:
115558 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
115638 ** command. If the latter, then the row-records in the table btree on disk
115641 ** If the former, then all row-records are guaranteed to include a value
116014 ** action, then we need to open all indices because we might need
116062 ** then regNewRowid is the same register as regOldRowid, which is
116098 ** If there are one or more BEFORE triggers, then do not populate the
116297 ** Then loop through the contents of this ephemeral table executing a
116329 /* Allocate nArg registers to martial the arguments to VUpdate. Then
116549 ** restored before returning. Then set the writable-schema flag, and
116944 ** Except, if argument db is not NULL, then the entry associated with
117019 ** or, if the virtual table is stored in a non-sharable database, then
117166 ** created now instead of just being read out of sqlite_master) then
117344 ** into the linked list headed by pTab->pVTable. Then loop through the
117668 ** sqlite3.aVTrans array. Then clear the array itself.
117677 ** sqlite3.aVTrans array. Then clear the array itself.
117697 ** than zero, then this function is being called from within a
117741 ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
117785 ** If pExpr is a column in a virtual table, then let the virtual
118127 ** objects, then computing a particular sequence of WhereLoop objects, with
118195 ** Then a WherePath object is a path through the graph that visits some
118199 ** 1. Then using those as a basis to compute the N best WherePath objects
118230 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
118245 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
118380 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
118599 ** is run and there is an index on (a, b), then this function returns a
118794 ** If all the children of a term are disabled, then that term is also
118804 ** the virtual child terms are valid, then testing of the parent can be
118808 ** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead.
118839 ** SQLITE_AFF_BLOB, then no code gets generated.
118983 ** key value of the loop. If one or more IN operators appear, then
119028 /* Figure out how many memory cells we will need then allocate them.
119102 ** that originated from the LIKE optimization, then change the P3 to be
119372 ** index is on (x,y,z), then the following clauses are all
119387 ** If there are no inequality constraints, then N is at
119433 ** query, then the caller will only allow the loop to run for
119662 ** Then, for each indexed term, the following. The arguments to
119684 ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then
119762 ** Then for every term xN, evaluate as the subexpression: xN AND z
119996 ** then we cannot use the "t1.a=t2.b" constraint, but we can code
120104 ** If the wtFlags argument includes TERM_DYNAMIC, then responsibility
120166 ** collating sequence, then COLLATE operators are adjusted to ensure
120308 ** function, then no OP_Variable will be added to the program.
120335 ** If it is then return TRUE. If not, return FALSE.
120361 ** a join, then transfer the appropriate markings over to derived.
120381 ** a conjunction, then return just pTerm when N==0. If N is exceeds
120400 ** compatible (if one is = and the other is <, for example) then
120481 ** a single table T (as shown in example B above) then create a new virtual
120487 ** then create a new virtual term like this:
120494 ** has x=A (for the same x and A) then add a new virtual conjunct term to the
120503 ** If all subterms are indexable by a single table T, then set
120537 ** If none of cases 1, 2, or 3 apply, then leave the eOperator set to
120729 /* If the right-hand side is also a column, then the affinities
120798 ** returned when it should not be, then incorrect answers might result.
120859 ** If pExpr is a TK_COLUMN column reference, then this routine always returns
120906 ** columns, then the original expression is unchanged and a new virtual
121074 ** for LIKE) then the lower-bound is made all uppercase and the upper-
121471 ** then also write the indices of open cursors used by ONEPASS
121659 ** form X=Y then this routine might also return terms of the form
121663 ** If X is not the INTEGER PRIMARY KEY then X must be compatible with
121707 ** If pIdx!=0 then search for terms matching the iColumn-th column of pIdx
121719 ** then try for the one with no dependencies on <expr> - in other words where
121823 ** this query, then it will not be possible to show that the DISTINCT
121829 /* If any of the expressions is an IPK column on table iBase, then return
121883 ** If the bIncrRowid parameter is 0, then any OP_Rowid instructions on
121885 ** then each OP_Rowid is transformed into an instruction to increment the
121922 ** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines
122232 ** virtual table then allocate space for the aOrderBy part of
122399 ** If pRec contains N fields, where N is more than one, then as well as the
122410 ** Then the search space should ideally be the samples above and the
122480 /* If (res==0) is true, then pRec must be equal to sample i. */
122497 /* if i==0 and iCol==0, then record pRec is smaller than all samples
122498 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
122500 ** If (i>0), then pRec must also be greater than sample (i-1). */
122522 ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec
122558 ** then the return value is the likelihood multiplied by the number of
122709 ** If either of the upper or lower bound is not present, then NULL is passed in
122719 ** then nEq is set to 1 (as the range restricted column, b, is the second
122724 ** then nEq is set to 0.
122728 ** considering the range constraints. If nEq is 0, then *pnOut is the number of
122775 ** The number of rows between the two bounds is then just iUpper-iLower.
122843 ** sample, then assume they are 4x more selective. This brings
123196 ** If X is a proper subset of Y then Y is a better choice and ought
123269 ** If pX is a WhereLoop that pTemplate can supplant, then return the
123273 ** to be added to the list, then return a pointer to the tail of the list.
123283 ** then those WhereLoops need to be considered separately. Neither is
123323 /* If pTemplate is always better than p, then cause p to be overwritten
123348 ** If pBuilder->pOrSet is not NULL then we care about only the
123368 /* If pBuilder->pOrSet is defined, then only keep track of the costs
123409 ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new
123480 ** form "x==EXPR" and EXPR is not a constant 0 or 1, then make sure the
123483 ** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the
123512 ** then use the probability provided by the application. */
123755 ** seek only. Then, if this is a non-covering index, add the cost of
124131 /* If there was an INDEXED BY clause, then only that one index is
124155 ** then mExtra corresponds to (t1, t2) and mUnusable to (t5, t6).
124791 ** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then
124800 ** then
124840 ** terms are out of order, then block-sorting will reduce the
124865 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
124946 ** rows, then do not use the automatic index. */
124951 /* If nLoop is zero, then there are no FROM terms in the query. Since
125312 ** Then the code generated is conceptually like the following:
125363 ** if flag==0 then
125374 ** is called from an UPDATE or DELETE statement, then pOrderBy is NULL.
125379 ** specific cursor. If WHERE_ONEPASS_DESIRED is set, then iIdxCur is
125436 ** pTabList. But if the WHERE_ONETABLE_ONLY flag is set, then we should
125508 ** a table T, then X-1 is the bitmask for all other tables to the left of T.
126055 ** Then the "b" IdList records the list "a,b,c".
126227 ** defined, then do no error processing.
126303 ** Suppose the action integer is N. Then the action is determined as
126309 ** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
126334 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
126796 ** appears in the grammar, then ID becomes a fallback token for X, Y,
126934 ** If NULL, then tracing is turned off.
126936 ** line of trace output. If NULL, then tracing is
126989 "CASE", "WHEN", "THEN", "ELSE",
127256 /* 230 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
127257 /* 231 */ "case_exprlist ::= WHEN expr THEN expr",
127512 ** is popped from the stack, then call it.
127577 ** If the look-ahead token is YYNOCODE, then check to see if the action is
127642 ** If the look-ahead token is YYNOCODE, then check to see if the action is
128496 ** then extract the first few alphanumeric characters from within that
129073 case 230: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
129079 case 231: /* case_exprlist ::= WHEN expr THEN expr */
129376 ** one element off the stack, then we can push the new element back
129542 ** it is legal to shift the error symbol, then shift
129588 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
129604 ** * If the input token is $, then fail the parse.
129692 ** named keywordhash.h and then included into this source file by
129859 testcase( i==21 ); /* THEN */
129977 ** If X is a character that can be used in an identifier then
130291 ** then an and attempt is made to write an error message into
130565 /* If triggers are not supported by this compile then the statement machine
130903 ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
130912 ** name of a directory, then that directory will be used to store
130921 ** name of a directory, then that directory will be used to store
130942 ** thread has finished the initialization process, then the subsequent
130950 ** thread. Then while the initial invocation of this routine by X is
130978 /* If SQLite is already completely initialized, then this call
131023 /* If rc is not SQLITE_OK at this point, then either the malloc
131118 ** when this routine is invoked, then this routine is a harmless no-op.
131338 ** is NULL, then SQLite reverts to using its default memory allocator
131347 /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
131389 ** argument of type int. If non-zero, then URI handling is globally
131390 ** enabled. If the parameter is zero, then URI handling is globally
131422 ** negative, then that argument is changed to its compile-time default.
131471 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
131632 ** If the padFlag argument is not NULL then space padding at the end
131847 /* Convert the connection into a zombie and then close it.
131873 ** finished, then free all resources.
131881 ** then just leave the mutex and return.
131993 ** Rollback all database files. If tripCode is not SQLITE_OK, then
132009 ** here, then another shared-cache connection might sneak in between
132416 ** and there are active VMs, then return SQLITE_BUSY. If a function
132547 ** If the function already exists as a regular global function, then
132548 ** this routine is a no-op. If the function does not exist, then create
132636 ** If the invoked function returns non-zero, then the commit becomes a
132866 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
132995 ** above. If this is the case, then the db->mallocFailed flag needs to
133084 ** then any copies made by synthCollSeq() need to be invalidated.
133245 ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
134229 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
134328 ** is enabled, then the return value is true. If X is true and
134329 ** assert() is disabled, then the return value is zero. If X is
134330 ** false and assert() is enabled, then the assertion fires and the
134331 ** process aborts. If X is false and assert() is disabled, then the
134352 ** default setting. If the return value is 1, then ALWAYS() is either
134423 ** If zWord is a keyword recognized by the parser, then return the
134441 ** If sz>0 then allocate a scratch buffer into pNew.
134518 ** Enable imposter mode only when the schema has already been parsed. Then
134520 ** the parsed schema. Then turn imposter mode back off again.
134522 ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
134693 ** 3) If the argument db is not NULL, then none of the entries in the
134778 ** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
134785 ** on the same "db". If xNotify==0 then any prior callbacks are immediately
134856 ** set to db, then set pBlockingConnection=0.
134859 ** set to db, then invoke the configured unlock-notify callback and
134921 ** array already accumulated. We can then clear the array and
135080 ** (72-2) and then terminates with the 0 at K.
135201 ** If the root node is a leaf node, then start_block,
135331 ** If tokenizers are to be allowed to call sqlite3_*() functions, then
135374 ** then argc is set to 2, and the argv[] array contains pointers
135378 ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
135870 ** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index
135880 ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
135948 ** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist
136281 ** input does not begin with a quote character, then this routine
136300 /* If the first byte was a '[', then the close-quote character is a ']' */
136395 ** and then evaluate those statements. The success code is written
136398 ** If *pRc is initially non-zero then this routine is a no-op.
136507 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
136693 ** from left to write. If parameter zFunc is not NULL, then instead of
136751 ** If argument zFunc is not NULL, then all but the first question mark
136790 ** value. It reads the integer and sets *pnOut to the value read, then
137572 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
137615 /* If no row was found and no error has occurred, then the %_content
137637 ** If piFirst is not NULL, then this function sets *piFirst to the blockid
137640 ** If piLast is not NULL, then *piLast is set to the right-most child node
137663 ** interior node. Then load the blockid of the left-child of the b-tree
137668 ** root node, then the buffer comes from a SELECT statement. SQLite does
137672 ** table, then there are always 20 bytes of zeroed padding following the
137716 ** to the term from the interior node, then all terms on the sub-tree
137720 ** If the interior node term is larger than the specified term, then
137753 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
137755 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
137835 ** If pp is not NULL, then the contents of the position list are copied
137845 ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
137849 ** immediately preceded by a byte with the 0x80 bit set. Then increments
137881 ** If pp is not NULL, then the contents of the column-list are copied
138045 ** Then the position list for this row for token 'b' would consist of:
138232 ** called, if *pp points to pEnd or greater, then the end of the buffer
138235 ** If *pp does not point to or past pEnd, then a single varint is read
138236 ** from *pp. *pp is then set to point 1 byte past the end of the read varint.
138269 ** If *pbFirst is non-zero when this function is called, then the value
138300 ** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2).
138344 ** then the first docid in each list is simply encoded as a varint. For
138360 ** then the encoding of the first docid from the 'other' input list may
138704 ** for the pending-terms. If this is a scan, then this call must be being
138937 ** If the isPoslist argument is true, then it is assumed that the doclist
138999 ** If the numeric type of argument pVal is "integer", then return it
139018 ** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against
139021 ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
139024 ** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The
139372 ** set. So to find the start of the poslist, skip forward 2 bytes then
139394 ** sizeof(Fts3Cursor*), then the blob contents are copied to the
139739 ** of the sqlite library, then this function is called directly by
139861 ** there exists prefix b-tree of the right length) then it may be traversed
139863 ** doclist and then traversed.
140113 ** If parameter bOptOk is true, then the phrase may (or may not) use the
140300 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
140377 ** If there is no "next" entry and no error occurs, then *pbEof is set to
140480 ** If there is no "next" entry and no error occurs, then *pbEof is set to
140514 ** If parameter bOptOk is zero, then it is guaranteed that the
140517 ** Or, if bOptOk is non-zero, then one or more tokens within the expression
140627 ** this database, then the average docsize is 1. Otherwise, it is 1 plus
140749 ** Then, for each token, defer it if loading the doclist would result in
140894 ** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to
140952 ** at EOF, then the following variables are populated with the position list
140966 ** more non-deferred tokens, then the expression is advanced to the
141107 ** cluster, then this function returns 1 immediately.
141234 ** then any snippet() should ony highlight the "a" term, not the "b"
141324 ** token. Then, see if this row is really a match, considering deferred
141468 ** of a NEAR expression, then it also allocates and populates the same array
141573 ** * If a phrase consists entirely of deferred tokens, then all output
141582 ** * If the phrase is part of a NEAR expression, then only phrase instances
141668 ** itself is not EOF, then it may point to an earlier entry. */
142128 ** integer encountered in state 1 is not 0 or 1, then we need to
142387 ** is defined, then it uses the new syntax. The differences between
142401 ** If compiled with SQLITE_TEST defined, then this module exports the
142616 ** then free the old allocation.
142844 /* See if we are dealing with a quoted phrase. If this is the case, then
143371 ** If parameter n is a negative number, then z is assumed to point to a
143509 ** If the second argument is not NULL, then its contents are prepended to
143510 ** the returned expression text and then freed using sqlite3_free().
143988 ** If no element exists with a matching key, then a new
143992 ** If another element already exists with the same key, then the
143994 ** The key is not copied in this instance. If a malloc fails, then
143997 ** If the "data" parameter to this function is NULL, then the
144232 ** C be sequence of one or more consonants. Then every word can be
144320 ** of the word that preceeds the zFrom ending, then change the
144352 ** it contains digits) then word is truncated to 20 or 6 bytes
144395 ** in [a-zA-Z] then no stemming is attempted and this routine just
144770 ** to the string <key-name>. If <pointer> is not specified, then
145296 ** track such information in the database, then we'd only want this
145559 ** single block of memory. It then dequotes any of the strings that appear
145950 ** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer
146199 ** If argument apVal is not NULL, then it must point to an array with
146427 ** writing data to the fts3 table. If this lock is not acquired first, then
147089 ** NULL, then a buffer is allocated using sqlite3_malloc() and populated
147096 ** paBlob is non-NULL, then it is the responsibility of the caller to
147320 ** of these statements is untrue, then the data structure is corrupt.
147360 ** If arguments ppOffsetList and pnOffsetList are not NULL, then
147578 ** If the isPrefixIter parameter is zero, then the returned SegReader iterates
147582 ** "firebird", then the iterator visits the following 'terms' (in the order
148036 ** database. Then call this function recursively to write the parent of
148228 ** If the isCopyTerm parameter is true, then the buffer pointed to by
148487 ** If there are no entries in the input position list for column iCol, then
148490 ** If parameter bZero is non-zero, then any part of the input list following
148633 ** for, then advance each segment iterator until it points to a term of
148716 ** then the entire doclist for the term is available in
148766 ** forward. Then sort the list in order of current term again.
148788 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
149003 /* If nSize==0, then the %_segdir.end_block field does not not
149281 ** two. If nCol is the number of user defined columns, then values of the
149405 ** created using the content=xxx option, then the new index is based on
149759 ** Then allocate a new, empty sibling node. The key will be written
149792 ** If the size of the value in blob pPrev is zero, then this is the first
149931 ** If *pRc is not SQLITE_OK when this function is called, then no attempt
150052 ** is, then a NULL entry has been inserted into the %_segments table
150692 ** and then remove the entry. Write the two values read to *piAbsLevel and
150788 /* If nSeg is less that zero, then there is no level with at least
151484 ** value, then this operation requires constraint handling.
151488 ** if the on-conflict mode is other than REPLACE, then this method must
151506 ** rowid column. So if the conflict mode is REPLACE, then delete any
151904 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
151907 ** pnToken is not NULL, then it is set to the number of tokens in all
152139 /* Initialize the contents of the SnippetIter object. Then iterate through
152186 ** If nAppend is negative, then the length of the string zAppend is
152369 ** Then break out of the loop. */
152523 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
152786 ** If bGlobal is true, then populate all fields of the matchinfo() output.
152787 ** If it is false, then assume that those fields that do not change between
152932 /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the
153937 ** If the least significant bit in flags is clear, then the rule applies
153939 ** need to be folded). Or, if it is set, then the rule only applies to
153943 ** array. If a specific codepoint C does require folding, then its lower
154110 ** 1. If the node is the root node (node 1), then the first 2 bytes
154227 ** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will
154772 ** an internal node, then the 64-bit integer is a child page number.
155172 ** If the rScore is a tie, then use iLevel as the tie breaker with smaller
155174 ** SearchPoints, then iLevel becomes the deciding factor and the result
155715 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
155777 ** and then a linear search of an R-Tree node. This should be
156315 ** all cells from node pLeft. Then zero the original node.
156898 ** In the first case, if the conflict-handling mode is REPLACE, then
157190 ** If this function is being called as part of an xConnect(), then the rtree
157477 ** parameters to this function, then return that RtreeMatchArg object
157812 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
157836 ** then the result is also NULL.
158472 ** working set of leaves is larger than the available cache memory, then a
158541 ** Then the RBU database should contain:
158569 ** then the RBU database should contain:
158684 ** apply the update to the target database, then the RBU database
158709 ** If an RBU update is started and then suspended before it is completed,
158710 ** then an external client writes to the database, then attempting to resume
158850 ** then the new RBU VFS uses the default system VFS to access the file-system.
159273 ** then this routine returns -1.
159456 ** If an error has occurred, then set *pzErrmsg to point to a buffer
159696 ** than SQLITE_OK), then this function returns NULL without modifying the
159845 ** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
159846 ** if the table does have an external primary key index, then *piPk
160481 ** then the imposter table schema is:
160861 ** If the zMask string does not specify any columns to update, then this
160991 ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use.
161010 ** three characters, then shorten the suffix on z[] to be the last three
161013 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
161066 ** If argument pState is not NULL, then the incremental checkpoint is
161069 ** object, then the rbu handle is set to DONE state. This occurs if some
161075 /* If pState is NULL, then the wal file may not have been opened and
161234 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
161317 ** If RBU_UPDATE is returned, then output variable *pzMask is set to
161985 ** then edit any error message string so as to remove all occurrences of
162108 ** Then, when xOpen() is called to open the *-wal file associated with
162933 ** If the paths are sorted using the BINARY collation sequence, then
164503 ** If pApnd!=0, then try to append new nodes to complete zPath if it is
164657 ** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
164836 ** PATH element. If there are multiple PATHs, then return a JSON array
165798 ** "auxiliary data". The pointer may then be retrieved by the current or any
165804 ** more than once for a single FTS query, then all invocations share a
165808 ** invoked, then it is replaced by the new pointer. If an xDelete callback
165826 ** If the bClear argument is non-zero, then the auxiliary data is cleared
165978 ** If an xToken() callback returns any value other than SQLITE_OK, then
166003 ** "first" and "place". If the user then queries for '1st + place',
166010 ** FTS5 then queries the index for each synonym individually. For
166065 ** token "first" is subsituted for "1st" by the tokenizer, then the query:
166257 ** then an object of the following type is used to record the set of columns.
166975 ** defined, then do no error processing.
167039 ** Suppose the action integer is N. Then the action is determined as
167045 ** N between fts5YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
167070 ** a reduce action) then the fts5yy_reduce_ofst[] array is used in place of
167134 ** appears in the grammar, then ID becomes a fallback token for X, Y,
167202 ** If NULL, then tracing is turned off.
167204 ** line of trace output. If NULL, then tracing is
167376 ** is popped from the stack, then call it.
167441 ** If the look-ahead token is fts5YYNOCODE, then check to see if the action is
167506 ** If the look-ahead token is fts5YYNOCODE, then check to see if the action is
167812 ** one element off the stack, then we can push the new element back
167978 ** it is legal to shift the error symbol, then shift
168024 /* If the fts5YYNOERRORRECOVERY macro is defined, then do not attempt to
168040 ** * If the input token is $, then fail the parse.
168724 ** the printf() style processing, then appends the results to buffer pBuf.
168879 ** is non-negative, then it is the length of the string in bytes. Otherwise,
169105 ** input does not begin with a quote character, then this routine
170638 ** the maximum rowid. Or, if the iterator is "ORDER BY rowid DESC", then it
170848 ** This means that if the iteration order is ASC, then numerically larger
170864 ** bFromValid is zero, then pNode is advanced exactly once. Or, if argument
170865 ** bFromValid is non-zero, then pNode is advanced until it is at or past
171062 ** then the first document visited must have a rowid smaller than or
171147 ** If argument pNear is NULL, then a new Fts5ExprNearset object is allocated
172587 ** Then, for each level from 0 to nMax:
172599 ** The first value is the number of rows in the index. Then, for each column
172657 ** footer is 0 bytes in size, then this field is the same as the
173617 ** the next populated level, then that segment, and any other adjacent
174365 /* If this condition is true then the largest rowid for the current
174392 /* If pLast is NULL at this point, then the last rowid for this doclist
174397 ** Or, if pLast is non-NULL, then it is the page that contains the last
174457 ** If the specified term is found on the page, then the iterator is left
174461 ** If bGe is non-zero and the specified term is not found, then the
174821 ** If the returned value is non-zero, then it is the index of an entry
175122 ** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
175720 /* Append the number of bytes of new data, then the term data itself
176107 /* If nBest is still 0, then the index must be empty. */
176549 ** the position list contains entries for column iCol, then (*pa) is set
176592 ** If argument pColset is NULL, then the position list is filtered according
177109 /* If the QUERY_TEST_NOIDX flag was specified, then this must be a
178394 ** then this variable contains the result of the query.
178984 ** is using. Then attempt to move the cursor to a rowid equal to or laster
179358 /* If pSortCsr is non-NULL, then this call is being made as part of
180702 ** defined), then sqlite3_open() will call sqlite3Fts5Init() directly.
182255 ** then the next token. */
183319 ** If the least significant bit in flags is clear, then the rule applies
183321 ** need to be folded). Or, if it is set, then the rule only applies to
183325 ** array. If a specific codepoint C does require folding, then its lower
183920 ** then:
