SQLite Errors

The SQLITE_IOERR_UNLOCK error occurs when SQLite cannot properly release a file lock during database operations. This is an I/O error that typically indicates file system permission issues, disk space problems, or conflicts with antivirus software. The error prevents proper transaction completion and can lead to database corruption if not resolved.

This error occurs when SQLite cannot access a database file because it's locked by another process or connection. Common causes include multiple applications accessing the same database, improper connection handling, or file system locking issues.

SQLite failed to flush buffered data to persistent storage via the fsync() system call. This extended I/O error (code 1034) occurs when the operating system cannot sync written data to disk.

This error occurs when SQLite detects corruption in a virtual table, most commonly in FTS (Full Text Search) tables. It indicates that the virtual table's internal data structures have been damaged or contain invalid data.

This error occurs when trying to reuse a prepared SQLite statement that has already been finalized (closed). It typically happens after database connection closure or when the statement object is garbage collected while code still holds a reference to it.

This error occurs when an authorization callback denies access to a database operation. SQLite's authorization mechanism is typically used to enforce security policies when executing SQL from untrusted sources.

The SQLITE_IOERR_WRITE error occurs when SQLite encounters an I/O failure while attempting to write data to disk. This extended error code indicates a problem at the VFS (Virtual File System) layer during write operations, often caused by filesystem issues, permission problems, or hardware failures.

This error occurs when you try to insert or update data in a SQLite table that violates a CHECK constraint. CHECK constraints enforce data validation rules at the database level, ensuring only valid data enters your table.

The SQLITE_READONLY_RECOVERY error occurs when SQLite is attempting to recover a WAL (Write-Ahead Logging) mode database but lacks the necessary write permissions to complete the recovery process. This typically happens when a database connection was improperly closed or crashed, and SQLite needs to replay uncommitted changes from the WAL file back to the main database but is prevented by insufficient file system permissions.

This error occurs when your application tries to write to a SQLite database that is opened in read-only mode or lacks write permissions. Common causes include incorrect file permissions on the database or its parent directory, stale journal files, multiple processes writing simultaneously, or the database being opened explicitly as read-only.

This error occurs when you attempt to insert or update a row with a primary key value that already exists in the table. SQLite enforces primary key uniqueness strictly, rejecting duplicate key values to maintain data integrity and ensure each row is uniquely identifiable.

SQL logic error is SQLite's most generic error code, indicating a problem with your SQL query, virtual table, or internal SQLite issue. This error is difficult to debug because it lacks specificity—the actual cause could be a malformed query, corrupted virtual table, or even memory corruption in your application code.

This error occurs when you try to insert or update a row in SQLite with a NULL value in a column that has a NOT NULL constraint. The database rejects the operation to maintain data integrity. Common causes include missing required fields, application logic errors, or schema mismatches.

This error occurs when better-sqlite3 tries to execute a query while the database connection is already processing another query. It commonly happens when attempting to run an UPDATE or DELETE while iterating through a SELECT result set, or when trying to close the database while a query is still running.

SQLite raises SQLITE_READONLY_DBMOVED when it detects that the database file has been moved or renamed after a connection was opened, so it refuses all writes to guard against rollback journal corruption.

This SQLite I/O error occurs when a read operation returns fewer bytes than expected, typically indicating file corruption, truncation, or filesystem issues. It's an extended error code for SQLITE_IOERR that signals potential database file integrity problems requiring immediate attention.

This SQLite error occurs when a write operation is blocked by a conflict on the same database connection or shared cache. It typically happens when multiple threads or processes attempt conflicting operations on the same table, or when using shared cache mode without proper synchronization.

This error occurs when SQLite's Write-Ahead Logging (WAL) mode database is being recovered by another process, preventing concurrent access. It's a specific busy error that happens during WAL checkpoint or recovery operations when multiple processes attempt to access the database simultaneously.

The SQLITE_INTERNAL error indicates an internal malfunction within the SQLite engine itself, often caused by bugs in SQLite, custom extensions, or Virtual File System (VFS) implementations. This error suggests a serious problem that requires investigation beyond typical application-level fixes.

This error occurs when SQLite cannot upgrade a read transaction to a write transaction due to snapshot isolation conflicts. It happens when a transaction starts in read mode, but later tries to write while other transactions are accessing the same data snapshot.

This SQLite I/O error occurs when the database engine encounters a disk I/O failure during read operations, typically indicating hardware issues, filesystem problems, or permission errors. It's a critical error that prevents SQLite from reading database files and requires immediate investigation to prevent data loss.

This error occurs when SQLite encounters a race condition in the file locking protocol, typically in WAL (Write-Ahead Logging) mode. It's a transient error that happens when multiple processes attempt to start transactions simultaneously, causing a conflict in the locking mechanism.

This error occurs when a SQLite trigger uses the RAISE function to abort an operation, typically for data validation or business rule enforcement. The trigger detects invalid data and prevents the INSERT, UPDATE, or DELETE operation from completing. Common causes include validation triggers, audit trails, and complex business logic enforcement.

SQLITE_MISUSE (error code 21) indicates the SQLite library is being used incorrectly, typically from using finalized statements, accessing connections from multiple threads, or calling API functions in the wrong order.

This error occurs when an insert, update, or delete operation violates a foreign key relationship between tables. Foreign key constraints must be explicitly enabled in SQLite and violations happen when referenced data is missing or incorrectly modified.

