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ả.
Alright, let's get started. Round of applause if you need a catch. Again, thank you for coming out.
Được rồi, chúng ta bắt đầu thôi. Cho một tràng pháo tay nếu các em cần bắt bóng. Một lần nữa, cảm ơn các em đã đến.
So a quick comment, I was going to give you a thank you for being professional this semester.
Trước hết, một nhận xét nhanh. Thầy định cảm ơn các em vì đã cư xử rất chuyên nghiệp trong học kỳ này.
Like my other DJs always have, like, ex-girlfriends showing up at my office or, like, you know, behind on child support payments. You've been very professional. I appreciate you being here always on time.
Không như các DJ khác của thầy lúc nào cũng có bạn gái cũ tìm đến văn phòng, hoặc kiểu như, các em biết đấy, nợ tiền cấp dưỡng nuôi con. Các em rất chuyên nghiệp. Thầy cảm kích vì các em luôn đến đúng giờ.
So thank you again for, you know, this semester's not over. I was just thinking this morning, oh man, DJ Cash isn't going to be a problem.
Nên cảm ơn các em một lần nữa, nhưng học kỳ này vẫn chưa kết thúc đâu. Sáng nay thầy còn nghĩ, trời ơi, DJ Cash sẽ không gây rắc rối gì cả.
It's kind of nice. Alright, so guys, a lot to get started, a lot to discuss. Let's get started.
Cũng dễ chịu đấy. Được rồi các em, có nhiều việc phải bắt đầu, nhiều điều cần bàn. Bắt đầu thôi.
Again, for you guys in the class, the docket looks like this as you finish up near the end of the semester. Homework five is going to be due again this Sunday coming up.
Một lần nữa, với các em trong lớp, lịch trình khi các em sắp kết thúc học kỳ trông như thế này. Bài tập về nhà 5 sẽ đến hạn vào Chủ nhật tới đây.
Project four went out last week. The recitation will be tomorrow, November 18th at 8pm on Zoom, and the link is on Piazza.
Dự án 4 đã được đăng tuần trước. Buổi thảo luận sẽ diễn ra vào ngày mai, 18 tháng 11, lúc 8 giờ tối trên Zoom, và đường liên kết có trên Piazza.
And again, the write-up is quite exhaustive, deliberately so, because transactions are super hard. We're trying to be very thorough on what exactly you need to do for project four so you don't get lost.
Một lần nữa, bản mô tả khá đầy đủ chi tiết, là có chủ đích, vì giao dịch cực kỳ khó. Chúng thầy cố gắng nêu thật kỹ chính xác các em cần làm gì trong dự án 4 để các em không bị lạc hướng.
So please read that before you show up to the recitation. And then the final exam is going to be Thursday, December 11th at 1pm.
Vì vậy hãy đọc nó trước khi đến buổi thảo luận. Còn kỳ thi cuối kỳ sẽ vào Thứ Năm, ngày 11 tháng 12, lúc 1 giờ chiều.
It's a three hour exam. I don't know where it's going to be. They haven't scheduled it yet.
Đó là bài thi ba tiếng. Thầy chưa biết thi ở đâu. Họ vẫn chưa xếp lịch.
So please don't make travel plans before this date, because there's no make up and there's no early exams. Any questions about any of these things? Yes. Question: what happened to the advanced class 721?
Vì vậy xin đừng lên kế hoạch đi lại trước ngày này, vì không có thi bù và cũng không có thi sớm. Các em có câu hỏi nào về những việc này không? Vâng, mời em. Câu hỏi: lớp nâng cao 721 sao rồi ạ?
Other people have emailed me about this. Jagnesh Patel is the other Davis professor at CMU in the CS department. They made him the department chair because nobody else wanted to do it.
Cũng có những bạn khác đã gửi email hỏi thầy về việc này. Jagnesh Patel là giáo sư cơ sở dữ liệu còn lại ở CMU, thuộc khoa Khoa học Máy tính. Họ đã cho thầy ấy làm trưởng khoa vì không ai khác muốn làm.
But it's interim department chair. And as such, he, they were supposed to find a replacement for him so that he could teach the intro class next semester.
Nhưng chỉ là quyền trưởng khoa. Và vì thế, thầy ấy, lẽ ra họ phải tìm người thay thế thầy ấy để thầy ấy có thể dạy lớp nhập môn học kỳ sau.
And I could teach the advanced class. They have not found a replacement yet. They haven't done, the dean hasn't started the external search yet.
Và thầy có thể dạy lớp nâng cao. Họ vẫn chưa tìm được người thay. Họ chưa làm, trưởng khoa chưa bắt đầu tìm kiếm bên ngoài.
So at this point, there's nobody, nobody can teach the class other than me next semester. So I can't teach 721. The question is, can we find a replacement?
Nên hiện tại không có ai, học kỳ sau không ai có thể dạy lớp này ngoài thầy. Vì vậy thầy không thể dạy 721. Câu hỏi là liệu có tìm được người thay không?
Be nice. Yes. Do you want to be department chair? No. It's a thankless job. Yes, at this point, like, it's outside of my hands.
Nhẹ nhàng thôi. Vâng. Em có muốn làm trưởng khoa không? Không. Đó là việc chẳng ai cảm ơn. Vâng, lúc này nó nằm ngoài tầm tay thầy.
I don't have the controls. I apologize, but there's nothing I can do at this point. The question is, did he get a raise? Again, that's above my pay scale.
Thầy không có quyền quyết định. Thầy xin lỗi, nhưng lúc này thầy không thể làm gì. Câu hỏi là thầy ấy có được tăng lương không? Một lần nữa, chuyện đó vượt quá thẩm quyền của thầy.
I don't know. Right. All I know is he's teaching 721 now and being department chair. And trying to do, like, you know, awesome data research with me. So he's not, it's not sustainable.
Thầy không biết. Đúng vậy. Thầy chỉ biết bây giờ thầy ấy vừa dạy 721 vừa làm trưởng khoa. Và còn cố làm, các em biết đấy, nghiên cứu dữ liệu tuyệt vời cùng thầy. Nên không bền vững được.
So if it gets added back, I will email everyone. But at this point, don't bank on it. The question is, what, I don't know.
Nên nếu lớp được thêm lại, tôi sẽ gửi email cho mọi người. Nhưng hiện giờ thì đừng trông chờ vào điều đó. Câu hỏi là, gì nhỉ, tôi không biết.
I mean, ideally, yeah, like, I can't be, like, two weeks into the semester. Hey, guys, I'm going to come back. No, like, January, early January.
Ý tôi là, lý tưởng thì có, nhưng tôi không thể nghỉ khi mới vào học kỳ được hai tuần. Kiểu như, "Này các em, thầy sẽ quay lại." Không, phải đến tháng Một, đầu tháng Một.
But again, don't bank on it. Yeah. I'm not happy, too. It is what it is. But what can you do?
Nhưng một lần nữa, đừng trông chờ vào điều đó. Vâng. Tôi cũng không vui đâu. Sự việc là vậy. Nhưng biết làm sao được?
It used to be the intro class was only once per semester because it was just me teaching it. And the wait list was 500 people. Right.
Trước đây lớp nhập môn chỉ mở một lần mỗi học kỳ vì chỉ có mình tôi dạy. Và danh sách chờ lên tới 500 người. Đúng vậy.
And so we stole Jignesh from Wisconsin. Maybe we'll hire somebody else.
Thế nên chúng tôi đã mời Jignesh từ Wisconsin về. Có thể chúng tôi sẽ tuyển thêm người khác.
But even then, like, if we hire somebody else in, if we hire another data person this year, then that person could potentially teach the intro class in the fall, and then I could teach 721 in the fall.
Nhưng kể cả vậy, nếu chúng tôi tuyển thêm một người, nếu năm nay tuyển thêm một giảng viên về dữ liệu, thì người đó có thể dạy lớp nhập môn vào học kỳ mùa thu, và khi đó tôi có thể dạy 721 vào mùa thu.
But spring is not looking good. Okay. All right. So moving on. What else do we have going on? We have a lot of cool Davis talks coming up.
Nhưng học kỳ mùa xuân thì không khả quan. Được rồi. Chúng ta tiếp tục nhé. Còn có gì nữa nhỉ? Sắp tới có rất nhiều buổi nói chuyện Davis thú vị.
Tonight, or today, after this class, we'll have Ben, who gave the talk in class before, from Firebolt, talk about how they support Iceberg now. Snowflake is on campus today and tomorrow.
Tối nay, hay đúng hơn là hôm nay, sau lớp này, chúng ta sẽ có Ben, người từng nói chuyện trong lớp trước đây, từ Firebolt, nói về cách họ hỗ trợ Iceberg hiện nay. Snowflake có mặt ở trường hôm nay và ngày mai.
One of my former students is giving a talk tomorrow at 12 o'clock. I think the university recruiter is here as well. I know they've made some offers to some students for full-time positions.
Một cựu sinh viên của tôi sẽ có buổi nói chuyện vào 12 giờ ngày mai. Tôi nghĩ người tuyển dụng của trường cũng có mặt ở đây. Tôi biết họ đã gửi một số lời mời làm việc toàn thời gian cho vài sinh viên.
I don't know the status of internships and full-time offers beyond that from Snowflake. But they're on campus here if you want to meet up and talk to them.
Tôi không rõ tình hình về thực tập và các lời mời toàn thời gian khác từ Snowflake. Nhưng họ đang ở trường, nếu các em muốn gặp và trao đổi với họ.
And then the following week, we'll have a system out of the UK called XTDB. This is a weird one. It's a time series database, but it runs on multiple dimensions of time.
Và tuần sau nữa, chúng ta sẽ có một hệ thống đến từ Anh tên là XTDB. Cái này khá kỳ lạ. Đây là cơ sở dữ liệu chuỗi thời gian, nhưng chạy trên nhiều chiều thời gian.
We don't really cover time series databases in your class, but just think of, like, I want to keep track of stock ticks when these events occur.
Lớp của các em không thực sự đề cập đến cơ sở dữ liệu chuỗi thời gian, nhưng hãy hình dung thế này, tôi muốn theo dõi các mức giá cổ phiếu khi những sự kiện này xảy ra.
And then I also want to keep track of another dimension of time, like what would happen if I traded this stock at an earlier point in time.
Và tôi cũng muốn theo dõi một chiều thời gian khác, chẳng hạn điều gì sẽ xảy ra nếu tôi giao dịch cổ phiếu này vào một thời điểm sớm hơn.
So now you have sort of two parallel dimensions running on. It's wild stuff. Not this system, but time series databases are widely used in FinTech and trading world.
Vậy là có hai chiều thời gian song song cùng chạy. Thật điên rồ. Không phải hệ thống này, nhưng cơ sở dữ liệu chuỗi thời gian được dùng rộng rãi trong FinTech và giới giao dịch.
But again, that'll be next week on the Zoom seminar. OK. So last class was the last lecture we did on concurrency control. And we finished up talking about multi-version concurrency control.
Nhưng một lần nữa, việc đó sẽ diễn ra vào tuần sau trong buổi seminar trên Zoom. Được rồi. Buổi trước là bài giảng cuối cùng của chúng ta về điều khiển đồng thời. Và chúng ta kết thúc bằng việc nói về điều khiển đồng thời đa phiên bản.
And we said this was a mechanism we could allow us to basically make multiple physical versions of a logical object in our database.
Và chúng ta đã nói rằng đây là một cơ chế cho phép chúng ta về cơ bản tạo nhiều phiên bản vật lý của một đối tượng logic trong cơ sở dữ liệu.
So instead of overwriting the data directly, we'll make a copy or make an extra physical version that has either the delta of the change or the actual change itself in our system so that we can do a bunch of tricks of allowing consistent snapshots of the database when we go read things.
Vì vậy, thay vì ghi đè trực tiếp lên dữ liệu, chúng ta sẽ tạo một bản sao, hay tạo thêm một phiên bản vật lý chứa delta của thay đổi hoặc chính thay đổi thực tế đó trong hệ thống để chúng ta có thể dùng nhiều mẹo cho phép các snapshot nhất quán của cơ sở dữ liệu khi chúng ta đọc dữ liệu.
And we talked about how, like, not just MVCC, but all the other concurrency protocols we talked about before, how the design decisions we make in our concurrency protocols are going to affect all throughout all the other parts of the system.
Và chúng ta đã nói về việc không chỉ MVCC, mà còn tất cả các giao thức điều khiển đồng thời khác mà chúng ta đã nói trước đây, những quyết định thiết kế mà ta đưa ra trong các giao thức điều khiển đồng thời sẽ ảnh hưởng như thế nào đến tất cả các phần khác của hệ thống.
Because the other parts of the system need to be aware of transactions and what transactions are doing in the system to make sure we're doing things correctly.
Bởi vì các phần khác của hệ thống cần biết về các transaction và các transaction đang làm gì trong hệ thống để đảm bảo ta làm mọi thứ một cách chính xác.
So what we talked about so far has given us three of the properties of ACID. We got atomicity, consistency, and isolation.
Vậy những gì ta đã học cho đến giờ cho ta ba trong các thuộc tính của ACID. Ta có tính nguyên tử, tính nhất quán và tính cô lập.
Today's class and next class, we're going to talk about how we guarantee durability as well as atomicity after a crash. OK.
Buổi học hôm nay và buổi tới, ta sẽ nói về cách đảm bảo tính bền vững cũng như tính nguyên tử sau một sự cố sập hệ thống. Được rồi.
So here's the motivation of the problem we're trying to solve here today or for this week. So transaction T1 wants to read on A, write on A, and then commit.
Đây là động lực của bài toán mà ta đang cố giải quyết hôm nay, hay trong tuần này. Transaction T1 muốn đọc A, ghi A, rồi commit.
So we know how to do reads. Ignoring how we find object A in a page on disk, index, whatever, it doesn't matter.
Ta đã biết cách thực hiện việc đọc. Bỏ qua việc ta tìm đối tượng A trong một trang trên đĩa bằng chỉ mục hay cách nào khác, không quan trọng.
We know that in order to read this object, we first got to make a copy of the page out on disk in our nonvolatile storage, bring that into our buffer pool, hand out the pointer to the execution engine so the operators can access this data.
Ta biết rằng để đọc đối tượng này, trước hết ta phải sao chép trang từ đĩa trong bộ nhớ không bay hơi, đưa nó vào buffer pool, rồi trao con trỏ cho execution engine để các toán tử có thể truy cập dữ liệu này.
Then now we want to do a write on A.
Bây giờ ta muốn ghi lên A.
Ignoring multiversioning, say I'm doing a single version system, I apply my change directly in my page, in my buffer pool, and then I go ahead and commit.
Bỏ qua multiversioning, giả sử tôi đang dùng hệ thống một phiên bản, tôi áp dụng thay đổi trực tiếp vào trang của mình trong buffer pool, rồi tôi tiến hành commit.
Again, the property of commit is that we're telling the outside world that all the changes for your transaction have the ACID guarantees that we care about.
Một lần nữa, ý nghĩa của commit là ta thông báo cho thế giới bên ngoài rằng mọi thay đổi của transaction của bạn đều có các đảm bảo ACID mà ta quan tâm.
So we've told the outside world that our transaction is committed.
Vậy ta đã báo cho thế giới bên ngoài rằng transaction của ta đã commit.
But then the problem is if there's a bad storm and there's a major disruption to power, ignoring whether we have battery backups or whatever, it doesn't matter.
Nhưng vấn đề là nếu có một cơn bão lớn và nguồn điện bị gián đoạn nghiêm trọng, bỏ qua chuyện ta có pin dự phòng hay không, không quan trọng.
The system crashes and we lose everything in our buffer pool.
Hệ thống sập và ta mất mọi thứ trong buffer pool.
Of course, the problem here is that we told the outside world that our transaction committed and we applied their change, but now upon recovery, assuming we get power again, when we come back, we're not going to see that modification we made to A because we didn't write it out to disk.
Tất nhiên, vấn đề ở đây là ta đã báo cho thế giới bên ngoài rằng transaction đã commit và ta đã áp dụng thay đổi của họ, nhưng giờ khi khôi phục, giả sử có điện trở lại, khi ta khởi động lại, ta sẽ không thấy thay đổi mà ta đã thực hiện trên A vì ta chưa ghi nó ra đĩa.
So that's the problem we're trying to solve today and next class.
Đó là vấn đề ta đang cố giải quyết hôm nay và buổi tới.
How do we make sure that if we tell the outside world your transaction is committed, how do we make sure that no matter what happens to our database system, even if the data center melts down, we won't solve that problem this week.
Làm sao ta đảm bảo rằng nếu ta báo cho thế giới bên ngoài rằng transaction của bạn đã commit, thì dù có chuyện gì xảy ra với hệ thống cơ sở dữ liệu, kể cả khi trung tâm dữ liệu sụp đổ, tuần này ta sẽ không giải quyết vấn đề đó.
That'll be when we talk about distributed databases. But if the whole thing falls in a giant sinkhole, we can still come back and recover your data.
Việc đó sẽ nằm trong phần cơ sở dữ liệu phân tán. Nhưng nếu cả hệ thống rơi xuống một hố sụt khổng lồ, ta vẫn có thể quay lại và khôi phục dữ liệu của bạn.
So that's the problem we're trying to solve through crash recovery.
Đó là vấn đề ta đang cố giải quyết thông qua khôi phục sau sự cố.
The idea here is that it's the algorithms we're going to implement in our database system so that no matter what happens to our database system, as long as we tell you that your transaction is committed, then we'll guarantee that we'll retain that data.
Ý tưởng ở đây là các thuật toán mà ta sẽ cài đặt trong hệ cơ sở dữ liệu của mình để cho dù có chuyện gì xảy ra với hệ thống cơ sở dữ liệu của chúng ta, miễn là chúng ta đã báo với bạn rằng giao dịch của bạn đã được commit, thì chúng ta sẽ đảm bảo giữ lại dữ liệu đó.
And we can guarantee the consistency, atomicity properties that we want, despite what happens.
Và chúng ta có thể đảm bảo các tính chất nhất quán, tính nguyên tử mà chúng ta muốn, bất kể điều gì xảy ra.
Now, just because we store it and say you committed, and even if it is durable, someone, of course, can come along and overwrite your change to the next transaction.
Bây giờ, chỉ vì chúng ta đã lưu nó và báo là bạn đã commit, và dù nó có bền vững đi nữa, thì ai đó, tất nhiên, vẫn có thể đến và ghi đè thay đổi của bạn bằng giao dịch tiếp theo.
But that's okay. That's normal operations of the database system. It's really like if things crash, how do we come back and not lose anything? So our recovery algorithm is going to have two parts.
Nhưng không sao. Đó là hoạt động bình thường của hệ thống cơ sở dữ liệu. Vấn đề thực sự là nếu hệ thống bị sập, làm sao để quay lại mà không mất gì? Vì vậy thuật toán khôi phục của chúng ta sẽ có hai phần.
The first would be what we'll talk about today.
Phần đầu tiên là phần chúng ta sẽ nói hôm nay.
And that'll be the things that the database system does during normal operations, during normal execution of transactions and queries, so that it can set itself up to be able to recover any of those changes if there's a later crash.
Đó là những việc mà hệ thống cơ sở dữ liệu thực hiện trong hoạt động bình thường, trong quá trình thực thi giao dịch và truy vấn bình thường, để nó có thể chuẩn bị sẵn sàng khôi phục bất kỳ thay đổi nào trong số đó nếu sau này có sự cố sập.
And the next class will be: how do we go back after a crash?
Còn buổi học tới sẽ là: làm sao quay lại sau một lần sập?
Look at all the things we're going to record today in our database system to go figure out what was going on in the system at the moment of the crash, and how can we reconstruct the state of the database to put us back where we should be.
Xem tất cả những thứ chúng ta sẽ ghi lại hôm nay trong hệ thống cơ sở dữ liệu để tìm ra điều gì đang diễn ra trong hệ thống vào lúc nó sập, và làm sao tái dựng trạng thái của cơ sở dữ liệu để đưa chúng ta trở lại đúng nơi chúng ta cần ở.
Another important thing to understand when we talk about this as well, going back to my diagram here, ignoring the crash part.
Một điều quan trọng nữa cần hiểu khi nói về việc này, quay lại sơ đồ của tôi ở đây, bỏ qua phần sập hệ thống.
But as soon as I tell you that your data has been committed, like you say, I want to commit my transaction, as soon as you get back the acknowledgment that the commit was successful, then we should be guaranteed that your data was successfully stored.
Nhưng ngay khi tôi báo với bạn rằng dữ liệu của bạn đã được commit, chẳng hạn bạn nói, tôi muốn commit giao dịch của mình, ngay khi bạn nhận lại xác nhận rằng commit đã thành công, thì chúng ta phải đảm bảo dữ liệu của bạn đã được lưu thành công.
Now, there may be a race condition where you say you want to commit the transaction.
Bây giờ, có thể có một tình huống tranh chấp (race condition) khi bạn nói muốn commit giao dịch.
We can make it safe out on disk, but then before we send you the network message saying your transaction is successfully committed, the system crashes before that network message goes out.
Chúng ta có thể lưu nó an toàn xuống đĩa, nhưng rồi trước khi chúng ta gửi cho bạn thông điệp mạng báo rằng giao dịch của bạn đã commit thành công, hệ thống bị sập trước khi thông điệp mạng đó được gửi đi.
That's still okay, because it's up for the application to go back and say, okay, did my transaction actually commit or not?
Vậy vẫn ổn, vì ứng dụng có trách nhiệm quay lại và hỏi, này, giao dịch của tôi rốt cuộc đã commit hay chưa?
People don't write code that way, but in theory, that's what you're supposed to do.
Mọi người không viết code như vậy, nhưng về lý thuyết thì đó là điều bạn phải làm.
All right, so today we're going to first talk about the kind of failures we're going to have and how we want to manage this in our buffer pool.
Được rồi, hôm nay trước hết chúng ta sẽ nói về các loại lỗi sẽ gặp và cách chúng ta muốn quản lý chúng trong buffer pool.
Because the buffer pool, again, that's where we're staging all the data in memory before we make any changes to them.
Vì buffer pool, như đã nói, là nơi chúng ta chuẩn bị toàn bộ dữ liệu trong bộ nhớ trước khi thực hiện bất kỳ thay đổi nào lên chúng.
We need to be aware of what's going to happen when we're allowed to do certain things in our buffer pool.
Chúng ta cần biết điều gì sẽ xảy ra khi chúng ta được phép làm những việc nhất định trong buffer pool.
Then we'll talk about the two main approaches to guarantee durability: shadow paging and write-ahead logging.
Sau đó chúng ta sẽ nói về hai cách tiếp cận chính để đảm bảo tính bền vững: shadow paging và write-ahead logging.
The spoiler is me, write-ahead logging is what you're going to want to use, and most databases are going to go ahead and use this.
Tiết lộ trước là, write-ahead logging là thứ bạn sẽ muốn dùng, và hầu hết các cơ sở dữ liệu đều dùng cách này.
Then we'll talk about different logging schemes and what you can put in your write-ahead log, like what data should actually be.
Sau đó chúng ta sẽ nói về các lược đồ ghi log khác nhau và những gì bạn có thể đưa vào write-ahead log của mình, chẳng hạn như dữ liệu nào thực sự nên được ghi.
And then we'll finish up talking briefly about checkpoints, and I'll show a sort of naive checkpoint scheme that works in conjunction with the write-ahead log.
Và cuối cùng, chúng ta sẽ nói ngắn gọn về checkpoint, và tôi sẽ trình bày một cơ chế checkpoint khá ngây thơ (naive) hoạt động kết hợp với write-ahead log.
And then we'll see the problems with it, and then next class we'll start off with doing better checkpointing. Okay?
Sau đó chúng ta sẽ thấy các vấn đề của nó, và buổi sau chúng ta sẽ bắt đầu với việc làm checkpoint tốt hơn. Được chứ?
All right, so at this point in the semester, this should not be a shock when I say this, but again, we've been assuming this assumption of our sort of conceptual database system we've been talking about through all these lectures, where the primary storage location of the data, of the database itself, is going to be on nonvolatile storage.
Được rồi, đến thời điểm này của học kỳ, việc tôi nói điều này hẳn không còn gây bất ngờ, nhưng một lần nữa, chúng ta vẫn luôn giả định về hệ cơ sở dữ liệu mang tính khái niệm mà chúng ta đã nói đến qua tất cả các bài giảng này, trong đó nơi lưu trữ chính của dữ liệu, tức của chính cơ sở dữ liệu, nằm trên bộ nhớ lưu trữ không bay hơi.
An SSD, spinning disk hard drive, S3, it doesn't matter.
SSD, ổ đĩa cứng quay, S3, loại nào cũng được.
And then because we can't manipulate that data on nonvolatile storage directly, we always got to copy it into our buffer pool, which runs in DRAM, which is going to be volatile storage.
Và vì không thể thao tác trực tiếp trên dữ liệu ở bộ nhớ không bay hơi, nên ta luôn phải sao chép nó vào buffer pool, vốn chạy trên DRAM, là bộ nhớ bay hơi.
Right? And it's going to give us faster access.
Đúng không? Và nó cho ta truy cập nhanh hơn.
So anytime we want to manipulate data, we got to copy into memory, do whatever changes we want on that data, and then we're going to write that dirty data out the disk at some point.
Vì vậy mỗi khi muốn thao tác trên dữ liệu, ta phải sao chép vào bộ nhớ, thực hiện bất cứ thay đổi nào ta muốn trên dữ liệu đó, rồi đến một lúc nào đó ghi dữ liệu "bẩn" (dirty) ấy ra đĩa.
Right? And again, we can't do byte... Although to memory we can do byte-addressable modifications, the granularity that we're going to interact with data on nonvolatile storage is going to be through pages.
Đúng không? Và một lần nữa, ta không thể làm theo từng byte... Mặc dù với bộ nhớ trong ta có thể sửa đổi theo từng byte, đơn vị mà ta tương tác với dữ liệu trên bộ nhớ không bay hơi lại là các trang (page).
Four kilobytes, eight kilobytes, or whatever. And then the hardware itself can only ensure that four kilobytes be written atomically.
Bốn kilobyte, tám kilobyte, hoặc tùy loại. Và bản thân phần cứng chỉ đảm bảo được rằng bốn kilobyte được ghi một cách nguyên tử.
So again, the property we need to guarantee, or we need to provide, in order to say we have durable transactions, is that for any changes that a transaction makes, once we tell somebody that the transaction has been successfully committed, then the data has to be durable.
Vì vậy, một lần nữa, thuộc tính mà ta cần bảo đảm, hay cần cung cấp, để có thể nói rằng ta có các giao dịch bền vững (durable), là với mọi thay đổi mà một giao dịch thực hiện, một khi ta đã báo cho ai đó rằng giao dịch đã được commit thành công, thì dữ liệu phải được lưu bền vững.
And of course that means we can't have any partial changes For any transaction that's been committed, we don't want to have the transaction modify two pages and only one of them make it out to disk.
Và tất nhiên điều đó có nghĩa là ta không thể có các thay đổi một phần. Với bất kỳ giao dịch nào đã commit, ta không muốn giao dịch sửa hai trang mà chỉ một trong số đó được ghi ra đĩa.
Or if the database page is eight kilobytes, and therefore we've got to write two four-kilobyte pages out to the hardware, we don't want the first page to be written, but not the second, and we're telling the outside world that our transaction has successfully committed.
Hoặc nếu trang cơ sở dữ liệu là tám kilobyte, và do đó ta phải ghi hai trang bốn kilobyte ra phần cứng, ta không muốn trang đầu được ghi mà trang thứ hai thì không, trong khi ta lại báo với thế giới bên ngoài rằng giao dịch của ta đã commit thành công.
So today is about understanding how to make sure that our changes are written out to disk in the right order, so that, again, next class, when we crash and come back, we can make sure that we have what we expect to see, and enough information for us to recover the database back to the correct state.
Vì vậy hôm nay là để hiểu cách đảm bảo rằng các thay đổi của ta được ghi ra đĩa theo đúng thứ tự, để, một lần nữa, ở buổi sau, khi hệ thống sập rồi khởi động lại, ta có thể chắc chắn rằng mình có những gì mình mong đợi, và đủ thông tin để khôi phục cơ sở dữ liệu về trạng thái đúng.
So the two mechanisms we need to have are undo and redo. And this should be kind of obvious, but we're setting up to do something more sophisticated.
Vì vậy hai cơ chế ta cần có là undo và redo. Điều này có vẻ khá hiển nhiên, nhưng chúng ta đang chuẩn bị để làm một việc phức tạp hơn.
So undo is the mechanism we use to remove the effects of an incomplete or aborted transaction. Right?
Vậy undo là cơ chế chúng ta dùng để loại bỏ các ảnh hưởng của một giao dịch chưa hoàn tất hoặc đã bị hủy. Đúng không?
And again, that can happen because either the transaction itself says it wants to abort, calls rollback explicitly, or the concurrency control protocol says you can't commit, and then the transaction gets rolled back.
Và một lần nữa, điều đó có thể xảy ra vì chính giao dịch tự yêu cầu hủy, gọi rollback một cách tường minh, hoặc giao thức điều khiển đồng thời nói rằng bạn không thể commit, và sau đó giao dịch bị rollback.
Or again, the transaction's in flight, or is active, and then we crash, and we've got to make sure we roll things back.
Hoặc, giao dịch đang chạy dở, tức là đang hoạt động, rồi hệ thống bị sập, và chúng ta phải đảm bảo hoàn tác lại mọi thứ.
Redo is the mechanism that allows us to reapply the changes of a transaction that has committed.
Redo là cơ chế cho phép chúng ta áp dụng lại các thay đổi của một giao dịch đã commit.
So we want to make sure that we reinstall, or that we install, the changes that they did when they were normally running, so that, again, upon recovery, it looks like, you know, not looks, but it is as if that transaction fully executed, or did fully execute.
Vì vậy chúng ta muốn đảm bảo rằng mình cài đặt lại, hay đúng hơn là cài đặt, những thay đổi mà chúng đã thực hiện khi chạy bình thường, để một lần nữa, khi khôi phục, trông như là, ừm, không phải trông như là, mà thực sự là giao dịch đó đã được thực thi đầy đủ.
So how we're going to support undo and redo is going to depend on the policies we're going to have in our buffer pool.
Vậy cách chúng ta hỗ trợ undo và redo sẽ phụ thuộc vào các chính sách mà chúng ta áp dụng trong buffer pool.
Let's go back to this example here. Now we have two transactions. T1's going to do a read on A, write on A. T2's going to read on B and write on B.
Hãy quay lại ví dụ này. Bây giờ ta có hai giao dịch. T1 sẽ đọc A, ghi A. T2 sẽ đọc B và ghi B.
Again, I'm showing all this, you know, just sort of moving pages back and forth between buffer pool and disk.
Một lần nữa, tôi minh họa tất cả điều này, chỉ là việc di chuyển các trang qua lại giữa buffer pool và đĩa.
There's still going to be the concurrency protocols that we talked about before, like two-phase locking or OCC.
Vẫn sẽ có các giao thức điều khiển đồng thời mà chúng ta đã nói trước đó, như khóa hai pha hoặc OCC.
All that's still going to happen above all this as well, but we're ignoring that for today's class because in this example here, they don't conflict, therefore they can write independently.
Tất cả những thứ đó vẫn diễn ra phía trên toàn bộ phần này, nhưng hôm nay ta bỏ qua chúng vì trong ví dụ này, chúng không xung đột, nên có thể ghi độc lập.
So T1's going to start with a read on A. It's not in our buffer pool, so we know how to go out to disk and get it.
Vậy T1 bắt đầu với thao tác đọc A. Nó không có trong buffer pool, nên ta biết cách ra đĩa để lấy về.
We fetch the page, and we store it in our buffer pool. Now we're going to do a write on A, and we'll update A, make A equals 3 there.
Ta nạp trang đó và lưu vào buffer pool. Giờ ta ghi A, cập nhật A, cho A bằng 3.
Now there's a context switch where T2 starts. It does a read on B. That's already in the buffer pool, so that's fine. We can read that page.
Rồi có một lần chuyển ngữ cảnh khi T2 bắt đầu. Nó đọc B. Trang đó đã có trong buffer pool rồi, nên ổn. Ta có thể đọc trang đó.
And then now we're going to do a write on B and set B's value to 8. Now B wants to commit, right?
Và giờ ta ghi B và đặt giá trị của B thành 8. Giờ T2 muốn commit, đúng không?
Again, assuming this is one page with three cells or three blocks in it.
Giả sử đây là một trang có ba ô hay ba khối trong đó.
So at this point here, we need to make sure, before we tell the application that T2 has successfully committed, its changes have been written out to disk, right?
Vậy tại thời điểm này, ta cần đảm bảo rằng, trước khi báo cho ứng dụng biết T2 đã commit thành công, các thay đổi của nó đã được ghi xuống đĩa, đúng không?
The problem is, in the same page where B's located, there's also A. So the question is, should we allow A's dirty change to be written out to disk as well, because it's not committed?
Vấn đề là, trong cùng trang chứa B thì cũng có A. Vậy câu hỏi là, liệu ta có nên cho phép thay đổi dirty của A cũng được ghi xuống đĩa, vì nó chưa được commit?
So let's say we do write it out. Put A equals 3 and B equals 8, and we update that single page out on disk, right?
Giả sử ta cứ ghi nó xuống. Đặt A bằng 3 và B bằng 8, và ta cập nhật trang duy nhất đó trên đĩa, đúng không?
Now we tell T2, ha-ha, congrats, your transaction has been successfully committed, and they're happy. But now when T1 starts running up again, now they roll back.
Giờ ta nói với T2, ha-ha, chúc mừng, giao dịch của bạn đã commit thành công, và nó rất vui. Nhưng khi T1 chạy lại, giờ nó rollback.
And now we need to make sure, before we proceed any further, we don't have to block on the rollback request.
Và giờ ta cần đảm bảo, trước khi tiếp tục thêm, chúng ta không phải chặn yêu cầu rollback.
So if the application says rollback, we'll immediately come back and say, yep, got it, no problem, right? But now it's our job in the database system to go clean things up.
Vậy nếu ứng dụng nói rollback, chúng ta sẽ lập tức quay lại và nói, vâng, đã nhận, không vấn đề gì, đúng không? Nhưng giờ nhiệm vụ của hệ thống cơ sở dữ liệu là đi dọn dẹp mọi thứ.
So now we've got to make sure that we go remove the effects of T1 in that page, because we flushed it out to disk.
Vậy bây giờ chúng ta phải đảm bảo loại bỏ các tác động của T1 trong trang đó, vì chúng ta đã ghi nó ra đĩa.
So what's one way to do that? That's your question. It's kind of obvious, right?
Vậy một cách để làm việc đó là gì? Đó là câu hỏi của bạn. Khá hiển nhiên, đúng không?
Go fetch the page back in, see that it matches what I have now, and undo the effects of T1. Do we think that's a good idea or a bad idea?
Lấy trang đó vào lại, xem nó có khớp với những gì tôi đang có không, và hoàn tác các tác động của T1. Các bạn nghĩ đó là ý hay hay dở?
Is it correct? For one page, yeah. But always think in streams. What if I have a billion pages?
Nó có đúng không? Với một trang thì đúng. Nhưng hãy luôn nghĩ theo quy mô lớn. Nếu tôi có một tỉ trang thì sao?
Do I really want to go out and bring back in a billion pages, reverse changes, and write them all back out again? No.
Liệu tôi có thực sự muốn đọc lại một tỉ trang, đảo ngược các thay đổi, rồi ghi tất cả ra lại không? Không.
Because what happens also, too, if I crash halfway through that, updating a billion things? Now I've got a bunch of torn writes I've got to go clean up.
Vì còn một chuyện nữa xảy ra, nếu tôi bị sập giữa chừng khi đang cập nhật một tỉ thứ đó thì sao? Lúc đó tôi có cả đống torn write phải đi dọn dẹp.
So there can be two policies that affect what the database system is allowed to write out to disk, and when it is allowed to write out the pages to disk.
Vì vậy có hai chính sách ảnh hưởng đến việc hệ thống cơ sở dữ liệu được phép ghi gì ra đĩa, và khi nào thì được phép ghi các trang ra đĩa.
The first is going to be called the steal policy.
Chính sách đầu tiên gọi là steal policy.
And this determines whether the database system is allowed to evict a dirty object, again, think a page, a dirty object from the buffer pool that's been modified by a transaction that has not committed, and therefore is allowed to overwrite whatever the most recent committed version of that object out in non-volatile storage, out on our disk.
Nó quyết định liệu hệ thống cơ sở dữ liệu có được phép loại bỏ một đối tượng dirty, hãy nghĩ đó là một trang, một đối tượng dirty khỏi buffer pool, đã bị sửa đổi bởi một giao dịch chưa commit, và do đó được phép ghi đè lên phiên bản đã commit gần nhất của đối tượng đó trong bộ nhớ không bay hơi, tức là trên đĩa của chúng ta.
So if steal is enabled, then you're allowed to evict things and overwrite what's out on disk. If no-steal is enabled, then you're not allowed to do this.
Vậy nếu steal được bật, thì bạn được phép loại bỏ các trang và ghi đè lên những gì đang có trên đĩa. Nếu no-steal được bật, thì bạn không được phép làm vậy.
So this all ties together with project one now, because now in your replacement policy algorithm, like ARC or LRU-K, whatever you're using, it's got to be aware of which of these ones you're actually doing, because that's going to determine if I have a dirty page, am I allowed to write it out or not?
Điều này liên quan đến project một, vì giờ thuật toán chính sách thay thế của bạn, như ARC hay LRU-K, bất kể bạn dùng cái nào, phải biết bạn đang dùng chính sách nào trong số này, vì điều đó sẽ quyết định nếu tôi có một trang dirty, thì tôi có được phép ghi nó ra hay không?
And I'll say also too, I'm showing you steal, no steal. It's not like you do steal for some transactions, no steal for other transactions; your implementation only does one of these.
Tôi cũng xin nói thêm, tôi đang cho các bạn xem steal, no steal. Không phải là bạn dùng steal cho một số giao dịch, còn no steal cho các giao dịch khác; cách cài đặt của bạn chỉ làm một trong hai.
So the question is, if it's no steal, then some transactions may never be allowed to finish?
Vậy câu hỏi là, nếu là no steal, thì một số giao dịch có thể không bao giờ được phép hoàn tất?
Yes, we'll get there in a second, yes.
Đúng, lát nữa chúng ta sẽ nói tới, đúng vậy.
The thing they point out, which they are correct, that if I am not allowed to write uncommitted pages out to disk, then how would I ever handle a billion updates where everything's in memory?
Điều bạn ấy chỉ ra là hoàn toàn chính xác, nếu tôi không được phép ghi các trang chưa commit ra đĩa, thì làm sao tôi xử lý được một tỉ lần cập nhật khi mọi thứ đều nằm trong bộ nhớ?
You can kind of get around that by writing things to the side, but we'll get to that in a second.
Bạn có thể phần nào lách được bằng cách ghi dữ liệu sang một chỗ riêng, nhưng chúng ta sẽ nói tới điều đó ngay sau đây.
All right, the other policy, it's called the force policy, and this determines whether the data system is required to flush all the dirty pages from a transaction, that were modified by the transaction, before the transaction is allowed to commit.
Được rồi, chính sách còn lại gọi là force policy, và nó quyết định liệu hệ thống dữ liệu có bắt buộc phải tất cả các trang bẩn của một giao dịch, những trang đã bị giao dịch đó sửa đổi, trước khi giao dịch được phép commit.
So when I get that commit message from the application, I don't respond back and say, yes, you've successfully committed, until all the pages that it's modified in the buffer pool have been written out to disk.
Vậy khi tôi nhận được thông điệp commit từ ứng dụng, tôi sẽ không phản hồi lại rằng, vâng, bạn đã commit thành công, cho đến khi tất cả các trang mà nó đã sửa đổi trong buffer pool được ghi xuống đĩa.
And if I say no force, then I don't require that, right?
Còn nếu tôi chọn no force thì tôi không yêu cầu điều đó, đúng không?
So forcing can make it easier for us to do recovery later on, because I don't have to worry about whether a transaction has all its changes made out to disk or not, right?
Vậy force có thể giúp việc khôi phục sau này dễ dàng hơn, vì tôi không phải lo lắng về việc một giao dịch đã ghi hết các thay đổi của nó xuống đĩa hay chưa, đúng không?
If I'm totally committed, then I got them all out on disk. I still may have to clean things up to make sure I handle torn transactions.
Nếu giao dịch đã commit hoàn toàn thì tôi đã ghi tất cả xuống đĩa rồi. Tôi vẫn có thể phải dọn dẹp để đảm bảo xử lý được các giao dịch bị ghi dở (torn).
All right, so let's look at an example of no steal and force.
Được rồi, hãy xem một ví dụ về no steal và force.
Again, no steal means that I'm not allowed to evict dirty pages before a transaction commits, And then force means that when a transaction commits, I have to write all of the changes out to disk.
Nhắc lại, no steal nghĩa là tôi không được phép đẩy các trang bẩn ra khỏi bộ nhớ trước khi giao dịch commit. Còn force nghĩa là khi một giao dịch commit, tôi phải ghi tất cả các thay đổi xuống đĩa.
So I start off again, T1 does a read on A, I fetch that page, bring it into memory, then I do the write on A, I update that single record in the page, context switch over to T2.
Vậy ta bắt đầu lại: T1 đọc A, tôi lấy trang đó và nạp vào bộ nhớ, rồi tôi ghi A, cập nhật bản ghi đơn đó trong trang, chuyển ngữ cảnh sang T2.
T2 does a read on B, that's fine, that's in memory, does a write on B, that's in memory, we overwrite the existing value. Now I go ahead and commit.
T2 đọc B, không sao, trang đó đang ở trong bộ nhớ, rồi ghi B, cũng trong bộ nhớ, ta ghi đè giá trị hiện có. Giờ tôi tiến hành commit.
And again, under the force policy, before I can tell the application that T2 has successfully committed, I got to write out that page that it modified.
Và một lần nữa, theo chính sách force, trước khi tôi có thể báo cho ứng dụng rằng T2 đã commit thành công, tôi phải ghi trang mà nó đã sửa đổi xuống đĩa.
But the problem is, in that page, I also have changes from T1 on A, but T1 is not committed. So no steal says I can't write out that page at all.
Nhưng vấn đề là trong trang đó cũng có thay đổi của T1 trên A, mà T1 thì chưa commit. Vậy no steal nói rằng tôi hoàn toàn không được ghi trang đó ra.
So I have this sort of conflict here that says one transaction says flush everything, the other transaction says it's not allowed to flush anything.
Như vậy ở đây có một kiểu xung đột: một giao dịch bảo hãy flush mọi thứ, giao dịch kia lại bảo không được flush bất cứ thứ gì.
So a simple way to handle this is just make a copy of the page, only include the change from the transaction that's committing into that new page, and then that gets written out to disk.
Một cách đơn giản để xử lý là tạo một bản sao của trang, chỉ đưa vào trang mới đó thay đổi của giao dịch đang commit, rồi trang đó được ghi xuống đĩa.
Yes.
Vâng, mời bạn.
The question is, why is no steal preventing us from writing out that page? Because I can't write pages, I can't write modifications from transactions that have not committed yet.
Câu hỏi là: tại sao no steal lại ngăn ta ghi trang đó ra? Vì tôi không thể ghi các trang, không thể ghi các sửa đổi từ những giao dịch chưa commit.
They just have to be in the same page. Yes.
Chúng chỉ tình cờ nằm trong cùng một trang. Vâng, mời bạn.
The question is, how do I know the original data of the page?
Câu hỏi là: làm sao tôi biết dữ liệu gốc của trang?
We're getting there in a second, but assume your transaction maintains some metadata, like the undo, redo, to know what it changed and what it changed it from.
Lát nữa ta sẽ nói tới, nhưng hãy giả sử giao dịch của bạn lưu một số metadata, như undo, redo, để biết nó đã thay đổi cái gì và thay đổi từ giá trị nào.
The question is, what if there's no space to make a copy? Correct, yes. You're poking holes through this, yes. I'm not saying this is a good idea.
Câu hỏi là: nếu không còn chỗ để tạo bản sao thì sao? Đúng vậy. Bạn đang chọc thủng cách này rồi đấy. Tôi không nói đây là ý hay.
This is the straw man. So yes. Yes.
Đây chỉ là một giải pháp làm ví dụ (straw man). Vâng, mời bạn.
The question is, is it an option to wait on T1? I mean, wait for T1 to, sorry, wait for T1 to do what? Who's waiting? T2 is waiting for T1?
Câu hỏi là: liệu có thể chọn cách chờ T1 không? Ý tôi là, chờ T1, xin lỗi, chờ T1 làm gì? Ai đang chờ? T2 đang chờ T1 à?
The question is, so yeah, in this case here, should this T2 yield for T1 and wait till T1 does something so that I can decide what to do?
Câu hỏi là, vâng, trong trường hợp này, T2 có nên nhường cho T1 và chờ đến khi T1 làm gì đó để tôi có thể quyết định phải làm gì không?
Shadow paging will do this, but how long should you wait? What if a person in T1 walks, typing at the terminal, walks away?
Shadow paging sẽ làm như vậy, nhưng bạn nên chờ bao lâu? Nếu một người dùng ở T1 gõ ở terminal rồi bỏ đi thì sao?
So the Databricks talk talked about this, and they said that people in, like, notebooks in Databricks, so people start transactions and then they get up and walk away, and then so they had to set an automatic timeout to kill transactions if they run for 24 hours.
Buổi nói chuyện của Databricks có nhắc đến chuyện này, và họ nói rằng những người dùng, chẳng hạn trong các notebook trên Databricks, họ bắt đầu giao dịch rồi đứng dậy bỏ đi, nên họ phải đặt một thời gian chờ tự động để hủy các giao dịch nếu chúng chạy quá 24 giờ.
Do I want to wait 24, should T2 wait for 24 hours? No.
Tôi có muốn chờ 24, T2 có nên chờ 24 giờ không? Không.
All right, so the advantage of this now, if we do this approach, it's really tractable for us to roll back T1 now, because we just go reverse the change in our page, and we didn't, none of its changes made it out to the disk.
Được rồi, ưu điểm của cách này là, nếu ta làm theo hướng này, việc rollback T1 lúc này thực sự khả thi, vì ta chỉ cần đảo ngược thay đổi trong trang của mình, và không có thay đổi nào của nó được ghi ra đĩa.
Right, the no-steal prevents that. So we don't have to do any clean up with no-steal, because we know whatever's been out on disk is from transactions that have committed.
Đúng vậy, no-steal ngăn điều đó. Vì thế với no-steal ta không phải dọn dẹp gì cả, vì ta biết bất cứ thứ gì đã được ghi ra đĩa đều đến từ các giao dịch đã commit.
So that's good.
Vậy là tốt.
So, I would say it's a strong end, this is the easiest thing to implement, right?
Tôi có thể nói đây là cách mạnh, và là cách dễ triển khai nhất, đúng không?
Again, of course, the problem is you have to have enough memory so that you can maintain the write set in memory without running out of disk.
Tất nhiên, vấn đề là bạn phải có đủ bộ nhớ để giữ write set trong bộ nhớ mà không bị hết chỗ trên đĩa.
Assuming you can do that, then this is pretty simple to do, and it makes recovery trivial, because again, when you come back, the disk is going to look exactly the way it should, because it's only containing information from committed transactions.
Giả sử bạn làm được điều đó, thì cách này khá đơn giản, và khiến việc khôi phục trở nên tầm thường, vì khi hệ thống chạy lại, đĩa sẽ trông đúng như nó phải có, vì nó chỉ chứa thông tin từ các giao dịch đã commit.
That's not entirely true either in the example I'm showing here, because there's no metadata, there's no additional metadata to say that all the changes from a committed transaction have been written out to disk.
Điều đó cũng không hoàn toàn đúng trong ví dụ tôi đang cho xem ở đây, vì không có metadata, không có metadata bổ sung nào cho biết rằng tất cả thay đổi của một giao dịch đã commit đã được ghi ra đĩa.
In my toy example, They're only running one page, and that can be done, we can assume that's done atomically.
Trong ví dụ đơn giản của tôi, họ chỉ ghi một trang, và điều đó có thể làm được, ta có thể giả sử nó được thực hiện một cách nguyên tử.
So, the way you really implement no-steal enforced is through a technique we talked earlier on, talked about earlier on, called shadow paging. And this is what IBM invented in the 1970s on System R.
Vậy, cách thực sự để triển khai no-steal bắt buộc là qua một kỹ thuật mà ta đã nói đến trước đó, đã nhắc đến trước đó, gọi là shadow paging. Và đây là thứ IBM đã phát minh vào những năm 1970 trên System R.
This is the first way they wanted to implement and support durable transactions in one of the first relational database systems.
Đây là cách đầu tiên họ muốn dùng để triển khai và hỗ trợ các giao dịch bền vững trong một trong những hệ quản trị cơ sở dữ liệu quan hệ đầu tiên.
I don't know what Ingres did in the early days, and Oracle came later, and Oracle didn't do this. So, the basic idea of shadow paging is that you maintain two copies of the database.
Tôi không biết Ingres đã làm gì trong những ngày đầu, còn Oracle ra đời sau, và Oracle không làm như vậy. Vậy, ý tưởng cơ bản của shadow paging là bạn duy trì hai bản sao của cơ sở dữ liệu.
The master copy is going to contain changes from only committed transactions, and then the shadow copy is sort of temporary space where uncommitted transactions are making changes and can write them out to disk if necessary, to swap them out in order to get space.
Bản chính sẽ chỉ chứa các thay đổi từ những giao dịch đã commit, còn bản shadow là một dạng không gian tạm thời nơi các giao dịch chưa commit thực hiện thay đổi và có thể ghi chúng ra đĩa nếu cần, để hoán đổi chúng ra ngoài nhằm lấy thêm chỗ.
But because they're not overwriting the master copies, then this is okay.
Nhưng vì chúng không ghi đè lên các bản chính, nên điều này không sao.
So that now if I crash and come back, I just ignore whatever's in the shadow copy database, because the master only contains the data from committed transactions.
Như vậy bây giờ nếu hệ thống bị sập rồi khởi động lại, tôi chỉ việc bỏ qua bất cứ thứ gì có trong cơ sở dữ liệu bản bóng, vì bản chính chỉ chứa dữ liệu từ các giao dịch đã commit.
And then to make sure that we know that all our changes from committed transactions have been successfully made out to disk, I'm going to have a single record called the master record, which is basically a pointer that says, here's the latest page table,
Và để biết chắc rằng mọi thay đổi từ các giao dịch đã commit đã được ghi thành công xuống đĩa, tôi sẽ có một bản ghi duy nhất gọi là master record, về cơ bản là một con trỏ cho biết: đây là bảng trang mới nhất,
here's the current page table of the database system, sorry, not the page table, the directory. Here's the current page directory that I know only contains changes from committed transactions.
đây là bảng trang hiện tại của hệ cơ sở dữ liệu, xin lỗi, không phải bảng trang, mà là page directory. Đây là page directory hiện tại mà tôi biết chỉ chứa các thay đổi từ những giao dịch đã commit.
So once my transaction commits and I write all those pages out to disk, I just flip a pointer now in a single record, which I can do atomically, to say now you're pointing to the new page directory.
Vì vậy khi giao dịch của tôi commit và tôi ghi tất cả các trang đó xuống đĩa, tôi chỉ cần đổi một con trỏ trong một bản ghi duy nhất, việc này có thể làm một cách nguyên tử, để nói rằng giờ nó trỏ tới page directory mới.
So this technique is old, but it's very rare. We'll talk a little bit about why IBM abandoned this later on. Probably the most famous system that uses this approach is LMDB.
Kỹ thuật này đã cũ, nhưng rất hiếm khi được dùng. Lát nữa chúng ta sẽ nói một chút về lý do IBM đã từ bỏ nó. Có lẽ hệ thống nổi tiếng nhất dùng cách tiếp cận này là LMDB.
And he's the opposite of me. He loves mmap. He loves shadow paging. And he's very vocal about this. And we'll see roughly how they do it, but it has some limitations.
Và ông ấy trái ngược với tôi. Ông ấy thích mmap. Ông ấy thích shadow paging. Và ông ấy phát biểu về điều này rất mạnh mẽ. Chúng ta sẽ xem đại khái họ làm thế nào, nhưng nó có một số hạn chế.
CacheDB does this as well. They're going to get around the fragmentation problem by only appending the shadow pages to the end of the database file.
CacheDB cũng làm như vậy. Họ khắc phục vấn đề phân mảnh bằng cách chỉ nối thêm các trang bóng vào cuối tệp cơ sở dữ liệu.
Of course, you have to do garbage collection to clean that up. FastDB is out of Russia. Gemstone, that's a rando system that's pretty old.
Tất nhiên, bạn phải thu gom rác để dọn chúng đi. FastDB đến từ Nga. Gemstone là một hệ thống vô danh khá cũ.
And then SQLite did this originally, but they got rid of it, and they switched over to the write-ahead log. We'll see that in a second. Question: where are the shadow pages?
Còn SQLite ban đầu cũng làm vậy, nhưng họ đã bỏ nó và chuyển sang dùng write-ahead log. Lát nữa ta sẽ thấy. Câu hỏi: các trang bóng nằm ở đâu?
We'll just do the example and you'll see. It's in both.
Chúng ta cứ làm ví dụ rồi sẽ thấy. Nó nằm ở cả hai.
It's also going to look a lot like multiversioning, but now it's being done at the granularity of a page instead of a single record.
Nó cũng trông rất giống đa phiên bản, nhưng giờ được thực hiện ở mức độ chi tiết của một trang thay vì một bản ghi đơn lẻ.
And then we talked about taking page locks when we talked about the hierarchy of locks. And pages were in there, but I didn't really discuss them.
Và chúng ta đã nói về việc khóa trang khi nói về phân cấp khóa. Trang có trong đó, nhưng tôi chưa thật sự bàn đến.
You would use page locking for this kind of stuff. All right, so we have our master pointer that's pointing to the master page table. That should be page directory, but it's all the same.
Bạn sẽ dùng khóa trang cho loại việc này. Được rồi, ta có con trỏ chính trỏ tới bảng trang chính. Đáng lẽ phải là page directory, nhưng cũng như nhau thôi.
But it's basically in memory, mapping through our page ID to some location on disk.
Nhưng về cơ bản nó nằm trong bộ nhớ, ánh xạ page ID của ta tới một vị trí nào đó trên đĩa.
So then now when a transaction starts, say T1 comes along and it starts, it's going to create a shadow page table that's going to basically, in the beginning, just contain the exact same records and pointers to those pages out on disk, because there's been no changes made yet.
Vậy bây giờ khi một giao dịch bắt đầu, giả sử T1 xuất hiện và bắt đầu, nó sẽ tạo một bảng trang bóng, mà về cơ bản, lúc đầu chỉ chứa y hệt các bản ghi và con trỏ tới những trang đó trên đĩa, vì chưa có thay đổi nào được thực hiện.
But then as T1 modifies things and modifies data and pages, instead of overwriting the master record database, we're going to instead make a copy of that data first, make a copy of that page on disk and in memory, and then write all our changes to there.
Nhưng khi T1 sửa đổi các thứ, sửa đổi dữ liệu và các trang, thay vì ghi đè lên cơ sở dữ liệu bản chính, trước tiên ta sẽ tạo một bản sao của dữ liệu đó, tạo một bản sao của trang đó trên đĩa và trong bộ nhớ, rồi ghi mọi thay đổi của chúng ta vào đó.
And then same thing as we update other pages, we're going to make more copies of them.
Và tương tự khi chúng ta cập nhật các trang khác, chúng ta sẽ tạo thêm các bản sao của chúng.
Now, any other transaction that comes along that's read-only, right, well, they're going to always go to the master pointer, which is going to take them to the master page table, so they'll see the master version of the database.
Bây giờ, bất kỳ transaction nào khác đến và chỉ đọc, đúng không, thì chúng sẽ luôn đi đến master pointer, master pointer sẽ đưa chúng đến master page table, nên chúng sẽ thấy phiên bản master của cơ sở dữ liệu.
They're not going to see any of the changes from the first transaction. All right. So LMDB does this. LMDB only allows one writer transaction and can have multiple reader transactions.
Chúng sẽ không thấy bất kỳ thay đổi nào từ transaction đầu tiên. Được rồi. LMDB làm như vậy. LMDB chỉ cho phép một transaction ghi và có thể có nhiều transaction đọc.
Because they're essentially hiding things this way. You don't have to, but it makes things a lot easier. All right. So then now T1 wants to commit.
Vì về cơ bản họ đang ẩn các thay đổi theo cách này. Bạn không bắt buộc phải làm vậy, nhưng nó giúp mọi thứ dễ hơn nhiều. Được rồi. Bây giờ T1 muốn commit.
So what we're going to do is that we're going to make sure that we update the master pointer to now point to the new page directory with all our shadow pages that we've installed.
Vậy điều chúng ta sẽ làm là bảo đảm rằng chúng ta cập nhật master pointer để giờ trỏ đến page directory mới chứa tất cả các shadow page mà chúng ta đã cài đặt.
And then once we know that's been flushed and saved out on disk, then now we're essentially flipping the pointer to point to the master page, the shadow, the old shadow page table becomes the new master page table.
Và khi biết rằng nó đã được flush và lưu xuống đĩa, thì về cơ bản chúng ta lật con trỏ để trỏ đến master page, shadow page table cũ trở thành master page table mới.
Any other transaction that comes along after we've done this switch over will now see the changes that T1 made.
Bất kỳ transaction nào khác đến sau khi chúng ta đã thực hiện việc chuyển đổi này sẽ thấy các thay đổi mà T1 đã thực hiện.
And if we crash and come back, we look in the master pointer on disk and we would know which page directory we should be looking at.
Và nếu hệ thống bị sập rồi khởi động lại, chúng ta xem master pointer trên đĩa và sẽ biết cần xem page directory nào.
So we won't lose any of the changes from this transaction once we said that it's committed. And then just like in multi-version, we have to do garbage collection.
Vì vậy chúng ta sẽ không mất bất kỳ thay đổi nào từ transaction này một khi đã nói rằng nó được commit. Và giống như trong multi-version, chúng ta phải thực hiện garbage collection.
So eventually at some point we've got to make sure we throw away the old page table and then clean up any of the invalidated older version pages.
Vậy đến một lúc nào đó, chúng ta phải bảo đảm vứt bỏ page table cũ rồi dọn dẹp các trang phiên bản cũ đã bị vô hiệu.
Right. And then we can just reuse them for future transactions.
Đúng không. Và sau đó chúng ta có thể tái sử dụng chúng cho các transaction trong tương lai.
Yes. Question is, does this only allow one writer? In my example here, yes. It doesn't have to.
Vâng. Câu hỏi là liệu cách này chỉ cho phép một transaction ghi? Trong ví dụ của tôi ở đây thì đúng vậy. Nhưng không nhất thiết phải vậy.
It's just now you got to do the thing he was, he was asking about, like, all right, well, when do I switch my master pointer over?
Chỉ là giờ bạn phải làm điều mà bạn ấy vừa hỏi, kiểu như, được rồi, khi nào thì tôi chuyển master pointer sang?
Because I don't want to switch it over with a transaction that hasn't committed yet. So now I got to wait for all the transactions to say, "Up, we're going to commit."
Vì tôi không muốn chuyển nó sang cùng với một transaction chưa commit. Vậy giờ tôi phải đợi tất cả các transaction nói rằng: "Này, chúng tôi sắp commit."
Then I can do a group commit that way. If you allow multiple writers. If you only allow one writer transaction, then you don't have to do that.
Rồi tôi có thể thực hiện group commit theo cách đó. Nếu bạn cho phép nhiều transaction ghi. Nếu chỉ cho phép một transaction ghi, thì bạn không phải làm vậy.
You have to wait. Yes. Yes. So, so you can, you can get around this a little bit.
Bạn phải đợi. Vâng. Vâng. Vì vậy bạn có thể phần nào lách được điều này.
Like, if you do page level locks, then your transaction is updating some pages, my transaction is updating other pages, I can't read your writes, that's fine.
Chẳng hạn, nếu bạn dùng khóa mức trang, thì transaction của bạn đang cập nhật một số trang, transaction của tôi cập nhật các trang khác, tôi không đọc được các thay đổi của bạn, không sao.
I go ahead and commit, I update the master pointer to now point to the new master page table, but I make sure it doesn't include any of your changes, and I immediately establish a new shadow page table with all your in-flight changes.
Tôi cứ commit, tôi cập nhật master pointer để giờ trỏ đến master page table mới, nhưng tôi bảo đảm nó không chứa bất kỳ thay đổi nào của bạn, và tôi lập tức tạo một bảng trang bóng (shadow page table) mới chứa toàn bộ các thay đổi đang thực hiện của bạn.
You can do it, but it's more work.
Làm được, nhưng tốn nhiều công hơn.
And what LMDB does, I'm showing, like, an example here of, like, there's a single master pointer, but they, the data, they're doing index organized storage, so the index is actually the data itself.
Còn LMDB làm thế này, tôi đang trình bày một ví dụ ở đây, trong đó chỉ có một con trỏ master duy nhất, nhưng họ dùng lưu trữ tổ chức theo chỉ mục, nghĩa là bản thân chỉ mục chính là dữ liệu.
So in that case, you just change the root of the B+tree, you swap that to the new pointer, and then that gives you the switch between the master and the shadow.
Vậy trong trường hợp đó, bạn chỉ cần thay đổi gốc của B+tree, hoán đổi nó sang con trỏ mới, và thế là bạn chuyển được giữa bản master và bản shadow.
Say it again?
Bạn nói lại được không?
The question is, is this a naive way to do multi-versioning?
Câu hỏi là: đây có phải là cách đơn giản, ngây thơ để làm đa phiên bản không?
So I'll talk about this in a second, but, like, all these ideas, like, between multi-versioning concurrency control, there's logging stuff we're talking about, the shadow paging stuff we're talking about here, you're talking about log-structured merge trees, all these things kind of are very similar to each other, but oftentimes they're treated as separate concepts because the way you sort of abstract the concerns of the system.
Lát nữa tôi sẽ nói về điều này, nhưng tất cả những ý tưởng này, từ điều khiển đồng thời đa phiên bản, đến phần ghi log mà chúng ta đang nói, phần shadow paging mà chúng ta đang nói ở đây, hay các log-structured merge tree, tất cả đều khá giống nhau, nhưng thường được coi là các khái niệm riêng biệt vì cách ta trừu tượng hóa các mối quan tâm của hệ thống.
So there's a lot of redundancy in this, right?
Nên có rất nhiều sự dư thừa ở đây, đúng không?
We'll talk about Postgres in a second.
Lát nữa chúng ta sẽ nói về Postgres.
Postgres didn't have a write-ahead log because they assumed, "I would make a copy of the tuple and I'd write that out, and that was the log," but the performance reasons, right?
Postgres đã không có write-ahead log vì họ cho rằng, "Tôi sẽ tạo một bản sao của tuple và ghi nó ra, và đó chính là log", nhưng vì lý do hiệu năng, đúng không?
Then down below that you have, like, your file system that's doing journaling too, that's maintaining its own log as well.
Rồi bên dưới đó là hệ thống tệp của bạn cũng đang làm journaling, cũng tự duy trì một log riêng.
And then go even lower than that, now you've got, on the actual SSD, it's doing logging down there too.
Và xuống thấp hơn nữa, trên chính ổ SSD cũng đang ghi log ở dưới đó.
So it's a lot of redundancy, but like, it's just, you know, unless you control the entire stack, which nobody actually can, it's all kind of unavoidable, except Oracle.
Vậy là có rất nhiều sự dư thừa, nhưng thôi, bạn biết đấy, trừ khi bạn kiểm soát toàn bộ ngăn xếp, mà thực tế không ai làm được, thì điều này khó tránh, trừ Oracle.
But even then, there's probably still running on a journaling file system, right? They're still going to do write-ahead logging, they're not a log-structured storage system, right?
Nhưng ngay cả khi đó, có lẽ họ vẫn chạy trên một hệ thống tệp có journaling, đúng không? Họ vẫn sẽ làm write-ahead logging, họ không phải là một hệ thống lưu trữ log-structured, đúng không?
So yes, atomicity?
Vậy, vâng, tính nguyên tử?
The question is, how does shadow paging ensure atomicity? All right, so going back here, transaction, transaction T1 wants to commit, okay?
Câu hỏi là: shadow paging đảm bảo tính nguyên tử như thế nào? Được rồi, quay lại đây, giao dịch T1 muốn commit, được chứ?
So it modified three pages, so we need to make sure those three pages are getting installed and everyone can see them at, you know, at the moment we say this thing's been committed, okay?
Nó đã sửa ba trang, nên ta cần đảm bảo ba trang đó được cài đặt và mọi người đều thấy chúng vào đúng thời điểm ta tuyên bố giao dịch này đã commit, được chứ?
So I can't, I can't guarantee that I can do flushing to those three pages out on disk atomically, all right?
Tôi không thể đảm bảo rằng việc ghi ba trang đó xuống đĩa diễn ra một cách nguyên tử, đúng không?
So I need to, I need some way to guarantee through one write, atomic write on disk, that these things have been installed. So that's what the master pointer does.
Nên tôi cần một cách để đảm bảo, chỉ qua một lần ghi nguyên tử trên đĩa, rằng những thứ này đã được cài đặt. Và đó chính là việc con trỏ master làm.
That's a single page, say the header, header of the file. I can guarantee I can write that atomically.
Đó là một trang duy nhất, chẳng hạn phần header, header của tệp. Tôi có thể đảm bảo ghi được trang đó một cách nguyên tử.
So once, now I install all the changes, uh, for this transaction, those, those three pages in blue, then now to switch it over I need to do an atomic write to the master pointer record.
Vậy nên, giờ tôi cài đặt tất cả các thay đổi, của giao dịch này, tức ba trang màu xanh đó, thì để chuyển sang phiên bản mới, tôi cần thực hiện một lần ghi nguyên tử vào bản ghi master pointer.
Once that's been installed, then I know now that anybody comes along and reads the master pointer is going to see the shadow page table and would see my three changes.
Một khi điều đó đã được cài đặt, thì tôi biết rằng bất kỳ ai đến đọc master pointer cũng sẽ thấy shadow page table và thấy ba thay đổi của tôi.
So this guarantees that no matter how many pages I modify That they all get installed atomically and the single parent swap, everyone sees them.
Như vậy điều này đảm bảo rằng dù tôi sửa bao nhiêu trang đi nữa thì tất cả chúng đều được cài đặt một cách nguyên tử và nhờ một lần hoán đổi con trỏ cha duy nhất, mọi người đều thấy chúng.
Okay, so supporting rollbacks is super easy. As I said, if your transaction's in flight and I crash, come back, I ignore what was ever in the shadow pages, right?
Được rồi, vậy nên việc hỗ trợ rollback rất dễ. Như tôi đã nói, nếu giao dịch đang chạy mà hệ thống sập, rồi khởi động lại, tôi bỏ qua mọi thứ từng có trong các shadow page, đúng không?
And if a transaction aborts while running, same thing: I throw away the shadow pages for the in-flight transaction that got aborted and then don't update the pointer, so no one's going to see any of the changes anyway, right?
Và nếu một giao dịch bị hủy (abort) khi đang chạy, cũng tương tự: tôi vứt bỏ các shadow page của giao dịch đang chạy đã bị hủy đó và không cập nhật con trỏ, nên dù sao cũng không ai thấy bất kỳ thay đổi nào, đúng không?
So the problem with this is that copying that page table is expensive. Now, LMDB gets away from that, doesn't have this problem, because they're copying sort of paths through trees, through a B+tree, right?
Vấn đề của cách này là việc sao chép page table rất tốn kém. LMDB thì tránh được điều đó, không gặp vấn đề này, vì họ chỉ sao chép các đường đi trong cây, trong một B+tree, đúng không?
But if I have to copy the entire tree, or I have to copy the entire page table, then that's expensive. Especially for large databases, this becomes problematic.
Nhưng nếu tôi phải sao chép toàn bộ cây, hoặc phải sao chép toàn bộ page table thì sẽ rất tốn kém. Đặc biệt với các cơ sở dữ liệu lớn, điều này trở nên rắc rối.
The other challenge is that, going back here, now I have a bunch of empty space, empty pages in my database file.
Thách thức khác là, quay lại đây, giờ tôi có một loạt khoảng trống, các trang trống trong tệp cơ sở dữ liệu.
Now, I can maybe get around that by creating a new file every single time, so I don't worry about all these empty pages, but at some point I've got to be able to reclaim them.
Có lẽ tôi có thể né điều đó bằng cách tạo một tệp mới mỗi lần, để không phải lo về các trang trống này, nhưng đến một lúc nào đó tôi vẫn phải thu hồi chúng.
In the case of System R, the problem they had when they were running shadow paging is that, since sequential IO is so much faster than random IO, now I have a bunch of gaps in my tables that I've got to jump over and ignore, and that starts to look more like random IO, the more fragmentation I have.
Trong trường hợp System R, vấn đề họ gặp phải khi chạy shadow paging là, vì IO tuần tự nhanh hơn nhiều so với IO ngẫu nhiên, giờ các bảng của tôi có nhiều khoảng trống mà tôi phải nhảy qua và bỏ qua, và càng phân mảnh nhiều thì nó càng giống IO ngẫu nhiên.
So over time the database would get slower and slower and slower, and then you have to run expensive garbage collection and go clean all that up.
Vì vậy theo thời gian cơ sở dữ liệu sẽ chậm dần, chậm dần, rồi bạn phải chạy garbage collection tốn kém để dọn dẹp tất cả.
And again, in the 1970s the hardware was like super slow, you know, this became really problematic back then. Yes?
Và vào những năm 1970 phần cứng rất chậm, nên hồi đó điều này trở nên thực sự rắc rối. Vâng, bạn hỏi?
Yeah, so the question is, um, it's still, this still concerning SSDs going faster than SSDs. So we were looking at, uh, the Optane stuff from Intel, persistent memory.
Vâng, câu hỏi là, ừm, vẫn là, điều này vẫn liên quan đến việc SSD nhanh hơn SSD. Chúng tôi từng xem xét Optane của Intel, bộ nhớ bền vững (persistent memory).
So it was like DRAM but it was persistent, so that the speed of DRAM, but like you could ensure your writes actually were durable.
Nó giống như DRAM nhưng bền vững, nên có tốc độ của DRAM, mà bạn vẫn có thể đảm bảo các lần ghi thật sự được lưu bền.
And in that environment, the shadow copying or shadow paging, uh, if I remember correctly, still did not perform as well as, uh, as like write-ahead logging, because you have to do, uh, because you do copy-on-writes, the copies kill you at that point.
Và trong môi trường đó, shadow copying hay shadow paging, nếu tôi nhớ đúng, vẫn không hoạt động tốt bằng write-ahead logging, vì bạn phải làm, vì bạn thực hiện copy-on-write, nên các bản sao làm hiệu năng sụt giảm nặng ở thời điểm đó.
So if the disk is slower, the disk writes, that's what kills you. If it gets faster, now the mem copying you're doing in this world gets slower.
Vậy nếu đĩa chậm hơn thì chính việc ghi đĩa sẽ làm hiệu năng sụt giảm. Nếu đĩa nhanh hơn thì việc sao chép bộ nhớ mà ta làm trong cách này lại trở nên chậm hơn.
I don't think this is a few years ago. Optane is dead, of course.
Tôi không nghĩ đây là chuyện của vài năm trước. Tất nhiên là Optane đã chết rồi.
You can't buy the hardware, but, um, I still think our findings still hold today, but I have to go look again.
Bạn không thể mua được phần cứng đó nữa, nhưng, ừm, tôi vẫn nghĩ những kết quả của chúng tôi vẫn đúng đến ngày nay, nhưng tôi phải xem lại.
So question: if it was an SSD, do we care about hardware prefetching? What do you mean?
Câu hỏi là: nếu là SSD thì ta có quan tâm đến việc prefetching bằng phần cứng không? Ý bạn là sao?
Yeah, yeah, I want things to be as sequential as possible, uh, because that's, again, if I'm doing scans it's going to be faster.
Vâng, tôi muốn mọi thứ tuần tự nhất có thể, vì như đã nói, nếu tôi thực hiện scan thì sẽ nhanh hơn.
And so even the LMDB stuff, because it's a tree structure, things are more scattered, but if you're only doing point queries maybe not that big of a deal, but anything beyond that, having everything sequential still helps.
Và ngay cả với LMDB, vì nó là cấu trúc cây nên dữ liệu bị phân tán hơn, nhưng nếu chỉ thực hiện point query thì có lẽ không phải vấn đề lớn, còn với bất cứ thứ gì hơn thế, việc có mọi thứ tuần tự vẫn có ích.
And again, you say, oh, is it multi-versioning, isn't that going to have the same kind of fragmentation? Well, no.
Và bạn lại hỏi: thế còn đa phiên bản thì sao, chẳng phải nó cũng gây ra phân mảnh tương tự sao? Không hẳn.
If I do it the MySQL Oracle way, where I do newest to oldest and most queries only need the newest data, then the main table itself is going to have the data I want, and I'll have to go look at the Delta records.
Nếu tôi làm theo cách của MySQL và Oracle, tức là từ mới nhất đến cũ nhất, và hầu hết các truy vấn chỉ cần dữ liệu mới nhất, thì bản thân bảng chính sẽ chứa dữ liệu tôi cần, và tôi chỉ phải đi xem các bản ghi Delta khi cần.
Yes.
Vâng.
Yes, so the question is, going back here, uh, so so so so
Vâng, vậy câu hỏi là, quay lại chỗ này, ừm, vậy thì vậy thì vậy vậy
so so so so so so so so so so so so so so so so so so so so so so so so so.
vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì vậy thì.
Because again, this thing's running in satellites, it's running in planes, like this critical piece of infrastructure. You need to make sure that it runs forever.
Vì như đã nói, thứ này chạy trên vệ tinh, chạy trên máy bay, là một thành phần hạ tầng cực kỳ quan trọng. Bạn phải đảm bảo nó chạy mãi mãi.
So that's why you're very unlikely... Current version of SQLite is SQLite 3. You're very unlikely to see SQLite 4 any time soon.
Vì thế rất khó... Phiên bản hiện tại của SQLite là SQLite 3. Rất khó có chuyện bạn sẽ thấy SQLite 4 sớm.
So the way it would work is that there wouldn't be a sort of page table. There'd be this separate journal file.
Cách nó hoạt động là sẽ không có một dạng bảng trang (page table). Sẽ có một tệp nhật ký (journal) riêng.
What would happen is, any time I wanted to make a change to a page in memory from a transaction, by the way, SQLite was like LMDB, one writer, multiple readers.
Điều xảy ra là, mỗi khi tôi muốn thay đổi một trang trong bộ nhớ từ một giao dịch, nhân tiện, SQLite giống LMDB: một writer, nhiều reader.
So only one writer for that. We don't worry about concurrent updates from different transactions.
Nên chỉ có một writer. Ta không phải lo về các cập nhật đồng thời từ các giao dịch khác nhau.
So before I modify page 2 in memory, I'm going to make a copy of it and flush it out to disk in this special file called the journal file.
Vì vậy trước khi sửa trang 2 trong bộ nhớ, tôi sẽ tạo một bản sao của nó và ghi xuống đĩa trong một tệp đặc biệt gọi là tệp journal.
That was separate from the main database file. Then once that's been flushed, then I go ahead and make my change to page 2 in memory. Same thing, I want to modify page 3.
Tệp này tách biệt với tệp cơ sở dữ liệu chính. Sau khi việc ghi đó hoàn tất, tôi mới tiến hành thay đổi trang 2 trong bộ nhớ. Tương tự, tôi muốn sửa trang 3.
I make a copy of the page in the journal file, and I go ahead and then modify page 3.
Tôi tạo một bản sao của trang đó trong tệp journal, rồi mới tiến hành sửa trang 3.
Then when I want to say my transaction is committed, now I've got to make sure that all of these changes have been written out.
Sau đó, khi tôi muốn tuyên bố giao dịch đã được commit, thì bây giờ tôi phải đảm bảo rằng tất cả những thay đổi này đã được ghi ra.
So I start writing out page 2 to disk. Flush that, that's fine.
Vậy tôi bắt đầu ghi trang 2 xuống đĩa. Flush xong, không vấn đề gì.
But then as I start trying to write page 3 during this commit process, there's a system crash, and I lose all my contents in my buffer pool. Right?
Nhưng rồi khi tôi bắt đầu ghi trang 3 trong quá trình commit này, hệ thống bị sập, và tôi mất toàn bộ nội dung trong buffer pool. Đúng không?
So again, going back here, in order for me to say this transaction is committed, I've got to write page 2 and then write page 3.
Vậy nên, quay lại đây, để có thể nói giao dịch này đã được commit, tôi phải ghi trang 2 rồi ghi trang 3.
And once I know that's done, then I can tell the outside world you've committed.
Và khi biết việc đó đã xong, lúc đó tôi mới có thể báo cho bên ngoài biết là bạn đã commit.
But if I crash before then, then upon recovery when I come back, the first thing I'm going to go do is look in this journal file and figure out what was in there.
Nhưng nếu tôi sập trước đó, thì khi khôi phục và quay trở lại, việc đầu tiên tôi sẽ làm là xem trong tệp journal này và tìm ra trong đó có những gì.
Again, these are the copies of the data before I made any changes. So I'm going to go bring in page 2 and page 3 back into memory.
Một lần nữa, đây là các bản sao của dữ liệu trước khi tôi thực hiện bất kỳ thay đổi nào. Vậy tôi sẽ nạp trang 2 và trang 3 trở lại vào bộ nhớ.
And I know that this is to be the current version of these pages.
Và tôi biết đây là phiên bản hiện tại của các trang này.
Before I start running new transactions, in order to tell you I've completed the recovery process, I've got to make sure that whatever got from the journal file is what matches what's actually in the database file itself.
Trước khi bắt đầu chạy các giao dịch mới, để có thể báo rằng tôi đã hoàn tất quá trình khôi phục, tôi phải đảm bảo rằng bất cứ thứ gì lấy được từ tệp journal đều khớp với những gì thực sự có trong chính tệp cơ sở dữ liệu.
So I'll go ahead and take page 2 and make sure I just overwrite whatever's in the database file for page 2. And I'll do the same thing for page 3.
Vậy tôi sẽ lấy trang 2 và đảm bảo ghi đè lên bất cứ thứ gì đang có trong tệp cơ sở dữ liệu cho trang 2. Và tôi cũng làm như vậy với trang 3.
Since I don't know what's in there, I know I've got to just overwrite it and make sure that it's the version I expect.
Vì tôi không biết trong đó có gì, tôi biết mình cứ phải ghi đè và đảm bảo nó là phiên bản mà tôi mong đợi.
What do you mean, if it didn't commit? What didn't commit, sorry?
Ý bạn là sao, nếu nó không commit? Xin lỗi, cái gì không commit?
The question is, what if a transaction that modified page 3 doesn't commit? Well, that's the case here. So page 3 isn't written out in the disk.
Câu hỏi là: nếu một giao dịch đã sửa trang 3 mà không commit thì sao? Thì đó chính là trường hợp ở đây. Trang 3 chưa được ghi xuống đĩa.
I crash, come back. I don't care what is in this thing. The journal file says this is the page before the transaction started running.
Tôi sập, rồi quay lại. Tôi không quan tâm trong đó có gì. Tệp journal cho biết đây là trang trước khi giao dịch bắt đầu chạy.
So if I have things in my journal file that I know there's a transaction that didn't commit successfully, I need to go take whatever's in my journal file and make sure it goes back down into my database file.
Vậy nếu trong tệp journal có những thứ mà tôi biết là có một giao dịch đã không commit thành công, tôi cần lấy bất cứ thứ gì có trong tệp journal và đảm bảo nó được ghi ngược xuống tệp cơ sở dữ liệu.
No, no, no, so the journal file's before the change. So again, maybe it's hard to read. The boxes are blue. So maybe I change page 2. Maybe I change page 3.
Không, không, không, tệp journal là trạng thái trước khi thay đổi. Có thể khó đọc. Các ô màu xanh. Giả sử tôi sửa trang 2. Giả sử tôi sửa trang 3.
Blue boxes, only the blue box page 2 got written. That crashes. So then I bring up the white boxes for page 2 and 3. Yes.
Các ô xanh, chỉ ô xanh của trang 2 được ghi ra. Rồi sập. Vậy tôi lấy lên các ô trắng của trang 2 và 3. Vâng, mời bạn.
I should make that more clear. It looks good in the slides. It doesn't look good in the overhead. Or it's clear on the overhead. Not as clear on the overhead.
Tôi nên làm cho rõ hơn. Trên slide thì trông ổn. Trên máy chiếu vật thể thì không đẹp. Hoặc là rõ trên máy chiếu. Không rõ bằng trên máy chiếu.
So it's the opposite of the shadow paging, where the master page would tell me, here's things that, here are the, there's, in my shadow page table, I have changes from uncommitted transactions that I just ignore.
Vậy nó ngược lại với shadow paging, nơi master page sẽ cho tôi biết, đây là những thứ, đây là, trong shadow page table của tôi, tôi có những thay đổi từ các giao dịch chưa commit mà tôi cứ bỏ qua.
The journal file's like, here's the things you need to roll back and undo, because the transaction might have modified these pages, and then it didn't commit. You make sure those things get reversed.
Còn tệp journal thì như kiểu: đây là những thứ bạn cần rollback và hoàn tác, vì giao dịch có thể đã sửa các trang này, và sau đó nó không commit. Bạn đảm bảo những thứ đó được đảo ngược lại.
Steven is correct, yes. So after I replay the journal file, bring that back to memory, write them back out to disk, then I delete the journal file.
Steven nói đúng, vâng. Vậy sau khi tôi phát lại tệp journal, đưa chúng trở lại bộ nhớ, ghi chúng ra đĩa, rồi tôi xóa tệp journal.
And then I can start executing new transactions again. So we can give a demo next class.
Và sau đó tôi có thể bắt đầu thực thi các giao dịch mới trở lại. Vì vậy chúng ta có thể làm demo vào buổi học sau.
If you go read the debug log of any, pick your favorite data system, it'll say, when it first boots up, doing recovery.
Nếu các bạn đọc nhật ký debug của bất kỳ hệ quản trị dữ liệu nào, cứ chọn cái bạn thích nhất, khi vừa khởi động, nó sẽ báo là đang thực hiện khôi phục.
And it's looking in the log, looking at checkpoints, trying to figure out, it's got a journal file, it looks in that, trying to figure out what was going on at the time, the last time I was running, because it may not have been a clean shutdown.
Và nó xem trong log, xem các checkpoint, cố gắng xác định, nó có một tệp journal, nó xem trong đó, cố gắng xác định chuyện gì đã xảy ra vào thời điểm đó, lần chạy trước, vì có thể hệ thống đã không được tắt một cách sạch sẽ.
All right. So as we said before, shadow paging requires us to do a bunch of random IOs to potentially non-contiguous pages on disk.
Được rồi. Như đã nói trước đó, shadow paging buộc chúng ta thực hiện hàng loạt thao tác IO ngẫu nhiên tới các trang có thể không liên tục trên đĩa.
Even the SQLite method, right, those pages were right next to each other, there's two and three.
Ngay cả với phương pháp của SQLite, đúng không, các trang đó nằm ngay cạnh nhau, là trang hai và ba.
But they could have been all different parts of the file, and I'm doing a bunch of random IO to write them out.
Nhưng chúng cũng có thể nằm ở những phần hoàn toàn khác nhau của tệp, và tôi phải thực hiện hàng loạt IO ngẫu nhiên để ghi chúng ra.
And we said at the beginning of the semester, and we've repeated this many times, sequential IO is going to be faster than random IO, even on modern SSDs.
Và chúng ta đã nói từ đầu học kỳ, và đã lặp lại nhiều lần, rằng IO tuần tự sẽ nhanh hơn IO ngẫu nhiên, ngay cả trên các SSD hiện đại.
And therefore, we want to choose algorithms where we can maximize the amount of sequential IO that we're doing.
Do đó, chúng ta muốn chọn những thuật toán cho phép tối đa hóa lượng IO tuần tự mà chúng ta thực hiện.
And ideally, we want to be able to choose algorithms where we don't have to write entire pages out to disk, even if only a small portion of it, a small portion of that page, has been written out on the disk.
Và lý tưởng nhất, chúng ta muốn chọn những thuật toán mà không phải ghi cả trang ra đĩa, ngay cả khi chỉ có một phần nhỏ của trang đó bị thay đổi.
So CalciB is going to get rid of the random IO problem, because they're just going to append the shadow pages to the end of the file, and then truncate it later on, and do sort of compaction, like a log-structured merge tree.
Vậy CalciB sẽ loại bỏ vấn đề IO ngẫu nhiên, vì họ chỉ nối các shadow page vào cuối tệp, rồi cắt bớt chúng sau đó, và thực hiện một kiểu compaction, giống như log-structured merge tree.
But they're still going to have to copy the entire page out to disk, even if only a small portion of it has been written. So the solution to this would be the write-ahead log.
Nhưng họ vẫn phải sao chép toàn bộ trang ra đĩa, ngay cả khi chỉ có một phần nhỏ của nó bị ghi thay đổi. Vì vậy giải pháp cho vấn đề này là write-ahead log.
And as I said, this is pretty much every single database system that supports durable transactions and recovery is doing with this approach.
Và như tôi đã nói, hầu như mọi hệ quản trị cơ sở dữ liệu hỗ trợ giao dịch bền vững và khôi phục đều dùng cách tiếp cận này.
So the idea is that we're going to maintain a separate log file on disk, or non-volatile storage, that's separate from the database file, and that's going to contain all the changes that transactions make to the database while they're running.
Ý tưởng là chúng ta sẽ duy trì một tệp log riêng trên đĩa, hay bộ nhớ không bay hơi, tách biệt với tệp cơ sở dữ liệu, và nó sẽ chứa tất cả các thay đổi mà các giao dịch thực hiện lên cơ sở dữ liệu khi chúng đang chạy.
And we're going to assume that the log itself is going to have enough information for us to allow it to undo and redo any transaction that has come along and either committed or did not commit.
Và chúng ta sẽ giả định rằng bản thân log có đủ thông tin để cho phép chúng ta hoàn tác và làm lại bất kỳ giao dịch nào đã xuất hiện và hoặc đã commit hoặc chưa commit.
And the most important thing you've got to understand about the write-ahead log is this paragraph right here.
Và điều quan trọng nhất mà các bạn cần hiểu về write-ahead log là đoạn văn ngay đây.
And that is, the database system is not allowed to write out any page that's been modified by a transaction from the buffer pool, cannot write that out to disk before the log record that corresponds to those changes has been safely written out to disk.
Đó là, hệ quản trị cơ sở dữ liệu không được phép ghi ra bất kỳ trang nào đã bị một giao dịch sửa đổi từ buffer pool, không được ghi trang đó ra đĩa trước khi bản ghi log tương ứng với các thay đổi đó đã được ghi an toàn ra đĩa.
That's why it's called the write-ahead log, because you're writing ahead to the log before you write to the database system.
Đó là lý do nó được gọi là write-ahead log, vì bạn ghi trước vào log rồi mới ghi vào hệ quản trị cơ sở dữ liệu.
There is write-behind logging for the experimental hardware that he and I were talking about. And we did that, and you actually want to write to the database first before the log.
Có một kiểu gọi là write-behind logging dành cho phần cứng thử nghiệm mà anh ấy và tôi đã nói đến. Và chúng tôi đã làm như vậy, và ở đó bạn thực sự muốn ghi vào cơ sở dữ liệu trước rồi mới ghi log.
That's only in research land. Don't do that for real. It has to be before. And so with this, this is all it's going to do: steal and no-force.
Cái đó chỉ có trong giới nghiên cứu thôi. Đừng làm vậy trong thực tế. Log phải được ghi trước. Và như vậy, thứ nó sẽ làm chỉ là: steal và no-force.
So steal is going to allow us to write out uncommitted changes, or changes from uncommitted transactions, before the transaction is committed.
Steal cho phép chúng ta ghi ra các thay đổi chưa commit, hay các thay đổi của những giao dịch chưa commit, trước khi giao dịch được commit.
But again, we got to make sure we write the log records first before those pages get written to disk.
Nhưng một lần nữa, ta phải đảm bảo ghi các log record trước khi những trang đó được ghi xuống đĩa.
And then no-force says that we don't require the database system to flush out all the pages that transactions modify when the transaction is committed, but we got to write out the log records for that transaction first before we tell the outside world you've committed.
Còn no-force nghĩa là ta không yêu cầu hệ quản trị cơ sở dữ liệu phải flush toàn bộ các trang mà giao dịch đã sửa đổi khi giao dịch được commit, nhưng ta phải ghi các log record của giao dịch đó ra trước khi báo cho thế giới bên ngoài biết là bạn đã commit.
So that means that if a transaction modifies 1,000 pages, there'll be 1,000 log records, at least, for those changes. And all those 1,000 log records, we've got to write to disk.
Vậy nghĩa là nếu một giao dịch sửa đổi 1.000 trang, thì sẽ có ít nhất 1.000 log record cho các thay đổi đó. Và tất cả 1.000 log record đó, ta phải ghi xuống đĩa.
But we can do that sequentially with a fewer number of IOs versus doing random IOs for all those 1,000 pages, as we have to do in shadow paging and other techniques.
Nhưng ta có thể ghi tuần tự với số lượng IO ít hơn so với việc thực hiện IO ngẫu nhiên cho cả 1.000 trang đó, như ta phải làm trong shadow paging và các kỹ thuật khác.
The question is, are people doing shadow paging because no-steal and force is easier to implement? Yes. But you can do it quick and dirty pretty easily.
Câu hỏi là: có phải người ta dùng shadow paging vì no-steal và force dễ cài đặt hơn không? Đúng. Nhưng bạn có thể làm nhanh gọn khá dễ dàng.
Because if you write-ahead log, we'll see as you go along, it's a bit more complicated.
Vì nếu dùng write-ahead log, như ta sẽ thấy dần dần, nó phức tạp hơn một chút.
And then when you throw checkpoints in, that's hard, because now you've got to be able to handle, what if I crash and recover, and then during my recovery, I crash again?
Và khi thêm checkpoint vào thì nó khó, vì giờ bạn phải xử lý được tình huống: nếu tôi bị crash rồi phục hồi, và trong lúc phục hồi tôi lại crash lần nữa thì sao?
That's hard. Shadow paging doesn't have that problem.
Cái đó khó. Shadow paging không gặp vấn đề này.
So I'll go through this quickly. But for force and steal, if I do force, it's trivial to do.
Nên tôi sẽ lướt qua nhanh phần này. Nhưng với force và steal, nếu tôi dùng force thì làm rất đơn giản.
But I want to be able to do steal, because I want to be able to write out pages for transactions committed. So again, this is repeating what I said.
Nhưng tôi muốn có thể dùng steal, vì tôi muốn có thể ghi ra các trang cho những giao dịch đã commit. Vậy đây là nhắc lại điều tôi đã nói.
If you do force, on every update, you flush out a page before you go to disk. If I do no-steal, then I can't flush anything out Before a transaction is committed.
Nếu dùng force, mỗi lần cập nhật bạn phải flush một trang ra trước khi ghi xuống đĩa. Nếu tôi dùng no-steal, thì tôi không thể flush gì ra trước khi giao dịch được commit.
But it makes it trivial for us to do rollbacks on aborted transactions, because you just throw away everything in memory, and nothing's out on disk.
Nhưng nó giúp việc rollback các giao dịch bị hủy trở nên đơn giản, vì bạn chỉ cần bỏ hết mọi thứ trong bộ nhớ, và không có gì nằm trên đĩa.
If I'm doing no force, then in order for me to recover after a crash, I need to maintain log information to know that a transaction is committed, and make sure I can redo any of the changes so I don't lose them.
Nếu tôi dùng no-force, thì để phục hồi sau crash, tôi cần duy trì thông tin log để biết giao dịch nào đã commit, và đảm bảo có thể redo mọi thay đổi để không bị mất chúng.
And then if I'm doing steal as well, I can flush any dirty pages out to disk, even if the transaction is still running.
Và nếu tôi cũng dùng steal, tôi có thể flush bất kỳ trang dirty nào xuống đĩa, kể cả khi giao dịch vẫn đang chạy.
But I need to make sure I can undo those changes later on if I crash and come back. So let me walk through this, and then hopefully this will make more sense.
Nhưng tôi cần đảm bảo có thể undo các thay đổi đó sau này nếu bị crash rồi khởi động lại. Vậy hãy cùng đi qua phần này, và hy vọng sau đó sẽ dễ hiểu hơn.
So again, now we're going to have these log records we're going to maintain for transactions. But now we need a place to store them.
Vậy một lần nữa, giờ chúng ta sẽ có những bản ghi log này, được duy trì cho các giao dịch. Nhưng bây giờ chúng ta cần một nơi để lưu chúng.
So there'll be some area in memory that we're going to append the changes to, this memory buffer, as transactions make them.
Vì vậy sẽ có một vùng nào đó trong bộ nhớ mà chúng ta sẽ nối thêm các thay đổi vào, tức là bộ đệm bộ nhớ này, khi các giao dịch thực hiện thay đổi.
It says usually backed by a buffer pool. That's usually not the case. It's just memory.
Slide ghi là thường được hỗ trợ bởi một buffer pool. Thường thì không phải vậy. Nó chỉ là bộ nhớ.
And then again, all the log records for the transaction, for the pages they modified, have to be written to disk, non-volatile storage, before the page itself is allowed to be overwritten.
Và một lần nữa, tất cả các bản ghi log của giao dịch, cho những trang mà nó đã sửa đổi, phải được ghi xuống đĩa, tức bộ lưu trữ không bay hơi, trước khi chính trang đó được phép bị ghi đè.
So again, in your buffer pool replacement policy, or in the background writer, when you go through and start evicting pages and writing them out to disk, you've got to make sure the log records that dirtied those pages, those are written to disk.
Vậy nên, trong chính sách thay thế của buffer pool, hoặc trong tiến trình ghi nền (background writer), khi bạn duyệt qua và bắt đầu loại bỏ các trang rồi ghi chúng xuống đĩa, bạn phải đảm bảo các bản ghi log đã làm bẩn những trang đó đã được ghi xuống đĩa.
And we'll see how we're going to track that next class using log sequence numbers. You basically track a number that says, here's the log record that corresponded to this change.
Và chúng ta sẽ thấy cách theo dõi điều đó ở buổi sau bằng log sequence number. Về cơ bản bạn theo dõi một con số cho biết: đây là bản ghi log tương ứng với thay đổi này.
I know it's been written to disk. Therefore, I can evict this page.
Tôi biết nó đã được ghi xuống đĩa. Do đó, tôi có thể loại bỏ trang này.
And then we don't tell the outside world that our transaction is fully committed until all its log records have been written to non-volatile storage. Stable storage is the same thing.
Và chúng ta không báo cho thế giới bên ngoài rằng giao dịch đã commit hoàn toàn cho đến khi mọi bản ghi log của nó được ghi vào bộ lưu trữ không bay hơi. Stable storage cũng có nghĩa như vậy.
So the way this is going to work is that when a transaction starts, we're going to put a begin record into the log as representing its starting point.
Cách hoạt động là khi một giao dịch bắt đầu, chúng ta sẽ đưa một bản ghi begin vào log để biểu thị điểm bắt đầu của nó.
It's kind of not unnecessary for today's class, but next class we'll see it, because we need to know when a transaction showed up.
Nó không hẳn là cần thiết cho buổi học hôm nay, nhưng buổi sau chúng ta sẽ thấy nó, vì ta cần biết giao dịch xuất hiện khi nào.
When we do recovery, you figure out where the demarcation line is, the starting point of the transaction.
Khi thực hiện khôi phục, bạn xác định ranh giới nằm ở đâu, tức điểm bắt đầu của giao dịch.
Then any time that a transaction makes a change to an object, we're going to record a new log record that keeps track of its transaction ID, the object ID of what got modified, and the before value for undo, and the after value for redo.
Sau đó, mỗi khi một giao dịch thay đổi một đối tượng, chúng ta sẽ ghi một bản ghi log mới lưu lại ID giao dịch của nó, ID đối tượng của thứ bị sửa đổi, cùng giá trị trước để undo, và giá trị sau để redo.
If we're doing multi-version concurrency control the Postgres way, we don't actually need the undo value, because we're never overwriting things. We're always making a new copy of it.
Nếu dùng kiểm soát đồng thời đa phiên bản theo kiểu của Postgres, thì thực ra ta không cần giá trị undo, vì ta không bao giờ ghi đè lên dữ liệu. Ta luôn tạo một bản sao mới.
But to be super careful, we'll record both. Then when a transaction finishes and, say, it gets committed successfully, then we're going to append this commit record to the log.
Nhưng để thật cẩn thận, ta sẽ ghi cả hai. Rồi khi một giao dịch kết thúc và, giả sử, được commit thành công, thì chúng ta sẽ nối bản ghi commit này vào log.
And then we need to make sure that all the log records that come before this commit for that transaction get written out to disk before we come back with acknowledgments to say your transaction is successfully committed.
Và sau đó ta cần đảm bảo rằng tất cả các bản ghi log đứng trước commit này của giao dịch đó được ghi xuống đĩa trước khi ta phản hồi lại với xác nhận rằng giao dịch của bạn đã commit thành công.
Now, this means that we may be writing out log records from transactions that have not committed yet. But that's OK, because we haven't written the commit record yet for them.
Điều này có nghĩa là ta có thể đang ghi ra các bản ghi log của những giao dịch chưa commit. Nhưng không sao, vì ta chưa ghi bản ghi commit của chúng.
So again, when we crash and come back, we see a bunch of changes, a bunch of log records for changes, but then not the commit. We know we need to undo that transaction.
Vậy nên, khi hệ thống sập rồi khởi động lại, ta thấy một loạt thay đổi, một loạt bản ghi log cho các thay đổi, nhưng lại không có commit. Ta biết rằng cần hoàn tác (undo) giao dịch đó.
So it's OK for us to write out changes from transactions in our log records that have not committed yet.
Vì vậy, việc ghi các thay đổi của những giao dịch vào các bản ghi log là chấp nhận được dù những giao dịch đó chưa commit.
So when transaction T1 starts, there's a write on A. We append a log record that says our transaction has begun.
Vậy khi giao dịch T1 bắt đầu, có một thao tác ghi lên A. Ta thêm vào cuối một bản ghi log cho biết giao dịch đã bắt đầu.
And then now when we do a write, the first thing we've got to do is append a log record in the right-hand log buffer that corresponds to the change.
Rồi khi thực hiện thao tác ghi, việc đầu tiên ta phải làm là thêm vào một bản ghi log tương ứng với thay đổi đó vào log buffer bên phải.
So our transaction is T1. We're modifying object A. And then we have the before and after value. And then once that's written, appended to the log, everything's still in memory here, so that's fine.
Giao dịch của ta là T1. Ta đang sửa đối tượng A. Và ta có giá trị trước và giá trị sau. Sau khi nó được ghi, được thêm vào log, mọi thứ vẫn nằm trong bộ nhớ ở đây, nên không sao.
So that's fast. We append that log record. And then we go ahead and make our change to the actual data object itself.
Vậy là nhanh. Ta thêm bản ghi log đó. Rồi ta tiến hành thay đổi trên chính đối tượng dữ liệu thực tế.
Then we do another write on B, same thing, append the log record, then modify the page. Then when our transaction commits, we put a log record in to say T1 has committed.
Sau đó ta ghi tiếp lên B, cũng như vậy, thêm bản ghi log, rồi sửa trang. Khi giao dịch commit, ta thêm một bản ghi log để nói rằng T1 đã commit.
Then we do an fsync, flush that out to disk.
Sau đó ta gọi fsync, đẩy nó xuống đĩa.
And then once now the hardware comes back or the OS comes back with an acknowledgment saying that our change has been flushed to disk, then we can tell the outside world that our transaction has committed.
Và khi phần cứng phản hồi hoặc hệ điều hành phản hồi với xác nhận cho biết thay đổi của ta đã được đẩy xuống đĩa, thì ta mới có thể báo cho bên ngoài biết giao dịch đã commit.
Yes.
Vâng, mời bạn.
Question is, we never put the values in the buffer pool. Yes, that's the whole point. That's fine.
Câu hỏi là: ta chưa bao giờ đưa các giá trị vào buffer pool. Đúng, đó chính là mấu chốt. Như vậy là ổn.
Because everything I need if there's a crash, everything I need to be able to recover the database if there's a crash is in the log.
Vì mọi thứ tôi cần nếu có sự cố, mọi thứ tôi cần để khôi phục cơ sở dữ liệu khi có sự cố đều nằm trong log.
So again, if I get blasted by power outage or whatever, OS crashes or whatever, that's OK. Because everything I need to replay that transaction is up above in the right-hand log.
Nên nếu tôi bị mất điện đột ngột hay gì đó, hệ điều hành bị sập hay gì đó, cũng không sao. Vì mọi thứ tôi cần để chạy lại giao dịch đó đều ở trong log bên phải phía trên.
And I can bring that in memory upon recovery. Next class, we'll talk about how we handle that. And I can just replay the transaction changes.
Và tôi có thể nạp nó vào bộ nhớ khi khôi phục. Buổi sau, chúng ta sẽ nói về cách xử lý việc đó. Và tôi có thể chạy lại các thay đổi của giao dịch.
Of course now, if I have to flush the log for every single transaction in order to say it's committed, if the log flush on a fast SSD takes one to five milliseconds, then that's going to really become a bottleneck in my system.
Tất nhiên, nếu tôi phải flush log cho từng giao dịch một để có thể nói rằng nó đã commit, mà một lần flush log trên SSD nhanh mất từ một đến năm mili giây, thì đó sẽ thực sự trở thành nút thắt cổ chai của hệ thống.
Best case scenario, if a log flush takes one millisecond, then I can only run 1,000 transactions a second. And that's super slow.
Trường hợp tốt nhất, nếu một lần flush log mất một mili giây, thì tôi chỉ chạy được 1.000 giao dịch mỗi giây. Và như thế là rất chậm.
Some sites want to run 100,000 transactions a second or a million transactions a second.
Một số trang muốn chạy 100.000 giao dịch mỗi giây hoặc một triệu giao dịch mỗi giây.
So the way to get around that is through a simple optimization called group commit, where when a transaction wants to go ahead and commit, then it'll wait until a small timeout period.
Cách để khắc phục là một tối ưu hóa đơn giản gọi là group commit, trong đó khi một giao dịch muốn commit, nó sẽ chờ cho đến khi hết một khoảng thời gian chờ ngắn.
Think of every five milliseconds. The system will say, if I have any changes from a transaction that wants to commit after this timeout, I'm going to go ahead and write it all to disk.
Hãy nghĩ là cứ mỗi năm mili giây. Hệ thống sẽ nói: nếu tôi có bất kỳ thay đổi nào từ một giao dịch muốn commit sau khoảng chờ này, thì tôi sẽ ghi tất cả xuống đĩa.
I'm basically batching together a bunch of changes in my log buffer. And then those things can all get written out together.
Về cơ bản, em gom nhiều thay đổi lại với nhau trong log buffer. Rồi tất cả chúng có thể được ghi ra cùng một lúc.
So I'm not blocked waiting for one commit after another. Say it again?
Nên em không bị chặn để chờ hết lần commit này đến lần commit khác. Em nói lại được không?
When you say queries, what do you mean?
Khi em nói truy vấn thì ý em là gì?
The question is, can a transaction only commit in five millisecond intervals? Yes. That's pretty good. Yeah. Because I can commit, whatever, 10,000 transactions in that five milliseconds.
Câu hỏi là: một transaction chỉ có thể commit theo từng khoảng năm mili giây phải không? Đúng vậy. Như vậy là khá tốt rồi. Vâng. Vì trong năm mili giây đó tôi có thể commit, ví dụ, 10.000 transaction.
I would say the general rule of thumb in databases is that anything below 50 milliseconds is good enough. If you get into high-frequency trading, those guys do cocaine.
Quy tắc kinh nghiệm chung trong cơ sở dữ liệu là bất cứ thứ gì dưới 50 mili giây là đủ tốt. Còn nếu làm giao dịch tần suất cao thì mấy người đó như phê thuốc vậy.
They want to be under a millisecond. They want to be microsecond level. But most websites, 50 milliseconds is the upper bound of what you want to be for a transaction to commit time.
Họ muốn dưới một mili giây. Họ muốn ở mức micro giây. Nhưng với hầu hết các trang web, 50 mili giây là cận trên của thời gian commit một transaction mà bạn nên hướng tới.
And this comes from internet advertising auctions.
Và con số này xuất phát từ các cuộc đấu giá quảng cáo trên internet.
When you go visit a website, assuming you're not using uBlock Origin, then when you visit a website, the Google ads or whatever, the ad broker sends bid requests to a bunch of other advertising brokers.
Khi bạn truy cập một trang web, giả sử bạn không dùng uBlock Origin, thì khi bạn truy cập một trang web, quảng cáo Google hay gì đó, nhà môi giới quảng cáo gửi yêu cầu đặt giá đến một loạt nhà môi giới quảng cáo khác.
And they come back and say how much they want to pay to show you an ad or something. And the time of request for that is 50 milliseconds or less, maybe 40 milliseconds.
Và họ phản hồi lại, cho biết họ muốn trả bao nhiêu để hiển thị quảng cáo cho bạn. Và thời gian cho yêu cầu đó là 50 mili giây hoặc ít hơn, có thể là 40 mili giây.
So basically, you get a request. You need to do some kind of running transaction and come back with a response within 40 milliseconds. Say it again? Is there overhead? Yeah, there's network overhead.
Về cơ bản, bạn nhận một yêu cầu. Bạn cần chạy một transaction nào đó và trả lời trong vòng 40 mili giây. Em nói lại được không? Có chi phí phụ không? Có, có chi phí phụ của mạng.
Say that the deadline is you've got to be back in 50 milliseconds. So say you get a request. You have 40 milliseconds to figure out what you want to do and send back.
Giả sử thời hạn là bạn phải phản hồi trong 50 mili giây. Giả sử bạn nhận được một yêu cầu. Bạn có 40 mili giây để quyết định làm gì và gửi lại.
Or any time you update a website, you want to be back. 50 milliseconds is the general rule of thumb. So if I'm committing every five milliseconds, that's good enough.
Hoặc bất cứ khi nào bạn cập nhật một trang web, bạn muốn có phản hồi ngay. 50 mili giây là quy tắc kinh nghiệm chung. Vậy nếu tôi commit mỗi năm mili giây thì là đủ tốt.
That's pretty good.
Như vậy là khá tốt.
So again, the way it works like this is that now we're going to have two log buffers. So T1 starts, it begins a transaction. We put our entry in the first log buffer.
Vậy nên, cách nó hoạt động là bây giờ chúng ta sẽ có hai log buffer. T1 bắt đầu, nó mở một transaction. Chúng ta đặt mục của nó vào log buffer đầu tiên.
Does a write on A, ends up there. Again, I'm not showing updating the pages in the buffer pool. Assume we're doing that too. Then I do a write on B.
Ghi lên A, và nó nằm ở đó. Một lần nữa, tôi không minh họa việc cập nhật các trang trong buffer pool. Cứ cho là chúng ta cũng làm việc đó. Rồi tôi ghi lên B.
Context switch over to T2. T2 does begin, does a write on C, does a write on D. Before we do the write on D, though, our buffer pool is full.
Chuyển ngữ cảnh sang T2. T2 bắt đầu, ghi lên C, ghi lên D. Tuy nhiên, trước khi ghi lên D, buffer pool của chúng ta đã đầy.
So now we can go ahead and asynchronously flush this out to disk. But in the meanwhile, now we just switch over now to using the second log buffer.
Vì vậy bây giờ chúng ta có thể flush nó ra đĩa một cách bất đồng bộ. Nhưng trong lúc đó, chúng ta chuyển sang dùng log buffer thứ hai.
So we write all our changes there. And then say now there's a stall, and we go ahead and do a bunch of commit.
Nên ta ghi mọi thay đổi vào đó. Rồi giả sử bây giờ có một khoảng dừng, và ta tiến hành một loạt commit.
And at this point here, the first transaction, T1, will wait until the timeout to do a group commit in the second log buffer.
Và tại thời điểm này, transaction đầu tiên, T1, sẽ chờ đến hết thời gian chờ để thực hiện group commit trong log buffer thứ hai.
And then when that happens, again, in milliseconds, then we write out the change from the second log buffer out to disk.
Và khi điều đó xảy ra, một lần nữa, trong vài mili giây, thì chúng ta ghi các thay đổi từ log buffer thứ hai xuống đĩa.
So basically, I'm showing two buffers here. You could have more than two. I could basically always be writing things out to disk.
Về cơ bản, ở đây tôi đang minh họa hai buffer. Bạn có thể có nhiều hơn hai. Về cơ bản tôi có thể luôn luôn ghi dữ liệu xuống đĩa.
And they're all sequential writes, because I'm just appending to this log file. I'm not doing random I/O. So this is pretty efficient and pretty fast to do.
Và tất cả đều là ghi tuần tự, vì tôi chỉ nối thêm vào tệp log này. Tôi không thực hiện I/O ngẫu nhiên. Nên cách này khá hiệu quả và khá nhanh.
Yes. Question: what do you do for HFT guys?
Vâng. Câu hỏi: còn với những người làm HFT thì sao?
They usually run in-memory databases, and then they can do, they replicate.
Họ thường chạy cơ sở dữ liệu trong bộ nhớ, và họ có thể sao chép, tức là replicate.
They usually don't fail. Yeah, they're also not running on machines you find behind the dumpster. They're running on high-end machines that are fault-tolerant. Then there's a whole other class of databases called super-fault-tolerant databases.
Họ thường không bị hỏng. Vâng, họ cũng không chạy trên những cái máy bạn nhặt được sau thùng rác đâu. Họ chạy trên các máy cao cấp có khả năng chịu lỗi. Rồi còn có một lớp cơ sở dữ liệu hoàn toàn khác gọi là cơ sở dữ liệu siêu chịu lỗi.
We're getting ahead of ourselves. But there's a system called NonStop SQL that basically, it's like NASA-level replication. So you run a transaction, and it runs in parallel on three machines.
Chúng ta đang đi trước quá xa rồi. Nhưng có một hệ thống tên là NonStop SQL, về cơ bản nó giống như kiểu sao chép cấp độ NASA. Bạn chạy một giao dịch, và nó chạy song song trên ba máy.
And they all come back and say, "Yes, we did the same thing." They do that kind of stuff. They build their own hardware.
Và tất cả đều trả về và nói: "Vâng, chúng tôi đã làm cùng một việc." Họ làm những việc như vậy. Họ tự chế tạo phần cứng.
They'll run fiber under the Hudson River to get an extra 5 millisecond lower latency from the data center to the trading headquarters. They're just minting money. They do whatever.
Họ sẽ kéo cáp quang dưới sông Hudson để có thêm 5 mili giây độ trễ thấp hơn từ trung tâm dữ liệu đến trụ sở giao dịch. Họ kiếm tiền như in. Họ muốn làm gì thì làm.
But the core idea is basically still the same. So again, as I said before, there's a lot.
Nhưng ý tưởng cốt lõi về cơ bản vẫn như vậy. Vậy nên, như tôi đã nói trước đó, có rất nhiều.
It seems like a lot of overlap, what I'm talking about here, for this write-ahead log versus the log-structured storage we talked about before, or append-only MVCC.
Có vẻ như có rất nhiều điểm chồng chéo, những gì tôi đang nói ở đây, giữa write-ahead log này với lưu trữ có cấu trúc log mà chúng ta đã nói trước đó, hoặc MVCC chỉ nối thêm.
And yes, there is a lot of duplicated ideas here. I will say, though, in the case of log-structured merge trees, they're still going to have a write-ahead log for the memtable.
Và đúng, ở đây có rất nhiều ý tưởng bị trùng lặp. Tuy nhiên, tôi sẽ nói rằng với log-structured merge tree, chúng vẫn có write-ahead log cho memtable.
The memtable is like that skip list or B+tree that's in memory that's absorbing all the writes. And then eventually it gets full.
Memtable giống như skip list hoặc B+tree nằm trong bộ nhớ, tiếp nhận tất cả các thao tác ghi. Rồi cuối cùng nó đầy.
And then you compact it into an SSTable and write that out to disk.
Và khi đó bạn nén gộp nó thành một SSTable rồi ghi xuống đĩa.
For that memtable piece, since that's not durable, it's in memory, they're going to maintain a write-ahead log for that as well.
Với phần memtable đó, vì nó không bền vững, nằm trong bộ nhớ, nên họ cũng sẽ duy trì một write-ahead log cho nó.
Then once you know that the memtable has been converted to an SSTable and written out to disk, you can then truncate the log.
Sau đó, một khi bạn biết rằng memtable đã được chuyển thành SSTable và ghi xuống đĩa, thì bạn có thể cắt bớt log.
So even though log-structured storage kind of looks the same, they're still going to maintain a separate log file as well, doing the same things we're talking about here.
Vì vậy, dù lưu trữ có cấu trúc log trông có vẻ giống nhau, chúng vẫn sẽ duy trì một tệp log riêng nữa, làm những việc giống như chúng ta đang nói ở đây.
All right, so now, again, if we go look at, again, no-steal versus steal and no-force versus force policies, you can break up the performance characteristics of these two approaches based on what happens when the system is running during normal operations and what happens during recovery.
Được rồi, bây giờ, một lần nữa, nếu chúng ta xem xét các chính sách no-steal so với steal và no-force so với force, bạn có thể chia các đặc điểm hiệu năng của hai cách tiếp cận này dựa trên những gì xảy ra khi hệ thống chạy trong hoạt động bình thường và những gì xảy ra trong quá trình khôi phục.
And part of the reason why most systems are going to do no-steal and force, and with the write-ahead log, is that it's going to be the fastest approach to use during normal operations.
Và một phần lý do tại sao hầu hết các hệ thống sẽ dùng no-steal và force, và với write-ahead log, là đây sẽ là cách nhanh nhất trong quá trình hoạt động bình thường.
If I assume my data set is not going to fail every five seconds, if it does, you have other problems.
Giả sử tập dữ liệu của tôi không bị lỗi cứ năm giây một lần, mà nếu có thì các bạn còn có những vấn đề khác.
Like, if my system is not going to fail all the time, then the write-ahead log approach is actually going to be faster. And so then you pay the penalty for slow recovery.
Tức là, nếu hệ thống của tôi không hỏng suốt, thì cách dùng write-ahead log thực ra sẽ nhanh hơn. Và khi đó bạn phải trả giá bằng việc khôi phục chậm.
But again, if I don't think I'm going to crash that often, or if I start replicating things the way that I was briefly mentioning there, then it's less of an issue, right?
Nhưng một lần nữa, nếu tôi không nghĩ là mình sẽ sập thường xuyên, hoặc nếu tôi bắt đầu nhân bản dữ liệu như tôi đã nhắc sơ qua lúc nãy, thì đó là vấn đề nhỏ hơn, đúng không?
The reason why the recovery would be faster with force and no-steal is that I don't have to do any undo or redo.
Lý do việc khôi phục sẽ nhanh hơn với force và no-steal là tôi không phải thực hiện undo hay redo nào cả.
Like in the shadow paging case, I just come back and I ignore whatever's in the shadow page table, and I'm good to go. My data's consistent.
Như trong trường hợp shadow paging, tôi chỉ cần quay lại và bỏ qua mọi thứ trong bảng shadow page, và thế là xong. Dữ liệu của tôi nhất quán.
All right, so in my example so far in PowerPoint, I've been showing like, oh, here's T1. I'm showing the log workers as, here's T1.
Được rồi, trong ví dụ trên PowerPoint từ đầu đến giờ, tôi đã minh họa kiểu như: đây là T1. Tôi biểu diễn các log worker như là: đây là T1.
I'm modifying object A, and then here's a before and after value. But in an actual system, we have to be more concrete and understand what we're actually going to store in our logs.
Tôi sửa đối tượng A, và đây là giá trị trước và sau. Nhưng trong một hệ thống thực tế, chúng ta phải cụ thể hơn và hiểu rõ mình thực sự sẽ lưu gì trong log.
And there's basically three approaches to do this.
Về cơ bản có ba cách tiếp cận.
One is what's called physical logging, where we're storing a byte-level diff of the changes we're making to a specific page at a specific offset in that page.
Một là cái gọi là physical logging, trong đó ta lưu một diff ở mức byte của những thay đổi ta thực hiện lên một trang cụ thể, tại một offset cụ thể trong trang đó.
Think of it like making a diff patch in Git or in Linux.
Hãy hình dung nó như tạo một diff patch trong Git hoặc trong Linux.
Another approach is to do logical logging, where I store the actual query that made the changes to the database, like the actual little SQL string itself.
Cách khác là logical logging, trong đó tôi lưu chính câu truy vấn đã gây ra các thay đổi lên cơ sở dữ liệu, tức là chính chuỗi SQL nhỏ đó.
And then that way, when I crash, I just come back and re-execute the SQL query.
Như vậy, khi sập, tôi chỉ cần quay lại và thực thi lại câu truy vấn SQL.
And then a hybrid approach is physiological, where I don't want to store the actual SQL query itself, but I maybe don't want to store byte level diffs.
Và cách lai là physiological, trong đó tôi không muốn lưu chính câu truy vấn SQL, nhưng cũng có thể không muốn lưu các diff ở mức byte.
I want to be able to just keep track of, here's the pages I modified. And then here's a high level change on what I modified in my page.
Tôi muốn theo dõi được: đây là những trang tôi đã sửa. Và đây là thay đổi ở mức cao về những gì tôi đã sửa trong trang.
So that upon recovery, I don't have to make sure the page is exactly the way it was before.
Để khi khôi phục, tôi không phải đảm bảo trang giống hệt như trước đó.
The datastore can decide to reorganize and move things around within that page itself, and things still work out the same, and I don't lose any data.
Kho dữ liệu có thể quyết định sắp xếp lại và di chuyển các thứ bên trong chính trang đó, mà mọi thứ vẫn ổn như nhau, và tôi không mất dữ liệu nào.
I'll say also, too, that what I'm not talking about so far is, we assume we're modifying tuples, but we have other data structures we need to make sure that are safe on disk as well.
Tôi cũng xin nói thêm rằng điều tôi chưa đề cập đến từ đầu đến giờ là, chúng ta giả định rằng mình đang sửa các tuple, nhưng còn các cấu trúc dữ liệu khác mà ta cũng cần đảm bảo được an toàn trên đĩa.
Indexes. Indexes are basically a second copy of data. So in addition to writing out log entries for the data pages themselves, I want to write out log entries for my indexes as well.
Index. Index về cơ bản là một bản sao thứ hai của dữ liệu. Vì vậy, ngoài việc ghi các log entry cho chính các trang dữ liệu, tôi cũng muốn ghi các log entry cho các index.
So upon recovery, I want to restore them. Because otherwise, if I have to rebuild the index, I've got to read the whole table all over again and repopulate it.
Để khi khôi phục, tôi muốn phục hồi chúng. Bởi vì nếu không, nếu tôi phải xây dựng lại index, thì tôi phải đọc lại toàn bộ bảng một lần nữa và điền lại dữ liệu cho nó.
And that's what the in-memory database guys do.
Và đó chính là điều mà các hệ thống cơ sở dữ liệu in-memory làm.
If you assume your primary storage database is in memory, like in the HFT world, they do this a lot, where you say, I'm not going to pay the penalty for writing log records for the indexes so that I can rebuild them more efficiently when I crash.
Nếu bạn giả định cơ sở dữ liệu lưu trữ chính của mình nằm trong bộ nhớ, như trong thế giới HFT, họ làm việc này rất nhiều, họ nói rằng, tôi sẽ không chịu cái giá của việc ghi các bản ghi log cho các chỉ mục chỉ để có thể dựng lại chúng hiệu quả hơn khi hệ thống gặp sự cố.
I'm just going to read the whole database anyway and bring it to memory. I'll rebuild the index when I bring it to memory. And then they end up doing less logging.
Dù sao tôi cũng sẽ đọc toàn bộ cơ sở dữ liệu và đưa nó vào bộ nhớ. Tôi sẽ dựng lại chỉ mục khi đưa dữ liệu vào bộ nhớ. Và nhờ vậy họ cuối cùng ghi log ít hơn.
So let's say, sample query: "UPDATE foo SET value = 'xyz' WHERE id = 1." Again, in physical logging, it's a low-level diff of what's actually in the bytes.
Vậy giả sử có truy vấn mẫu: "UPDATE foo SET value = 'xyz' WHERE id = 1." Một lần nữa, với physical logging, đó là một bản khác biệt (diff) mức thấp của những gì thực sự có trong các byte.
So I would say, in this page, at this offset, I want to write these values. And again, I still have that before and after value, because I want to know what was there before.
Nên tôi sẽ nói rằng, trong trang này, tại offset này, tôi muốn ghi các giá trị này. Và một lần nữa, tôi vẫn có giá trị trước và giá trị sau, vì tôi muốn biết trước đó ở đó có gì.
I want to know what I want to install in it. And I would have to do the same thing for the index. In logical logging, I just record the query.
Tôi cũng muốn biết mình muốn ghi giá trị nào vào đó. Và tôi sẽ phải làm điều tương tự cho chỉ mục. Với logical logging, tôi chỉ ghi lại câu truy vấn.
Just say, hey, there's transaction T1, and here's the update query that it ran.
Chỉ cần nói rằng, này, có giao dịch T1, và đây là câu truy vấn cập nhật mà nó đã chạy.
Of course, the challenge with this one is, in this case here, it's pretty simple. We're setting the value to xyz, setting to an exact value.
Tất nhiên, thách thức của cách này là, trong trường hợp này thì khá đơn giản. Ta đặt giá trị thành xyz, tức là đặt thành một giá trị cụ thể.
If I have things like a random function, time functions, I need to make sure that when I replay the log, that I get the same values for those function calls as I did when I first ran them.
Nếu có những thứ như hàm ngẫu nhiên, hàm thời gian, tôi cần đảm bảo rằng khi phát lại log, tôi nhận được cùng các giá trị cho những lời gọi hàm đó như lúc tôi chạy chúng lần đầu.
Because I don't want to run this update query, get today's date and time, then I crash and recover it, and replay the same query, and get tomorrow's date and time.
Vì tôi không muốn chạy câu truy vấn cập nhật này, lấy ngày giờ hôm nay, rồi hệ thống gặp sự cố, tôi khôi phục và phát lại cùng câu truy vấn đó, và lại lấy ra ngày giờ của ngày mai.
Because then my changes aren't durable, and that's bad. But obviously, if I update a billion tuples with my one update query, I only need to put one log record for that update.
Bởi khi đó các thay đổi của tôi không còn bền vững, và điều đó thật tệ. Nhưng rõ ràng, nếu tôi cập nhật một tỉ tuple chỉ với một câu truy vấn cập nhật, thì tôi chỉ cần ghi một bản ghi log cho lần cập nhật đó.
Whereas with physical logging, you've got to record a billion log records for them, assuming they're across a billion pages. And in physical logging, again, it may seem more nuanced.
Trong khi với physical logging, bạn phải ghi một tỉ bản ghi log cho chúng, giả sử chúng nằm trên một tỉ trang. Và với physical logging, một lần nữa, nó có thể có vẻ tinh tế hơn.
But again, basically, think about it as, yeah, I've got to show what page I'm updating.
Nhưng một lần nữa, về cơ bản hãy nghĩ nó như thế này, đúng, tôi phải chỉ ra mình đang cập nhật trang nào.
But now I'm just going to say what slot number I'm modifying, because that's corresponding to a logical tuple within the page. And then the slot can change.
Nhưng giờ tôi chỉ nói số slot nào mà tôi đang sửa, vì nó tương ứng với một tuple logic bên trong trang. Và slot đó có thể thay đổi.
Where the slot is pointing to in the page can change. And then upon recovery, I can move things around.
Vị trí mà slot trỏ tới trong trang có thể thay đổi. Và khi khôi phục, tôi có thể di chuyển các thứ xung quanh.
And I still have the freedom to reorganize things, but then still know how to apply the changes correctly. And then same thing for the indexes as well.
Tôi vẫn có quyền tự do tổ chức lại dữ liệu, mà vẫn biết cách áp dụng các thay đổi một cách chính xác. Và với các chỉ mục cũng tương tự như vậy.
So logical logging is nice, because you end up writing a lot less data for the changes you make to your database.
Vậy logical logging rất tốt, vì cuối cùng bạn ghi ít dữ liệu hơn rất nhiều cho những thay đổi bạn thực hiện lên cơ sở dữ liệu.
But the challenge is going to be, as I said, for timestamps and other non-deterministic functions, you make sure they are deterministic upon recovery.
Nhưng thách thức sẽ là, như tôi đã nói, đối với timestamp và các hàm không tất định khác, bạn phải đảm bảo chúng có tính tất định khi khôi phục.
And likewise, if I have transactions running at different isolation levels, I need to make sure I replay the log in the same ordering as I did when I actually executed them.
Và tương tự, nếu có các giao dịch chạy ở các mức cô lập khác nhau, thì tôi cần đảm bảo phát lại log theo cùng thứ tự như lúc tôi thực sự thực thi chúng.
I need to maintain more metadata about the actual true ordering of transactions when they actually executed, not the logical ordering, necessarily.
Tôi cần lưu thêm siêu dữ liệu về thứ tự thực sự của các giao dịch khi chúng thực sự được thực thi, chứ không nhất thiết là thứ tự logic.
The other thing about logical logging, too, is if the query you get logged took an hour to run, there's no magic wand that can make that query run faster upon recovery.
Một điều khác về logical logging là nếu câu truy vấn được ghi log mất một giờ để chạy, thì không có cây đũa thần nào giúp truy vấn đó chạy nhanh hơn khi khôi phục.
So if a query took an hour to run during normal operations, when I crash and come back, it's going to take an hour again to run that same query.
Vậy nếu một truy vấn mất một giờ để chạy trong lúc hoạt động bình thường, thì khi hệ thống sập rồi khởi động lại, chạy lại đúng truy vấn đó sẽ mất một giờ nữa.
So recovery could be potentially slow.
Vì vậy việc khôi phục có thể sẽ chậm.
So most systems do not do logical logging. Most systems are going to do physiological logging, yes.
Do đó hầu hết các hệ thống không dùng logical logging. Hầu hết các hệ thống sẽ dùng physiological logging, vâng.
The question is, do data systems allow you to choose what you want to do? Not for recovery as the regular mechanism for the system to do recovery. It'll show up when we do replication.
Câu hỏi là: các hệ quản trị dữ liệu có cho phép bạn chọn cách làm không? Không phải với khôi phục, tức cơ chế thông thường để hệ thống thực hiện khôi phục. Nó sẽ xuất hiện khi ta nói về sao chép dữ liệu (replication).
It's actually the next slide, right?
Thực ra đó là slide tiếp theo, đúng không?
If I want to apply changes that I make from one database to another database so that if this node crashes, I can just pick up where I left off on the other one, sometimes I can do logical logging, sometimes I can do physical logging.
Nếu tôi muốn áp dụng những thay đổi mà tôi thực hiện từ cơ sở dữ liệu này sang cơ sở dữ liệu khác, để nếu nút này sập, tôi có thể tiếp tục từ chỗ đã dừng trên nút kia, thì đôi khi tôi có thể dùng logical logging, đôi khi dùng physical logging.
In those, you can change what you want to do. In Postgres, at least. Other systems, less so.
Trong những trường hợp đó, bạn có thể thay đổi cách làm. Ít nhất là trong Postgres. Các hệ thống khác thì ít hơn.
So one of the cool things about the write-ahead log is that we can use it for other things other than recovery.
Một điều hay về write-ahead log là ta có thể dùng nó cho những việc khác ngoài khôi phục.
Basically, what I just said to them is that we can use it to propagate the changes on our database to other sources that wouldn't be aware of those changes.
Về cơ bản, điều tôi vừa nói với các bạn là ta có thể dùng nó để truyền những thay đổi trên cơ sở dữ liệu của mình sang các nguồn khác vốn không biết về những thay đổi đó.
So one example would be if I have two copies of Postgres, and all my writes go to this one, and I want to make sure that any changes on this one get propagated to the other one, I can just send them the log messages, the write-ahead log, to that second database system.
Một ví dụ là nếu tôi có hai bản sao của Postgres, và mọi thao tác ghi đều đi vào bản này, và tôi muốn đảm bảo mọi thay đổi trên bản này đều được truyền sang bản kia, thì tôi có thể gửi các thông điệp log, tức write-ahead log, sang hệ quản trị cơ sở dữ liệu thứ hai đó.
And they can pretend that it's in recovery mode and just replay the log as if it was recovering from a crash, but it's just replaying the log that's coming over the network.
Và nó có thể giả vờ rằng mình đang ở chế độ khôi phục và cứ phát lại log như thể đang khôi phục sau sự cố, nhưng thực ra nó chỉ phát lại log đến từ mạng.
And this shows up a lot of times in systems that are doing the ETL stuff that the DBT guys talked about, where I want to run analytical queries or transfer my data in a certain way so I can install it in the Snowflake or Databricks, whatever my data warehouse I want to use, and do a bunch of AI analytical stuff on that data.
Và điều này xuất hiện rất nhiều trong các hệ thống làm ETL mà các bạn của DBT đã nói tới, nơi tôi muốn chạy các truy vấn phân tích hoặc chuyển dữ liệu theo một cách nào đó để có thể nạp vào Snowflake hoặc Databricks, hay bất kỳ kho dữ liệu nào tôi muốn dùng, và làm hàng loạt phân tích AI trên dữ liệu đó.
The change data capture technique is basically one way to essentially do that. And so the most efficient way to do this is to do the write-ahead log replication.
Kỹ thuật change data capture về cơ bản là một cách để làm điều đó. Và cách hiệu quả nhất để làm việc này là sao chép write-ahead log.
As I'm writing out the write-ahead log to disk, I can also write it out to the network, and then some other node on the other side knows how to process that data and do something with it.
Khi tôi ghi write-ahead log xuống đĩa, tôi cũng có thể ghi nó ra mạng, rồi một nút nào đó ở phía bên kia biết cách xử lý dữ liệu đó và làm gì đó với nó.
So again, like this, I got my write-ahead log. I committed a transaction on this node here, and I can send it over to this other node here.
Vậy nên, như thế này, tôi có write-ahead log của mình. Tôi commit một giao dịch trên nút này ở đây, và tôi có thể gửi nó sang nút khác ở đây.
Now, we won't talk about how to make sure that these things are consistent. So if one guy crashes, how do we make sure that all our changes are made to the other one?
Bây giờ, chúng ta sẽ không nói về cách đảm bảo những thứ này nhất quán. Tức là nếu một nút bị sập, làm sao ta đảm bảo mọi thay đổi của mình đều được áp dụng sang nút kia?
That'll be starting next week. We'll talk about how we handle that.
Phần đó sẽ bắt đầu từ tuần sau. Chúng ta sẽ nói về cách xử lý vấn đề này.
But there's a bunch of tools that know how to interpret the contents of the write-ahead log because these things are well-documented, and then can extract them and do queries on top of them and transform them in different ways.
Nhưng có một loạt công cụ biết cách diễn giải nội dung của write-ahead log vì những thứ này được tài liệu hóa rất rõ, rồi trích xuất chúng và chạy truy vấn trên đó và biến đổi chúng theo nhiều cách khác nhau.
So the most expensive one of these is probably Oracle GoldenGate. And then there's this open source tool called Debezium.
Công cụ đắt nhất trong số này có lẽ là Oracle GoldenGate. Và còn có một công cụ mã nguồn mở tên là Debezium.
And you can connect this with streaming systems like Kafka, where you can take the output of a Postgres write-ahead log through Debezium, and then convert this into JSON files or JSON documents that you can then process on, crunch on them, and transform them, and then send them off to other systems for consumption.
Bạn có thể kết nối nó với các hệ thống streaming như Kafka, nơi bạn lấy đầu ra của write-ahead log của Postgres thông qua Debezium, rồi chuyển nó thành các tệp JSON hoặc tài liệu JSON mà sau đó bạn có thể xử lý, nghiền ngẫm và biến đổi chúng, rồi gửi chúng sang các hệ thống khác để sử dụng.
We'll talk a little bit more about this starting next week. But when we talk about replication, the basic idea is the write-ahead log doesn't have to be on disk.
Chúng ta sẽ nói thêm một chút về điều này từ tuần sau. Nhưng khi nói về replication, ý tưởng cơ bản là write-ahead log không nhất thiết phải nằm trên đĩa.
It could actually be a network stream to another system itself. And all the mechanisms we're talking about here today still work.
Thực ra nó có thể là một luồng mạng gửi tới một hệ thống khác. Và mọi cơ chế chúng ta nói hôm nay vẫn hoạt động.
So now, to finish up, the obvious problem with everything we've talked about so far with write-ahead logging, it is the preferred choice, is that it grows forever.
Vậy bây giờ, để kết thúc, vấn đề hiển nhiên của mọi thứ chúng ta đã nói cho đến giờ về write-ahead logging, vốn là lựa chọn ưu tiên, là nó phình ra mãi mãi.
My database system has been alive for a year. My write-ahead log will contain a year's worth of write-ahead log messages.
Hệ quản trị cơ sở dữ liệu của tôi đã chạy được một năm. Write-ahead log của tôi sẽ chứa các bản ghi log của cả một năm.
And so that's going to suck, if now I crash and come back, I don't have to replay an entire year's worth of log in order to recover the database.
Và như vậy thì tệ, vì nếu giờ tôi bị sập rồi khởi động lại, tôi không muốn phải phát lại log của cả một năm chỉ để khôi phục cơ sở dữ liệu.
Even if I'm doing physiological or physical logging, where reapplying the changes is very fast, not rerunning the queries as I would in logical logging, I still got to crunch through a year's worth of log messages.
Ngay cả khi tôi dùng physiological hoặc physical logging, nơi việc áp dụng lại các thay đổi rất nhanh, chứ không chạy lại các truy vấn như trong logical logging, tôi vẫn phải xử lý hết log của cả một năm.
And that's going to take a long time. So the way we're going to get around this problem is through checkpoints.
Và việc đó sẽ mất rất nhiều thời gian. Cách chúng ta giải quyết vấn đề này là dùng checkpoint.
The checkpoint is basically a mechanism where we say we're going to write out all the dirty pages that are in our buffer pool.
Checkpoint về cơ bản là một cơ chế trong đó chúng ta ghi ra toàn bộ các trang dirty trong buffer pool.
We're going to write them out to disk, record that as a checkpoint, or apply that, flush them out to disk.
Ta ghi chúng ra đĩa, ghi nhận đó là một checkpoint, hoặc áp dụng nó, flush chúng ra đĩa.
And then now we're going to record in our log message that we took a checkpoint at this point in time, so that when we crash and come back, or restart the system and need to examine the log, it bounds how far we have to look back.
Rồi sau đó ta ghi vào bản ghi log rằng ta đã tạo checkpoint tại thời điểm này, để khi hệ thống sập và quay lại, hoặc khởi động lại và cần xem xét log, nó giới hạn việc ta phải nhìn ngược lại bao xa.
Because we would know that there's not going to be changes from transactions that didn't make it out to disk. At the moment we take the checkpoint, those dirty pages have been flushed out.
Bởi vì ta sẽ biết rằng không có thay đổi nào từ các giao dịch mà chưa được ghi ra đĩa. Tại thời điểm ta tạo checkpoint, các trang dirty đó đã được flush ra đĩa.
So we don't have to look at the beginning of the log. We only have to look back just a little bit to some sort of safe point in time.
Vì vậy ta không phải xem từ đầu log. Ta chỉ cần nhìn ngược lại một chút đến một thời điểm an toàn nào đó.
So I'm going to first talk about how to do a naive scheme called blocking checkpoints. And then we'll see the problems of this.
Trước tiên tôi sẽ nói về một cách làm đơn giản, gọi là blocking checkpoint. Rồi chúng ta sẽ thấy các vấn đề của nó.
And then, again, as I said, next class we'll pick up with how to make this thing actually usable. This is basically what you don't want to do.
Và sau đó, như tôi đã nói, buổi sau ta sẽ tiếp tục với cách làm cho nó thực sự dùng được. Về cơ bản đây là thứ bạn không nên làm.
But it'll solve the problems that we want to have in not having to look at the entire log. But it's going to have other problems.
Nhưng nó sẽ giải quyết được vấn đề là không phải xem toàn bộ log. Nhưng nó sẽ có những vấn đề khác.
All right, so the blocking or consistent checkpoint protocol is pretty straightforward. You basically pause all queries from executing. All right, wherever they're at, you stop them.
Được rồi, giao thức checkpoint chặn hay nhất quán khá đơn giản. Về cơ bản bạn tạm dừng việc thực thi mọi truy vấn. Chúng đang ở đâu thì bạn dừng chúng ở đó.
You don't let any new transactions or any new queries start. And then now you're going to flush all the log records that are in your buffer log in memory.
Bạn không cho bắt đầu bất kỳ transaction hay truy vấn mới nào. Sau đó bạn flush tất cả các bản ghi log đang nằm trong log buffer trong bộ nhớ.
Write that out to disk first. Then you can take all the pages in your buffer pool that are dirty and flush those out to disk.
Ghi chúng ra đĩa trước. Rồi bạn lấy tất cả các trang trong buffer pool đang dirty và flush chúng ra đĩa.
Then you write a checkpoint entry to the log, flush that out to disk. And now unpause and resume all query execution.
Rồi bạn ghi một mục checkpoint vào log và flush nó ra đĩa. Và giờ bỏ tạm dừng và tiếp tục thực thi mọi truy vấn.
So let's see what it looks like. So say this is a write-ahead log. We're applying a bunch of changes. And then at some later point, we're going to crash.
Hãy xem nó trông thế nào. Giả sử đây là một write-ahead log. Ta đang áp dụng một loạt thay đổi. Rồi đến một thời điểm sau đó, hệ thống bị crash.
You see we have a checkpoint entry in here. So when we crash and come back, you basically replay the log going from the newest record to the oldest record.
Bạn thấy ở đây có một mục checkpoint. Vậy khi crash rồi khởi động lại, về cơ bản bạn phát lại log từ bản ghi mới nhất đến bản ghi cũ nhất.
So you sort of go back in time from the bottom to the top. So you start from the bottom, scan up until you find the checkpoint here.
Tức là bạn đi ngược thời gian từ dưới lên trên. Bạn bắt đầu từ dưới cùng, quét lên cho đến khi gặp checkpoint ở đây.
And now we know this is the starting point where we want to make sure we apply all the changes that come after this.
Và giờ ta biết đây là điểm bắt đầu mà ta muốn đảm bảo áp dụng mọi thay đổi đến sau nó.
Because anything up above, we know we made it out to disk, because those pages have been flushed.
Vì mọi thứ phía trên, ta biết đã được ghi ra đĩa, do các trang đó đã được flush.
So at this point here, we know that any transaction that committed before T1 can be just ignored. And we don't have to do anything, because we know their changes are safely on disk.
Vậy tại điểm này, ta biết bất kỳ transaction nào đã commit trước T1 đều có thể bỏ qua. Và ta không phải làm gì cả, vì biết các thay đổi của chúng đã nằm an toàn trên đĩa.
So in the case here, we can ignore T1. But here, we see that we have T2 and T3 exist. And we could scan up until we find them.
Vậy ở trường hợp này, ta có thể bỏ qua T1. Nhưng ở đây, ta thấy có T2 và T3. Và ta có thể quét lên cho đến khi tìm thấy chúng.
But again, if we see a commit, we scan up and find them. If we see a commit from them, we know we ignore them.
Nhưng, nếu ta thấy một commit, ta quét lên và tìm chúng. Nếu thấy commit của chúng, ta biết là bỏ qua chúng.
In the case here, T2, T3, they made some changes after our checkpoint. So we've got to make sure we undo those changes, because they didn't commit before we crashed.
Ở trường hợp này, T2 và T3 đã thực hiện một số thay đổi sau checkpoint. Vậy ta phải đảm bảo undo những thay đổi đó, vì chúng chưa commit trước khi ta bị crash.
So we need to redo T2, because T2 committed after our checkpoint. And we need to undo T3, because it didn't commit before we crashed.
Vậy ta cần redo T2, vì T2 đã commit sau checkpoint của ta. Và ta cần undo T3, vì nó chưa commit trước khi ta bị crash.
The question is, in my toy example here, do I need to scan the whole log?
Câu hỏi là, trong ví dụ đơn giản này, liệu em có phải quét toàn bộ log không?
Because there may be other transactions that made a bunch of changes at the beginning, and I didn't see any more things after my checkpoint.
Vì có thể có những giao dịch khác đã thực hiện một loạt thay đổi ở đầu log, và em không thấy thêm gì sau checkpoint của mình.
Yes. We'll fix that next class. Yes. All right. So they brought up a good point. But one is, again, There may be changes from transactions that have not committed yet that aren't doing anything.
Đúng vậy. Chúng ta sẽ khắc phục điều đó ở buổi sau. Vâng. Được rồi, bạn nêu một điểm rất hay. Nhưng một điều là, một lần nữa, có thể có những thay đổi từ các giao dịch chưa commit và hiện không làm gì cả.
So I still got to scan the log to find them. So next class, we'll see.
Nên tôi vẫn phải quét log để tìm chúng. Buổi sau chúng ta sẽ thấy.
We can store some metadata about how to keep track of what are the actions and transactions that are running, so that we know what we need to go find them.
Chúng ta có thể lưu một số metadata để theo dõi các hành động và các giao dịch đang chạy, để biết cần phải đi tìm những gì.
The other problem is that, in order to make sure we have a consistent snapshot of the database, we have to pause all the queries.
Vấn đề khác là, để đảm bảo có một snapshot nhất quán của cơ sở dữ liệu, chúng ta phải tạm dừng tất cả các truy vấn.
And again, depending on how big our buffer pool is and how dirty it is, we may have to write out a lot of pages. And that could take a long time.
Và một lần nữa, tùy vào buffer pool lớn cỡ nào và có bao nhiêu trang dirty, chúng ta có thể phải ghi ra rất nhiều trang. Và việc đó có thể mất rất lâu.
So now your queries are running, a checkpoint happens, and it blocks all your queries until you flush everything out to disk.
Vậy là các truy vấn của bạn đang chạy, một checkpoint xảy ra, và nó chặn mọi truy vấn cho đến khi bạn ghi hết xuống đĩa.
So if my buffer pool is, say, 100 terabytes, again, it's not outlandish on high-end systems, and all the pages in my buffer pool are dirty, worst-case scenario, I got to write out 100 terabytes before any query can start running again.
Nên nếu buffer pool của tôi là, giả sử, 100 terabyte, một lần nữa, điều này không quá xa vời trên các hệ thống cao cấp, và mọi trang trong buffer pool đều dirty, trường hợp xấu nhất, tôi phải ghi ra 100 terabyte trước khi bất kỳ truy vấn nào chạy lại được.
So that's problematic. To the point they said, well, I got to find all the committed transactions, which would take a long time.
Vậy nên điều đó là vấn đề. Về ý bạn nói, là tôi phải tìm tất cả các giao dịch đã commit, việc đó sẽ mất rất lâu.
And then the other challenge is, how often should we take these checkpoints? So we have to pause every so often. That's not good. I don't want to take checkpoints too often.
Và thách thức còn lại là, chúng ta nên tạo các checkpoint này thường xuyên đến mức nào? Vì chúng ta phải tạm dừng theo từng khoảng thời gian. Điều đó không tốt. Tôi không muốn tạo checkpoint quá thường xuyên.
But then now my recovery time is going to take longer because I have longer gaps between my checkpoints.
Nhưng khi đó thời gian khôi phục sẽ lâu hơn vì khoảng cách giữa các checkpoint dài hơn.
So if we spend all our time just flushing out dirty pages from the checkpoints, then that's going to slow down queries.
Nếu chúng ta dành toàn bộ thời gian chỉ để ghi các trang dirty ra từ các checkpoint, thì các truy vấn sẽ bị chậm lại.
But again, if we don't do that, then that takes the recovery, it's going to take longer. So there's no right answer. I can't tell you how often you should be taking checkpoints.
Nhưng ngược lại, nếu không làm vậy, thì việc khôi phục sẽ mất nhiều thời gian hơn. Vậy nên không có đáp án đúng duy nhất. Tôi không thể nói bạn nên tạo checkpoint thường xuyên đến đâu.
And if you do the better ones, the fuzzy ones, we'll see next class. It depends on the pain tolerance for whatever your application or whatever your company is.
Và nếu bạn dùng loại tốt hơn, loại fuzzy, chúng ta sẽ thấy ở buổi sau. Nó phụ thuộc vào mức chịu đựng khó khăn của ứng dụng của bạn hay của công ty của bạn.
So the HFT guys, they don't want things. They want to recover right away. So they'll take checkpoints every five minutes. But for other systems, that's probably more than you need.
Những người làm HFT thì không muốn chờ. Họ muốn khôi phục ngay lập tức. Nên họ sẽ tạo checkpoint mỗi năm phút. Nhưng với các hệ thống khác, như vậy có lẽ là quá mức cần thiết.
Now, it can be based on time or it can be based on, in a lot of systems, it's based on how much log records, how many log records, how much log record data you've generated.
Điều này có thể dựa trên thời gian, hoặc dựa trên, ở nhiều hệ thống, dựa trên số lượng bản ghi log, hay lượng dữ liệu bản ghi log mà bạn đã tạo ra.
So like, say, like MySQL, it might be like, if I write out 512 megabytes of log data, then I take a checkpoint. So that way, I'm not taking checkpoints at regular intervals.
Ví dụ như MySQL, có thể là nếu tôi ghi ra 512 megabyte dữ liệu log thì tôi tạo một checkpoint. Như vậy, tôi sẽ không tạo checkpoint theo các khoảng thời gian đều đặn.
I only do it when I write a bunch of stuff. So if my data system is idle or I'm running read-only queries, I'm not taking checkpoints unnecessarily.
Tôi chỉ làm khi đã ghi một lượng lớn dữ liệu. Nên nếu hệ thống dữ liệu của tôi đang rảnh hoặc đang chạy các truy vấn chỉ đọc, thì tôi sẽ không tạo checkpoint một cách không cần thiết.
So how to do this correctly, again, depends on what your tolerance is. But every single data system will expose different parameters for these things.
Còn làm thế nào cho đúng thì, một lần nữa, phụ thuộc vào mức độ chịu đựng của bạn. Nhưng mọi hệ thống dữ liệu đều cung cấp các tham số khác nhau cho những việc này.
So again, next class, we'll then talk about how we actually make this checkpoint thing for real and handle the case where we can find transactions that were running at the time we took the checkpoint and not have to block anybody while we do it.
Vậy nên, một lần nữa, ở buổi học sau, chúng ta sẽ nói về cách thực sự làm checkpoint này trong thực tế và xử lý trường hợp cần tìm các giao dịch đang chạy tại thời điểm chúng ta tạo checkpoint mà không phải chặn bất kỳ ai trong lúc thực hiện.
The question is, if I'm doing write-ahead logging, does that mean I should keep the entire write-ahead log since the inception of the database?
Câu hỏi là, nếu tôi dùng write-ahead logging, thì có nghĩa là tôi nên giữ toàn bộ write-ahead log kể từ khi cơ sở dữ liệu ra đời không?
No. Checkpoints will allow you not to have to do that, the correct checkpoints. There may be external factors that require you to do that.
Không. Checkpoint, nếu làm đúng, sẽ giúp bạn không phải làm vậy. Có thể có các yếu tố bên ngoài buộc bạn phải làm như vậy.
So if you're a financial firm, I got to keep things around for regulatory reasons, like for auditing, like Sarbanes-Oxley.
Chẳng hạn nếu bạn là một công ty tài chính, bạn phải lưu giữ dữ liệu vì các quy định pháp lý, như để kiểm toán, ví dụ Sarbanes-Oxley.
So you've got to keep the write-ahead log around for seven years, because I need to be able to say, what are all the changes that I made?
Khi đó bạn phải giữ write-ahead log trong bảy năm, vì tôi cần có thể nói được: tất cả các thay đổi mà tôi đã thực hiện là gì?
But in most systems, you don't need that. I think Postgres cleans them up. I think MySQL, the old versions didn't clean them up. I think the new versions clean up the log pretty efficiently.
Nhưng với hầu hết các hệ thống, bạn không cần như vậy. Tôi nghĩ Postgres sẽ dọn chúng đi. Tôi nghĩ MySQL các phiên bản cũ thì không dọn. Tôi nghĩ các phiên bản mới dọn log khá hiệu quả.
But in general, yeah, if you don't need it. If you take checkpoints enough, you don't need a bunch of them.
Nhưng nói chung, đúng vậy, nếu bạn không cần đến nó. Nếu bạn tạo checkpoint đủ thường xuyên, bạn không cần giữ nhiều như vậy.
And then when we talk about fuzzy checkpoints, even if I have last year's write-ahead log, I won't even have to go look at it. It's just there to give space.
Và khi nói về fuzzy checkpoint, dù tôi có write-ahead log của năm ngoái, tôi cũng không cần phải xem đến nó. Nó chỉ nằm đó để chiếm chỗ.
So again, main takeaway from all this is that write-ahead logging is going to be the superior choice in implementing your data system to ensure durable transactions.
Vậy, một lần nữa, điểm mấu chốt rút ra từ tất cả những điều này là write-ahead logging sẽ là lựa chọn vượt trội khi xây dựng hệ thống dữ liệu của bạn để đảm bảo các giao dịch bền vững.
And the core ideas of write-ahead log is the steal no-force policy, where steal means we can write out dirty pages before a transaction is committed.
Và ý tưởng cốt lõi của write-ahead log là chính sách steal no-force, trong đó steal nghĩa là chúng ta có thể ghi các trang bẩn ra trước khi giao dịch được commit.
And no-force means that we don't require all those dirty pages in memory to be written on disk.
Còn no-force nghĩa là chúng ta không yêu cầu tất cả các trang bẩn trong bộ nhớ phải được ghi xuống đĩa.
But we do require all the log records for that transaction to be written out on the disk.
Nhưng chúng ta yêu cầu tất cả các bản ghi log của giao dịch đó phải được ghi xuống đĩa.
Now, the dirty secret is every major data system is going to support what are called synchronous commits to make sure that I flush things to disk before I tell you you're committed.
Giờ thì, bí mật không mấy hay ho là mọi hệ thống dữ liệu lớn đều hỗ trợ cái gọi là commit đồng bộ để đảm bảo rằng tôi đã flush dữ liệu xuống đĩa trước khi báo cho bạn là đã commit.
It's not on by default in those systems. Like in Postgres and MySQL, I don't think it's on by default.
Trong các hệ thống đó, nó không được bật theo mặc định. Như Postgres và MySQL, tôi nghĩ nó không bật theo mặc định.
So even then, even though they're write-ahead logging, you know, you tell your transaction you're committed, there's still a five-millisecond window, depending on your group commit interval, where you could still crash and lose data.
Vì vậy, ngay cả khi chúng dùng write-ahead logging, bạn biết đấy, bạn báo cho giao dịch là đã commit, vẫn có một khoảng trống năm mili giây, tùy vào khoảng thời gian group commit của bạn, trong đó hệ thống vẫn có thể sập và mất dữ liệu.
So if you really care about performance, or sorry, if you really care about not losing data, you make sure that that thing's turned on.
Vậy nên nếu bạn thật sự quan tâm đến hiệu năng, à xin lỗi, nếu bạn thật sự quan tâm đến việc không để mất dữ liệu, thì bạn phải bảo đảm là tính năng đó đã được bật.
All right. So again, next class, we'll be taking better checkpoints. So we don't have to block the system. We don't have to scan the entire log, and it allows us to do more efficiently.
Được rồi. Vậy nên, buổi học tới chúng ta sẽ nói về cách tạo checkpoint tốt hơn. Để chúng ta không phải chặn hệ thống. Chúng ta không phải quét toàn bộ log, và nhờ vậy việc này được thực hiện hiệu quả hơn.
And then we'll show how we actually take our logs and take our checkpoints and do recovery for this. And the algorithm we're going to use is called ARIES.
Sau đó chúng ta sẽ xem cách lấy các log của mình và các checkpoint của mình để thực hiện khôi phục. Thuật toán mà chúng ta sẽ dùng có tên là ARIES.
This was invented by IBM, and the paper came out in 1992.
Nó do IBM phát minh, và bài báo được công bố năm 1992.
And although the techniques, like, Although what the textbook describes as ARIES and what the original ARIES paper talks about, most systems are not going to implement exactly as I'm describing here.
Và mặc dù các kỹ thuật, kiểu như, Mặc dù những gì sách giáo khoa mô tả là ARIES và những gì bài báo ARIES gốc nói đến, thì hầu hết các hệ thống sẽ không cài đặt đúng hoàn toàn như tôi mô tả ở đây.
But the high-level ideas of doing redo, or analyze, redo, and undo, is going to be very similar. OK? Question: did IBM invent shadow paging? Yes.
Nhưng những ý tưởng ở mức cao về việc thực hiện redo, hay analyze, redo và undo, sẽ rất giống nhau. Được chứ? Câu hỏi: IBM có phát minh ra shadow paging không? Có.
So if you hang around any of the old-school database guys at IBM, you tell them whatever your research is, they'll tell you they invented that in the 80s.
Nên nếu bạn tiếp xúc với bất kỳ người làm cơ sở dữ liệu kiểu cũ nào ở IBM, bạn nói với họ nghiên cứu của bạn là gì cũng được, họ sẽ bảo bạn là họ đã phát minh ra cái đó từ những năm 80.
So IBM always invented some shit before, right? But then a lot of it they didn't write about. At least in this, the paper for ARIES, it's amazing.
Nên IBM lúc nào cũng phát minh ra mấy thứ trước cả, đúng không? Nhưng rồi phần lớn trong số đó họ không viết ra. Ít nhất là bài báo về ARIES này thì thật tuyệt vời.
It's 70 pages, because it's hard. Because how do you make sure you don't lose data? This is the gold standard of how you make sure your databases recover after crashes using ARIES.
Nó dài 70 trang, vì vấn đề này khó. Vì làm sao bạn bảo đảm không bị mất dữ liệu? Đây là tiêu chuẩn vàng về cách bảo đảm cơ sở dữ liệu của bạn khôi phục được sau sự cố bằng ARIES.
But a lot of that shit, they didn't publish. OK? Hit it. Yeah.
Nhưng nhiều thứ trong đó họ đã không công bố. Được chứ? Nào. Vâng.
Yeah.
Vâng.
Yeah. Yeah.
Vâng. Vâng.
Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah. Yeah.
Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng. Vâng.
Yeah. Yeah. Yeah. Yeah. Yeah.
Vâng. Vâng. Vâng. Vâng. Vâng.
Đă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.