Lines Matching refs:must
51 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
52 ** system #includes. Hence, this block of code must be the very first
202 ** The maximum number of attached databases. This must be between 0
357 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
376 ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
386 ** Exactly one of the following macros must be defined in order to
462 ** testcase() must be evaluated both true and false in order to
826 ** Applications must [sqlite3_finalize | finalize] all [prepared statements]
836 ** The C parameter to [sqlite3_close(C)] must be either a NULL
905 ** <li> The application must insure that the 1st parameter to sqlite3_exec()
907 ** <li> The application must not close [database connection] specified by
909 ** <li> The application must not modify the SQL statement text passed into
1223 ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
1321 ** to read the database file, as the WAL and shared memory files must exist
1384 ** The zName field holds the name of the VFS module. The name must
1400 ** must invent its own temporary name for the file. ^Whenever the
1459 ** the xOpen method must set the sqlite3_file.pMethods to either
1460 ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
1504 ** next. Applications that use these interfaces must be prepared for any
1506 ** from one release to the next. Applications must not attempt to access
1589 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1635 ** is not. The sqlite3_shutdown() interface must only be called from a
1636 ** single thread. All open [database connections] must be closed and all
1637 ** other SQLite resources must be deallocated prior to invoking
1656 ** are omitted and the application must call sqlite3_initialize() directly
1681 ** option) the application must supply a suitable implementation for
1684 ** must return [SQLITE_OK] on success and some other [error code] upon
1702 ** must insure that no other SQLite interfaces are invoked by other
1766 ** The xMalloc, xRealloc, and xFree methods must work like the
1798 ** methods must be threadsafe or else make their own arrangements for
1910 ** argument must be a multiple of 16.
1911 ** The first argument must be a pointer to an 8-byte aligned buffer
1937 ** The pointer in the first argument must
1953 ** The first pointer (the memory pointer) must be aligned to an 8-byte
2018 ** supplied by the application must not invoke any SQLite interface.
2020 ** function must be threadsafe. </dd>
2077 ** slots. The size of the buffer in the first argument must be greater than
2079 ** must be aligned to an 8-byte boundary. ^If the second argument to
2321 ** The input to [sqlite3_complete()] must be a zero-terminated
2324 ** The input to [sqlite3_complete16()] must be a zero-terminated
2391 ** A busy handler must not close the database connection
2474 ** it must pass the result table pointer to sqlite3_free_table() in order to
2477 ** function must not try to call [sqlite3_free()] directly. Only
2659 ** must be either NULL or else pointers obtained from a prior
2663 ** The application must not read or write any part of
2781 ** The authorizer callback must not do anything that will modify
2806 ** The [sqlite3_set_authorizer | authorizer callback function] must
2925 ** The progress handler callback must not do anything that will modify
2973 ** case the database must already exist, otherwise an error is returned.</dd>)^
3029 ** authority, then it must be either an empty string or the string
3122 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3124 ** characters must be converted to UTF-8 prior to passing them into
3335 ** To execute an SQL query, it must first be compiled into a byte-code
3340 ** [sqlite3_open16()]. The database connection must not have been closed.
3566 ** ^The NNN value must be between 1 and the [sqlite3_limit()]
3679 ** name must be given in UTF-8 even if the original statement
3827 ** must be called one or more times to evaluate the statement.
3888 ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
4065 ** sqlite3_column_text16() is called. The content must be converted
4068 ** sqlite3_column_text() is called. The content must be converted
4138 ** The application must finalize every [prepared statement] in order to avoid
4188 ** connection then application-defined SQL functions must be added
4208 ** its parameters. Every SQL function implementation must be able to work
4224 ** callback only; NULL pointers must be passed as the xStep and xFinal
4226 ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
4256 ** SQLite interfaces. However, such calls must not
4366 ** These routines must be called from the same thread as
4413 ** The first parameter must be a copy of the
4418 ** This routine must be called from the same thread in which
4432 ** This routine must be called from the same thread in which
4487 ** These routines must be called from the same thread in which
4646 ** ^(The third argument (eTextRep) must be one of the constants:
4674 ** by the eTextRep argument. The collating function must return an
4677 ** respectively. A collating function must always return the same answer
4680 ** must give an equivalent answer when invoked with equivalent strings.
4681 ** The collating function must obey the following properties for all
4913 ** [sqlite3_next_stmt(D,S)] must refer to an open database
4914 ** connection and in particular must not be a NULL pointer.
4938 ** The callback implementation must not do anything that will modify
4940 ** to modify the database connection must be deferred until after the
4996 ** The update hook implementation must not do anything that will modify
4998 ** to modify the database connection must be deferred until after the
5216 ** ^Extension loading must be enabled using
5319 ** of this structure must not change while it is registered with
5389 ** The [xBestIndex] method must fill aConstraintUsage[] with information
5455 ** ^Module names must be registered before
5553 ** must exist in order to be overloaded.)^
5665 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
5666 ** it must exist and there must be either a blob or text value stored in
5846 ** application must supply a custom mutex implementation using the
5896 ** dynamic mutex that it allocates. The dynamic mutexes must not be in
5908 ** mutex must be exited an equal number of times before another thread
5987 ** The xMutexInit() method must be threadsafe. ^It must be harmless to
5990 ** xMutexInit() must be no-ops.
5992 ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
5993 ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
6056 ** next. Applications that override the built-in mutex logic must be
6499 ** not need to be threadsafe either. All other methods must be threadsafe
6509 ** first parameter, szPage, is the size in bytes of the pages that must
6539 ** The xPagecount() method must return the number of pages currently
6551 ** implementation must return a pointer to the page buffer with its content
6574 ** then the page must be evicted from the cache.
6580 ** The cache must not perform any reference counting. A single
6587 ** previously contains an entry associated with newKey, it must be
6591 ** When SQLite calls the xTruncate() method, the cache must discard all
6672 ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
6724 ** errors are considered fatal.)^ The application must accept
6790 ** However, the application must guarantee that the destination
6799 ** If running in [shared cache mode], the application must
6802 ** that the application must guarantee that the disk file being
6968 ** The zFormat string must not be NULL.
7200 ** must do so within the [xUpdate] method. If a call to the
7824 ** All variables must either be on the stack or dynamically allocated from
7826 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
7945 ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
7975 ** NOTE: These values must match the corresponding PAGER_ values in
8020 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
8651 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
9328 ** A thread must be holding a mutex on the corresponding Btree in order
9329 ** to access Schema content. This implies that the thread must also be
9595 ** These must be the low-order bits of the flags field.
9903 ** that the datatype of the PRIMARY KEY must be INTEGER for this field to
10116 ** must be unique and what to do if they are not. When Index.onError=OE_None,
10475 ** such a table must be a simple name: ID. But in SQLite, the table can
10680 ** These addresses must be stored so that we can go back and fill in
11861 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
12093 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
12732 ** the following flags must be set to determine the memory management
13373 ** The HH, MM, and SS must each be exactly 2 digits. The
14773 ** are merely placeholders. Real drivers must be substituted using
15808 ** this mem3.iMaster replacement to work, the master chunk must be
15810 ** affairs, of course. The calling routine must link the master
15811 ** chunk before invoking this routine, then must unlink the (possibly
16252 ** The size of this object must be a power of two. That fact is
16435 /* nByte must be a positive */
16610 ** All allocations must be a power of two and must be expressed by a
16640 ** This routine is not threadsafe. The caller must be holding a mutex
16655 /* The size of a Mem5Link object must be a power of two. Verify that
17076 ** mutex must be exited an equal number of times before another thread
17351 ** mutex must be exited an equal number of times before another thread
17614 ** mutex must be exited an equal number of times before another thread
17999 ** mutex must be exited an equal number of times before another thread
18850 ** This function must be called before exiting any API function (i.e.
18863 /* If the db handle is not NULL, then we must hold the connection handle
19847 ** sqlite3_log() must render into a static buffer. It cannot dynamically
19939 ** must be held while executing this routine.
20488 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
20539 ** in pZ. nChar must be non-negative.
20788 ** The input string must be zero-terminated. A new zero-terminator
21030 ** Note that zNum must contain exactly 19 characters.
21621 ** binary value has been obtained from malloc and must be freed by
22589 /* Unread portions of the input buffer must be zero-filled */
22761 ** must go straight to locking level 0.
22937 ** must be either NO_LOCK or SHARED_LOCK.
23193 ** os2ShmMutexHeld() must be true when creating or destroying
23205 ** Either os2ShmNode.mutex must be held or os2ShmNode.nRef==0 and
23223 char shmBaseName[1]; /* Name of the memory object !!! must last !!! */
23237 ** All other fields are read/write. The os2Shm.pShmNode->mutex must be held
23254 ** The os2ShmMutexHeld() must be true while reading or writing this list.
23767 ** All loads and stores begun before the barrier must complete before
23818 ** Create a temporary file name in zBuf. zBuf must be big enough to
23941 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
23942 ** (b) if CREATE is set, then READWRITE must also be set, and
23943 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
23944 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
25292 ** On VxWorks, a unique file id must be based on the canonical filename.
25670 ** The mutex entered using the unixEnterMutex() function must be held
25702 ** The mutex entered using the unixEnterMutex() function must be held
26141 ** must be either NO_LOCK or SHARED_LOCK.
26325 ** must be either NO_LOCK or SHARED_LOCK.
26571 ** must be either NO_LOCK or SHARED_LOCK.
26769 /* didn't get, must be busy */
26791 ** must be either NO_LOCK or SHARED_LOCK.
26957 ** must be either NO_LOCK or SHARED_LOCK.
27135 /* if we failed to get the lock then someone else must have it */
27351 ** must be either NO_LOCK or SHARED_LOCK.
27497 ** must be either NO_LOCK or SHARED_LOCK.
27603 /* Unread parts of the buffer must be zero-filled */
28174 ** unixMutexHeld() must be true when creating or destroying
28184 ** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
28216 ** All other fields are read/write. The unixShm.pFile->mutex must be held
28366 ** the file must be truncated to zero length or have its header cleared.
28482 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
28738 ** All loads and stores begun before the barrier must complete before
29316 ** Create a temporary file name in zBuf. zBuf must be allocated
29317 ** by the calling process and must be big enough to hold at least
29553 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
29554 ** (b) if CREATE is set, then READWRITE must also be set, and
29555 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
29556 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
29602 ** open(). These must be calculated even if open() is not called, as
30150 ** The conch file - to use a proxy file, sqlite must first "hold the conch"
30235 ** which must point to valid, writable memory large enough for a maxLen length
30411 /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
30589 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
31163 ** must be either NO_LOCK or SHARED_LOCK.
32361 ** must be zero-initialized */
32700 /* Unread parts of the buffer must be zero-filled */
32969 ** must go straight to locking level 0.
33118 ** must be either NO_LOCK or SHARED_LOCK.
33286 ** winShmMutexHeld() must be true when creating or destroying
33297 ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
33326 ** The winShmMutexHeld() must be true while reading or writing this list.
33340 ** All other fields are read/write. The winShm.pShmNode->mutex must be held
33463 ** the file must be truncated to zero length or have its header cleared.
33555 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
33725 ** All loads and stores begun before the barrier must complete before
33913 ** is obtained from malloc and must be freed by the calling
33932 ** Create a temporary file name in zBuf. zBuf must be big enough to
34055 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
34056 ** (b) if CREATE is set, then READWRITE must also be set, and
34057 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
34058 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
34926 ** The calling function must ensure that p is a valid Bitvec object
34998 ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
35363 ** Change the page size for PCache object. The caller must ensure that there
35502 ** Drop a page from the cache. There must be exactly one reference to the
35585 ** caller must ensure that there are no outstanding references to any pages
35600 ** it must be that pgno==0.
35902 ** The PGroup mutex must be held when accessing nMax.
36262 /* The group mutex must be released before pcache1Alloc() is called. This
36388 ** The PCache mutex must be held when this function is called.
36432 ** The PGroup mutex must be held when this function is called.
36468 ** The PGroup mutex must be held when this function is called.
36503 ** The PCache mutex must be held when this function is called.
37107 ** It must be the case that N is sufficient to make a Rowset. If not
37807 ** layer must either commit or rollback the transaction.
38342 /* State must be valid. */
38359 /* If the useJournal flag is clear, the journal-mode must be "OFF".
38360 ** And if the journal-mode is "OFF", the journal file must not be open.
38382 /* If changeCountDone is set, a RESERVED lock or greater must be held
38455 /* There must be at least one outstanding reference to the pager if
38581 ** Unlock the database file to level eLock, which must be either NO_LOCK
38607 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
38715 ** When this is called the journal file for pager pPager must be open.
38721 ** zMaster must point to a buffer of at least nMaster bytes allocated by
38805 ** The journal file must be open when this function is called.
38860 ** The journal file must be open when this routine is called. A journal
38881 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
38976 ** The journal file must be open when this is called. A journal header file
39003 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
39070 ** invalid, then the process that wrote the journal-header must have
39100 ** pPager at the current location. The master journal name must be the last
39552 ** Parameter aData must point to a buffer of pPager->pageSize bytes
39653 assert( aData ); /* Temp storage must have already been allocated */
39711 /* If the pager is in CACHEMOD state, then there must be a copy of this
39732 ** statement we must not write to the original database unless we know
39736 ** restore the database to its original form. Two conditions must be
39737 ** met before writing to the database files. (1) the database must be
39818 ** journal file, then its content must be as they were when the
40180 ** it is corrupted, then a process must have failed while writing it.
40322 ** pPg->pData. A shared lock or greater must be held on the database
40449 ** the backups must be restarted.
40555 int changed = 0; /* True if cache must be reset */
40644 ** The caller must hold a SHARED lock on the database file to call this
41496 ** The pager must hold at least a RESERVED lock when this function
42350 ** the file. If the unlock attempt fails, then Pager.eLock must be
42647 ** There must already be a RESERVED or EXCLUSIVE lock on the database
42955 ** Mark a data page as writeable. This routine must be called before
42956 ** making changes to a page. The caller must check the return value
42963 ** must have been written to the journal file before returning.
43037 ** journal file must contain sync()ed copies of all of them
43251 ** is not synced. The caller must call sqlite3PagerSync() directly to
43359 ** being discarded by the truncation must be written to the journal
43829 ** There must be no references to the page previously located at
43838 ** A transaction must be active when this routine is called. It used to be
43863 /* In order to be able to rollback, an in-memory database must journal
43996 ** Get/set the locking-mode for this pager. Parameter eMode must be one
44019 ** Set the journal-mode for this pager. Parameter eMode must be one of:
44261 ** The caller must be holding a SHARED lock on the database file to call
44462 ** before the xSync must complete before any write that launches after the
44502 ** on a network filesystem. All users of the database must be able to
44937 ** The argument to this macro must be of type u32. On a little-endian
44955 ** nByte must be a positive multiple of 8.
45133 ** A lock cannot be moved directly between shared and exclusive - it must go
45173 ** Compute a hash on a page number. The resulting hash value must land
45362 ** must have exited unexpectedly in the middle of a transaction (after
45599 ** Open a connection to the WAL file zWalName. The database file must
45601 ** to must remain valid for the lifetime of the returned Wal* handle.
45695 u32 iMin; /* Result pgno must be greater than iMin */
45865 ** pages in the WAL in ascending order. The caller must hold the checkpoint
45972 ** The cache of the wal-index header must be valid to call this function.
46006 ** The caller must be holding sufficient locks to ensure that no other
46223 /* The first page of the wal-index must be mapped at this point. */
46361 ** The caller must set the cnt parameter to the number of prior calls to
46375 ** that means the Wal does not hold any read lock. The reader must not
46383 ** When the read transaction is completed, the caller must release the
46446 ** must be zeroed before the requested page is returned.
46743 ** A read transaction must have already been started by a prior call
46846 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
46861 ** the values in the aWalData[] array. aWalData must point to an array
46973 ** Write a set of frames to the log. The caller must hold the write-lock
47256 ** into locking_mode=NORMAL. This means that we must acquire a lock
47260 ** operation must occur while the pager is still holding the exclusive
47264 ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
47267 ** routine is a no-op. The pager must already hold the exclusive lock
47497 ** increasing order. Because a freeblock must be at least 4 bytes in size,
47582 ** header must be exactly 16 bytes including the zero-terminator so
47607 ** walk up the BTree from any leaf to the root. Care must be taken to
47915 ** is moved, the pointer in its parent must be updated to point to the
48381 Btree *pBtree, /* Handle that must hold lock */
48490 /* If requesting a write-lock, then the Btree must have an open write
48492 ** must be an open write transaction on the file itself.
48538 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
48649 ** than the writer must be about to drop to zero. In this case
48652 ** If there is not currently a writer, then BtShared.isPending must
48824 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
49034 /* The master-journal page number must never be used as a pointer map page */
49674 /* To many cells for a single page. The page must be corrupt */
49723 /* Free blocks must be in ascending order. And the last byte of
49724 ** the free-block must lie on the database page. */
49734 ** of the page, then the page must be corrupted. This check also
49951 ** These flags are passed through into sqlite3PagerOpen() and must
50405 ** The page size must be a power of 2 between 512 and 65536. If the page
50622 /* The maximum embedded fraction must be exactly 25%. And the minimum
50623 ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
50672 ** Besides the payload, the cell must store:
50770 ** A write-transaction must be started before attempting any
50791 ** One or the other of the two processes must give way or there can be
51242 ** A write-transaction must be opened before calling this function.
51520 ** All cursors using the same cache must be tripped
51524 ** save the state of the cursor. The cursor must be
51604 ** back independently of the main transaction. You must start a transaction
51684 ** are the conditions that must be met in order for writing to
51687 ** 1: The cursor must have been opened with wrFlag==1
51695 ** 3: The database must be writable (not on read-only media)
51697 ** 4: There must be an active transaction.
51774 ** to users so they cannot do the sizeof() themselves - they must call
51921 ** The caller must position the cursor prior to invoking this routine.
51941 ** The caller must guarantee that the cursor is pointing to a non-NULL
51942 ** valid entry. In other words, the calling procedure must guarantee
52123 /* Check if data must be read/written to/from the btree page itself. */
52230 ** The caller must ensure that pCur is pointing to a valid row
52286 ** onto overflow pages, then accessPayload() must be used to reassemble
52510 /* Assert that the root page is of the correct type. This must be the
52656 ** must be NULL. For index tables, pIdxKey is used and intKey
52728 /* pPage->nCell must be greater than zero. If this is the root-page
52731 ** would have already detected db corruption. Similarly, pPage must
53048 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
53459 ** file the database must be corrupt. */
53473 ** must not really be an overflow page and the database must be corrupt.
53662 ** "sz" must be the number of bytes in the cell.
53881 ** pParent is its parent. pPage must have a single overflow entry
53887 ** words, at most 13 bytes. Hence the pSpace buffer must be at
53939 ** a variable length key value (which must be the same value as the
54154 ** this overflow cell is present, it must be the cell with
54595 ** (it must be, as it was just reconstructed using assemblePage()). This
55403 ** If pnChange is not NULL, then table iTable must be an intkey table. The
56091 ** A read-only or read-write transaction must be opened before calling
56351 ** Argument pCsr must be a cursor opened for writing on an
56604 pDestDb, SQLITE_ERROR, "source and destination must be distinct"
57109 ** must be active for both files.
57121 /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
57419 ** If the memory cell contains a string value that must be freed by
57990 /* The collation sequence must be defined at this point, even if
58024 /* Both values must be blobs. Compare using memcmp(). */
58095 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
58099 ** If that is the case, then the result must be aligned on an even byte
58506 ** The zWhere string must have been obtained from sqlite3_malloc().
58564 ** be inserted. The parameter "x" must have been obtained from
60000 ** zName must be a pointer to a nul terminated string.
60002 ** This call must be made after a call to sqlite3VdbeSetNumCols().
60004 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
60313 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
60457 ** transaction must be rolled back to restore the database to a
60979 ** nBuf is the amount of space left in buf[]. nBuf must always be
61223 ** greater than key2. The {nKey1, pKey1} key must be a blob
61225 ** key must be a parsed key such as obtained from
61365 ** than 2GiB are support - anything large must be database corruption.
61381 /* The index entry must begin with a header size */
61512 ** The returned value must be freed by the caller using sqlite3ValueFree().
62441 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
63620 ** sqlite3VdbeMakeReady() must be called before this routine in order to
64595 ** Thus the program must guarantee that the original will not change
64873 ** Register P3 must not be one of the function inputs.
65235 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
65885 ** of the record (when all fields present), then we must be dealing
66327 ** that the other VMs must complete first.
66334 ** return an error indicating that the other VMs must complete first.
66389 ** write transaction must be started before any changes can be made to the
66457 ** There must be a read-lock on the database (either a transaction
66458 ** must be started or there must be an open cursor) before
66488 ** A transaction must be started before executing this opcode.
66952 /* If we reach this point, then the P3 value must be a floating
67494 ** number P2. The key is stored in register P3. The key must
67615 ** P1 must not be pseudo-table. It has to be a real table with
67620 ** If P4 is not NULL then the P1 cursor must have been positioned
67732 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67742 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67987 ** The P1 cursor must be for a real table, not a pseudo-table.
68004 ** The P1 cursor must be for a real table, not a pseudo-table.
68318 ** If the P3 value is non-zero, then the table referred to must be an
68354 ** The difference between a table and an index is this: A table must
68619 ** must have P4==0, the final set P4=-1. P4 must be either -1 or
68726 ** is already allocated. Otherwise, it must be initialized. */
68916 ** The register P1 must contain an integer. Add literal P3 to the
69062 ** Change the journal mode of database P1 to P3. P3 must be one of the
70030 ** key columns must be indexed. The check below will pick up this
70310 ** all PMAs currently stored on disk must be merged together. This comment
72806 ** SELECT statement pItem->pSelect must be correlated. Set the
72832 /* If a HAVING clause is present, then there must be a GROUP BY clause.
73592 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
74417 ** epheremal table must be used unless the selected <column> is guaranteed
74422 ** for fast set membership tests. In this case an epheremal table must
74454 int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
74495 ** be used in place of a temp-table, it must be ordered according
74603 /* This code must be run in its entirety every time it is encountered
74868 ** "x IN (...)" expression must be either 0 or NULL. If the set
75169 ** There must be an open cursor to pTab in iTable when this routine
75275 ** must check the return code and move the results to the desired
76491 ** must never return 0 if the two ExprList objects are different, or
77442 ** column must not be NULL.
78480 "attached databases must use the same text encoding as main database");
78743 ** Initialize a DbFixer structure. This routine must be called prior
78752 int iDb, /* This is the database that must be used */
78772 ** must have been initialized by a prior call to sqlite3FixInit().
79379 return; /* A malloc must have failed */
79519 /* Justification of ALWAYS(); The index must be on the list of
79707 ** is obtained from sqliteMalloc() and must be freed by the calling
79895 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
79989 ** the SQLITE_MASTER table. Note in particular that we must go ahead
79992 ** indices to be created and the table record must come before the
79993 ** indices. Hence, the record number for the table must be allocated
80222 ** Default value expressions must be constant. Raise an exception if this
80505 ** from sqliteMalloc() and must be freed by the calling function.
80685 ** as a schema-lock must have already been obtained to create it. Since
80772 assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
81003 ** We must continue looping until all tables and indices with
81456 ** the index already exists and must be cleared before being refilled and
81609 assert( pStart==0 || pEnd!=0 ); /* pEnd must be non-NULL if pStart is */
81839 ** must exist or else there must have been an OOM error. But if there
81935 assert( p==pIndex ); /* Malloc must have failed */
82058 ** of the index. And so forth. It must always be the case that
82747 ** such that the abort must occur after the multiwrite. This makes
83012 ** If it is not NULL, then pColl must point to the database native encoding
83303 ** So we must not search for built-ins when creating a new function.
83864 ** The VDBE must be in a particular state when this routine is called.
83868 ** to be deleted, must be opened as cursor number $iCur.
83870 ** 2. Read/write cursors for all indices of pTab must be open as
83873 ** 3. The record number of the row to be deleted must be stored in
83973 ** The VDBE must be in a particular state when this routine is called.
83977 ** to be deleted, must be opened as cursor number "iCur".
83979 ** 2. Read/write cursors for all indices of pTab must be open as
83982 ** 3. The "iCur" cursor must be pointing to the row that is to be
84758 /* The escape character string must consist of a single UTF-8 character.
84765 "ESCAPE expression must be a single character", -1);
85023 ** must be exact. Collating sequences are not used.
85735 ** modified (values must be compared at runtime).
87505 ** A temp table must be used if the table being updated is also one
88012 ** The calling routine must open a read/write cursor for pTab with
88013 ** cursor number "baseCur". All indices of pTab must also have open
88136 pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
88452 /* If no test above fails then the indices must be compatible */
88468 ** (3) There must be no triggers on tab1
88514 return 0; /* tab1 must not have triggers */
88518 return 0; /* tab1 must not be a virtual table */
88529 return 0; /* FROM clause must have exactly one term */
88558 return 0; /* The result set must have exactly one column */
88562 return 0; /* The result set must be the special operator "*" */
88579 return 0; /* tab2 must not be a virtual table */
88586 return 0; /* Number of columns must be the same in tab1 and tab2 */
88589 return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
88593 return 0; /* Affinity must be the same on all columns */
88596 return 0; /* Collating sequence must be the same on all columns */
88599 return 0; /* tab2 must be NOT NULL if tab1 is */
88674 pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
89714 ** must call sqlite3_enable_load_extension() to turn on extension
89836 ** mutex must be held while accessing this list.
90088 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
90224 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
90457 ** of the PRAGMA command. In this case the locking-mode must be
91756 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
93190 ** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT,
93494 /* The vdbe must make its own copy of the column-type and other
94377 /* If none of the above, then the result destination must be
95017 ** ORDER by clause of the parent must be simple references to
95023 ** (20) If the sub-query is a compound select, then it must not use
95025 ** somewhat by saying that the terms of the ORDER BY clause must
95039 ** All of the expression analysis must occur on both the outer query and
95140 /* Restriction 17: If the sub-query is a compound SELECT, then it must
95180 ** 17 and 18 above) it must be a UNION ALL and the parent query must
95768 ** SELECT statement. The SELECT statement must be expanded before
95894 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
96038 ** SRT_Set The result must be a single column. Store each
96272 ** written the query must use a temp-table for at least one of the ORDER
96747 ** A special flag must be passed to sqlite3WhereBegin() to slightly
97773 ** one trigger that must be fired when an operation of type 'op' is
98186 ** always defined. The trigger must be in the same schema as the table
98187 ** or else it must be a TEMP trigger. */
98217 ** accessed by triggers. The caller must always assume that it is.
98219 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
98222 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
98527 /* Virtual tables must be handled separately */
98678 ** values for registers not modified by the UPDATE must be reloaded from
99470 ** associated with the database handle itself must be held.
99682 assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
99765 /* Justification of ALWAYS(): A correct vtab constructor must allocate
99895 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
100450 u8 nChild; /* Number of children that must disable us */
100775 ** In order for this routine to work, the calling function must have
100838 ** IMPLEMENTATION-OF: R-59926-26393 To be usable by an index a term must be
100924 Bitmask notReady, /* RHS must not overlap with this mask */
100991 ** In order for the operator to be optimizible, the RHS must be a string
101020 /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
101135 ** The term being analyzed must have two or more of OR-connected subterms.
101337 /* This term must be of the form t1.a==t2.b where t2 is in the
101372 ** of both right and left sides must be such that no type
101694 ** Note that the virtual term must be tagged with TERM_VNULL. This
101890 ** comparison and select-list expressions must match those of the index.
101924 ** All terms of the ORDER BY that match against the index must be either
101953 /* Argument pIdx must either point to a 'real' named index structure,
102376 ** original table never needs to be accessed. Automatic indices must
102575 ** must represent a virtual table. This function invokes the xBestIndex()
102680 /* The module name must be defined. Also, by this point there must
103191 ** * Whether or not sorting must occur.
103193 ** * Whether or not there must be separate lookups in the
103297 ** SQLite must perform on the index in question. For example, if the
103302 ** SQLite must perform 9 lookups on an index on (a, b), so nInMul is
103318 ** IN operator must be a SELECT, not a value list, for this variable
103322 ** An estimate on the amount of the table that must be searched. A
104324 ** the right-most column can be an inequality - the rest must
104700 /* Case 5: There is no usable index. We must do a complete
104851 ** If the WHERE clause is empty, the foreach loops must each scan their
104939 ** field (type Bitmask) it must be aligned on an 8-byte boundary on
104985 ** When assigning bitmask values to FROM clause cursors, it must be
105156 /* If an INDEXED BY clause is present, then the plan must use that
105168 ** (1) The table must not depend on other tables that have not
105183 ** (4) The plan cost must be lower than prior plans or else the
105184 ** cost must be the same and the number of rows must be lower.
107567 ** Perform a reduce action and the shift that must immediately
109317 ** sqlite3IsIdChar[X] must be 1.
109827 ** must end with ";END;".
109847 ** (5) TRIGGER We are in the middle of a trigger definition that must be
110224 ** This routine must be called to initialize the memory allocation,
110236 ** threads must block until the first thread finishes with the initialization.
110246 ** * Calls to this routine from Y must block until the outer-most
110265 ** must be complete. So isInit must not be set until the very end
110275 ** The mutex subsystem must take care of serializing its own
110285 ** mutex must not require support from the malloc subsystem.
111352 ** A global function must exist in order for name resolution to work
111848 ** initializer must be kept in sync with the SQLITE_LIMIT_*
111869 # error SQLITE_MAX_LENGTH must be at least 100
111872 # error SQLITE_MAX_SQL_LENGTH must be at least 100
111875 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
111878 # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
111881 # error SQLITE_MAX_VDBE_OP must be at least 40
111884 # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 1000
111887 # error SQLITE_MAX_ATTACHED must be between 0 and 62
111890 # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
111893 # error SQLITE_MAX_COLUMN must not exceed 32767
111896 # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
113599 ** itself grows too big and must be split. The format of interior
114245 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
114301 ** A "phrase" is a sequence of one or more tokens that must match in
114328 int iColumn; /* Index of column this phrase must match */
115188 ** the number of bytes of space that must be allocated to store copies
115864 ** Before calling this routine *pi must be initialized to the value of
115978 ** called, *pp1 and *pp2 must both point to position lists. A position-list is
116298 ** the difference between it and the previous value in the output must
116571 ** for the pending-terms. If this is a scan, then this call must be being
116986 /* The column value supplied by SQLite must be in range. */
117078 ** When called, *ppPoslist must point to the byte immediately following the
117141 /* There must be at least one argument passed to this function (otherwise
117987 int iCol; /* The column the token must match */
118820 ** Expression pExpr must be of type FTSQUERY_PHRASE.
118973 ** must be of type FTSQUERY_PHRASE.
119944 ** the next byte must contain either whitespace, an open or close
120004 /* If control flows to this point, this must be a regular token, or
120258 ** Column names must be nul-terminated strings.
120694 ** "new_size" must be a power of 2. The hash table might fail
121160 int (*xCond)(const char*) /* Condition that must be true */
121448 ** part of a token. In other words, delimiters all must have
121462 ** Extract the next token from a tokenization cursor. The cursor must
121576 ** If the <pointer> argument is specified, it must be a blob value
121579 ** the string <key-name> must already exist in the has table. Otherwise,
121746 ** function must be called with two arguments:
121962 ** the hash table pointed to by argument pHash. The hash table must
122178 ** Extract the next token from a tokenization cursor. The cursor must
122348 int iCol; /* Column token must occur in */
122499 ** If argument apVal is not NULL, then it must point to an array with
122935 ** Tokens must have a non-zero length.
123231 ** must call sqlite3Fts3SegmentsClose() before returning.
123242 /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */
124195 int isCopyTerm, /* True if buffer zTerm must be copied */
124252 ** the interior tree must:
124260 ** In other words, it must be the prefix of zTerm 1 byte longer than
124326 ** database. This function must be called after all terms have been added
124818 ** of Fts3SegReader objects is the same. The doclists must be merged
125324 int iCol /* Column that token must appear in (or -1) */
125425 ** if the on-conflict mode is other than REPLACE, then this method must
127069 ** table must be the same size as the root node. The content of each node
127103 ** Exactly one of the following must be set to 1.
127230 ** Therefore all non-root nodes must contain at least 3 entries. Since
127313 ** An instance of this structure must be supplied as a blob argument to
127544 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
128118 /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
128306 /* A MATCH operator. The right-hand-side must be a blob that
129766 ** case, SQLITE_CONSTRAINT must be returned regardless of the
130488 /* The escape character string must consist of a single UTF-8 character.
130498 "ESCAPE expression must be a single character", -1);