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
422 ** We need to define _XOPEN_SOURCE as follows in order to enable
489 ** Sometimes we need a small amount of code such as a variable initialization
1105 ** information need not be flushed. If the lower four bits of the flag
1298 ** Some specialized VFSes need this signal in order to operate correctly
1300 ** VFSes do not need this signal and should silently ignore this opcode.
1684 ** SQLite normally do not need to invoke either of these routines.
1714 ** SQLite interfaces so that an application usually does not need to
1855 ** the xInit method, so the xInit method need not be threadsafe. The
1857 ** not need
2842 ** Applications that need to process SQL from untrusted sources
3272 ** The application does not need to worry about freeing the result.
3589 ** connection that are in need of being reset. This can be used,
3706 ** information is in static, unmanaged space and does not need to be freed.
4191 ** need to be added to the string.</li>
4588 ** does not need to be recompiled on each invocation.
4628 ** and will never change. It does not need to be destroyed. ^The
6048 ** The mutex implementation does not need to make a distinction
6623 ** need to be reinitialized each time the statement is run.</dd>
6702 ** so the xInit method need not be threadsafe. ^The
6704 ** not need to be threadsafe either. All other methods must be threadsafe
7017 ** pages that need to be updated or the size of the source database file
8376 ** If we are not using shared cache, then there is no need to
9653 ** changes and so the view will need to be reset.
10107 ** transaction, these accesses need to be made via the same database
10243 ** which is attached to the from-table. The to-table need not exist when
10435 ** fields do not need to be freed when deallocating the AggInfo structure.
10473 ** need more than about 10 or 20 variables. But some extreme users want
10612 #define EP2_MallocedToken 0x0001 /* Need to sqlite3DbFree() Expr.zToken */
10839 ** we need a place to cache virtual table index information for each
11015 ** normally coordinate their activities, but we do need to coordinate the
11357 /* The above might be initialized to non-zero. The following need to always
12788 ** linear search is adequate. No need for a binary search. */
13025 #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
14771 ** and we need to know about the failures. Use sqlite3OsFileControlHint()
17694 ** The mutex implementation does not need to make a distinction
18006 ** The mutex implementation does not need to make a distinction
18416 ** The mutex implementation does not need to make a distinction
20403 ** not need to contain a lot of randomness since we are not
22702 ** a compelling need to use the wrappers.
22709 ** be exercised on Linux (which does not need to malloc() in the driver)
22855 #error Need implementation of sqlite3Hwtime() for your platform.
23226 /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
23771 /* We need some additional space at the end to append the region number */
25203 #error Need implementation of sqlite3Hwtime() for your platform.
25979 ** The unixInodeInfo structure keeps a list of file descriptors that need to
26924 ** sitting around that need to be cleared manually.
26963 ** holds a lock on the file. No need to check further. */
27068 ** lock state. No need to mess with the file on disk.
27784 /* Remove the shared lock before trying the range. we'll need to
28494 ** layers, we need to report this file size as zero even though it is
28889 ** that case, we do not really need shared memory. No shared memory
29470 ** proxy locking is located much further down in the file. But we need
29532 ** that does not need to be locked. */
29585 ** that does not need to be locked. */
29726 ** according to requirement F11141. So we do not need to make a
30741 ** The proxy file and the lock file are never deleted so they only need
31199 /* a short read or version format mismatch means we need to create a new
31208 do { /* in case we need to try again for an :auto: named lock file */
31246 /* either the conch didn't match or we need to create a new one */
31347 /* Need to make a copy of path if we extracted the value
31371 } while (1); /* in case we need to retry the :auto: lock file -
31906 ** Some operating systems might need to do some cleanup in this routine,
32067 #error Need implementation of sqlite3Hwtime() for your platform.
34005 /* No need to log a failure to lock */
34085 /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
34607 /* TBD need to come up with better match here. Perhaps
36762 /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
37017 ** to be serialized already. There is no need for further mutexing.
37046 ** in pcache1 need to be protected via mutex.
37210 ** for all page cache needs and we should not need to spill the
37397 ** not need to be freed.
37991 ** for any subsequent allocations that need to occur.
38714 ** commit the transaction. If an error did occur, the caller will need
38911 ** need (and no reason to release them).
38931 ** need only update the change-counter once, for the first transaction
39009 ** and to determine whether or not pages need to be journalled before
39721 ** not need to be synced following this operation.
39746 ** space than that limit allows for, truncate it now. There is no need
39962 ** are within range. To be 'in range', both values need to be a power
40250 ** the persistent error occurred, then the rollback journal may need
40580 ** it could cause invalid data to be written into the journal. We need to
40721 ** as clean, since there will be no need to write it out to the
41065 ** present on disk, then the journal is not hot and does not need to be
41125 ** pages that need to be rolled back and that the number of pages
41621 ** journal file. There is no need for a bitvec in this case.
42273 ** * If the journal file is an in-memory journal file, no action need
42659 ** the database image, it may need to be written to the sub-journal.
43126 ** with it under an EXCLUSIVE lock where we do not need to
43408 ** b) When a savepoint is being rolled back and we need to load
43494 ** page that does not need to be journaled. Nevertheless, be sure
43665 ** functions need be called.
43818 ** page in the block above, set the need-sync flag for the page.
44406 ** to the database file. So there is no need to zero the journal
44407 ** header. Since the pager is in exclusive mode, there is no need
44641 ** The savepoint to release or rollback need not be the most recently
44837 ** subjournalPage() may need to allocate space to store pPg->pgno into
44855 ** If the isCommit flag is set, there is no need to remember that
44877 ** need to rollback later. Just move the page out of the way. */
45281 ** it may need to be checkpointed before the connection can switch to
45561 ** average, only two or three slots in each index block need to be
48156 /* If this is the end of a transaction, then we might need to pad
48536 ** and thus when they need to flush their cache.
49149 ** which need to be locked after p. If we cannot get a lock on
50521 ** allocation. This routine might need to defragment in order to bring
50650 ** the freelist. So we do need to check for corruption while scanning
52169 ** The isCommit flag indicates that there is no need to remember that
52203 ** pages need to be changed.
52912 ** do not need to be zeroed and they are large, so we can save a lot
53323 /* Need to read this page properly. It contains some of the
54040 ** have been deleted? This API will need to change to return an error code
54683 ** Note that pCell does not necessary need to point to the pPage->aData
55402 ** four bytes of it, and this function does not need the first
55599 ** in this procedure so there is no need to act upon it now.
55797 ** There are several different types of pointer-map entries that need to
55803 ** been set. We don't need to worry about old siblings that were
55812 ** cells stored on the sibling pages may need to be updated.
55815 ** overflow pages used by these cells may need to be updated
55819 ** entries for the right-child pages of each sibling may need
55873 ** with any child or overflow pages need to be updated. */
56652 ** need to move another root-page to fill a gap left by the deleted
57729 ** If the "temp" database is requested, it may need to be opened by this
58097 ** two extra things may need to happen:
58099 ** * The destination may need to be truncated, and
58102 ** pending-byte page in the source database may need to be
58163 ** no need to check the return values of the btree methods here, as
60349 ** if SQLITE_OMIT_TRACE is defined, the OP_Trace is omitted and we do need to
60484 ** The prepared statements need to know in advance the complete set of
61310 ** TEMP database) has a transaction active. There is no need for the
61642 ** state. We need to rollback the statement transaction, if there is
62386 ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
62536 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
63528 ** need to call malloc() to expand the result of a zeroblob()
64039 ** Return true if the prepared statement is in need of being reset.
64882 #error Need implementation of sqlite3Hwtime() for your platform.
65482 /* Check to see if we need to simulate an interrupt. This only happens
67173 /* Compute in u.an.len the number of bytes of data we need to read in order
67950 ** values need not be contiguous but all P1 values should be small integers.
69984 ** This allows optimizations: (a) when P4==0 there is no need to test
69986 ** (b) when P4==-1 there is no need to insert the value, as it will
69988 ** inserted, there is no need to search to see if the same value was
73516 ** case, we need to return right away and not make any changes to
75988 ** for membership testing only. There is no need to initialize any
76111 /* If the expression is not constant then we will need to
76114 ** expression we need to rerun this code each time.
77621 ** or OP_Variable that does not need to be placed in a
77625 ** expressions that need to be placed in a particular register.
78346 ** for variables that need to be added to the pParse->aAgg[] array.
78649 ** there is no need to worry about syntax like
80818 ** means we do need to fix the database references, FALSE means we do not.
80971 ** systems that do not need this facility may omit it by recompiling
82009 ** and types will be used, so there is no need to test for namespace
82794 ** SQLITE_MASTER table. We just need to update that slot with all
82813 /* Check to see if we need to create an sqlite_sequence table for
82991 /* If we get this far, it means we need to compute the table names.
84291 ** need be.
84411 ** need be. A new entry is created in the SrcList even if pTable is NULL.
84799 ** the way through and which will need to undo some writes without having to
84826 ** perform this abort without corrupting the database, we need to make
84829 ** Technically, we only need to set the mayAbort flag if the
85636 /* We only need to generate a select expression if there
86545 /* We need to prevent a random number of 0x8000000000000000
88083 ** outstanding constraints to resolve. If there are not, there is no need
88087 ** any are, then the constraint is considered satisfied. No need to
90110 ** cursors do not need to be open for indices where aRegIdx[i]==0.
90626 /* Do not need to test for a HAVING clause. If HAVING is present but
90745 ** of index entries might need to change.)
91936 ** loading is supported. We need a dummy sqlite3Apis pointer for that
94213 ** while this routine is running. Hence, we do not need to hold
94214 ** locks on the schema, we just need to make sure nobody else is
94795 ** WHERE clause during join processing but we need to remember that they
95387 ** we need to run the sorter and output the results. The following
96205 /* We will need to create our own temporary table to hold the
96258 ** it is that we currently need.
96293 ** by allocating the tables we will need.
97741 /* This statement has already been prepared. There is no need
97801 ** that need expanding.
97813 ** operators that need to be expanded. Loop through each expression
97826 /* This particular expression does not need to be expanded.
98383 ** a trigger, then we only need to compute the value of the subquery
98663 /* If there is a GROUP BY clause we might need a sorting index to
98665 ** that we do not need it after all, the OP_SorterOpen instruction
98703 ** cancelled later because we still need to use the pKeyInfo
98996 /* If there is an ORDER BY clause, then we need to sort the results
99172 int need; /* Slots needed in p->azResult[] */
99177 ** we need to remember from this invocation of the callback.
99180 need = nCol*2;
99182 need = nCol;
99184 if( p->nData + need > p->nAlloc ){
99186 p->nAlloc = p->nAlloc*2 + need;
100553 int nIdx; /* Number of indices that need updating */
100562 int openAll = 0; /* True if all indices need to be opened */
100626 ** need to occur right after the database cursor. So go ahead and
100794 ** action, then we need to open all indices because we might need
101837 ** SQLITE_MASTER table. We just need to update that slot with all
102657 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
102661 #define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */
102662 #define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */
103272 ** value of the variable means there is no need to invoke the LIKE
103517 ** will correspond to the common table. We still need to check to make
104140 ** index do not need to satisfy this constraint.) The *pbRev value is
104275 ** The results need not be exact. This is only used for estimating
106132 /* Figure out how many memory cells we will need then allocate them.
106354 int bRev; /* True if we need to scan in reverse order */
106938 ** need to be tested later.
107754 ** the table need never be read from. This is a performance boost,
111296 ** an upper-to-lower case map. On EBCDIC machines we also need
111298 ** need to be translated.
112625 ** to the xInit method, so the xInit method need not be threadsafe.
113191 ** call will do so. We need to do this before the check for active
114162 ** then any copies made by synthCollSeq() need to be invalidated.
114163 ** Also, collation destructor - CollSeq.xDel() - function may need
115783 /* This occurs when the array of context pointers that need to
116109 ** which need to be scanned and merged. For instance, with 100k docs
116206 ** we will need a way to register the API consistently.
118315 ** headed by node iChild are smaller than zTerm. No need to search
122128 ** integer encountered in state 1 is not 0 or 1, then we need to
124921 /* TODO(shess) Delimiters need to remain the same from run to run,
124922 ** else we need to reindex. One solution would be a meta-table to
