Lines Matching defs:once
978 ** There was once also a CLANG_VERSION macro. However, we learn that the
2298 ** object once the object has been registered.
2726 ** SQLite will never invoke xInit() more than once without an intervening
4065 ** is invoked once for that table with a column name that is an empty string.
5001 ** be used just once or at most a few times and then destroyed using
5265 ** [prepared statement] S has been stepped at least once using
5366 ** SQL parameter is used more than once, second and subsequent
6564 ** called once for each invocation of the xStep callback and then one
6567 ** implementation is never called and xFinal() is called exactly once.
6652 ** once, when the metadata is discarded.
7078 ** It is intended that this variable be set once
7135 ** It is intended that this variable be set once
7778 ** will be called more than once for each database connection that is opened.
8562 ** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined.
8605 ** ^The xMutexInit routine is called by SQLite exactly once for each
8613 ** interface is invoked exactly once for each call to [sqlite3_shutdown()].
9267 ** to disk all at once. When pages spill mid-transaction, that introduces
9439 ** ^(The xInit() method is called once for each effective
9441 ** (usually only once during the lifetime of the process). ^(The xInit()
9461 ** ^SQLite will never invoke xInit() more than once without an intervening
9642 ** <li><b>sqlite3_backup_init()</b> is called once to initialize the
9889 ** multiple times, it is invoked once with the set of void* context pointers
11278 ** If xFilter returns 0, changes are not tracked. Note that once a table is
11344 ** recorded once - the first time a row with said primary key is inserted,
11387 ** is written to more than once during a session. For example, if a row
11991 ** so that the accompanying values are as if the row was updated once
12313 ** exactly once before the changeset is committed. If the conflict handler
12919 ** more than once for a single FTS query, then all invocations share a
13087 ** be invoked exactly once for each successful call to xCreate().
13779 ** is significant and used at least once. On switch statements
17138 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
18492 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
18819 ** Parse.pTriggerPrg and deleted once statement compilation has been
24976 ** changed) key chunk once this routine has finished.
26457 ** more than once, the behavior is undefined.
26763 ** more than once, the behavior is undefined.
27483 ** more than once, the behavior is undefined.
28174 ** Hence for a particular database connection, once malloc starts
30602 /* Initialize the state of the random number generator once,
35439 ** lock once every millisecond until either the timeout expires, or until
35455 ** ever obtained is an exclusive lock, and it is obtained exactly once
37511 ** It'd be better to detect fullfsync support once and avoid
38105 ** only once per process.
41797 ** This routine is called once during SQLite initialization and by a
42578 ** The following variable is (normally) set once and never changes
45340 ** erases all locks at once and returns us immediately to locking level 0.
45809 ** log-summary is opened only once per process.
50298 ** Note: Variables isBulkLocal and isAnchor were once type "u8". That works,
52447 ** to read or write data returns an error. Eventually, once all
52636 ** need only update the change-counter once, for the first transaction
52894 ** data that was once in other files that have now been deleted. If the
54605 ** A super-journal file may only be deleted once all of its child
55188 ** This function is invoked once for each page that has already been
55497 Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
55659 ** NORMAL The journal is synced once before writes begin on the
58359 ** To avoid excess churning of page 1, the update only happens once.
63456 /* Write all frames into the log file exactly once */
64332 ** may not be modified once it is initially set as long as nRef>0.
64333 ** The pSchema field may be set once under BtShared.mutex and
67201 ** Release a MemPage. This should be called once for each prior
68794 /* If bCommit is zero, this loop runs exactly once and page pLastPg
70973 /* The code within this loop is run only once if the 'searchList' variable
70974 ** is not true. Otherwise, it runs once for each trunk-page on the
71320 ** for now. At some point in the future (once everyone has upgraded
73209 /* All pages have been processed exactly once */
73304 ** to call releasePage() on *ppChild exactly once. If an error occurs,
75720 int bDestLocked; /* True once a write-transaction is open on pDest */
75734 int isAttached; /* True once backup has been registered with pager */
75949 /* This loop runs once for each destination page spanned by the source
78957 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
80467 ** running the code, it invokes the callback once for each instruction.
80711 ** This function may be called exactly once on each virtual machine.
82127 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
84466 ** is requested more than once within the same run of a single prepared
85929 ** When this global variable is positive, it gets decremented once before
86682 int once = 1;
86693 if( once ) printf("VDBE Query Plan:\n");
86695 once = 0;
92946 ** sqlite3_context only happens once, instead of on each call to the
92993 ** been called at least once prior to any xInverse call. */
98428 ** Walk an expression tree. Invoke the callback once for each node
102794 ** can be added to the pParse->pConstExpr list and evaluated once when
103340 if( mCol & colUsed ) break; /* Each column used only once */
103536 ** If all of the above are false, then we can compute the RHS just once
103657 ** this code only executes once. Because for a non-constant
103725 ** If all of the above are false, then we can run this code just once
105224 ** once. If no functions are involved, then factor the code out and put it at
106371 /* There was once a NEVER() on the second term on the grounds that
109951 /* For a single-column UNIQUE index, once we have found a non-NULL
110305 ** This callback is invoked once for each index when reading the
110412 ** once the trailing PK fields are considered all index keys are
110439 ** only once where there exist duplicate prefixes). */
112929 ** The parser calls this routine once for each column declaration
116851 ** This routine is invoked once per CTE by the parser while parsing a
121009 ** affected - once to "delete" the old row, and then again to "insert" the
121236 ** once to "delete" the old row and once to "insert" the new row.
122714 ** once straight down through. Pseudo-code follows (we call this
130669 ** If the same database is attached more than once, the first
133475 ** The setup-query runs once to generate an initial set of rows that go
134597 /* This code runs once to initialize everything.
134919 ** but only has to scan the data once. And because indices might
135317 /* The following loop runs once for each term in a compound-subquery
135320 ** then this loop only runs once.
135507 ** Make sure the same pColumn is not inserted more than once */
137448 /* The code for a subquery should only be generated once, though it is
137498 ** it does not need to be computed more than once), and
137561 ** once. */
137646 ** changed to an OP_Noop once we figure out that the sorting index is
138205 ** that the accumulator registers are (a) updated only once if
138208 ** least once even if the FILTER clause means the min() or max()
138359 ** This routine is called once for each row in the result table. Its job
143490 ** or all of the WhereLoop objects once.
144692 ** scan loop run twice, once for strings and a second time for BLOBs.
145877 ** OR clause, since the transformation will become invalid once we
147594 ** In other words, once <e1> has been removed, the inner query
149667 ** times (once for each (a,b) combination that matches a=?) is dealt with
150482 /* Stop the search once we hit the query planner search limit */
150868 ** However, the nIn multiplier should only be applied once, not once
151778 /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq)
151864 int once = 1;
151909 }else if( once ){
151911 once = 0;
152440 ** once. This path is then loaded into the pWInfo->a[].pWLoop fields.
153218 ** FROM ... WHERE random()>0; -- eval random() once per row
153219 ** FROM ... WHERE (SELECT random())>0; -- eval random() once overall
155478 ** aggressively removes rows once they are no longer required, but that's
155481 ** once its window function values have been calculated. Another (end)
156330 ** and invoke the sub-routine at instruction addrGosub once for each row.
156554 ** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE
159410 ** Pop the parser's stack once.
164394 ** reason. So we run it once during initialization.
168969 /* This loop runs once for each entry in the blocked-connections list. */
169489 ** exactly once for each successful call to xCreate().
169506 ** method exactly once for each successful call to xOpen().
172105 ** pEnd once more so that it points to the byte immediately following the
172772 int bWritten = 0; /* True once iDelta has been written */
173113 int bFound = 0; /* True once an index has been found */
174707 /* Advance the iterator for each token in the phrase once. */
174974 ** This function is called once for each AND/NEAR cluster in the
175870 ** words we assume that very common tokens occur exactly once in each
177476 /* This loop runs once for each leaf in the tree of eType nodes. */
180269 ** memory incrementally instead of all at once. This can be a big performance
180437 ** the tree is assembled in memory and written out only once all leaves have
198497 ** single leaf that is modified more than once as part of the transaction
198507 ** exactly once. SQLite uses this trick to improve the performance of
199465 ** in *pz and is decremented once for each character in the integer.
203388 ** locks are no-ops (so that once obtained, these locks are never
206437 ** time control flows to here they have already been called once from
211366 ** more than once for a single FTS query, then all invocations share a
211534 ** be invoked exactly once for each successful call to xCreate().
212218 ** For an insert, it must be called once for each token in the new document.
212219 ** If the operation is a delete, it must be called (at least) once for each
213247 ** Pop the parser's stack once.
214757 Fts5Bm25Data *pData; /* Values allocated/calculated once only */
215922 ** The callback is invoked once for each token in the input text. The
220342 ** Set to true once iterator has reached EOF.
222507 ** always advanced at least once.
223555 ** This is called once for each leaf page except the first that contains
224331 /* Begin scanning through hash table entries. This loop runs once for each
224826 ** it to the output. This can happen at most once for each input
225239 ** For an insert, it must be called once for each token in the new document.
225240 ** If the operation is a delete, it must be called (at least) once for each
234145 ** once prior to any call to stmtColumn() or stmtRowid() or