Lines Matching defs:time
38 ** This file implements routines used to report what compile-time options
65 ** An array of names of all compile-time options. This array should
69 ** only a handful of compile-time options, so most times this array is usually
1180 ** string contains the date and time of the check-in (UTC) and a SHA1
1235 ** compile time. ^The SQLITE_ prefix may be omitted from the
1239 ** over the list of options that were defined at compile time by
1240 ** returning the N-th compile time option string. ^If N is out of range,
1247 ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
1265 ** [SQLITE_THREADSAFE] compile-time option being set to 0.
1283 ** This interface only reports on the compile-time mutex setting
1289 ** sqlite3_threadsafe() function shows only the compile-time setting of
1290 ** thread safety, not any run-time changes to that setting made by
1889 ** compile-time option is used.
1914 ** chunks (say 1MB at a time), may reduce file-system fragmentation and
2085 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
2271 ** the end. Each time such an extension occurs, the iVersion field
2409 ** method returns a Julian Day Number for the current date and time as
2415 ** date and time if that method is available (if iVersion is 2 or
2545 ** the first time sqlite3_initialize() is invoked during the lifetime of
2546 ** the process, or if it is the first time sqlite3_initialize() is invoked
2577 ** compile-time option, then the automatic calls to sqlite3_initialize()
2602 ** (using the [SQLITE_OS_OTHER=1] compile-time
2761 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2775 ** [database connection] at the same time. ^If SQLite is compiled with
2776 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2790 ** same [prepared statement] in different threads at the same time.
2792 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2903 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2916 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2981 ** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
2982 ** if that compile-time option is omitted.
3021 ** compile-time maximum mmap size set by the
3022 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
3024 ** changed to its compile-time default.
3046 ** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched
3064 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
3080 ** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
3090 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that
3091 ** compile-time option is not set, then the default maximum is 1073741824.
3350 ** compile-time option.
3359 ** compile-time option.
3617 ** ^If an SQL operation is very nearly finished at the time when
3741 ** for a specified amount of time when a table is locked. ^The handler
3950 ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
4087 ** at a time. Each call to sqlite3_set_authorizer overrides the
4201 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
4206 ** the original statement text and an estimate of wall-clock time
4208 ** time is in units of nanoseconds, however the current implementation
4210 ** digits in the time are meaningless. Future versions of SQLite
4329 ** ^Only a single progress handler may be defined at one time per
4410 ** to use SQLite at the same time, as long as each thread is using
4416 ** attempt to use the same database connection at the same time.
4463 ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
4831 ** the time of the first error and the call to these interfaces.
4876 ** CAPI3REF: Run-time Limits
4889 ** set at compile-time by a C preprocessor macro called
4900 ** Run-time limits are intended for use in applications that manage
4913 ** New run-time limit categories may be added in future releases.
4922 ** that can be lowered at run-time using [sqlite3_limit()].
4998 ** that the prepared statement will be retained for a long time and
5115 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
5197 ** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of
5198 ** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time
5497 ** to the parameters at a later time.
5652 ** at the same time then the results are undefined.
5684 ** ^SQLite uses dynamic run-time typing. ^So just because a column
5730 ** is returned each time a new row of data is ready for processing by the
5734 ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
5748 ** more threads at the same moment in time.
5760 ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
6558 ** ^The first time the sqlite3_aggregate_context(C,N) routine is called
6565 ** last time when the xFinal callback is invoked. ^(When no rows match
6569 ** first time from within xFinal().)^
6653 ** SQLite is free to discard the metadata at any time, including: <ul>
6670 ** function parameters that are compile-time constants, including literal
7045 ** millisecond time resolution, then the time will be rounded up to
7075 ** thread at a time. It is not safe to read or modify this variable
7076 ** if a [database connection] is being used at the same time in a separate
7132 ** thread at a time. It is not safe to read or modify this variable
7133 ** if a [database connection] is being used at the same time in a separate
7454 ** that was in effect at the time they were opened.)^
7502 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
7561 ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
7562 ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
7808 ** If this is a problem for you, do not use the interface at this time.
8186 ** If this is a problem for you, do not use the interface at this time.
8477 ** is selected automatically at compile-time. The following
8890 ** compile-time options. For example, "VACUUM" is not a keyword if
9069 ** These integer constants designate various run-time status parameters
9130 ** New status parameters may be added from time to time.
9346 ** need to be reinitialized each time the statement is run.</dd>
9488 ** ^(The xCachesize() method may be called at any time by SQLite to set the
9540 ** may choose to evict unpinned pages at any time.
9738 ** updated at the same time.
9806 ** same time as another thread is invoking sqlite3_backup_step() it is
9851 ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
10021 ** is invoked each time data is committed to a database in wal mode.
10044 ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
10161 ** any other process is running a checkpoint operation at the same time, the
10445 ** compile-time option.
10521 ** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option.
10526 ** ^At most one preupdate hook may be registered at a time on a single
10643 ** as it existed for the point in time when the transaction first started.
10697 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10746 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10763 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10779 ** last time the wal file was deleted. The wal file is deleted when the
10983 ** SQLITE_RTREE_INT_ONLY compile-time option.
11344 ** recorded once - the first time a row with said primary key is inserted,
12107 ** Each time the conflict handler function is invoked, it must return one
12570 ** Each time the xInput callback is invoked by the sessions module, the first
13211 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
13445 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options.
13484 ** compile time. This is no longer permitted, on the grounds that it creates
13528 ** This value can be lowered (or raised) at run-time using that the
13659 ** database connection at the same time.
13665 ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
13715 # error "Two or more of the following compile-time configuration options\
14292 ** changed at run-time using a pragma.
14332 ** The default value of "20" was choosen to minimize the run-time of the
14347 ** The compile-time options SQLITE_MMAP_READWRITE and
14453 ** can be used at compile-time if desired.
14456 typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */
14524 ** and whether or not that determination is run-time or compile-time.
14529 ** at run-time.
14627 ** default MMAP_SIZE is specified at compile-time, make sure that it does
14734 ** directly, we use its constant as a key to lookup the run-time allocated
14736 ** for the run-time allocated buffer.
14886 ** at a time and provides a journal for rollback.
15605 u64 cycles; /* Total time spent executing this instruction */
16491 ** any time. Other processes may hold and obtain new SHARED locks.
16493 ** any one time. Existing SHARED locks may persist, but no new
16519 ** same time, unless they are unlucky and choose the same lock byte.
16663 ** at start-time.
16668 ** start-time.
16710 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
17312 ** single query - might change over time */
17363 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
17372 ** Used for "pure" date/time functions, this macro is like DFUNCTION
17622 ** next time a statement is prepared using said sqlite3*. This is done
18096 ** the option is available (at compile-time).
18625 ** the number of columns in P2 can be computed at the same time
18728 ** results each time it is invoked. The entry point
20601 ** play when the SQLITE_MEMDEBUG compile-time option is used.
20777 ** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
20788 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
20789 ** that compile-time option is omitted.
20795 # error "Compile-time disabling of covering index scan using the\
20825 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
20826 ** or at run-time for an individual database connection using
21649 ** we have to locate the state vector at run-time. In the more common
22004 ** This file contains the C functions that implement date and time
22041 #include <time.h>
22056 ** A structure for holding a single date and time.
22141 ** Parse a timezone extension on the end of a date-time.
22308 /* We got the time */
22326 ** Set the time to the current time reported by the VFS.
22368 ** as there is a time string. The time string can be omitted as long
22503 ** local time.
22538 ** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
22579 sqlite3_result_error(pCtx, "local time unavailable", -1);
22607 ** of several units of time.
22625 ** Process a modifier to a date-time stamp. The modifiers are
22652 DateTime *p /* The date/time value to be modified */
22661 ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
22662 ** show local time.
22712 ** Move the date to the same time on the next occurrence of
22783 ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be
22857 ** Process time function arguments. argv[0] is a date-time stamp.
22859 ** the resulting time into the DateTime structure p. Return 0
22900 ** The following routines implement the various date and time functions
22942 ** time( TIMESTRING, MOD, MOD, ...)
23134 ** This function returns the same value as time('now').
23176 ** If the library is compiled to omit the full-scale date and time
23182 ** This function uses the C-library functions time(), gmtime()
23229 PURE_DATE(time, -1, 0, 0, timeFunc ),
23532 ** method to get the current date and time if that method is available
23728 ** we have to locate the state vector at run-time. In the more common
23799 ** used when no other memory allocator is specified using compile-time
23886 ** used when no other memory allocator is specified using compile-time
25034 ** successful most of the time (about 9 times out of 10).
25394 ** be the maximum amount of memory ever outstanding at one time. Let
25402 ** that an application can, at any time, verify this constraint.
25571 ** threads can be in this routine at the same time.
25801 ** to prevent multiple threads from entering at the same time.
26314 ** mutex routines at start-time using the
26504 ** is used regardless of the run-time threadsafety setting.
26776 ** address at the same time. If either of these two conditions
26819 ** address at the same time. If either of these two conditions
26958 ** switch. The following code should catch this problem at compile-time.
28556 ** The counter *cnt is incremented each time. After counter exceeds
30572 ** we have to locate the state vector at run-time. In the more common
30603 ** the first time this routine is called. The seed value does
30645 ** PRNG and restore the PRNG to its saved state at a later time, or
32964 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
32970 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
33069 ** non-standard compile-time options is enabled.
33758 /* #include <time.h> */
33759 #include <sys/time.h>
33990 ** switch. The following code should catch this problem at compile-time.
34762 ** There are never very many files open at one time and lookups are not
34964 ** in thread B. But there is no way to know at compile-time which
34966 ** compile-time whether or not thread A can override locks on thread B.
34967 ** One has to do a run-time check to discover the behavior of the
35456 ** the first time any lock is attempted. All subsequent system locking
36035 ** time and one or more of those connections are writing.
36254 ** only a single process can be reading the database at a time.
36456 ** the database file at a time. This reduces potential concurrency, but
37512 ** the fcntl call every time sync is called.
37585 ** size, access time, etc) are synced. If dataOnly!=0 then only the
37623 ** is set. This is a one-time occurrence. Many systems (examples: AIX)
38260 ** a time, assuming that each mapping must be an integer multiple of the
38386 ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
38387 ** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
38390 ** same database file at the same time, database corruption will likely
38391 ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
39898 ** a file-descriptor on the directory too. The first time unixSync()
40483 time(&t);
40499 ** Sleep for a little while. Return the amount of time slept.
40534 SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
40538 ** Find the current time (in Universal Coordinated Time). Write into *piNow
40539 ** the current time and date as a Julian Day number times 86_400_000. In
40544 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
40552 time(&t);
40575 ** Find the current time (in Universal Coordinated Time). Write the
40576 ** current time and date as a Julian Day number into *prNow and
40577 ** return 0. Return 1 if the time and date cannot be found.
40650 ** single host at a time and moving file locks off of the database file
40692 ** at a time
40723 ** to be created the first time they are used.
41077 * 1st try: get the mod time of the conch, wait 0.5s and try again.
41078 * 2nd try: fail if the mod time changed or host id is different, wait
41080 * 3rd try: break the lock unless the mod time has changed.
41494 ** the unix structure properly cleaned up at close time:
41821 ** that filesystem time.
41958 ** switch. The following code should catch this problem at compile-time.
44304 /* # include <time.h> */
45341 ** It is not possible to lower the locking level one step at a time. You
45348 int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
45570 ** time and one or more of those connections are writing.
47992 ** Sleep for a little while. Return the amount of time slept.
48006 SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
48010 ** Find the current time (in Universal Coordinated Time). Write into *piNow
48011 ** the current time and date as a Julian Day number times 86_400_000. In
48016 ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
48034 SYSTEMTIME time;
48035 osGetSystemTime(&time);
48037 if (!osSystemTimeToFileTime(&time,&ft)){
48058 ** Find the current time (in Universal Coordinated Time). Write the
48059 ** current time and date as a Julian Day number into *prNow and
48060 ** return 0. Return 1 if the time and date cannot be found.
48706 ** Return the current time as a Julian Day number in *pTimeOut.
48930 ** may be set or cleared one at a time.
50241 ** size can vary according to architecture, compile-time options, and
50370 ** modified at any time by a call to the pcache1Cachesize() method.
50412 ** fixed at sqlite3_initialize() time and do not require mutex protection.
50532 ** Multiple threads can run this routine at the same time. Global variables
50917 ** configured a start-time buffer for use as page-cache memory using
51541 ** primitives are constant time. The cost of DESTROY is O(N).
51671 /* We could allocate a fresh RowSetEntry each time one is needed, but it
52078 ** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and
52223 ** Definition: Two databases (or the same database at two points it time)
52229 ** (7) At any time, if any subset, including the empty set and the total set,
52450 ** page-cache and any other in-memory state at the same time. Everything
52631 ** relinquished on the database file. Each time a transaction is committed,
52690 ** This variable is updated by the upper layer each time a new
52741 ** write-transaction is opened (at the same time as dbFileSize and
53612 ** journal header. Normally, zero is written to this value at this time.
53774 ** respective compile time maximum limits.
53962 ** as a hot-journal and rolled back the next time a read-transaction
54291 ** the rollback at this time. Instead, pager_unlock() is called. The
55329 ** makes a snapshot of the database at the current point in time and preserves
55480 ** Throughout the rollback process, each time a page is rolled back, the
55483 ** rolled back the first time it is encountered in either journal.
56047 ** b) if the page content were written at this time, it would not
57575 ** first time a page is loaded into memory. If the page requested is
57608 ** just returns 0. This routine acquires a read-lock the first time it
58388 ** enabled at compile time, the compiler can omit the tests of
58433 ** next time a read transaction is opened the cache will be
58593 ** was enabled at compile time, and if this transaction meets the
58601 ** If the optimization was not enabled at compile time, then the
59776 ** If this is a WAL database, store a pointer to pSnapshot. Next time a
59955 ** being considered valid at the same time and being checkpointing together
59973 ** of the database from a single point in time. This technique allows
60090 ** at a later time (after additional transactions were added to the WAL
61789 ** time.
62063 ** be writing the header at the same time this procedure is trying to
62480 ** instances of time. No I/O or other system calls are done while the
62483 ** paged out or take a page-fault that is time-consuming to resolve,
62492 ** The total delay time before giving up is less than 10 seconds.
62495 int nDelay = 1; /* Pause time in microseconds */
62631 ** between the time it was read and when the shared-lock was obtained
62755 ** instant in time. The current thread will continue to use this snapshot.
63031 ** There can only be a single writer active at a time.
63055 /* Only one writer allowed at a time. Get the write lock. Return
63065 ** time the read transaction on this connection was started, then
63630 ** checkpoint operation at the same time, the lock cannot be obtained and
63693 ** next time the pager opens a snapshot on this database it knows that
63844 ** is incremented each time the wal file is restarted. */
64170 ** You can change this value at compile-time by specifying a
64322 ** A single database file can be in use at the same time by two
64940 ** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not
66388 ** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
67084 ** about the content of the page at this time. So do not go to the disk
68334 ** upgraded to exclusive by calling this routine a second time - the
69472 ** of run-time by skipping the initialization of those elements.
70035 ** page of the database. The data might change or move the next time
75488 ** The first time this is called on a shared-btree, nBytes bytes of memory
78538 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
78963 ** Mark the VDBE as one that can only be run one time.
79139 ** Assert if an Abort at this point in time might result in a corrupt
80705 ** Prepare a virtual machine for execution for the first time after
80952 ** statement. This is now set at compile time, rather than during
83492 ** This routine is invoked by date/time functions that use non-deterministic
84259 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
84465 ** Return the current time for a statement. If the current time
84467 ** statement, the exact same time is returned for each invocation regardless
84468 ** of the amount of time that elapses between invocations. In other words,
84469 ** the time returned is always the time of the first call.
85918 ** The following global variable is incremented every time a cursor
85978 ** The next global variable is incremented each time the OP_Found opcode
86862 ** sqlite3VdbeExec() or since last time the progress callback was called).
87136 ** into a String opcode before it is executed for the first time. During
88391 ** Fall through to the next instruction the first time this opcode is
88883 ** compile-time option is enabled:
93828 ** function was determined to be constant at compile time. If the first
93847 ** function was determined to be constant at compile time. If the first
93855 ** purely non-deterministic. Some built-in date/time functions can be
93936 ** first time they are evaluated for this run.
94136 ** On the other hand, it does burn CPU cycles every time through
94876 ** PMAs at a time. This done is to improve locality.
94999 ** In other words, each time we advance to the next sorter element, log2(N)
95156 ** The PMA is written one record at a time. Each record is of an arbitrary
99120 ** resolved by the time the WHERE clause is resolved.
99580 /* For the purposes of the EP_ConstFunc flag, date and time
99588 ** date/time functions that use 'now', and other functions like
99589 ** sqlite_version() that might change over time cannot be used
100386 /* Resolve the GROUP BY clause. At the same time, make sure
100442 ** table columns and result-set columns. At the same time, do error
100859 /* The Expr.x union is never used at the same time as Expr.pRight */
101784 /* The Expr.x union is never used at the same time as Expr.pRight */
103501 ** constructed ephermeral table is returned. The first time the ephemeral
103529 /* The evaluation of the IN must be repeated every time it
103658 ** expression we need to rerun this code each time.
103718 /* The evaluation of the EXISTS/SELECT must be repeated every time it
105219 ** Generate code that will evaluate expression pExpr just one time
105355 ** might choose to code the expression at initialization time.
105861 ** to re-prepare each time a new value is bound to variable pVar.
108924 ** appropriate compile-time options are provided.
109819 ** this time though. */
111619 ** Record the fact that we want to lock a table at run-time.
113417 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
116528 ** isMultiWrite flag was previously set. There is a time dependency
116531 ** go a little faster. But taking advantage of this time dependency
118334 ** block of registers has already been deallocated by the time
118437 ** time functions, are implemented separately.)
119820 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
119837 ** is only available if the SQLITE_SOUNDEX compile-time option is used
120532 ** to the global function hash table. This occurs at start-time (as
120543 ** FuncDef.pHash elements at start-time. The elements of this array
120745 ** with the database handle. The counter is set to zero each time a
120746 ** database transaction is opened. Each time a statement is executed
120748 ** time a statement is executed that removes an existing violation from
121012 ** Each time it is called, this function generates VDBE code to locate the
122243 /* The first time a column affinity string for a particular index is
122747 ** and the SELECT clause does not read from <table> at any time.
124836 ** is empty - a factor that can only be determined at run-time. In that
126742 ** we have to locate the state vector at run-time. In the more common
127657 ** and 0 to use the compile-time default.
128484 ** value will be restored the next time the database is opened.
128486 ** Note that it is possible for the library compile-time options to
128620 ** default value will be restored the next time the database is
129076 ** is linear time wherease integrity_check is O(NlogN).
129443 ** SQLite each time a query is executed to ensure that the internal cache
129495 ** Return the names of all compile-time options used in this build,
129576 ** to change and improve over time. Applications should anticipate that
129615 ** since the last time ANALYZE was run.
132817 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
132866 /* At one time, code such as "SELECT new.x" within a trigger would
135093 ** because they could be computed at compile-time. But when LIMIT and OFFSET
135340 jointype = pSubitem->fg.jointype; /* First time through the loop */
135669 ** At the time this function is called it is guaranteed that
135991 ** to sqlite3SelectPrep() and similar a second time. The rewriting done
137381 ** a join. No need to speed time on this operation for non-join queries
138203 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
139282 /* The first time a RETURNING trigger is seen, the "op" value tells
139283 ** us what time of trigger it should be. */
139370 ** This routine makes a copy of the pList, and at the same time expands
139785 ** If there are no triggers that fire at the specified time for the specified
141782 ** time to parse and run the PRAGMA to turn journalling off than it does
142422 ** first time (in other words if the virtual table is actually being
142476 ** the first time the virtual table is used in an SQL statement. This
143430 LogEst rSetup; /* One-time setup cost (ex: create transient index) */
143731 ** pathological queries can spend excess time in the sqlite3WhereBegin()
143946 ** at a time. This routine adds a new term to the end of the expression.
144022 ** defined at compile-time. If it is not a no-op, a single OP_Explain opcode
144692 ** scan loop run twice, once for strings and a second time for BLOBs.
151320 /* TUNING: One-time cost for computing the automatic index is
151765 ** xBestIndex again, this time with IN(...) terms disabled. */
152484 ** will invoke this function a second time, passing the estimate as the
156307 ** Return true if it can be determined at compile time that expression
156356 ** // First time this branch is taken, the eph table contains two
164181 ** the SQLITE_THREADSAFE compile-time option being set to 0.
164272 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
164411 ** compile-time option.
164478 ** the SQLite library at run-time.
164688 /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
164689 ** can be changed at start-time using the
164728 ** negative, then that argument is changed to its compile-time default.
164732 ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
164733 ** compile-time option.
164815 ** both at the same time.
166125 ** a new one that always throws a run-time error.
166268 ** Register a callback to be invoked each time a row is updated,
166293 ** Register a callback to be invoked each time a transaction is rolled
166319 ** Register a callback to be invoked each time a row is updated,
166389 ** Register a callback to be invoked each time a transaction is written
166541 ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
166833 ** there is a hard upper bound set at compile-time by a C preprocessor
167249 /* The SQLITE_DQS compile-time option determines the default settings
167395 ** database schema yet. This is delayed until the first time the database
167420 /* Testing use only!!! The -DSQLITE_ENABLE_INTERNAL_FUNCTIONS=1 compile-time
167844 ** Sleep for a little while. Return the amount of time slept.
168064 ** This action provides a run-time test to see whether or not
168065 ** assert() was enabled at compile-time. If X is true and assert()
168083 ** This action provides a run-time test to see how the ALWAYS and
168084 ** NEVER macros were defined at compile-time.
168097 ** The run-time test procedure might look something like this:
168119 ** 1 big-endian, determined at run-time
168120 ** 10 little-endian, determined at run-time
168121 ** 432101 big-endian, determined at compile-time
168122 ** 123410 little-endian, determined at compile-time
168197 ** too big to test in a reasonable amount of time, so this control is
168250 ** the schema to be reparsed the next time it is needed. This has the
168681 ** Given the name of a compile-time option, return true if that option
168717 ** Return the N-th compile-time option string. If N is out of range,
169134 ** FTS3 used to optionally store character offsets using a compile-time
169320 ** a tiny bit slower (perhaps due to more overhead in merge-time
169324 ** At query time, high MERGE_COUNT increases the number of segments
169420 ** including customization information defined at creation time.
169428 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
169911 ** time must share a common language-id (see the FTS4 langid= feature).
173505 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
173529 ** are merged eight at a time, updating the input segments at the end
179476 ** defined at compilation time, a temporary virtual table (see header
180380 ** by the caller. They are valid from the time SegmentReaderNew() returns
184061 ** This function is called while writing an FTS segment each time a leaf o
185115 ** Incremental merges happen nMin segments at a time. The segments
187399 /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the
188580 ** For the time being, all JSON is stored as pure text. (We might add
191479 ** coordinates within a single R-Tree are always of the same time.
191638 ** and whether or not that determination is run-time or compile-time.
191643 ** at run-time.
191654 # define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */
198431 ** checkpointed each time sqlite3rbu_step() is called. If the RBU
198716 ** time sqlite3rbu_close() is called, various state information is saved
198795 ** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
199057 ** file-system via "rbu" all the time, even if it only uses RBU functionality
200364 ** aiTblOrder[] arrays at the same time. */
201908 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
201914 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
202154 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
204171 ** Return the current time as a Julian Day number in *pTimeOut.
206437 ** time control flows to here they have already been called once from
206705 ** blob each time a NULL value is read from the "idx" column of the
209747 ** again, this time with pbRetry set to NULL.
209754 ** row before invoking this function again, this time with pbReplace set
211658 ** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time
211916 ** compile time default. Zero disables auto-merge altogether.
212214 ** Insert or remove data to or from the index. Each time a document is
214642 ** The first time the bm25() function is called for a query, an instance
217048 ** Populate the pPhrase->poslist buffers at the same time. If any
220056 ** Each time a blob is read from the %_data table, it is padded with this
224126 ** and last leaf page number at the same time. */
225235 ** Insert or remove data to or from the index. Each time a document is
225686 ** a time, and the multi-iter loop from which this function is called
228119 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
229830 ** remove the %_content row at this time though.