Phục hồi từ WAL khi checkpoint mới xong một phần
Áp dụng phép gán đã commit, bỏ đuôi log chưa đủ và chỉ ra lỗi thứ tự làm mất tính nguyên tử khi ghi vùng chính hoặc xóa log quá sớm.

Một giao dịch đã commit có thể sống sót dù các trang chính của cơ sở dữ liệu vẫn chứa giá trị cũ. Nhật ký ghi trước, hay write-ahead log (WAL), giữ đủ công việc đã commit để dựng lại trạng thái cần có sau đó. Câu hỏi quyết định không phải có tệp log hay không, mà là những bản ghi nào đã được lưu bền trước sự cố và quy tắc phục hồi sẽ diễn giải chúng ra sao.
Bài này dành cho lập trình viên hiểu ghi tệp thông thường và khác biệt giữa nhìn thấy dữ liệu với lưu bền dữ liệu. Ta dùng mô hình nhỏ chỉ có redo, tức áp dụng lại thay đổi mới, để cập nhật hai giá trị cùng nhau, ngắt ở vài ranh giới và giải thích thứ tự checkpoint. Chỉ cần biết dictionary của Python. Mọi ranh giới sự cố dưới đây đều là trạng thái mô phỏng, không phải lỗi thiết bị thật hay thí nghiệm phục hồi SQLite.
Giao nhiệm vụ khác nhau cho log và vùng dữ liệu chính
Giả sử vùng dữ liệu chính chứa x = 0 và y = 0. Một giao dịch muốn đặt x = 10 và y = 20. Ghi thẳng hai giá trị vào vùng chính có thể để lại trạng thái trộn 10, 0 nếu chỉ thay đổi đầu sống sót. Lần đồng bộ cuối không thể giúp sau một sự cố xảy ra trước khi nó hoàn tất.
Log của mô hình ghi các phép gán mới, rồi đến dấu commit. Một lượt phục hồi gom phép gán cho tới khi gặp dấu ấy, sau đó áp dụng cả nhóm đang chờ vào trạng thái được dựng lại. Nhóm ở cuối chưa có dấu commit bị bỏ qua. Mô hình cho các giao dịch nối tiếp: có một bên ghi, bản ghi của các giao dịch không xen kẽ, và không có ảnh chụp của bên đọc đồng thời cần giữ lại.
Với thiết kế chỉ có redo này, toàn bộ giao dịch, kể cả dấu commit, phải được lưu bền trước khi bất kỳ thay đổi nào của nó được lưu bền ở vùng chính. Đây là quy tắc cố ý nghiêm ngặt cho mô hình nhỏ này, không phải khẳng định mọi bộ máy lưu trữ đều cấm ghi trang chưa commit. Thiết kế phục hồi khác có thể cho phép điều đó nếu duy trì cả thông tin và giao thức để hoàn tác công việc chưa xong. Ví dụ này không có log undo.
Tổng quan WAL của SQLite mô tả nối nội dung đã đổi vào log riêng và ghi commit ở đó mà chưa cần ghi lại tệp cơ sở dữ liệu gốc. Định dạng WAL thật chứa nội dung trang đã sửa trong các frame, với chỉ dấu commit ở phần đầu frame. Các tuple set và commit dễ đọc ở đây là bản ghi phục vụ bài học, không phải định dạng nhị phân của SQLite.
Dấu commit mới được nối vào bộ đệm của tiến trình chưa phải ranh giới lưu bền. Đầu vào mang tên durable_records chỉ đại diện cho các bản ghi được biết là đã sống sót, theo đúng thứ tự. Mô hình giả định sẵn điều ấy để ta nghiên cứu replay, thay vì coi một danh sách Python là phép mô phỏng đồng bộ hệ thống tệp.
Áp dụng giao dịch đủ và bỏ phần cuối chưa hoàn tất
Hàm sao chép dictionary vùng chính được truyền vào thay vì sửa đối tượng của bên gọi. Trong một giao dịch, phép gán cuối cùng cho một khóa có hiệu lực. Tới dấu commit, các thay đổi đang chờ cập nhật trạng thái được dựng lại; tới cuối log, thay đổi còn chờ bị bỏ. Khóa không có trong bất kỳ phép gán đã commit nào giữ giá trị ở vùng chính.
def recover(home, durable_records):
"""Replay complete serialized transactions from trusted logical records."""
recovered = dict(home)
pending = {}
for record in durable_records:
if record[0] == "set":
_, key, value = record
pending[key] = value
elif record == ("commit",):
recovered.update(pending)
pending.clear()
else:
raise ValueError("unknown record")
# Any remaining changes belong to an uncommitted tail.
return recovered
initial = {"x": 0, "y": 0}
records = [
("set", "x", 10),
("set", "y", 20),
("commit",),
("set", "x", 99), # A later transaction has not committed.
]
cases = [
("before durable commit", initial, records[:2], {"x": 0, "y": 0}),
("commit durable; home old", initial, records[:3], {"x": 10, "y": 20}),
("one home value copied", {"x": 10, "y": 0}, records[:3], {"x": 10, "y": 20}),
("uncommitted log tail", {"x": 10, "y": 20}, records, {"x": 10, "y": 20}),
]
for label, home, durable, expected in cases:
result = recover(home, durable)
assert result == expected
assert recover(result, durable) == result
print(label, result)
Trước khi commit được lưu bền, chỉ hai bản ghi gán đầu chưa cho phép áp dụng thay đổi nào. Với vùng chính còn cũ, phục hồi trả 0, 0. Khi toàn bộ giao dịch ba bản ghi đã được lưu bền, phục hồi trả 10, 20 dù chưa chép giá trị nào vào vùng chính.
Trường hợp thứ ba đã lưu bền giá trị mới của x nhưng chưa lưu y. Áp dụng lại giao dịch bền sẽ gán x thêm lần nữa và sửa y. Trường hợp thứ tư nối thêm x = 99 của giao dịch sau nhưng chưa có commit mới. Phục hồi bỏ giao dịch chưa hoàn tất đó và giữ cặp đã commit trước là 10, 20.
Những kết quả ấy dựa trên trạng thái đầu vào hợp lệ. Mỗi thay đổi ở vùng chính trong các trường hợp được chấp nhận đều đã được một giao dịch đầy đủ, lưu bền bảo vệ. Hàm không thể phát hiện một dictionary vùng chính tùy ý vi phạm quy tắc, cũng không thể dựng lại giá trị cũ nếu chưa từng ghi lại ảnh cũ của nó.
Làm cho việc áp dụng lại có thể lặp an toàn
Chính quá trình phục hồi cũng có thể bị ngắt. Bản ghi ở đây chứa phép gán tuyệt đối như “đặt x thành 10”, nên áp dụng lại cùng một log đầy đủ vẫn cho cùng giá trị cuối. Các assertion kiểm tra tính lặp không đổi kết quả này ở từng trạng thái đã minh họa. Gán x hai lần không gây hại; cộng thêm 10 hai lần lại là thao tác khác.
Log chứa phép tăng sẽ cần quy tắc khác để tránh áp dụng hai lần, chẳng hạn thông tin tiến độ được lưu bền và phối hợp với cập nhật trang. Hệ thống thật dùng metadata cùng giao thức phục hồi phong phú hơn; mô hình hiện tại không cài đặt hay chứng minh chúng. Việc chọn bản ghi phép gán làm ví dụ redo nhỏ này dễ kiểm tra.
Tính lặp không đổi còn áp dụng cho vùng chính và lịch sử log cố định, không phải sửa đổi đồng thời tùy ý. Áp dụng một log cũ còn giữ lên các thay đổi mới không liên quan có thể ghi đè chúng. Mô hình giả định phục hồi kiểm soát trạng thái và phát lại toàn bộ phần lịch sử đã commit còn liên quan theo thứ tự. Nó không cho ứng dụng đọc đồng thời các giá trị mới dựng được một phần.
Giữ log tới khi checkpoint đã được lưu bền
Checkpoint chuyển nội dung log đã commit về vùng chính để phục hồi không phải giữ mãi cùng lịch sử. Trong mô hình không có bên đọc này, thứ tự an toàn là giữ log bền, chép đầy đủ trạng thái đã commit vào vùng chính, xác lập việc lưu bền vùng chính, rồi mới bỏ log đã hết cần thiết. Chỉ chép byte mà chưa hoàn thành bước lưu bền cần thiết là chưa đủ.
Phần bàn về checkpoint của SQLite nêu thứ tự quan trọng: đồng bộ WAL trước khi chuyển nội dung vào cơ sở dữ liệu, rồi đồng bộ cơ sở dữ liệu trước khi đặt lại WAL. Bài này giải thích thứ tự ấy, không phải hướng dẫn đầy đủ để xóa an toàn log của một cơ sở dữ liệu đang hoạt động.
Chạy tiếp trong cùng phiên Python để xem hai trạng thái cố ý sai và một checkpoint đã hoàn tất hợp lệ:
# Deliberately invalid: home changed before the commit became durable.
mixed = {"x": 10, "y": 0}
assert recover(mixed, records[:2]) == mixed
assert mixed not in [initial, {"x": 10, "y": 20}]
# Deliberately invalid: discard the log before home is fully persisted.
assert recover(mixed, []) == mixed
# Valid completed checkpoint in this no-reader, single-writer model.
complete_home = {"x": 10, "y": 20}
assert recover(complete_home, []) == complete_home
# Redo uses assignments, including the latest assignment within a transaction.
repeated = [("set", "x", 5), ("set", "x", 7), ("commit",)]
assert recover(initial, repeated) == {"x": 7, "y": 0}
assert recover(recover(initial, repeated), repeated) == {"x": 7, "y": 0}
Ca sai đầu lưu bền x quá sớm, trước khi commit được lưu bền. Phục hồi bỏ giao dịch chưa đủ nhưng không thể hoàn tác x đã đổi, để lại trạng thái không phải toàn bộ cũ hay toàn bộ mới. Ca thứ hai bỏ log khi y còn cũ, làm mất thông tin mô hình cần để hoàn tất cập nhật.
Ở ca hợp lệ, cả hai giá trị vùng chính đã lưu bền trước khi log trở thành rỗng. Khi đó phát lại log rỗng trả trạng thái đã commit. Tái sử dụng log thật còn cần cơ chế tránh nhầm byte cũ với bản ghi hiện tại. Định dạng SQLite dùng salt và checksum tích lũy để xác định frame hợp lệ; các tuple được tin cậy ở đây không phát hiện bản ghi bị ghi dở, không đóng khung byte, không có checksum hay định danh thế hệ.
Tách commit bền, chuyển phản hồi và hoàn tất checkpoint
Nếu hứa dữ liệu sống sót qua mất điện, phản hồi thành công phải tôn trọng ranh giới log bền cần thiết. Nó không nhất thiết phải chờ mọi trang chính được checkpoint. Tuy nhiên, sự cố sau commit bền nhưng trước khi khách nhận phản hồi có thể làm khách không biết kết quả: phục hồi vẫn bao gồm giao dịch dù bên gọi chưa từng thấy thành công.
Sự không chắc chắn ấy không biến mất chỉ vì replay lưu trữ dùng phép gán có thể lặp. Một lần thử lại ở ứng dụng có thể là thao tác nghiệp vụ mới, nhất là với bộ đếm, thanh toán hay thông điệp gửi ra ngoài. Định danh yêu cầu và ý nghĩa của retry là bài toán thiết kế riêng; ví dụ không chứng minh hiệu ứng bên ngoài xảy ra đúng một lần.
Thiết lập lưu bền cũng quan trọng. Tài liệu WAL của SQLite phân biệt đồng bộ WAL ở mỗi commit với synchronous=FULL và bỏ lần đồng bộ commit đó với NORMAL; ở cấu hình sau, commit gần đây có thể mất sau mất điện hay reset cứng. Vì vậy chỉ nói “đã commit”, thiếu cấu hình và mô hình sự cố, là quá mơ hồ để suy ra lời hứa lưu bền.
Bên đọc thật làm tiến độ checkpoint phức tạp hơn. SQLite cho giao dịch đọc một mốc cuối trong log; bên đọc kéo dài có thể hạn chế checkpoint đi xa tới đâu. Mô hình cố ý không có bên đọc như vậy, nên khả năng bỏ toàn bộ lịch sử đã commit không phải chỉ dẫn tự cắt ngắn WAL đang dùng. Tài liệu về tệp WAL coi nó là một phần trạng thái lưu bền của cơ sở dữ liệu.
Để luyện tập, thêm hai giao dịch nối tiếp, trong đó có nhiều phép gán cho cùng khóa. Thử mọi tiền tố log với một đối chứng chỉ áp dụng giao dịch có dấu commit hiện diện. Sau đó ngắt việc chép vùng chính sau từng tập con các khóa của một giao dịch đã commit và kiểm tra phục hồi vẫn tới cùng trạng thái cuối. Giữ log đầy đủ cho tới ranh giới lưu bền vùng chính cuối cùng; bỏ sớm phải tái hiện lỗi cụ thể, không được âm thầm làm phép thử vẫn thành công.