# Source code for apsw.bestpractice

    #

    """Ensure SQLite usage prevents common mistakes, and get best performance."""

    from __future__ import annotations

    from typing import Callable

    import apsw
    import apsw.ext

    def connection_wal(connection: apsw.Connection) -> None:
        """Turns on write ahead logging

        Reduces contention and improves write performance.  WAL is
        `described here <https://www.sqlite.org/wal.html>`__.
        """
        try:
            if not connection.readonly("main"):
                connection.pragma("journal_mode", "wal")
        except apsw.ReadOnlyError:
            # journal/wal etc could still be readonly
            pass

    def connection_busy_timeout(connection: apsw.Connection, duration_ms: int = 100) -> None:
        """Sets a short busy timeout

        :param duration_ms: How many thousandths of a second to wait

        When another thread or process has locked the database, SQLite
        immediately raises :exc:`apsw.BusyError`.  Changing the `busy
        timeout <https://www.sqlite.org/c3ref/busy_timeout.html>`__ gives
        a grace period during which SQLite retries.
        """
        connection.set_busy_timeout(duration_ms)

    def connection_enable_foreign_keys(connection: apsw.Connection) -> None:
        """Enables foreign key constraints

        `Foreign keys <https://www.sqlite.org/foreignkeys.html>`__ need to
        `be enabled <https://www.sqlite.org/foreignkeys.html#fk_enable>`__
        to have an effect.
        """
        connection.pragma("foreign_keys", "ON")

    def connection_dqs(connection: apsw.Connection) -> None:
        """Double quotes are for identifiers only, not strings

        Turns off `allowing double quoted strings
        <https://www.sqlite.org/quirks.html#dblquote>`__ if they don't
        match any identifier (column/table names etc), making it an error
        to use double quotes around strings.  SQL strings use single
        quotes.
        """
        connection.config(apsw.SQLITE_DBCONFIG_DQS_DML, 0)
        connection.config(apsw.SQLITE_DBCONFIG_DQS_DDL, 0)

    def connection_optimize(connection: apsw.Connection) -> None:
        """Enables query planner optimization

        It enables the query planner to record cases when it would benefit
        from having accurate statistics about tables and indexes for the
        queries you make.

        You can later run :code:`connection.pragma("optimize")` to have
        those statistics updated, such as when closing a database or
        periodically when the database is open for long periods of time.
        The statistics are recorded in the database and help with future
        queries during this connection, and all future connections.

        There is more detail in the `documentation
        <https://sqlite.org/lang_analyze.html>`__.
        """
        try:
            if not connection.readonly("main"):
                connection.pragma("optimize", 0x10002)
        except apsw.ReadOnlyError:
            # journal/wal etc could still be readonly
            pass

    def connection_recursive_triggers(connection: apsw.Connection) -> None:
        """Recursive triggers are off for historical backwards compatibility

        This `enables them
        <https://www.sqlite.org/pragma.html#pragma_recursive_triggers>`__.
        """
        connection.pragma("recursive_triggers", "ON")

    def library_logging() -> None:
        """Forwards SQLite logging to Python logging module

        See :meth:`apsw.ext.log_sqlite`
        """
        apsw.ext.log_sqlite()

    recommended: tuple[Callable, ...] = (
        connection_busy_timeout,
        connection_wal,
        connection_enable_foreign_keys,
        connection_dqs,
        connection_optimize,
        connection_recursive_triggers,
        library_logging,
    )
    "All of them"

    def apply(which: tuple[Callable, ...]) -> None:
        "Applies library immediately and connection to new connections"
        hooks: list[Callable] = []
        for func in which:
            if func.__name__.startswith("connection_"):
                hooks.append(func)
            else:
                func()

        def best_practise_connection_apply(connection: apsw.Connection) -> None:
            for func in hooks:
                func(connection)

        apsw.connection_hooks.append(best_practise_connection_apply)