How to Optimize SQLite Database Performance in Python

A Python helper that creates an index, enables WAL mode, and tunes synchronous settings to optimize SQLite database performance.

Easy Python 3.9+ Aug 9, 2026 Database scaling & optimization 14 views 0 copies

Python code

44 lines
Python 3.9+
import sqlite3

DATABASE_PATH = "beginners.db"
UNOPTIMIZED_TABLE_SCHEMA = """
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT NOT NULL
)
"""


def optimize_database(db_path: str = DATABASE_PATH) -> dict:
    with sqlite3.connect(db_path) as connection:
        cursor = connection.cursor()
        cursor.execute(UNOPTIMIZED_TABLE_SCHEMA)

        # Optimize: create an index on frequently queried columns
        cursor.execute("CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)")

        # Optimize: set WAL mode for better concurrent reads/writes
        cursor.execute("PRAGMA journal_mode=WAL")
        # Optimize: tune synchronous for speed (safe for most apps)
        cursor.execute("PRAGMA synchronous=NORMAL")

        connection.commit()
        journal_mode = cursor.execute("PRAGMA journal_mode").fetchone()[0]
        synchronous_setting = cursor.execute("PRAGMA synchronous").fetchone()[0]
        has_index = cursor.execute(
            "SELECT 1 FROM sqlite_master WHERE type='index' AND name='idx_users_email'"
        ).fetchone()

    return {
        "database": db_path,
        "journal_mode": journal_mode,
        "synchronous": synchronous_setting,
        "index_created": bool(has_index),
        "optimization_status": "optimized" if has_index else "not optimized",
    }


if __name__ == "__main__":
    result = optimize_database()
    print(f"Optimization result: {result}")

Output

stdout
Optimization result: {'database': 'beginners.db', 'journal_mode': 'wal', 'synchronous': '1', 'index_created': True, 'optimization_status': 'optimized'}

How it works

This helper uses the sqlite3 module to connect to a database and apply three key optimizations. The CREATE INDEX statement builds an index on the email column, speeding up queries that filter or sort by that column. Enabling WAL (Write-Ahead Logging) mode improves concurrency by allowing readers and writers to operate simultaneously without blocking. Setting synchronous=NORMAL reduces disk flush frequency, increasing write performance while still maintaining durability for most applications. The function returns a dictionary with the actual applied settings, confirming the optimizations took effect, and the if __name__ == '__main__' block demonstrates the helper's usage.

Common mistakes

  • Forgetting to set a good index key — indexing low-cardinality columns wastes space
  • Not committing PRAGMA changes — some settings require a commit to persist
  • Ignoring that WAL mode is persistent but can be reset by VACUUM; re-apply after major operations

Variations

  1. Use `CREATE INDEX IF NOT EXISTS` with a composite index on multiple columns for complex queries
  2. Run `ANALYZE` after creating indexes to update query planner statistics

Real-world use cases

  • A REST API back-end that reads user profiles by email, so indexing that column turns slow full scans into fast lookups.
  • A data ingestion pipeline writing thousands of rows per second, where WAL mode plus `synchronous=NORMAL` prevents write bottlenecks.
  • A small business app shipping with a local SQLite database, where this helper runs once at startup to ensure the schema is always optimized.

Sponsored

Run this sample

Open the browser IDE to tweak the example and see results without installing anything.

Open editor

More from Database scaling & optimization

Related tutorials and quizzes for this topic.