Lines Matching full: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
8407 ** held by Y.
8573 ** information about each column of an SQL table is held in an instance
9179 #define EP_Static 0x4000 /* Held in memory not obtained from malloc() */
13339 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
13340 ** will already be held (obtained by code in malloc.c) if
13473 ** already held by the caller. Hence "Unsafe".
13555 ** already held by the caller. Hence "Unsafe".
13996 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
13997 ** will already be held (obtained by code in malloc.c) if
15675 ** held by SQLite. An example of non-essential memory is memory used to
15701 ** be held while the callback is running. Recursive calls into
15847 ** lock is already held.
15923 ** for situations where the memory might be held long-term. This
17274 ** mutex is held.
17368 ** must be held while executing this routine.
20232 unsigned char locktype; /* Type of lock currently held on this file */
20471 OSTRACE3( "LOCK %d %d ok (already held)\n", pFile->h, locktype );
20569 /* Update the state of the lock has held in the file descriptor then
20585 ** This routine checks if there is a RESERVED lock held on the specified
20586 ** file by this or any other process. If such a lock is held, return
21484 unsigned char locktype; /* The type of lock held on this fd */
21793 ** is held when required. This function is only used as part of assert()
21985 ** All unique filenames are held on a linked list headed by this
22196 ** to another while locks are held.
22201 ** or if no locks are held. But the unixFile.pLock field needs to be
22256 int cnt; /* Number of SHARED locks held */
22391 ** The mutex entered using the unixEnterMutex() function must be held
22418 ** The mutex entered using the unixEnterMutex() function must be held
22458 ** The mutex entered using the unixEnterMutex() function must be held
22631 ** This routine checks if there is a RESERVED lock held on the specified
22632 ** file by this or any other process. If such a lock is held, set *pResOut
22785 ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
22788 ** within this range, this ensures that no other locks are held on the
22813 OSTRACE3("LOCK %d %s ok (already held) (unix)\n", pFile->h,
22821 ** (3) A shared lock is always held when a reserve lock is requested.
23300 ** This routine checks if there is a RESERVED lock held on the specified
23301 ** file by this or any other process. If such a lock is held, set *pResOut
23307 ** is held on the file and false if the file is unlocked.
23324 /* The lock is held if and only if the lockfile exists */
23486 ** This routine checks if there is a RESERVED lock held on the specified
23487 ** file by this or any other process. If such a lock is held, set *pResOut
23685 ** This routine checks if there is a RESERVED lock held on the specified
23686 ** file by this or any other process. If such a lock is held, set *pResOut
23930 ** This routine checks if there is a RESERVED lock held on the specified
23931 ** file by this or any other process. If such a lock is held, set *pResOut
24012 OSTRACE3("LOCK %d %s ok (already held) (afp)\n", pFile->h,
25499 ** it would not be safe to close as this would release any locks held
25940 ** the above APIs (assuming the conch file is not being held by another
25965 ** is held by another process (with a shared lock), the exclusive lock
26047 int conchHeld; /* True if the conch is currently held */
26812 *(const char **)pArg = ":auto: (not held)";
26867 ** This routine checks if there is a RESERVED lock held on the specified
26868 ** file by this or any other process. If such a lock is held, set *pResOut
27417 unsigned char locktype; /* Type of lock currently held on this file */
28272 ** held by another reader process who will release it momentarily.
28337 /* Update the state of the lock has held in the file descriptor then
28353 ** This routine checks if there is a RESERVED lock held on the specified
28354 ** file by this or any other process. If such a lock is held, return
30174 ** Return the total number of referenced pages held by the cache.
30264 ** The global mutex must be held when accessing nMax.
30493 ** The global mutex must be held when this function is called.
30537 ** The global mutex must be held when this function is called.
30565 ** The global mutex must be held when this function is called.
30598 ** The global mutex must be held when this function is called.
30965 ** held by the pager system. Memory in use by any SQLite pager allocated
31488 ** data held in memory. This is the initial
31616 ** can only happen if an exclusive lock is held on the database file.
32139 ** is still held on the file. If there is a size limit configured for
32987 ** for page 1 which is held in use in order to keep the lock on the
33174 ** held, this function is a no-op. Otherwise, the size of the file is
33513 ** is reset to the value that it held at the start of the savepoint
33803 ** Return a pointer to the "temporary page" buffer held internally
33946 ** a similar or greater lock is already held, this function is a no-op
33973 ** already held, or one of the transistions that the busy-handler
34146 ** page currently held in memory before returning SQLITE_OK. If an IO
34516 ** all information is held in cache. It is never written to disk.
34903 ** pPg->pData. A shared lock or greater must be held on the database
34949 ** has been successfully called. If a shared-lock is already held when
34954 held
35493 ** an EXCLUSIVE lock. If such a lock is already held, no locking
35905 ** direct mode, page 1 is always held in cache and hence the PagerGet()
37196 ** 2) The number of locks held by other connections drops to zero.
37229 BtLock *pLock; /* List of locks held on this shared-btree struct */
37249 u16 nLocal; /* Amount of payload held locally */
37564 ** Return true if the BtShared mutex is held on the btree, or if the
37917 ** the correct locks are held. So do not bother - just return true.
37924 /* Figure out the root-page that the lock should be held on. For table
38111 ** and the requested lock. This means if a write-lock was already held
38126 ** the setSharedCacheTableLock() procedure) held by Btree object p.
38163 ** that writer, then the number of locks held by connections other
38175 ** This function changes all write-locks held by Btree p into read-locks.
38711 int minLocal; /* Minimum amount of payload held locally */
38712 int maxLocal; /* Maximum amount of payload held locally */
39771 ** The call to sqlite3BtreeRollback() drops any table-locks held by
41711 ** Hence, a mutex on the BtShared should be held prior to calling
44550 ** held by open cursors.
45402 ** allocation errors, an error message held in memory obtained from
45756 ** be held when either of these functions are invoked.
46236 ** corresponding to the source database is held when this function is
46265 ** corresponding to the source database is held when this function is
46614 ** Release any memory held by the Mem. This may leave the Mem in an
47209 ** that both the BtShared and database handle mutexes are held. */
48826 ** reduce the amount of memory held by a prepared statement.
48933 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
49601 /* If the auto-commit flag is set to true, then any locks that were held
57067 ** read by this instruction) is currently held, it is necessary to
57071 ** sqlite3BtreeEnterAll(). If all mutexes are not already held, the
57226 ** Insert the integer value held by register P2 into a boolean index
57227 ** held in register P1.
57272 ** the value held in P3, jump to register P2. Otherwise, insert the
58488 /* Make sure a mutex is held on the table to be accessed */
70584 ** Free all resources held by the schema structure. The void* argument points
76827 ** mutex must be held while accessing this list.
79553 ** table is the last entry. The join operator is held in the entry to
83638 ** The result that is written to ***pazResult is held in memory obtained
85792 ** database. No locks are held on any other files (since the main file
85957 ** that contains table p is held by the caller. See header comments
85989 ** shared b-tree databases opened using connection db are held by the
85994 ** associated with the database handle itself must be held.
85998 ** associated with the database the virtual table is stored in is held
86000 ** the database handle mutex is held.
96684 ** deleted when the file is closed) or it an be held entirely in memory.
97864 ** mutex is held.
98034 ** the transaction opened by database db has just finished. Locks held
99150 /* Free any prepared statements held */
105534 ** Release all memory held by the SegmentWriter object passed as the
