Lines Matching refs:need
10 ** This file is all you need to compile SQLite. To use SQLite in other
11 ** programs, you need this file and the "sqlite3.h" header file that defines
1004 ** information need not be flushed. If the lower four bits of the flag
1236 ** do not need this signal should silently ignore this opcode. Applications
1243 ** but before the database is unlocked. VFSes that do not need this signal
1883 ** SQLite normally do not need to invoke either of these routines.
1913 ** SQLite interfaces so that an application usually does not need to
2057 ** the xInit method, so the xInit method need not be threadsafe. The
2059 ** not need to be threadsafe either. For all other methods, SQLite
2734 ** is now scarcely any need to generated database files that are compatible
3435 ** Applications that need to process SQL from untrusted sources
4194 ** The application does not need to worry about freeing the result.
4675 ** connection that are in need of being reset. This can be used,
5394 ** need to be added to the string.</li>
5581 ** all application-defined SQL functions that do not need to be
6113 ** and will never change. It does not need to be destroyed. ^The
6700 ** occur on a different thread. Applications that need to
7513 ** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback
8114 ** The mutex implementation does not need to make a distinction
8935 ** need to be reinitialized each time the statement is run.</dd>
9057 ** so the xInit method need not be threadsafe. ^The
9059 ** not need to be threadsafe either. All other methods must be threadsafe
9705 ** compatibility and as a convenience for applications that need to manually
9706 ** start a callback but which do not need the full power (and corresponding
10030 ** that the query planner does not need the rows to be returned in sorted order
10036 ** that the query planner does not need the rows returned in any particular
10048 ** that the query planner needs only distinct rows but it does need the
12119 ** to be modified, only those fields need to match the original values to
13684 ** We need to define _XOPEN_SOURCE as follows in order to enable
13752 ** Sometimes we need a small amount of code such as a variable initialization
13816 ** defined. We need to defend against those failures when testing with
15796 ** If we are not using shared cache, then there is no need to
16844 ** changes and so the view will need to be reset.
17703 ** transaction, these accesses need to be made via the same database
17892 ** which is attached to the from-table. The to-table need not exist when
18190 ** fields do not need to be freed when deallocating the AggInfo structure.
18231 ** need more than about 10 or 20 variables. But some extreme users want
19002 ** normally coordinate their activities, but we do need to coordinate the
19072 u8 bMaybeNullRow; /* True if we need an OP_IfNullRow check */
19168 ** down to the beginning of the recursive section, do not need to be
19497 /* The above might be initialized to non-zero. The following need to always
24986 ** and we need to know about the failures. Use sqlite3OsFileControlHint()
28282 ** The mutex implementation does not need to make a distinction
28755 static int winMutex_isNt = -1; /* <0 means "need to query" */
28830 ** The mutex implementation does not need to make a distinction
36082 ** concerns, so it does not need an iVersion member. This file is
37909 ** The unixInodeInfo structure keeps a list of file descriptors that need to
39039 ** sitting around that need to be cleared manually.
39173 ** lock state. No need to mess with the file on disk.
39881 /* Remove the shared lock before trying the range. we'll need to
40485 ** descriptor as we need a method to provoke a failure during
40704 ** layers, we need to report this file size as zero even though it is
41476 ** that case, we do not really need shared memory. No shared memory
41684 ** allocated or extended. Technically, we need only write to the
42382 ** proxy locking is located much further down in the file. But we need
42446 ** that does not need to be locked. */
42497 ** that does not need to be locked. */
42630 ** according to requirement F11141. So we do not need to make a
43842 ** The proxy file and the lock file are never deleted so they only need
44316 /* a short read or version format mismatch means we need to create a new
44325 do { /* in case we need to try again for an :auto: named lock file */
44363 /* either the conch didn't match or we need to create a new one */
44489 } while (1); /* in case we need to retry the :auto: lock file -
44742 ** switching proxy locking mode off then it will need to fail if
45061 ** Some operating systems might need to do some cleanup in this routine,
45260 ** Do we need to manually define the Win32 file mapping APIs for use with WAL
45268 ** set we need.
48260 /* No need to log a failure to lock */
48349 /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
49023 /* TBD need to come up with better match here. Perhaps
49927 ** be used. However, we may need to convert the string containing
53396 /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
53807 ** to be serialized already. There is no need for further mutexing.
53876 ** in pcache1 need to be protected via mutex.
54046 ** for all page cache needs and we should not need to spill the
54122 ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */
54192 ** Only scan those hash slots that might contain pages that need to
54282 ** not need to be freed.
54467 ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */
55273 /* Only sort the current set of entries if they need it */
55758 ** commit the transaction. If an error did occur, the caller will need
55964 ** need (and no reason to release them).
55984 ** need only update the change-counter once, for the first transaction
56064 ** and to determine whether or not pages need to be journalled before
56893 ** not need to be synced following this operation.
56919 ** space than that limit allows for, truncate it now. There is no need
57135 ** are within range. To be 'in range', both values need to be a power
57421 ** the persistent error occurred, then the rollback journal may need
57828 ** it could cause invalid data to be written into the journal. We need to
58333 ** present on disk, then the journal is not hot and does not need to be
58393 ** pages that need to be rolled back and that the number of pages
58909 ** journal file. There is no need for a bitvec in this case.
59761 ** * If the journal file is an in-memory journal file, no action need
60735 ** with it under an EXCLUSIVE lock where we do not need to
61034 ** b) When a savepoint is being rolled back and we need to load
61120 ** page that does not need to be journaled. Nevertheless, be sure
61419 ** functions need be called.
61515 ** page in the block above, set the need-sync flag for the page.
61640 ** a sector need to be journalled in case of a power loss in the middle of
61786 ** memory pressure forces page pPg out of the cache, the data does need
62224 ** to the database file. So there is no need to zero the journal
62225 ** header. Since the pager is in exclusive mode, there is no need
62479 ** The savepoint to release or rollback need not be the most recently
62731 ** subjournalPage() may need to allocate space to store pPg->pgno into
62748 ** If the isCommit flag is set, there is no need to remember that
62775 ** need to rollback later. Just move the page out of the way. */
63059 ** is invoked without any intervening transactions. We need to start
63207 ** it may need to be checkpointed before the connection can switch to
63585 ** average, only two or three slots in each index block need to be
64884 ** value of 120, we need to know that so there is an assert() to check it.
66257 ** file that has not yet been checkpointed. This client will not need
66437 ** checkpoint need not have completed for this to cause problems.
67126 /* If this is the end of a transaction, then we might need to pad
67654 ** and thus when they need to flush their cache.
68348 ** which need to be locked after p. If we cannot get a lock on
69373 ** need to be saved. It calls out to saveCursorsOnList() in the (unusual)
69374 ** event that cursors are in need to being saved.
69390 ** The common case is that no cursors need to be saved, so this routine is
70313 ** allocation. This routine might need to defragment in order to bring
72411 ** The isCommit flag indicates that there is no need to remember that
72446 ** pages need to be changed.
72928 ** flag is true, then only write-cursors need be tripped - read-only
73272 ** do not need to be zeroed and they are large, so we can save a lot
73306 /* Since the BtShared is not sharable, there is no need to
73778 ** cursor might be invalid or might need to be restored before being read.
74648 ** have been deleted? This API will need to change to return an error code
75434 ** Note that pCell does not necessary need to point to the pPage->aData
75496 /* If we reach this point, it means that some of the content will need
75720 ** as a contingency. In other words, never need more than 3 overflow
76093 /* No need to use cachedCellSize() here. The sizes of all cells that
76095 ** cells need freeing */
76615 ** four bytes of it, and this function does not need the first
77028 ** associated with the right-child of each sibling may also need to be
78216 ** then balance() will always be a no-op. No need to invoke it. */
79824 ** If the "temp" database is requested, it may need to be opened by this
80236 ** two extra things may need to happen:
80238 ** * The destination may need to be truncated, and
80241 ** pending-byte page in the source database may need to be
80319 ** no need to check the return values of the btree methods here, as
83355 ** below need to be considered. The mkopcodeh.tcl generator script groups
83357 ** any opcode that does not need processing by virtual of the fact that
84399 ** The prepared statements need to know in advance the complete set of
84512 ** This is a high-runner, so only those fields that really do need to
85327 /* Whether or not a database might need a super-journal depends upon
85366 ** TEMP database) has a transaction active. There is no need for the
85700 ** state. We need to rollback the statement transaction, if there is
86204 ** if need be. Return any I/O error from the restore operation.
86732 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
87260 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
88239 ** on value P is not going to be used and need to be destroyed.
89123 ** need to call malloc() to expand the result of a zeroblob()
89693 ** Return true if the prepared statement is in need of being reset.
91146 /* Check to see if we need to simulate an interrupt. This only happens
93252 ** need to cover the header of the record. If pC->aRow does not contain
93394 /* If the column value is a string, we need a persistent value, not
94446 ** values need not be contiguous but all P1 values should be small integers.
96786 ** reads against P3 over to P1, thus possibly avoiding the need to
97411 ** This allows optimizations: (a) when P4==0 there is no need to test
97413 ** (b) when P4==-1 there is no need to insert the value, as it will
97415 ** inserted, there is no need to search to see if the same value was
97725 ** value computed is the total number of rows that will need to be
99970 ** one big PMA using a merge operation. Separate PMAs all need to be
100303 ** case there is no need to make a copy of the data, just return a
104297 ** case, we need to return right away and not make any changes to
105545 ** is not detected until much later, and so we need to go ahead and
107791 ** statement handled by the parser. And so no token need be added
108223 ** allowed it, so we need to support it when reading sqlite_schema for
108497 ** an ephemeral table might need to be generated from the RHS and then
108529 ** might need to know whether or not the RHS side of the IN operator
109011 /* If the expression is not constant then we will need to
109014 ** expression we need to rerun this code each time.
112202 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
113832 /* Find tokens that need to be replaced. */
114224 /* Walker to find tokens that need to be replaced. */
115182 ** added a sample that shares this prefix, there is no need to add
117200 ** systems that do not need this facility may omit it by recompiling
117773 ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set
118752 ** and types will be used, so there is no need to test for namespace
120348 ** schema table. We just need to update that slot with all
120367 /* Check to see if we need to create an sqlite_sequence table for
120573 /* If we get this far, it means we need to compute the table names.
121545 ** The "vtab_err.test" test demonstrates the need of this statement. */
122138 ** need be.
122281 ** need be. A new entry is created in the SrcList even if pTable is NULL.
122692 ** Record the fact that the schema cookie will need to be verified
122737 ** the way through and which will need to undo some writes without having to
122764 ** perform this abort without corrupting the database, we need to make
122767 ** Technically, we only need to set the mayAbort flag if the
123899 /* We only need to generate a select expression if there
124241 /* For ONEPASS, no need to store the rowid/primary-key. There is only
124441 int iIdxNoSeek /* Cursor number of cursor that does not need seeking */
125226 ** However, we still need some kind of function implementation for this
125245 /* We need to prevent a random number of 0x8000000000000000
127467 ** outstanding constraints to resolve. If there are not, there is no need
127471 ** any are, then the constraint is considered satisfied. No need to
128164 /* Create a SrcList structure containing the child table. We need the
130419 if( b2ndPass ) break; /* Never need more than 2 passes */
130524 /* Otherwise, we'll need to run the IndexListTerm array version of the
130569 ** "replace triggers".) If any replace triggers run, we will need to
130643 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
130862 ** (4) No delete triggers need to be fired if there is a conflict
130863 ** (5) No FK constraint counters need to be updated if a conflict occurs.
131434 /* Do not need to test for a HAVING clause. If HAVING is present but
131541 /* Default values for second and subsequent columns need to match. */
131630 ** of index entries might need to change.)
137868 ** while this routine is running. Hence, we do not need to hold
137869 ** locks on the schema, we just need to make sure nobody else is
138600 ** WHERE clause during join processing but we need to remember that they
138679 ** do not need to be concerned with NATURAL joins and we only have
138997 ** in an array of registers. They need to be composed into a record
139005 ** If the new record does not need to be inserted into the sorter,
139173 ** The ephemeral table is not needed. But we do need register
139369 ** and reported later. But we need to make sure enough memory is allocated
139860 ** we need to run the sorter and output the results. The following
140305 ** applications should operate this way. Nevertheless, we need to support the
140966 ** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT
140977 ** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
141184 /* We will need to create our own temporary table to hold the
141237 ** it is that we currently need.
141267 ** by allocating the tables we will need.
141977 ** the left operands of a RIGHT JOIN. In either case, we need to potentially
144111 ** that need expanding.
144124 ** operators that need to be expanded. Loop through each expression
144141 /* This particular expression does not need to be expanded.
145165 ** a join. No need to speed time on this operation for non-join queries
145274 ** it does not need to be computed more than once), and
145335 ** a trigger, then we only need to compute the value of the subquery
145737 /* If there is a GROUP BY clause we might need a sorting index to
145739 ** that we do not need it after all, the OP_SorterOpen instruction
145785 ** cancelled later because we still need to use the pKeyInfo
146108 /* If there is an ORDER BY clause, then we need to sort the results
146205 int need; /* Slots needed in p->azResult[] */
146210 ** we need to remember from this invocation of the callback.
146213 need = nCol*2;
146215 need = nCol;
146217 if( p->nData + need > p->nAlloc ){
146219 p->nAlloc = p->nAlloc*2 + need;
148141 int nIdx; /* Number of indices that need updating */
148256 ** need to occur right after the database cursor. So go ahead and
149496 /* excluded.* columns of type REAL need to be converted to a hard real */
150416 ** schema table. We just need to update that slot with all
151796 Bitmask revMask; /* Mask of ORDER BY terms that need reversing */
152714 /* Figure out how many memory cells we will need then allocate them.
153253 int bRev; /* True if we need to scan in reverse order */
153449 /* These registers need to be preserved in case there is an IN operator
153958 /* pIdx is a covering index. No need to access the main table. */
154250 ** need to insert the key into the temp table, as it will never
154278 ** need to be tested later.
154352 ** a pseudo-cursor. No need to Rewind or Next such cursors. */
154998 ** value of the variable means there is no need to invoke the LIKE
155464 ** will correspond to the common table. We still need to check to make
156424 ** the stack. Many calls to sqlite3WhereExprUsageNN() do not need
156960 ** need to push registers onto the stack as part of its prologue.
158954 ** then those WhereLoops need to be considered separately. Neither is
159813 ** all columns less than 63 (really BMS-1) are covered, so we don't need
159814 ** to check them. But we do need to check any column at 63 or greater.
161068 ** the loop need to be marked as not order-distinct because it can
161322 ** Assume that the total number of output rows that will need to be sorted
162399 ** then we need to rerun the whole loop building process so that all
162612 ** WITHOUT ROWID table. No need for a separate index */
162696 ** optimizations. We need to do an actual sort for RIGHT JOIN. */
163062 /* Do not need to translate the column number */
171704 ** a lookup table is used, all of the classes need to be small integers and
171705 ** all of them need to be used within the switch.
171783 ** an upper-to-lower case map. On EBCDIC machines we also need
173449 ** for modules that need them.
173688 ** to the xInit method, so the xInit method need not be threadsafe.
174652 ** call will do so. We need to do this before the check for active
176167 ** then any copies made by synthCollSeq() need to be invalidated.
176168 ** Also, collation destructor - CollSeq.xDel() - function may need
178340 ** adequate. No need for a binary search. */
178634 /* This occurs when the array of context pointers that need to
178960 ** which need to be scanned and merged. For instance, with 100k docs
179065 ** we will need a way to register the API consistently.
181604 ** headed by node iChild are smaller than zTerm. No need to search
186079 ** integer encountered in state 1 is not 0 or 1, then we need to
189260 /* TODO(shess) Delimiters need to remain the same from run to run,
189261 ** else we need to reindex. One solution would be a meta-table to
193824 ** stored in blob *pNode. The node need not contain any terms, but the
198113 ** need to be folded). Or, if it is set, then the rule only applies to
198600 ** Return the number of consecutive JsonNode slots need to represent
201014 ** If building separately, we will need some setup that is normally
204355 ** This module does not need to do anything to support savepoints. However,
208554 ** can be convenient, as it means that the RBU application does not need to
208660 ** tables, the application may need to call sqlite3_create_module() on
215111 ** This is an eponymous virtual table so it does not need to be created before
231051 /* TODO: Do we need this if the leaf-index is appended? Probably... */
242464 ** need to be folded). Or, if it is set, then the rule only applies to