Lines Matching refs:shared
1325 ** write ahead log and shared memory files used for transaction control
1330 ** to read the database file, as the WAL and shared memory files must exist
1653 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1656 ** The xShmLock method can transition between unlocked and SHARED or
1657 ** between unlocked and EXCLUSIVE. It cannot transition between SHARED
3064 ** eligible to use [shared cache mode], regardless of whether or not shared
3067 ** participate in [shared cache mode] even if it is enabled.
3140 ** <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
3141 ** "private". ^Setting it to "shared" is equivalent to setting the
3175 ** Regardless of whether or not shared-cache mode is enabled by
5178 ** CAPI3REF: Enable Or Disable Shared Pager Cache
5179 ** KEYWORDS: {shared cache}
5195 ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
5198 ** ^Shared cache is disabled by default. But this might change in
5199 ** future releases of SQLite. Applications that care about shared
5202 ** See Also: [SQLite Shared-Cache Mode]
5400 const char *zFile, /* Name of the shared library containing extension */
6537 ** schema memory is shared with other database connections due to
6538 ** [shared cache mode] being enabled.
6970 ** sqlite3_backup_step() obtains a [shared lock] on the source database that
7037 ** If running in [shared cache mode], the application must
7038 ** guarantee that the shared cache used by the destination database
7065 ** ^When running in shared-cache mode, a database operation may fail with
7066 ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
7067 ** individual tables within the shared-cache cannot be obtained. See
7068 ** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
7076 ** ^Shared-cache locks are released when a database connection concludes
7080 ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
7097 ** shared-cache table, and more than one other connection currently holds
8376 ** If we are not using shared cache, then there is no need to
9370 ** SHARED: Any number of processes may hold a SHARED lock simultaneously.
9372 ** any time. Other processes may hold and obtain new SHARED locks.
9374 ** any one time. Existing SHARED locks may persist, but no new
9375 ** SHARED locks may be obtained by other processes.
9417 ** a random byte is selected for a shared lock. The pool of bytes for
9418 ** shared locks begins at SHARED_FIRST.
9422 ** clients on win95, winNT, and unix all talking to the same shared file
9602 Schema *pSchema; /* Pointer to database schema (possibly shared) */
9610 ** In shared cache mode, a single Schema object can be shared by multiple
9680 ** be stored in lookaside because in shared cache mode the schema information
9681 ** is shared by multiple database connections. Therefore, while parsing
9748 void **aExtension; /* Array of shared library handles */
9843 #define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */
10096 ** If the database schema is shared, then there is one instance of this
10097 ** structure for each database connection (sqlite3*) that uses the shared
10100 ** implementation. sqlite3_vtab* handles can not be shared between
10102 ** schema is shared, as the implementation often stores the database
10110 ** All VTable objects that correspond to a single table in a shared
11077 ** The nTableLock and aTableLock variables are only used if the shared-cache
11125 TableLock *aTableLock; /* Required table locks for shared-cache mode */
11356 int sharedCacheEnabled; /* true if shared-cache mode enabled */
22941 typedef struct os2ShmNode os2ShmNode; /* A shared descritive memory node */
22942 typedef struct os2ShmLink os2ShmLink; /* A connection to shared-memory */
22955 os2ShmLink *pShmLink; /* Instance of shared memory on this file */
23187 ** UNLOCKED -> SHARED
23188 ** SHARED -> RESERVED
23189 ** SHARED -> (PENDING) -> EXCLUSIVE
23227 ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
23247 shared lock
23255 OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
23312 OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
23623 ** Object used to represent a the shared memory area for a single log file.
23649 int szRegion; /* Size of shared-memory regions */
23652 void **apRegion; /* Array of pointers to shared-memory regions */
23664 ** open shared memory connection.
23678 u32 sharedMask; /* Mask of shared locks held */
23708 #define _SHM_RDLCK 2 /* shared lock, no wait */
23712 os2ShmNode *pNode, /* Apply locks to this open shared-memory segment */
23724 mode = 1; /* shared lock */
23759 ** This is not a VFS shared-memory method; it is a utility function called
23760 ** by VFS shared-memory methods.
23776 /* Replace colon in file name to form a valid shared memory name */
23787 /* Find node by it's shared memory base name */
23864 ** This is not a VFS shared-memory method; it is a utility function called
23865 ** by VFS shared-memory methods.
23882 /* Prevent other processes from resizing the shared memory */
23896 /* Allow other processes to resize the shared memory */
23930 ** shared-memory associated with the database file id. Shared-memory regions
23931 ** are numbered starting from zero. Each shared-memory region is szRegion
23936 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
23939 ** bExtend is non-zero and the requested shared-memory region has not yet
23942 ** If the shared-memory region has already been allocated or is allocated by
23975 /* Prevent other processes from resizing the shared memory */
24015 /* Allow other processes to resize the shared memory */
24033 ** Close a connection to shared-memory. Delete the underlying
24036 ** If there is no shared memory associated with the connection then this
24041 int deleteFlag /* Delete shared-memory if true */
24080 ** Change the lock state for a shared-memory segment.
24082 ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
24084 ** to shared and back or from unlocked to exclusive and back. But one may
24085 ** not go from shared to exclusive or from exclusive to shared.
24088 sqlite3_file *id, /* Database file holding the shared memory */
24096 os2ShmLink *p = pFile->pShmLink; /* The shared memory being locked */
24139 /* Find out which shared locks are already held by sibling connections.
24151 /* Get shared locks at the system level, if necessary */
24160 /* Get the local shared locks */
24200 ** Implement a memory barrier or memory fence on shared memory.
24206 sqlite3_file *id /* Database file holding the shared memory */
24555 ** Interfaces for opening a shared library, finding entry points
24556 ** within the shared library, and closing the shared library.
24559 ** Interfaces for opening a shared library, finding entry points
24560 ** within the shared library, and closing the shared library.
24993 typedef struct unixShm unixShm; /* Connection shared memory */
24994 typedef struct unixShmNode unixShmNode; /* Shared memory instance */
25026 unixShm *pShm; /* Shared memory segment information */
25577 ** shared by multiple threads.
25609 case SHARED_LOCK: return "SHARED";
25963 ** cnt>0 means there are cnt shared locks on the file.
26028 int nShared; /* Number of SHARED locks held */
26032 unixShmNode *pShmNode; /* Shared memory associated with this inode */
26038 unsigned long long sharedByte; /* for AFP simulated shared lock */
26291 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
26385 ** UNLOCKED -> SHARED
26386 ** SHARED -> RESERVED
26387 ** SHARED -> (PENDING) -> EXCLUSIVE
26396 ** lock transitions in terms of the POSIX advisory shared and exclusive
26403 ** byte', each single bytes at well known offsets, and the 'shared byte
26406 ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
26407 ** byte'. If this is successful, a random byte from the 'shared byte
26410 ** A process may only obtain a RESERVED lock after it has a SHARED lock.
26415 ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
26416 ** on the 'pending byte'. This ensures that no new SHARED locks can be
26417 ** obtained, but existing SHARED locks are allowed to persist. A process
26423 ** implemented by obtaining a write-lock on the entire 'shared byte
26428 ** The reason a single byte cannot be used instead of the 'shared byte
26430 ** locking a random byte from a range, concurrent SHARED locks may exist
26455 ** (1) We never move from unlocked to anything higher than shared lock.
26457 ** (3) A shared lock is always held when a reserve lock is requested.
26463 /* This mutex is needed because pFile->pInode is shared across threads
26478 /* If a SHARED lock is requested, and some thread using this PID already
26479 ** has a SHARED or RESERVED lock, then increment reference counts and
26494 /* A PENDING lock is needed before acquiring a SHARED lock and before
26495 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
26554 ** same process is still holding a shared lock. */
26558 ** assumed that there is a SHARED or greater lock on the file
26585 ** transitioning from a SHARED to a RESERVED lock. The change
26586 ** from SHARED to RESERVED marks the beginning of a normal
26635 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
26674 /* downgrading to a shared lock on NFS involves clearing the write lock
26763 /* Decrement the shared lock counter. Release the lock using an
26932 ** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
26990 ** UNLOCKED -> SHARED
26991 ** SHARED -> RESERVED
26992 ** SHARED -> (PENDING) -> EXCLUSIVE
27067 /* To downgrade to shared, simply update our internal notion of the
27117 ** a single exclusive lock. In other words, SHARED, RESERVED, and
27215 ** UNLOCKED -> SHARED
27216 ** SHARED -> RESERVED
27217 ** SHARED -> (PENDING) -> EXCLUSIVE
27222 ** lock states in the sqlite3_file structure, but all locks SHARED or
27286 /* shared can just be set because we always have an exclusive */
27391 ** UNLOCKED -> SHARED
27392 ** SHARED -> RESERVED
27393 ** SHARED -> (PENDING) -> EXCLUSIVE
27398 ** lock states in the sqlite3_file structure, but all locks SHARED or
27454 /* shared can just be set because we always have an exclusive */
27595 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
27642 ** UNLOCKED -> SHARED
27643 ** SHARED -> RESERVED
27644 ** SHARED -> (PENDING) -> EXCLUSIVE
27673 ** (1) We never move from unlocked to anything higher than shared lock.
27675 ** (3) A shared lock is always held when a reserve lock is requested.
27681 /* This mutex is needed because pFile->pInode is shared across threads
27696 /* If a SHARED lock is requested, and some thread using this PID already
27697 ** has a SHARED or RESERVED lock, then increment reference counts and
27711 /* A PENDING lock is needed before acquiring a SHARED lock and before
27712 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
27765 ** same process is still holding a shared lock. */
27769 ** assumed that there is a SHARED or greater lock on the file
27784 /* Remove the shared lock before trying the range. we'll need to
27785 ** reestablish the shared lock if we can't get the afpUnlock
27795 /* Can't reestablish the shared lock. Sqlite can't deal, this is
27879 /* only re-establish the shared lock if necessary */
27901 /* Decrement the shared lock counter. Release the lock using an
28680 ** Object used to represent an shared memory buffer.
28689 ** every open file that does not use shared memory (in other words, most
28713 int szRegion; /* Size of shared-memory regions */
28716 char **apRegion; /* Array of mapped shared-memory regions */
28721 u8 sharedMask; /* Mask of shared locks held */
28728 ** open shared memory connection.
28744 u16 sharedMask; /* Mask of shared locks held */
28761 unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
28772 /* Shared locks never span more than one byte */
28832 ** This is not a VFS shared-memory method; it is a utility function called
28833 ** by VFS shared-memory methods.
28860 ** Open a shared-memory area associated with open database file pDbFd.
28863 ** The file used to implement shared-memory is in the same directory
28867 ** for shared memory will be called "/home/user1/config.db-shm".
28873 ** database to end up using different files for shared memory -
28874 ** meaning that their memory would not really be shared - resulting
28884 ** When opening a new shared-memory file, if no other instances of that
28891 ** that case, we do not really need shared memory. No shared memory
28892 ** file is created. The shared memory will be simulated with heap memory.
29026 ** shared-memory associated with the database file fd. Shared-memory regions
29027 ** are numbered starting from zero. Each shared-memory region is szRegion
29032 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
29035 ** bExtend is non-zero and the requested shared-memory region has not yet
29038 ** If the shared-memory region has already been allocated or is allocated by
29055 /* If the shared-memory file has not yet been opened, open it now. */
29147 ** Change the lock state for a shared-memory segment.
29149 ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
29151 ** to shared and back or from unlocked to exclusive and back. But one may
29152 ** not go from shared to exclusive or from exclusive to shared.
29155 sqlite3_file *fd, /* Database file holding the shared memory */
29160 unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */
29161 unixShm *p = pDbFd->pShm; /* The shared memory being locked */
29207 /* Find out which shared locks are already held by sibling connections.
29219 /* Get shared locks at the system level, if necessary */
29228 /* Get the local shared locks */
29261 ** Implement a memory barrier or memory fence on shared memory.
29267 sqlite3_file *fd /* Database file holding the shared memory */
29275 ** Close a connection to shared-memory. Delete the underlying
29278 ** If there is no shared memory associated with the connection then this
29283 int deleteFlag /* Delete shared-memory if true */
29286 unixShmNode *pShmNode; /* The underlying shared-memory file */
29310 ** shared-memory file, too */
29406 2, /* shared memory is enabled */
29415 1, /* shared memory is disabled */
29424 1, /* shared memory is disabled */
29435 1, /* shared memory is disabled */
29447 1, /* shared memory is disabled */
29459 1, /* shared memory is disabled */
29484 1, /* shared memory is disabled */
29497 1, /* shared memory is disabled */
30419 ** Interfaces for opening a shared library, finding entry points
30420 ** within the shared library, and closing the shared library.
30647 ** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
30651 ** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
30652 ** address in the shared range is taken for a SHARED lock, the entire
30653 ** shared range is taken for an EXCLUSIVE lock):
30719 ** by taking an sqlite-style shared lock on the conch file, reading the
30727 ** path and the lock is downgraded to a shared lock again. If the conch
30728 ** is held by another process (with a shared lock), the exclusive lock
30740 ** The shared lock and an open file descriptor are maintained until
31155 /* Takes the conch by taking a shared lock and read the contents conch, if
31256 ** has a shared lock already), if the host id matches, use the big
31263 ** same process is still holding a shared lock. */
31701 ** UNLOCKED -> SHARED
31702 ** SHARED -> RESERVED
31703 ** SHARED -> (PENDING) -> EXCLUSIVE
32161 typedef struct winShm winShm; /* A connection to shared-memory */
32162 typedef struct winShmNode winShmNode; /* A region of shared-memory */
32187 short sharedLockByte; /* Randomly chosen byte used as a shared lock */
32190 winShm *pShm; /* Instance of shared memory on this file */
32195 HANDLE hMutex; /* Mutex used to control access to shared lock */
32196 HANDLE hShared; /* Shared memory segment used for locking */
32198 winceLock *shared; /* Global shared lock memory for the file */
33389 ** Create the mutex and shared memory used for locking in the file
33427 ** and using that as the shared filemapping name.
33442 /* If we succeeded in making the shared memory handle, map it. */
33444 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
33446 /* If mapping failed, close the shared memory handle and erase it */
33447 if (!pFile->shared){
33456 /* If shared memory could not be created, then close the mutex and fail */
33464 /* Initialize the shared memory if we're supposed to */
33466 memset(pFile->shared, 0, sizeof(winceLock));
33484 pFile->shared->nReaders --;
33487 pFile->shared->bReserved = FALSE;
33490 pFile->shared->bPending = FALSE;
33493 pFile->shared->bExclusive = FALSE;
33496 /* De-reference and close our copy of the shared memory handle */
33497 osUnmapViewOfFile(pFile->shared);
33529 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
33530 pFile->shared->bExclusive = TRUE;
33539 if (pFile->shared->bExclusive == 0){
33542 pFile->shared->nReaders ++;
33551 if (pFile->shared->bPending == 0) {
33552 pFile->shared->bPending = TRUE;
33560 if (pFile->shared->bReserved == 0) {
33561 pFile->shared->bReserved = TRUE;
33596 pFile->shared->bExclusive = FALSE;
33606 pFile->shared->nReaders --;
33616 pFile->shared->bPending = FALSE;
33624 pFile->shared->bReserved = FALSE;
33647 /* If the caller wants a shared read lock, forward this call
34050 ** UNLOCKED -> SHARED
34051 ** SHARED -> RESERVED
34052 ** SHARED -> (PENDING) -> EXCLUSIVE
34088 ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
34113 /* Acquire a shared lock
34368 ** this file, all of which may be shared by multiple threads.
34392 ** shared memory. When multiple threads all reference the same
34418 int szRegion; /* Size of shared-memory regions */
34443 ** open shared memory connection.
34458 u16 sharedMask; /* Mask of shared locks held */
34478 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
34527 ** This is not a VFS shared-memory method; it is a utility function called
34528 ** by VFS shared-memory methods.
34572 ** Open the shared-memory area associated with database file pDbFd.
34574 ** When opening a new shared-memory file, if no other instances of that
34688 ** Close a connection to shared-memory. Delete the underlying
34692 sqlite3_file *fd, /* Database holding shared memory */
34695 winFile *pDbFd; /* Database holding shared-memory */
34697 winShmNode *pShmNode; /* The underlying shared-memory file */
34717 ** shared-memory file, too */
34730 ** Change the lock state for a shared-memory segment.
34733 sqlite3_file *fd, /* Database file holding the shared memory */
34738 winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */
34739 winShm *p = pDbFd->pShm; /* The shared memory being locked */
34781 /* Find out which shared locks are already held by sibling connections.
34793 /* Get shared locks at the system level, if necessary */
34802 /* Get the local shared locks */
34836 ** Implement a memory barrier or memory fence on shared memory.
34842 sqlite3_file *fd /* Database holding the shared memory */
34852 ** shared-memory associated with the database file fd. Shared-memory regions
34853 ** are numbered starting from zero. Each shared-memory region is szRegion
34858 ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
34861 ** isWrite is non-zero and the requested shared-memory region has not yet
34864 ** If the shared-memory region has already been allocated or is allocated by
35575 ** Interfaces for opening a shared library, finding entry points
35576 ** within the shared library, and closing the shared library.
35579 ** Interfaces for opening a shared library, finding entry points
35580 ** within the shared library, and closing the shared library.
38447 ** WAL module is using shared-memory, return false.
38546 ** (13) A SHARED lock is held on the database file while reading any
38637 ** * A SHARED or greater lock is held on the database file.
38820 ** in the file-system that needs to be rolled back (as part of a OPEN->SHARED
38837 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
39404 p->eLock==SHARED_LOCK ? "SHARED" :
40431 ** connection to obtain a shared lock on the pager (which may be this one)
41237 ** pPg->pData. A shared lock or greater must be held on the database
41556 ** The caller must hold a SHARED lock on the database file to call this
41871 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
41874 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
43143 ** This function is called to obtain a shared lock on the database file.
43145 ** has been successfully called. If a shared-lock is already held when
43152 ** SHARED lock on the database file. Immediately after obtaining
43153 ** the SHARED lock, the file-system is checked for a hot-journal,
43303 /* The shared-lock has just been acquired on the database file
45192 ** in. Otherwise, use the normal shared-memory.
45201 ** heap-memory for the wal-index instead of the VFS shared-memory
45224 ** The caller must be holding a SHARED lock on the database file to call
45476 ** Conceptually, the wal-index is shared memory, though VFS implementations
45478 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
45685 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
46114 ** Set or release locks on the WAL. Locks are either shared or exclusive.
46115 ** A lock cannot be moved directly between shared and exclusive - it must go
46125 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
46134 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
46586 ** A SHARED lock should be held on the database file when this function
46587 ** is called. The purpose of this SHARED lock is to prevent any other
47230 ** The wal-index is in shared memory. Another thread or process might
47246 WalIndexHdr volatile *aHdr; /* Header in shared memory */
47252 ** same area of shared memory on a different CPU in a SMP,
47470 ** code that determines whether or not the shared-memory region
47564 ** between the time it was read and when the shared-lock was obtained
48411 ** WAL module is using shared-memory, return false.
48782 ** shared between multiple connections. In that case, each connection
48812 ** If the shared-data extension is enabled, there may be multiple users
48841 ** the shared-cache enters 'pending-lock' state and isPending is
48844 ** The shared-cache leaves the 'pending lock' state when either of
48883 BtLock *pLock; /* List of locks held on this shared-btree struct */
48935 ** A single database file can be shared by two more database connections,
48936 ** but cursors cannot be shared. Each cursor is associated with a
49162 ** the same connection. Only shared Btrees are on the list. */
49354 ** in single threaded applications that use shared cache. Except for
49358 ** If shared cache is disabled, then all btree mutex routines, including
49426 ** in shared cache. This variable has file scope during normal builds,
49441 ** Enable or disable the shared pager and schema features.
49444 ** The shared cache setting effects only future calls to
49460 ** shared-cache table level locks. If the library is compiled with the
49461 ** shared-cache feature disabled, then there is only ever one user
49565 ** table or index rooted at iRoot because other shared connections are
49615 /* This routine is a no-op if the shared-cache is not enabled */
49655 ** Add a lock on the table with root-page iTable to the shared-btree used
49820 ** on the shared btree structure pBt.
51071 ** and we are in shared cache mode, then the open will fail with an
51084 BtShared *pBt = 0; /* Shared part of btree structure */
51134 ** If this Btree is a candidate for shared cache, try to find an
51326 ** default value. Except, when opening on an existing shared pager-cache,
51424 /* If there are still other outstanding references to the shared-btree
51426 ** up the shared-btree.
51946 ** on this shared-btree structure and a second write transaction is
51970 ** page 1. So if some other shared-cache client already has a write-lock
52532 ** transaction count of the shared btree. If the transaction count
52533 ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
52584 /* If the handle has a write-transaction open, commit the shared-btrees
52585 ** transaction and set the shared state to TRANS_READ.
52841 BtShared *pBt = p->pBt; /* Shared b-tree handle */
57442 ** transaction on the shared-cache the argument Btree is connected to.
57479 ** a single shared-btree. The memory is used by client code for its own
57481 ** the shared-btree). The btree layer manages reference counting issues.
57483 ** The first time this is called on a shared-btree, nBytes bytes of memory
57492 ** Just before the shared-btree is closed, the function passed as the
57509 ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared
60502 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
60508 ** If SQLite is not threadsafe but does support shared-cache mode, then
60513 ** If SQLite is not threadsafe and does not support shared-cache mode, this
60518 ** corresponding to btrees that use shared cache. Then the runtime of
67666 ** there are active writing VMs or active VMs that use shared cache.
70475 ** in temporary storage or if the VFS does not support shared memory
70479 || !sqlite3PagerWalSupported(u.ci.pPager)) /* No shared-memory support */
70597 ** the shared-cache feature is enabled.
79764 /* Establish a read-lock on the table at the shared-cache level. */
81387 ** shared-cache feature is enabled.
82757 ** A shared-cache write-lock is not required to write to the new table,
87343 ** A function that loads a shared-library extension then returns NULL.
88536 /* Take a shared-cache advisory read-lock on the parent table. Allocate
91000 ** shared libraries that want to be imported as extensions into
91001 ** an SQLite instance. Shared libraries that intend to be loaded
91017 ** versions of SQLite will not be able to load each others' shared
91813 const char *zFile, /* Name of the shared library containing extension */
91849 "unable to open shared library [%s]", zFile);
91863 "no entry point [%s] in shared library [%s]", zProc,zFile);
91878 /* Append the new shared library handle to the db->aExtension array. */
91894 const char *zFile, /* Name of the shared library containing extension */
91951 ** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER
93563 "unlocked", "shared", "reserved", "pending", "exclusive"
101664 ** shared b-tree databases opened using connection db are held by the
114449 { "shared", SQLITE_OPEN_SHAREDCACHE },
115650 ** (call it pOther) in the same process was busy using the same shared
115983 ** varint nPrefix; (length of prefix shared with previous term)
116029 ** varint nPrefix; (length of shared prefix with previous term)
125489 ** This function ensures that the caller has obtained a shared-cache
126904 ** Return the size of the common prefix (if any) shared by zPrev and
