Lines Matching refs:must
145 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
146 ** system #includes. Hence, this block of code must be the very first
198 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
220 /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
221 ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
531 ** must be either a NULL
602 ** <li> The application must ensure that the 1st parameter to sqlite3_exec()
604 ** <li> The application must not close the [database connection] specified by
606 ** <li> The application must not modify the SQL statement text passed into
951 ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
1080 ** to read the database file, as the WAL and shared memory files must exist
1118 ** sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be
1295 ** The zName field holds the name of the VFS module. The name must
1311 ** must invent its own temporary name for the file. ^Whenever the
1370 ** the xOpen method must set the sqlite3_file.pMethods to either
1371 ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
1415 ** next. Applications that use these interfaces must be prepared for any
1417 ** from one release to the next. Applications must not attempt to access
1500 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1546 ** is not. The sqlite3_shutdown() interface must only be called from a
1547 ** single thread. All open [database connections] must be closed and all
1548 ** other SQLite resources must be deallocated prior to invoking
1567 ** are omitted and the application must call sqlite3_initialize() directly
1592 ** option) the application must supply a suitable implementation for
1595 ** must return [SQLITE_OK] on success and some other [error code] upon
1613 ** must ensure that no other SQLite interfaces are invoked by other
1680 ** The xMalloc, xRealloc, and xFree methods must work like the
1712 ** methods must be threadsafe or else make their own arrangements for
1827 ** The first argument must be a pointer to an 8-byte aligned buffer
1857 ** argument must be either a NULL pointer or a pointer to an 8-byte
1888 ** The first pointer (the memory pointer) must be aligned to an 8-byte
1955 ** supplied by the application must not invoke any SQLite interface.
1957 ** function must be threadsafe. </dd>
2114 ** slots. The size of the buffer in the first argument must be greater than
2116 ** must be aligned to an 8-byte boundary. ^If the second argument to
2374 ** The input to [sqlite3_complete()] must be a zero-terminated
2377 ** The input to [sqlite3_complete16()] must be a zero-terminated
2439 ** A busy handler must not close the database connection
2526 ** it must pass the result table pointer to sqlite3_free_table() in order to
2529 ** function must not try to call [sqlite3_free()] directly. Only
2739 ** must be either NULL or else pointers obtained from a prior
2743 ** The application must not read or write any part of
2868 ** The authorizer callback must not do anything that will modify
2893 ** The [sqlite3_set_authorizer | authorizer callback function] must
3019 ** The progress handler callback must not do anything that will modify
3068 ** case the database must already exist, otherwise an error is returned.</dd>)^
3124 ** authority, then it must be either an empty string or the string
3243 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3245 ** characters must be converted to UTF-8 prior to passing them into
3248 ** <b>Note to Windows Runtime users:</b> The temporary directory must be set
3338 ** and must not be freed by the application)^.
3369 ** is the compiled object code. All SQL must be converted into a
3503 ** To execute an SQL query, it must first be compiled into a byte-code
3508 ** [sqlite3_open16()]. The database connection must not have been closed.
3759 ** ^The NNN value must be between 1 and the [sqlite3_limit()]
3777 ** that parameter must be the byte offset
3795 ** ^The sixth argument to sqlite3_bind_text64() must be one of
3904 ** name must be given in UTF-8 even if the original statement
4058 ** must be called one or more times to evaluate the statement.
4119 ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
4297 ** sqlite3_column_text16() is called. The content must be converted
4300 ** sqlite3_column_text() is called. The content must be converted
4371 ** The application must finalize every [prepared statement] in order to avoid
4423 ** connection then application-defined SQL functions must be added
4468 ** callback only; NULL pointers must be passed as the xStep and xFinal
4470 ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
4500 ** SQLite interfaces. However, such calls must not
4622 ** These routines must be called from the same thread as
4706 ** The first parameter must be a copy of the
4711 ** This routine must be called from the same thread in which
4726 ** This routine must be called from the same thread in which
4791 ** These routines must be called from the same thread in which
4887 ** specified by the fifth (and last) parameter, which must be one
4898 ** must be the byte offset into the string where the NUL terminator would
4981 ** ^(The third argument (eTextRep) must be one of the constants:
5009 ** by the eTextRep argument. The collating function must return an
5012 ** respectively. A collating function must always return the same answer
5015 ** must give an equivalent answer when invoked with equivalent strings.
5016 ** The collating function must obey the following properties for all
5220 ** the application wants that memory to be freed, it must do
5224 ** <b>Note to Windows Runtime users:</b> The temporary directory must be set
5353 ** [sqlite3_next_stmt(D,S)] must refer to an open database
5354 ** connection and in particular must not be a NULL pointer.
5380 ** The callback implementation must not do anything that will modify
5382 ** to modify the database connection must be deferred until after the
5442 ** The update hook implementation must not do anything that will modify
5444 ** to modify the database connection must be deferred until after the
5701 ** ^Extension loading must be enabled using
5818 ** of this structure must not change while it is registered with
5899 ** The [xBestIndex] method must fill aConstraintUsage[] with information
5934 ** SQLITE_CONSTRAINT, the database contents must be exactly as they were
6010 ** ^Module names must be registered before
6109 ** must exist in order to be overloaded.)^
6239 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
6240 ** it must exist and there must be either a blob or text value stored in
6424 ** application must supply a custom mutex implementation using the
6432 ** mutex. The argument to sqlite3_mutex_alloc() must one of these
6489 ** mutex must be exited an equal number of times before another thread
6566 ** The xMutexInit() method must be threadsafe. It must be harmless to
6569 ** xMutexInit() must be no-ops.
6571 ** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
6572 ** and its associates). Similarly, xMutexAlloc() must not use SQLite memory
6635 ** next. Applications that override the built-in mutex logic must be
7156 ** not need to be threadsafe either. All other methods must be threadsafe
7166 ** first parameter, szPage, is the size in bytes of the pages that must
7194 ** The xPagecount() method must return the number of pages currently
7211 ** implementation must return a pointer to the page buffer with its content
7234 ** then the page must be evicted from the cache.
7240 ** The cache must not perform any reference counting. A single
7247 ** previously contains an entry associated with newKey, it must be
7251 ** When SQLite calls the xTruncate() method, the cache must discard all
7362 ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
7418 ** errors are considered fatal.)^ The application must accept
7484 ** However, the application must guarantee that the destination
7493 ** If running in [shared cache mode], the application must
7496 ** that the application must guarantee that the disk file being
7704 ** The zFormat string must not be NULL.
7814 ** ^(The M parameter must be a valid [checkpoint mode]:)^
7967 ** must do so within the [xUpdate] method. If a call to the
8076 ** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior
8197 ** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()]
8219 ** ^In order to succeed, a call to [sqlite3_snapshot_open(D,S,P)] must be
8243 ** The application must eventually free every [sqlite3_snapshot] object
8693 ** following structure. All structure methods must be defined, setting
8750 ** For each token in the input string, the supplied callback xToken() must
9094 ** The maximum number of attached databases. This must be between 0
9268 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
9304 ** Exactly one of the following macros must be defined in order to
9382 ** testcase() must be evaluated both true and false in order to
9781 /* The token codes above must all fit in 8 bits */
10246 ** All variables must either be on the stack or dynamically allocated from
10248 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
10370 ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
10400 ** NOTE: These values must match the corresponding PAGER_ values in
10448 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
11169 ** Every VDBE branch operation must be tagged with one of the macros above.
11258 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
12019 ** A thread must be holding a mutex on the corresponding Btree in order
12020 ** to access Schema content. This implies that the thread must also be
12412 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
12413 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
12923 ** must be unique and what to do if they are not. When Index.onError=OE_None,
13351 ** such a table must be a simple name: ID. But in SQLite, the table can
13474 ** Note: NC_MinMaxAgg must have the same value as SF_MinMaxAgg and
13497 ** These addresses must be stored so that we can go back and fill in
13569 ** follow must honor the ORDER BY clause.
13579 ** SRT_Set The result must be a single column. Store each
13802 ** using offsetof(Parse,nVar) so the nVar field must be the first field
15048 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
15346 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
16091 ** the following flags must be set to determine the memory management
16436 ** Return the current value of a status parameter. The caller must
16449 ** Add N to the value of a status record. The caller must hold the
16457 ** mark is unchanged. N must be non-negative for StatusDown().
16482 ** The caller must hold the appropriate mutex.
16903 ** The HH, MM, and SS must each be exactly 2 digits. The
18018 ** The core must call OsFileControl() though, not OsFileControlHint(),
18408 ** are merely placeholders. Real drivers must be substituted using
19593 ** this mem3.iMaster replacement to work, the master chunk must be
19595 ** affairs, of course. The calling routine must link the master
19596 ** chunk before invoking this routine, then must unlink the (possibly
20038 ** The size of this object must be a power of two. That fact is
20200 /* nByte must be a positive */
20391 ** All allocations must be a power of two and must be expressed by a
20421 ** This routine is not threadsafe. The caller must be holding a mutex
20436 /* The size of a Mem5Link object must be a power of two. Verify that
20884 ** mutex must be exited an equal number of times before another thread
21183 ** mutex must be exited an equal number of times before another thread
21904 ** mutex must be exited an equal number of times before another thread
22828 ** This function must be called before exiting any API function (i.e.
22840 /* If the db handle must hold the connection handle mutex here.
23884 ** sqlite3_log() must render into a static buffer. It cannot dynamically
23890 ** Care must be taken that any sqlite3_log() calls that occur while the
25290 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
25314 ** in pZ. nChar must be non-negative.
25625 ** The input string must be zero-terminated. A new zero-terminator
25913 ** Note that zNum must contain exactly 19 characters.
25941 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
26585 ** binary value has been obtained from malloc and must be freed by
28341 ** On VxWorks, a unique file id must be based on the canonical filename.
28726 ** The mutex entered using the unixEnterMutex() function must be held
28758 ** The mutex entered using the unixEnterMutex() function must be held
29246 ** must be either NO_LOCK or SHARED_LOCK.
29412 ** must be either NO_LOCK or SHARED_LOCK.
29665 ** must be either NO_LOCK or SHARED_LOCK.
29858 /* didn't get, must be busy */
29880 ** must be either NO_LOCK or SHARED_LOCK.
30043 ** must be either NO_LOCK or SHARED_LOCK.
30221 /* if we failed to get the lock then someone else must have it */
30437 ** must be either NO_LOCK or SHARED_LOCK.
30582 ** must be either NO_LOCK or SHARED_LOCK.
30718 /* Unread parts of the buffer must be zero-filled */
31522 ** unixMutexHeld() must be true when creating or destroying
31532 ** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
31564 ** All other fields are read/write. The unixShm.pFile->mutex must be held
31660 ** a time, assuming that each mapping must be an integer multiple of the
31664 ** to use 64KB pages - in this case each mapping must cover at least two
31670 assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */
31733 ** the file must be truncated to zero length or have its header cleared.
31852 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
32135 ** All loads and stores begun before the barrier must complete before
32354 ** iOff. The mapping must be valid for at least nAmt bytes.
32361 ** If this function does return a pointer, the caller must eventually
32388 ** argument passed to this function must be the same as the corresponding
32400 /* If p==0 (unmap the entire file) then there must be no outstanding
32402 ** then there must be at least one outstanding. */
32405 /* If p!=0, it must match the iOff value. */
32938 ** Create a temporary file name in zBuf. zBuf must be allocated
32939 ** by the calling process and must be big enough to hold at least
33178 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
33179 ** (b) if CREATE is set, then READWRITE must also be set, and
33180 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
33181 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
33247 ** open(). These must be calculated even if open() is not called, as
33882 ** The conch file - to use a proxy file, sqlite must first "hold the conch"
33968 ** which must point to valid, writable memory large enough for a maxLen length
34146 /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
34322 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
34901 ** must be either NO_LOCK or SHARED_LOCK.
35355 must be defined."
37070 ** the provided arguments. The type argument must be 1 in order to set the
37243 ** must accept the error code DWORD as its only argument and should return
37253 ** defined, the "winIoerrCanRetry2" macro must exhibit external semantics
37407 ** must be zero-initialized */
37890 /* Unread parts of the buffer must be zero-filled */
38315 ** must go straight to locking level 0.
38488 ** must be either NO_LOCK or SHARED_LOCK.
38731 ** winShmMutexHeld() must be true when creating or destroying
38742 ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
38771 ** The winShmMutexHeld() must be true while reading or writing this list.
38785 ** All other fields are read/write. The winShm.pShmNode->mutex must be held
38906 ** the file must be truncated to zero length or have its header cleared.
38996 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
39166 ** All loads and stores begun before the barrier must complete before
39476 ** iOff. The mapping must be valid for at least nAmt bytes.
39483 ** If this function does return a pointer, the caller must eventually
39520 ** argument passed to this function must be the same as the corresponding
39531 /* If p==0 (unmap the entire file) then there must be no outstanding
39533 ** then there must be at least one outstanding. */
39536 /* If p!=0, it must match the iOff value. */
39603 ** obtained from malloc and must be freed by the calling function.
39623 ** is obtained from malloc and must be freed by the calling
39663 ** The pointer returned in pzBuf must be freed via sqlite3_free().
39738 ** it must be converted to a native Win32 path via the Cygwin API
39973 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
39974 ** (b) if CREATE is set, then READWRITE must also be set, and
39975 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
39976 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
40408 ** non-zero is returned from this function, the calling function must simply
40428 ** relative path or an absolute path. Callers of this function must not
41152 ** The calling function must ensure that p is a valid Bitvec object
41224 ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
41584 ** Change the page size for PCache object. The caller must ensure that there
41740 ** must be called after sqlite3PcacheFetch() in order to get a usable
41788 ** Drop a page from the cache. There must be exactly one reference to the
41870 ** caller must ensure that there are no outstanding references to any pages
41885 ** it must be that pgno==0.
42246 ** The PGroup mutex must be held when accessing nMax.
42506 /* The group mutex must be released before pcache1Alloc() is called. This
42612 ** The PCache mutex must be held when this function is called.
42653 ** The PGroup mutex must be held when this function is called.
42681 ** The PGroup mutex must be held when this function is called.
42724 ** The PCache mutex must be held when this function is called.
43466 ** It must be the case that N is sufficient to make a Rowset. If not
44267 ** layer must either commit or rollback the transaction.
44839 /* State must be valid. */
44856 /* If the useJournal flag is clear, the journal-mode must be "OFF".
44857 ** And if the journal-mode is "OFF", the journal file must not be open.
44879 /* If changeCountDone is set, a RESERVED lock or greater must be held
44952 /* There must be at least one outstanding reference to the pager if
45081 ** Unlock the database file to level eLock, which must be either NO_LOCK
45107 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
45215 ** When this is called the journal file for pager pPager must be open.
45221 ** zMaster must point to a buffer of at least nMaster bytes allocated by
45306 ** The journal file must be open when this function is called.
45362 ** The journal file must be open when this routine is called. A journal
45383 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
45478 ** The journal file must be open when this is called. A journal header file
45505 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
45572 ** invalid, then the process that wrote the journal-header must have
45602 ** pPager at the current location. The master journal name must be the last
46076 ** Parameter aData must point to a buffer of pPager->pageSize bytes
46191 assert( aData ); /* Temp storage must have already been allocated */
46249 /* If the pager is in CACHEMOD state, then there must be a copy of this
46270 ** statement we must not write to the original database unless we know
46274 ** restore the database to its original form. Two conditions must be
46275 ** met before writing to the database files. (1) the database must be
46356 ** journal file, then its content must be as they were when the
46739 ** it is corrupted, then a process must have failed while writing it.
46887 ** pPg->pData. A shared lock or greater must be held on the database
47014 ** the backups must be restarted.
47125 int changed = 0; /* True if cache must be reset */
47211 ** The caller must hold a SHARED lock on the database file to call this
47870 ** Once this function has been called, the transaction must either be
47965 ** Release a reference to page pPg. pPg must have been returned by an
48227 ** The pager must hold at least a RESERVED lock when this function
49125 ** the file. If the unlock attempt fails, then Pager.eLock must be
49508 ** There must already be a RESERVED or EXCLUSIVE lock on the database
49896 ** journal file must contain sync()ed copies of all of them
49916 ** Mark a data page as writeable. This routine must be called before
49917 ** making changes to a page. The caller must check the return value
49924 ** must have been written to the journal file before returning.
50151 ** is not synced. The caller must call sqlite3PagerSync() directly to
50497 ** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or
50767 ** There must be no references to the page previously located at
50776 ** A transaction must be active when this routine is called. It used to be
50801 /* In order to be able to rollback, an in-memory database must journal
50946 ** Get/set the locking-mode for this pager. Parameter eMode must be one
50969 ** Set the journal-mode for this pager. Parameter eMode must be one of:
51225 ** The caller must be holding a SHARED lock on the database file to call
51347 ** A read-lock must be held on the pager when this function is called. If
51455 ** before the xSync must complete before any write that launches after the
51495 ** on a network filesystem. All users of the database must be able to
51700 ** WalIndexHdr.mxFrame must never be less than nBackfillAttempted.
51958 ** The argument to this macro must be of type u32. On a little-endian
51976 ** nByte must be a positive multiple of 8.
52158 ** A lock cannot be moved directly between shared and exclusive - it must go
52198 ** Compute a hash on a page number. The resulting hash value must land
52387 ** must have exited unexpectedly in the middle of a transaction (after
52628 ** Open a connection to the WAL file zWalName. The database file must
52630 ** to must remain valid for the lifetime of the returned Wal* handle.
52735 u32 iMin; /* Result pgno must be greater than iMin */
52909 ** pages in the WAL in ascending order. The caller must hold the checkpoint
53016 ** The cache of the wal-index header must be valid to call this function.
53083 ** The caller must be holding sufficient locks to ensure that no other
53369 /* The first page of the wal-index must be mapped at this point. */
53507 ** The caller must set the cnt parameter to the number of prior calls to
53521 ** that means the Wal does not hold any read lock. The reader must not
53529 ** When the read transaction is completed, the caller must release the
53593 ** must be zeroed before the requested page is returned.
53987 ** A read transaction must have already been started by a prior call
54092 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
54107 ** the values in the aWalData[] array. aWalData must point to an array
54279 ** transaction restarted the wal file), these values must be read from the
54312 ** Write a set of frames to the log. The caller must hold the write-lock
54421 ** checksums must be recomputed when the transaction is committed. */
54673 ** into locking_mode=NORMAL. This means that we must acquire a lock
54677 ** operation must occur while the pager is still holding the exclusive
54681 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
54684 ** routine is a no-op. The pager must already hold the exclusive lock
54870 ** 21 1 Max embedded payload fraction (must be 64)
54871 ** 22 1 Min embedded payload fraction (must be 32)
54872 ** 23 1 Min leaf payload fraction (must be 32)
54962 ** increasing order. Because a freeblock must be at least 4 bytes in size,
55049 ** header must be exactly 16 bytes including the zero-terminator so
55074 ** walk up the BTree from any leaf to the root. Care must be taken to
55329 ** sqlite3BtreeCursorZero(). Fields that follow must be manually
55420 ** is moved, the pointer in its parent must be updated to point to the
55942 Btree *pBtree, /* Handle that must hold lock */
55980 /* Two or more indexes share the same root page. There must
56057 /* If requesting a write-lock, then the Btree must have an open write
56059 ** must be an open write transaction on the file itself.
56105 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
56215 ** than the writer must be about to drop to zero. In this case
56218 ** If there is not currently a writer, then BTS_PENDING must
56400 ** The cursor passed as the only argument must point to a valid entry
56447 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
56730 /* The master-journal page number must never be used as a pointer map page */
57394 /* The list of freeblocks must be in ascending order. Find the
57571 /* To many cells for a single page. The page must be corrupt */
57630 /* Free blocks must be in ascending order. And the last byte of
57631 ** the free-block must lie on the database page. */
57641 ** of the page, then the page must be corrupted. This check also
57769 ** And if the fetch fails, this routine must decrement pCur->iPage.
57811 /* If obtaining a child page for a cursor, we must verify that the page is
58428 ** The page size must be a power of 2 between 512 and 65536. If the page
58693 ** fractions and the leaf payload fraction values must be 64, 32, and 32.
58758 ** Besides the payload, the cell must store:
58899 ** A write-transaction must be started before attempting any
58920 ** One or the other of the two processes must give way or there can be
59392 ** A write-transaction must be opened before calling this function.
59774 ** back independently of the main transaction. You must start a transaction
59856 ** are also met. These are the conditions that must be met in order
59859 ** 1: The cursor must have been opened with wrFlag containing BTREE_WRCSR
59867 ** 3: The database must be writable (not on read-only media)
59869 ** 4: There must be an active transaction.
59936 ** cursors *must* have the BTCF_Multiple flag set. */
59971 ** to users so they cannot do the sizeof() themselves - they must call
60073 ** The caller must position the cursor prior to invoking this routine.
60089 ** The caller must guarantee that the cursor is pointing to a non-NULL
60090 ** valid entry. In other words, the calling procedure must guarantee
60286 /* Check if data must be read/written to/from the btree page itself. */
60363 ** Note that the aOverflow[] array must be allocated because eOp!=2
60450 ** The caller must ensure that pCur is pointing to a valid row
60506 ** onto overflow pages, then accessPayload() must be used to reassemble
60843 ** must be NULL. For index tables, pIdxKey is used and intKey
60930 /* pPage->nCell must be greater than zero. If this is the root-page
60933 ** would have already detected db corruption. Similarly, pPage must
61360 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
61826 ** file the database must be corrupt. */
61840 ** must not really be an overflow page and the database must be corrupt.
61947 ** that means content must spill into overflow pages.
62059 ** "sz" must be the number of bytes in the cell.
62327 ** area must be extended to before this point in order to accomodate all
62558 ** pParent is its parent. pPage must have a single overflow entry
62564 ** words, at most 13 bytes. Hence the pSpace buffer must be at
62618 ** a variable length key value (which must be the same value as the
62838 ** this overflow cell is present, it must be the cell with
63000 ** This must be done in advance. Once the balance starts, the cell
63175 ** must be true:
63970 /* If the bPreserve flag is set to true, then the cursor position must
64298 ** If pnChange is not NULL, then table iTable must be an intkey table. The
64876 ** False if IPK must be strictly less than maxKey */
65115 ** A read-only or read-write transaction must be opened before calling
65382 ** Argument pCsr must be a cursor opened for writing on an
65410 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
65686 pDestDb, SQLITE_ERROR, "source and destination must be distinct"
66249 ** must be active for both files.
66271 /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
66358 /* If p holds a string or blob, the Mem.z must point to exactly
66423 ** pMem->z into the new allocation. pMem must be either a string or
66432 /* If the bPreserve flag is set to true, then the memory cell must already
66663 ** If the memory cell contains a value that must be freed by
67257 ** The pMem object must have been initialized. This routine will use
67369 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
67373 ** If that is the case, then the result must be aligned on an even byte
67858 ** When this function is called, *ppRec must either point to an object
67859 ** allocated by an earlier call to this function, or must be NULL. If it
67959 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
68328 ** The zWhere string must have been obtained from sqlite3_malloc().
68398 ** be inserted. The parameter "x" must have been obtained from
70134 ** zName must be a pointer to a nul terminated string.
70136 ** This call must be made after a call to sqlite3VdbeSetNumCols().
70138 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
70308 /* The antipenultimate character of the master journal name must
70456 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
70604 ** transaction must be rolled back to restore the database to a
71833 /* The collation sequence must be defined at this point, even if
71846 /* Both values must be blobs. Compare using memcmp(). */
71896 ** greater than key2. The {nKey1, pKey1} key must be a blob
71898 ** key must be a parsed key such as obtained from
72318 ** than 2GiB are support - anything large must be database corruption.
72334 /* The index entry must begin with a header size */
72467 ** The returned value must be freed by the caller using sqlite3ValueFree().
73645 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
75748 ** Thus the program must guarantee that the original will not change
76064 ** Register P3 must not be one of the function inputs.
76081 ** in register P3. Register P3 must not be one of the function inputs.
76356 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
77508 ** return an error indicating that the other VMs must complete first.
77675 ** There must be a read-lock on the database (either a transaction
77676 ** must be started or there must be an open cursor) before
77706 ** A transaction must be started before executing this opcode.
77777 ** a P4_KEYINFO object. Furthermore, the P3 value must be the same as
78105 ** opcode must be followed by an IdxLE opcode with the same arguments.
78170 ** opcode must be followed by an IdxGE opcode with the same arguments.
78258 ** OP_SeekLE opcodes are allowed, and these must be immediately followed
78704 ** number P2. The key is stored in register P3. The key must
78832 ** P1 must not be pseudo-table. It has to be a real table with
78837 ** If P4 is not NULL then the P1 cursor must have been positioned
78979 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
78990 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
79251 ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have
79284 ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is
79373 ** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have
79684 ** If the P3 value is non-zero, then the table referred to must be an
79746 ** The difference between a table and an index is this: A table must
80014 ** must have P4==0, the final set P4=-1. P4 must be either -1 or
80114 ** is already allocated. Otherwise, it must be initialized. */
80295 ** Register P1 must contain an integer.
80344 ** Register P1 must contain an integer. If the content of register P1 is
80363 ** Register P1 must hold an integer. Decrement the value in register P1
80379 ** The register P1 must contain an integer. If register P1 is initially
80562 ** Change the journal mode of database P1 to P3. P3 must be one of the
81560 ** key columns must be indexed. The check below will pick up this
81896 ** The interfaces above must be called in a particular order. Write() can
85218 ** structures must be increased by the nSubquery amount.
85832 "second argument to likelihood() must be a "
86343 ** SELECT statement pItem->pSelect must be correlated. Set the
86380 /* If a HAVING clause is present, then there must be a GROUP BY clause.
86812 ** p->x.pSelect cannot. So if p->x.pLeft exists, it must hold at
87334 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
88069 ** expression must not refer to any non-deterministic function nor any
88333 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
88346 ** The inFlags parameter must contain exactly one of the bits
88354 ** through the set members) then the b-tree must not contain duplicates.
88355 ** An epheremal table must be used unless the selected <column> is guaranteed
88360 ** for fast set membership tests) then an epheremal table must
88389 int mustBeUnique; /* True if RHS must be unique */
88435 ** be used in place of a temp-table, it must be ordered according
88547 /* This code must be run in its entirety every time it is encountered
88871 ** "x IN (...)" expression must be either 0 or NULL. If the set
89179 ** There must be an open cursor to pTab in iTable when this routine
89297 ** must check the return code and move the results to the desired
90054 ** filled using OP_SCopy. OP_Copy must be used instead.
90526 ** must never return 0 if the two ExprList objects are different, or
91573 ** column must not be NULL.
91802 ** must be separated from the last integer by a single space. If the
92344 /* The "rows less-than" for the rowid column must be greater than that
93391 ** Arguments zSql1 and zSql2 must point to SQL statements that return
93780 "attached databases must use the same text encoding as main database");
94051 ** Initialize a DbFixer structure. This routine must be called prior
94057 int iDb, /* This is the database that must be used */
94077 ** must have been initialized by a prior call to sqlite3FixInit().
94749 return; /* A malloc must have failed */
94944 /* Justification of ALWAYS(); The index must be on the list of
95144 ** is obtained from sqliteMalloc() and must be freed by the calling
95337 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
95425 ** the SQLITE_MASTER table. Note in particular that we must go ahead
95428 ** indices to be created and the table record must come before the
95429 ** indices. Hence, the record number for the table must be allocated
95677 ** Default value expressions must be constant. Raise an exception if this
96000 ** from sqliteMalloc() and must be freed by the calling function.
96398 ** as a schema-lock must have already been obtained to create it. Since
96506 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
96747 ** We must continue looping until all tables and indices with
97217 ** the index already exists and must be cleared before being refilled and
97766 assert( p==pIndex ); /* Malloc must have failed */
97891 ** of the index. And so forth. It must always be the case that
98571 ** such that the abort must occur after the multiwrite. This makes
98970 ** If it is not NULL, then pColl must point to the database native encoding
99237 ** of arguments. If nArg is -2, then createFlag must be 0.
99282 ** So we must not search for built-ins when creating a new function.
99990 ** 2. Read/write cursors for all indices of pTab must be open as
99993 ** 3. The primary key for the row to be deleted must be stored in a
100002 ** then this function must seek iDataCur to the entry identified by iPk
100144 ** 1. A read/write cursor "iDataCur" must be open on the canonical storage
100149 ** 2. Read/write cursors for all indices of pTab must be open as
100153 ** 3. The "iDataCur" cursor must be already be positioned on the row
100194 ** iCur must be the cursor of the PRIMARY KEY index.
101112 /* The escape character string must consist of a single UTF-8 character.
101119 "ESCAPE expression must be a single character", -1);
101438 ** must be exact. Collating sequences are not used.
102181 ** modified (values must be compared at runtime).
104214 ** A temp table must be used if the table being updated is also one
104684 ** The caller must have already opened writeable cursors on the main
105358 /* If no test above fails then the indices must be compatible */
105420 return 0; /* tab1 must not have triggers */
105424 return 0; /* tab1 must not be a virtual table */
105433 return 0; /* FROM clause must have exactly one term */
105462 return 0; /* The result set must have exactly one column */
105466 return 0; /* The result set must be the special operator "*" */
105482 return 0; /* source and destination must both be WITHOUT ROWID or not */
105486 return 0; /* tab2 must not be a virtual table */
105493 return 0; /* Number of columns must be the same in tab1 and tab2 */
105496 return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
105509 return 0; /* Affinity must be the same on all columns */
105512 return 0; /* Collating sequence must be the same on all columns */
105515 return 0; /* tab2 must be NOT NULL if tab1 is */
105525 return 0; /* Default values must be the same for all columns */
105589 ** Conditions under which the destination must be empty:
106861 ** must call sqlite3_enable_load_extension() to turn on extension
107027 ** mutex must be held while accessing this list.
107799 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
107906 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
108213 ** of the PRAGMA command. In this case the locking-mode must be
109879 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
111659 ** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT,
112010 /* The vdbe must make its own copy of the column-type and other
112397 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
112527 ** the Distinct table must be exactly one greater than Queue in order
113056 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
113178 /* If none of the above, then the result destination must be
113788 ** Also, each component of the sub-query must return the same number
113795 ** ORDER by clause of the parent must be simple references to
113801 ** (20) If the sub-query is a compound select, then it must not use
113803 ** somewhat by saying that the terms of the ORDER BY clause must
113830 ** All of the expression analysis must occur on both the outer query and
113948 /* Restriction 17: If the sub-query is a compound SELECT, then it must
113994 ** 17 and 18 above) it must be a UNION ALL and the parent query must
115009 ** SELECT statement. The SELECT statement must be expanded before
115155 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
115586 ** written the query must use a temp-table for at least one of the ORDER
116070 ** A special flag must be passed to sqlite3WhereBegin() to slightly
116991 ** one trigger that must be fired when an operation of type 'op' is
117407 ** always defined. The trigger must be in the same schema as the table
117408 ** or else it must be a TEMP trigger. */
117438 ** accessed by triggers. The caller must always assume that it is.
117440 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
117443 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
117823 /* Virtual tables must be handled separately */
117985 ** values for registers not modified by the UPDATE must be reloaded from
118387 ** database content must be written into the rollback journal prior to
118899 ** associated with the database handle itself must be held.
119113 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
119215 /* Justification of ALWAYS(): A correct vtab constructor must allocate
119347 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
120013 Bitmask prereq; /* Bitmask of other loops that must run first */
120158 u8 nChild; /* Number of children that must disable us */
120344 Bitmask notReady, /* RHS must not overlap with this mask */
120631 ** If argument addrExplain is not 0, it must be the address of an
121083 /* An aggregate function in the WHERE clause of a query means this must
121088 ** expression, as the result of the expression must be stored in a
121335 ** encoding of the value in the register, so it *must* be reloaded. */
121492 ** the right-most column can be an inequality - the rest must
122066 /* Case 6: There is no usable index. We must do a complete
122369 ** In order for the operator to be optimizible, the RHS must be a string
122370 ** literal that does not begin with a wildcard. The LHS must be a column
122373 ** collating sequence for the column on the LHS must be appropriate for
122406 /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
122622 ** The term being analyzed must have two or more of OR-connected subterms.
122851 /* This term must be of the form t1.a==t2.b where t2 is in the
122886 ** of both right and left sides must be such that no type
122945 ** 1. The SQLITE_Transitive optimization must be enabled
122948 ** 4. The affinities of A and B must be compatible
123348 ** Note that the virtual term must be tagged with TERM_VNULL.
123815 ** iCur. The <op> must be one of the operators described by opMask.
123822 ** If X is not the INTEGER PRIMARY KEY then X must be compatible with
123889 Bitmask notReady, /* RHS must not overlap with this mask */
124006 ** comparison and select-list expressions must match those of the index.
124238 ** original table never needs to be accessed. Automatic indices must
124475 ** must represent a virtual table. This function invokes the xBestIndex()
124646 /* If (res==0) is true, then pRec must be equal to sample i. */
124655 ** all samples in the aSample[] array, pRec must be smaller than the
124664 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
124666 ** If (i>0), then pRec must also be greater than sample (i-1). */
124959 /* Note: this call could be optimized away - since the same values must
126331 ** Argument mPrereq is a mask of tables that must be scanned before the
126340 Bitmask mPrereq, /* Mask of tables that must be used. */
126483 ** All the tables in mPrereq must be scanned before the current virtual
126486 ** Conversely, all tables in mUnusable must be scanned after the current
126492 Bitmask mPrereq, /* Tables that must be scanned before this one */
126493 Bitmask mUnusable /* Tables that must be scanned after this one */
126793 ** pOrderBy terms must be matched in strict left-to-right order.
126843 ** To be order-distinct, the columns must be UNIQUE and NOT NULL.
127604 ** If the WHERE clause is empty, the foreach loops must each scan their
127718 ** field (type Bitmask) it must be aligned on an 8-byte boundary on
129933 assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
130416 ** Perform a reduce action and the shift that must immediately
132393 ** sqlite3IsIdChar[X] must be 1.
132669 ** but z[i] is a character not allowed within keywords, so this must
132691 /* If it is not a BLOB literal, then it must be an ID, since no
132900 ** must end with ";END;".
132920 ** (5) TRIGGER We are in the middle of a trigger definition that must be
133335 ** This routine must be called to initialize the memory allocation,
133347 ** threads must block until the first thread finishes with the initialization.
133357 ** * Calls to this routine from Y must block until the outer-most
133384 ** must be complete. So isInit must not be set until the very end
133394 ** The mutex subsystem must take care of serializing its own
133404 ** mutex must not require support from the malloc subsystem.
134997 ** A global function must exist in order for name resolution to work
135260 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
135562 ** initializer must be kept in sync with the SQLITE_LIMIT_*
135584 # error SQLITE_MAX_LENGTH must be at least 100
135587 # error SQLITE_MAX_SQL_LENGTH must be at least 100
135590 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
135593 # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
135596 # error SQLITE_MAX_VDBE_OP must be at least 40
135599 # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
135602 # error SQLITE_MAX_ATTACHED must be between 0 and 125
135605 # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
135608 # error SQLITE_MAX_COLUMN must not exceed 32767
135611 # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
135614 # error SQLITE_MAX_WORKER_THREADS must be between 0 and 50
137698 ** itself grows too big and must be split. The format of interior
138355 ** time must share a common language-id (see the FTS4 langid= feature).
138406 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
138471 ** A "phrase" is a sequence of one or more tokens that must match in
138480 int bFirst; /* True if token must appear at position 0 */
138504 int iColumn; /* Index of column this phrase must match */
139608 ** the number of bytes of space that must be allocated to store copies
140488 ** Before calling this routine *pi must be initialized to the value of
140602 ** called, *pp1 and *pp2 must both point to position lists. A position-list is
140916 ** the difference between it and the previous value in the output must
141172 ** as a single-byte delta, whereas in the second it must be stored as a
141267 ** for the pending-terms. If this is a scan, then this call must be being
141745 /* The column value supplied by SQLite must be in range. */
141914 ** When called, *ppPoslist must point to the byte immediately following the
141997 /* There must be at least one argument passed to this function (otherwise
142152 /* At this point it must be known if the %_stat table exists or not.
143117 int iCol; /* The column the token must match */
144015 ** Expression pExpr must be of type FTSQUERY_PHRASE.
144167 ** must be of type FTSQUERY_PHRASE.
145371 ** the next byte must contain either whitespace, an open or close
145425 /* If control flows to this point, this must be a regular token, or
145929 ** Column names must be nul-terminated strings.
146417 ** "new_size" must be a power of 2. The hash table might fail
146885 int (*xCond)(const char*) /* Condition that must be true */
147189 ** part of a token. In other words, delimiters all must have
147203 ** Extract the next token from a tokenization cursor. The cursor must
147331 ** If the <pointer> argument is specified, it must be a blob value
147334 ** the string <key-name> must already exist in the has table. Otherwise,
147510 ** function must be called with two or more arguments:
147731 ** the hash table pointed to by argument pHash. The hash table must
147946 ** Extract the next token from a tokenization cursor. The cursor must
148053 ** When queried, the query must include a WHERE clause of type:
148601 int iCol; /* Column token must occur in */
148768 ** If argument apVal is not NULL, then it must point to an array with
149315 ** Tokens must have a non-zero length.
149677 ** must call sqlite3Fts3SegmentsClose() before returning.
149688 /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */
150217 ** below, the "Fts3HashElem *pE" must be declared so that it is valid
150689 int isCopyTerm, /* True if buffer zTerm must be copied */
150747 ** the interior tree must:
150755 ** In other words, it must be the prefix of zTerm 1 byte longer than
150824 ** database. This function must be called after all terms have been added
151401 ** of Fts3SegReader objects is the same. The doclists must be merged
152353 ** header must be written before this function is called.
152360 ** node, both aDoclist and nDoclist must be passed 0.
152387 /* Node must have already been started. There must be a doclist for a
152388 ** leaf node, and there must not be a doclist for an internal node. */
152455 ** parent must:
152463 ** In other words, it must be the prefix of zTerm 1 byte longer than
152539 ** start_block and end_block fields of the %_segdir table must be populated.
153927 int iCol /* Column that token must appear in (or -1) */
154015 /* At this point it must be known if the %_stat table exists or not.
154059 ** if the on-conflict mode is other than REPLACE, then this method must
156184 ** Extract the next token from a tokenization cursor. The cursor must
156678 ** table must be the same size as the root node. The content of each node
156845 ** Therefore all non-root nodes must contain at least 3 entries. Since
157199 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
158221 /* A MATCH operator. The right-hand-side must be a blob that
159471 ** case, SQLITE_CONSTRAINT must be returned regardless of the
160362 /* The escape character string must consist of a single UTF-8 character.
160372 "ESCAPE expression must be a single character", -1);
161080 ** containing the entry being inserted or deleted must be modified. If the
161115 ** * The transaction must consist of INSERT, UPDATE and DELETE operations
161120 ** * UPDATE and DELETE statements must identify their target rows by
161123 ** has no PRIMARY KEY, affected rows must be identified by rowid.
161169 ** PRIMARY KEY declaration, the data_% table must also contain a column
161183 ** target table must be present in the input table. For virtual tables,
161218 ** "rbu_control" column must contain the same number of characters as
161219 ** there are columns in the target database table, and must consist entirely
161252 ** the existing value within the target database table must be of type BLOB.
161338 ** the path to the RBU database. Each call to this function must be matched
161349 ** Or, if zState is non-NULL, it must be a path to a database file in which
161352 ** When resuming an RBU update, the zState argument must be passed the same
161378 ** The first argument passed to this function must be a valid, open, RBU
161394 ** it must use sqlite3_create_function() or similar to register the
161483 ** exists, must contain the same columns as the following:
161487 ** There must be one row in the table for each source (data_xxx) table within
161512 ** the custom VFS must be explicitly created by the user before the RBU
161656 ** These values must match the values defined in wal.c for the equivalent
162078 ** arguments must be passed to this function. The first is the blob to
162484 ** The first argument must be a nul-terminated string. This function
164087 ** Argument eType must be one of RBU_INSERT, RBU_DELETE, RBU_IDX_INSERT or
167809 sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
168110 sqlite3_vtab_cursor base; /* Base class - must be first */
168982 ** following structure. All structure methods must be defined, setting
169039 ** For each token in the input string, the supplied callback xToken() must
169303 ** Maximum number of prefix indexes on single FTS5 table. This must be
169670 ** For an insert, it must be called once for each token in the new document.
169671 ** If the operation is a delete, it must be called (at least) once for each
169702 ** records must be invalidated.
170650 assert( fts5yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
170831 ** Perform a reduce action and the shift that must immediately
172055 ** pBuf, which must be already be large enough to hold the new data.
173292 ** A phrase. One or more terms that must appear in a contiguous sequence
173303 ** One or more phrases that must appear within a certain token distance of
173491 ** Argument pTerm must be a synonym iterator. Return the current rowid
173516 ** Argument pTerm must be a synonym iterator.
174513 ** then the first document visited must have a rowid smaller than or
179900 ** id must be between 1 and 65335 inclusive, and must not be used by
180707 /* If nBest is still 0, then the index must be empty. */
180906 ** that each varint must be stored contiguously. */
181496 ** records must be invalidated.
181628 ** For an insert, it must be called once for each token in the new document.
181629 ** If the operation is a delete, it must be called (at least) once for each
181680 /* If the QUERY_SCAN flag is set, all other flags must be clear. */
181692 ** If the QUERY_TEST_NOIDX flag was specified, then this must be a
181816 ** Parameter anSize must point to an array of size nCol, where nCol is
182278 /* Page iter.iLeaf must now be the rightmost leaf-page in the segment */
182801 "first arg to fts5_rowid() must be 'segment'" , -1
183991 ** Note: The following set of if(...) statements must be in the same
184310 /* A transaction must be open when this is called. */
184340 ** any conflict on the rowid value must be detected before any
186571 ** must match that passed to the sqlite3Fts5StorageStmt() call.