Lines Matching refs:must
833 ** In all cases, the special comment must be enclosed in the usual
945 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
946 ** system #includes. Hence, this block of code must be the very first
1036 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
1058 /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
1059 ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
1386 ** must be either a NULL
1457 ** <li> The application must ensure that the 1st parameter to sqlite3_exec()
1459 ** <li> The application must not close the [database connection] specified by
1461 ** <li> The application must not modify the SQL statement text passed into
1840 ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
1979 ** to read the database file, as the WAL and shared memory files must exist
2017 ** sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be
2257 ** structure must be typedefed in order to work around compiler warnings
2300 ** The zName field holds the name of the VFS module. The name must
2316 ** must invent its own temporary name for the file. ^Whenever the
2375 ** the xOpen method must set the sqlite3_file.pMethods to either
2376 ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
2426 ** next. Applications that use these interfaces must be prepared for any
2428 ** from one release to the next. Applications must not attempt to access
2511 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
2557 ** is not. The sqlite3_shutdown() interface must only be called from a
2558 ** single thread. All open [database connections] must be closed and all
2559 ** other SQLite resources must be deallocated prior to invoking
2578 ** are omitted and the application must call sqlite3_initialize() directly
2603 ** option) the application must supply a suitable implementation for
2606 ** must return [SQLITE_OK] on success and some other [error code] upon
2624 ** must ensure that no other SQLite interfaces are invoked by other
2691 ** The xMalloc, xRealloc, and xFree methods must work like the
2723 ** methods must be threadsafe or else make their own arrangements for
2861 ** argument must be either a NULL pointer or a pointer to an 8-byte
2891 ** The first pointer (the memory pointer) must be aligned to an 8-byte
2958 ** supplied by the application must not invoke any SQLite interface.
2960 ** function must be threadsafe. </dd>
3148 ** slots. The size of the buffer in the first argument must be greater than
3150 ** must be aligned to an 8-byte boundary. ^If the second argument to
3243 ** must ensure that the argument passed into this DBCONFIG option is unchanged
3666 ** The input to [sqlite3_complete()] must be a zero-terminated
3669 ** The input to [sqlite3_complete16()] must be a zero-terminated
3731 ** A busy handler must not close the database connection
3818 ** it must pass the result table pointer to sqlite3_free_table() in order to
3821 ** function must not try to call [sqlite3_free()] directly. Only
3954 ** must be either NULL or else pointers obtained from a prior
3958 ** The application must not read or write any part of
4052 ** Applications must always be prepared to encounter a NULL pointer in any
4091 ** The authorizer callback must not do anything that will modify
4116 ** The [sqlite3_set_authorizer | authorizer callback function] must
4339 ** The progress handler callback must not do anything that will modify
4375 ** sqlite3_open_v2() must include, at a minimum, one of the following
4386 ** case the database must already exist, otherwise an error is returned.</dd>)^
4470 ** authority, then it must be either an empty string or the string
4590 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
4592 ** characters must be converted to UTF-8 prior to passing them into
4595 ** <b>Note to Windows Runtime users:</b> The temporary directory must be set
4624 ** as F) must be one of:
4728 ** The argument sqlite3_file_object(X) must be a filename pointer that
4759 ** must be released by a corresponding call to sqlite3_free_filename(Y).
4827 ** and must not be freed by the application)^.
4858 ** is the compiled object code. All SQL must be converted into a
5031 ** To execute an SQL statement, it must first be compiled into a byte-code
5047 ** [sqlite3_open16()]. The database connection must not have been closed.
5205 ** is obtained from [sqlite3_malloc()] and must be free by the application
5371 ** ^The NNN value must be between 1 and the [sqlite3_limit()]
5407 ** that parameter must be the byte offset
5427 ** ^The sixth argument to sqlite3_bind_text64() must be one of
5546 ** name must be given in UTF-8 even if the original statement
5702 ** must be called one or more times to evaluate the statement.
5765 ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
5983 ** sqlite3_column_text16() is called. The content must be converted
5986 ** sqlite3_column_text() is called. The content must be converted
6071 ** The application must finalize every [prepared statement] in order to avoid
6123 ** connection then application-defined SQL functions must be added
6186 ** callback only; NULL pointers must be passed as the xStep and xFinal
6188 ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
6195 ** must both be non-NULL. xValue and xInverse may either both be NULL, in
6196 ** which case a regular aggregate function is created, or must both be
6227 ** SQLite interfaces. However, such calls must not
6301 ** [randomblob|randomblob()] is not. Functions must
6481 ** These routines must be called from the same thread as
6586 ** The first parameter must be a copy of the
6591 ** This routine must be called from the same thread in which
6606 ** This routine must be called from the same thread in which
6677 ** These routines must be called from the same thread in which
6774 ** specified by the fifth (and last) parameter, which must be one
6785 ** must be the byte offset into the string where the NUL terminator would
6899 ** ^(The third argument (eTextRep) must be one of the constants:
6929 ** function must return an integer that is negative, zero, or positive
6931 ** respectively. A collating function must always return the same answer
6934 ** must give an equivalent answer when invoked with equivalent strings.
6935 ** The collating function must obey the following properties for all
7094 ** the application wants that memory to be freed, it must do
7098 ** <b>Note to Windows Runtime users:</b> The temporary directory must be set
7168 ** sqlite3_win32_set_directory interface except the string parameter must be
7328 ** [sqlite3_next_stmt(D,S)] must refer to an open database
7329 ** connection and in particular must not be a NULL pointer.
7355 ** The callback implementation must not do anything that will modify
7357 ** to modify the database connection must be deferred until after the
7417 ** The update hook implementation must not do anything that will modify
7419 ** to modify the database connection must be deferred until after the
7463 ** must be used, it is recommended that shared cache only be enabled for
7698 ** ^Extension loading must be enabled using
7835 ** of this structure must not change while it is registered with
7919 ** The [xBestIndex] method must fill aConstraintUsage[] with information
7960 ** SQLITE_CONSTRAINT, the database contents must be exactly as they were
8048 ** ^Module names must be registered before
8095 ** The L parameter must be either NULL or a pointer to an array of pointers
8170 ** must exist in order to be overloaded.)^
8310 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
8311 ** it must exist and there must be either a blob or text value stored in
8495 ** application must supply a custom mutex implementation using the
8503 ** mutex. The argument to sqlite3_mutex_alloc() must one of these
8560 ** mutex must be exited an equal number of times before another thread
8637 ** The xMutexInit() method must be threadsafe. It must be harmless to
8640 ** xMutexInit() must be no-ops.
8642 ** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
8643 ** and its associates). Similarly, xMutexAlloc() must not use SQLite memory
8706 ** next. Applications that override the built-in mutex logic must be
8922 ** [sqlite3_str_new()] must be freed by a subsequent call to
8971 ** onto the end of the [sqlite3_str] object X. N must be non-negative.
8972 ** S must contain at least N non-zero bytes of content. To append a
9019 ** [sqlite3_str] object. Applications must not used the pointer returned
9458 ** not need to be threadsafe either. All other methods must be threadsafe
9468 ** first parameter, szPage, is the size in bytes of the pages that must
9496 ** The xPagecount() method must return the number of pages currently
9513 ** implementation must return a pointer to the page buffer with its content
9536 ** then the page must be evicted from the cache.
9542 ** The cache must not perform any reference counting. A single
9549 ** previously contains an entry associated with newKey, it must be
9553 ** When SQLite calls the xTruncate() method, the cache must discard all
9664 ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
9720 ** errors are considered fatal.)^ The application must accept
9786 ** However, the application must guarantee that the destination
9795 ** If running in [shared cache mode], the application must
9798 ** that the application must guarantee that the disk file being
10006 ** The zFormat string must not be NULL.
10116 ** ^(The M parameter must be a valid [checkpoint mode]:)^
10276 ** must do so within the [xUpdate] method. If a call to the
10353 ** The first argument must be the sqlite3_index_info object that is the
10354 ** first parameter to the xBestIndex() method. The second argument must be
10448 ** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior
10575 ** the table row before it is updated. The N parameter must be between 0
10577 ** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE
10584 ** the table row after it is updated. The N parameter must be between 0
10586 ** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE
10668 ** The following must be true for this function to succeed. If any of
10674 ** <li> The database handle must not be in [autocommit mode].
10676 ** <li> Schema S of [database connection] D must be a [WAL mode] database.
10678 ** <li> There must not be a write transaction open on schema S of database
10681 ** <li> One or more transactions must have been written to the current wal
10685 ** must be written to it first.
10693 ** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()]
10716 ** ^In order to succeed, the database connection must not be in
10719 ** must have no active statements (SELECT statements that have been passed
10759 ** The application must eventually free every [sqlite3_snapshot] object
11151 ** Session objects must be deleted before the database handle to which they
11259 ** must translate X'' to NULL itself if required.
11411 ** Argument zFromDb must be the name of a database ("main", "temp" etc.)
11547 ** changeset (pChangeset) must remain valid until after the iterator is
11625 ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this
11697 ** call to [sqlite3changeset_next()] must have returned SQLITE_ROW.
11702 ** Argument iVal must be greater than or equal to 0, and less than the number
11728 ** call to [sqlite3changeset_next()] must have returned SQLITE_ROW.
11733 ** Argument iVal must be greater than or equal to 0, and less than the number
11765 ** Argument iVal must be greater than or equal to 0, and less than the number
11955 ** on the same changegroup object must also have specified patchsets. Or, if
11956 ** the buffer contains a changeset, so must have the earlier calls to this
12014 ** primary key columns for the table must be consistent. If this is not the
12107 ** Each time the conflict handler function is invoked, it must return one
12341 ** A conflict handler callback must return one of the following three values.
12453 ** In order to rebase a local changeset, the remote changeset must first
12490 ** bytes), which must have been obtained from a previous call to
12502 ** Argument pIn must point to a buffer containing a changeset nIn bytes
12713 ** The first argument to the sqlite3session_config() function must be one
12724 ** passed as the second argument must point to a value of type (int).
13062 ** following structure. All structure methods must be defined, setting
13119 ** For each token in the input string, the supplied callback xToken() must
13460 ** The maximum number of attached databases. This must be between 0
13654 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
13695 ** Exactly one of the following macros must be defined in order to
13773 ** testcase() must be evaluated both true and false in order to
14349 ** You must choose one or the other (or neither) but not both.
14730 ** All variables must either be on the stack or dynamically allocated from
14732 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
14930 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
15145 ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
15176 ** NOTE: These values must match the corresponding PAGER_ values in
15234 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
16104 ** Every VDBE branch operation must be tagged with one of the macros above.
16768 ** A thread must be holding a mutex on the corresponding Btree in order
16769 ** to access Schema content. This implies that the thread must also be
17286 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
17287 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
17937 ** must be unique and what to do if they are not. When Index.onError=OE_None,
18451 ** such a table must be a simple name: ID. But in SQLite, the table can
18603 /* All fields above are owned by the Upsert object and must be freed
18623 ** These addresses must be stored so that we can go back and fill in
18716 ** SRT_Set The result must be a single column. Store each
18945 ** Fields above must be initialized to zero. The fields that follow,
18957 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
19405 ** about each Common Table Expression that must be preserved for the
20581 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
20926 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
21093 ** The fields that follow are uninitialized, and must be individually
21245 ** the following flags must be set to determine the memory management
21662 ** Return the current value of a status parameter. The caller must
21675 ** Add N to the value of a status record. The caller must hold the
21683 ** mark is unchanged. N must be non-negative for StatusDown().
21708 ** The caller must hold the appropriate mutex.
22187 ** The HH, MM, and SS must each be exactly 2 digits. The
23386 ** The core must call OsFileControl() though, not OsFileControlHint(),
23792 ** are merely placeholders. Real drivers must be substituted using
24972 ** this mem3.iKeyBlk replacement to work, the key chunk must be
24974 ** affairs, of course. The calling routine must link the key
24975 ** chunk before invoking this routine, then must unlink the (possibly
25417 ** The size of this object must be a power of two. That fact is
25579 /* nByte must be a positive */
25770 ** All allocations must be a power of two and must be expressed by a
25800 ** This routine is not threadsafe. The caller must be holding a mutex
25815 /* The size of a Mem5Link object must be a power of two. Verify that
26455 ** mutex must be exited an equal number of times before another thread
26761 ** mutex must be exited an equal number of times before another thread
27481 ** mutex must be exited an equal number of times before another thread
27839 ** implementation of malloc_good_size(), which must be called in debug
28409 ** This function must be called before exiting any API function (i.e.
28421 /* If the db handle must hold the connection handle mutex here.
29676 ** sqlite3_log() must render into a static buffer. It cannot dynamically
29682 ** Care must be taken that any sqlite3_log() calls that occur while the
31411 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
31435 ** in pZ. nChar must be non-negative.
31715 ** The input string must be zero-terminated. A new zero-terminator
32096 ** The caller must ensure that zOut[] is at least 21 bytes in size.
32121 ** Note that zNum must contain exactly 19 characters.
32149 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
32207 ** them, but we must appaise the undefined-behavior pharisees. */
32813 ** binary value has been obtained from malloc and must be freed by
34587 ** To prevent deadlock, the global unixBigLock must must be acquired
34590 ** that happens, the unixBigLock mutex must not be acquired until after
34754 ** On VxWorks, a unique file id must be based on the canonical filename.
35007 ** (1) Only the pLockMutex mutex must be held in order to read or write
35020 ** and pLockMutex are needed, then unixBigLock must be acquired first.
35182 ** The global mutex must be held when this routine is called, but the mutex
35183 ** on the inode being deleted must NOT be held.
35218 ** The global mutex must held when calling this routine.
35758 ** must be either NO_LOCK or SHARED_LOCK.
35924 ** must be either NO_LOCK or SHARED_LOCK.
36184 ** must be either NO_LOCK or SHARED_LOCK.
36377 /* didn't get, must be busy */
36399 ** must be either NO_LOCK or SHARED_LOCK.
36562 ** must be either NO_LOCK or SHARED_LOCK.
36740 /* if we failed to get the lock then someone else must have it */
36956 ** must be either NO_LOCK or SHARED_LOCK.
37107 ** must be either NO_LOCK or SHARED_LOCK.
37260 /* Unread parts of the buffer must be zero-filled */
38114 ** unixMutexHeld() must be true when creating or destroying
38124 ** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and
38158 ** All other fields are read/write. The unixShm.pShmNode->pShmMutex must
38260 ** a time, assuming that each mapping must be an integer multiple of the
38264 ** to use 64KB pages - in this case each mapping must cover at least two
38270 assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */
38349 /* The first connection to attach must truncate the -shm file. We
38396 ** the file must be truncated to zero length or have its header cleared.
38510 ** at pShmNode->pFirst. This must be done while holding the
38850 ** All loads and stores begun before the barrier must complete before
39073 ** iOff. The mapping must be valid for at least nAmt bytes.
39080 ** If this function does return a pointer, the caller must eventually
39107 ** argument passed to this function must be the same as the corresponding
39119 /* If p==0 (unmap the entire file) then there must be no outstanding
39121 ** then there must be at least one outstanding. */
39124 /* If p!=0, it must match the iOff value. */
39650 ** Create a temporary file name in zBuf. zBuf must be allocated
39651 ** by the calling process and must be big enough to hold at least
39915 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
39916 ** (b) if CREATE is set, then READWRITE must also be set, and
39917 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
39918 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
39983 ** open(). These must be calculated even if open() is not called, as
40697 ** The conch file - to use a proxy file, sqlite must first "hold the conch"
40783 ** which must point to valid, writable memory large enough for a maxLen length
40961 /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
41137 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
41716 ** must be either NO_LOCK or SHARED_LOCK.
42172 must be defined."
44078 ** the provided arguments. The type argument must be 1 in order to set the
44228 ** must accept the error code DWORD as its only argument and should return
44238 ** defined, the "winIoerrCanRetry2" macro must exhibit external semantics
44397 ** must be zero-initialized */
44885 /* Unread parts of the buffer must be zero-filled */
45342 ** must go straight to locking level 0.
45514 ** must be either NO_LOCK or SHARED_LOCK.
45811 ** winShmMutexHeld() must be true when creating or destroying
45822 ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
45854 ** The winShmMutexHeld() must be true while reading or writing this list.
45868 ** All other fields are read/write. The winShm.pShmNode->mutex must be held
46020 ** the file must be truncated to zero length or have its header cleared.
46108 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
46278 ** All loads and stores begun before the barrier must complete before
46600 ** iOff. The mapping must be valid for at least nAmt bytes.
46607 ** If this function does return a pointer, the caller must eventually
46645 ** argument passed to this function must be the same as the corresponding
46656 /* If p==0 (unmap the entire file) then there must be no outstanding
46658 ** then there must be at least one outstanding. */
46661 /* If p!=0, it must match the iOff value. */
46766 ** obtained from malloc and must be freed by the calling function.
46786 ** is obtained from malloc and must be freed by the calling
46826 ** The pointer returned in pzBuf must be freed via sqlite3_free().
46901 ** it must be converted to a native Win32 path via the Cygwin API
47145 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
47146 ** (b) if CREATE is set, then READWRITE must also be set, and
47147 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
47148 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
47622 ** non-zero is returned from this function, the calling function must simply
47642 ** relative path or an absolute path. Callers of this function must not
49068 ** The calling function must ensure that p is a valid Bitvec object
49140 ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
49436 /* WRITEABLE pages must also be DIRTY */
49454 ** must be journalled and synced before any of those pages can be safely
49633 ** Change the page size for PCache object. The caller must ensure that there
49800 ** must be called after sqlite3PcacheFetch() in order to get a usable
49849 ** Drop a page from the cache. There must be exactly one reference to the
49952 ** caller must ensure that there are no outstanding references to any pages
49968 ** it must be that pgno==0.
50300 ** pointers must be either 4 or 8-byte aligned). As this structure is located
50322 ** that the page is in active use and must not be deallocated.
50371 ** The PGroup mutex must be held when accessing nMax.
50635 /* The group mutex must be released before pcache1Alloc() is called. This
50741 ** The PCache mutex must be held when this function is called.
50782 ** The PGroup mutex must be held when this function is called.
50807 ** The PGroup mutex must be held when this function is called.
50850 ** The PCache mutex must be held when this function is called.
52418 ** layer must either commit or rollback the transaction.
52997 /* State must be valid. */
53014 /* If the useJournal flag is clear, the journal-mode must be "OFF".
53015 ** And if the journal-mode is "OFF", the journal file must not be open.
53038 /* If changeCountDone is set, a RESERVED lock or greater must be held
53113 /* There must be at least one outstanding reference to the pager if
53272 ** Unlock the database file to level eLock, which must be either NO_LOCK
53299 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
53422 ** When this is called the journal file for pager pPager must be open.
53428 ** zSuper must point to a buffer of at least nSuper bytes allocated by
53515 ** The journal file must be open when this function is called.
53571 ** The journal file must be open when this routine is called. A journal
53592 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
53687 ** The journal file must be open when this is called. A journal header file
53714 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
53781 ** invalid, then the process that wrote the journal-header must have
53811 ** pPager at the current location. The super-journal name must be the last
54319 ** Parameter aData must point to a buffer of pPager->pageSize bytes
54405 assert( aData ); /* Temp storage must have already been allocated */
54462 /* If the pager is in CACHEMOD state, then there must be a copy of this
54483 ** statement we must not write to the original database unless we know
54487 ** restore the database to its original form. Two conditions must be
54488 ** met before writing to the database files. (1) the database must be
54525 ** case it must be encrypted here before it is copied into the database
54944 ** it is corrupted, then a process must have failed while writing it.
55100 ** pPg->pData. A shared lock or greater must be held on the database
55224 ** the backups must be restarted.
55335 int changed = 0; /* True if cache must be reset */
55420 ** The caller must hold a SHARED lock on the database file to call this
56081 ** Once this function has been called, the transaction must either be
56179 ** Release a reference to page pPg. pPg must have been returned by an
56469 ** The pager must hold at least a RESERVED lock when this function
57445 ** the file. If the unlock attempt fails, then Pager.eLock must be
57870 ** There must already be a RESERVED or EXCLUSIVE lock on the database
58258 ** journal file must contain sync()ed copies of all of them
58278 ** Mark a data page as writeable. This routine must be called before
58279 ** making changes to a page. The caller must check the return value
58286 ** must have been written to the journal file before returning.
58518 ** is not synced. The caller must call sqlite3PagerSync() directly to
58922 ** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE,
59182 ** There must be no references to the page previously located at
59191 ** A transaction must be active when this routine is called. It used to be
59216 /* In order to be able to rollback, an in-memory database must journal
59365 ** Get/set the locking-mode for this pager. Parameter eMode must be one
59388 ** Set the journal-mode for this pager. Parameter eMode must be one of:
59645 ** The caller must be holding a SHARED lock on the database file to call
59843 ** A read-lock must be held on the pager when this function is called. If
59950 ** before the xSync must complete before any write that launches after the
59990 ** on a network filesystem. All users of the database must be able to
60208 ** WalIndexHdr.mxFrame must never be less than nBackfillAttempted.
60493 ** The argument to this macro must be of type u32. On a little-endian
60511 ** nByte must be a positive multiple of 8.
60712 ** A lock cannot be moved directly between shared and exclusive - it must go
60752 ** Compute a hash on a page number. The resulting hash value must land
60944 ** must have exited unexpectedly in the middle of a transaction (after
61243 ** Open a connection to the WAL file zWalName. The database file must
61245 ** to must remain valid for the lifetime of the returned Wal* handle.
61350 u32 iMin; /* Result pgno must be greater than iMin */
61526 ** only. The caller must hold the checkpoint lock.
61720 ** The cache of the wal-index header must be valid to call this function.
61787 ** The caller must be holding sufficient locks to ensure that no other
61874 ** must be corruption somewhere. */
62080 /* The first page of the wal-index must be mapped at this point. */
62310 ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY
62338 ** wal-index header has mxFrame==0, then it must be safe to proceed
62432 ** The caller must set the cnt parameter to the number of prior calls to
62446 ** that means the Wal does not hold any read lock. The reader must not
62454 ** When the read transaction is completed, the caller must release the
62524 ** must be zeroed before the requested page is returned.
63023 ** A read transaction must have already been started by a prior call
63138 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
63153 ** the values in the aWalData[] array. aWalData must point to an array
63321 ** transaction restarted the wal file), these values must be read from the
63354 ** Write a set of frames to the log. The caller must hold the write-lock
63463 ** checksums must be recomputed when the transaction is committed. */
63734 ** into locking_mode=NORMAL. This means that we must acquire a lock
63738 ** operation must occur while the pager is still holding the exclusive
63742 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
63745 ** routine is a no-op. The pager must already hold the exclusive lock
63993 ** 21 1 Max embedded payload fraction (must be 64)
63994 ** 22 1 Min embedded payload fraction (must be 32)
63995 ** 23 1 Min leaf payload fraction (must be 32)
64085 ** increasing order. Because a freeblock must be at least 4 bytes in size,
64172 ** header must be exactly 16 bytes including the zero-terminator so
64210 ** is allocated. All fields that follow must be initialized before use */
64301 ** These values must match SQLITE_TXN_NONE, SQLITE_TXN_READ, and
64465 ** sqlite3BtreeCursorZero(). Fields that follow must be manually
64564 ** is moved, the pointer in its parent must be updated to point to the
65084 ** (MemPage*) as an argument. The (MemPage*) must not be NULL.
65136 Btree *pBtree, /* Handle that must hold lock */
65175 /* Two or more indexes share the same root page. There must
65253 /* If requesting a write-lock, then the Btree must have an open write
65255 ** must be an open write transaction on the file itself.
65301 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
65411 ** than the writer must be about to drop to zero. In this case
65414 ** If there is not currently a writer, then BTS_PENDING must
65610 ** The cursor passed as the only argument must point to a valid entry
65661 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
65860 ** cursor returned must not be used with any other Btree interface.
65963 /* The super-journal page number must never be used as a pointer map page */
66711 /* The list of freeblocks must be in ascending order. Find the
66920 ** of the page, then the page must be corrupted. This check also
67006 /* To many cells for a single page. The page must be corrupt */
67139 ** And if the fetch fails, this routine must decrement pCur->iPage.
67180 /* If obtaining a child page for a cursor, we must verify that the page is
67204 ** Page1 is a special case and must be released using releasePageOne().
67831 ** The page size must be a power of 2 between 512 and 65536. If the page
68130 ** fractions and the leaf payload fraction values must be 64, 32, and 32.
68196 ** Besides the payload, the cell must store:
68337 ** A write-transaction must be started before attempting any
68358 ** One or the other of the two processes must give way or there can be
68858 ** A write-transaction must be opened before calling this function.
69244 ** back independently of the main transaction. You must start a transaction
69312 ** the transaction was started. Otherwise, it must be at least 1. */
69330 ** are also met. These are the conditions that must be met in order
69333 ** 1: The cursor must have been opened with wrFlag containing BTREE_WRCSR
69341 ** 3: The database must be writable (not on read-only media)
69343 ** 4: There must be an active transaction.
69415 ** cursors *must* have the BTCF_Multiple flag set. */
69459 ** to users so they cannot do the sizeof() themselves - they must call
69612 ** The caller must guarantee that the cursor is pointing to a non-NULL
69613 ** valid entry. In other words, the calling procedure must guarantee
69770 ** Once an overflow page-list cache has been allocated, it must be
69815 /* Check if data must be read/written to/from the btree page itself. */
69973 ** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing
70031 ** onto overflow pages, then accessPayload() must be used to reassemble
70054 ** of local content. Database must be corrupt. */
70382 ** must be NULL. For index tables, pIdxKey is used and intKey
70495 /* pPage->nCell must be greater than zero. If this is the root-page
70498 ** would have already detected db corruption. Similarly, pPage must
70942 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
71415 ** file the database must be corrupt. */
71429 ** must not really be an overflow page and the database must be corrupt.
71539 ** that means content must spill into overflow pages.
71650 ** "sz" must be the number of bytes in the cell.
71706 ** *pRC must be SQLITE_OK when this routine is called.
72028 ** area must be extended to before this point in order to accomodate all
72272 ** pParent is its parent. pPage must have a single overflow entry
72278 ** words, at most 13 bytes. Hence the pSpace buffer must be at
72343 ** a variable length key value (which must be the same value as the
72562 ** this overflow cell is present, it must be the cell with
72731 ** This must be done in advance. Once the balance starts, the cell
72921 ** must be true:
73613 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
73619 ** pX.pData,nData,nZero fields must be zero.
73630 ** In that case, this routine must seek the cursor to the correct insertion
73695 /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
73732 /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
74075 /* If the bPreserve flag is set to true, then the cursor position must
74448 ** If pnChange is not NULL, then table iTable must be an intkey table. The
75004 ** False if IPK must be strictly less than maxKey */
75249 ** A read-only or read-write transaction must be opened before calling
75556 ** Argument pCsr must be a cursor opened for writing on an
75584 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
75864 pDestDb, SQLITE_ERROR, "source and destination must be distinct"
76411 ** must be active for both files.
76433 /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
76523 ** sqlite3_result_pointer(). If a pointer, then MEM_Term must also be
76549 /* If p holds a string or blob, the Mem.z must point to exactly
76696 ** pMem->z into the new allocation. pMem must be either a string or
76705 /* If the bPreserve flag is set to true, then the memory cell must already
76956 ** If the memory cell contains a value that must be freed by
77636 ** The pMem object must have been initialized. This routine will use
77736 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
77740 ** If that is the case, then the result must be aligned on an even byte
78198 ** When this function is called, *ppRec must either point to an object
78199 ** allocated by an earlier call to this function, or must be NULL. If it
78310 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
78848 ** The zWhere string must have been obtained from sqlite3_malloc().
78925 ** be inserted. The parameter "x" must have been obtained from
79165 ** script numbers the opcodes correctly. Changes to this routine must be
79714 ** The P4 operand must not have been previously defined. And the new
79715 ** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of
80973 ** zName must be a pointer to a nul terminated string.
80975 ** This call must be made after a call to sqlite3VdbeSetNumCols().
80977 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
81149 /* The antipenultimate character of the super-journal name must
81297 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
81443 ** transaction must be rolled back to restore the database to a
82776 /* The collation sequence must be defined at this point, even if
82789 /* Both values must be blobs. Compare using memcmp(). */
82839 ** greater than key2. The {nKey1, pKey1} key must be a blob
82841 ** key must be a parsed key such as obtained from
83288 ** than 2GiB are support - anything large must be database corruption.
83303 /* The index entry must begin with a header size */
83452 ** The returned value must be freed by the caller using sqlite3ValueFree().
83490 ** OP_PureFunc means that the function must be deterministic, and should
84532 ** single prepared statement. The iArg values must match.
84874 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
87378 ** Thus the program must guarantee that the original will not change
87419 ** non-zero. The P2 opcode must be 1.
87888 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
87938 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
88132 ** This opcode must follow an OP_Lt or OP_Gt comparison operator. There
88135 ** OP_Lt or OP_Gt. Furthermore, the prior OP_Lt or OP_Gt must have the
88962 ** have a non-NULL default value. Also, the record must be left with
89402 ** return an error indicating that the other VMs must complete first.
89567 ** There must be a read-lock on the database (either a transaction
89568 ** must be started or there must be an open cursor) before
89598 ** A transaction must be started before executing this opcode.
89656 ** object, then table being opened must be an [index b-tree] where the
89659 ** value, then the table being opened must be a [table b-tree] with a
89673 ** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must
89695 ** object, then table being opened must be an [index b-tree] where the
89698 ** value, then the table being opened must be a [table b-tree] with a
89827 ** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral
90095 ** this opcode must be followed by an IdxLE opcode with the same arguments.
90162 ** this opcode must be followed by an IdxLE opcode with the same arguments.
90263 ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be
90367 ** opcode must be immediately followed by OP_SeekGE. This constraint is
90516 ** P1 must be a valid b-tree cursor.
90740 ** the P3 register must be guaranteed to contain an integer value. With this
90997 ** number P2. The key is stored in register P3. The key must
91007 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
91113 ** P1 and P2 are both open cursors. Both must be opened on the same type
91119 ** This opcode must be followed by either an Insert or InsertIdx opcode
91159 ** P1 must not be pseudo-table. It has to be a real table with
91163 ** the update or pre-update hook, or both, may be invoked. The P1 cursor must
91356 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
91493 ** if the cursor is valid, then the cursor must already be pointing
91658 ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have
91686 ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is
91702 ** This opcode works just like OP_Next except that P1 must be a
91776 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
92176 ** If the P3 value is non-zero, then the table referred to must be an
92236 ** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
92237 ** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
92524 ** must have P4==0, the final set must have P4==-1, and for all other sets
92525 ** must have P4>0.
92622 ** is already allocated. Otherwise, it must be initialized. */
92816 ** Register P1 must contain an integer.
92878 ** Register P1 must contain an integer. If the content of register P1 is
92897 ** Register P1 must hold an integer. Decrement the value in P1
92974 /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */
93146 ** Change the journal mode of database P1 to P3. P3 must be one of the
93825 ** in register P3. Register P3 must not be one of the function inputs.
93844 ** in register P3. Register P3 must not be one of the function inputs.
93854 ** its name. This opcode is used in places where the function must be
93921 ** Operand P1 must be 0x7fffffff and P2 must positive.
93948 /* If the P4 argument is not NULL, then it must be an SQL comment string.
94448 ** key columns must be indexed. The check below will pick up this
94805 ** The interfaces above must be called in a particular order. Write() can
97537 sqlite3_vtab base; /* Base class - must be first */
97546 sqlite3_vtab_cursor base; /* Base class - must be first */
97550 int needFinalize; /* Cursors owns pStmt and must finalize it */
97864 ** We must have a single stmt=? constraint that will be passed through
98693 ** structures must be increased by the nSubquery amount.
99548 "second argument to likelihood() must be a "
100318 /* If a HAVING clause is present, then there must be a GROUP BY clause.
101097 ** column of the vector (numbered starting with 0). The caller must
101135 ** then the returned object will reference pVector and so pVector must remain
101206 ** If pVector is a TK_SELECT expression, then code for it must have
101245 ** The caller must satisfy the following preconditions:
101733 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
102310 ** The pList argument must be either NULL or a pointer to an ExprList
102386 ** wildcards ("*") in the result set of the SELECT must be expanded before
102622 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
102804 ** expression must not refer to any non-deterministic function nor any
102847 ** the value of the HAVING clause term must be the same for all members of
102848 ** a "group". The requirement that the GROUP BY term must be BINARY
103079 /* All SELECT results must be columns. */
103144 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
103157 ** The inFlags parameter must contain, at a minimum, one of the bits
103164 ** through the set members) then the b-tree must not contain duplicates.
103170 ** for fast set membership tests) then an epheremal table must
103194 ** If the aiMap parameter is not NULL, it must point to an array containing
103217 int mustBeUnique; /* True if RHS must be unique */
103529 /* The evaluation of the IN must be repeated every time it
103718 /* The evaluation of the EXISTS/SELECT must be repeated every time it
103841 ** subquery. If the RHS is a subquery, the number of result columns must
103843 ** a list of values, the LHS must be a scalar.
103999 ** LHS does contain NULLs then the result must be either FALSE or NULL.
104041 ** an match on the search above, then the result must be FALSE.
104088 /* Step 7: If we reach this point, we know that the result must
104273 ** There must be an open cursor to pTab in iTable when this routine
104303 ** register iReg. The caller must ensure that iReg already contains
104477 ** must check the return code and move the results to the desired
105374 ** filled using OP_SCopy. OP_Copy must be used instead.
105428 && pOp->p5==0 /* The do-not-merge flag must be clear */
105998 ** must never return 0 if the two ExprList objects are different, or
107099 ** column must not be NULL.
107836 ** trigger object, the database must be corrupt. */
107910 ** corresponding to all tokens in the input SQL that must be replaced
108826 ** must be separated from the last integer by a single space. If the
109381 /* The "rows less-than" for the rowid column must be greater than that
110479 ** Arguments zSql1 and zSql2 must point to SQL statements that return
110895 "attached databases must use the same text encoding as main database");
111206 ** Initialize a DbFixer structure. This routine must be called prior
111212 int iDb, /* This is the database that must be used */
111237 ** must have been initialized by a prior call to sqlite3FixInit().
112137 /* Justification of ALWAYS(); The index must be on the list of
112352 ** is obtained from sqliteMalloc() and must be freed by the calling
112672 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
112767 ** the schema table. Note in particular that we must go ahead
112770 ** indices to be created and the table record must come before the
112771 ** indices. Hence, the record number for the table must be allocated
113124 ** Default value expressions must be constant. Raise an exception if this
113505 ** from sqliteMalloc() and must be freed by the calling function.
113652 ** collating sequence must match for this routine, but for hasColumn() only
113653 ** the column name must match.
114073 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
114127 ** as a schema-lock must have already been obtained to create it. Since
114235 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
114501 ** We must continue looping until all tables and indices with
115007 ** the index already exists and must be cleared before being refilled and
115344 ** must have names that are distinct from normal automatic index names.
115636 assert( p==pIndex ); /* Malloc must have failed */
115775 ** of the index. And so forth. It must always be the case that
116529 ** such that the abort must occur after the multiwrite. This makes
117094 ** the pDfltColl must change as well.
117110 ** If it is not NULL, then pColl must point to the database native encoding
117304 ** of arguments. If nArg is -2, then createFlag must be 0.
117349 ** So we must not search for built-ins when creating a new function.
118110 ** 2. Read/write cursors for all indices of pTab must be open as
118113 ** 3. The primary key for the row to be deleted must be stored in a
118122 ** then this function must seek iDataCur to the entry identified by iPk
118279 ** 1. A read/write cursor "iDataCur" must be open on the canonical storage
118284 ** 2. Read/write cursors for all indices of pTab must be open as
118288 ** 3. The "iDataCur" cursor must be already be positioned on the row
118330 ** iCur must be the cursor of the PRIMARY KEY index.
119305 /* The escape character string must consist of a single UTF-8 character.
119312 "ESCAPE expression must be a single character", -1);
119640 ** must be exact. Collating sequences are not used.
120789 ** modified (values must be compared at runtime).
123027 ** A temp table must be used if the table being updated is also one
123327 ** columns have already been computed. This must be done after
123398 ** columns have already been computed. This must be done after
123552 ** return true if this CHECK constraint must be validated for
123689 ** The caller must have already opened writeable cursors on the main
123953 ** OE_Fail and OE_Ignore must happen before any changes are made.
123955 ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback
124333 ** must be explicitly deleted in order to ensure any pre-update hook
124564 ** to be the number of columns in table pTab that must not be NULL-trimmed.
124817 /* If no test above fails then the indices must be compatible */
124879 return 0; /* tab1 must not have triggers */
124883 return 0; /* tab1 must not be a virtual table */
124892 return 0; /* FROM clause must have exactly one term */
124920 return 0; /* The result set must have exactly one column */
124924 return 0; /* The result set must be the special operator "*" */
124941 return 0; /* source and destination must both be WITHOUT ROWID or not */
124945 return 0; /* tab2 must not be a virtual table */
124952 return 0; /* Number of columns must be the same in tab1 and tab2 */
124955 return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
125001 return 0; /* Affinity must be the same on all columns */
125004 return 0; /* Collating sequence must be the same on all columns */
125007 return 0; /* tab2 must be NOT NULL if tab1 is */
125017 return 0; /* Default values must be the same for all columns */
125089 ** Conditions under which the destination must be empty:
126576 ** must call either sqlite3_enable_load_extension(db) or
126732 ** mutex must be held while accessing this list.
127698 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
127803 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
128198 ** of the PRAGMA command. In this case the locking-mode must be
130449 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
130583 /* All other schemas after the main schema. The "temp" schema must be last */
132988 /* The vdbe must make its own copy of the column-type and other
133415 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
133553 ** the Distinct table must be exactly one greater than Queue in order
134096 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
134217 /* If none of the above, then the result destination must be
134930 ** (2a) the outer query must not be a join and
134931 ** (2b) the outer query must not use subqueries
134952 ** (7) The subquery must have a FROM clause. TODO: For subqueries without
134984 ** (17a) all compound operators must be a UNION ALL, and
134987 ** (17c) every term within the subquery compound must have a FROM clause
134992 ** (17f) the subquery must not be the RHS of a LEFT JOIN.
135001 ** Also, each component of the sub-query must return the same number
135008 ** ORDER BY clause of the parent must be copies of a term returned
135014 ** (20) If the sub-query is a compound select, then it must not use
135016 ** somewhat by saying that the terms of the ORDER BY clause must
135048 ** All of the expression analysis must occur on both the outer query and
135158 /* Restriction (17): If the sub-query is a compound SELECT, then it must
135227 ** 17 and 18 above) it must be a UNION ALL and the parent query must
135531 ** is a constant expression and where the term must be true because it
135848 ** WHERE_ORDERBY_NORMAL (which must be zero).
135850 ** This routine must be called after aggregate functions have been
136656 ** SELECT statement. The SELECT statement must be expanded before
136801 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
137617 ** written the query must use a temp-table for at least one of the ORDER
139244 ** one trigger that must be fired when an operation of type 'op' is
139838 ** always defined. The trigger must be in the same schema as the table
139839 ** or else it must be a TEMP trigger. */
139877 ** accessed by triggers. The caller must always assume that it is.
139879 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
139882 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
140078 ** this function, they must be deleted by the caller.
140093 ** If the table is a WITHOUT ROWID table, then argument pPk must be its
140555 /* Virtual tables must be handled separately */
140821 ** values for registers not modified by the UPDATE must be reloaded from
140943 /* We must run the OP_FinishSeek opcode to resolve a prior
141609 /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX,
141661 ** database content must be written into the rollback journal prior to
142269 ** associated with the database handle itself must be held.
142487 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
142591 /* Justification of ALWAYS(): A correct vtab constructor must allocate
142727 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
142816 /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
142817 ** or else must have a single-column PRIMARY KEY */
143423 Bitmask prereq; /* Bitmask of other loops that must run first */
143565 u8 nChild; /* Number of children that must disable us */
143818 Bitmask notReady, /* RHS must not overlap with this mask */
144138 ** If argument addrExplain is not 0, it must be the address of an
144316 ** IN expression must also be run on each output row for correctness.
144816 /* An aggregate function in the WHERE clause of a query means this must
144821 ** expression, as the result of the expression must be stored in a
144869 ** that were specified as part of the WHERE clause must be excluded.
144993 ** If the expression is not a vector, then nReg must be passed 1. In
145162 ** WHERE clause terms on the query, and if any of those terms must be
145334 ** encoding of the value in the register, so it *must* be reloaded. */
145514 ** the right-most column can be an inequality - the rest must
145886 ** terms from the query that must be true due to the WHERE clause of
146221 /* Case 6: There is no usable index. We must do a complete
146571 ** In order for the operator to be optimizible, the RHS must be a string
146572 ** literal that does not begin with a wildcard. The LHS must be a column
146575 ** collating sequence for the column on the LHS must be appropriate for
146656 ** pattern prefix boundaries (both the start and end boundaries) must
146740 ** In every case, "column" must be a column of a virtual table. If there
146960 ** The term being analyzed must have two or more of OR-connected subterms.
147197 /* This term must be of the form t1.a==t2.b where t2 is in the
147235 ** of both right and left sides must be such that no type
147293 ** 1. The SQLITE_Transitive optimization must be enabled
147296 ** 4. The affinities of A and B must be compatible
147585 ** 1. The sub-select must not be an aggregate or use window functions,
147587 ** 2. The sub-select must not be a compound SELECT,
147589 ** 3. Expression <e1> must refer to at least one column from the outer
147590 ** query, and must not refer to any column from the inner query
147593 ** 4. <e2> and <e3> must not refer to any values from the outer query.
147595 ** must not be correlated.
147890 ** The virtual term must be tagged with TERM_VNULL.
148365 ** WHERE clause. A return of 0 means that the output must be
148680 ** must be one of the indexes of table iCur.
148682 ** The <op> must be one of the operators described by opMask.
148689 ** If X is not the INTEGER PRIMARY KEY then X must be compatible with
148737 ** If pIdx!=0 then it must be one of the indexes of table iCur.
148760 Bitmask notReady, /* RHS must not overlap with this mask */
148879 ** comparison and select-list expressions must match those of the index.
149120 ** original table never needs to be accessed. Automatic indices must
149384 ** must represent a virtual table. This function invokes the xBestIndex()
149545 /* If (res==0) is true, then pRec must be equal to sample i. */
149554 ** all samples in the aSample[] array, pRec must be smaller than the
149563 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
149565 ** If (i>0), then pRec must also be greater than sample (i-1). */
149860 /* Note: this call could be optimized away - since the same values must
151504 ** Argument mPrereq is a mask of tables that must be scanned before the
151513 Bitmask mPrereq, /* Mask of tables that must be used. */
151627 /* The non-zero argvIdx values must be contiguous. Raise an
151704 ** All the tables in mPrereq must be scanned before the current virtual
151707 ** Conversely, all tables in mUnusable must be scanned after the current
151713 Bitmask mPrereq, /* Tables that must be scanned before this one */
151714 Bitmask mUnusable /* Tables that must be scanned after this one */
152034 ** pOrderBy terms must be matched in strict left-to-right order.
152085 ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
153010 ** If the WHERE clause is empty, the foreach loops must each scan their
153124 ** field (type Bitmask) it must be aligned on an 8-byte boundary on
153333 ** For a table to not affect the result, the following must be true:
153335 ** 1) The query must not be an aggregate.
153336 ** 2) The table must be the RHS of a LEFT JOIN.
153337 ** 3) Either the query must be DISTINCT, or else the ON or USING clause
153338 ** must contain a constraint that limits the scan of the table to
153340 ** 4) The table must not be referenced by any part of the query apart
154185 pCtx, "second argument to nth_value must be a positive integer", -1
154372 pCtx, "argument of ntile must be a positive integer", -1
155380 "frame starting offset must be a non-negative integer",
155381 "frame ending offset must be a non-negative integer",
155382 "second argument to nth_value must be a positive integer",
155383 "frame starting offset must be a non-negative number",
155384 "frame ending offset must be a non-negative number",
155569 /* All OVER clauses in the same window function aggregate step must
159545 assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
160498 ** Perform a reduce action and the shift that must immediately
162963 ** sqlite3IsIdChar[X] must be 1.
163314 ** but z[i] is a character not allowed within keywords, so this must
163336 /* If it is not a BLOB literal, then it must be an ID, since no
163722 ** must end with ";END;".
163742 ** (5) TRIGGER We are in the middle of a trigger definition that must be
164228 ** This routine must be called to initialize the memory allocation,
164240 ** threads must block until the first thread finishes with the initialization.
164250 ** * Calls to this routine from Y must block until the outer-most
164277 ** must be complete. So isInit must not be set until the very end
164290 ** The mutex subsystem must take care of serializing its own
164300 ** mutex must not require support from the malloc subsystem.
165731 ** must be done in increments of whole seconds */
166129 ** A global function must exist in order for name resolution to work
166445 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
166756 ** initializer must be kept in sync with the SQLITE_LIMIT_*
166778 # error SQLITE_MAX_LENGTH must be at least 100
166781 # error SQLITE_MAX_SQL_LENGTH must be at least 100
166784 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
166787 # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
166790 # error SQLITE_MAX_VDBE_OP must be at least 40
166793 # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
166796 # error SQLITE_MAX_ATTACHED must be between 0 and 125
166799 # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
166802 # error SQLITE_MAX_COLUMN must not exceed 32767
166805 # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
166808 # error SQLITE_MAX_WORKER_THREADS must be between 0 and 50
166884 ** The caller must invoke sqlite3_free_filename() (not sqlite3_free()!) on
168372 ** Memory layout must be compatible with that generated by the pager
169233 ** itself grows too big and must be split. The format of interior
169911 ** time must share a common language-id (see the FTS4 langid= feature).
169972 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
170038 ** A "phrase" is a sequence of one or more tokens that must match in
170047 int bFirst; /* True if token must appear at position 0 */
170071 int iColumn; /* Index of column this phrase must match */
171240 ** the number of bytes of space that must be allocated to store copies
172163 ** Value used to signify the end of an position-list. This must be
172181 ** Before calling this routine *pi must be initialized to the value of
172307 ** called, *pp1 and *pp2 must both point to position lists. A position-list is
172624 ** the difference between it and the previous value in the output must
172889 ** as a single-byte delta, whereas in the second it must be stored as a
172985 ** for the pending-terms. If this is a scan, then this call must be being
173463 /* The column value supplied by SQLite must be in range. */
173633 ** When called, *ppPoslist must point to the byte immediately following the
173715 /* There must be at least one argument passed to this function (otherwise
173874 /* At this point it must be known if the %_stat table exists or not.
174858 int iCol; /* The column the token must match */
175758 ** Expression pExpr must be of type FTSQUERY_PHRASE.
175911 ** must be of type FTSQUERY_PHRASE.
177113 ** the next byte must contain either whitespace, an open or close
177171 /* If control flows to this point, this must be a regular token, or
177675 ** Column names must be nul-terminated strings.
178146 ** "new_size" must be a power of 2. The hash table might fail
178614 int (*xCond)(const char*) /* Condition that must be true */
178918 ** part of a token. In other words, delimiters all must have
178932 ** Extract the next token from a tokenization cursor. The cursor must
179060 ** If the <pointer> argument is specified, it must be a blob value
179063 ** the string <key-name> must already exist in the has table. Otherwise,
179245 ** function must be called with two or more arguments:
179468 ** the hash table pointed to by argument pHash. The hash table must
179683 ** Extract the next token from a tokenization cursor. The cursor must
179790 ** When queried, the query must include a WHERE clause of type:
180340 int iCol; /* Column token must occur in */
180507 ** If argument apVal is not NULL, then it must point to an array with
181058 ** Tokens must have a non-zero length.
181420 ** must call sqlite3Fts3SegmentsClose() before returning.
181431 /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */
181974 ** below, the "Fts3HashElem *pE" must be declared so that it is valid
182263 /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of
182264 ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when
182454 int isCopyTerm, /* True if buffer zTerm must be copied */
182496 /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of
182497 ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when
182518 ** the interior tree must:
182526 ** In other words, it must be the prefix of zTerm 1 byte longer than
182598 ** database. This function must be called after all terms have been added
183189 ** of Fts3SegReader objects is the same. The doclists must be merged
184151 ** header must be written before this function is called.
184158 ** node, both aDoclist and nDoclist must be passed 0.
184185 /* Node must have already been started. There must be a doclist for a
184186 ** leaf node, and there must not be a doclist for an internal node. */
184254 ** parent must:
184262 ** In other words, it must be the prefix of zTerm 1 byte longer than
184338 ** start_block and end_block fields of the %_segdir table must be populated.
185787 int iCol /* Column that token must appear in (or -1) */
185874 /* At this point it must be known if the %_stat table exists or not.
185918 ** if the on-conflict mode is other than REPLACE, then this method must
188088 ** Extract the next token from a tokenization cursor. The cursor must
190249 sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
190612 sqlite3_vtab_cursor base; /* Base class - must be first */
191235 ** table must be the same size as the root node. The content of each node
191439 ** Therefore all non-root nodes must contain at least 3 entries. Since
191527 ** with the normal values above, but must be less than RTREE_MATCH. These
191956 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
193078 /* A MATCH operator. The right-hand-side must be a blob that
194411 ** case, SQLITE_CONSTRAINT must be returned regardless of the
194920 "Auxiliary rtree columns must be last" /* 4 */
195398 ** The second argument to this function must be either "_rowid" or
197787 /* The escape character string must consist of a single UTF-8 character.
197797 "ESCAPE expression must be a single character", -1);
198495 ** containing the entry being inserted or deleted must be modified. If the
198530 ** * The transaction must consist of INSERT, UPDATE and DELETE operations
198535 ** * UPDATE and DELETE statements must identify their target rows by
198538 ** has no PRIMARY KEY, affected rows must be identified by rowid.
198584 ** PRIMARY KEY declaration, the data_% table must also contain a column
198598 ** target table must be present in the input table. For virtual tables,
198633 ** "rbu_control" column must contain the same number of characters as
198634 ** there are columns in the target database table, and must consist entirely
198667 ** the existing value within the target database table must be of type BLOB.
198753 ** the path to the RBU database. Each call to this function must be matched
198764 ** Or, if zState is non-NULL, it must be a path to a database file in which
198767 ** When resuming an RBU update, the zState argument must be passed the same
198857 ** The first argument passed to this function must be a valid, open, RBU
198873 ** it must use sqlite3_create_function() or similar to register the
198962 ** exists, must contain the same columns as the following:
198966 ** There must be one row in the table for each source (data_xxx) table within
199029 ** the custom VFS must be explicitly created by the user before the RBU
199187 ** These values must match the values defined in wal.c for the equivalent
199652 ** arguments must be passed to this function. The first is the blob to
200083 ** The first argument must be a nul-terminated string. This function
202301 ** Argument eType must be one of RBU_INSERT, RBU_DELETE, RBU_IDX_INSERT or
203869 ** recovery, the connection must request *-shm pages in order
205184 ** value must be a BLOB which is the correct page size, otherwise the
205268 /* If there is a schema= constraint, it must be honored. Report a
205708 ** change-set binary format, and so must be architecture independent.
206021 ** Free buffer pFree, which must have been allocated by an earlier
206032 ** order to use this macro, the entire data structure must be represented
206559 ** All returned buffers are part of the same single allocation, which must
206834 /* This may fail if SQLite value p contains a utf-16 string that must
207414 ** The new object must be linked onto the end of the list, not
209492 ** Iterator pIter must point to an SQLITE_INSERT entry. This function
209546 ** If this function returns SQLITE_ROW, the caller must eventually reset()
209632 ** Argument eType must be either CHANGESET_DATA or CHANGESET_CONFLICT.
210558 /* The new object must be linked on to the end of the list, not
210827 ** Buffers a1 and a2 must both contain a sessions module record nCol
211509 ** following structure. All structure methods must be defined, setting
211566 ** For each token in the input string, the supplied callback xToken() must
211831 ** Maximum number of prefix indexes on single FTS5 table. This must be
212218 ** For an insert, it must be called once for each token in the new document.
212219 ** If the operation is a delete, it must be called (at least) once for each
212250 ** records must be invalidated.
213382 assert( fts5yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
213595 ** Perform a reduce action and the shift that must immediately
215053 ** pBuf, which must be already be large enough to hold the new data.
216284 u8 bFirst; /* True if token must be first in column */
216291 ** A phrase. One or more terms that must appear in a contiguous sequence
216302 ** One or more phrases that must appear within a certain token distance of
216620 ** Argument pTerm must be a synonym iterator. Return the current rowid
216645 ** Argument pTerm must be a synonym iterator.
217671 ** then the first document visited must have a rowid smaller than or
222944 ** This function filters it according to pColset (which must be non-NULL)
223371 ** id must be between 1 and 65335 inclusive, and must not be used by
224196 /* If nBest is still 0, then the index must be empty. */
224397 ** that each varint must be stored contiguously. */
225099 ** records must be invalidated.
225239 ** For an insert, it must be called once for each token in the new document.
225240 ** If the operation is a delete, it must be called (at least) once for each
225291 /* If the QUERY_SCAN flag is set, all other flags must be clear. */
225304 ** If the QUERY_TEST_NOIDX flag was specified, then this must be a
225430 ** Parameter anSize must point to an array of size nCol, where nCol is
225930 /* Page iter.iLeaf must now be the rightmost leaf-page in the segment */
226476 "first arg to fts5_rowid() must be 'segment'" , -1
228142 /* A transaction must be open when this is called. */
228171 ** any conflict on the rowid value must be detected before any
230454 ** must match that passed to the sqlite3Fts5StorageStmt() call.
230846 /* Values for eRemoveDiacritic (must match internals of fts5_unicode2.c) */
233970 sqlite3_vtab base; /* Base class - must be first */
233980 sqlite3_vtab_cursor base; /* Base class - must be first */