SQLite FOREIGN KEY constraint failed

The FOREIGN KEY constraint in SQLite is a fundamental aspect of database integrity, ensuring the relationships between tables are consistently maintained. This constraint links a column or a set of columns in one table to the primary key or a unique key in another table. The purpose is to ensure that the value of the foreign key matches one of the values in the referenced table, maintaining referential integrity within the database.

About FOREIGN KEY constraint failed

When SQLite reports a FOREIGN KEY constraint failed error, it indicates that an attempt to insert or update a row in a table has violated this referential integrity. Specifically, the error occurs under the following circumstances:

Insert Operation: When inserting a new row into a table that has a FOREIGN KEY constraint, if the value of the foreign key does not exist in the referenced table, SQLite will reject the insertion and report this error.

Update Operation: If you try to update a row in such a way that the foreign key reference is broken—either by changing the foreign key to a value that doesn’t exist in the referenced table or by modifying the referenced value in such a way that it no longer matches—the update will be rejected.

Delete Operation: When attempting to delete a row from a referenced table that has a corresponding foreign key in a different table (and if the ON DELETE action is set to something like RESTRICT), SQLite will prevent the deletion if it would result in orphaned rows in the table with the foreign key.

Handle FOREIGN KEY constraint failed

To resolve a FOREIGN KEY constraint failed error, consider the following approaches:

Verify Foreign Key Values: Before inserting or updating rows, ensure that the foreign key values exist in the referenced table. This often involves checking the data in the referenced table to confirm the presence of the required primary or unique keys.

Adjust Data Accordingly: If the foreign key value does not exist in the referenced table, you may need to insert or update the data in the referenced table first to create a valid reference.

Review Database Schema: Ensure that the FOREIGN KEY constraints are correctly defined, including the referenced table and column names. Typos or incorrect table references can lead to unexpected constraint failures.

Use Corrective SQL Statements: Depending on the specific operation that caused the error, you may need to use SQL INSERT, UPDATE, or DELETE statements to correct the data or relationships between tables.

Cascade Actions: For updates and deletes that affect referenced keys, consider using ON UPDATE CASCADE and ON DELETE CASCADE actions in your foreign key constraints, if appropriate. These actions automatically update or delete the corresponding rows in the referencing table to maintain integrity.


Below is an example in Python using the sqlite3 library. In this example, we’ll create two tables, one with a foreign key constraint, and then we’ll handle and catch the FOREIGN KEY constraint failed error.

import sqlite3

# Connect to the SQLite database (or create a new one if it doesn't exist)
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Create a table with a FOREIGN KEY constraint
cursor.execute('''CREATE TABLE IF NOT EXISTS authors (
                    id INTEGER PRIMARY KEY,
                    name TEXT

cursor.execute('''CREATE TABLE IF NOT EXISTS books (
                    id INTEGER PRIMARY KEY,
                    title TEXT,
                    author_id INTEGER,
                    FOREIGN KEY (author_id) REFERENCES authors(id)

# Insert some data into the tables
cursor.execute("INSERT INTO authors (name) VALUES ('Author 1')")
cursor.execute("INSERT INTO books (title, author_id) VALUES ('Book 1', 1)")

    # Try to insert a book with a non-existing author_id
    cursor.execute("INSERT INTO books (title, author_id) VALUES ('Book 2', 2)")
except sqlite3.IntegrityError as e:
    # Catch and handle the FOREIGN KEY constraint failed error
    print("Error:", e)
    conn.rollback()  # Rollback the transaction to avoid partial data insertion

# Close the database connection

In this example:

We create a SQLite database named example.db and establish a connection.
We create two tables, authors and books, where books has a FOREIGN KEY constraint referencing the authors table.
We insert valid data into the tables.
We attempt to insert a book with an author_id that does not exist in the authors table. This will trigger a FOREIGN KEY constraint failed error.
We use a try-except block to catch the sqlite3.IntegrityError exception, which is raised when the FOREIGN KEY constraint fails.
In the catch block, we print the error message and rollback the transaction using conn.rollback() to maintain data consistency.

This example demonstrates how to handle and catch a FOREIGN KEY constraint failed error when working with SQLite in Python. Adapt the error handling to your specific programming language and library as needed.

It’s crucial to handle FOREIGN KEY constraint failed errors thoughtfully to maintain the integrity and reliability of your database. Designing the database with careful consideration of foreign key relationships and consistently checking data before operations can help avoid these errors.