Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Hi guys, let's get started. A round of applause for DJ Cash, thank you.
Chào các bạn, bắt đầu thôi. Một tràng pháo tay cho DJ Cash nào, cảm ơn bạn.
I was complimenting how great of a DJ you are, but there's a lot of coverage today, so he's great, this is great, let's go. Project 4, the recitation, the video is available on...
Tôi đang khen bạn ấy làm DJ giỏi thế nào, nhưng hôm nay có rất nhiều nội dung cần bao phủ, nên bạn ấy giỏi, thế là tuyệt rồi, bắt đầu nào. Về Project 4, buổi thảo luận, video có sẵn trên...
actually, I think that 280 is wrong. I posted it this morning, but the recitation was last night. Slides are available, the video is available.
thực ra, tôi nghĩ 280 bị sai. Tôi đã đăng nó sáng nay, nhưng buổi thảo luận diễn ra tối qua. Slide đã có, video cũng đã có.
Homework 5 is due this Sunday coming up, and then again, the final exam will be on December 11th, and there's one more homework after this.
Bài tập về nhà 5 hạn nộp là Chủ nhật này, và nhắc lại, kỳ thi cuối kỳ sẽ diễn ra vào ngày 11 tháng 12, và sau bài này còn một bài tập về nhà nữa.
Alright, so, remember last class we were talking about, the first lecture of how we're going to handle logging and recovery in our database system.
Được rồi, hãy nhớ lại buổi trước chúng ta đã nói về bài giảng đầu tiên về cách chúng ta xử lý việc ghi log và khôi phục trong hệ quản trị cơ sở dữ liệu.
And obviously the reason why we need to do this is because if we write some data, we tell the outside world your transaction is committed, no matter what happens, we don't want to lose that data.
Và rõ ràng lý do chúng ta cần làm điều này là vì nếu ta ghi một số dữ liệu, ta báo cho thế giới bên ngoài biết giao dịch của bạn đã được commit, thì dù có chuyện gì xảy ra, ta cũng không muốn mất dữ liệu đó.
So we crash, if the OS crashes, the database system crashes, the hardware crashes, whatever, we need to come back and restore those changes.
Vì vậy nếu hệ điều hành bị sập, hệ quản trị cơ sở dữ liệu bị sập, phần cứng bị hỏng, bất kể điều gì, ta cần quay lại và khôi phục những thay đổi đó.
And then recall from last class, I said that every recovery protocol you're going to have in a database system is going to have two parts.
Và hãy nhớ lại từ buổi trước, tôi đã nói rằng mọi giao thức khôi phục mà bạn có trong một hệ quản trị cơ sở dữ liệu đều có hai phần.
The first part is what we talked about last class, was all the things you do during normal operations to ensure that when there's a crash later on, that you can recover.
Phần đầu tiên là điều chúng ta đã nói ở buổi trước, tức là tất cả những việc bạn làm trong quá trình hoạt động bình thường để đảm bảo rằng khi có sự cố sập về sau, bạn có thể khôi phục.
So we talked about how we're going to maintain this write-ahead log, in most systems, that we're just going to record all the things that we're doing, all the changes that transactions are making as they go along.
Chúng ta đã nói về cách duy trì write-ahead log này, trong hầu hết các hệ thống, theo đó ta chỉ ghi lại tất cả những gì ta đang làm, tất cả các thay đổi mà các giao dịch thực hiện trong quá trình chạy.
So then now, today's class is the second part, where we start talking about, after now there's a crash, the system comes back online, and we're going to look at all the data we recorded for ourselves during the normal operation to try to reconstruct the database to be what it was at the moment that it crashed.
Vậy bài hôm nay là phần thứ hai, nơi ta bắt đầu nói về việc sau khi có sự cố sập, hệ thống hoạt động trở lại, và ta sẽ xem xét tất cả dữ liệu mà ta đã ghi lại cho chính mình trong quá trình hoạt động bình thường để cố gắng dựng lại cơ sở dữ liệu về trạng thái của nó tại thời điểm bị sập.
But of course, we can't resume any crashed transactions.
Nhưng tất nhiên, ta không thể tiếp tục các giao dịch đã bị sập.
We need to make sure that we clean all those guys up and roll back any of their changes so we don't have any torn writes or partial transactions.
Ta cần đảm bảo dọn dẹp tất cả những giao dịch đó và rollback mọi thay đổi của chúng để không có torn write hay giao dịch dang dở.
So again, we're going to restore the database basically to the state it was at the moment of the crash. So again, with write-ahead log, in our buffer pool, it means steal, no-force policy.
Vậy một lần nữa, về cơ bản ta sẽ khôi phục cơ sở dữ liệu về trạng thái mà nó có tại thời điểm xảy ra sự cố. Một lần nữa, với write-ahead log, trong buffer pool của ta, nó có nghĩa là chính sách steal, no-force.
Steal means that we're allowed to evict dirty pages before the transactions that modified those pages are committed.
Steal nghĩa là ta được phép đẩy ra các trang bẩn trước khi các giao dịch đã sửa đổi những trang đó được commit.
And then no-force says we're not required to flush all the dirty pages for transactions at the moment that they commit.
Còn no-force nghĩa là ta không bắt buộc phải flush tất cả các trang bẩn của giao dịch ngay tại thời điểm chúng commit.
And since transactions may abort or fail during normal operations, again, we want to make sure we can roll back those changes and ensure that everything's atomic.
Và vì các giao dịch có thể abort hoặc thất bại trong quá trình hoạt động bình thường, một lần nữa, ta muốn đảm bảo có thể rollback những thay đổi đó và bảo đảm mọi thứ có tính nguyên tử.
So basically, we're trying to deal with the state of the world like this. So say we're running some transactions, all of a sudden there's a crash.
Về cơ bản, ta đang cố xử lý trạng thái của thế giới như thế này. Giả sử ta đang chạy một số giao dịch, đột nhiên có sự cố sập.
The top guy, T1, has committed, we make sure we keep its changes. T2 did not commit, it aborted, make sure we roll back its changes.
T1 ở trên cùng đã commit, nên ta đảm bảo giữ lại các thay đổi của nó. T2 không commit mà bị abort, nên ta đảm bảo roll back các thay đổi của nó.
And then T3 didn't complete before the crash, and therefore we make sure none of its changes survived after the crash.
Còn T3 thì chưa hoàn tất trước khi xảy ra sự cố, nên ta phải đảm bảo không có thay đổi nào của nó còn lại sau sự cố.
So again, the last class was about, okay, what are we going to put in the write-ahead log, the undo and redo records, so that we can recover after a crash.
Vậy buổi trước nói về việc, chúng ta sẽ đưa gì vào write-ahead log, các bản ghi undo và redo, để có thể phục hồi sau sự cố.
And then we quickly talked about a sort of naive checkpointing scheme at the end of the class so that we don't have to replay the entire log, but we said they had a bunch of problems, and that's what we're going to fix today.
Rồi cuối buổi ta cũng nói qua một sơ đồ checkpoint khá đơn giản để không phải phát lại toàn bộ log, nhưng ta đã nói là nó có nhiều vấn đề, và hôm nay ta sẽ khắc phục chúng.
So now, the protocol we're going to learn about today is called ARIES: the Algorithms for Recovery and Isolation Exploiting Semantics. Like, it's so important, it has its own Wikipedia article about it.
Giao thức mà hôm nay ta sẽ học có tên là ARIES: Algorithms for Recovery and Isolation Exploiting Semantics. Nó quan trọng đến mức có hẳn một bài viết trên Wikipedia.
And this was a, this is work developed at IBM Research as part of the DB2 project. So this is, you know, building a relational system, it's not IMS stuff.
Đây là công trình được phát triển tại IBM Research trong dự án DB2. Tức là xây dựng một hệ quan hệ, chứ không phải thứ như IMS.
And this is basically the gold standard of how you would, how you want to implement a transaction recovery, or sorry, a recovery protocol in your database system to ensure that you don't, you don't lose any changes.
Và về cơ bản đây là chuẩn mực vàng về cách bạn muốn triển khai việc phục hồi giao dịch, à nhầm, một giao thức phục hồi trong hệ cơ sở dữ liệu để đảm bảo rằng bạn không mất bất kỳ thay đổi nào.
So there was obviously, you know, this paper came out in '92. There are people who have been doing database recovery protocols for a while.
Dĩ nhiên bài báo này ra đời năm 92. Trước đó đã có người làm các giao thức phục hồi cơ sở dữ liệu một thời gian rồi.
One of the key differences that we'll see in ARIES is that it's going to be overly careful to make sure we don't lose anything.
Một khác biệt chính mà ta sẽ thấy ở ARIES là nó cực kỳ cẩn trọng để đảm bảo không mất gì cả.
I'd rather do, I'd rather make sure I'm super careful and then slowly peel back some of the pieces to make it faster. But I want to make sure I don't lose anything first.
Tôi thà đảm bảo thật sự cẩn thận trước rồi từ từ gỡ bớt một số phần để làm nó nhanh hơn. Nhưng trước hết tôi muốn chắc chắn là không mất gì.
And we'll see as we go along, there's, the ARIES protocol has its three phases: the analyze or analysis, the redo and the undo.
Và ta sẽ thấy dần, giao thức ARIES có ba pha: phân tích, redo và undo.
And what differs from what ARIES does, from what other data systems were doing prior to this paper, is that sometimes they were doing the redo first and sometimes they were doing the undo first.
Điểm ARIES khác với các hệ dữ liệu khác trước bài báo này là đôi khi họ làm redo trước và đôi khi lại làm undo trước.
But this thing is going to be super careful and make sure that you do the redo first followed by the undo.
Còn ARIES thì rất cẩn trọng và đảm bảo làm redo trước rồi mới đến undo.
And then once you finish that last phase, then you see that now the database is fully returned back to the correct state and you can start running transactions again.
Và khi bạn hoàn thành pha cuối cùng đó, thì cơ sở dữ liệu đã được đưa hoàn toàn về trạng thái đúng và bạn có thể bắt đầu chạy lại các giao dịch.
So again, I've said this many times before, I'm going to go through what ARIES does, but the exact implementation from different data systems is going to vary slightly.
Tôi đã nói nhiều lần rồi, tôi sẽ trình bày những gì ARIES làm, nhưng cách triển khai cụ thể ở các hệ dữ liệu khác nhau sẽ hơi khác nhau.
But the three phase piece and the CLR stuff we'll talk about in a second, that's the key ideas that everyone should be doing to ensure that everything's recoverable.
Nhưng phần ba pha và phần CLR mà lát nữa ta sẽ nói, đó là những ý tưởng then chốt mà ai cũng nên áp dụng để đảm bảo mọi thứ có thể phục hồi được.
The paper is beautiful. It's 70 pages. It's not an easy read.
Bài báo rất hay. Dài 70 trang. Không dễ đọc đâu.
And there's a bunch of things that they're going to cover that we're not going to cover, like how do you handle different isolation levels for transactions running at the same time.
Và có nhiều nội dung mà họ đề cập nhưng ta sẽ không đề cập, như cách xử lý các mức cô lập khác nhau cho các giao dịch chạy cùng lúc.
We're going to keep our lives simple and assume we're running everything in strong, strict 2PL, so we get serializable transactions. All right, so there's three main ideas for ARIES.
Chúng ta sẽ giữ mọi thứ đơn giản và giả định rằng mọi thứ đều chạy theo 2PL chặt, strict 2PL, để có được các giao dịch khả tuần tự. Được rồi, ARIES có ba ý tưởng chính.
The first one, we've already covered, is that we're going to maintain a write-ahead log during normal operations, where we record all the changes that transactions make to objects in our database.
Ý đầu tiên, chúng ta đã học rồi, là duy trì một write-ahead log trong quá trình hoạt động bình thường, trong đó ta ghi lại mọi thay đổi mà các giao dịch thực hiện lên các đối tượng trong cơ sở dữ liệu.
But we're going to have to record them to the log first before we apply the changes to the actual objects.
Nhưng ta phải ghi chúng vào log trước rồi mới áp dụng các thay đổi lên chính các đối tượng.
And then we said last class that we have to make sure that the log records that correspond to changes to objects, those things have to be written to disk before the modified objects, or the dirty pages, before they're allowed to be written to disk.
Và ở buổi trước chúng ta đã nói rằng phải đảm bảo các bản ghi log tương ứng với những thay đổi lên đối tượng, những thứ đó phải được ghi xuống đĩa trước các đối tượng đã bị sửa, hay các trang bẩn, trước khi những trang đó được phép ghi xuống đĩa.
All right, so we can't write the dirty page and then later on write a log record, because if we crash and come back, the log record may not have made it out, but now we have a page that made a change and we don't know what changed it or how that changed.
Vậy nên ta không thể ghi trang bẩn trước rồi mới ghi bản ghi log sau, vì nếu hệ thống sập rồi khởi động lại, bản ghi log có thể chưa kịp được ghi ra, nhưng lúc này ta có một trang đã bị thay đổi mà không biết cái gì đã thay đổi nó hay nó đã thay đổi như thế nào.
The next idea that we're going to do is that we're going to repeat our history during the redo phase upon recovery.
Ý tưởng tiếp theo là ta sẽ lặp lại lịch sử của mình trong pha redo khi khôi phục.
So that means that we're going to look at our write-ahead log, look at all the changes transactions made during the normal operation, and we're going to just redo everything.
Nghĩa là ta sẽ xem write-ahead log, xem tất cả các thay đổi mà giao dịch đã thực hiện trong quá trình hoạt động bình thường, và ta sẽ redo tất cả.
Even if some of those changes actually made it out to disk, we're going to be super cautious and we're going to say, I'm going to make sure you really got this, and we'll go ahead and apply those changes.
Kể cả khi một số thay đổi đó thực ra đã được ghi xuống đĩa, ta vẫn cực kỳ thận trọng và nói rằng, tôi sẽ chắc chắn là bạn thực sự có được thay đổi này, và ta cứ tiến hành áp dụng các thay đổi đó.
And then the last piece is that when we start undoing the effects of transactions, undoing operations of transactions, Because they got aborted or they crashed, they crashed before the system, they didn't commit before the system crashed, we're now actually going to maintain additional write-ahead log records that correspond to the reversal operations
Và phần cuối cùng là khi ta bắt đầu hoàn tác tác động của các giao dịch, hoàn tác các thao tác của giao dịch, vì chúng bị hủy hoặc bị sập, chúng chưa kịp trước khi hệ thống sập, chúng chưa commit trước khi hệ thống sập, thì giờ đây ta sẽ duy trì thêm các bản ghi write-ahead log tương ứng với các thao tác đảo ngược
that we're going to do as part of the undo step.
mà ta thực hiện trong bước undo.
Basically, you get a log record for any time you make a change, and then if a transaction aborts and you roll it back, now I'm going to have log records to reverse those changes.
Về cơ bản, mỗi lần bạn thay đổi gì đó là có một bản ghi log, và nếu một giao dịch bị hủy và bạn rollback nó, thì giờ tôi sẽ có các bản ghi log để đảo ngược những thay đổi đó.
Because, again, I want to know exactly what's happening in my data system on my pages, and so I want to record everything that I do.
Bởi vì, một lần nữa, tôi muốn biết chính xác điều gì đang xảy ra trong hệ dữ liệu của mình, trên các trang của mình, nên tôi muốn ghi lại mọi thứ mình làm.
So we'll start off talking about the log sequence numbers and how we're going to start keeping track of the order of these operations that transactions are doing, and then we'll talk about how we do a normal commit and an abort during regular runtime.
Vì vậy ta sẽ bắt đầu với các log sequence number và cách ta bắt đầu theo dõi thứ tự của các thao tác mà giao dịch thực hiện, rồi sau đó ta sẽ nói về cách commit bình thường và abort trong lúc chạy thông thường.
Then we'll build or design a better checkpointing algorithm called fuzzy checkpoints, where we don't have to block all the transactions while we're running in the system.
Sau đó ta sẽ xây dựng hay thiết kế một thuật toán checkpoint tốt hơn gọi là fuzzy checkpoint, trong đó ta không phải chặn tất cả các giao dịch khi hệ thống đang chạy.
And then we'll put it all together and finish up with ARIES.
Rồi ta sẽ kết hợp tất cả lại và kết thúc với ARIES.
And then we have the Clickhouse guys giving a talk with us today, and so we'll cut rid of that at the end, and if we run out of time, we're not getting full ARIES, we can pick up on that on Monday next week.
Và hôm nay chúng ta có các bạn từ Clickhouse đến nói chuyện cùng chúng ta, và vì vậy chúng ta sẽ bỏ phần đó ở cuối bài, và nếu hết thời gian thì chúng ta sẽ không học được trọn vẹn ARIES, chúng ta có thể tiếp tục vào thứ Hai tuần sau.
And again, during this discussion, today's lecture, I'm going to be very conservative and very careful about how our recovery scheme is going to be implemented, and that means we're going to end up writing a bunch of redundant information, but that's okay because we don't want to lose anything.
Và một lần nữa, trong phần thảo luận của bài giảng hôm nay, tôi sẽ rất thận trọng và rất cẩn thận về cách cài đặt cơ chế khôi phục của chúng ta, và điều đó có nghĩa là chúng ta sẽ phải ghi ra khá nhiều thông tin dư thừa, nhưng không sao, vì chúng ta không muốn mất bất cứ thứ gì.
And there's some optimizations we can talk about at the end where you can start tweaking some of this to maybe not do everything with so much verbosity as, again, the textbook or as the ARIES paper describes it.
Và có một số tối ưu hóa mà chúng ta có thể bàn đến ở cuối bài, trong đó bạn có thể bắt đầu điều chỉnh một số phần để có thể không làm mọi thứ dài dòng đến vậy như giáo trình hay bài báo về ARIES mô tả.
But keep it simple, we'll ignore it in the beginning.
Nhưng hãy cứ giữ cho đơn giản, ban đầu chúng ta sẽ bỏ qua chúng.
All right, so the first thing we need to do is extend our write-ahead log record, the log objects or records we talked about last time, including some additional information.
Được rồi, việc đầu tiên cần làm là mở rộng bản ghi nhật ký ghi trước (write-ahead log) của chúng ta, các đối tượng hay bản ghi nhật ký mà chúng ta đã nói ở buổi trước, bằng cách thêm một số thông tin bổ sung.
And when I showed the log records before, I'm kind of appending them in sequential order and I was only showing like one or two transactions running at a time.
Và khi tôi trình bày các bản ghi nhật ký trước đây, tôi chỉ nối chúng vào theo thứ tự tuần tự và chỉ cho thấy khoảng một hai giao dịch chạy cùng lúc.
But now if you have maybe hundreds or thousands of transactions running at the same time, you kind of want to know what the true order of these operations that are getting applied, especially if they're happening to different pages at the same time.
Nhưng giờ nếu có hàng trăm hoặc hàng nghìn giao dịch chạy cùng một lúc, bạn sẽ muốn biết thứ tự thực sự của các thao tác đang được áp dụng này, đặc biệt là khi chúng diễn ra trên các trang khác nhau cùng lúc.
So now every log record is going to now record and be provided a globally unique, monotonically increasing log sequence number.
Vì vậy giờ mỗi bản ghi nhật ký sẽ được ghi nhận và cấp một số thứ tự nhật ký duy nhất toàn cục, tăng đơn điệu (log sequence number).
You can think of this a little bit like the timestamp we talked about with transactions in OCC, where the transactions are assigned these globally unique timestamps.
Bạn có thể hình dung nó hơi giống dấu thời gian mà ta đã nói về các giao dịch trong OCC, nơi các giao dịch được gán những dấu thời gian duy nhất toàn cục này.
Every log record is now going to be assigned a globally unique log sequence number. And this is going to represent the physical order in which the changes are applied to pages.
Giờ mỗi bản ghi nhật ký sẽ được gán một log sequence number duy nhất toàn cục. Và nó biểu diễn thứ tự vật lý mà các thay đổi được áp dụng lên các trang.
The logical order is the timestamp stuff up above. So we're still running two-phase locking or OCC or whatever you want up above in the rest of the system.
Thứ tự logic là phần dấu thời gian ở tầng trên. Vì vậy ở tầng trên, trong phần còn lại của hệ thống, chúng ta vẫn chạy khóa hai pha hoặc OCC hay bất cứ thứ gì bạn muốn.
But now when I actually write log records to disk, this log sequence number is going to correspond to the physical order in which those things actually occur.
Nhưng giờ khi thực sự ghi các bản ghi nhật ký xuống đĩa, log sequence number này sẽ tương ứng với thứ tự vật lý mà các việc đó thực sự xảy ra.
And now other parts of the system need to be aware of these log sequence numbers, because it's going to determine when they're allowed to do certain things with pages.
Và giờ các phần khác của hệ thống cần biết về các log sequence number này, vì nó sẽ quyết định khi nào chúng được phép làm một số việc nhất định với các trang.
So again, we have the log sequence number. That can increase every time we make a new record.
Vậy là chúng ta có log sequence number. Nó có thể tăng lên mỗi khi ta tạo một bản ghi mới.
But now in every page in our database, whether it's an index page or a table page, doesn't matter what it is, it's going to have this page LSN record that's going to keep track of the most recent log record that modified the contents of that page.
Nhưng giờ trong mỗi trang của cơ sở dữ liệu, dù là trang chỉ mục hay trang bảng, loại nào cũng được, sẽ có bản ghi page LSN này, dùng để theo dõi bản ghi nhật ký gần nhất đã sửa đổi nội dung của trang đó.
So again, everything in the header, every data page, now we're going to have this page LSN. And some of them are going to point to log records that are on disk.
Vậy nên, mọi thứ trong phần đầu trang, mọi trang dữ liệu, giờ chúng ta sẽ có page LSN này. Và một số trong đó sẽ trỏ tới các log record nằm trên đĩa.
Some of them are going to point to log records that are still in memory in our log buffer. And then now there's a global LSN called the flush LSN.
Một số khác sẽ trỏ tới các log record vẫn còn nằm trong bộ nhớ, trong log buffer của chúng ta. Và tiếp theo có một LSN toàn cục gọi là flush LSN.
The DBMS keeps track of what is the largest log sequence number for a log record that's been flushed to disk.
DBMS theo dõi xem log sequence number lớn nhất của một log record đã được flush xuống đĩa là bao nhiêu.
So it's basically the dividing point, the demarcation line of where the disk buffer stops and where the in-memory buffer continues.
Về cơ bản nó là điểm phân chia, đường ranh giới cho biết phần buffer trên đĩa kết thúc ở đâu và phần buffer trong bộ nhớ bắt đầu từ đâu.
And so again, as I said before, now we talked about how we need to make sure that the log record that modified a page and made it dirty, make sure that that gets written to disk before we can write the dirty page to disk.
Và như tôi đã nói trước đó, chúng ta đã bàn về việc cần đảm bảo rằng log record đã sửa đổi một trang và làm trang đó thành dirty phải được ghi xuống đĩa trước khi chúng ta có thể ghi trang dirty đó xuống đĩa.
These LSNs are how we're going to be able to do this now. So now in your buffer pool manager, in your eviction algorithm, it has to be aware of what's my flush LSN.
Các LSN này chính là cách để chúng ta làm được điều đó. Vậy trong buffer pool manager, trong thuật toán eviction của bạn, nó phải biết flush LSN của mình là bao nhiêu.
And now as you start examining pages to determine whether they can be evicted or not, you go look at the page LSN in the header and you see whether it's less than or equal to the flush LSN.
Và khi bạn bắt đầu xem xét các trang để quyết định có thể evict chúng hay không, bạn xem page LSN trong header và kiểm tra xem nó có nhỏ hơn hoặc bằng flush LSN hay không.
If it is, then you know that the log record that modified that page last is out on disk.
Nếu có, thì bạn biết rằng log record sửa đổi trang đó gần nhất đã nằm trên đĩa.
If the page LSN is greater than this, then you know there's some log record hanging out in DRAM and therefore you can't flush that page.
Nếu page LSN lớn hơn flush LSN, thì bạn biết có một log record nào đó vẫn còn trong DRAM và do đó bạn không thể flush trang đó.
So now you do a bunch of things like, all right, well, I really want to, my eviction policy says I really want to flush this page, but my log record for it is still in memory.
Lúc này bạn có thể làm một số việc, kiểu như: được rồi, tôi thực sự muốn, chính sách eviction nói rằng tôi thực sự muốn flush trang này, nhưng log record của nó vẫn còn trong bộ nhớ.
So you could have your buffer pool then decide, oh, go flush the log buffer by doing one of the group commit stuff, make that happen earlier than it normally would.
Vậy buffer pool có thể quyết định rằng, à, hãy flush log buffer bằng cách dùng cơ chế group commit, cho việc đó xảy ra sớm hơn bình thường.
And then when that comes back with an acknowledgement, then you can go flush, you can flush out the page, evict it.
Và khi có phản hồi xác nhận quay về, thì bạn có thể flush trang đó và evict nó.
So these LSNs are going to show up in a bunch of different places. We talked about the page LSN and the flush LSN.
Vì vậy các LSN này sẽ xuất hiện ở khá nhiều nơi khác nhau. Chúng ta đã nói về page LSN và flush LSN.
Flush LSN hangs out in memory because it's the last LSN of the log record on disk. Page LSN is the latest LSN that last modified a page.
Flush LSN nằm trong bộ nhớ vì nó là LSN cuối cùng của log record trên đĩa. Page LSN là LSN mới nhất đã sửa đổi một trang gần nhất.
But for every single page, we're also going to keep track of the recLSN, which is going to be the oldest update that modified this page since that page was last flushed to disk.
Nhưng với mỗi trang, chúng ta cũng sẽ theo dõi recLSN, tức là bản cập nhật cũ nhất đã sửa đổi trang này kể từ lần trang được flush xuống đĩa gần nhất.
And you don't actually have to store this in the page itself. We're going to have two separate data structures we'll cover in a second, called the dirty page table and the active transaction table.
Và thực ra bạn không cần lưu nó trong chính trang đó. Chúng ta sẽ có hai cấu trúc dữ liệu riêng biệt mà lát nữa sẽ nói tới, gọi là dirty page table và active transaction table.
So unlike the page LSN, where in the header of the page you put the LSN that modified it last, the recLSN just hangs out in memory, and it's going to correspond to the LSN that first modified the page since it was last flushed and written to disk.
Vậy không như page LSN, nơi bạn đặt LSN sửa đổi trang gần nhất vào header của trang, recLSN chỉ nằm trong bộ nhớ, và nó tương ứng với LSN đầu tiên đã sửa đổi trang kể từ lần trang được flush và ghi xuống đĩa gần nhất.
The lastLSN for every transaction is, we keep track of the latest, the most recent log record for any transaction that's actually running in our system.
Còn lastLSN của mỗi transaction thì chúng ta theo dõi cái mới nhất, bản ghi log gần nhất của bất kỳ giao dịch nào đang thực sự chạy trong hệ thống của chúng ta.
So if it aborts, we know how to jump to the lastLSN and start working our way backwards, undoing changes.
Vì vậy nếu nó abort, ta biết cách nhảy tới lastLSN và bắt đầu đi ngược lại, hoàn tác các thay đổi.
And then a special one called the master record will be a global LSN that's going to keep track of the beginning point of the last checkpoint that's successfully completed in our write-ahead log.
Và sau đó có một LSN đặc biệt gọi là master record, là một LSN toàn cục dùng để theo dõi điểm bắt đầu của checkpoint gần nhất đã hoàn tất thành công trong write-ahead log của chúng ta.
Remember, we said when we take a checkpoint, we have to write a log record that says I'm taking a checkpoint.
Hãy nhớ rằng ta đã nói là khi thực hiện một checkpoint, ta phải ghi một bản ghi log nói rằng tôi đang thực hiện checkpoint.
So the master record will keep track of when that last checkpoint that completed successfully, when that started, where to go find that in the log.
Vì vậy master record sẽ theo dõi xem checkpoint gần nhất đã hoàn tất thành công đó, nó bắt đầu khi nào, và tìm nó ở đâu trong log.
All right, so now we go back to our example we had before. We have now a write-ahead log, it hangs out in memory. We have a buffer pool, we're bringing in pages.
Được rồi, bây giờ ta quay lại ví dụ lúc trước. Giờ ta có một write-ahead log nằm trong bộ nhớ. Ta có một buffer pool, đang nạp các trang vào.
And then now we see that in our write-ahead log we're including these LSNs, right? This is monotonically increasing by one every time we get a new log record.
Và bây giờ ta thấy trong write-ahead log ta có kèm các LSN này, đúng không? Nó tăng đơn điệu thêm một mỗi khi có một bản ghi log mới.
And then we have now in our pages, for data pages, we have a page LSN. And they can be different in memory versus on disk.
Và trong các trang, với các trang dữ liệu, ta có một page LSN. Và chúng có thể khác nhau giữa trong bộ nhớ và trên đĩa.
So whenever it gets written out, then obviously the on-disk one gets updated. Then you have this flush LSN that's just going to correspond to what's the last LSN that made it out to disk.
Vì vậy mỗi khi nó được ghi ra, thì dĩ nhiên bản trên đĩa được cập nhật. Rồi bạn có flush LSN này, chỉ tương ứng với LSN cuối cùng đã được ghi ra đĩa.
And that may exist in your buffer pool in memory or not. Sorry, in the log buffer that's in memory, it may still be in there, but I don't care about that.
Và nó có thể vẫn còn trong buffer pool trong bộ nhớ hoặc không. Xin lỗi, trong log buffer nằm trong bộ nhớ, nó có thể vẫn còn ở đó, nhưng tôi không quan tâm điều đó.
I just care about, you know, I'm pointing basically to the last entry I have on my log on disk. I have my master record, that's going to hang out on disk too.
Tôi chỉ quan tâm, về cơ bản tôi đang trỏ tới mục cuối cùng của log trên đĩa. Tôi có master record, cái này cũng nằm trên đĩa.
Again, that's just going to point to the starting point of the last checkpoint that I took.
Một lần nữa, nó chỉ trỏ tới điểm bắt đầu của checkpoint gần nhất mà tôi đã thực hiện.
Because I'm going to use that as a way to jump into the log and figure out what was going on at the time of the crash.
Vì tôi sẽ dùng nó để nhảy vào log và tìm hiểu điều gì đang diễn ra vào lúc xảy ra sự cố.
So if my page LSN points to something that's on disk, can I flush it?
Vậy nếu page LSN của tôi trỏ tới thứ đã có trên đĩa, tôi có thể flush không?
Say I need to modify this page and I want to write it out to disk. My page LSN points to something in the log. Can I flush it?
Giả sử tôi cần sửa trang này và muốn ghi nó ra đĩa. Page LSN của tôi trỏ tới một thứ trong log. Tôi có thể flush không?
Yes, because I know the log record that corresponds to that change made it out to disk. So it's safe to flush this.
Có, vì tôi biết bản ghi log tương ứng với thay đổi đó đã được ghi ra đĩa. Nên flush trang này là an toàn.
But now if my page LSN points to something that's still in memory, and I know that that LSN is greater than my flush LSN, then I know it's not safe to flush this because the log record for it hasn't made it out.
Nhưng bây giờ nếu page LSN của tôi trỏ tới thứ vẫn còn trong bộ nhớ, và tôi biết LSN đó lớn hơn flush LSN của tôi, thì tôi biết flush trang này là không an toàn vì bản ghi log của nó chưa được ghi ra.
So these LSNs are simple watermarks for us to determine what's on disk, what's in memory, for both pages and for log records.
Vì vậy các LSN này là những mốc đơn giản để ta xác định cái gì ở trên đĩa, cái gì ở trong bộ nhớ, cho cả các trang lẫn các bản ghi log.
So I've already said this: every log record has an LSN.
Tôi đã nói rồi: mọi bản ghi log đều có một LSN.
And then every time we're going to modify a page, we're going to create the log record, get an LSN that corresponds to the change we're making to the page.
Và mỗi khi ta sắp sửa một trang, ta sẽ tạo bản ghi log, lấy một LSN tương ứng với thay đổi ta đang thực hiện trên trang.
Then now when we go modify the page, we also go update the page LSN that sits in the header.
Rồi bây giờ khi ta tiến hành sửa trang, thì chúng ta cũng cập nhật page LSN nằm trong phần header.
And we have the right latch on the page, so we can go ahead and do that.
Và chúng ta đang giữ latch phù hợp trên page, nên có thể tiến hành việc đó.
Then every single time we flush out the write-ahead log, in a group commit process or when the log buffer gets full, then we update the flush LSN to determine where the endpoint is for the log on disk.
Sau đó, mỗi lần chúng ta ghi write-ahead log xuống đĩa, trong quá trình group commit hoặc khi log buffer đầy, thì chúng ta cập nhật flush LSN để xác định điểm cuối của log trên đĩa nằm ở đâu.
All right, so normal execution, it's basically all the stuff that I just talked about, right?
Được rồi, vậy là quá trình thực thi bình thường, về cơ bản là tất cả những gì tôi vừa nói, đúng không?
The transaction makes changes, and we want to record those changes in our write-ahead log before we go apply the changes to the pages themselves.
Giao dịch thực hiện các thay đổi, và chúng ta muốn ghi lại các thay đổi đó vào write-ahead log trước khi áp dụng các thay đổi lên chính các page.
So to simplify our discussion today, the assumption we're going to make is that we're going to assume that all our log records fit in a single page, right?
Để đơn giản hóa phần thảo luận hôm nay, giả định mà chúng ta sẽ đưa ra là chúng ta sẽ coi như mọi log record của chúng ta đều nằm vừa trong một page, đúng không?
Yes, you can have tuples that are larger than a single page, like, you know, 4 kilobytes, 8 kilobytes. But then, you know, obviously, what do you do if the log record expands that?
Đúng là bạn có thể có các tuple lớn hơn một page, chẳng hạn 4 kilobyte, 8 kilobyte. Nhưng khi đó, rõ ràng là phải làm gì nếu log record vượt quá kích thước đó?
You know, you just have a sequence number within the page or segment number.
Bạn chỉ cần có một số thứ tự trong page hoặc số đoạn (segment).
So I would say my log record is too big to fit in a single page, and I would have sort of the first half log record say, I'm segment number 1, 1 of 2, and then the next log record say, I'm segment 2 of 2.
Tức là tôi sẽ nói log record của tôi quá lớn để nằm vừa trong một page, và log record nửa đầu sẽ ghi là: tôi là đoạn số 1, 1 trên 2, rồi log record tiếp theo ghi: tôi là đoạn 2 trên 2.
So you would know, you don't have the first one, not the second one, you don't have the full log record.
Như vậy bạn sẽ biết là bạn có đoạn đầu mà không có đoạn thứ hai, tức là bạn không có log record đầy đủ.
And obviously, you don't update anything to say things are successfully flushed until both of those segments make it out. But we can ignore that for now.
Và rõ ràng, bạn không cập nhật bất cứ thứ gì để báo rằng việc ghi xuống đĩa đã thành công cho đến khi cả hai đoạn đó đều được ghi ra. Nhưng bây giờ chúng ta có thể bỏ qua chuyện đó.
We assume that all our disk writes are going to be, you know, 4 kilobytes atomic writes, right?
Chúng ta giả định mọi lần ghi xuống đĩa đều là các lần ghi nguyên tử 4 kilobyte, đúng không?
If things span multiple pages, you know, just wait for the extra flush to make sure everything's made it out before you tell the outside world you've committed.
Nếu dữ liệu trải trên nhiều page, thì cứ chờ thêm một lần flush nữa để đảm bảo mọi thứ đã được ghi ra hết trước khi báo cho thế giới bên ngoài rằng bạn đã commit.
We're going to assume that the data system is going to be single version running strong strict 2PL. So that means that we won't worry about weird interleavings of transactions upon replay.
Chúng ta sẽ giả định rằng hệ thống dữ liệu là đơn phiên bản (single version) và chạy strong strict 2PL. Như vậy nghĩa là chúng ta không phải lo về những cách đan xen kỳ lạ của các giao dịch khi phát lại.
And of course, we're using write-ahead log. We have to use steal or no-force. We assume we're going to do physical log scheme, physical log scheme or physiological logging.
Và tất nhiên, chúng ta dùng write-ahead log. Chúng ta phải dùng steal hoặc no-force. Chúng ta giả định sẽ dùng cơ chế physical log, cơ chế physical log hoặc physiological logging.
We're not going to do the logical logging where you just have the SQL query in the log record. We basically have the diff of the changes we're making to pages.
Chúng ta sẽ không dùng logical logging, tức là chỉ để câu truy vấn SQL trong log record. Về cơ bản chúng ta có phần diff của các thay đổi mà chúng ta thực hiện lên các page.
And then I'm not going to talk about how you update the pages for indexes as a part of these changes. It works the same way as it would for regular table pages.
Và tôi cũng sẽ không nói về cách cập nhật các page của chỉ mục như một phần của những thay đổi này. Nó hoạt động giống như với các page của bảng thông thường.
But to keep it simple, we're just updating single objects and we'll do physical logging.
Nhưng để cho đơn giản, chúng ta chỉ cập nhật từng đối tượng đơn lẻ và sẽ dùng physical logging.
All right, so when a transaction goes commit, the data system is going to write the commit message to the log buffer in memory.
Được rồi, khi một giao dịch thực hiện commit, hệ thống dữ liệu sẽ ghi thông điệp commit vào log buffer trong bộ nhớ.
And then it can then flush that log buffer out the disk either right away or part of the group commit without, you know, waiting a little bit to get batched together.
Và sau đó nó có thể flush log buffer đó xuống đĩa ngay lập tức hoặc như một phần của group commit mà không cần, bạn biết đấy, chờ một chút để được gom lại thành một lô.
And then once we know that the commit is successful, we can tell the outside world that your transaction has successfully committed.
Và khi đã biết commit thành công, chúng ta có thể báo cho thế giới bên ngoài biết giao dịch của bạn đã commit thành công.
But then now we're also going to introduce a new log record called transaction end that we can append to our in-memory log buffer.
Nhưng giờ chúng ta cũng sẽ đưa vào một bản ghi log mới gọi là transaction end mà chúng ta có thể nối thêm vào log buffer trong bộ nhớ.
And this is being used to represent to the system to keep track of the fact that this transaction has successfully committed and there's nothing else we ever need to do for It ever again.
Bản ghi này được dùng để cho hệ thống biết và theo dõi việc giao dịch này đã commit thành công và chúng ta không bao giờ cần làm thêm gì cho nó nữa.
So in this case here, since the transaction is normally committing, I commit, and then I can put the transaction end message. Once I know it, things are successfully flushed.
Vậy trong trường hợp này, vì giao dịch commit bình thường, tôi commit, rồi tôi có thể đặt thông điệp transaction end. Khi tôi biết mọi thứ đã được flush thành công.
And I don't need to maintain any additional metadata about it later on. This will make more sense when we do recovery.
Và về sau tôi không cần lưu thêm siêu dữ liệu nào về nó nữa. Điều này sẽ dễ hiểu hơn khi chúng ta học về khôi phục.
And we see in this case why we need this transaction end for aborts, when we do aborts. But for commit, it's pretty straightforward.
Và chúng ta sẽ thấy trong trường hợp này vì sao cần transaction end cho abort, khi chúng ta xử lý abort. Còn với commit thì khá đơn giản.
And this transaction end message does not need to be flushed immediately. We can just put that in the log buffer, and then eventually it'll get written out, and that's fine.
Và thông điệp transaction end này không cần flush ngay lập tức. Chúng ta chỉ cần đặt nó vào log buffer, rồi cuối cùng nó sẽ được ghi ra, và như vậy là ổn.
There's no problems. So it looks like this, right? So again, we have our transaction begin. That's why we put a log buffer there. Then this transaction does a bunch of updates. We update the...
Không có vấn đề gì. Vậy nó trông như thế này, đúng không? Một lần nữa, chúng ta có transaction begin. Đó là lý do chúng ta đặt một log buffer ở đó. Rồi giao dịch này thực hiện hàng loạt cập nhật. Chúng ta cập nhật...
We go ahead and create the log records. We update the pages in the memory. Then upon commit, we got to make sure we flush this out to disk. That's fine.
Chúng ta tạo các bản ghi log. Chúng ta cập nhật các trang trong bộ nhớ. Rồi khi commit, chúng ta phải đảm bảo flush chúng ra đĩa. Điều đó ổn.
Once that's been updated, we can update the flush LSN to now point to this latest log record here. We can tell the outside world that our transaction has committed.
Khi việc đó đã được cập nhật xong, chúng ta có thể cập nhật flush LSN để trỏ tới bản ghi log mới nhất này. Chúng ta có thể báo cho thế giới bên ngoài biết giao dịch đã commit.
That's all fine. And then at some later point, soon after this, we'll say, all right, we don't need this transaction anymore. We'll put a transaction end message in it, in the log.
Tất cả đều ổn. Rồi đến một thời điểm nào đó sau này, ngay sau đó, chúng ta sẽ nói: được rồi, chúng ta không cần giao dịch này nữa. Chúng ta sẽ đặt một thông điệp transaction end vào trong log.
And then that'll eventually get written out.
Và rồi cuối cùng nó sẽ được ghi ra.
One additional optimization you can do: you can say, well, I keep track of my flush LSN, so I know that at some point, I don't need to keep this log buffer around.
Còn một tối ưu hóa nữa mà bạn có thể làm: bạn có thể nói, tôi theo dõi flush LSN của mình, nên tôi biết rằng đến một lúc nào đó, tôi không cần giữ log buffer này nữa.
And so again, I can just do the swapping mechanism if I have two buffers or three buffers.
Và vì vậy, một lần nữa, tôi có thể dùng cơ chế hoán đổi nếu tôi có hai hoặc ba buffer.
Essentially, I'm just trimming out what I have in memory because I know I don't need to access these logs anymore. Okay? All right, so this is pretty straightforward.
Về bản chất, tôi chỉ cắt bỏ bớt những gì đang có trong bộ nhớ vì tôi biết mình không cần truy cập các log này nữa. Được chứ? Vậy là phần này khá đơn giản.
The aborts one, we're going to add additional things. So now, when a transaction aborts, it's basically going to be like an undo operation.
Với abort, chúng ta sẽ thêm một số thứ. Bây giờ, khi một giao dịch abort, về cơ bản nó sẽ giống như một thao tác undo.
During normal execution, when we abort, it's going to basically be doing the same steps that we would do during recovery, because now we're just doing this part of the regular execution process.
Trong quá trình thực thi bình thường, khi chúng ta abort, về cơ bản nó sẽ thực hiện các bước giống như chúng ta làm khi khôi phục, vì giờ chúng ta chỉ đang làm phần này trong quá trình thực thi thông thường.
So we need to add one additional field to our log records called the previous LSN. And we don't need this for correctness reasons. We're going to need this for performance reasons.
Vậy chúng ta cần thêm một trường nữa vào các bản ghi log, gọi là previous LSN. Và chúng ta không cần nó vì lý do tính đúng đắn. Chúng ta sẽ cần nó vì lý do hiệu năng.
It's going to allow us to basically maintain a linked list of the log records that correspond to a single transaction.
Nó cho phép chúng ta duy trì một danh sách liên kết gồm các bản ghi log tương ứng với một giao dịch duy nhất.
So I can jump to the last log record for a transaction and then follow this previous LSN to jump to the different log records for that transaction. Right? And it corresponds to order.
Nhờ vậy tôi có thể nhảy tới bản ghi log cuối cùng của một giao dịch rồi lần theo previous LSN này để nhảy tới các bản ghi log khác của giao dịch đó. Đúng không? Và nó tương ứng với thứ tự.
Again, for PowerPoint, I'm only showing like one or two transactions at a time.
Lưu ý, trên PowerPoint tôi chỉ cho xem một hoặc hai giao dịch cùng lúc.
Think of like 1,000 transactions a second; I want to quickly be able to navigate and get all the log records I need for a transaction.
Hãy nghĩ tới 1.000 giao dịch mỗi giây; tôi muốn có thể nhanh chóng duyệt qua và lấy ra tất cả các bản ghi log cần cho một giao dịch.
Another thing to point out, too, is that while we're doing this, while transactions are running and then we end up aborting and need to roll them back, we're still technically doing all the concurrent usual stuff we talked about before.
Một điều nữa cần chỉ ra là, trong khi chúng ta làm việc này, trong lúc các giao dịch đang chạy rồi cuối cùng bị hủy và cần rollback, thì về mặt kỹ thuật chúng ta vẫn đang làm toàn bộ những việc điều khiển đồng thời thông thường đã nói trước đây.
So if I'm doing 2PL, I don't release the locks as soon as the transaction tells me I abort, because I still need to go modify the records I've already modified when I thought I was going to still commit.
Vì vậy nếu tôi dùng 2PL, tôi không nhả khóa ngay khi giao dịch báo cho tôi là abort, vì tôi vẫn cần đi sửa lại các bản ghi mà tôi đã sửa khi tôi còn nghĩ là mình sẽ commit.
So I hold the locks and all those things I'm going to reverse back out.
Nên tôi giữ các khóa, và mọi thứ đó tôi sẽ hoàn tác lại.
And only when I go ahead and actually finish the rollback, finish the undo process, then I go ahead and release the locks.
Và chỉ khi tôi thực sự hoàn tất rollback, hoàn tất quá trình undo, thì tôi mới nhả các khóa.
This ensures that, like, someone else doesn't write to something and I try to roll back my change and try to put it back to the value it was before I started running, and I end up blowing away, you know, that other transaction's write.
Điều này đảm bảo rằng không ai khác ghi vào một thứ trong khi tôi cố rollback thay đổi của mình và đặt nó về giá trị trước khi tôi bắt đầu chạy, rồi cuối cùng tôi xóa mất, các bạn biết đấy, thao tác ghi của giao dịch kia.
All the same stuff we talked about before with 2PL. All right, so coming back here now. Now we have, again, in our head of our log records, we have the LSN.
Tất cả đều giống những gì chúng ta đã nói trước đây về 2PL. Được rồi, bây giờ quay lại đây. Giờ chúng ta lại có LSN ở phần đầu của các bản ghi log.
It's always going up in time. And the previous LSN just corresponds to the previous one.
Nó luôn tăng dần theo thời gian. Còn previous LSN chỉ tương ứng với bản ghi ngay trước đó.
In the case of the top one, where we're beginning transaction 4, there isn't a previous LSN for the begin message. So it's just null or nil.
Với bản ghi trên cùng, nơi chúng ta bắt đầu giao dịch 4, thì không có previous LSN cho thông điệp begin. Nên nó chỉ là null hoặc nil.
So the transaction is run, makes these changes. Then it goes ahead and gets an abort.
Vậy giao dịch chạy và thực hiện các thay đổi này. Rồi nó nhận một abort.
And again, this could occur because either the application said abort this transaction or our concurrency control protocol said abort this transaction. We don't know. We don't care.
Và một lần nữa, điều này có thể xảy ra vì ứng dụng yêu cầu hủy giao dịch này hoặc vì giao thức điều khiển đồng thời yêu cầu hủy giao dịch này. Chúng ta không biết. Chúng ta không quan tâm.
And now the question is, what do we do in this middle step here before we can put that transaction end message for T4?
Và bây giờ câu hỏi là, chúng ta làm gì ở bước giữa này trước khi có thể ghi thông điệp transaction end cho T4?
What do we need to do to roll back those changes? What's that? Following class, but, like, and do what?
Chúng ta cần làm gì để rollback những thay đổi đó? Gì vậy? Theo sau lớp học, nhưng mà, làm gì nữa?
I heard somebody said it, yes. Process the undo. Yes, but we're talking about the logging here. We got to record what we do. So undo gives me the same thing as normal operation.
Tôi nghe có người nói rồi, đúng. Xử lý undo. Đúng, nhưng ở đây chúng ta đang nói về logging. Chúng ta phải ghi lại những gì mình làm. Vậy undo cho ra giống như hoạt động bình thường.
We want to record what we're undoing so that if we crash when we try to undo this, we know what we undid, and we can make sure we can still undo it.
Chúng ta muốn ghi lại những gì mình đang undo để nếu hệ thống bị sập khi ta đang cố hoàn tác thao tác này, ta biết mình đã hoàn tác những gì, và vẫn có thể đảm bảo hoàn tác được nó.
And so we're interested in a new log record type called compensation log records, or CLRs. And it's the same thing as the update operation.
Vì vậy, ta quan tâm đến một loại bản ghi log mới gọi là bản ghi log bù (compensation log record), hay CLR. Nó giống hệt thao tác cập nhật.
We do normal execution, but it's just the reversal of it. We're just taking the before and after value and just swapping it over. All right?
Ta thực thi bình thường, nhưng đó chỉ là đảo ngược của thao tác ban đầu. Ta chỉ lấy giá trị trước và giá trị sau rồi hoán đổi chúng cho nhau. Được chứ?
And then when we do this for normal execution, when we're undoing transactions, we don't have to wait until these CLRs that reverse the changes, they don't need to be flushed to disk immediately when we complete the undo process.
Và khi ta làm điều này trong quá trình thực thi bình thường, tức là khi đang hoàn tác các giao dịch, ta không phải chờ các CLR này, những bản ghi đảo ngược thay đổi, không cần phải được ghi xuống đĩa ngay khi ta hoàn tất quá trình hoàn tác.
Because, actually, as soon as the transaction says it gets aborted, like, either because they say abort or we tell it it's going to abort, We immediately come back to the application and say your transaction has been aborted.
Bởi vì thực ra, ngay khi giao dịch báo là nó bị hủy bỏ, dù là do người dùng yêu cầu abort hay do ta báo rằng nó sẽ bị hủy, ta lập tức quay lại với ứng dụng và nói rằng giao dịch của bạn đã bị hủy bỏ.
We don't need to wait to flush anything. Right? Because we're not making any guarantees other than make sure that we reverse all these changes, which we'll do.
Ta không cần chờ ghi (flush) bất cứ thứ gì. Đúng không? Vì ta không đảm bảo điều gì khác ngoài việc bảo đảm rằng ta đảo ngược tất cả các thay đổi này, và ta sẽ làm điều đó.
Questions? If the machine crashes before the rollback completes, what do we do? Roll it back. We'll get there in a second. That's the last step of ARIES.
Có câu hỏi nào không? Nếu máy sập trước khi quá trình rollback hoàn tất thì ta làm gì? Rollback lại. Lát nữa ta sẽ đến phần đó. Đó là bước cuối cùng của ARIES.
All right, we're running out of space in PowerPoint, so now I'm going to put this in tabular form. So now we have, think of every row in this table corresponds to a log record.
Được rồi, trong PowerPoint sắp hết chỗ, nên giờ tôi sẽ chuyển sang dạng bảng. Giờ hãy coi mỗi hàng trong bảng này tương ứng với một bản ghi log.
We have an LSN, a previous LSN, transaction ID of the transaction making the change, the log record type, what object they're modifying, the before and after value, and this undo next LSN thing if we need to roll things back.
Ta có một LSN, một LSN trước đó, ID của giao dịch thực hiện thay đổi, loại bản ghi log, đối tượng bị sửa đổi, giá trị trước và giá trị sau, và trường undo next LSN này nếu ta cần rollback.
So this is the same setup we had before. T1 made some changes. Now it aborts.
Đây là cách thiết lập giống trước. T1 đã thực hiện vài thay đổi. Giờ nó bị abort.
So as soon as we get the abort message, we tell the outside world the transaction is finished, it's aborted, but then now we've got to start undoing the changes.
Vì vậy ngay khi nhận được thông điệp abort, ta báo cho thế giới bên ngoài rằng giao dịch đã kết thúc, đã bị hủy, nhưng giờ ta phải bắt đầu hoàn tác các thay đổi.
So this is why having the previous LSN for transactions makes this easier, because I see the abort message, I know the previous LSN for this transaction was 003, so I can quickly jump up to find that log record and roll it back.
Đây là lý do việc có LSN trước đó cho các giao dịch giúp việc này dễ hơn, vì tôi thấy thông điệp abort, tôi biết LSN trước đó của giao dịch này là 003, nên tôi có thể nhanh chóng nhảy lên tìm bản ghi log đó và rollback nó.
So I see the update message at LSN 3, so I'm going to create a CLR for this that says I'm going to reverse the change that happened up above in this previous LSN.
Vậy tôi thấy thông điệp update tại LSN 3, nên tôi sẽ tạo một CLR cho nó, nói rằng tôi sẽ đảo ngược thay đổi đã xảy ra ở phía trên, tại LSN trước đó này.
So I'm going to have the same object that I modified, but then I have now basically the reverse of the before and after value, so I can swap it back to what it should have been before the transaction made any changes.
Vậy tôi có cùng đối tượng mà tôi đã sửa đổi, nhưng giờ về cơ bản có giá trị trước và sau bị đảo ngược, để tôi có thể hoán đổi nó về giá trị lẽ ra phải có trước khi giao dịch thực hiện bất kỳ thay đổi nào.
And then my undo next LSN, again, it's just a helper to say, here's the next LSN that you need to roll back after this one, so then jump up there.
Và undo next LSN của tôi, một lần nữa, chỉ là một trợ giúp để nói rằng, đây là LSN kế tiếp mà bạn cần rollback sau cái này, rồi nhảy lên đó.
And then I'll do the same thing: create another LSN, or a CLR, for it that's going to correspond to this change here, and I'm just reversing the values back.
Rồi tôi sẽ làm tương tự: tạo thêm một LSN, hay một CLR, cho nó, tương ứng với thay đổi ở đây, và tôi chỉ đảo ngược các giá trị lại.
Then I get the undo next LSN, I see that it's the begin message, and at this point I know I'm done.
Sau đó tôi lấy undo next LSN, và thấy đó là bản ghi begin, và đến thời điểm này tôi biết mình đã xong.
I reversed all the changes I needed for this transaction, so now this is where I put the transaction end message for this aborted transaction.
Tôi đã đảo ngược tất cả các thay đổi cần thiết cho giao dịch này, nên bây giờ đây là chỗ tôi ghi bản ghi kết thúc giao dịch cho giao dịch bị hủy này.
So for committed transactions, there's nothing in between commit and end. In aborted transactions, it's all the CLRs making sure that you reverse all the changes that it made during normal operations before it aborted.
Vậy với các giao dịch đã commit, giữa commit và end không có gì cả. Còn với các giao dịch bị hủy, đó là toàn bộ các CLR để đảm bảo rằng bạn đảo ngược mọi thay đổi mà nó đã thực hiện trong quá trình hoạt động bình thường trước khi bị hủy.
Yes.
Vâng.
The question is, for committed transactions, can I immediately write the transaction end after the commit? Yes. During normal operation, yes.
Câu hỏi là, với các giao dịch đã commit, liệu tôi có thể ghi ngay bản ghi kết thúc giao dịch sau commit không? Có. Trong quá trình hoạt động bình thường thì có.
Recovery, we'll see it in a second. It has to stick around maybe a little longer.
Còn khi khôi phục, lát nữa chúng ta sẽ thấy. Nó có thể phải tồn tại lâu hơn một chút.
Any other questions? All right, good. So far, so good. So far, this is pretty straightforward.
Còn câu hỏi nào khác không? Được rồi, tốt. Cho đến giờ thì ổn. Cho đến giờ, mọi thứ khá đơn giản.
And so the abort algorithm is basically, as I said before, we first write the abort message in the write-ahead log.
Và thuật toán hủy về cơ bản là như tôi đã nói trước đó, đầu tiên ta ghi bản ghi abort vào write-ahead log.
We can tell the outside world the transaction's been aborted at that point, and then we're going to analyze the transaction's operations, updates it made, in reverse order, and apply the reversal, and then going back in time.
Lúc đó ta có thể báo cho bên ngoài biết giao dịch đã bị hủy, rồi ta sẽ phân tích các thao tác của giao dịch, tức các cập nhật mà nó đã thực hiện, theo thứ tự ngược lại, và áp dụng phép đảo ngược, cứ thế quay ngược thời gian.
So take the latest log record that they established to do an update, reverse that, and then do the next one, until I hit begin, and then I know I'm done.
Lấy bản ghi log mới nhất đã tạo ra một cập nhật, đảo ngược nó, rồi làm tiếp bản ghi kế, cho đến khi gặp begin, và lúc đó tôi biết mình đã xong.
I'm going to write the transaction end message. At that point, I can release all the locks for my transaction because I've updated all the records that I wanted to update, and then I'm done.
Tôi sẽ ghi bản ghi kết thúc giao dịch. Lúc đó, tôi có thể giải phóng tất cả các khóa của giao dịch vì tôi đã cập nhật mọi bản ghi mình muốn cập nhật, và thế là xong.
Again, a simple optimization you could do in this case here, it's, you know, this is an example where in two-phase locking, you could start releasing the locks early.
Một lần nữa, một tối ưu hóa đơn giản bạn có thể làm trong trường hợp này, đây là một ví dụ mà trong khóa hai pha, bạn có thể bắt đầu giải phóng khóa sớm.
If you know that you're never going to update the same object again multiple times, there are undo changes during the undo process, you can release the lock for that object in the moment you get, you know, as you apply the update.
Nếu bạn biết mình sẽ không bao giờ cập nhật cùng một đối tượng nhiều lần, tức là có các thay đổi undo trong quá trình undo, bạn có thể giải phóng khóa của đối tượng đó ngay khi bạn, bạn biết đấy, áp dụng cập nhật.
Right, but you have to, if you scan all the write-ahead log and know all the objects you're going to modify ahead of time, you can do that.
Nhưng bạn phải, nếu bạn quét toàn bộ write-ahead log và biết trước tất cả các đối tượng sẽ sửa đổi, thì bạn làm được.
If you don't do that, then you can't because you don't know whether you have to do multiple undoes.
Nếu không làm vậy, thì bạn không thể, vì bạn không biết liệu có phải undo nhiều lần hay không.
The other thing to point out too is, like, we're never going to undo a CLR, we're never going to undo an undo.
Một điều nữa cần chỉ ra là, ta sẽ không bao giờ undo một CLR, ta sẽ không bao giờ undo một thao tác undo.
It doesn't make any sense because, again, we're trying to undo something that happened during execution. So we don't need to make CLRs for our CLRs when we do recovery, right?
Điều đó không có nghĩa lý gì, vì một lần nữa, ta đang cố hoàn tác một việc đã xảy ra trong quá trình thực thi. Vì vậy ta không cần tạo CLR cho các CLR của mình khi thực hiện khôi phục, đúng không?
Once it's there, we know that we can always reapply it over and over again.
Một khi nó đã có đó, ta biết có thể áp dụng lại nó nhiều lần.
Say it again? Question: why do we need the before and after value for the CLRs? Again, we're being over-pathetic here, right?
Bạn nói lại được không? Câu hỏi: tại sao ta cần cả giá trị trước và sau cho các CLR? Một lần nữa, ở đây ta đang làm thừa cẩn thận, đúng không?
Like, you could say, I know, going back here, you could just say, I know I need to reverse this change here.
Kiểu như, bạn có thể nói, tôi biết, quay lại chỗ này, bạn có thể nói, tôi biết mình cần đảo ngược thay đổi này.
Go look at it and say it was 30, 40. I don't need to record that it was 40, 30. But again, we're being overly verbose.
Cứ xem nó và thấy là 30, 40. Tôi không cần ghi lại rằng nó là 40, 30. Nhưng một lần nữa, chúng ta đang ghi quá dài dòng.
All right, so he's basically saying, can I start caching things? Let's not do any, let's not do any optimization. Let's make sure it's correct first.
Được rồi, vậy bạn ấy về cơ bản đang hỏi là liệu có thể bắt đầu dùng bộ nhớ đệm (caching) không? Đừng làm bất kỳ tối ưu hóa nào vội. Hãy đảm bảo nó đúng trước đã.
In databases, you want to make sure it's correct first, then you make it faster. But yes, you could start doing things like that, yes.
Với cơ sở dữ liệu, trước hết bạn phải đảm bảo nó đúng, rồi sau đó mới làm cho nó nhanh hơn. Nhưng đúng vậy, bạn có thể bắt đầu làm những việc như thế.
I'm just going to wrap my mind around why do we need this whole CLR and avoid it at all?
Tôi chỉ đang cố hiểu rõ tại sao chúng ta lại cần toàn bộ cơ chế CLR này, và có tránh được nó không?
If you didn't have to, isn't it true that you just need to write a headline as is?
Nếu không bắt buộc, chẳng phải chỉ cần ghi nguyên bản bản ghi đó ra là đủ sao?
And since there will never be a condition, then you know that the changes are correct. So the statement is, Why do I need to maintain the CLRs?
Và vì sẽ không bao giờ có điều kiện nào xảy ra, nên bạn biết rằng các thay đổi là đúng. Vậy câu hỏi là: tại sao tôi phải duy trì các CLR?
Shouldn't it be enough for me to go just look at what the changes that were made in the regular update transaction, or update records, and just reverse them?
Chẳng phải chỉ cần xem những thay đổi đã được thực hiện trong giao dịch cập nhật thông thường, hay các bản ghi cập nhật, rồi đảo ngược chúng là đủ sao?
The statement is, aborting and crashing is the same thing.
Ý bạn là: hủy bỏ và gặp sự cố là một việc như nhau.
Yeah, later on, we'll see this is like, the key idea of what we're going to do with this is that there's not going to be any log records that say, has this page been flushed to disk?
Vâng, lát nữa chúng ta sẽ thấy, ý tưởng then chốt của những gì chúng ta sắp làm là sẽ không có bản ghi nhật ký nào cho biết trang này đã được ghi xuống đĩa chưa.
So we don't know when we come back and crash, which of these changes actually made it out to disk yet. Sometimes we can, sometimes we don't.
Vì vậy khi quay lại sau sự cố, chúng ta không biết những thay đổi nào trong số này đã thực sự được ghi xuống đĩa. Đôi khi biết, đôi khi không.
Yeah, but, in any case, isn't it true that within a day, like yesterday, and the first day...
Vâng, nhưng dù sao đi nữa, chẳng phải trong vòng một ngày, như hôm qua chẳng hạn, và ngày đầu tiên...
The statement is, isn't it true that I need to be able to look at a log record from yesterday and know what went into it so I can then reverse it?
Ý bạn là, chẳng phải tôi cần xem được một bản ghi nhật ký từ hôm qua và biết nó chứa những gì để có thể đảo ngược nó sao?
Yes, but to do that correctly, I got to reverse all the changes. The checkpoints are basically trying to freeze the state of the buffer pool, write all these dirty pages.
Đúng, nhưng để làm đúng, tôi phải đảo ngược tất cả các thay đổi. Về cơ bản, checkpoint cố gắng đóng băng trạng thái của buffer pool, và ghi tất cả các trang dirty này xuống.
But then the problem is, the way I'm going to do checkpoints is that I'm not going to stop everybody from updating things while I'm doing it.
Nhưng vấn đề là, cách tôi thực hiện checkpoint là tôi sẽ không chặn mọi người cập nhật dữ liệu trong lúc đang làm.
So I could be in this weird state where some dirty page has been written to disk and some pages haven't been, and I've been modifying things while the checkpoint is occurring.
Vì vậy tôi có thể rơi vào trạng thái kỳ lạ, trong đó một số trang dirty đã được ghi xuống đĩa còn một số thì chưa, và tôi vẫn đang sửa đổi dữ liệu trong khi checkpoint diễn ra.
So I don't know what exactly the state of the world is at the moment I got a checkpoint.
Vì thế tôi không biết chính xác trạng thái của hệ thống tại thời điểm tôi tạo checkpoint là gì.
So all these undos and these CLRs and the regular records allows me to reverse things back to the correct state. Are there some optimizations you could do? Yes.
Do đó, tất cả các thao tác undo và các CLR này cùng với các bản ghi thông thường cho phép tôi đảo ngược mọi thứ về đúng trạng thái. Có thể tối ưu hóa được không? Có.
But again, for recovery stuff, you want to be super, super careful.
Nhưng một lần nữa, với phần khôi phục, bạn phải cực kỳ cẩn thận.
So I said in the beginning, this is overly verbose. Let's start with this. So Postgres is even more verbose than this. Postgres... I'm getting ahead of myself.
Như tôi đã nói lúc đầu, cách này khá dài dòng. Hãy bắt đầu với nó. Postgres còn dài dòng hơn thế này nữa. Postgres... Tôi đang nói trước mất rồi.
Postgres will be, after you take a checkpoint, the first time a transaction modifies a page, they write the whole page out to the write-ahead log, then write the log record that modified that page.
Postgres sẽ làm như sau: sau khi tạo checkpoint, lần đầu tiên một giao dịch sửa đổi một trang, họ ghi toàn bộ trang đó ra write-ahead log, rồi mới ghi log record đã sửa trang đó.
Because again, you want to be super careful that if things get corrupted, you want to always come back and get back to the correct state.
Vì một lần nữa, bạn muốn cực kỳ cẩn thận, phòng khi dữ liệu bị hỏng, bạn luôn muốn quay lại và khôi phục về đúng trạng thái.
So we're getting extra redundancy through these CLRs, but it's also to make sure that if we crash during recovery, we know what we actually made, what we actually modified.
Vậy là ta có thêm tính dư thừa nhờ các CLR này, nhưng nó cũng để đảm bảo rằng nếu ta bị sập trong lúc khôi phục, ta biết mình thực sự đã làm gì, thực sự đã sửa những gì.
So you two guys, every year, people always say, why are we doing this? It seems so wasteful. You're correct, but to be super careful, we're going to do all of this.
Hai bạn ạ, năm nào cũng có người hỏi: tại sao ta lại làm thế này? Nghe có vẻ rất lãng phí. Đúng vậy, nhưng để cực kỳ cẩn thận, ta sẽ làm tất cả những việc này.
And there's optimizations you obviously can do afterwards. Okay. So I think we've covered all this.
Và dĩ nhiên sau đó có thể có các tối ưu hóa. Được rồi. Tôi nghĩ ta đã nói hết phần này.
So at this point, now we get to start to understand why we have all these CLRs and additional things. So now we're talking about how we're going to do fuzzy checkpoints.
Đến đây, ta bắt đầu hiểu vì sao có tất cả các CLR và những thứ bổ sung này. Giờ ta sẽ nói về cách thực hiện fuzzy checkpoint.
Again, as a reminder, the reason why we need to do checkpoints is that a log's going to grow forever, assuming you have transactions running all the time.
Xin nhắc lại, lý do ta cần checkpoint là log sẽ lớn lên mãi mãi, giả sử các giao dịch chạy liên tục.
And when I crash and come back, I don't want to have to replay five years worth of log to put my database back in the correct state.
Và khi tôi bị sập rồi quay lại, tôi không muốn phải phát lại log của năm năm để đưa cơ sở dữ liệu về đúng trạng thái.
I want to be able to go back a little bit in my write-ahead log and use that as a starting point for me to say, let me reconstruct the state of the database at that point in time rather than the beginning of time.
Tôi muốn có thể quay lại một chút trong write-ahead log và dùng đó làm điểm bắt đầu, để nói rằng: hãy dựng lại trạng thái của cơ sở dữ liệu tại thời điểm đó thay vì từ thuở ban đầu.
So this is going to be a mechanism we're going to allow us to sort of speed up the recovery time.
Vậy đây là một cơ chế giúp ta đẩy nhanh thời gian khôi phục.
So the last class, we talked about a simple protocol where we basically stop the world When we want to take a checkpoint, like stop queries from running, queries from modifying things, stop any new queries from starting any new transactions, wait until all, any active transactions that are still running could finish execution, which could take days or hours, and that sucks.
Ở buổi trước, ta đã nói về một giao thức đơn giản, về cơ bản là dừng toàn bộ hệ thống. Khi muốn tạo checkpoint, ta dừng các truy vấn đang chạy, dừng các truy vấn sửa dữ liệu, không cho truy vấn mới bắt đầu giao dịch mới nào, chờ cho đến khi mọi giao dịch đang hoạt động còn chạy dở kết thúc xong, việc này có thể mất hàng ngày hoặc hàng giờ, và thật tệ.
But then once we know there's no active transactions, then we take whatever's in our buffer pool, write that out to disk, and we know that's been flushed, and then we can add a checkpoint entry into our log.
Nhưng khi đã biết không còn giao dịch nào đang hoạt động, ta lấy mọi thứ trong buffer pool và ghi xuống đĩa, và ta biết dữ liệu đã được flush, rồi ta thêm một mục checkpoint vào log.
So now if we crash and come back, we go look at that checkpoint record, and we know that there's no in-flight transactions at that moment at the checkpoint, and the database is a consistent snapshot.
Giờ nếu bị sập rồi quay lại, ta xem checkpoint record đó, và biết rằng không có giao dịch nào đang dở tại thời điểm checkpoint, và cơ sở dữ liệu là một snapshot nhất quán.
So it makes recovery super easy because, again, I don't have to look at the log and look for transactions that might have been running while I took the checkpoint.
Vì vậy việc khôi phục cực kỳ dễ, bởi tôi không phải xem log để tìm các giao dịch có thể đang chạy trong lúc tôi tạo checkpoint.
I waited until they all finished, and then I don't have any weird torn write situations.
Tôi đã chờ cho chúng kết thúc hết, nên không có tình huống torn write kỳ quặc nào.
So recovery's easy, but obviously this is super slow because you have to pause everything while you take a checkpoint.
Khôi phục thì dễ, nhưng rõ ràng cách này cực kỳ chậm vì phải tạm dừng mọi thứ trong khi tạo checkpoint.
So a slightly better one is not wait for transactions to finish, but you just pause them from executing whatever they were executing.
Một cách khá hơn một chút là không chờ các giao dịch kết thúc, mà chỉ tạm dừng chúng, không cho chạy tiếp việc đang làm.
And then you write out your dirty pages, and then once that's done, then you can allow transactions to start running again.
Rồi bạn ghi các trang dirty xuống đĩa, và sau khi xong, lúc đó bạn mới cho phép các giao dịch chạy trở lại.
But this has problems, too. So say I have three pages in my database. I have it in my buffer pool. I have one worker thread wants to do checkpoints.
Nhưng cách này cũng có vấn đề. Giả sử tôi có ba trang trong cơ sở dữ liệu. Chúng nằm trong buffer pool của tôi. Có một worker thread muốn thực hiện checkpoint.
One worker thread is running transactions. So say the transaction, it's going to modify two pages. It's going to modify page one and three. So it first modifies page three.
Một worker thread khác đang chạy các giao dịch. Giả sử giao dịch này sẽ sửa đổi hai trang. Nó sẽ sửa trang một và trang ba. Đầu tiên nó sửa trang ba.
Then the checkpoint starts, and the checkpoint's going to pause any transaction that's running from running anything else. It could be either in-flight query or just preventing it from running another query.
Sau đó checkpoint bắt đầu, và checkpoint sẽ tạm dừng bất kỳ giao dịch nào đang chạy, không cho chạy thêm gì nữa. Có thể là truy vấn đang thực thi dở, hoặc chỉ là ngăn nó chạy truy vấn tiếp theo.
Then now the checkpoint's going to basically do a sequential scan on all my pages in my buffer pool and write those out to disk.
Rồi bây giờ checkpoint về cơ bản sẽ quét tuần tự tất cả các trang trong buffer pool của tôi và ghi chúng xuống đĩa.
So I have page one, page two, and then the modified page three that the transaction modified. Then the checkpoint completes.
Vậy là tôi có trang một, trang hai, và trang ba đã bị giao dịch sửa đổi. Sau đó checkpoint hoàn tất.
The transaction wakes up again, and now it modifies page one, but I don't have a consistent snapshot of those pages in my buffer pool. I'll have half the changes that transaction one made.
Giao dịch thức dậy trở lại, và bây giờ nó sửa trang một, nhưng tôi không có một ảnh chụp nhất quán của các trang đó trong buffer pool của mình. Tôi chỉ có một nửa các thay đổi mà giao dịch một đã thực hiện.
So I still have to go look around more in the right-hand log to figure out what was this transaction doing at the time I was taking the checkpoint, so I make sure that I got, I can try to reconstruct the database and make sure I get that page one in there, because this transaction may later commit, and we tell the outside world the transaction's committed, but I'm missing its update in the page.
Vì vậy tôi vẫn phải xem xét thêm trong log bên phải để biết giao dịch này đã làm gì vào lúc tôi thực hiện checkpoint, để đảm bảo rằng tôi đã có, tôi có thể cố dựng lại cơ sở dữ liệu và chắc chắn có thay đổi của trang một ở đó, vì giao dịch này sau đó có thể commit, và chúng ta báo cho thế giới bên ngoài rằng giao dịch đã commit, nhưng tôi lại thiếu bản cập nhật của nó trong trang.
So what we're going to start doing now, now we're going to add additional metadata to our write-ahead log to keep track of when we take the checkpoints, when the checkpoint's going to start and when it's going to finish, and then we're going to record what were the transactions that were running at the moment that the checkpoint started and what pages were dirty in our buffer pool at the moment the checkpoint started.
Vậy điều chúng ta sẽ bắt đầu làm bây giờ là thêm siêu dữ liệu vào write-ahead log để theo dõi thời điểm chúng ta thực hiện checkpoint, khi nào checkpoint bắt đầu và khi nào nó kết thúc, rồi chúng ta sẽ ghi lại những giao dịch nào đang chạy vào thời điểm checkpoint bắt đầu và những trang nào là dirty trong buffer pool vào thời điểm checkpoint bắt đầu.
So that's at least going to give us more idea about what's going on in the state of the system.
Như vậy ít nhất sẽ cho chúng ta thêm thông tin về trạng thái của hệ thống.
At the moment that we start to take a checkpoint, we'll know whether these changes actually made it out to disk or not. So the ATT, or the Active Transaction Table, is pretty straightforward.
Vào thời điểm chúng ta bắt đầu checkpoint, chúng ta sẽ biết các thay đổi này đã thực sự được ghi xuống đĩa hay chưa. Vậy ATT, hay Active Transaction Table, khá đơn giản.
Every transaction that exists will have a transaction ID. It's similar to the Active Transaction Table we talked about when we tried to do OCC or MVCC.
Mỗi giao dịch tồn tại sẽ có một ID giao dịch. Nó tương tự Active Transaction Table mà chúng ta đã nói tới khi bàn về OCC hoặc MVCC.
We need to keep track of what transactions are running at the same time. So it's basically the same table. Then we'll have the status of the transaction's mode, what phase it's in.
Chúng ta cần theo dõi những giao dịch nào đang chạy cùng lúc. Vậy về cơ bản đó là cùng một bảng. Rồi chúng ta sẽ có trạng thái của giao dịch, tức nó đang ở giai đoạn nào.
It can either be running because it's still actively going on, it's in committing process, and then candidate for undo means that we think we're going to have to undo this.
Nó có thể là running vì vẫn đang hoạt động, đang trong quá trình commit, và candidate for undo nghĩa là chúng ta cho rằng sẽ phải undo giao dịch này.
It may change later on. It turns out this transaction does commit and we can change its status.
Điều đó có thể thay đổi sau này. Hóa ra giao dịch này có commit và chúng ta có thể đổi trạng thái của nó.
But when we do recovery, we're going to assume everyone's going to get rolled back until we learn otherwise.
Nhưng khi thực hiện recovery, chúng ta sẽ giả định mọi giao dịch đều bị rollback cho đến khi biết điều ngược lại.
So we can remove a transaction from the ATT once we see its transaction end message, either because it got committed or aborted and rolled back, because at that point we know that there isn't going to be any more changes coming from this transaction and we don't need to maintain additional state for it.
Vậy chúng ta có thể xóa một transaction khỏi ATT khi thấy thông điệp kết thúc transaction của nó, dù là do nó đã commit hay đã bị abort và rollback, vì tại thời điểm đó chúng ta biết rằng sẽ không còn thay đổi nào đến từ transaction này nữa và chúng ta không cần duy trì thêm trạng thái nào cho nó.
So when we do this recovery process, we're going to look at the active transaction table and say, well, these transactions are running at the time I took the checkpoint, but I don't know yet whether they're going to commit or not, so I'm going to assume everyone's going to abort.
Vậy khi thực hiện quá trình khôi phục này, chúng ta sẽ xem bảng transaction đang hoạt động và nói rằng: những transaction này đang chạy vào lúc tôi tạo checkpoint, nhưng tôi chưa biết liệu chúng có commit hay không, nên tôi sẽ giả định tất cả đều sẽ abort.
And then later on, as I scan the log, I might find the commit message and I go ahead and change its status.
Rồi sau đó, khi quét log, tôi có thể thấy thông điệp commit và tôi sẽ đổi trạng thái của nó.
The dirty page table is going to be another separate data structure where we're going to record all the pages that were in our buffer pool that were marked dirty, that were not flushed to disk yet at the moment that the checkpoint started.
Bảng trang bẩn là một cấu trúc dữ liệu riêng khác nơi chúng ta ghi lại tất cả các trang nằm trong buffer pool và được đánh dấu là bẩn, tức là chưa được ghi xuống đĩa vào lúc checkpoint bắt đầu.
And this is where we're going to record the recLSN to say, here's the newest log record, sorry, here's the oldest log record that modified this page and made it dirty since the last time that page was written out to disk.
Và đây là nơi chúng ta ghi recLSN để nói rằng, đây là bản ghi log mới nhất, xin lỗi, đây là bản ghi log cũ nhất đã sửa đổi trang này và làm nó bẩn kể từ lần cuối trang đó được ghi xuống đĩa.
So pageLSN is the newest log record that modified the page and recLSN is the oldest log record since the page was brought into memory. Or since it was last written to disk, right?
Vậy pageLSN là bản ghi log mới nhất đã sửa đổi trang và recLSN là bản ghi log cũ nhất kể từ khi trang được đưa vào bộ nhớ. Hoặc kể từ lần cuối nó được ghi xuống đĩa, đúng không?
So this dirty page table is going to keep track of all the pages that are in our buffer pool at the moment the checkpoint started that are dirty, right?
Vậy bảng trang bẩn này sẽ theo dõi tất cả các trang nằm trong buffer pool vào lúc checkpoint bắt đầu mà đang bẩn, đúng không?
So now, in this case here, we have our checkpoint starts, and in this case here we have the, when our checkpoint starts, we keep track of the ATT, so we know that there's a transaction T2 that's still running.
Bây giờ, trong trường hợp này, checkpoint của chúng ta bắt đầu, và ở đây chúng ta có, khi checkpoint bắt đầu, chúng ta theo dõi ATT, nên biết rằng có một transaction T2 vẫn đang chạy.
T1 got transaction end before the checkpoint started, so it's not in our active transaction table.
T1 đã kết thúc transaction trước khi checkpoint bắt đầu, nên nó không có trong bảng transaction đang hoạt động.
And then there's this, there's a log record up above that corresponds to a modification on page 22 from transaction T2, and that's hanging out in our buffer pool that's still dirty.
Và có một bản ghi log ở phía trên tương ứng với một sửa đổi trên trang 22 từ transaction T2, và trang đó vẫn nằm trong buffer pool và vẫn còn bẩn.
Then later on we take another checkpoint, right? And now we have transaction T2 and T3, right?
Sau đó chúng ta tạo một checkpoint khác, đúng không? Và bây giờ chúng ta có transaction T2 và T3, đúng không?
Because T2 committed before our checkpoint started, but we haven't seen their transaction end message yet, so it's still technically alive.
Vì T2 đã commit trước khi checkpoint của chúng ta bắt đầu, nhưng chúng ta chưa thấy thông điệp kết thúc transaction của nó, nên về mặt kỹ thuật nó vẫn còn tồn tại.
And then T3 started after the last checkpoint, so that goes in our active transaction table. And then we have in our dirty page table, we have the two modifications here from T2 and T3.
Còn T3 bắt đầu sau checkpoint trước, nên nó được đưa vào bảng transaction đang hoạt động. Và trong bảng trang bẩn, chúng ta có hai sửa đổi ở đây từ T2 và T3.
The question is, why isn't P11 in the DPT? It got written to disk, right? There's no log record that said a page got written to disk.
Câu hỏi là: tại sao P11 không có trong DPT? Nó đã được ghi xuống đĩa rồi, đúng không? Không có bản ghi log nào cho biết một trang đã được ghi xuống đĩa.
The only information we have is whether it shows up in the dirty page table.
Thông tin duy nhất chúng ta có là nó có xuất hiện trong bảng trang bẩn hay không.
So this is better, because now we at least have some additional metadata about what's going on in our system at the moment of the crash. But we're still taking blocking checkpoints.
Vậy cách này tốt hơn, vì giờ ít nhất chúng ta có thêm một số siêu dữ liệu về những gì đang diễn ra trong hệ thống vào thời điểm xảy ra sự cố. Nhưng chúng ta vẫn đang dùng checkpoint chặn (blocking checkpoint).
So every time I'm taking a checkpoint here, and the two log records here, I'm stopping all the transactions running, take a checkpoint, and at least now I know that if a transaction modified pages, I would at least keep track of, like, was it dirty before or after I took the checkpoint, yes or no.
Cho nên mỗi lần tôi tạo một checkpoint ở đây, cùng với hai bản ghi log này, tôi phải dừng tất cả các transaction đang chạy, tạo checkpoint, và ít nhất giờ tôi biết rằng nếu một transaction đã sửa các trang, thì tôi ít nhất sẽ theo dõi được, trang đó đã bẩn trước hay sau khi tôi tạo checkpoint, có hay không.
But I'm still blocking all my transactions.
Nhưng tôi vẫn đang chặn tất cả các transaction.
So what everyone does instead is what are called fuzzy checkpoints, and this is now where it's fuzzy, because it's allowed to write out pages.
Vì vậy cách mà mọi người đều dùng là cái gọi là fuzzy checkpoint, và ở đây nó "mờ" (fuzzy) vì nó được phép ghi các trang ra đĩa.
You want to write all the pages that were dirty since the moment the checkpoint starts.
Bạn muốn ghi ra tất cả các trang đã bẩn kể từ thời điểm checkpoint bắt đầu.
But those dirty pages might contain changes from log records that came in after the checkpoint started, and there may be changes that occur to pages that I don't write out in my checkpoint because they were modified after the checkpoint started as well.
Nhưng những trang bẩn đó có thể chứa các thay đổi từ những bản ghi log đến sau khi checkpoint đã bắt đầu, và cũng có thể có những thay đổi xảy ra với các trang mà tôi không ghi ra trong checkpoint vì chúng cũng bị sửa sau khi checkpoint bắt đầu.
But I just, I missed it, right?
Nhưng tôi bỏ sót nó, đúng không?
But the DPT and ATT is going to give me enough metadata to go look in the log, snoop around, and figure out what was actually going on, to find out the things that I may have missed.
Nhưng DPT và ATT sẽ cho tôi đủ siêu dữ liệu để quay lại xem log, dò xét xung quanh và tìm ra điều gì thực sự đã diễn ra, để tìm ra những thứ mà tôi có thể đã bỏ sót.
So now, instead of just having a single checkpoint record in my log that says here's the checkpoint started and I block everyone, now I'm going to have a begin and end, and that's going to correspond to the point in time, right?
Vì vậy, thay vì chỉ có một bản ghi checkpoint duy nhất trong log, nói rằng checkpoint bắt đầu ở đây và tôi chặn mọi người, giờ tôi sẽ có một bản ghi begin và một bản ghi end, và chúng tương ứng với một khoảng thời gian, đúng không?
Denoted by the log sequence numbers, because that's basically representing physical time of when the checkpoint was occurring.
Được biểu thị bằng các số thứ tự log (LSN), vì về cơ bản chúng biểu diễn thời gian vật lý mà checkpoint diễn ra.
And I'm going to record what the DPT and ATT were at the moment the checkpoint started, but I end up writing it out to the commit end message, the checkpoint end message, as a way to simplify things so I can find things more easily later on.
Và tôi sẽ ghi lại DPT và ATT tại thời điểm checkpoint bắt đầu, nhưng tôi ghi chúng ra ở thông điệp kết thúc, tức thông điệp checkpoint end, để đơn giản hóa, giúp sau này tìm lại dễ hơn.
So in this case here, assume now we're going to, that transaction data is going to flush page P11 before the checkpoint starts here, right?
Vậy trong trường hợp này, giả sử bây giờ chúng ta sẽ có transaction ghi trang P11 ra đĩa trước khi checkpoint bắt đầu ở đây, đúng không?
So then now when the checkpoint finishes I'll have the ATT from when I started.
Thế thì khi checkpoint kết thúc, tôi sẽ có ATT tại lúc tôi bắt đầu.
So transaction T2 was running when the checkpoint started at 007, T1 got a transaction end at 006, so it's not in the active transaction table.
Transaction T2 đang chạy khi checkpoint bắt đầu ở 007, T1 có transaction end ở 006, nên nó không nằm trong bảng transaction đang hoạt động.
And then there's my dirty page table, that begin up there.
Và đây là bảng trang bẩn của tôi, ở chỗ begin phía trên.
My dirty page table corresponds to this update here that occurred, that was dirty before I took the checkpoint, and then I may have Written it out with that change, or maybe a change from another transaction that made a change before the checkpoint ended, or I made it, written it out, and then someone updated it and that page, that update, is still in memory too.
Bảng trang bẩn của tôi tương ứng với bản cập nhật này đã xảy ra, trang đã bẩn trước khi tôi tạo checkpoint, rồi tôi có thể đã ghi nó ra với thay đổi đó, hoặc với thay đổi từ một transaction khác đã sửa trước khi checkpoint kết thúc, hoặc tôi đã ghi nó ra, rồi có người cập nhật trang đó tiếp, và bản cập nhật đó vẫn còn trong bộ nhớ.
So there are sort of three states that a page could be in.
Như vậy một trang có thể ở ba trạng thái.
And now, once the checkpoint completes and I flush the checkpoint end message, I then update the master record for the database and say, here's the LSN of the last checkpoint that I took.
Và bây giờ, khi checkpoint hoàn tất và tôi ghi thông điệp checkpoint end ra đĩa, Sau đó tôi cập nhật master record của cơ sở dữ liệu và nói rằng, đây là LSN của checkpoint cuối cùng mà tôi đã thực hiện.
So in the case here, 010, when I complete that checkpoint, I write my master record 007, because that's the checkpoint begin up above.
Vậy trong trường hợp này, 010, khi tôi hoàn tất checkpoint đó, tôi ghi master record là 007, vì đó là checkpoint begin ở phía trên.
Then when this checkpoint ends down here, 015, I write my master record that the checkpoint started, last successful checkpoint, was 013.
Rồi khi checkpoint này kết thúc ở dưới đây, 015, tôi ghi master record rằng checkpoint bắt đầu, checkpoint thành công gần nhất, là 013.
And then when I crash, come back, when I see you in a second, we're going to use that to jump to this checkpoint begin.
Và khi tôi gặp sự cố rồi khởi động lại, lát nữa chúng ta sẽ gặp lại, chúng ta sẽ dùng nó để nhảy tới checkpoint begin này.
All right, so now ARIES, with our fuzzy checkpoints and these CLRs and the log records, we now get new recovery. So it can be three phases.
Được rồi, vậy với ARIES, cùng các fuzzy checkpoint và các CLR này cùng các bản ghi log, giờ chúng ta có cách khôi phục mới. Nó gồm ba giai đoạn.
The first phase we're going to do, we're going to analyze the write-ahead log, starting at where the master record points to, so the beginning of the last successful checkpoint, and we're going to scan forward in time to the end of the log on disk and look at all the log records we see and try to figure out what transactions are going to survive, which transactions need to get rolled back, and what pages may
Giai đoạn đầu tiên, chúng ta sẽ phân tích write-ahead log, bắt đầu từ chỗ master record trỏ tới, tức là điểm bắt đầu của checkpoint thành công gần nhất, và quét tiến theo thời gian tới cuối log trên đĩa và xem tất cả các bản ghi log mà ta thấy để xác định giao dịch nào sẽ được giữ lại, giao dịch nào cần được rollback, và những trang nào có thể
or may not have been written to disk during this process. Then after the analysis phase, we do redo.
đã hoặc chưa được ghi xuống đĩa trong quá trình này. Sau giai đoạn phân tích, chúng ta làm redo.
We're now going to jump back to another point in the log where we determine, here's the starting point of an active transaction, or a transaction that was active when a checkpoint started, and we're going to scan through and make sure we redo all its changes.
Giờ chúng ta nhảy ngược về một điểm khác trong log nơi ta xác định đây là điểm bắt đầu của một giao dịch đang hoạt động, hoặc một giao dịch đang hoạt động khi checkpoint bắt đầu, và ta sẽ quét qua để đảm bảo redo mọi thay đổi của nó.
And then now we go back and undo all the changes of transactions that should not survive after the crash, and go ahead and reverse that.
Rồi sau đó ta quay lại và undo mọi thay đổi của các giao dịch không được giữ lại sau sự cố, và tiến hành đảo ngược chúng.
So essentially taking three passes over the log, but in every pass we may be jumping farther and farther back in the log based on the information we collect during the analysis and redo process.
Về bản chất là duyệt log ba lượt, nhưng ở mỗi lượt ta có thể nhảy lùi xa hơn và xa hơn trong log dựa trên thông tin thu thập được trong quá trình phân tích và redo.
And the way to look at it visually again, we say this is a write-ahead log and we crash here down below.
Và để nhìn trực quan một lần nữa, giả sử đây là write-ahead log và ta gặp sự cố ở đây, phía dưới.
So when I come back, in the analysis phase I'm going to use the master record to figure out what's the starting point of the last checkpoint, and so I'll scan from that point down and look at what all the transactions are doing after that checkpoint started.
Vậy khi tôi khởi động lại, trong giai đoạn phân tích tôi sẽ dùng master record để xác định điểm bắt đầu của checkpoint gần nhất, và tôi sẽ quét từ điểm đó xuống dưới và xem tất cả các giao dịch làm gì sau khi checkpoint đó bắt đầu.
Then now based on my ATT, it's going to determine here's the transactions that I know about in my log, and I need to make sure I redo all their changes, even if they're going to get aborted later on.
Rồi dựa trên ATT của tôi, nó sẽ xác định đây là các giao dịch mà tôi biết trong log, và tôi cần đảm bảo redo mọi thay đổi của chúng, kể cả khi sau này chúng sẽ bị abort.
I'm still going to redo them. So in this case here, I go look at my log. In the redo phase, I find the smallest recLSN in my dirty page table after analysis.
Tôi vẫn sẽ redo chúng. Vậy trong trường hợp này, tôi xem log của mình. Trong giai đoạn redo, tôi tìm recLSN nhỏ nhất trong bảng trang bẩn sau khi phân tích.
So this is going to be what's the earliest LSN that corresponds to a log record that modified a page that was dirty before I started my checkpoint.
Đó sẽ là LSN sớm nhất ứng với một bản ghi log đã sửa đổi một trang là trang bẩn trước khi tôi bắt đầu checkpoint.
I'm going to go back and make sure I reapply all these changes from here down below.
Tôi sẽ quay lại và đảm bảo áp dụng lại tất cả những thay đổi này từ đây trở xuống.
And then now in the undo phase, I'm going to jump to the oldest log record of any active transaction that was still alive at the moment that I crashed, jump back to that point in time, and then scan through and undo all those transactions that should be aborted and rolled back.
Và sau đó, ở giai đoạn undo, tôi sẽ nhảy tới bản ghi log cũ nhất của bất kỳ giao dịch đang hoạt động nào vẫn còn sống vào thời điểm hệ thống sập, nhảy ngược về thời điểm đó, rồi quét qua và hoàn tác tất cả những giao dịch cần phải bị hủy và rollback.
And during this redo process we may end up, sorry, going like this, we may end up reapplying the CLR records to make sure we will reverse things, but that's okay, because that's, again, that's going to put it back to the correct state we want to be in.
Và trong quá trình redo này, xin lỗi, kiểu như thế này, chúng ta có thể sẽ áp dụng lại các bản ghi CLR để đảm bảo đảo ngược mọi thứ, nhưng không sao, vì một lần nữa, điều đó sẽ đưa nó về đúng trạng thái mà chúng ta muốn.
All right, so analysis phase, as I've already said, you scan forward from the beginning of the last successful checkpoint to the end of the log. You're basically reconstructing the ATT going forward in time.
Được rồi, vậy giai đoạn phân tích, như tôi đã nói, bạn quét xuôi từ đầu của checkpoint thành công gần nhất đến cuối log. Về cơ bản bạn đang tái dựng ATT theo chiều thời gian đi tới.
As you're scanning along in the analysis phase, if you find a transaction end message, you know that there's not going to be anything else from that transaction, so you can go ahead and remove it from the ATT.
Khi đang quét trong giai đoạn phân tích, nếu bạn thấy một thông điệp kết thúc giao dịch, bạn biết sẽ không còn gì khác từ giao dịch đó nữa, nên bạn có thể xóa nó khỏi ATT.
It's successfully committed.
Nó đã được commit thành công.
For all the log records, if the transaction is not in the ATT, then you go ahead and add it, but you set its undo status, its execution status, to be candidate for undo, because again you're scanning forward in time, so you haven't seen a commit or abort message for the transaction, so you just assume that it's going to abort.
Với tất cả các bản ghi log, nếu giao dịch chưa có trong ATT thì bạn thêm nó vào, nhưng đặt trạng thái undo, tức trạng thái thực thi của nó, là ứng viên để undo, vì một lần nữa, bạn đang quét xuôi theo thời gian, nên bạn chưa thấy thông điệp commit hay abort của giao dịch đó, do đó bạn cứ giả định rằng nó sẽ bị abort.
But then when you see the commit message for a transaction, then you update its status in the ATT to say it's allowed to commit.
Nhưng khi bạn thấy thông điệp commit của một giao dịch, thì bạn cập nhật trạng thái của nó trong ATT thành được phép commit.
As we scan along too, we just want to populate the DPT.
Trong lúc quét, chúng ta cũng muốn điền vào DPT.
So if we find a page that's being referenced that's not in our DPT as we scan along, then we know it's been modified since our last checkpoint, and therefore we want to make sure that it exists in there, and we just set its recLSN then to be whatever the LSN that modified it, because we know it didn't exist in the buffer pool, at least in a modified form,
Nên nếu chúng ta thấy một trang đang được tham chiếu mà không có trong DPT khi quét, thì ta biết nó đã bị sửa đổi kể từ checkpoint trước, và do đó ta muốn đảm bảo nó có mặt trong đó, và ta đặt recLSN của nó là LSN nào đã sửa đổi nó, vì ta biết nó không tồn tại trong buffer pool, ít nhất ở dạng đã sửa đổi,
at the moment that we see the log message, because otherwise we would have seen it in the DPT.
vào thời điểm chúng ta thấy bản ghi log đó, bởi vì nếu không thì ta đã thấy nó trong DPT rồi.
So now at the end of the analysis phase, the ATT is going to tell us what are all the transactions that are active at the time of the crash, and therefore we need to roll them back.
Vậy đến cuối giai đoạn phân tích, ATT sẽ cho chúng ta biết tất cả các giao dịch nào đang hoạt động tại thời điểm sập, và do đó chúng ta cần rollback chúng.
And the DPT is going to tell us all the pages that might have been, that were modified but may not have been written out to disk.
Còn DPT sẽ cho chúng ta biết tất cả những trang có thể đã bị sửa đổi nhưng có thể chưa được ghi xuống đĩa.
And you don't know whether they've been modified, whether the changes got written out to disk, unless you go read them. The DPT is telling you what you've got to go check.
Và bạn không biết chúng đã bị sửa đổi hay chưa, các thay đổi có được ghi xuống đĩa hay chưa, trừ khi bạn đọc chúng. DPT cho bạn biết những gì bạn phải đi kiểm tra.
Let's look at an example like this. So say that our transaction, sorry, system begins a checkpoint at 010.
Hãy xem một ví dụ như thế này. Giả sử giao dịch của chúng ta, xin lỗi, hệ thống bắt đầu một checkpoint tại 010.
So at this point here we don't, we don't have anything in our ATT or DPT, at least initially, but we know that we're all, all the transactions that are running in our system and all the, all the log records, sorry, all the pages that are sitting in our buffer pool.
Vậy tại thời điểm này, chúng ta chưa có gì trong ATT hay DPT, ít nhất là ban đầu, nhưng chúng ta biết là tất cả, tất cả các transaction đang chạy trong hệ thống và tất cả các, tất cả các log record, xin lỗi, tất cả các trang đang nằm trong buffer pool.
But at this point here we don't record that in the begin message.
Nhưng tại thời điểm này chúng ta không ghi điều đó vào thông điệp begin.
Then later on, at 020, you see this transaction T96 is making an update to a, to an object A in page 33.
Sau đó, ở 020, bạn thấy transaction T96 đang cập nhật một đối tượng A trong trang 33.
And again, assuming that if this thing was in our log message, then you know it modified the page, but we don't know whether that page was flushed out to disk as part of the checkpoint, like the checkpoint got to it first, or we modified it after the checkpoint, right, off that page.
Và một lần nữa, giả sử rằng nếu thứ này có trong log message của chúng ta, thì bạn biết là nó đã sửa đổi trang đó, nhưng chúng ta không biết liệu trang đó đã được ghi xuống đĩa như một phần của checkpoint hay chưa, tức là checkpoint đã xử lý nó trước, hay chúng ta đã sửa nó sau checkpoint, đúng không, trên trang đó.
So we put a log record in that says, here's, here's an entry in our ATT, says there's this transaction T96 that we now know about because we didn't, we didn't see the begin for it before the checkpoint started.
Vì vậy chúng ta ghi một log record nói rằng, đây là một mục trong ATT của chúng ta, cho biết có transaction T96 này mà giờ chúng ta mới biết đến vì chúng ta đã không thấy begin của nó trước khi checkpoint bắt đầu.
So that the, the begin message for this transaction is up above, before the checkpoint begin. But since that, we don't know what's gonna happen to it at this point.
Tức là thông điệp begin của transaction này nằm ở phía trên, trước checkpoint begin. Nhưng từ đó đến giờ, chúng ta không biết điều gì sẽ xảy ra với nó ở thời điểm này.
As we, in our analysis, we think it's gonna, we assume it's gonna get rolled back and abort, so it's an undo candidate.
Trong phần analysis, chúng ta nghĩ là nó sẽ, chúng ta giả định nó sẽ bị rollback và abort, nên nó là ứng viên để undo.
And we keep track of the page that it modified during this, right? And the recLSN corresponds to the one that modified it.
Và chúng ta theo dõi trang mà nó đã sửa đổi trong quá trình này, đúng không? Và recLSN tương ứng với bản ghi đã sửa đổi nó.
Then now we get to our transaction end, and at this point here now we have in our ATT T96, T97.
Rồi giờ chúng ta đến transaction end, và tại thời điểm này trong ATT của chúng ta có T96, T97.
So there's another transaction, T97, up above that did a bunch of other stuff before the transaction began, and we haven't seen it yet in any log messages after the checkpoint started, so we now know about it, and I'm gonna assume that it's gonna abort.
Vậy còn một transaction khác, T97, ở phía trên đã làm một loạt việc khác trước khi transaction begin, và chúng ta chưa thấy nó trong bất kỳ log message nào sau khi checkpoint bắt đầu, nên giờ chúng ta biết đến nó, và tôi sẽ giả định rằng nó sẽ abort.
And we also know about, there's a page 20 that was dirty in our buffer pool that the checkpoint would have, at least we know it would have been written out at the checkpoint completed.
Và chúng ta cũng biết có một trang 20 bị dirty trong buffer pool mà checkpoint sẽ, ít nhất chúng ta biết nó đã được ghi xuống khi checkpoint hoàn tất.
Then we see the log record for T96 that it committed, so we update its status in the ATT that it's allowed to commit, and then we now see the transaction end message for T96, so we can go ahead and remove it.
Sau đó chúng ta thấy log record của T96 cho biết nó đã commit, nên chúng ta cập nhật trạng thái của nó trong ATT là được phép commit, và rồi giờ chúng ta thấy thông điệp transaction end của T96, nên chúng ta có thể xóa nó đi.
So at this point, at the end, we know that there's a transaction T97 that did something up above that we're gonna need to roll back.
Vậy ở thời điểm này, cuối cùng, chúng ta biết có transaction T97 đã làm gì đó ở phía trên mà chúng ta sẽ cần rollback.
We don't have the log records for it, so we have to go find those, and we know that there's page 33 and page 20 where there were changes made to them that may have not made it out to disk.
Chúng ta không có các log record của nó, nên phải đi tìm chúng, và chúng ta biết có trang 33 và trang 20 nơi đã có các thay đổi mà có thể chưa được ghi xuống đĩa.
Yes, the question is: why does the DPT not have P33 at LSN 030?
Vâng, câu hỏi là: tại sao DPT không có P33 ở LSN 030?
Because it was not dirty at the moment the checkpoint started.
Vì nó chưa dirty vào thời điểm checkpoint bắt đầu.
So the DPT, ATT record what was the state of the world at the time the checkpoint started, and they put it in the transaction end part, not the beginning.
Vậy DPT và ATT ghi lại trạng thái của hệ thống tại thời điểm checkpoint bắt đầu, và chúng được đặt ở phần transaction end, không phải phần đầu.
All right, so now after the analysis phase we have our ATT and DPT, and now we know what transactions we need to Reapply changes to, and what transactions are gonna get aborted, and therefore we need to start undoing those changes.
Được rồi, vậy sau phần analysis chúng ta có ATT và DPT, và giờ chúng ta biết những transaction nào cần áp dụng lại các thay đổi, và những transaction nào sẽ bị abort, và do đó chúng ta cần bắt đầu hoàn tác các thay đổi đó.
And, sorry, and sorry, we don't, we're not gonna undo anything yet.
Và xin lỗi, xin lỗi, chúng ta chưa undo bất cứ thứ gì ở bước này đâu.
We're gonna apply all our changes, but if there were aborted transactions and we see the CLRs in the log as we're scanning through, we're gonna reapply them as well.
Chúng ta sẽ áp dụng tất cả các thay đổi, nhưng nếu có các giao dịch bị hủy và chúng ta thấy các CLR trong log khi đang quét qua, thì chúng ta cũng sẽ áp dụng lại chúng.
And then in the second phase, we're gonna go back and undo stuff. But for now, we're just gonna reapply whatever we see in the log.
Rồi ở giai đoạn thứ hai, chúng ta sẽ quay lại và undo các thay đổi. Nhưng bây giờ, chúng ta chỉ áp dụng lại bất cứ thứ gì thấy trong log.
We're not gonna create new log entries, we're just re-executing what we have.
Chúng ta không tạo mục log mới, chỉ thực thi lại những gì đã có.
So we're gonna scan from the log, log record at the smallest recLSN in the DPT, because that's gonna correspond to the log record that modified a page, uh, that was dirty at the moment the checkpoint started.
Vậy chúng ta sẽ quét từ log record có recLSN nhỏ nhất trong DPT, vì nó tương ứng với log record đã sửa đổi một trang, trang đó đã bị dirty tại thời điểm checkpoint bắt đầu.
So we know that's gonna be farther back in time than anything that got modified, you know, while the checkpoint was running.
Nên chúng ta biết nó nằm xa hơn về quá khứ so với bất cứ thứ gì bị sửa đổi trong lúc checkpoint đang chạy.
And then anytime we need to reverse or undo a transaction, because we know what its status should be, because we scanned to the end of the log, we know whether any transaction committed or not.
Và bất cứ khi nào cần đảo ngược hay undo một giao dịch, vì chúng ta biết trạng thái của nó phải là gì, do chúng ta đã quét đến cuối log, chúng ta biết giao dịch nào đã commit hay chưa.
So we have to undo any changes, that's when we go ahead and apply the CLRs. Um, that, sorry, I'm getting ahead of myself, that's undo.
Nên chúng ta phải undo mọi thay đổi, đó là lúc chúng ta áp dụng các CLR. À, xin lỗi, tôi nói trước rồi, đó là undo.
For redo, as I scan through, if I find a log record that updates a page or a CLR, I need to determine whether I should bring that page back into memory and go apply it.
Với redo, khi tôi quét qua, nếu tôi thấy một log record cập nhật một trang hoặc một CLR, tôi cần xác định xem có nên đưa trang đó trở lại bộ nhớ và áp dụng nó hay không.
And so now you can start looking at what's in my dirty page table and understanding how these log sequence numbers are gonna determine whether I've already applied this change or not, based on what I see when I bring the page back into memory.
Và giờ các bạn có thể bắt đầu xem trong dirty page table của tôi có gì và hiểu cách các log sequence number này quyết định tôi đã áp dụng thay đổi này hay chưa, dựa trên những gì tôi thấy khi đưa trang trở lại bộ nhớ.
So if we see an update record or a CLR that we need to reapply, if that page is not in our dirty page table, then we know that the change for that particular page, that page, that page when it was modified, was written out to disk before we crashed, and therefore we don't need to bring it back into memory and reapply our change.
Vậy nếu chúng ta thấy một bản ghi cập nhật hoặc một CLR cần áp dụng lại, mà trang đó không nằm trong dirty page table, thì chúng ta biết thay đổi đối với trang cụ thể đó, trang đó, khi nó bị sửa đổi, đã được ghi xuống đĩa trước khi hệ thống gặp sự cố, và do đó chúng ta không cần đưa nó lại vào bộ nhớ và áp dụng lại thay đổi.
If it is in our dirty page table, then we need to check to see whether the last log record, the recLSN, the earliest log record that modified that page since it was last flushed to disk, if that comes before the LSN that I'm looking at right now, then I know that whatever my change was that got applied to that log record,
Nếu nó nằm trong dirty page table, thì chúng ta cần kiểm tra xem log record cuối, tức recLSN, log record sớm nhất đã sửa đổi trang đó kể từ lần flush xuống đĩa gần nhất, nếu nó nằm trước LSN mà tôi đang xem lúc này, thì tôi biết rằng thay đổi của tôi đã được áp dụng tại log record đó,
or that the log record I'm looking at, that got applied since the page was written out, so I don't need to reapply it.
hay log record mà tôi đang xem, đã được áp dụng kể từ khi trang được ghi xuống, nên tôi không cần áp dụng lại.
But if the log record I'm trying to apply, if its LSN is greater than the pageLSN, then I know that my transaction that I'm trying to redo made some change that modified the page, and that that record was not, those changes were not written out to disk,
Nhưng nếu log record mà tôi đang cố áp dụng, có LSN lớn hơn pageLSN, thì tôi biết rằng giao dịch mà tôi đang cố redo đã thực hiện một thay đổi sửa đổi trang, và bản ghi đó, những thay đổi đó đã không được ghi xuống đĩa,
because the pageLSN was the last log record that modified this page when that page was written to disk.
vì pageLSN là log record cuối cùng đã sửa đổi trang này khi trang đó được ghi xuống đĩa.
So my recLSN, if my LSN comes later in time, I know that this page got modified, flushed to disk, and then I try to update it and my update didn't actually make it out to disk.
Vậy với recLSN của tôi, nếu LSN của tôi đến sau về thời gian, tôi biết trang này đã bị sửa đổi, được flush xuống đĩa, rồi tôi cố cập nhật nó và bản cập nhật của tôi thực ra đã không được ghi xuống đĩa.
The challenge, though, in order for me to figure that out, I've got to go out to disk, bring that page back in and go check its pageLSN, because I'm not recording that in my dirty page table in my checkpoints.
Tuy nhiên, thách thức là để tìm ra điều đó, tôi phải ra đĩa, đưa trang đó trở lại và kiểm tra pageLSN của nó, vì tôi không ghi giá trị đó vào dirty page table trong các checkpoint của mình.
I'm only recording the recLSN. I'm only recording the oldest log record that modified the page since it was last flushed to disk.
Tôi chỉ ghi recLSN. Tôi chỉ ghi bản ghi log cũ nhất đã sửa đổi trang kể từ lần cuối nó được flush xuống đĩa.
So for the first two here, you can just check the dirty page table without actually looking at the page and figure out whether you need to reapply this.
Vậy với hai trường hợp đầu ở đây, bạn chỉ cần kiểm tra dirty page table mà không cần xem trang và xác định xem có cần áp dụng lại thao tác này hay không.
For the last one, you have to go bring the page in and look at what the page LSN is set to.
Còn với trường hợp cuối, bạn phải đưa trang vào và xem page LSN đang được đặt bằng bao nhiêu.
So to redo any action, we just apply the update and then set the page LSN to whatever the LSN is that we applied.
Vậy để redo một hành động, ta chỉ việc áp dụng bản cập nhật rồi đặt page LSN bằng LSN mà ta vừa áp dụng.
We don't do any logging, and we don't need to make sure we flush anything during this recovery process, because that would be unnecessarily slow.
Ta không ghi log gì cả, và ta cũng không cần đảm bảo flush bất cứ thứ gì trong quá trình khôi phục này, vì làm vậy sẽ chậm một cách không cần thiết.
All right, we're not running the transaction, we're just trying to redo things, so why bother flushing things and making sure things committed.
Được rồi, ta không chạy giao dịch, ta chỉ đang cố gắng làm lại các thao tác, vậy thì cần gì phải flush rồi đảm bảo mọi thứ đã commit.
And then now, once we reach the end of the redo phase, any transaction that successfully committed, then we can put the transaction end message.
Và bây giờ, khi ta đến cuối pha redo, với bất kỳ giao dịch nào đã commit thành công, ta có thể ghi thông điệp kết thúc giao dịch (transaction end).
But we may still have transactions that we need to reverse their changes on, right? And that's what we're going to do in the second phase, because we have to.
Nhưng có thể vẫn còn những giao dịch mà ta cần hoàn tác các thay đổi, đúng không? Và đó là việc ta sẽ làm ở pha thứ hai, vì ta bắt buộc phải làm vậy.
We're going to generate additional CLRs.
Ta sẽ tạo thêm các CLR.
All right, so now in the undo phase, this is where we know all the transactions that successfully committed or did not commit at the time the crash occurred.
Được rồi, bây giờ ở pha undo, đây là lúc ta biết tất cả các giao dịch đã commit thành công hay chưa commit tại thời điểm sự cố xảy ra.
We've gone through the analysis phase, we figured out what everything is, we've done the redo where we've reapplied everybody's changes, and then now we need to go back and undo the changes for transactions that should not be allowed to commit or don't commit.
Ta đã đi qua pha analysis, đã xác định được mọi thứ, đã thực hiện redo, áp dụng lại các thay đổi của tất cả mọi người, và giờ ta cần quay lại để hoàn tác các thay đổi của những giao dịch không được phép commit hoặc không commit.
So any transaction that's still in our ATT with this undo status at the end of the redo phase, we now need to go back in reverse order and apply the changes as if it was an abort during normal execution operations.
Vậy bất kỳ giao dịch nào vẫn còn trong ATT với trạng thái undo này ở cuối pha redo, giờ ta cần quay ngược theo thứ tự đảo và áp dụng các thay đổi như thể đó là một lần abort trong quá trình thực thi bình thường.
Right, and we're going to use this, the last LSN.
Đúng vậy, và ta sẽ dùng cái này, last LSN.
The undo things allow us to quickly jump back in the write-ahead log, jump over things we don't need to look at again, just jump to the transaction, a transaction that we're aborting, undoing.
Các con trỏ undo cho phép ta nhảy ngược nhanh trong write-ahead log, bỏ qua những thứ không cần xem lại, chỉ nhảy đến giao dịch, giao dịch mà ta đang abort, hoàn tác.
You can jump to its log records and quickly find them and roll them back. And every time we're going to reverse a change, undo a change, we're going to create a new CLR.
Bạn có thể nhảy đến các bản ghi log của nó, tìm chúng nhanh chóng và rollback. Và mỗi lần ta đảo ngược một thay đổi, hoàn tác một thay đổi, ta sẽ tạo một CLR mới.
All right, so let's look at an example here. So we have our transaction starts at checkpoint at 010, sorry, 011, checkpoint ends at 012.
Được rồi, ta hãy xem một ví dụ. Giao dịch của ta bắt đầu checkpoint ở 010, xin lỗi, 011, checkpoint kết thúc ở 012.
There's a T1 at 013 that makes a change to P5. T2 makes a change to P3.
Có T1 ở 013 thay đổi P5. T2 thay đổi P3.
T1 then calls an abort, so to roll that back, again, we have our CLR records for this, right? We just go ahead and reverse the changes.
Sau đó T1 gọi abort, nên để rollback nó, một lần nữa, ta có các bản ghi CLR cho việc này, đúng không? Chúng ta chỉ việc tiến hành đảo ngược các thay đổi.
Once we know all the changes for T1 are done, then we can put the transaction end message in, right?
Khi biết tất cả các thay đổi của T1 đã xong, thì ta có thể ghi thông điệp kết thúc giao dịch vào, đúng không?
And then prevLSN just allows us to quickly jump through and find everything we want without having to look at everything individually. Then now say T3 does another change, right?
Và prevLSN cho phép ta nhanh chóng nhảy qua các bản ghi và tìm mọi thứ mình muốn mà không phải xem từng bản ghi một. Giờ giả sử T3 thực hiện thêm một thay đổi nữa, đúng không?
T2 now shows up, makes a change, and then we crash. So now we're going to go through the three phases.
Bây giờ T2 xuất hiện, thực hiện một thay đổi, rồi hệ thống bị sập. Vậy bây giờ ta sẽ đi qua ba pha.
So we're going to come back and use the master record to figure out where the starting point of the last successful checkpoint was.
Ta sẽ quay lại và dùng bản ghi master để xác định điểm bắt đầu của checkpoint thành công gần nhất nằm ở đâu.
So that's going to be up here, and then when we now look at the checkpoint end message, assume inside of it that record is going to have the ATT and the DPT.
Điểm đó sẽ ở trên này, và khi ta xem thông điệp kết thúc checkpoint, giả sử bên trong bản ghi đó có ATT và DPT.
So that's going to tell us that we know about transactions T1, T2, T3, and we know, since we don't know what's going to happen to them at this point, we assume that their status is undo candidates.
Nó sẽ cho ta biết có các giao dịch T1, T2, T3, và vì ở thời điểm này ta chưa biết chuyện gì sẽ xảy ra với chúng, ta giả định trạng thái của chúng là ứng viên hoàn tác (undo candidates).
And then there's a dirty page P1 that has some modification from a transaction that made a change up above at LSN 001.
Và có một trang dirty P1 mang thay đổi từ một giao dịch đã thực hiện ở phía trên tại LSN 001.
So now when I scan through in my, to from that in the checkpoint end to the end, right, I would see that I saw that there's two more pages that got modified since then.
Giờ khi tôi quét qua, từ checkpoint end đến cuối log, đúng không, tôi sẽ thấy có thêm hai trang nữa đã bị sửa đổi kể từ đó.
They may not have made it out to disk, I don't know.
Chúng có thể chưa được ghi xuống đĩa, tôi không biết.
And then now T1, I saw a transaction end message for, so I don't need to keep track of it anymore because I know it's going to successfully commit.
Và với T1, tôi thấy có thông điệp kết thúc giao dịch, nên tôi không cần theo dõi nó nữa vì tôi biết nó sẽ commit thành công.
So then now I have these last LSNs for my, for these T2 and T3 here.
Vậy giờ tôi có các LSN cuối cùng cho T2 và T3 ở đây.
I'm going to know where I need to start, my starting point is, to be able to roll them back.
Tôi sẽ biết mình cần bắt đầu từ đâu, điểm xuất phát của tôi là gì, để có thể hoàn tác chúng.
So same, now I do my, I do my redo, I go through and reapply everything, right?
Tương tự, giờ tôi thực hiện pha redo, đi qua và áp dụng lại mọi thứ, đúng không?
And then now at this point I want to start reversing the two transactions that don't successfully commit.
Và đến đây tôi muốn bắt đầu đảo ngược hai giao dịch không commit thành công.
So I'm going to start with T2 because that's the first one that I had the most recent log message right before the crash.
Tôi sẽ bắt đầu với T2 vì đó là giao dịch đầu tiên có thông điệp log gần nhất ngay trước lúc sập.
So I'm going to put a CLR for it to reverse its change, and then my undo next pointer just points to the next thing I have to undo.
Vậy tôi ghi một CLR cho nó để đảo ngược thay đổi của nó, và con trỏ undo next chỉ tới việc kế tiếp cần hoàn tác.
And then now I know the next thing I need to do is reverse this change at the T3, and again assuming that this undo next is some begin message for this transaction that's up above us in the log that we're not showing here.
Rồi giờ tôi biết việc tiếp theo cần làm là đảo ngược thay đổi này của T3, và lại giả sử undo next này là một thông điệp begin của giao dịch đó, nằm ở phía trên trong log mà ta không hiển thị ở đây.
At this point here I know I don't have any more changes I have for T3.
Đến đây tôi biết mình không còn thay đổi nào của T3 nữa.
So again, if I want to be super cautious, I'll flush the write-ahead log and flush all the dirty pages to disk, and then that way again I'm ensuring that all my changes are made out there.
Vậy nên, nếu muốn cực kỳ thận trọng, tôi sẽ flush write-ahead log và flush mọi trang dirty xuống đĩa, như vậy tôi đảm bảo mọi thay đổi của mình đã được ghi ra đó.
But yet you don't have to do this, and I just update my flush LSN to keep track of that these are the changes that I made.
Nhưng bạn không bắt buộc phải làm vậy, và tôi chỉ cập nhật flush LSN để theo dõi rằng đây là những thay đổi tôi đã thực hiện.
The reason why I want to do this: if I crash, come back during this recovery process.
I can look at the page LSN and recognize that my change actually made it out to disk when I reverse this transaction, so therefore I don't have to reapply the changes later on.
Lý do tôi muốn làm vậy: nếu tôi bị sập, rồi quay lại trong chính quá trình khôi phục này, tôi có thể xem page LSN và nhận ra rằng thay đổi của tôi thực sự đã được ghi xuống đĩa khi tôi đảo ngược giao dịch này, nên sau đó tôi không phải áp dụng lại các thay đổi.
But let's say now during recovery I crash again, worst case scenario.
Nhưng giả sử bây giờ, trong lúc khôi phục, tôi lại gặp sự cố một lần nữa, đó là trường hợp xấu nhất.
So now when I come back the second time, after I do my analysis, I'm going to see that the only thing I have sitting around is this T3 that I still need...
Vậy khi quay lại lần thứ hai, sau khi tôi thực hiện phân tích, tôi sẽ thấy thứ duy nhất còn lại là T3 này mà tôi vẫn cần...
I'm sorry, T2 that I still need to roll back.
xin lỗi, là T2 mà tôi vẫn cần phải rollback.
Right, so I'll just add my CLR to reverse its change, see that there's some undo next pointing to something else, and at this point here I know I've...
Đúng rồi, vậy tôi sẽ thêm CLR để đảo ngược thay đổi của nó, thấy rằng có một undo next trỏ đến một thứ khác, và đến thời điểm này tôi biết là mình đã...
there's nothing else for me to reverse for the T2. So I'm going to go ahead and put my transaction end message in, and then now at this point the database is fully recovered.
không còn gì để đảo ngược cho T2 nữa. Vì vậy tôi sẽ ghi thông điệp kết thúc giao dịch vào, và đến lúc này cơ sở dữ liệu đã được khôi phục hoàn toàn.
I can tell the outside world that we're accepting new queries and new transactions.
Tôi có thể thông báo với bên ngoài rằng chúng ta đang nhận các truy vấn và giao dịch mới.
Yes, question: what if you crash in the middle of abort? Well, we just did that, right? So I'm aborting T2 and T3.
Vâng, câu hỏi: nếu bị sập giữa chừng lúc abort thì sao? Chúng ta vừa làm điều đó rồi mà, đúng không? Tôi đang abort T2 và T3.
T3 gets aborted, I put transaction end, but before I can put the transaction, reverse the last change for T2, I crash.
T3 bị abort, tôi ghi transaction end, nhưng trước khi tôi kịp ghi giao dịch, đảo ngược thay đổi cuối cùng của T2, thì tôi gặp sự cố.
What do you mean by partial CLR?
Ý bạn là partial CLR là gì?
That's this, that's what I'm doing right here, right? T2, when I go for it, T2 has still one more thing to abort.
Chính là cái này, là điều tôi đang làm ngay đây, đúng không? T2, khi tôi xử lý nó, T2 vẫn còn một việc nữa cần abort.
Before I get there, I crash, I come back, and when I scan, when I scan everything, I see T2 is still hanging out there. I have to roll it back.
Trước khi tới đó, tôi gặp sự cố, rồi quay lại, và khi quét qua mọi thứ, tôi thấy T2 vẫn còn treo ở đó. Tôi phải rollback nó.
But then when I go through and redo, I would reapply the CLR change and make sure I reverse its change, then recognize I still have to...
Nhưng khi tôi đi qua và thực hiện redo, tôi sẽ áp dụng lại thay đổi của CLR và đảm bảo đảo ngược thay đổi của nó, rồi nhận ra tôi vẫn phải...
there's this thing points to undo next 014, so when I come back I need to put a CLR for 014.
có một thứ trỏ đến undo next 014, nên khi quay lại tôi cần ghi một CLR cho 014.
So no matter how many times I keep aborting and come back, I'm going to redo the changes until I get to the transaction end.
Vì vậy dù tôi có abort và quay lại bao nhiêu lần, tôi vẫn sẽ redo các thay đổi cho đến khi tới transaction end.
Other questions?
Còn câu hỏi nào khác không?
All right, well, we can finish up quickly then. Okay, so what do I do if I crash during recovery? Analysis phase: nothing, right?
Được rồi, vậy chúng ta có thể kết thúc nhanh thôi. Được rồi, vậy tôi làm gì nếu bị sập trong lúc khôi phục? Giai đoạn phân tích: không làm gì cả, đúng không?
You just come back and do the analysis phase over again, because again, that's a read-only operation.
Bạn chỉ cần quay lại và thực hiện lại giai đoạn phân tích, vì một lần nữa, đó là thao tác chỉ đọc.
If I crash during the redo, again I do nothing, because all I'm doing is just pedantically reapplying the changes over again, and maybe overwriting the same change over and over again, but that's okay.
Nếu tôi bị sập trong lúc redo, tôi cũng không làm gì, vì tất cả những gì tôi làm chỉ là áp dụng lại các thay đổi một cách tỉ mỉ lần nữa, và có thể ghi đè cùng một thay đổi nhiều lần, nhưng không sao.
I'm guaranteed to end up with the same database state. So just, if I crash during redo, I just do it all over again.
Tôi được đảm bảo sẽ có cùng trạng thái cơ sở dữ liệu. Vậy nếu tôi bị sập trong lúc redo, tôi chỉ việc làm lại tất cả từ đầu.
To make things go faster during redo, again, I assume that my changes are not...
Để redo chạy nhanh hơn, một lần nữa, tôi giả định rằng các thay đổi của mình không...
that I'm not going to crash during the redo process, so I don't do those flushes every single time I see a transaction end. I just eventually get them later on.
rằng tôi sẽ không bị sập trong quá trình redo, nên tôi không flush mỗi lần thấy một transaction end. Cuối cùng tôi sẽ flush chúng sau.
And this is what most systems will do. The original ARIES paper was super careful; they would flush every time a transaction ended, even though you don't need to.
Và đây là điều hầu hết các hệ thống sẽ làm. Bài báo ARIES gốc cực kỳ cẩn thận; họ flush mỗi khi một giao dịch kết thúc, dù thực ra không cần thiết.
And then, to make the undos faster, there is a research paper that basically says you don't apply the changes in the undo phase.
Và sau đó, để việc undo nhanh hơn, có một bài báo nghiên cứu về cơ bản nói rằng bạn không áp dụng các thay đổi trong pha undo.
You just record that there's things you want to undo in pages, and it's kind of like the mod log we saw in the case of, like, the B-epsilon tree or, like, my C++ compression scheme.
Bạn chỉ ghi lại rằng có những thứ cần undo trong các trang, và nó hơi giống mod log mà chúng ta đã thấy ở trường hợp cây B-epsilon, hay lược đồ nén bằng C++ của tôi.
You keep a little mod log that says, here's the things I need to reverse back on this page.
Bạn giữ một mod log nhỏ ghi rằng, đây là những thứ tôi cần hoàn tác trên trang này.
And then, upon reading that page or trying to do something on that page, then I go ahead and apply that.
Và rồi, khi đọc trang đó hoặc cố làm gì đó trên trang đó, lúc ấy tôi mới tiến hành áp dụng chúng.
And the idea there is that rather than waiting for me to do the entire undo process, I just queue up those changes and immediately start executing other transactions.
Ý tưởng ở đây là thay vì phải đợi tôi làm xong toàn bộ quá trình undo, tôi chỉ xếp hàng các thay đổi đó và bắt đầu thực thi ngay các giao dịch khác.
So they can go ahead and read and do whatever they want, and eventually one of them will touch the pages that have pending undo records I need to apply, and only then do I go ahead and apply them.
Vậy là chúng có thể cứ đọc và làm bất cứ gì chúng muốn, và cuối cùng sẽ có một giao dịch chạm vào các trang có các bản ghi undo đang chờ mà tôi cần áp dụng, và chỉ khi đó tôi mới áp dụng chúng.
And of course, the last one is to rewrite your application and try to avoid long-running transactions. That's easier said than done. Alright, so I'm rushing to the end.
Và tất nhiên, cách cuối cùng là viết lại ứng dụng của bạn và cố tránh các giao dịch chạy lâu. Nói thì dễ hơn làm. Được rồi, tôi đang chạy vội về cuối.
I can pick up where we left off.
Tôi có thể tiếp tục từ chỗ chúng ta đã dừng.
I'll pick up on this again and do a quick review next class, but the main things to remember about ARIES is that we're still using no-force, doing fuzzy checkpoints, which allows us to take snapshots of the pages while transactions are still running.
Tôi sẽ tiếp tục phần này và ôn lại nhanh vào buổi sau, nhưng những điều chính cần nhớ về ARIES là chúng ta vẫn dùng no-force, thực hiện fuzzy checkpoint, cho phép chúng ta chụp snapshot các trang trong khi các giao dịch vẫn đang chạy.
We can still redo everything starting at the earliest dirty page.
Chúng ta vẫn có thể redo mọi thứ bắt đầu từ trang dirty sớm nhất.
We're never going to make sure that when transactions get aborted we're going to apply CLRs, make sure we undo all the changes, and that no matter how many times we restart, those changes always get correctly reversed.
Chúng ta sẽ luôn đảm bảo rằng khi giao dịch bị hủy, chúng ta sẽ áp dụng các CLR, đảm bảo undo tất cả các thay đổi, và rằng dù khởi động lại bao nhiêu lần, các thay đổi đó luôn được hoàn tác đúng.
And the log sequence numbers are just a way to record the physical ordering of the changes as they should be correctly applied.
Còn log sequence number chỉ là cách ghi lại thứ tự vật lý của các thay đổi để chúng được áp dụng đúng.
So at this point in the semester, you know how to build now a safe and correct single-node database system. Congrats.
Vậy tại thời điểm này của học kỳ, các bạn đã biết cách xây dựng một hệ cơ sở dữ liệu đơn nút an toàn và đúng đắn. Chúc mừng.
It may not be, you know, the first pass may not be a good one, but you know how to build one.
Có thể lần làm đầu tiên chưa tốt, nhưng các bạn biết cách xây dựng một hệ như vậy.
Next class we'll talk about how do I make it distributed, because this is when everything gets much harder. Okay, alright, so let's switch over to the guest speaker.
Buổi sau chúng ta sẽ nói về cách làm cho nó phân tán, vì đây là lúc mọi thứ trở nên khó hơn nhiều. Được rồi, vậy chúng ta chuyển sang khách mời.
Hi everyone, again, and thanks for having me on.
Xin chào mọi người một lần nữa, cảm ơn đã mời tôi.
I'm Robert, I work at ClickHouse, and I saw that you had Benjamin from Firebolt speaking here two weeks ago in class, so I guess that makes me the second gentleman to present this semester.
Tôi là Robert, tôi làm việc tại ClickHouse, và tôi thấy lớp đã có Benjamin của Firebolt đến nói chuyện hai tuần trước, nên chắc tôi là vị khách nam thứ hai trình bày trong học kỳ này.
And it's actually quite interesting, Firebolt started as a fork of ClickHouse's open source code base, and as far as I know, they are still using the same file format as ClickHouse, so we must obviously have done something right with the file format.
Và thực ra điều đó khá thú vị, Firebolt khởi đầu là một bản fork từ mã nguồn mở của ClickHouse, và theo như tôi biết, họ vẫn đang dùng cùng định dạng tệp với ClickHouse, nên rõ ràng là chúng tôi đã làm đúng điều gì đó với định dạng tệp này.
And I thought I could talk a little bit about data organization and indices in ClickHouse and how that powers fast analytics. First of all, what is ClickHouse actually?
Và tôi nghĩ mình có thể nói đôi chút về cách tổ chức dữ liệu và các chỉ mục trong ClickHouse, cũng như cách chúng giúp phân tích dữ liệu nhanh. Trước hết, ClickHouse thực chất là gì?
So ClickHouse is an open source, column-oriented, distributed analytics database. The code has been open source for 10 years, and ClickHouse is really popular.
ClickHouse là một cơ sở dữ liệu phân tích mã nguồn mở, hướng cột, phân tán. Mã nguồn đã được mở suốt 10 năm, và ClickHouse thực sự rất phổ biến.
I took a look and there are almost 45,000 stars on GitHub, and on the right you see some of the analytics databases in our space.
Tôi đã xem thử và có gần 45.000 sao trên GitHub, và bên phải bạn thấy một số cơ sở dữ liệu phân tích trong lĩnh vực của chúng tôi.
The code is written in C++, and the database runs on pretty much anything, from a Raspberry Pi to powerful servers and clusters with hundreds of nodes.
Mã được viết bằng C++, và cơ sở dữ liệu chạy được trên hầu như mọi thứ, từ Raspberry Pi đến các máy chủ mạnh và cụm có hàng trăm nút.
ClickHouse is a column store, and people typically use it to filter and aggregate billions and trillions of rows.
ClickHouse là một column store, và người ta thường dùng nó để lọc và tổng hợp hàng tỉ, hàng nghìn tỉ dòng.
Our storage layer is also optimized for appends, which basically means that inserts are super fast, and updates and deletes do work, but they tend to be a bit slower, but I'd say we made a few optimizations for that recently as well.
Tầng lưu trữ của chúng tôi cũng được tối ưu cho thao tác ghi nối thêm (append), nghĩa là thao tác chèn cực kỳ nhanh, còn cập nhật và xóa vẫn hoạt động, nhưng có xu hướng chậm hơn một chút, dù tôi cho rằng gần đây chúng tôi cũng đã có vài tối ưu cho việc đó.
Now, append-only workloads, that might sound a bit strange, but there are actually lots of use cases where the data is continuously inserted but only rarely or never modified.
Còn khối lượng công việc chỉ nối thêm thì nghe có vẻ hơi lạ, nhưng thực ra có rất nhiều trường hợp dữ liệu được chèn liên tục mà hiếm khi hoặc không bao giờ bị sửa.
These use cases are typically around events, log files, time series, financial data and so on. OK, this slide shows how ClickHouse stores tables.
Những trường hợp này thường liên quan đến sự kiện, tệp nhật ký, chuỗi thời gian, dữ liệu tài chính, v.v. Được rồi, slide này cho thấy ClickHouse lưu trữ bảng như thế nào.
So you see on the left side a bunch of insert operations, and each insert basically creates a file on disk.
Bên trái bạn thấy một loạt thao tác chèn, và mỗi lần chèn về cơ bản tạo ra một tệp trên đĩa.
The term that we use internally is part, but in the end it's a file plus some metadata.
Thuật ngữ chúng tôi dùng nội bộ là part, nhưng suy cho cùng nó là một tệp cộng với một ít siêu dữ liệu.
And it might even be too obvious here, but when you insert the data, you don't need to synchronize with existing parts or global data structures, you don't need to do index lookups to check uniqueness.
Có thể điều này quá hiển nhiên, nhưng khi bạn chèn dữ liệu, bạn không cần đồng bộ với các part hiện có hay các cấu trúc dữ liệu toàn cục, cũng không cần tra cứu chỉ mục để kiểm tra tính duy nhất.
The performance of your inserts is only limited by the performance of your disk.
Hiệu năng chèn của bạn chỉ bị giới hạn bởi hiệu năng của đĩa.
The other thing, that's the other important thing, is that the rows in each part are sorted or clustered by the primary key columns of the table.
Điều còn lại, cũng là điều quan trọng khác, là các dòng trong mỗi part được sắp xếp hay gom cụm theo các cột khóa chính của bảng.
The user defines the primary key columns up front, so keep that in mind for a second.
Người dùng định nghĩa các cột khóa chính từ trước, nên hãy ghi nhớ điều đó một lát.
You also see a box labeled buffer on the left side, and that's our asynchronous insert mode, which basically buffers the rows from multiple inserts before the part is then flushed to disk.
Bạn cũng thấy một ô có nhãn buffer ở bên trái, đó là chế độ chèn bất đồng bộ của chúng tôi, nó đệm các dòng từ nhiều lần chèn trước khi part được ghi xuống đĩa.
Okay, now as more data comes in, the parts of course start to accumulate, so ClickHouse has a compaction job that runs in the background, and it continuously merges multiple parts into bigger parts.
Được rồi, khi có thêm dữ liệu, các part dĩ nhiên bắt đầu tích tụ, nên ClickHouse có một tác vụ compaction chạy nền, liên tục gộp nhiều part thành các part lớn hơn.
And remember, the parts are sorted, right? This means the compaction job can use a k-way merge sort algorithm to combine the parts, and that's fairly efficient.
Và nhớ rằng, các part đã được sắp xếp, đúng không? Điều này nghĩa là tác vụ compaction có thể dùng thuật toán merge sort k đường để kết hợp các part, và cách đó khá hiệu quả.
So you may notice that all of this is quite similar to a classical LSM tree.
Có thể bạn nhận ra tất cả những điều này khá giống với một LSM tree cổ điển.
The difference is that the parts in ClickHouse are all equal, so they are not organized in a tree or in a hierarchy. This is quite nice for our use case because of two reasons.
Điểm khác biệt là các part trong ClickHouse đều ngang hàng nhau, nên chúng không được tổ chức thành cây hay theo một cấu trúc phân cấp. Điều này khá tốt cho trường hợp sử dụng của chúng ta vì hai lý do.
First, the scan can parallelize over all the parts, so there is no implicit chronological ordering between the parts that would somehow restrict concurrency.
Thứ nhất, thao tác quét có thể song song hóa trên tất cả các part, vì không có thứ tự thời gian ngầm định nào giữa các part làm hạn chế tính đồng thời theo một cách nào đó.
And the second reason is that the merge is also not bound to certain LSM tree levels, so it can freely pick any parts anywhere to merge.
Và lý do thứ hai là thao tác merge cũng không bị ràng buộc vào các tầng nhất định của LSM tree, nên nó có thể tự do chọn bất kỳ part nào ở bất kỳ đâu để merge.
I'll also say that updates and deletes become a bit more tricky in this overall design, so we cannot use tombstones, but that's fine for us since we don't expect to have a lot of updates and deletes anyways.
Tôi cũng xin nói thêm rằng việc cập nhật và xóa trở nên phức tạp hơn một chút trong thiết kế tổng thể này, nên chúng ta không thể dùng tombstone, nhưng điều đó không sao với chúng ta vì dù sao chúng ta cũng không kỳ vọng sẽ có nhiều thao tác cập nhật và xóa.
Okay, now let's zoom into one of these mysterious parts.
Được rồi, bây giờ hãy xem kỹ một trong những part bí ẩn này.
This slide shows a table with web access statistics, so you have a user from a certain region who accesses a certain website, and we collect all of this information in a table.
Slide này cho thấy một bảng thống kê truy cập web, trong đó có một người dùng từ một khu vực nào đó truy cập một trang web nào đó, và chúng ta thu thập toàn bộ thông tin này trong một bảng.
So the data in this part consists of only a few seconds, but there are nevertheless many thousands of rows here.
Dữ liệu trong part này chỉ kéo dài vài giây, nhưng dù vậy vẫn có hàng nghìn hàng ở đây.
The user defined the event time column as the primary key for the table, and like I mentioned before, this means that ClickHouse sorts the rows in the part by event time.
Người dùng đã định nghĩa cột event time làm khóa chính của bảng, và như tôi đã đề cập trước đó, điều này có nghĩa là ClickHouse sắp xếp các hàng trong part theo event time.
From a database perspective, sorting is really nice, but we'll need an even smaller granularity, or data access granularity, to make the scans efficient.
Từ góc nhìn cơ sở dữ liệu, việc sắp xếp rất tốt, nhưng chúng ta cần một độ mịn nhỏ hơn nữa, hay độ mịn truy cập dữ liệu, để việc quét hiệu quả.
So what ClickHouse does is that it splits each part further into so-called granules, and every granule has 8192 rows.
Vì vậy, ClickHouse chia mỗi part thành các đơn vị gọi là granule, và mỗi granule có 8192 hàng.
You can see that on the left side: so there is granule 0 in blue, granule 1 in pink, and so on.
Bạn có thể thấy ở phía bên trái: granule 0 màu xanh dương, granule 1 màu hồng, và cứ thế tiếp tục.
A granule in ClickHouse is the smallest unit that our scan operator can load from disk. Now the question is, of course, how does all of this help with scans?
Một granule trong ClickHouse là đơn vị nhỏ nhất mà toán tử quét của chúng ta có thể nạp từ đĩa. Câu hỏi tất nhiên là: tất cả những điều này giúp ích gì cho việc quét?
The key concept is to prune data as aggressively as possible. So you want your select query to skip most of the data, because every byte that you don't read makes your query faster, right?
Khái niệm then chốt là cắt tỉa dữ liệu mạnh tay nhất có thể. Tức là bạn muốn truy vấn select bỏ qua phần lớn dữ liệu, vì mỗi byte bạn không đọc sẽ làm truy vấn nhanh hơn, đúng không?
So let's make an example.
Hãy xem một ví dụ.
You see a simple select query with a filter on event time at the bottom of the slide, and this query could in theory do a binary search on the event time column to find the right granules.
Bạn thấy một truy vấn select đơn giản với một bộ lọc trên event time ở cuối slide, và về lý thuyết truy vấn này có thể thực hiện tìm kiếm nhị phân trên cột event time để tìm các granule phù hợp.
Now, a binary search will have a logarithmic number of disk accesses.
Tìm kiếm nhị phân sẽ có số lần truy cập đĩa theo cấp logarit.
That sounds nice, but it's still not fast enough, especially when you try to do that on top of object storage, which has latencies of multiple tens of milliseconds.
Nghe có vẻ tốt, nhưng vẫn chưa đủ nhanh, đặc biệt khi bạn làm điều đó trên object storage, vốn có độ trễ vài chục mili giây.
So ClickHouse will do something smarter.
Vì vậy ClickHouse sẽ làm một cách thông minh hơn.
It will create a small index structure on top of the primary key columns which contains the first row of each granule, and you can see that in the yellow box on the slide.
Nó tạo một cấu trúc chỉ mục nhỏ trên các cột khóa chính chứa hàng đầu tiên của mỗi granule, và bạn có thể thấy điều đó trong khung màu vàng trên slide.
We say that this index is a sparse index because it points only to every 8192nd row and not to every row, and this index is also tiny compared to the rest of the table.
Chúng ta gọi chỉ mục này là chỉ mục thưa (sparse index) vì nó chỉ trỏ tới mỗi hàng thứ 8192 chứ không trỏ tới từng hàng, và chỉ mục này cũng rất nhỏ so với phần còn lại của bảng.
For example, you need only 1000 entries and then you can index already over 8 million rows. So actually, the index is so small that we load it and pin it in memory.
Ví dụ, bạn chỉ cần 1000 mục là đã có thể đánh chỉ mục cho hơn 8 triệu hàng. Thực ra chỉ mục nhỏ đến mức chúng tôi nạp nó và ghim (pin) cố định trong bộ nhớ.
So now our select query will do the binary search on the sparse index, and that will find the right granule, and then it will load the granules from this and finally filter them, because they could still contain a mix of matching and non-matching rows.
Vậy bây giờ truy vấn select sẽ thực hiện tìm kiếm nhị phân trên chỉ mục thưa, và việc đó sẽ tìm ra granule đúng, rồi nó sẽ nạp các granule từ đó và cuối cùng lọc chúng, vì chúng vẫn có thể chứa lẫn cả các hàng khớp và không khớp.
So that's what we call pruning with primary key indices. There are two more pruning techniques in Clickhouse, and I'll mention them only briefly. Projections are the second pruning technique.
Đó là điều chúng ta gọi là cắt tỉa (pruning) bằng chỉ mục khóa chính. Trong Clickhouse còn có hai kỹ thuật cắt tỉa nữa, và tôi chỉ nhắc đến ngắn gọn thôi. Projection là kỹ thuật cắt tỉa thứ hai.
So you can think of a projection as a permutation of a table. It contains exactly the same rows as the original table, but it's sorted by a different primary key.
Bạn có thể xem một projection như một hoán vị của bảng. Nó chứa chính xác các hàng giống như bảng gốc, nhưng được sắp xếp theo một khóa chính khác.
So if your workload has a lot of queries with filters on columns different than the original primary key columns, then you want to create a projection.
Vì vậy, nếu khối lượng công việc của bạn có nhiều truy vấn lọc trên các cột khác với các cột khóa chính ban đầu, thì bạn nên tạo một projection.
The cool thing is that the projections in Clickhouse are implemented at the part level, so basically every part can have an arbitrary number of projections, and the optimizer will pick the most beneficial one for every query.
Điều hay là các projection trong Clickhouse được cài đặt ở mức part, nên về cơ bản mỗi part có thể có số lượng projection tùy ý, và trình tối ưu hóa sẽ chọn projection có lợi nhất cho từng truy vấn.
Projections can help a lot with query performance, but their biggest problem is the storage footprint. So you can easily double or triple the memory consumption of the table.
Projection có thể cải thiện đáng kể hiệu năng truy vấn, nhưng vấn đề lớn nhất của chúng là dung lượng lưu trữ. Bạn rất dễ làm mức tiêu thụ bộ nhớ của bảng tăng gấp đôi hoặc gấp ba.
So what is even more popular is our customers are skipping indices, and the idea here is to annotate the granules with small amounts of metadata.
Điều phổ biến hơn nữa với khách hàng của chúng tôi là chỉ mục bỏ qua (skipping index), và ý tưởng ở đây là gắn vào các granule một lượng nhỏ siêu dữ liệu.
The scan can then check if no rows, or if all the rows, in the block or in the granules match the predicate, and it can potentially skip the entire block.
Khi quét, hệ thống có thể kiểm tra xem không hàng nào, hoặc tất cả các hàng, trong khối hay trong các granule có khớp với vị từ hay không, và nhờ đó có thể bỏ qua toàn bộ khối.
Clickhouse has different types of skipping indices, for example the max indices, the unique block values and bloom filters.
Clickhouse có nhiều loại chỉ mục bỏ qua khác nhau, ví dụ chỉ mục max, các giá trị duy nhất của khối và bloom filter.
Each type has different trade-offs, but generally speaking skipping indices are a lot more lightweight than projections, but they're also harder to tune because they make assumptions about the data distribution.
Mỗi loại có những đánh đổi khác nhau, nhưng nói chung chỉ mục bỏ qua nhẹ hơn nhiều so với projection, nhưng cũng khó tinh chỉnh hơn vì chúng đưa ra các giả định về phân bố dữ liệu.
There is a lot more to say about Clickhouse, of course, but I hope I could give you at least an idea how data pruning works in our database.
Tất nhiên còn rất nhiều điều để nói về Clickhouse, nhưng tôi hy vọng đã cho các bạn ít nhất một hình dung về cách cắt tỉa dữ liệu hoạt động trong cơ sở dữ liệu của chúng tôi.
If you have any more questions, feel free to drop me an email, and thanks for your attention. Any quick questions for Robert? Yes. Are there any plans to make joins faster?
Nếu có thêm câu hỏi nào, cứ thoải mái gửi email cho tôi, và cảm ơn các bạn đã chú ý lắng nghe. Có câu hỏi nhanh nào cho Robert không? Vâng, mời bạn. Có kế hoạch nào để làm cho phép join nhanh hơn không?
Because I feel like joins have been like a primary bottleneck for primary queries on ClickHouse. Yes. Go for it.
Vì tôi cảm thấy join từ trước đến nay là điểm nghẽn chính đối với các truy vấn chính trên ClickHouse. Vâng. Mời bạn trả lời.
We're working on it, and we implemented join reordering recently, and we are now adding tons more optimizations for joins. Yeah. What is the primary bottleneck that stopped you so far?
Chúng tôi đang làm việc đó, và gần đây chúng tôi đã cài đặt việc sắp xếp lại thứ tự join, và hiện giờ chúng tôi đang bổ sung thêm rất nhiều tối ưu hóa cho phép join. Vâng. Điều gì là nút thắt cổ chai chính đã cản trở các bạn cho đến nay?
The question is, what was the main bottleneck for joins in ClickHouse that you guys have been fixing in recent weeks or months?
Câu hỏi là, nút thắt cổ chai chính của phép join trong ClickHouse là gì mà các bạn đã khắc phục trong những tuần hay những tháng gần đây?
Oh no, there was no particular bottleneck, it's just, you know, historically most of our users use denormalized tables, right? So everything's one single huge fact table, and then you don't need joins.
À không, không có nút thắt cổ chai cụ thể nào cả, chỉ là, bạn biết đấy, từ trước đến nay hầu hết người dùng của chúng tôi dùng các bảng phi chuẩn hóa, đúng không? Tức là mọi thứ nằm trong một bảng fact khổng lồ duy nhất, và khi đó bạn không cần join.
That was the only reason. Yes. ClickHouse is an amazingly engineered system.
Đó là lý do duy nhất. Vâng. ClickHouse là một hệ thống được thiết kế kỹ thuật rất xuất sắc.
It's like the same category as like the Umbra system or Yellowbrick, like the amount of engineering they've done in ClickHouse is amazing.
Nó thuộc cùng nhóm với hệ thống Umbra hay Yellowbrick, lượng công sức kỹ thuật họ bỏ ra cho ClickHouse thật đáng kinh ngạc.
I think when Yandex first announced in 2016, I thought it was fake, I thought it was vaporware, because like I'd never heard about it before 2016 or 2015, and then they list all these features.
Tôi nhớ khi Yandex lần đầu công bố vào năm 2016, tôi tưởng đó là chuyện bịa, tôi tưởng đó là vaporware, vì trước năm 2016 hay 2015 tôi chưa từng nghe nói đến nó, rồi họ liệt kê ra hàng loạt tính năng.
I was like, there's no way somebody wrote all this in a year, but like they've been working on it for a long time, just publicly came out about that, and the amount of engineering these guys do to make this system work is phenomenal.
Tôi nghĩ, không thể nào có ai viết hết những thứ này trong một năm, nhưng thực ra họ đã làm việc với nó từ rất lâu, chỉ là đến lúc đó mới công khai, và công sức kỹ thuật mà những người này bỏ ra để hệ thống vận hành được là phi thường.
It's amazing. So again, thank you, Robert.
Thật tuyệt vời. Một lần nữa, cảm ơn Robert.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.