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 */
25566 ** shared by multiple threads.
25598 case SHARED_LOCK: return "SHARED";
25952 ** cnt>0 means there are cnt shared locks on the file.
26017 int nShared; /* Number of SHARED locks held */
26021 unixShmNode *pShmNode; /* Shared memory associated with this inode */
26027 unsigned long long sharedByte; /* for AFP simulated shared lock */
26280 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
26374 ** UNLOCKED -> SHARED
26375 ** SHARED -> RESERVED
26376 ** SHARED -> (PENDING) -> EXCLUSIVE
26385 ** lock transitions in terms of the POSIX advisory shared and exclusive
26392 ** byte', each single bytes at well known offsets, and the 'shared byte
26395 ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
26396 ** byte'. If this is successful, a random byte from the 'shared byte
26399 ** A process may only obtain a RESERVED lock after it has a SHARED lock.
26404 ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
26405 ** on the 'pending byte'. This ensures that no new SHARED locks can be
26406 ** obtained, but existing SHARED locks are allowed to persist. A process
26412 ** implemented by obtaining a write-lock on the entire 'shared byte
26417 ** The reason a single byte cannot be used instead of the 'shared byte
26419 ** locking a random byte from a range, concurrent SHARED locks may exist
26444 ** (1) We never move from unlocked to anything higher than shared lock.
26446 ** (3) A shared lock is always held when a reserve lock is requested.
26452 /* This mutex is needed because pFile->pInode is shared across threads
26467 /* If a SHARED lock is requested, and some thread using this PID already
26468 ** has a SHARED or RESERVED lock, then increment reference counts and
26483 /* A PENDING lock is needed before acquiring a SHARED lock and before
26484 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
26543 ** same process is still holding a shared lock. */
26547 ** assumed that there is a SHARED or greater lock on the file
26574 ** transitioning from a SHARED to a RESERVED lock. The change
26575 ** from SHARED to RESERVED marks the beginning of a normal
26624 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
26663 /* downgrading to a shared lock on NFS involves clearing the write lock
26752 /* Decrement the shared lock counter. Release the lock using an
26921 ** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
26979 ** UNLOCKED -> SHARED
26980 ** SHARED -> RESERVED
26981 ** SHARED -> (PENDING) -> EXCLUSIVE
27056 /* To downgrade to shared, simply update our internal notion of the
27106 ** a single exclusive lock. In other words, SHARED, RESERVED, and
27204 ** UNLOCKED -> SHARED
27205 ** SHARED -> RESERVED
27206 ** SHARED -> (PENDING) -> EXCLUSIVE
27211 ** lock states in the sqlite3_file structure, but all locks SHARED or
27275 /* shared can just be set because we always have an exclusive */
27380 ** UNLOCKED -> SHARED
27381 ** SHARED -> RESERVED
27382 ** SHARED -> (PENDING) -> EXCLUSIVE
27387 ** lock states in the sqlite3_file structure, but all locks SHARED or
27443 /* shared can just be set because we always have an exclusive */
27584 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
27631 ** UNLOCKED -> SHARED
27632 ** SHARED -> RESERVED
27633 ** SHARED -> (PENDING) -> EXCLUSIVE
27662 ** (1) We never move from unlocked to anything higher than shared lock.
27664 ** (3) A shared lock is always held when a reserve lock is requested.
27670 /* This mutex is needed because pFile->pInode is shared across threads
27685 /* If a SHARED lock is requested, and some thread using this PID already
27686 ** has a SHARED or RESERVED lock, then increment reference counts and
27700 /* A PENDING lock is needed before acquiring a SHARED lock and before
27701 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
27754 ** same process is still holding a shared lock. */
27758 ** assumed that there is a SHARED or greater lock on the file
27773 /* Remove the shared lock before trying the range. we'll need to
27774 ** reestablish the shared lock if we can't get the afpUnlock
27784 /* Can't reestablish the shared lock. Sqlite can't deal, this is
27868 /* only re-establish the shared lock if necessary */
27890 /* Decrement the shared lock counter. Release the lock using an
28667 ** Object used to represent an shared memory buffer.
28676 ** every open file that does not use shared memory (in other words, most
28700 int szRegion; /* Size of shared-memory regions */
28703 char **apRegion; /* Array of mapped shared-memory regions */
28708 u8 sharedMask; /* Mask of shared locks held */
28715 ** open shared memory connection.
28731 u16 sharedMask; /* Mask of shared locks held */
28748 unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
28759 /* Shared locks never span more than one byte */
28819 ** This is not a VFS shared-memory method; it is a utility function called
28820 ** by VFS shared-memory methods.
28847 ** Open a shared-memory area associated with open database file pDbFd.
28850 ** The file used to implement shared-memory is in the same directory
28854 ** for shared memory will be called "/home/user1/config.db-shm".
28860 ** database to end up using different files for shared memory -
28861 ** meaning that their memory would not really be shared - resulting
28871 ** When opening a new shared-memory file, if no other instances of that
28878 ** that case, we do not really need shared memory. No shared memory
28879 ** file is created. The shared memory will be simulated with heap memory.
29013 ** shared-memory associated with the database file fd. Shared-memory regions
29014 ** are numbered starting from zero. Each shared-memory region is szRegion
29019 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
29022 ** bExtend is non-zero and the requested shared-memory region has not yet
29025 ** If the shared-memory region has already been allocated or is allocated by
29042 /* If the shared-memory file has not yet been opened, open it now. */
29134 ** Change the lock state for a shared-memory segment.
29136 ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
29138 ** to shared and back or from unlocked to exclusive and back. But one may
29139 ** not go from shared to exclusive or from exclusive to shared.
29142 sqlite3_file *fd, /* Database file holding the shared memory */
29147 unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */
29148 unixShm *p = pDbFd->pShm; /* The shared memory being locked */
29194 /* Find out which shared
29206 /* Get shared locks at the system level, if necessary */
29215 /* Get the local shared locks */
29248 ** Implement a memory barrier or memory fence on shared memory.
29254 sqlite3_file *fd /* Database file holding the shared memory */
29262 ** Close a connection to shared-memory. Delete the underlying
29265 ** If there is no shared memory associated with the connection then this
29270 int deleteFlag /* Delete shared-memory if true */
29273 unixShmNode *pShmNode; /* The underlying shared-memory file */
29297 ** shared-memory file, too */
29393 2, /* shared memory is enabled */
29402 1, /* shared memory is disabled */
29411 1, /* shared memory is disabled */
29422 1, /* shared memory is disabled */
29434 1, /* shared memory is disabled */
29446 1, /* shared memory is disabled */
29471 1, /* shared memory is disabled */
29484 1, /* shared memory is disabled */
30406 ** Interfaces for opening a shared library, finding entry points
30407 ** within the shared library, and closing the shared library.
30634 ** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
30638 ** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
30639 ** address in the shared range is taken for a SHARED lock, the entire
30640 ** shared range is taken for an EXCLUSIVE lock):
30706 ** by taking an sqlite-style shared lock on the conch file, reading the
30714 ** path and the lock is downgraded to a shared lock again. If the conch
30715 ** is held by another process (with a shared lock), the exclusive lock
30727 ** The shared lock and an open file descriptor are maintained until
31142 /* Takes the conch by taking a shared lock and read the contents conch, if
31243 ** has a shared lock already), if the host id matches, use the big
31250 ** same process is still holding a shared lock. */
31688 ** UNLOCKED -> SHARED
31689 ** SHARED -> RESERVED
31690 ** SHARED -> (PENDING) -> EXCLUSIVE
32148 typedef struct winShm winShm; /* A connection to shared-memory */
32149 typedef struct winShmNode winShmNode; /* A region of shared-memory */
32174 short sharedLockByte; /* Randomly chosen byte used as a shared lock */
32177 winShm *pShm; /* Instance of shared memory on this file */
32182 HANDLE hMutex; /* Mutex used to control access to shared lock */
32183 HANDLE hShared; /* Shared memory segment used for locking */
32185 winceLock *shared; /* Global shared lock memory for the file */
33376 ** Create the mutex and shared memory used for locking in the file
33414 ** and using that as the shared filemapping name.
33429 /* If we succeeded in making the shared memory handle, map it. */
33431 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
33433 /* If mapping failed, close the shared memory handle and erase it */
33434 if (!pFile->shared){
33443 /* If shared memory could not be created, then close the mutex and fail */
33451 /* Initialize the shared memory if we're supposed to */
33453 memset(pFile->shared, 0, sizeof(winceLock));
33471 pFile->shared->nReaders --;
33474 pFile->shared->bReserved = FALSE;
33477 pFile->shared->bPending = FALSE;
33480 pFile->shared->bExclusive = FALSE;
33483 /* De-reference and close our copy of the shared memory handle */
33484 osUnmapViewOfFile(pFile->shared);
33516 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
33517 pFile->shared->bExclusive = TRUE;
33526 if (pFile->shared->bExclusive == 0){
33529 pFile->shared->nReaders ++;
33538 if (pFile->shared->bPending == 0) {
33539 pFile->shared->bPending = TRUE;
33547 if (pFile->shared->bReserved == 0) {
33548 pFile->shared->bReserved = TRUE;
33583 pFile->shared->bExclusive = FALSE;
33593 pFile->shared->nReaders --;
33603 pFile->shared->bPending = FALSE;
33611 pFile->shared->bReserved = FALSE;
33634 /* If the caller wants a shared read lock, forward this call
34037 ** UNLOCKED -> SHARED
34038 ** SHARED -> RESERVED
34039 ** SHARED -> (PENDING) -> EXCLUSIVE
34075 ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
34100 /* Acquire a shared lock
34355 ** this file, all of which may be shared by multiple threads.
34379 ** shared memory. When multiple threads all reference the same
34405 int szRegion; /* Size of shared-memory regions */
34430 ** open shared memory connection.
34445 u16 sharedMask; /* Mask of shared locks held */
34465 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
34514 ** This is not a VFS shared-memory method; it is a utility function called
34515 ** by VFS shared-memory methods.
34559 ** Open the shared-memory area associated with database file pDbFd.
34561 ** When opening a new shared-memory file, if no other instances of that
34675 ** Close a connection to shared-memory. Delete the underlying
34679 sqlite3_file *fd, /* Database holding shared memory */
34682 winFile *pDbFd; /* Database holding shared-memory */
34684 winShmNode *pShmNode; /* The underlying shared-memory file */
34704 ** shared-memory file, too */
34717 ** Change the lock state for a shared-memory segment.
34720 sqlite3_file *fd, /* Database file holding the shared memory */
34725 winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */
34726 winShm *p = pDbFd->pShm; /* The shared memory being locked */
34768 /* Find out which shared locks are already held by sibling connections.
34780 /* Get shared locks at the system level, if necessary */
34789 /* Get the local shared locks */
34823 ** Implement a memory barrier or memory fence on shared memory.
34829 sqlite3_file *fd /* Database holding the shared memory */
34839 ** shared-memory associated with the database file fd. Shared-memory regions
34840 ** are numbered starting from zero. Each shared-memory region is szRegion
34845 ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
34848 ** isWrite is non-zero and the requested shared-memory region has not yet
34851 ** If the shared-memory region has already been allocated or is allocated by
35562 ** Interfaces for opening a shared library, finding entry points
35563 ** within the shared library, and closing the shared library.
35566 ** Interfaces for opening a shared library, finding entry points
35567 ** within the shared library, and closing the shared library.
38434 ** WAL module is using shared-memory, return false.
38533 ** (13) A SHARED lock is held on the database file while reading any
38624 ** * A SHARED or greater lock is held on the database file.
38807 ** in the file-system that needs to be rolled back (as part of a OPEN->SHARED
38824 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
39391 p->eLock==SHARED_LOCK ? "SHARED" :
40418 ** connection to obtain a shared lock on the pager (which may be this one)
41224 ** pPg->pData. A shared lock or greater must be held on the database
41543 ** The caller must hold a SHARED lock on the database file to call this
41858 ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
41861 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
43130 ** This function is called to obtain a shared lock on the database file.
43132 ** has been successfully called. If a shared-lock is already held when
43139 ** SHARED lock on the database file. Immediately after obtaining
43140 ** the SHARED lock, the file-system is checked for a hot-journal,
43290 /* The shared-lock has just been acquired on the database file
45179 ** in. Otherwise, use the normal shared-memory.
45188 ** heap-memory for the wal-index instead of the VFS shared-memory
45211 ** The caller must be holding a SHARED lock on the database file to call
45463 ** Conceptually, the wal-index is shared memory, though VFS implementations
45465 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
45672 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
46101 ** Set or release locks on the WAL. Locks are either shared or exclusive.
46102 ** A lock cannot be moved directly between shared and exclusive - it must go
46112 WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
46121 WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
46573 ** A SHARED lock should be held on the database file when this function
46574 ** is called. The purpose of this SHARED lock is to prevent any other
47217 ** The wal-index is in shared memory. Another thread or process might
47233 WalIndexHdr volatile *aHdr; /* Header in shared memory */
47239 ** same area of shared memory on a different CPU in a SMP,
47457 ** code that determines whether or not the shared-memory region
47551 ** between the time it was read and when the shared-lock was obtained
48398 ** WAL module is using shared-memory, return false.
48769 ** shared between multiple connections. In that case, each connection
48799 ** If the shared-data extension is enabled, there may be multiple users
48828 ** the shared-cache enters 'pending-lock' state and isPending is
48831 ** The shared-cache leaves the 'pending lock' state when either of
48870 BtLock *pLock; /* List of locks held on this shared-btree struct */
48922 ** A single database file can be shared by two more database connections,
48923 ** but cursors cannot be shared. Each cursor is associated with a
49149 ** the same connection. Only shared Btrees are on the list. */
49341 ** in single threaded applications that use shared cache. Except for
49345 ** If shared cache is disabled, then all btree mutex routines, including
49413 ** in shared cache. This variable has file scope during normal builds,
49428 ** Enable or disable the shared pager and schema features.
49431 ** The shared cache setting effects only future calls to
49447 ** shared-cache table level locks. If the library is compiled with the
49448 ** shared-cache feature disabled, then there is only ever one user
49552 ** table or index rooted at iRoot because other shared connections are
49602 /* This routine is a no-op if the shared-cache is not enabled */
49642 ** Add a lock on the table with root-page iTable to the shared-btree used
49807 ** on the shared btree structure pBt.
51058 ** and we are in shared cache mode, then the open will fail with an
51071 BtShared *pBt = 0; /* Shared part of btree structure */
51121 ** If this Btree is a candidate for shared cache, try to find an
51313 ** default value. Except, when opening on an existing shared pager-cache,
51411 /* If there are still other outstanding references to the shared-btree
51413 ** up the shared-btree.
51933 ** on this shared-btree structure and a second write transaction is
51957 ** page 1. So if some other shared-cache client already has a write-lock
52519 ** transaction count of the shared btree. If the transaction count
52520 ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
52571 /* If the handle has a write-transaction open, commit the shared-btrees
52572 ** transaction and set the shared state to TRANS_READ.
52828 BtShared *pBt = p->pBt; /* Shared b-tree handle */
57429 ** transaction on the shared-cache the argument Btree is connected to.
57466 ** a single shared-btree. The memory is used by client code for its own
57468 ** the shared-btree). The btree layer manages reference counting issues.
57470 ** The first time this is called on a shared-btree, nBytes bytes of memory
57479 ** Just before the shared-btree is closed, the function passed as the
57496 ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared
60489 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
60495 ** If SQLite is not threadsafe but does support shared-cache mode, then
60500 ** If SQLite is not threadsafe and does not support shared-cache mode, this
60505 ** corresponding to btrees that use shared cache. Then the runtime of
67653 ** there are active writing VMs or active VMs that use shared cache.
70462 ** in temporary storage or if the VFS does not support shared memory
70466 || !sqlite3PagerWalSupported(u.ci.pPager)) /* No shared-memory support */
70584 ** the shared-cache feature is enabled.
79751 /* Establish a read-lock on the table at the shared-cache level. */
81374 ** shared-cache feature is enabled.
82744 ** A shared-cache write-lock is not required to write to the new table,
87330 ** A function that loads a shared-library extension then returns NULL.
88523 /* Take a shared-cache advisory read-lock on the parent table. Allocate
90987 ** shared libraries that want to be imported as extensions into
90988 ** an SQLite instance. Shared libraries that intend to be loaded
91004 ** versions of SQLite will not be able to load each others' shared
91800 const char *zFile, /* Name of the shared library containing extension */
91836 "unable to open shared library [%s]", zFile);
91850 "no entry point [%s] in shared library [%s]", zProc,zFile);
91865 /* Append the new shared library handle to the db->aExtension array. */
91881 const char *zFile, /* Name of the shared library containing extension */
91938 ** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER
93550 "unlocked", "shared", "reserved", "pending", "exclusive"
101651 ** shared b-tree databases opened using connection db are held by the
114436 { "shared", SQLITE_OPEN_SHAREDCACHE },
115622 ** (call it pOther) in the same process was busy using the same shared
115955 ** varint nPrefix; (length of prefix shared with previous term)
116001 ** varint nPrefix; (length of shared prefix with previous term)
125458 ** This function ensures that the caller has obtained a shared-cache
126873 ** Return the size of the common prefix (if any) shared by zPrev and
