Lines Matching defs:once
214 ** There was once also a CLANG_VERSION macro. However, we learn that the
1639 ** object once the object has been registered.
2067 ** SQLite will never invoke xInit() more than once without an intervening
3419 ** is invoked once for that table with a column name that is an empty string.
4383 ** be used just once or at most a few times and then destroyed using
4665 ** [prepared statement] S has been stepped at least once using
4768 ** SQL parameter is used more than once, second and subsequent
5987 ** called once for each invocation of the xStep callback and then one
5990 ** implementation is never called and xFinal() is called exactly once.
6075 ** once, when the metadata is discarded.
6540 ** It is intended that this variable be set once
6597 ** It is intended that this variable be set once
7333 ** will be called more than once for each database connection that is opened.
8149 ** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined.
8192 ** ^The xMutexInit routine is called by SQLite exactly once for each
8200 ** interface is invoked exactly once for each call to [sqlite3_shutdown()].
8856 ** to disk all at once. When pages spill mid-transaction, that introduces
9040 ** ^(The xInit() method is called once for each effective
9042 ** (usually only once during the lifetime of the process). ^(The xInit()
9062 ** ^SQLite will never invoke xInit() more than once without an intervening
9243 ** <li><b>sqlite3_backup_init()</b> is called once to initialize the
9490 ** multiple times, it is invoked once with the set of void* context pointers
10093 ** that invokes the [xFilter|xFilter() method] once for each value
10100 ** once. The sqlite3_vtab_in() interfaces facilitates this in two ways:
10106 ** is an [IN operator] that can be processed all at once. ^In other words,
10108 ** by which the virtual table can ask SQLite if all-at-once processing
10114 ** the IN operator all-at-once, respectively. ^Thus when the third
10125 ** that can be processed all-at-once. ^If the constraint is not an IN
10126 ** operator or cannot be processed all-at-once, then the interface returns
10129 ** ^(All-at-once processing of the IN operator is selected if both of the
10162 ** a parameter that was previously selected for all-at-once IN constraint
10165 ** an xFilter argument that was selected for all-at-once IN constraint
11204 ** If xFilter returns 0, changes are not tracked. Note that once a table is
11270 ** recorded once - the first time a row with said primary key is inserted,
11313 ** is written to more than once during a session. For example, if a row
11933 ** so that the accompanying values are as if the row was updated once
12255 ** exactly once before the changeset is committed. If the conflict handler
12861 ** more than once for a single FTS query, then all invocations share a
13029 ** be invoked exactly once for each successful call to xCreate().
13727 ** is significant and used at least once. On switch statements
17188 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
18613 unsigned isOn :1; /* u3.pOn was once valid and non-NULL */
18680 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
19016 ** Parse.pTriggerPrg and deleted once statement compilation has been
26603 ** changed) key chunk once this routine has finished.
28093 ** more than once, the behavior is undefined.
28399 ** more than once, the behavior is undefined.
28921 ** more than once, the behavior is undefined.
29664 ** Hence for a particular database connection, once malloc starts
32718 /* Initialize the state of the random number generator once,
38405 ** lock once every millisecond until either the timeout expires, or until
38421 ** ever obtained is an exclusive lock, and it is obtained exactly once
40504 ** It'd be better to detect fullfsync support once and avoid
41146 ** only once per process.
44930 ** This routine is called once during SQLite initialization and by a
45543 ** The following variable is (normally) set once and never changes
48312 ** erases all locks at once and returns us immediately to locking level 0.
48781 ** log-summary is opened only once per process.
53636 ** Variables isBulkLocal and isAnchor were once type "u8". That works,
55781 ** to read or write data returns an error. Eventually, once all
55984 ** need only update the change-counter once, for the first transaction
56250 ** data that was once in other files that have now been deleted. If the
58021 ** A super-journal file may only be deleted once all of its child
58611 ** This function is invoked once for each page that has already been
58920 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
59082 ** NORMAL The journal is synced once before writes begin on the
61809 ** To avoid excess churning of page 1, the update only happens once.
67080 /* Write all frames into the log file exactly once */
67969 ** may not be modified once it is initially set as long as nRef>0.
67970 ** The pSchema field may be set once under BtShared.mutex and
70950 ** Release a MemPage. This should be called once for each prior
72561 /* If bCommit is zero, this loop runs exactly once and page pLastPg
74939 /* The code within this loop is run only once if the 'searchList' variable
74940 ** is not true. Otherwise, it runs once for each trunk-page on the
75286 ** for now. At some point in the future (once everyone has upgraded
77193 /* All pages have been processed exactly once */
77288 ** to call releasePage() on *ppChild exactly once. If an error occurs,
79771 int bDestLocked; /* True once a write-transaction is open on pDest */
79785 int isAttached; /* True once backup has been registered with pager */
80024 /* This loop runs once for each destination page spanned by the source
83124 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
84758 ** running the code, it invokes the callback once for each instruction.
85003 ** This function may be called exactly once on each virtual machine.
86383 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
88714 ** already been done once on a prior invocation that failed due to
88848 ** is requested more than once within the same run of a single prepared
90321 ** When this global variable is positive, it gets decremented once before
91101 int once = 1;
91112 if( once ) printf("VDBE Query Plan:\n");
91114 once = 0;
97844 ** sqlite3_context only happens once, instead of on each call to the
97892 ** been called at least once prior to any xInverse call. */
103461 ** Walk an expression tree. Invoke the callback once for each node
108099 ** can be added to the pParse->pConstExpr list and evaluated once when
108688 if( mCol & colUsed ) break; /* Each column used only once */
108886 ** If all of the above are false, then we can compute the RHS just once
109013 ** this code only executes once. Because for a non-constant
109106 ** If all of the above are false, then we can run this code just once
110695 ** once. If no functions are involved, then factor the code out and put it at
115778 /* For a single-column UNIQUE index, once we have found a non-NULL
116132 ** This callback is invoked once for each index when reading the
116239 ** once the trailing PK fields are considered all index keys are
116266 ** only once where there exist duplicate prefixes). */
118962 ** The parser calls this routine once for each column declaration
123091 ** This routine is invoked once per CTE by the parser while parsing a
127422 ** affected - once to "delete" the old row, and then again to "insert" the
127648 ** once to "delete" the old row and once to "insert" the new row.
129208 ** once straight down through. Pseudo-code follows (we call this
137681 ** If the same database is attached more than once, the first
140779 ** The setup-query runs once to generate an initial set of rows that go
141927 /* This code runs once to initialize everything.
142326 ** but only has to scan the data once. And because indices might
142759 /* The following loop runs once for each term in a compound-subquery
142762 ** then this loop only runs once.
142958 ** Make sure the same pColumn is not inserted more than once */
145233 /* The code for a subquery should only be generated once. */
145274 ** it does not need to be computed more than once), and
145336 ** once. */
145425 ** changed to an OP_Noop once we figure out that the sorting index is
146031 ** that the accumulator registers are (a) updated only once if
146034 ** least once even if the FILTER clause means the min() or max()
146199 ** This routine is called once for each row in the result table. Its job
151504 ** or all of the WhereLoop objects once.
152805 ** scan loop run twice, once for strings and a second time for BLOBs.
154506 ** been matched at least once.
154517 ** least once. This is accomplished by storing the PK for the row in
158215 ** times (once for each (a,b) combination that matches a=?) is dealt with
159040 /* Stop the search once we hit the query planner search limit */
159450 ** However, the nIn multiplier should only be applied once, not once
160620 /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq)
160709 int once = 1;
160756 }else if( once ){
160758 once = 0;
161320 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
162338 ** FROM ... WHERE random()>0; -- eval random() once per row
162339 ** FROM ... WHERE (SELECT random())>0; -- eval random() once overall
164703 ** aggressively removes rows once they are no longer required, but that's
164706 ** once its window function values have been calculated. Another (end)
165572 ** and invoke the sub-routine at instruction addrGosub once for each row.
165796 ** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE
168682 ** Pop the parser's stack once.
173745 ** reason. So we run it once during initialization.
178604 /* This loop runs once for each entry in the blocked-connections list. */
179124 ** exactly once for each successful call to xCreate().
179141 ** method exactly once for each successful call to xOpen().
181743 ** pEnd once more so that it points to the byte immediately following the
182410 int bWritten = 0; /* True once iDelta has been written */
182751 int bFound = 0; /* True once an index has been found */
184361 /* Advance the iterator for each token in the phrase once. */
184628 ** This function is called once for each AND/NEAR cluster in the
185522 ** words we assume that very common tokens occur exactly once in each
187136 /* This loop runs once for each leaf in the tree of eType nodes. */
189931 ** memory incrementally instead of all at once. This can be a big performance
190099 ** the tree is assembled in memory and written out only once all leaves have
208289 ** single leaf that is modified more than once as part of the transaction
208299 ** exactly once. SQLite uses this trick to improve the performance of
209294 ** in *pz and is decremented once for each character in the integer.
213288 ** locks are no-ops (so that once obtained, these locks are never
216382 ** time control flows to here they have already been called once from
221522 ** more than once for a single FTS query, then all invocations share a
221690 ** be invoked exactly once for each successful call to xCreate().
222389 ** For an insert, it must be called once for each token in the new document.
222390 ** If the operation is a delete, it must be called (at least) once for each
223418 ** Pop the parser's stack once.
224927 Fts5Bm25Data *pData; /* Values allocated/calculated once only */
226102 ** The callback is invoked once for each token in the input text. The
230539 ** Set to true once iterator has reached EOF.
232768 ** always advanced at least once.
233829 ** This is called once for each leaf page except the first that contains
234608 /* Begin scanning through hash table entries. This loop runs once for each
235103 ** it to the output. This can happen at most once for each input
235517 ** For an insert, it must be called once for each token in the new document.
235518 ** If the operation is a delete, it must be called (at least) once for each
244468 ** once prior to any call to stmtColumn() or stmtRowid() or