Lines Matching refs:held
619 ** be held constant and Z will be incremented or else Y will be incremented
3007 ** a mutex is held. A internal mutex is held for a protected
3008 ** sqlite3_value object but no mutex is held for an unprotected
4251 ** that this variable points to is held in memory obtained from
4445 ** held by the database library. Memory used to cache database
5003 ** ^If any writes were made to the BLOB, they might be held in cache
5345 ** is held or not held, respectively, by the calling thread.
5354 ** clearly the mutex cannot be held if it does not exist. But the
8402 ** held by Y.
8568 ** information about each column of an SQL table is held in an instance
9174 #define EP_Static 0x4000 /* Held in memory not obtained from malloc() */
13334 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
13335 ** will already be held (obtained by code in malloc.c) if
13468 ** already held by the caller. Hence "Unsafe".
13550 ** already held by the caller. Hence "Unsafe".
13991 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
13992 ** will already be held (obtained by code in malloc.c) if
15670 ** held by SQLite. An example of non-essential memory is memory used to
15696 ** be held while the callback is running. Recursive calls into
15842 ** lock is already held.
15918 ** for situations where the memory might be held long-term. This
17269 ** mutex is held.
17363 ** must be held while executing this routine.
20227 unsigned char locktype; /* Type of lock currently held on this file */
20466 OSTRACE3( "LOCK %d %d ok (already held)\n", pFile->h, locktype );
20564 /* Update the state of the lock has held in the file descriptor then
20580 ** This routine checks if there is a RESERVED lock held on the specified
20581 ** file by this or any other process. If such a lock is held, return
21479 unsigned char locktype; /* The type of lock held on this fd */
21788 ** is held when required. This function is only used as part of assert()
21980 ** All unique filenames are held on a linked list headed by this
22191 ** to another while locks are held.
22196 ** or if no locks are held. But the unixFile.pLock field needs to be
22251 int cnt; /* Number of SHARED locks held */
22386 held
22413 ** The mutex entered using the unixEnterMutex() function must be held
22453 ** The mutex entered using the unixEnterMutex() function must be held
22626 ** This routine checks if there is a RESERVED lock held on the specified
22627 ** file by this or any other process. If such a lock is held, set *pResOut
22780 ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
22783 ** within this range, this ensures that no other locks are held on the
22808 OSTRACE3("LOCK %d %s ok (already held) (unix)\n", pFile->h,
22816 ** (3) A shared lock is always held when a reserve lock is requested.
23295 ** This routine checks if there is a RESERVED lock held on the specified
23296 ** file by this or any other process. If such a lock is held, set *pResOut
23302 ** is held on the file and false if the file is unlocked.
23319 /* The lock is held if and only if the lockfile exists */
23481 ** This routine checks if there is a RESERVED lock held on the specified
23482 ** file by this or any other process. If such a lock is held, set *pResOut
23680 ** This routine checks if there is a RESERVED lock held on the specified
23681 ** file by this or any other process. If such a lock is held, set *pResOut
23925 ** This routine checks if there is a RESERVED lock held on the specified
23926 ** file by this or any other process. If such a lock is held, set *pResOut
24007 OSTRACE3("LOCK %d %s ok (already held) (afp)\n", pFile->h,
25494 ** it would not be safe to close as this would release any locks held
25935 ** the above APIs (assuming the conch file is not being held by another
25960 ** is held by another process (with a shared lock), the exclusive lock
26042 int conchHeld; /* True if the conch is currently held */
26807 *(const char **)pArg = ":auto: (not held)";
26862 ** This routine checks if there is a RESERVED lock held on the specified
26863 ** file by this or any other process. If such a lock is held, set *pResOut
27412 unsigned char locktype; /* Type of lock currently held on this file */
28267 ** held by another reader process who will release it momentarily.
28332 /* Update the state of the lock has held in the file descriptor then
28348 ** This routine checks if there is a RESERVED lock held on the specified
28349 ** file by this or any other process. If such a lock is held, return
30169 ** Return the total number of referenced pages held by the cache.
30259 ** The global mutex must be held when accessing nMax.
30488 ** The global mutex must be held when this function is called.
30532 ** The global mutex must be held when this function is called.
30560 ** The global mutex must be held when this function is called.
30593 ** The global mutex must be held when this function is called.
30960 ** held by the pager system. Memory in use by any SQLite pager allocated
31483 ** data held in memory. This is the initial
31611 ** can only happen if an exclusive lock is held on the database file.
32134 ** is still held on the file. If there is a size limit configured for
32982 ** for page 1 which is held in use in order to keep the lock on the
33169 ** held, this function is a no-op. Otherwise, the size of the file is
33508 ** is reset to the value that it held at the start of the savepoint
33798 ** Return a pointer to the "temporary page" buffer held internally
33941 ** a similar or greater lock is already held, this function is a no-op
33968 ** already held, or one of the transistions that the busy-handler
34141 ** page currently held in memory before returning SQLITE_OK. If an IO
34511 ** all information is held in cache. It is never written to disk.
34898 ** pPg->pData. A shared lock or greater must be held on the database
34944 ** has been successfully called. If a shared-lock is already held when
34949 ** 1) If the pager is currently in PAGER_UNLOCK state (no lock held
35488 ** an EXCLUSIVE lock. If such a lock is already held, no locking
35900 ** direct mode, page 1 is always held in cache and hence the PagerGet()
37191 ** 2) The number of locks held by other connections drops to zero.
37224 BtLock *pLock; /* List of locks held on this shared-btree struct */
37244 u16 nLocal; /* Amount of payload held locally */
37559 ** Return true if the BtShared mutex is held on the btree, or if the
37912 ** the correct locks are held. So do not bother - just return true.
37919 /* Figure out the root-page that the lock should be held on. For table
38106 ** and the requested lock. This means if a write-lock was already held
38121 ** the setSharedCacheTableLock() procedure) held by Btree object p.
38158 ** that writer, then the number of locks held by connections other
38170 ** This function changes all write-locks held by Btree p into read-locks.
38706 int minLocal; /* Minimum amount of payload held locally */
38707 int maxLocal; /* Maximum amount of payload held locally */
39766 ** The call to sqlite3BtreeRollback() drops any table-locks held by
41700 ** Hence, a mutex on the BtShared should be held prior to calling
44539 ** held by open cursors.
45391 ** allocation errors, an error message held in memory obtained from
45745 ** be held when either of these functions are invoked.
46225 ** corresponding to the source database is held when this function is
46254 ** corresponding to the source database is held when this function is
46603 ** Release any memory held by the Mem. This may leave the Mem in an
47198 ** that both the BtShared and database handle mutexes are held. */
48815 ** reduce the amount of memory held by a prepared statement.
48922 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
49590 /* If the auto-commit flag is set to true, then any locks that were held
57056 ** read by this instruction) is currently held, it is necessary to
57060 ** sqlite3BtreeEnterAll(). If all mutexes are not already held, the
57215 ** Insert the integer value held by register P2 into a boolean index
57216 ** held in register P1.
57261 ** the value held in P3, jump to register P2. Otherwise, insert the
58477 /* Make sure a mutex is held on the table to be accessed */
70573 ** Free all resources held by the schema structure. The void* argument points
76816 ** mutex must be held while accessing this list.
79542 ** table is the last entry. The join operator is held in the entry to
83627 ** The result that is written to ***pazResult is held in memory obtained
85781 ** database. No locks are held on any other files (since the main file
85946 ** that contains table p is held by the caller. See header comments
85978 ** shared b-tree databases opened using connection db are held by the
85983 ** associated with the database handle itself must be held.
85987 ** associated with the database the virtual table is stored in is held
85989 ** the database handle mutex is held.
96671 ** deleted when the file is closed) or it an be held entirely in memory.
97830 ** mutex is held.
98000 ** the transaction opened by database db has just finished. Locks held
99116 /* Free any prepared statements held */
105494 ** Release all memory held by the SegmentWriter object passed as the
