数据库文件已经复制好了，为什么还是少了已提交的订单？

"""A quiescent WAL database: a file copy can be valid yet stale.

Only temporary demonstration databases are created. No business files are read.
"""
from contextlib import closing
from pathlib import Path
from shutil import copyfile
from tempfile import TemporaryDirectory
import sqlite3


def ids(connection):
    return [row[0] for row in connection.execute("SELECT id FROM orders ORDER BY id")]


def main():
    checks = 0

    def check(condition, message):
        nonlocal checks
        if not condition:
            raise AssertionError(message)
        checks += 1

    with TemporaryDirectory(prefix="qinghuan-wal-") as folder:
        root = Path(folder)
        source = root / "live.db"
        with closing(sqlite3.connect(source, isolation_level=None)) as live:
            mode = live.execute("PRAGMA journal_mode=WAL").fetchone()[0]
            check(mode == "wal", "WAL mode was not enabled")
            live.execute("PRAGMA wal_autocheckpoint=0")
            live.execute("CREATE TABLE orders(id INTEGER PRIMARY KEY, item TEXT NOT NULL)")
            live.execute("INSERT INTO orders VALUES(1, 'tea')")
            checkpoint = live.execute("PRAGMA wal_checkpoint(TRUNCATE)").fetchone()
            check(checkpoint == (0, 0, 0), "initial checkpoint must finish")
            live.execute("INSERT INTO orders VALUES(2, 'book')")
            check(not live.in_transaction, "second row must already be committed")
            check(ids(live) == [1, 2], "live database must include both orders")
            check(Path(str(source) + "-wal").stat().st_size > 0, "WAL must contain data")

            # Deliberately wrong backup: no writes occur during this copy, but
            # committed pages in the WAL are still omitted.
            copyfile(source, root / "raw-copy.db")
            with closing(sqlite3.connect(root / "raw-copy.db")) as raw:
                raw_ids = ids(raw)
                raw_integrity = raw.execute("PRAGMA integrity_check").fetchone()[0]
            check(raw_ids == [1], "raw copy should miss the WAL-only committed row")
            check(raw_integrity == "ok", "stale data can still pass integrity_check")

            with closing(sqlite3.connect(root / "api-backup.db")) as destination:
                live.backup(destination)
            # Reopen the destination: the following checks read restored data.
            with closing(sqlite3.connect(root / "api-backup.db")) as restored:
                restored_ids = ids(restored)
                restored_integrity = restored.execute("PRAGMA integrity_check").fetchone()[0]
                check(restored_ids == [1, 2], "backup must include the committed WAL row")
                check(restored_integrity == "ok", "backup must be structurally valid")
                live.execute("INSERT INTO orders VALUES(3, 'pen')")
                check(ids(live) == [1, 2, 3], "source should advance after backup")
                check(ids(restored) == [1, 2], "a backup does not follow later changes")

            print("live_before_backup=[1, 2]")
            print(f"raw_copy={raw_ids}; integrity={raw_integrity}")
            print(f"api_backup={restored_ids}; integrity={restored_integrity}")
            print("live_after_insert=[1, 2, 3]; backup_still=[1, 2]")
    print(f"PASS checks={checks}; temporary_files_cleaned=True")


if __name__ == "__main__":
    main()