Lines Matching defs: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
406 ** We need to define _XOPEN_SOURCE as follows in order to enable
473 ** Sometimes we need a small amount of code such as a variable initialization
1033 ** information need not be flushed. If the lower four bits of the flag
1374 ** SQLite normally do not need to invoke either of these routines.
1404 ** SQLite interfaces so that an application usually does not need to
1559 ** the xInit method, so the xInit method need not be threadsafe. The
1561 ** not need to be threadsafe either. For all other methods, SQLite
2468 ** Applications that need to process SQL from untrusted sources
2730 ** The application does not need to worry about freeing the result.
3095 ** information is in static, unmanaged space and does not need to be freed.
3542 ** need to be added to the string.</li>
3911 ** does not need to be recompiled on each invocation.
3951 ** and will never change. It does not need to be destroyed. ^The
5191 ** The mutex implementation does not need to make a distinction
5732 ** the xInit method, so the xInit method need not be threadsafe. ^The
5734 ** not need to be threadsafe either. All other methods must be threadsafe
5999 ** pages that need to be updated or the size of the source database file
6850 ** This structure records all of the Btrees that need to hold
7006 ** If we are not using shared cache, then there is no need to
8209 ** changes and so the view will need to be reset.
8661 ** transaction, these accesses need to be made via the same database
8797 ** which is attached to the from-table. The to-table need not exist when
8982 ** fields do not need to be freed when deallocating the AggInfo structure.
9021 ** need more than about 10 or 20 variables. But some extreme users want
9380 ** we need a place to cache virtual table index information for each
9547 ** normally coordinate their activities, but we do need to coordinate the
9872 /* The above might be initialized to non-zero. The following need to always
14760 ** The mutex implementation does not need to make a distinction
15067 ** The mutex implementation does not need to make a distinction
15443 ** The mutex implementation does not need to make a distinction
17332 ** not need to contain a lot of randomness since we are not
19948 ** a compelling need to use the wrappers.
19955 ** be exercised on Linux (which does not need to malloc() in the driver)
20454 /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
22136 ** The unixOpenCnt structure keeps a list of file descriptors that need to
23255 ** sitting around that need to be cleared manually.
23294 ** holds a lock on the file. No need to check further. */
23401 ** lock state. No need to mess with the file on disk.
24069 /* Remove the shared lock before trying the range. we'll need to
24575 err = close(pFile->dirfd); /* Only need to sync once, so close the */
24633 ** layers, we need to report this file size as zero even though it is
24856 ** proxy locking is located much further down in the file. But we need
24909 ** that does not need to be locked. */
24959 ** that does not need to be locked. */
25083 ** according to requirement F11141. So we do not need to make a
25958 ** The proxy file and the lock file are never deleted so they only need
26878 ** Some operating systems might need to do some cleanup in this routine,
26916 ** a compelling need to use the wrappers.
26923 ** be exercised on Linux (which does not need to malloc() in the driver)
28050 /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
28752 ** We need to get the full path name of the file
29937 /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
30433 ** not need to be freed.
30917 ** for any subsequent allocations that need to occur.
31411 ** need only update the change-counter once, for the first transaction
31429 ** do not need the PGHDR_NEED_SYNC flag set, as they do not need
31904 ** not need to be synced following this operation.
31929 ** space than that limit allows for, truncate it now. There is no need
32137 ** are within range. To be 'in range', both values need to be a power
32350 ** this happens. TODO: Really, this doesn't need to be cleared
32393 ** the persistent error occurred, then the rollback journal may need
32672 ** it could cause invalid data to be written into the journal. We need to
32788 ** as clean, since there will be no need to write it out to the.
33109 ** present on disk, then the journal is not hot and does not need to be
33171 ** pages that need to be rolled back and that the number of pages
33295 ** journal file. There is no need for a bitvec in this case.
33905 ** * If the journal file is an in-memory journal file, no action need
34244 ** the database image, it may need to be written to the sub-journal.
34672 ** with it under an EXCLUSIVE lock where we do not need to
34984 ** b) When a savepoint is being rolled back and we need to load
35077 ** page that does not need to be journaled. Nevertheless, be sure
35279 ** functions need be called.
35283 ** of the journal file is deferred until there is an actual need to
35441 ** page in the block above, set the need-sync flag for the page.
35958 ** to the database file. So there is no need to zero the journal
35959 ** header. Since the pager is in exclusive mode, there is no need
36166 ** The savepoint to release or rollback need not be the most recently
36353 ** subjournalPage() may need to allocate space to store pPg->pgno into
36371 ** If the isCommit flag is set, there is no need to remember that
36394 ** need to rollback later. Just move the page out of the way. */
36669 ** and thus when they need to flush their cache.
37266 ** which need to be locked after p. If we cannot get a lock on
38697 ** allocation. This routine might need to defragment in order to bring
38826 ** the freelist. So we do need to check for corruption while scanning
40215 ** The isCommit flag indicates that there is no need to remember that
40249 ** pages need to be changed.
40933 ** do not need to be zeroed and they are large, so we can save a lot
42011 ** have been deleted? This API will need to change to return an error code
42627 ** Note that pCell does not necessary need to point to the pPage->aData
43336 ** four bytes of it, and this function does not need the first
43706 ** There are several different types of pointer-map entries that need to
43712 ** been set. We don't need to worry about old siblings that were
43721 ** cells stored on the sibling pages may need to be updated.
43724 ** overflow pages used by these cells may need to be updated
43728 ** entries for the right-child pages of each sibling may need
43781 ** with any child or overflow pages need to be updated. */
44543 ** need to move another root-page to fill a gap left by the deleted
45500 ** If the "temp" database is requested, it may need to be opened by this
45816 ** two extra things may need to happen:
45818 ** * The destination may need to be truncated, and
45821 ** pending-byte page in the source database may need to be
45867 ** no need to check the return values of the btree methods here, as
47966 ** if SQLITE_OMIT_TRACE is defined, the OP_Trace is omitted and we do need to
48816 ** TEMP database) has a transaction active. There is no need for the
49174 ** state. We need to rollback the statement transaction, if there is
49202 /* If the query was read-only, we need do no rollback at all. Otherwise,
49873 ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
50037 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
50941 ** need to call malloc() to expand the result of a zeroblob()
52745 /* Check to see if we need to simulate an interrupt. This only happens
54340 /* Compute in u.am.len the number of bytes of data we need to read in order
55076 ** values need not be contiguous but all P1 values should be small integers.
56983 ** This allows optimizations: (a) when P4==0 there is no need to test
56985 ** (b) when P4==-1 there is no need to insert the value, as it will
56987 ** inserted, there is no need to search to see if the same value was
59376 ** case, we need to return right away and not make any changes to
61794 ** for membership testing only. There is no need to initialize any
61908 /* If the expression is not constant then we will need to
61911 ** expression we need to rerun this code each time.
63190 ** or OP_Variable that does not need to be placed in a
63194 ** expressions that need to be placed in a particular register.
63890 ** for variables that need to be added to the pParse->aAgg[] array.
64185 ** there is no need to worry about syntax like
65825 ** means we do need to fix the database references, FALSE means we do not.
65978 ** systems that do not need this facility may omit it by recompiling
67008 ** and types will be used, so there is no need to test for namespace
67787 ** SQLITE_MASTER table. We just need to update that slot with all
67806 /* Check to see if we need to create an sqlite_sequence table for
67985 /* If we get this far, it means we need to compute the table names.
69200 ** need be.
69323 ** need be. A new entry is created in the SrcList even if pTable is NULL.
69697 ** the way through and which will need to undo some writes without having to
69724 ** perform this abort without corrupting the database, we need to make
69727 ** Technically, we only need to set the mayAbort flag if the
70518 /* We only need to generate a select expression if there
71402 /* We need to prevent a random number of 0x8000000000000000
72866 ** outstanding constraints to resolve. If there are not, there is no need
72870 ** any are, then the constraint is considered satisfied. No need to
74863 ** cursors do not need to be open for indices where aRegIdx[i]==0.
75372 /* Do not need to test for a HAVING clause. If HAVING is present but
76545 ** loading is supported. We need a dummy sqlite3Apis pointer for that
78685 ** while this routine is running. Hence, we do not need to hold
78686 ** locks on the schema, we just need to make sure nobody else is
79270 ** WHERE clause during join processing but we need to remember that they
79772 ** we need to run the sorter and output the results. The following
80571 /* We will need to create our own temporary table to hold the
80621 ** it is that we currently need.
80656 ** by allocating the tables we will need.
82076 /* This statement has already been prepared. There is no need
82136 ** that need expanding.
82148 ** operators that need to be expanded. Loop through each expression
82161 /* This particular expression does not need to be expanded.
82836 /* If there is a GROUP BY clause we might need a sorting index to
82838 ** that we do not need it after all, the OpenEphemeral instruction
82875 ** cancelled later because we still need to use the pKeyInfo
83151 /* If there is an ORDER BY clause, then we need to sort the results
83323 int need; /* Slots needed in p->azResult[] */
83328 ** we need to remember from this invocation of the callback.
83331 need = nCol*2;
83333 need = nCol;
83335 if( p->nData + need > p->nAlloc ){
83337 p->nAlloc = p->nAlloc*2 + need;
84669 int nIdx; /* Number of indices that need updating */
84678 int openAll = 0; /* True if all indices need to be opened */
84743 ** need to occur right after the database cursor. So go ahead and
84909 ** action, then we need to open all indices because we might need
85907 ** SQLITE_MASTER table. We just need to update that slot with all
87210 ** value of the variable means there is no need to invoke the LIKE
87454 ** will correspond to the common table. We still need to check to make
87870 ** index do not need to satisfy this constraint.) The *pbRev value is
87998 ** The results need not be exact. This is only used for estimating
88695 ** CPU and disk I/O need to process the request using the selected plan.
89268 /* Figure out how many memory cells we will need then allocate them.
89330 int bRev; /* True if we need to scan in reverse order */
89858 ** need to be tested later.
90578 ** the table need never be read from. This is a performance boost,
94059 ** an upper-to-lower case map. On EBCDIC machines we also need
94061 ** need to be translated.
95813 ** call will do so. We need to do this before the check for active
96616 ** then any copies made by synthCollSeq() need to be invalidated.
96617 ** Also, collation destructor - CollSeq.xDel() - function may need
97799 /* This occurs when the array of context pointers that need to
98105 ** which need to be scanned and merged. For instance, with 100k docs
98197 ** we will need a way to register the API consistently.
99363 ** headed by node iChild are smaller than zTerm. No need to search
100004 ** b-tree structure to determine which leaves need to be inspected.
103410 /* TODO(shess) Delimiters need to remain the same from run to run,
103411 ** else we need to reindex. One solution would be a meta-table to
106482 Fts3Cursor *pCursor, /* The cursor we need the snippet for */