How to fix SQLITE_LOCKED_SHAREDCACHE: Conflict within shared cache in SQLite

What this error means

The SQLITE_LOCKED_SHAREDCACHE error is a result code that indicates a write operation could not continue because of a locking conflict within a shared database cache. This occurs when shared-cache mode is enabled and multiple connections to the same database attempt to access the same table concurrently. In shared-cache mode, SQLite uses table-level locking instead of database-level locking. When one connection modifies data in a table, SQLite locks that table at a fine-grained level. If another connection tries to access the same locked table simultaneously, SQLite returns the SQLITE_LOCKED_SHAREDCACHE error rather than blocking and waiting. This is fundamentally different from normal SQLite locking behavior, where separate connections would lock the entire database file and typically receive SQLITE_BUSY instead of SQLITE_LOCKED.

Typical symptoms

• Database operations fail intermittently with "SQLITE_LOCKED_SHAREDCACHE" error code
• Errors occur specifically when multiple threads or connections access the database simultaneously
• The application works fine with single-threaded access but fails under concurrent load
• Setting a busy timeout or using PRAGMA busy_timeout has no effect on SQLITE_LOCKED errors
• Errors are more frequent when one connection is writing while others are reading or writing to the same table

Common causes

1. Shared-cache mode is explicitly enabled on one or more database connections
2. Multiple connections share the same in-memory database with cache=shared parameter
3. One connection holds a write lock or schema modification lock while another attempts to access the same table
4. Schema modifications (ALTER TABLE, CREATE INDEX) are happening while other connections are reading or writing
5. Concurrent read and write operations overlap on the same table without proper transaction isolation controls

How to fix "SQLITE_LOCKED_SHAREDCACHE: Conflict within shared cache"

// In-memory database with shared cache
DataSource=file::memory:?cache=shared

// Or using URI format
DataSource=:memory:?cache=shared

// Or the SQLITE_OPEN_SHAREDCACHE flag in your sqlite3_open_v2() call

// Before (with shared cache - causes SQLITE_LOCKED_SHAREDCACHE)
var connectionString = "DataSource=file::memory:?cache=shared";

// After (private cache - default)
var connectionString = "DataSource=:memory:?cache=private";
// Or simply
var connectionString = "DataSource=:memory:";

// Or remove cache parameter entirely
var connectionString = "Data Source=mydata.db";

// When creating your connection
var connectionString = "Data Source=mydata.db";
using (var connection = new SqliteConnection(connectionString))
{
    connection.Open();
    
    // Enable WAL mode
    using (var command = connection.CreateCommand())
    {
        command.CommandText = "PRAGMA journal_mode = WAL";
        command.ExecuteNonQuery();
    }
}

const int maxRetries = 5;
int retryCount = 0;

while (retryCount < maxRetries)
{
    try
    {
        // Execute your database operation
        connection.Execute(sql);
        break; // Success
    }
    catch (SqliteException ex) when (ex.SqliteErrorCode == 6) // SQLITE_LOCKED
    {
        retryCount++;
        if (retryCount >= maxRetries) throw;
        
        // Exponential backoff
        int delayMs = (int)Math.Pow(2, retryCount) * 10;
        await Task.Delay(delayMs);
    }
}

// Test concurrent access
var tasks = Enumerable.Range(0, 10)
    .Select(i => Task.Run(() => ExecuteDatabaseOperation(i)))
    .ToArray();

await Task.WhenAll(tasks);
// Should complete without SQLITE_LOCKED_SHAREDCACHE errors

Advanced notes

Frequently asked questions

What does "SQLITE_LOCKED_SHAREDCACHE" mean?

The SQLITE_LOCKED_SHAREDCACHE error is a result code that indicates a write operation could not continue because of a locking conflict within a shared database cache. This occurs when shared-cache mode is enabled and multiple connections to the same database attempt to access the same table concurrently. In shared-cache mode, SQLite uses table-level locking instead of database-level locking.

How do I fix "SQLITE_LOCKED_SHAREDCACHE"?

SQLITE_LOCKED_SHAREDCACHE occurs when multiple connections to the same database in shared-cache mode attempt conflicting operations simultaneously. This error indicates a table-level lock conflict and typically appears in multi-threaded applications. The recommended solution is to disable shared-cache mode or migrate to WAL mode, which handles concurrent access more efficiently.

What causes "SQLITE_LOCKED_SHAREDCACHE"?

Shared-cache mode is explicitly enabled on one or more database connections Multiple connections share the same in-memory database with cache=shared parameter One connection holds a write lock or schema modification lock while another attempts to access the same table

Is the "SQLITE_LOCKED_SHAREDCACHE" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• SQLITE_MISMATCH: datatype mismatch

  How to fix 'SQLITE_MISMATCH: Data type mismatch' in SQLite

  MEDIUM

• SQLITE_LOCKED: A table in the database is locked

  How to fix "SQLITE_LOCKED: A table in the database is locked" in SQLite

  MEDIUM

• SQLITE_MISUSE: Library used incorrectly

  How to fix "SQLITE_MISUSE: Library used incorrectly" in SQLite

  HIGH

• SQLITE_IOERR_WRITE: Disk I/O error during write

  Disk I/O error during write operation

  HIGH

• SQLITE_CORRUPT: The database disk image is malformed

  How to fix "SQLITE_CORRUPT: The database disk image is malformed" in SQLite

  CRITICAL

• SQLITE_READONLY: Attempt to write a readonly database

  How to fix "SQLITE_READONLY: Attempt to write a readonly database" in SQLite

  HIGH

Official resources & further reading

• 📚SQLite Official Documentation
• 📖
  SQLite Shared-Cache Mode Documentation(Official Docs)
• 📖
  SQLite Enable Or Disable Shared Pager Cache(Official Docs)
• 📖
  SQLite URI Filenames(Official Docs)
• 📖
  Microsoft.Data.Sqlite Connection Strings(Official Docs)
• 🐙
  Go SQLite3 - Database is locked discussion(GitHub)