Lines Matching defs:time
450 ** string contains the date and time of the check-in (UTC) and a SHA1
505 ** compile time. ^The SQLITE_ prefix may be omitted from the
509 ** over the list of options that were defined at compile time by
510 ** returning the N-th compile time option string. ^If N is out of range,
517 ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
535 ** [SQLITE_THREADSAFE] compile-time option being set to 0.
553 ** This interface only reports on the compile-time mutex setting
559 ** sqlite3_threadsafe() function shows only the compile-time setting of
560 ** thread safety, not any run-time changes to that setting made by
1209 ** chunks (say 1MB at a time), may reduce file-system fragmentation and
1380 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
1612 ** the end. Each time such an extension occurs, the iVersion field
1750 ** method returns a Julian Day Number for the current date and time as
1756 ** date and time if that method is available (if iVersion is 2 or
1886 ** the first time sqlite3_initialize() is invoked during the lifetime of
1887 ** the process, or if it is the first time sqlite3_initialize() is invoked
1918 ** compile-time option, then the automatic calls to sqlite3_initialize()
1943 ** (using the [SQLITE_OS_OTHER=1] compile-time
2102 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2116 ** [database connection] at the same time. ^If SQLite is compiled with
2117 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2131 ** same [prepared statement] in different threads at the same time.
2133 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2244 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2257 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2322 ** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
2323 ** if that compile-time option is omitted.
2362 ** compile-time maximum mmap size set by the
2363 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
2365 ** changed to its compile-time default.
2387 ** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched
2405 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
2421 ** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
2431 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that
2432 ** compile-time option is not set, then the default maximum is 1073741824.
2692 ** compile-time option.
2701 ** compile-time option.
2971 ** ^If an SQL operation is very nearly finished at the time when
3095 ** for a specified amount of time when a table is locked. ^The handler
3304 ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
3441 ** at a time. Each call to sqlite3_set_authorizer overrides the
3555 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
3560 ** the original statement text and an estimate of wall-clock time
3562 ** time is in units of nanoseconds, however the current implementation
3564 ** digits in the time are meaningless. Future versions of SQLite
3683 ** ^Only a single progress handler may be defined at one time per
3764 ** to use SQLite at the same time, as long as each thread is using
3770 ** attempt to use the same database connection at the same time.
3836 ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
4212 ** the time of the first error and the call to these interfaces.
4258 ** CAPI3REF: Run-time Limits
4271 ** set at compile-time by a C preprocessor macro called
4282 ** Run-time limits are intended for use in applications that manage
4295 ** New run-time limit categories may be added in future releases.
4304 ** that can be lowered at run-time using [sqlite3_limit()].
4380 ** that the prepared statement will be retained for a long time and
4497 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
4579 ** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of
4580 ** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time
4591 ** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined.
4903 ** to the parameters at a later time.
5058 ** at the same time then the results are undefined.
5090 ** ^SQLite uses dynamic run-time typing. ^So just because a column
5136 ** is returned each time a new row of data is ready for processing by the
5140 ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
5154 ** more threads at the same moment in time.
5166 ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
5981 ** ^The first time the sqlite3_aggregate_context(C,N) routine is called
5988 ** last time when the xFinal callback is invoked. ^(When no rows match
5992 ** first time from within xFinal().)^
6076 ** SQLite is free to discard the metadata at any time, including: <ul>
6093 ** function parameters that are compile-time constants, including literal
6507 ** millisecond time resolution, then the time will be rounded up to
6537 ** thread at a time. It is not safe to read or modify this variable
6538 ** if a [database connection] is being used at the same time in a separate
6594 ** thread at a time. It is not safe to read or modify this variable
6595 ** if a [database connection] is being used at the same time in a separate
6998 ** compile-time option is recommended because the
7009 ** that was in effect at the time they were opened.)^
7057 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
7116 ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
7117 ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
7363 ** If this is a problem for you, do not use the interface at this time.
7773 ** If this is a problem for you, do not use the interface at this time.
8064 ** is selected automatically at compile-time. The following
8479 ** compile-time options. For example, "VACUUM" is not a keyword if
8658 ** These integer constants designate various run-time status parameters
8719 ** New status parameters may be added from time to time.
8935 ** need to be reinitialized each time the statement is run.</dd>
9089 ** ^(The xCachesize() method may be called at any time by SQLite to set the
9141 ** may choose to evict unpinned pages at any time.
9339 ** updated at the same time.
9407 ** same time as another thread is invoking sqlite3_backup_step() it is
9452 ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
9622 ** is invoked each time data is committed to a database in wal mode.
9645 ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
9763 ** any other process is running a checkpoint operation at the same time, the
10096 ** at a time.
10142 ** the traditional one-at-a-time processing strategy for the IN constraint.
10325 ** compile-time option.
10401 ** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option.
10406 ** ^At most one preupdate hook may be registered at a time on a single
10533 ** as it existed for the point in time when the transaction first started.
10587 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10636 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10653 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10669 ** last time the wal file was deleted. The wal file is deleted when the
10877 ** SQLITE_RTREE_INT_ONLY compile-time option.
11270 ** recorded once - the first time a row with said primary key is inserted,
12049 ** Each time the conflict handler function is invoked, it must return one
12512 ** Each time the xInput callback is invoked by the sessions module, the first
13153 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
13392 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options.
13431 ** compile time. This is no longer permitted, on the grounds that it creates
13475 ** This value can be lowered (or raised) at run-time using that the
13607 ** database connection at the same time.
13613 ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
13663 # error "Two or more of the following compile-time configuration options\
14238 ** changed at run-time using a pragma.
14278 ** The default value of "20" was chosen to minimize the run-time of the
14293 ** The compile-time options SQLITE_MMAP_READWRITE and
14399 ** can be used at compile-time if desired.
14402 typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */
14471 ** and whether or not that determination is run-time or compile-time.
14476 ** at run-time.
14585 ** default MMAP_SIZE is specified at compile-time, make sure that it does
14707 ** directly, we use its constant as a key to lookup the run-time allocated
14709 ** for the run-time allocated buffer.
14911 ** If SQLITE_OS_OTHER=1 is specified at compile-time, then the application
15024 ** any time. Other processes may hold and obtain new SHARED locks.
15026 ** any one time. Existing SHARED locks may persist, but no new
15052 ** same time, unless they are unlucky and choose the same lock byte.
15181 ** at a time and provides a journal for rollback.
15913 u64 cycles; /* Total time spent executing this instruction */
16703 ** at start-time.
16708 ** start-time.
16750 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
17372 ** single query - might change over time */
17426 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
17435 ** Used for "pure" date/time functions, this macro is like DFUNCTION
17720 ** next time a statement is prepared using said sqlite3*. This is done
18233 ** the option is available (at compile-time).
18635 ** It can never be both at the same time, but it can be neither.
18816 ** the number of columns in P2 can be computed at the same time
18925 ** results each time it is invoked. The entry point
20941 ** play when the SQLITE_MEMDEBUG compile-time option is used.
21014 ** switch. The following code should catch this problem at compile-time.
21210 ** This file implements routines used to report what compile-time options
21237 ** An array of names of all compile-time options. This array should
21241 ** only a handful of compile-time options, so most times this array is usually
22146 ** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
22164 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
22165 ** that compile-time option is omitted.
22171 # error "Compile-time disabling of covering index scan using the\
22201 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
22202 ** or at run-time for an individual database connection using
23155 ** we have to locate the state vector at run-time. In the more common
23515 ** This file contains the C functions that implement date and time
23552 #include <time.h>
23567 ** A structure for holding a single date and time.
23652 ** Parse a timezone extension on the end of a date-time.
23819 /* We got the time */
23837 ** Set the time to the current time reported by the VFS.
23879 ** as there is a time string. The time string can be omitted as long
24016 ** local time.
24100 sqlite3_result_error(pCtx, "local time unavailable", -1);
24125 ** of several units of time.
24142 ** Process a modifier to a date-time stamp. The modifiers are
24169 DateTime *p, /* The date/time value to be modified */
24222 ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
24223 ** show local time.
24253 i64 iGuess; /* Guess at the corresponding utc time */
24285 ** Move the date to the same time on the next occurrence of
24356 ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be
24432 ** Process time function arguments. argv[0] is a date-time stamp.
24434 ** the resulting time into the DateTime structure p. Return 0
24475 ** The following routines implement the various date and time functions
24562 ** time( TIMESTRING, MOD, MOD, ...)
24751 ** This function returns the same value as time('now').
24793 ** If the library is compiled to omit the full-scale date and time
24799 ** This function uses the C-library functions time(), gmtime()
24847 PURE_DATE(time, -1, 0, 0, timeFunc ),
25156 ** method to get the current date and time if that method is available
25355 ** we have to locate the state vector at run-time. In the more common
25426 ** used when no other memory allocator is specified using compile-time
25513 ** used when no other memory allocator is specified using compile-time
26661 ** successful most of the time (about 9 times out of 10).
27021 ** be the maximum amount of memory ever outstanding at one time. Let
27029 ** that an application can, at any time, verify this constraint.
27198 ** threads can be in this routine at the same time.
27437 ** to prevent multiple threads from entering at the same time.
27950 ** mutex routines at start-time using the
28140 ** is used regardless of the run-time threadsafety setting.
28412 ** address at the same time. If either of these two conditions
28455 ** address at the same time. If either of these two conditions
30067 ** The counter *cnt is incremented each time. After counter exceeds
32688 ** we have to locate the state vector at run-time. In the more common
32719 ** the first time this routine is called.
32759 ** PRNG and restore the PRNG to its saved state at a later time, or
35104 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
35110 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
36732 ** Return the current time as a Julian Day number in *pTimeOut.
36741 #include <sys/time.h>
36865 /* #include <time.h> */
36866 #include <sys/time.h> /* amalgamator: keep */
37719 ** There are never very many files open at one time and lookups are not
37921 ** in thread B. But there is no way to know at compile-time which
37923 ** compile-time whether or not thread A can override locks on thread B.
37924 ** One has to do a run-time check to discover the behavior of the
38422 ** the first time any lock is attempted. All subsequent system locking
39001 ** time and one or more of those connections are writing.
39220 ** only a single process can be reading the database at a time.
39425 ** the database file at a time. This reduces potential concurrency, but
40505 ** the fcntl call every time sync is called.
40578 ** size, access time, etc) are synced. If dataOnly!=0 then only the
40616 ** is set. This is a one-time occurrence. Many systems (examples: AIX)
41335 ** a time, assuming that each mapping must be an integer multiple of the
41461 ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
41462 ** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
41465 ** same database file at the same time, database corruption will likely
41466 ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
43011 ** a file-descriptor on the directory too. The first time unixSync()
43603 time(&t);
43619 ** Sleep for a little while. Return the amount of time slept.
43654 SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
43658 ** Find the current time (in Universal Coordinated Time). Write into *piNow
43659 ** the current time and date as a Julian Day number times 86_400_000. In
43664 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
43672 time(&t);
43695 ** Find the current time (in Universal Coordinated Time). Write the
43696 ** current time and date as a Julian Day number into *prNow and
43697 ** return 0. Return 1 if the time and date cannot be found.
43770 ** single host at a time and moving file locks off of the database file
43812 ** at a time
43843 ** to be created the first time they are used.
44201 * 1st try: get the mod time of the conch, wait 0.5s and try again.
44202 * 2nd try: fail if the mod time changed or host id is different, wait
44204 * 3rd try: break the lock unless the mod time has changed.
44627 ** the unix structure properly cleaned up at close time:
44954 ** that filesystem time.
47276 /* # include <time.h> */
48313 ** It is not possible to lower the locking level one step at a time. You
48320 int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
48542 ** time and one or more of those connections are writing.
50998 ** Sleep for a little while. Return the amount of time slept.
51012 SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
51016 ** Find the current time (in Universal Coordinated Time). Write into *piNow
51017 ** the current time and date as a Julian Day number times 86_400_000. In
51022 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
51040 SYSTEMTIME time;
51041 osGetSystemTime(&time);
51043 if (!osSystemTimeToFileTime(&time,&ft)){
51064 ** Find the current time (in Universal Coordinated Time). Write the
51065 ** current time and date as a Julian Day number into *prNow and
51066 ** return 0. Return 1 if the time and date cannot be found.
51325 ** at any time as long as we know the object is not being destroyed,
51987 ** Return the current time as a Julian Day number in *pTimeOut.
52222 ** may be set or cleared one at a time.
53573 ** size can vary according to architecture, compile-time options, and
53713 ** modified at any time by a call to the pcache1Cachesize() method.
53755 ** fixed at sqlite3_initialize() time and do not require mutex protection.
53875 ** Multiple threads can run this routine at the same time. Global variables
54245 ** configured a start-time buffer for use as page-cache memory using
54875 ** primitives are constant time. The cost of DESTROY is O(N).
55005 /* We could allocate a fresh RowSetEntry each time one is needed, but it
55412 ** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and
55557 ** Definition: Two databases (or the same database at two points it time)
55563 ** (7) At any time, if any subset, including the empty set and the total set,
55784 ** page-cache and any other in-memory state at the same time. Everything
55979 ** relinquished on the database file. Each time a transaction is committed,
56038 ** This variable is updated by the upper layer each time a new
56089 ** write-transaction is opened (at the same time as dbFileSize and
56975 ** journal header. Normally, zero is written to this value at this time.
57137 ** respective compile time maximum limits.
57325 ** as a hot-journal and rolled back the next time a read-transaction
57654 ** the rollback at this time. Instead, pager_unlock() is called. The
58752 ** makes a snapshot of the database at the current point in time and preserves
58903 ** Throughout the rollback process, each time a page is rolled back, the
58906 ** rolled back the first time it is encountered in either journal.
59471 ** b) if the page content were written at this time, it would not
61019 ** first time a page is loaded into memory. If the page requested is
61052 ** just returns 0. This routine acquires a read-lock the first time it
61838 ** enabled at compile time, the compiler can omit the tests of
61883 ** next time a read transaction is opened the cache will be
62043 ** was enabled at compile time, and if this transaction meets the
62051 ** If the optimization was not enabled at compile time, then the
63279 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
63458 ** being considered valid at the same time and being checkpointing together
63476 ** of the database from a single point in time. This technique allows
63596 ** at a later time (after additional transactions were added to the WAL
65396 ** time.
65672 ** be writing the header at the same time this procedure is trying to
66092 ** instances of time. No I/O or other system calls are done while the
66095 ** paged out or take a page-fault that is time-consuming to resolve,
66104 ** The total delay time before giving up is less than 10 seconds.
66107 int nDelay = 1; /* Pause time in microseconds */
66246 ** between the time it was read and when the shared-lock was obtained
66371 ** instant in time. The current thread will continue to use this snapshot.
66647 ** There can only be a single writer active at a time.
66671 /* Only one writer allowed at a time. Get the write lock. Return
66681 ** time the read transaction on this connection was started, then
67260 ** checkpoint operation at the same time, the lock cannot be obtained and
67323 ** next time the pager opens a snapshot on this database it knows that
67480 ** is incremented each time the wal file is restarted. */
67806 ** You can change this value at compile-time by specifying a
67959 ** A single database file can be in use at the same time by two
68578 ** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not
70108 ** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
70577 "childPtrSize[%u], cellOffset[%u], nCell[%u], hdrOffset[%u], minLocal[%u], maxLocal[%u], last ckpt time[%lld]",
70833 ** about the content of the page at this time. So do not go to the disk
72098 ** upgraded to exclusive by calling this routine a second time - the
73273 ** of run-time by skipping the initialization of those elements.
73837 ** page of the database. The data might change or move the next time
79528 ** The first time this is called on a shared-btree, nBytes bytes of memory
82702 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
83130 ** Mark the VDBE as one that can only be run one time.
83315 ** Assert if an Abort at this point in time might result in a corrupt
84997 ** Prepare a virtual machine for execution for the first time after
85238 ** statement. This is now set at compile time, rather than during
87722 ** This routine is invoked by date/time functions that use non-deterministic
88571 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
88847 ** Return the current time for a statement. If the current time
88849 ** statement, the exact same time is returned for each invocation regardless
88850 ** of the amount of time that elapses between invocations. In other words,
88851 ** the time returned is always the time of the first call.
90310 ** The following global variable is incremented every time a cursor
90370 ** The next global variable is incremented each time the OP_Found opcode
91281 ** sqlite3VdbeExec() or since last time the progress callback was called).
91582 ** into a String opcode before it is executed for the first time. During
92892 ** Fall through to the next instruction the first time this opcode is
93471 ** static generated columns. Virtual columns are computed at query time
93626 ** compile-time option is enabled:
98752 ** function was determined to be constant at compile time. If the first
98771 ** function was determined to be constant at compile time. If the first
98779 ** purely non-deterministic. Some built-in date/time functions can be
98942 ** first time they are evaluated for this run.
99142 ** On the other hand, it does burn CPU cycles every time through
99905 ** PMAs at a time. This done is to improve locality.
100028 ** In other words, each time we advance to the next sorter element, log2(N)
100185 ** The PMA is written one record at a time. Each record is of an arbitrary
104234 ** resolved by the time the WHERE clause is resolved.
104726 /* For the purposes of the EP_ConstFunc flag, date and time
104734 ** date/time functions that use 'now', and other functions like
104735 ** sqlite_version() that might change over time cannot be used
105559 /* Resolve the GROUP BY clause. At the same time, make sure
105602 ** table columns and result-set columns. At the same time, do error
106018 /* The Expr.x union is never used at the same time as Expr.pRight */
107046 /* The Expr.x union is never used at the same time as Expr.pRight */
108851 ** constructed ephermeral table is returned. The first time the ephemeral
108879 /* The evaluation of the IN must be repeated every time it
109014 ** expression we need to rerun this code each time.
109099 /* The evaluation of the EXISTS/SELECT must be repeated every time it
110690 ** Generate code that will evaluate expression pExpr just one time
110828 ** might choose to code the expression at initialization time.
111336 ** to re-prepare each time a new value is bound to variable pVar.
113569 /* Dequote the double-quoted token. Then requote it again, this time
114763 ** appropriate compile-time options are provided.
115646 ** this time though. */
117497 ** Record the fact that we want to lock a table at run-time.
119491 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
122768 ** isMultiWrite flag was previously set. There is a time dependency
122771 ** go a little faster. But taking advantage of this time dependency
124625 ** block of registers has already been deallocated by the time
124730 ** time functions, are implemented separately.)
126147 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
126164 ** is only available if the SQLITE_SOUNDEX compile-time option is used
126939 ** to the global function hash table. This occurs at start-time (as
126950 ** FuncDef.pHash elements at start-time. The elements of this array
127156 ** with the database handle. The counter is set to zero each time a
127157 ** database transaction is opened. Each time a statement is executed
127159 ** time a statement is executed that removes an existing violation from
127425 ** Each time it is called, this function generates VDBE code to locate the
128677 /* The first time a column affinity string for a particular index is
129241 ** and the SELECT clause does not read from <table> at any time.
131372 ** is empty - a factor that can only be determined at run-time. In that
133379 ** we have to locate the state vector at run-time. In the more common
134349 ** and 0 to use the compile-time default.
135196 ** value will be restored the next time the database is opened.
135198 ** Note that it is possible for the library compile-time options to
135338 ** default value will be restored the next time the database is
135494 ** and virtual tables. Each time we initialize a Table.nCol value
135888 ** is linear time wherease integrity_check is O(NlogN).
136398 ** SQLite each time a query is executed to ensure that the internal cache
136455 ** Return the names of all compile-time options used in this build,
136536 ** to change and improve over time. Applications should anticipate that
136575 ** since the last time ANALYZE was run.
140096 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
140145 /* At one time, code such as "SELECT new.x" within a trigger would
142518 ** because they could be computed at compile-time. But when LIMIT and OFFSET
142783 jointype = pSubitem->fg.jointype; /* First time through the loop */
143202 ** At the time this function is called it is guaranteed that
143559 ** to sqlite3SelectPrep() and similar a second time. The rewriting done
145165 ** a join. No need to speed time on this operation for non-join queries
146029 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
147158 /* The first time a RETURNING trigger is seen, the "op" value tells
147159 ** us what time of trigger it should be. */
147270 ** This routine makes a copy of the pList, and at the same time expands
147700 ** If there are no triggers that fire at the specified time for the specified
149726 ** time to parse and run the PRAGMA to turn journalling off than it does
150395 ** first time (in other words if the virtual table is actually being
151442 LogEst rSetup; /* One-time setup cost (ex: create transient index) */
151741 ** pathological queries can spend excess time in the sqlite3WhereBegin()
151965 ** at a time. This routine adds a new term to the end of the expression.
152041 ** defined at compile-time. If it is not a no-op, a single OP_Explain opcode
152805 ** scan loop run twice, once for strings and a second time for BLOBs.
153187 ** from being checked a second time when the inner loop is evaluated.
157637 ** measure the size of the table at run-time using OP_Count with
160009 /* TUNING: One-time cost for computing the automatic index is
160607 ** xBestIndex again, this time with IN(...) terms disabled. */
161362 ** will invoke this function a second time, passing the estimate as the
165549 ** Return true if it can be determined at compile time that expression
165598 ** // First time this branch is taken, the eph table contains two
173532 ** the SQLITE_THREADSAFE compile-time option being set to 0.
173623 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
173762 ** compile-time option.
173829 ** the SQLite library at run-time.
174039 /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
174040 ** can be changed at start-time using the
174079 ** negative, then that argument is changed to its compile-time default.
174083 ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
174084 ** compile-time option.
174166 ** both at the same time.
175527 ** a new one that always throws a run-time error.
175670 ** Register a callback to be invoked each time a row is updated,
175695 ** Register a callback to be invoked each time a transaction is rolled
175721 ** Register a callback to be invoked each time a row is updated,
175819 ** Register a callback to be invoked each time a transaction is written
175971 ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
176276 ** there is a hard upper bound set at compile-time by a C preprocessor
176726 ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the
176737 /* The SQLITE_DQS compile-time option determines the default settings
176902 ** database schema yet. This is delayed until the first time the database
176927 /* Testing use only!!! The -DSQLITE_ENABLE_INTERNAL_FUNCTIONS=1 compile-time
177360 ** Sleep for a little while. Return the amount of time slept.
177587 ** This action provides a run-time test to see whether or not
177588 ** assert() was enabled at compile-time. If X is true and assert()
177628 ** This action provides a run-time test to see how the ALWAYS and
177629 ** NEVER macros were defined at compile-time.
177642 ** The run-time test procedure might look something like this:
177664 ** 1 big-endian, determined at run-time
177665 ** 10 little-endian, determined at run-time
177666 ** 432101 big-endian, determined at compile-time
177667 ** 123410 little-endian, determined at compile-time
177756 ** too big to test in a reasonable amount of time, so this control is
177809 ** the schema to be reparsed the next time it is needed. This has the
178316 ** Given the name of a compile-time option, return true if that option
178352 ** Return the N-th compile-time option string. If N is out of range,
178769 ** FTS3 used to optionally store character offsets using a compile-time
178955 ** a tiny bit slower (perhaps due to more overhead in merge-time
178959 ** At query time, high MERGE_COUNT increases the number of segments
179055 ** including customization information defined at creation time.
179063 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
179547 ** time must share a common language-id (see the FTS4 langid= feature).
183143 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
183167 ** are merged eight at a time, updating the input segments at the end
189136 ** defined at compilation time, a temporary virtual table (see header
190042 ** by the caller. They are valid from the time SegmentReaderNew() returns
193733 ** This function is called while writing an FTS segment each time a leaf o
194794 ** Incremental merges happen nMin segments at a time. The segments
197081 /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the
198262 ** For the time being, all JSON is stored as pure text. (We might add
201248 ** coordinates within a single R-Tree are always of the same time.
201412 ** and whether or not that determination is run-time or compile-time.
201417 ** at run-time.
201428 # define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */
208223 ** checkpointed each time sqlite3rbu_step() is called. If the RBU
208508 ** time sqlite3rbu_close() is called, various state information is saved
208587 ** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
208877 ** file-system via "rbu" all the time, even if it only uses RBU functionality
210195 ** aiTblOrder[] arrays at the same time. */
211747 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
211753 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
212009 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
214057 ** Return the current time as a Julian Day number in *pTimeOut.
216382 ** time control flows to here they have already been called once from
216672 ** blob each time a NULL value is read from the "idx" column of the
219903 ** again, this time with pbRetry set to NULL.
219910 ** row before invoking this function again, this time with pbReplace set
221814 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
222084 ** compile time default. Zero disables auto-merge altogether.
222385 ** Insert or remove data to or from the index. Each time a document is
224812 ** The first time the bm25() function is called for a query, an instance
227230 ** Populate the pPhrase->poslist buffers at the same time. If any
230253 ** Each time a blob is read from the %_data table, it is padded with this
234402 ** and last leaf page number at the same time. */
235513 ** Insert or remove data to or from the index. Each time a document is
235968 ** a time, and the multi-iter loop from which this function is called
238432 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
240145 ** remove the %_content row at this time though.