Lines Matching defs:before
51 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
194 ** The default number of frames to accumulate in the log file before
871 ** NULL before returning.
1654 ** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
1831 ** before the [sqlite3_config()] call returns.</dd>
1916 ** content of the [sqlite3_mutex_methods] structure before the call to
2084 ** reverts to the last value inserted before the trigger fired.)^
2203 ** is closed or might close before sqlite3_interrupt() returns.
2216 ** that are started after the sqlite3_interrupt() call and before the
2235 ** if additional input is needed before sending the text into
2995 ** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
3392 ** SQLite makes its own private copy of the data immediately, before
3651 ** explicit transaction then you should rollback the transaction before
3682 ** other than [SQLITE_ROW] before any subsequent invocation of
3937 ** before statement S is ever evaluated, after
3966 ** or if [sqlite3_step(S)] has never before been called on S,
4287 ** the destructor will be called before the metadata is dropped.
4309 ** the content before returning.
4357 ** routines make a private copy of the error message text before
4407 ** from [sqlite3_malloc()] before it returns.
4545 ** ^To avoid having to register all collation sequences before a database
4658 ** as part of process initialization and before any SQLite interface
5074 ** is NULL before calling the xEntryPoint(). ^SQLite will invoke
5256 ** ^Module names must be registered before
5257 ** creating a new [virtual table] using the module and before using a
5358 ** before this API is called, a new function is created.)^ ^The implementation
5568 ** before the [BLOB handle] expired are not rolled back by the
5649 ** before calling sqlite3_initialize() or any other public sqlite3_
5709 ** mutex must be exited an equal number of times before another thread
6285 ** any outstanding resources before process shutdown, if required.
6499 ** busy-handler returns non-zero before the lock is available, then
6576 ** sqlite3_backup_init() is called and before the corresponding call to
6684 ** database waits for the callback to be issued before taking any further
6879 ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
6884 ** before returning to communicate this to the caller.
6896 ** database readers as described above. If the busy-handler returns 0 before
8526 #define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before
8725 # include <os2safe.h> /* has to be included before os2.h for linking to work */
9126 ** exits. Upon entering a before or instead of trigger, lastRowid is no
9152 int errMask; /* & result codes with this before returning */
10247 ** information for the i-th table in the FROM clause before reordering.
10570 /* Above is constant between recursions. Below is reset before and after
12306 ** restoring the state of the VM to as it was before the sub-program
14081 ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
14384 ** sqlite3_config() before SQLite will operate.
15126 ** before calling sqlite3_initialize() from which allocations
15420 ** chunk before invoking this routine, then must unlink the (possibly
15815 ** before calling sqlite3_initialize() from which allocations
16685 ** mutex must be exited an equal number of times before another thread
16960 ** mutex must be exited an equal number of times before another thread
17223 ** mutex must be exited an equal number of times before another thread
17608 ** mutex must be exited an equal number of times before another thread
18457 ** This function must be called before exiting any API function (i.e.
19041 /* "0" digits after the decimal point but before the first
19369 ** the string and before returnning. This routine is intended to be used
22332 int newLocktype; /* Set pFile->locktype to this value before exiting */
23333 ** All loads and stores begun before the barrier must complete before
24897 ** The nRef field of the vxworksFileId object is incremented before
25543 /* A PENDING lock is needed before acquiring a SHARED lock and before
25734 ** before establishing the readlock - to avoid a race condition we downgrade
26154 ** Close a file. Make sure the lock has been released before closing.
26769 /* A PENDING lock is needed before acquiring a SHARED lock and before
26842 /* Remove the shared lock before trying the range. we'll need to
27071 ** is set before returning.
27149 ** is set before returning.
28246 ** All loads and stores begun before the barrier must complete before
28691 ** immediately, before releasing the mutex. findInodeInfo() may fail
29388 ** this buffer before returning.
30421 /* now insert a "." before the last / character */
31501 /* Acquire the mutex before continuing */
31786 ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
31811 Sleep(100); /* Wait a little before trying again */
32098 int newLocktype; /* Set pFile->locktype to this value before exiting */
32815 ** All loads and stores begun before the barrier must complete before
33382 ** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
33975 /* Maximum number of entries in hash table before
35007 ** directly before this structure in memory (see the PGHDR1_TO_PAGE()
35062 ** bytes of data are located directly before it in memory (i.e. the total
35396 ** criteria are unpinned before they are discarded.
35624 ** optimization: The common case is to exit the module before reaching
35929 ** will only see elements that were inserted before the last change
36776 ** been turned on (and before any read or write transactions are
36831 ** lock on the database file before attempting to roll it back. See function
36871 ** journal before the journal-header. This is required during savepoint
36931 ** journal file before it is synced to disk.
37002 ** and to determine whether or not pages need to be journalled before
37071 Pgno dbOrigSize; /* dbSize before the current transaction */
37878 ** database before the transaction began, in pages. Also, pPager->cksumInit
37965 ** crashed before the header was synced. In this case stop reading
37996 ** journal file descriptor is advanced to the next sector boundary before
38036 /* If in full-sync mode, advance to the next disk sector before writing
38149 ** contents of the pager cache are discarded before switching back to
38591 /* If this page has already been played by before during the current
38631 ** met before writing to the database files. (1) the database must be
38687 ** requiring a journal-sync before it is written.
38726 ** be written out into the database file before its journal file
38736 ** Do this before any decoding. */
38969 ** the state it was in before we started making changes.
39174 ** before the transaction was committed, then the change-counter
39217 ** file before this function is called.
39607 ** In either case, before playback commences the Pager.dbSize variable
39629 /* Set the database size back to the value it was before the savepoint
39735 ** NORMAL The journal is synced once before writes begin on the
39742 ** FULL The journal is synced twice before writes begin on the
39896 ** then *pPageSize is set to the old, retained page size before returning.
39902 ** function may be called from within PagerOpen(), before the state
40061 ** variable to locktype before returning.
40131 ** This function is called before attempting a hot-journal rollback. It
40136 ** Syncing a hot-journal to disk before attempting to roll it back ensures
40184 /* If it is open, sync the journal file before calling UnlockAndRollback.
40193 ** rollback before accessing the database file.
40252 ** mode, then the journal file is synced before this field is updated.
40268 ** page currently held in memory before returning SQLITE_OK. If an IO
40296 ** occurs after nRec is updated but before this connection writes
40331 ** all data has really hit the disk before nRec is updated to mark
40395 ** is not yet open, it is created and opened before any data is
40517 ** that it is really required before calling this function.
40520 ** for all open savepoints before returning.
40775 ** check for a hot-journal before reading.
41026 ** call above, but then delete the journal and drop the lock before
41170 ** downgraded to SHARED_LOCK before this function returns.
41185 ** other connection managed to get in and roll it back before
41209 ** lock and reacquire the read lock. Purge the cache before
41211 ** an inconsistent cache. Sync the hot journal before playing
41214 ** the journal before playing it back.
41230 ** pager_unlock() routine will be called before returning to unlock
41765 ** This is done before calling sqlite3PcacheMakeDirty() on the page.
41868 ** Mark a data page as writeable. This routine must be called before
41876 ** must have been written to the journal file before returning.
41951 ** before any of them can be written out to the database file.
42165 ** sync the database file before calling CommitPhaseTwo() to delete the
42757 ** moved as part of a database reorganization just before the transaction
42813 /* If the journal needs to be sync()ed before page pPg->pgno can
42817 ** the journal needs to be sync()ed before database page pPg->pgno
42828 ** page pgno before the 'move' operation, it needs to be retained
42861 ** sync()ed before any data is written to database file page needSyncPgno.
42870 ** this transaction, it may be written to the database file before
43151 ** implementation. Take the exclusive lock now, before opening the WAL
43223 ** If successful, the EXCLUSIVE lock is not released before returning.
43231 ** it may need to be checkpointed before the connection can switch to
43373 ** before the xSync must complete before any write that launches after the
43659 /* Size of header before each frame in wal */
43852 ** The checksum is written back into aOut[] before returning.
43903 ** The checksum on pWal->hdr is updated before it is written.
44253 ** entire hash table and aPgno[] array before proceding.
44264 ** the hash-table before writing any new entries.
44332 ** If successful, the same bytes that are locked here are unlocked before
44526 /* In the amalgamation, the os_unix.c and os_win.c source files come before
44793 ** of memory will be freed before this function returns.
44882 ** Fsync is called on the WAL before writing content out of the WAL and
45062 ** The EXCLUSIVE lock is not released before returning.
45155 ** wal-index from the WAL before returning.
45298 ** The total delay time before giving up is less than 1 second.
45327 ** must be zeroed before the requested page is returned.
45352 ** may have been appended to the log before READ_LOCK(0) was obtained.
45359 ** is wrapped and written for that matter) before the READ_LOCK(0)
45361 ** have started to backfill the appended frames but crashed before
45428 ** date before proceeding. That would not be possible without somehow
45457 ** transaction, then *pChanged is set to 1 before returning. The
45527 ** slot (aHash[iKey]) may have been added before or after the
45531 ** that any slots written before the current read transaction was
45696 ** was in before the client began writing to the database.
45770 ** This function is called just before writing a set of frames to the log
46042 ** This has to be done before the call to walIndexReadHdr() below.
46080 /* If a new wal-index header was loaded before the checkpoint was
46128 ** on the main database file before invoking this operation.
46310 ** file header that occurs before the page header.
46490 u16 idx; /* Insert this cell before idx-th non-overflow cell */
47316 ** For example, before writing to any part of the table or index
47575 ** This function is called before modifying the contents of a table
47734 ** the table with root-page iRoot. Usually, this is called just before cursor
49191 ** to insure data is written to the disk surface before
49619 ** A write-transaction must be started before attempting any
49890 ** the journal needs to be sync()ed before database page pDbPage->pgno
50090 ** A write-transaction must be opened before calling this function.
50140 Pgno nOrig; /* Database size before freeing */
50453 ** before starting a subtransaction. The subtransaction is ended automatically
50663 ** ignored. If the rowid cache has never before been set, then a
51506 ** before or after the key.
51635 ** buffer before VdbeRecordCompare() can be called. */
51719 ** was already pointing to the last entry in the database before
51788 ** was already pointing to the first entry in the database before
52315 ** It is helpful to detect this before calling freePage2(), as
52921 ** to the page and its siblings fit into MemPage.aData[] before returning.
53106 ** divider cells are stripped from the cells before they are copied
53502 ** page before the balancing, then the pointer map entries associated
53536 ** Cleanup before returning.
53716 ** balance_nonroot(), or just before this function returns, whichever
53757 ** the cursor before the new key can be inserted.
53768 int loc = seekResult; /* -1: before desired location +1: after */
53947 /* Save the positions of any other cursors open on this table before
54263 ** page number that used to be the last root page in the file before
54282 ** This error is caught long before control reaches this point.
54908 ** A read-only or read-write transaction must be opened before calling
55109 ** Just before the shared-btree is closed, the function passed as the
55628 ** before this function exits.
55694 ** journalled by PagerCommitPhaseOne() before they are destroyed
55872 ** to be updated with the new data before the backup operation is
55927 ** transaction is committed before returning.
56283 ** before attempting the conversion.
56600 ** freed before the copy is made.
57950 ** check the value of p->nOp-1 before continuing.
58764 ** be called on an SQL statement before sqlite3_step().
58837 ** be done before determining whether a master journal file is
58990 ** file before the failure occurred.
59006 ** doing this the directory is synced again before any individual
59440 /* The expired flag was set on the VDBE before the first call
59617 ** In an SQLite index record, the serial type is stored directly before
60300 ** constants) to the value before returning it.
60681 /* We used to require that sqlite3_reset() be called before retrying
61888 ** When this global variable is positive, it gets decremented once before
62423 ** sqlite3VdbeMakeReady() must be called before this routine in order to
63224 ** into an OP_String before it is executed for the first time.
63426 ** opened by this VM before returning control to the user. This is to
64017 ** to coerce both inputs according to this affinity before the
64640 ** record, or if the end of the last field appears to be before the end
64834 ** sqlite3VdbeMemGrow() could clobber the value before it is used).
65129 ** write transaction must be started before any changes can be made to the
65194 ** must be started or there must be an open cursor) before
65224 ** A transaction must be started before executing this opcode.
65272 ** to be executed (to establish a read lock) before this opcode is
65414 ** before reaching this instruction. */
65502 ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
65649 ** blob, or NULL. But it needs to be an integer before we can do
66216 ** operation will not attempt to find the appropriate row before doing
66896 ** value of the root page that moved - its value before the move occurred -
67361 ** the trigger program. If this trigger has been fired before, then u.by.pRt
69096 int nBuf /* Bytes buffered before opening the file */
69418 ** is invoked before visiting children.)
70552 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
70556 /* Add the expression list to the name-context before parsing the
71315 ** has never appeared before, reuse the same variable number
72117 ** or ephermal table) is stored in pX->iTable before this function returns.
74332 ** because it was there before or because we just created it).
74556 /* Ran out of input before finding an opening bracket. Return NULL. */
74678 /* Ran out of input before finding the table name. Return NULL. */
74755 ** In this case zWhere is passed to sqlite3DbFree() before returning.
75091 /* The VDBE should have been allocated before this routine is called.
75092 ** If that allocation failed, we would have quit before reaching this
75917 ** table (if it is present) before returning.
77117 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
77182 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
77240 ** before the database closes. It is also called during a rollback
77697 ** indices to be created and the table record must come before the
78077 ** then an index may have been created on this column before the
78177 ** to the first byte after the last byte written before returning.
78941 ** the table being dropped. This is done before the table is dropped
79145 ** the index already exists and must be cleared before being refilled and
79196 ** call above. Just before that function was freed they were released
79278 ** before looking up the table.
79417 ** failure we have quit before reaching this point. */
79691 /* Clean up before exiting */
80011 ** before being added to the SrcList.
80112 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
80307 ** read transactions be started before anything else happens in
80322 ** early in the code, before we know if any database tables will be used.
80376 ** can be checked before any changes are made to the database, it is never
80707 ** This routine is called on a collation sequence before it is used to
81619 /* Jump here if the row had already been deleted before any BEFORE
83320 ** transaction before fixing the constraint violation, the attempt fails.
83373 ** resolution is considered to delete rows before the new row is inserted.
83400 ** accessed). No information is required by the code-generator before
83779 ** be applied to each child key value before the comparison takes place.
83910 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
83941 ** violations, halt the VDBE and return an error at this point, before
83970 ** For an UPDATE operation, this function is called twice. Once before
83973 ** but before the new record is inserted using the INSERT convention.
84118 ** This function is called before generating code to update or delete a
84144 ** This function is called before generating code to update or delete a
84759 ** routine just before the "exit" code.
85343 ** do not attempt any conversions before assembling the record.
85561 ** the address of a register containing the rowid before the update takes
87009 ** not NULL before calling it.
87146 ** before calling APIs that follow, extension should check the
88775 ** is executed, this is done before the ATTACH operation.
89282 ** will be closed before this function returns. */
89410 ** of the schema was loaded before the error occurred. The primary
89420 ** before that point, jump to error_out.
90505 ** and this row has been seen before, then do not make this row
91047 ** column specific strings, in case the schema is reset before this
91479 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
91485 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
92592 ** the subquery before this routine runs.
93320 ** SELECT statement. The SELECT statement must be expanded before
93592 ** Apply the affinity pDest->affinity before storing
94101 ** increments the iAbortFlag memory location before returning in
94660 ** up to the point of the BEGIN before the trigger actions. A Trigger
95082 int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
95497 ** TriggerPrg object exists, a new object is allocated and populated before
96144 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
96290 ** it out of the ephemeral table before calling VUpdate.
96484 ** restored before returning. Then set the writable-schema flag, and
96500 ** (possibly synchronous) transaction opened on the main database before
96923 ** This routine is called, for example, just before deleting the Table
97094 ** allows a schema that contains virtual tables to be loaded before
98912 u8 c, *pC; /* Last character before the first wildcard */
98916 /* The point is to increment the last character before the first
100023 ** aff applied to it, before returning. It is the responsibility of the
101007 ** no conversion should be attempted before using a t2.b value as part of
101263 int iReleaseReg = 0; /* Temp register to free before returning */
102596 ** as the vdbe level waits until the table is read before actually
103400 ** the parse is retried before an error is thrown.
103502 int yyerrcnt; /* Shifts left before out of the error */
104019 ** being destroyed before it is finished parsing.
104125 ** all stack elements before shutting the parser down.
106052 ** As before, subsequent error messages are suppressed until
106452 ** Store the token type in *tokenType before returning.
107335 ** completion. If subsequent threads call this routine before the first
107699 /* Free any existing lookaside buffer for this handle before
107941 ** call will do so. We need to do this before the check for active
108234 ** specified number of milliseconds before returning 0.
108820 ** be cleared before returning. Do this directly, instead of via
109714 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
109768 ** as it existing before this routine was called.
110052 ** before this routine returns.
110397 * to make sure before you decide that you aren't using manifest
110536 * contains the page data before DbPage. So code should always be
112866 int *piPosition /* OUT: Number of tokens returned before this one */
113414 ** 32-bit integer before it is returned.
113580 ** before returning.
113677 ** before returning.
114441 ** before this function returns.
114487 ** before this function returns. The POS_COLUMN or POS_END terminator
114527 ** point to the next value before returning.
114552 ** Set *pp to point to the byte just after the last byte written before
114606 ** incremented by 2 before being stored. Each list is terminated by a
114661 ** when the *pp1 token appears before the *pp2 token, but not more than nToken
114662 ** slots before it.
114668 int isExact, /* If *pp1 is exactly nTokens before *pp2 */
114839 ** of bytes written to aBuffer is stored in *pnBuffer before returning.
116124 /* In case the cursor has been used before, clear it now. */
117347 ** zero the memory before returning a pointer to it. If unsuccessful,
117362 ** reached before a token is found, set *ppExpr to zero. It is the
117580 /* Skip over any whitespace before checking for a keyword, an open or
120115 ** parameters. The values are bound to the statements parameters before
120265 ** table-lock on the %_content table. This is required before reading
120376 ** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning.
120753 ** to the size of the blob in bytes before returning.
120765 ** before control is returned to the user (to prevent a lock being held
120768 ** must call sqlite3Fts3SegmentsClose() before returning.
120964 ** Fts3SegReader.pOffsetList to point to the next offset list before
121909 ** *pnList is set to zero before returning.
123044 /* Set the output variables before returning. */
123089 ** The selected snippet parameters are stored in structure *pFragment before
123091 ** before returning.
123298 const char *zOpen, /* String inserted before highlighted term */
123679 ** array before returning. SQLITE_OK is returned in this case.
125205 ** pCursor->aConstraint[] array. If so, set *pbEof to true before
125809 float before;
125811 before = cellOverlap(pRtree, p, aCell, nCell, iExclude);
125814 return after-before;
126736 ** relinquished before this function returns.