How to fix SQLITE_BUSY: The database file is locked in SQLite

# Find processes accessing the SQLite file
lsof /path/to/your/database.db

# Check for lock files
ls -la /path/to/your/database.db-*

# Use Handle or Process Explorer tools
# Or check for lock files
Get-ChildItem "C:path	oyourdatabase.db-*"

const db = require('better-sqlite3')('database.db');

// Use transactions for multiple operations
const insert = db.prepare('INSERT INTO users (name) VALUES (?)');
const select = db.prepare('SELECT * FROM users WHERE name = ?');

// Always close connection when done
process.on('exit', () => db.close());
process.on('SIGINT', () => db.close());

import sqlite3
import contextlib

@contextlib.contextmanager
def get_db_connection(db_path):
    conn = sqlite3.connect(db_path)
    try:
        yield conn
    finally:
        conn.close()

# Usage
with get_db_connection('database.db') as conn:
    cursor = conn.cursor()
    cursor.execute('INSERT INTO users (name) VALUES (?)', ('John',))
    conn.commit()

try (Connection conn = DriverManager.getConnection("jdbc:sqlite:database.db")) {
    try (PreparedStatement stmt = conn.prepareStatement("INSERT INTO users (name) VALUES (?)")) {
        stmt.setString(1, "John");
        stmt.executeUpdate();
    }
} // Connection automatically closed

PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;

PRAGMA busy_timeout = 5000; -- Wait up to 5 seconds for locks

PRAGMA locking_mode = NORMAL; -- Default, allows shared locks

PRAGMA journal_mode = MEMORY; -- Faster but less durable
PRAGMA cache_size = -2000; -- 2MB cache

# Check for active connections
fuser /path/to/database.db

# If no output, it's safe to clean up
rm -f /path/to/database.db-wal
rm -f /path/to/database.db-shm
rm -f /path/to/database.db-journal

# Backup and recreate the database
sqlite3 database.db ".backup backup.db"
mv database.db database.db.corrupted
mv backup.db database.db

import fcntl
import os

class DatabaseLock:
    def __init__(self, db_path):
        self.lockfile = db_path + '.lock'
        self.fd = None

    def acquire(self):
        self.fd = open(self.lockfile, 'w')
        fcntl.flock(self.fd, fcntl.LOCK_EX)

    def release(self):
        if self.fd:
            fcntl.flock(self.fd, fcntl.LOCK_UN)
            self.fd.close()
            self.fd = None

# Usage
lock = DatabaseLock('database.db')
try:
    lock.acquire()
    # Perform database operations
finally:
    lock.release()

async function executeWithRetry(query, params, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await db.run(query, params);
    } catch (error) {
      if (error.code === 'SQLITE_BUSY' && i < maxRetries - 1) {
        await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
}

// Example with better-sqlite3 pool
const Database = require('better-sqlite3');
const pool = [];

function getConnection() {
  if (pool.length > 0) {
    return pool.pop();
  }
  return new Database('database.db');
}

function releaseConnection(conn) {
  pool.push(conn);
}