Lines Matching refs:either
376 ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
612 ** interfaces as either deprecated or experimental. New applications
836 ** The C parameter to [sqlite3_close(C)] must be either a NULL
1171 ** either in this process or in some other process, is holding a RESERVED,
1309 ** integer is the delay. If either integer is negative, then the setting
1389 ** is either a NULL pointer or string obtained
1459 ** the xOpen method must set the sqlite3_file.pMethods to either
1620 ** SQLite normally do not need to invoke either of these routines.
1672 ** The application should never invoke either sqlite3_os_init()
1793 ** not need to be threadsafe either. For all other methods, SQLite
1950 ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
2170 ** unpredictable and might not equal either the old or the new
2659 ** must be either NULL or else pointers obtained from a prior
2708 ** ^The first time this routine is invoked (either internally or by
2807 ** return either [SQLITE_OK] or one of these two constants in order
2972 ** only if the file is write protected by the operating system. In either
3029 ** authority, then it must be either an empty string or the string
3044 ** either by SQLite itself, or by a [VFS | custom VFS implementation].
3056 ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw" or
3069 ** <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
3175 ** text that describes the error, as either UTF-8 or UTF-16 respectively.
3343 ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
3350 ** zSql string ends at either the first '\000' or '\u0000' character or
3445 ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
3489 ** An sqlite3_value object may be either "protected" or "unprotected".
3491 ** will accept either a protected or an unprotected sqlite3_value.
3719 ** ^The returned string pointer is valid until either the [prepared statement]
3725 ** ^If sqlite3_malloc() fails during the processing of either routine
3744 ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
3824 ** After a [prepared statement] has been prepared using either
3836 ** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
3893 ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
4104 ** is either the integer 0, the floating point number 0.0, or a NULL
4232 ** The destructor is invoked when the function is deleted, either by being
4241 ** functions with the same name but with either differing numbers of
4610 ** [unprotected sqlite3_value] object is required, so either
4748 ** ^A call to either function replaces the existing collation-needed callback.
4862 ** Hence, if this variable is modified directly, either it should be
5131 ** this function. ^The second parameter is either the name of the database
5666 ** it must exist and there must be either a blob or text value stored in
5923 ** never do either.)^
6205 ** using [sqlite3_malloc()], either directly or indirectly. The
6499 ** not need to be threadsafe either. All other methods must be threadsafe
6635 ** It is useful either for creating backups of databases or
6729 ** on the destination file. ^The exclusive lock is not released until either
6839 ** its current transaction, either by committing it or rolling it back.
6994 ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
7110 ** lock retried until either the busy-handler returns 0 or the lock is
7157 ** This function may be called by either the [xConnect] or [xCreate] method
7824 ** All variables must either be on the stack or dynamically allocated from
8020 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
8967 ** will defined to either 1 or 0. One of the four will be 1. The other
9644 ** the number of FuncDef objects created (either 1 or 3, depending on whether
9797 ** A sort order can be either ASC or DESC.
9834 #define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */
10212 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
10646 ** is checked. This process continues until either a match is found
10973 ** A trigger is either a BEFORE or an AFTER trigger. The following constants
15118 ** This routine checks the guards at either end of the allocation and
15552 ** A chunk is two or more blocks that is either checked out or
15626 ** The master chunk is not in either the aiHash[] or aiSmall[].
15697 ** Link the chunk at index i into either the appropriate
15800 ** or same size hash. In other words, *pRoot is an entry in either
15868 ** Look for an entry of the correct size in either the small
17096 ** is not currently allocated. SQLite will never do either.
17378 ** is not currently allocated. SQLite will never do either.
17629 ** address at the same time. If either of these two conditions
17672 ** address at the same time. If either of these two conditions
17715 ** is not currently allocated. SQLite will never do either.
18056 ** is not currently allocated. SQLite will never do either.
18324 ** checked out since either the beginning of this process
19392 ** If the field type is etGENERIC, then convert to either etEXP
20887 int eValid = 1; /* True exponent is either not used or is well-formed */
22937 ** must be either NO_LOCK or SHARED_LOCK.
23855 * Trailing spaces are not allowed, either. */
24566 ** opportunity to either close or reuse it.
26141 ** must be either NO_LOCK or SHARED_LOCK.
26325 ** must be either NO_LOCK or SHARED_LOCK.
26471 ** In dotfile locking, either a lock exists or it does not. So in this
26571 ** must be either NO_LOCK or SHARED_LOCK.
26791 ** must be either NO_LOCK or SHARED_LOCK.
26957 ** must be either NO_LOCK or SHARED_LOCK.
27351 ** must be either NO_LOCK or SHARED_LOCK.
27497 ** must be either NO_LOCK or SHARED_LOCK.
27844 ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
29898 ** other hand, dlsym() will not work on such a system either, so we have
30681 /* either the conch didn't match or we need to create a new one */
31163 ** must be either NO_LOCK or SHARED_LOCK.
33118 ** must be either NO_LOCK or SHARED_LOCK.
34783 ** property. Usually only a few pages are meet either condition.
35225 ** is not, either fail an assert or return zero. Otherwise, return
37602 ** (4) Reads from the database file are either aligned on a page boundary and
37807 ** layer must either commit or rollback the transaction.
38053 ** The flag is cleared as soon as the journal file is finalized (either
38124 ** a call to xFilesize() that is not strictly required). In either case,
38162 ** routine opertion. Class members not in this block are either fixed
38367 ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
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,
38698 ** that the page is either dirty or still matches the calculated page-hash.
38812 ** zero the 28-byte header at the start of the journal file. In either case,
39069 /* If the either the page-size or sector-size in the journal-header is
39370 ** either a COMMIT or a ROLLBACK operation. This routine may be called
39596 ** Read a single page from either the journal file (if isMainJrnl==1) or
39719 ** either. So the condition described in the above paragraph is not
39739 ** in the main journal either because the page is not in cache or else
39992 ** If the main database file is not open, or the pager is not in either
40173 /* This loop terminates either when a readJournalHdr() or
40708 ** rolled back the first time it is encountered in either journal.
40713 ** In either case, before playback commences the Pager.dbSize variable
40989 ** * the database is either not an in-memory database or it is
40999 ** If the page size is not changed, either because one of the enumerated
41172 /* Check that this is either a no-op (because the requested lock is
41204 ** content of the page. However, since this content is not present in either
41507 ** a page is skipped if it meets either of the following criteria:
42022 /* If an error occurred in either of the blocks above, free the
42243 ** outstanding pages. This implies that the pager state should either
42267 ** database file, then it either needs to be played back or deleted.
43213 ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
43451 ** This function finalizes the journal file, either by deleting,
43482 ** to drop any locks either.
43520 ** current transaction are either expelled from the cache or reverted to
43692 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
44001 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
44269 ** not modified in either case.
44507 ** to either truncate or zero the header of the wal-index when the last
44587 ** examined in order to either find the last entry for page P, or to
44591 ** comparisons (on average) suffice to either locate a frame in the
45132 ** Set or release locks on the WAL. Locks are either shared or exclusive.
45732 ** either aLeft[] or the old aRight[] and such that the second condition
45954 ** busy-handler function. Invoke it and retry the lock until either the
46543 ** copied into the database by a checkpointer. If either of these things
46551 ** log-wrap (either of which would require an exclusive lock on
46827 ** (b) has an outstanding reference, then xUndo is either a no-op
47393 ** Each page can be either a btree page, a freelist page, an overflow
47734 ** The shared-cache leaves the 'pending lock' state when either of
48538 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
49405 ** of the first byte of allocated space. Return either SQLITE_OK or
50849 /* Call lockBtree() until either pBt->pPage1 is populated or
51297 ** is either a pointer-map page or the pending-byte page. If one
51641 ** or SAVEPOINT_RELEASE. This function either releases or rolls back the
52511 ** case as the call to this function that loaded the root-page (either
53711 ** in pPage->aOvfl[] and make it point to the cell content (either
53852 ** in a balancing operation. NN is the number of neighbors on either side
53855 ** NN neighbors on either side.
53862 #define NN 1 /* Number of neighbors on either side of pPage */
53923 ** cell on the page to an overflow page. If either of these
54074 ** same amount of free space. Usually a single sibling on either side of the
54167 ** either side of pPage. More siblings are taken from one side, however,
54852 ** use either balance_nonroot() or balance_deeper(). Until this
54880 ** copied either into the body of a database page or into the new
54888 ** now stored either on real database pages or within the
55171 ** be either under or overfull. In this case run the balancing algorithm
55310 ** order either to increase the database filesize, or to decrement the
56509 ** be held when either of these functions are invoked.
57136 ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
57764 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
57831 ** either case, SQLITE_TOOBIG is returned.
60313 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
60488 ** VM, then we do either a commit or rollback of the current transaction.
61140 ** The space is either allocated using sqlite3DbMallocRaw() or from within
61429 ** pUnpacked is either created without a rowid or is truncated so that it
61877 ** Execute the statement pStmt, either until a row of data is ready, the
63039 ** either an integer, a null-terminated string, a floating point
63068 ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test
63324 ** into a numeric representation. Use either INTEGER or REAL whichever
63624 ** Whenever a row or result data is available, this routine will either
63629 ** will either invoke the busy callback (if there is one) or it will
64160 ** of VDBE ops have been executed (either since this invocation of
64181 ** an undefined integer. Opcodes will either fill in the integer
64688 ** If either the P1 or P2 text are NULL then store NULL in P3.
64737 ** If either input is NULL, the result is NULL.
64744 ** If either input is NULL, the result is NULL.
64750 ** If either input is NULL, the result is NULL.
64756 ** register P1 is zero, then the result is NULL. If either input is
64764 ** If either operand is NULL, the result is NULL.
64992 ** If either input is NULL, the result is NULL.
64998 ** If either input is NULL, the result is NULL.
65005 ** If either input is NULL, the result is NULL.
65012 ** If either input is NULL, the result is NULL.
65174 ** Force the value in register P1 to be numeric (either an
65231 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
65233 ** bit is clear then fall through if either operand is NULL.
65254 ** store a boolean result (either 0, or 1, or NULL) in register P2.
65262 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
65264 ** of comparison is false. If either operand is NULL then the result is true.
65274 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
65276 ** of comparison is true. If either operand is NULL then the result is false.
65477 ** If either P1 or P2 is 0 (false) then the result is 0 even if
65486 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
66457 ** There must be a read-lock on the database (either a transaction
66604 ** The P4 value may be either an integer (P4_INT32) or a pointer to
66618 ** The P4 value may be either an integer (P4_INT32) or a pointer to
66725 ** confusion because the term "temp table", might refer either
67607 ** The cursor will be left pointing at either the next or the previous
67815 ** P1 can be either an ordinary table or a virtual table. There used to
68619 ** must have P4==0, the final set P4=-1. P4 must be either -1 or
69344 ** P4 is either NULL or a string that was generated by the xBestIndex
70021 ** It is against the rules to open a column to which either of these
70091 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
70191 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
70316 ** An aIter[] iterator either points to a valid key or else is at EOF. For
70910 ** are written out when either of the following are true:
71183 ** on disk is not created or populated until either:
71451 ** The cursor can be either for reading or writing.
72122 /* Advance to the next name context. The loop will exit when either
72659 ** The Name context of the SELECT statement is pNC. zType is either
73267 int jumpIfNull /* If true, jump if either operand is NULL */
73515 ** Join two expressions using an AND operator. If either expression is
73786 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
74398 ** either to test for membership of the (...) set or to iterate through
74418 ** to be unique - either because it is an INTEGER PRIMARY KEY or it
74650 ** if either column has NUMERIC or INTEGER affinity. If neither
74843 /* If the LHS is NULL, then the result is either false or NULL depending
74868 ** "x IN (...)" expression must be either 0 or NULL. If the set
76614 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
76954 ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
77152 ** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
78625 ** This procedure generates VDBE code for a single invocation of either the
78945 ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
79072 ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
79764 ** The token *pName contains the name of a database (either "main" or
81838 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
83015 ** The return value is either the collation sequence to be used in database
83257 ** function found is returned. A function is valid if either xFunc
83459 ** In either case leave an error message in pParse and return non-zero.
85821 ** If the required index cannot be found, either because:
86283 ** Normally, no code is required. However, if either
86388 ** on the parent key columns in the parent table. If either of these
86563 ** table in question is either the child or parent table for any
86822 ** for this operation (either update or delete), invoke the associated
86864 ** classified as either immediate or deferred.
87155 ** table (either directly or through triggers) needs to call this
88151 ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
88631 /* If we get this far, it means either:
90066 ** Invalidate temp storage, either when the temp storage is changed
90587 /* When setting the auto_vacuum mode to either "full" or
94490 ** and AgtB jump to either L2 or to one of EofA or EofB.
95388 /* The flattened query is distinct if either the inner or the
95397 ** does not work if either limit is negative.
95423 ** either min(x) or max(x), where x is a column reference.
96685 ** OP_Count instruction is executed either on the intkey table that
98219 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
98296 ** column definition. This was either supplied by the user when the table
99473 ** the sqlite3.pDisconnect list. In this case either the BtShared mutex
99715 ** Invoke a virtual table constructor (either xCreate or xConnect). The
100025 ** This function invokes either the xRollback or xCommit method
100147 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
100203 ** Return either the pDef argument (indicating no change) or a
100417 ** If a term in the WHERE clause does not match either of the two previous
100862 ** If a collation sequence is associated with either the left or right
101297 ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means
101306 ** might be possible to form an IN operator with either table1.column
101307 ** or table2.column as the LHS if either is common to every term of
101338 ** chngToIN set but t1 is not. This term will be either preceeded
101887 ** 2. All of the columns in the index are either part of the pDistinct
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,
102020 ** equality constraints are all either DESC or ASC. */
102131 ** The table associated with FROM clause term pSrc may be either a
102674 ** to will have been initialized, either during the current invocation or
102935 ** If either of the upper or lower bound is not present, then NULL is passed in
103303 ** set to 9. Given the same schema and either of the following WHERE
103786 ** term can be either X=expr or X IN (...). pTerm is the term to be
104976 ** expression and either jump over all of the code or fall thru.
105077 ** either once or twice.
106421 ** by making either argument NULL
106903 ** symbol. The symbol can be either a terminal or nonterminal.
110308 /* If rc is not SQLITE_OK at this point, then either the malloc
110310 ** the pInitMutex mutex. Return an error in either case. */
112964 ** default setting. If the return value is 1, then ALWAYS() is either
113134 ** for which either sqlite3.pBlockingConnection or sqlite3.pUnlockConnection
113145 ** 1) Each entry in the list has a non-NULL value for either
113264 ** blocking transaction. In either case, invoke the notify callback
113644 ** This could be either a leaf node or an interior node. If the top
113836 ** This method should return either SQLITE_OK (0), or an SQLite error
113873 ** method should either return SQLITE_OK and set the values of the
113892 ** nul-terminated. This should either be fixed, or pInput/nBytes
115610 ** either more than 20 bytes of allocated space following the nNode bytes of
115816 ** The column-list is terminated either by a POS_COLUMN varint (1) or
115829 /* A column-list is terminated by either a 0x01 or 0x00 byte that is
116085 ** iCol1 and iCol2) so that it points to either the 0x00 that marks the
116215 ** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal)
116249 ** sorted in either ascending or descending order.
116255 ** positions contained in either argument doclist). If the docids in the
116297 ** consumes either the same or less bytes as it did in the input (since
118142 ** Load the doclists for tokens that are either:
118521 ** left-hand child may be either a phrase or a NEAR node. There are
118975 ** The returned value is either NULL or a pointer to a buffer containing
118981 ** compression and is terminated by either an 0x01 or 0x00 byte. For example,
119346 /* State 1. In this state we are expecting either a 1, indicating
119757 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
119944 ** the next byte must contain either whitespace, an open or close
120096 ** returns either when the end of the buffer is reached or an unmatched
120172 /* This test catches attempts to make either operand of a NEAR
120173 ** operator something other than a phrase. For example, either of
120179 ** Return an error in either case.
120248 ** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse
122439 ** When a b+tree is written to the database (either as a result of a merge
123431 ** b-tree node. And that the final byte of the doclist is 0x00. If either
125442 ** the statement is either an INSERT or an UPDATE that modifies the
125452 ** call to fts3InsertData() (either just below or further on in this
126231 ** the last varint in the column-list (either the 0x00 signifying the end
126242 /* A column-list is terminated by either a 0x01 or 0x00. */
130538 ** the second is a string to match against that pattern. If either