The SQLITE_IOERR error indicates the operating system encountered an I/O error while reading or writing database files. This typically stems from file permissions, filesystem issues, or hardware problems rather than insufficient disk space.

This error occurs when a callback function passed to SQLite returns a non-zero value, signaling an abort request. In sqlite3_exec() and similar functions, returning non-zero from a callback aborts the current query. This is commonly triggered by intentional abort logic or transaction rollbacks during execution.

This error occurs when SQLite cannot allocate the memory needed to complete an operation. It indicates an internal call to malloc() or realloc() has failed, preventing SQLite from continuing the requested operation.

This I/O error occurs when SQLite cannot acquire the necessary file lock to access the database, typically due to file system limitations, network storage issues, or concurrent access conflicts.

This error occurs when SQLite cannot access or open a database file. Common causes include incorrect file permissions, missing directories, invalid file paths, or insufficient disk space.

This error occurs when SQLite cannot access a database file or directory due to insufficient file system permissions. Common causes include incorrect ownership, restrictive file modes, or attempting to write to read-only locations.

This error occurs when an INSERT or UPDATE operation violates a database constraint (UNIQUE, NOT NULL, PRIMARY KEY, FOREIGN KEY, or CHECK). SQLite aborts the statement and rolls back its changes while preserving earlier transaction operations.

SQLITE_CANTOPEN occurs when SQLite cannot access the database file due to missing files, incorrect paths, or permission issues. This guide covers checking file permissions, using absolute paths, and ensuring directory access.

This error occurs when a prepared SQL statement is no longer valid because the database schema was modified after the statement was prepared. SQLite detects the schema mismatch and refuses to execute potentially incorrect virtual machine code.

SQLite cannot write to your database because the directory containing it lacks write permissions. Both the database file and its parent directory must be writable for SQLite to function properly.

This error occurs when attempting to store a string or BLOB that exceeds SQLite's maximum allowed size, typically 1 billion bytes by default. It can also trigger when an SQL statement itself is too long.

This error occurs when you attempt to insert or update a row with a value that already exists in a column marked as UNIQUE. SQLite enforces uniqueness constraints and rejects duplicate values, preventing data inconsistency in your database.

The SQLITE_READONLY_ROLLBACK error occurs when SQLite detects a hot journal (an incomplete rollback journal from a previous crash) but cannot complete the rollback because the database is opened in read-only mode or the filesystem is read-only. This error prevents database access until the journal is either completed or removed.

The SQLITE_READONLY_CANTLOCK error occurs when SQLite cannot obtain a read lock on a WAL (Write-Ahead Logging) mode database because the shared-memory file is read-only. This typically happens when file permissions prevent SQLite from accessing or modifying the .db-shm file needed for WAL coordination.

This error occurs when SQLite cannot initialize the Write-Ahead Logging (WAL) shared memory region due to insufficient write permissions on the WAL or shared memory files, preventing database access even for read-only operations.

This error occurs when a database operation is intentionally interrupted using the sqlite3_interrupt() function, typically in response to user cancellation. Handle it by properly finalizing interrupted statements and implementing timeout mechanisms.

SQLite throws SQLITE_FULL when it cannot complete a write operation because disk space is exhausted or temporary directories lack sufficient space. Free disk space, redirect temp files, or enable auto-vacuum to resolve this issue.

Database corruption prevents all queries and operations. Use PRAGMA integrity_check to diagnose the issue, then recover data using the .recover command or dump-and-rebuild method to restore functionality.

SQLITE_NOTFOUND occurs when code calls sqlite3_file_control() with an opcode that the underlying VFS (Virtual File System) implementation does not recognize or support. This typically happens with custom VFS implementations, version mismatches, or calling opcodes meant for internal use only.

This error occurs when Sequelize cannot open the SQLite database file at the specified path. Common causes include missing database file, incorrect file path, missing parent directory, or insufficient file/directory permissions. The error prevents Sequelize from establishing a connection to your SQLite database.

The SQLITE_NOLFS error occurs when SQLite tries to create a database file larger than 2GB on a system without Large File Support (LFS). This typically happens on older filesystems, 32-bit systems, or mismatched OS/filesystem configurations that cannot handle files exceeding the 2GB limit.

The SQLITE_MISMATCH error occurs when you attempt an operation that violates SQLite's strict type requirements, most commonly when trying to set a rowid to a non-integer value or when inserting data that conflicts with column type declarations in STRICT tables. SQLite is typically forgiving about type mismatches, but certain operations require exact type compliance.

The SQLITE_RANGE error occurs when you attempt to bind a value to a parameter index that doesn't exist in your SQL statement. SQLite uses 1-based indexing for parameters, and the index must match the actual number of placeholders in your prepared statement.

This error occurs when SQLite tries to open a file that does not have a valid SQLite database file format. This typically happens due to database corruption, attempting to open a non-database file, encrypted database without the correct key, or file header corruption. The file lacks the "SQLite format 3" signature at its beginning, which all valid SQLite databases must have.

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.

When using SQLite's shared-cache mode, connections within the same process experience table-level locking conflicts that return SQLITE_LOCKED_SHAREDCACHE (error code 6). Unlike SQLITE_BUSY (which occurs between separate processes), this error indicates a locking conflict between connections sharing the same cache and cannot be resolved with timeout settings.