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ả.
Any questions about Project 3? All right.
Có câu hỏi nào về Project 3 không? Được rồi.
In terms of database talks, today after this class, we will have CMU DB alumni Ryan Johnson.
Về các buổi nói chuyện về cơ sở dữ liệu, hôm nay sau lớp này, chúng ta sẽ có cựu sinh viên CMU DB là Ryan Johnson.
He did his PhD here in, I think, 2010, and he won the Jim Gray Best Dissertation Award in Databases for SIGMOD. So he's now at Databricks working on Delta Lake.
Anh ấy lấy bằng tiến sĩ ở đây, tôi nhớ là năm 2010, và đã giành Giải Luận án xuất sắc nhất về Cơ sở dữ liệu Jim Gray của SIGMOD. Bây giờ anh ấy làm ở Databricks, phụ trách Delta Lake.
Delta Lake is going to smell a lot like the Hudi stuff and the Iceberg stuff and the Duck-like stuff, so it's sort of in that same space. It was Databricks' version of Iceberg.
Delta Lake sẽ khá giống với Hudi và Iceberg và các thứ kiểu Duck, nên nó nằm trong cùng mảng đó. Nó là phiên bản Iceberg của Databricks.
It didn't get quite the adoption that Iceberg had, so they paid a billion dollars for Iceberg, as one does if you're Databricks.
Nó không được áp dụng rộng rãi như Iceberg, nên họ đã trả một tỉ đô la để mua Iceberg, như những gì Databricks vẫn làm.
Tomorrow at noon in the Gates building, we're having somebody give a talk from Uber talking about the Apache Pinot project that they use internally, and sort of talk about the various things they tried throughout the years and why Pinot was the right choice for the problems that they're trying to solve.
Ngày mai vào buổi trưa tại tòa nhà Gates, sẽ có một người từ Uber đến nói chuyện về dự án Apache Pinot mà họ dùng nội bộ, và kể về nhiều thứ họ đã thử qua các năm cũng như vì sao Pinot là lựa chọn đúng cho những bài toán họ đang giải quyết.
And that one will be food, and that one's on Gates.
Buổi đó sẽ có đồ ăn, và nó diễn ra ở Gates.
And then a week from now, we're having the other database startup that Databricks bought this year, called Mooncake, and this is Iceberg using DuckDB to connect to Iceberg inside of Postgres.
Rồi một tuần nữa, chúng ta sẽ có công ty khởi nghiệp cơ sở dữ liệu còn lại mà Databricks đã mua trong năm nay, tên là Mooncake, và đây là Iceberg dùng DuckDB để kết nối với Iceberg bên trong Postgres.
Again, all these are optional. All right, so at this point in the semester, where we're at is that we've gone up the entire stack, right?
Một lần nữa, tất cả những buổi này đều không bắt buộc. Được rồi, tại thời điểm này của học kỳ, chúng ta đã đi hết toàn bộ ngăn xếp, đúng không?
We started off talking about how to read and write things at disk, and your buffer pool managers, talked about how to manage memory.
Chúng ta bắt đầu bằng việc nói về cách đọc và ghi dữ liệu trên đĩa, và các bộ quản lý buffer pool, rồi nói về cách quản lý bộ nhớ.
Above that, we talked about how to actually access tables that we're storing in our buffer pool that are based in our disk manager.
Phía trên đó, chúng ta nói về cách truy cập các bảng được lưu trong buffer pool mà dựa trên bộ quản lý đĩa của chúng ta.
Then we talked about how to build the query engine to actually execute queries.
Sau đó chúng ta nói về cách xây dựng query engine để thực thi truy vấn.
And then the last two lectures were about how do we take a SQL query from the application, convert that into an optimal plan that we can actually run and execute inside of our system, Right?
Và hai bài giảng gần nhất nói về cách lấy một truy vấn SQL từ ứng dụng, chuyển nó thành một kế hoạch tối ưu mà chúng ta có thể thực sự chạy và thực thi bên trong hệ thống, đúng không?
So at this point in the semester, you know how to build sort of a first pass, first implementation of an end-to-end database system, taking SQL queries all the way down to data on disk.
Vậy nên đến lúc này, các em đã biết cách xây dựng bản triển khai đầu tiên, ở mức sơ bộ, của một hệ cơ sở dữ liệu đầu cuối, đi từ truy vấn SQL xuống tận dữ liệu trên đĩa.
But obviously, we're not done yet, because we still have a few more weeks left in the semester, right?
Nhưng rõ ràng là chúng ta chưa xong, vì chúng ta vẫn còn vài tuần nữa trong học kỳ, đúng không?
What we've built so far is a nice database system, but it's not suitable for production because it's not safe, right?
Những gì chúng ta đã xây dựng cho đến giờ là một hệ cơ sở dữ liệu khá tốt, nhưng nó chưa phù hợp để đưa vào sản xuất vì nó chưa an toàn, đúng không?
We haven't talked about how do you, if you crash, how do you make sure you come back and you don't lose data?
Chúng ta chưa nói về việc nếu hệ thống bị sập thì làm sao đảm bảo khi khởi động lại không bị mất dữ liệu?
We haven't talked about if you have two queries trying to update the same thing at the same time, right? How do you make sure that's safe and reliable?
Chúng ta cũng chưa nói về trường hợp có hai truy vấn cùng cố cập nhật một thứ tại cùng một thời điểm, đúng không? Làm sao đảm bảo điều đó an toàn và đáng tin cậy?
So that's what we're going on at this point in the semester for the next three weeks. And we're going to talk about concurrency protocols and recovery management, right?
Đó chính là những gì chúng ta sẽ làm ở thời điểm này của học kỳ, trong ba tuần tới. Chúng ta sẽ nói về các giao thức điều khiển đồng thời và quản lý khôi phục, đúng không?
And the reason why we don't really show that in this sort of the stack hierarchy that I was showing before at the beginning of the semester is because these concepts and these components are going to overlap and be intertwined with all the parts of the system.
Còn lý do chúng ta không thực sự thể hiện chúng trong sơ đồ phân tầng ngăn xếp mà tôi đã trình bày lúc đầu học kỳ là vì những khái niệm này và các thành phần này sẽ chồng lấn lên nhau và đan xen với mọi phần của hệ thống.
So the buffer pool manager you build for project one had no notion of transactions, no notion of whether it's safe to write data out to disk, right?
Vì vậy, buffer pool manager mà các em xây dựng ở project một hoàn toàn không có khái niệm về giao dịch, không có khái niệm nào về việc liệu có an toàn để ghi dữ liệu xuống đĩa hay không, đúng không?
When your eviction policy algorithm ran, you just said, all right, this page is not dirty, I can throw it away, or this page is dirty, I'll write it out to disk.
Khi thuật toán chính sách loại bỏ trang của các em chạy, các em chỉ nói: được rồi, trang này không bị dirty, tôi có thể bỏ nó đi, hoặc trang này bị dirty, tôi sẽ ghi nó xuống đĩa.
But we'll see as we go along, there's actually another notion of safety we have to be aware of to know when it's actually safe to actually write that data.
Nhưng chúng ta sẽ thấy khi học tiếp, thực ra còn có một khái niệm an toàn khác mà chúng ta phải lưu ý để biết khi nào thì thực sự an toàn để ghi dữ liệu đó.
So if we end up crashing, we don't come back with an invalid database state. We don't come back with corrupted data, right?
Để nếu rốt cuộc hệ thống bị sập, khi khôi phục lại chúng ta không có trạng thái cơ sở dữ liệu không hợp lệ. Chúng ta không quay lại với dữ liệu bị hỏng, đúng không?
Again, what if a tuple touches two pages, Right, for a single update, and I only write one of them and not the other one?
Một lần nữa, nếu một tuple nằm trên hai trang, đúng không, cho một lần cập nhật duy nhất, và tôi chỉ ghi một trang mà không ghi trang còn lại thì sao?
How do I make sure that, you know, I don't come back and see a torn write? So that's where we're going next. And so we'll start off with concurrency control.
Làm sao để đảm bảo rằng khi quay lại, tôi không thấy một torn write? Đó là hướng chúng ta sẽ đi tiếp theo. Và chúng ta sẽ bắt đầu với điều khiển đồng thời.
That'll be today's class, all this week, and a little bit next week. And then next week, we'll pick up on... I should take it back.
Đó sẽ là buổi học hôm nay, cả tuần này, và một chút của tuần sau. Và sau đó tuần sau, chúng ta sẽ tiếp tục... Tôi xin rút lại.
Concurrency control is so important. It's the next two weeks. And then after that, we'll do a week of recovery management. How do you crash, make sure you come back, and everything's still there?
Điều khiển đồng thời rất quan trọng. Nó chiếm hai tuần tới. Và sau đó, chúng ta sẽ học một tuần về quản lý khôi phục. Làm thế nào để hệ thống sập, rồi khôi phục lại mà mọi thứ vẫn còn nguyên?
I'm just trying to emphasize it, like, again, these things we're going to start talking about next are all throughout the rest of the system.
Tôi chỉ muốn nhấn mạnh rằng, những thứ này, mà chúng ta sắp bắt đầu bàn tới, hiện diện xuyên suốt phần còn lại của hệ thống.
We're going to sort of go back and revisit some of the things that we've talked about already, and see how we then infuse the notion of transactions and correctness inside of them.
Chúng ta sẽ quay lại và xem xét lại một số điều mà chúng ta đã nói đến, và xem làm thế nào để đưa khái niệm giao dịch và tính đúng đắn vào bên trong chúng.
Okay? All right. So what are we talking about now, right?
Được chứ? Được rồi. Vậy bây giờ chúng ta đang nói về điều gì?
So we've sort of been talking about these SQL queries so far in this semester, and we've really sort of focusing on doing sort of not so much simple things, but the scope of the data that they're accessing or modifying is sort of limited to, like, one query.
Từ đầu học kỳ đến giờ, chúng ta đã nói về các truy vấn SQL, và chúng ta thực sự tập trung vào những việc không hẳn là đơn giản, nhưng phạm vi dữ liệu mà chúng truy cập hoặc sửa đổi chỉ giới hạn trong một truy vấn.
Like, yeah, I can do joins or subqueries in a single query, but really, when it comes time to, like, updating things and modifying things, we've been focusing on sort of really simple operations, like, one operation at a time.
Đúng, tôi có thể dùng join hoặc truy vấn con trong một truy vấn, nhưng thực sự khi đến lúc cập nhật và sửa đổi dữ liệu, chúng ta chỉ tập trung vào các thao tác rất đơn giản, mỗi lần một thao tác.
So now we need to expand our discussion and our vernacular to understand what it means to start doing more complex things inside of our database system.
Vì vậy bây giờ chúng ta cần mở rộng phần thảo luận và vốn từ của mình để hiểu việc bắt đầu làm những việc phức tạp hơn bên trong hệ thống cơ sở dữ liệu nghĩa là gì.
So here's a typical sort of application somebody might want to build for, like, a bank, right? Where I keep track of, like, how much money somebody has in their account.
Đây là một ứng dụng điển hình mà ai đó có thể muốn xây dựng cho một ngân hàng, đúng không? Nơi tôi theo dõi xem ai đó có bao nhiêu tiền trong tài khoản.
And so on the other side here, I'm showing this is the application code that someone would write to build a bank application against a database, right?
Và ở phía bên kia, tôi đang cho xem mã ứng dụng mà ai đó sẽ viết để xây dựng ứng dụng ngân hàng trên một cơ sở dữ liệu, đúng không?
Whether it's in Python, PHP, Java, Rust, it doesn't matter. Like, the high-level concepts are what we care about. So say I want to do a bank transfer, right?
Dù là bằng Python, PHP, Java hay Rust, điều đó không quan trọng. Các khái niệm ở mức cao mới là điều chúng ta quan tâm. Giả sử tôi muốn thực hiện một giao dịch chuyển khoản, đúng không?
And so I'm going to access object A, read object A. So that's somebody's bank account. And I'm first going to read how much money I have in that account.
Và tôi sẽ truy cập đối tượng A, đọc đối tượng A. Đó là tài khoản ngân hàng của ai đó. Đầu tiên tôi sẽ đọc xem trong tài khoản đó tôi có bao nhiêu tiền.
So the application will get back now the balance of $100. Then if I'm going to transfer $25, I've got to make sure that this account has sufficient funds to do that transfer.
Vậy ứng dụng sẽ nhận lại số dư là $100. Sau đó, nếu tôi muốn chuyển $25, tôi phải đảm bảo tài khoản này có đủ tiền để thực hiện khoản chuyển đó.
So I'll have a client-side check that says, you know, does this account have $25?
Vì vậy tôi sẽ có một bước kiểm tra phía client để xem tài khoản này có $25 không?
If yes, then I'll go ahead and do the payment to some other account, like, I think Venmo, Cash App, whatever, doesn't matter, right? I'm going to pay $25 to somebody, to some other account.
Nếu có, tôi sẽ tiến hành thanh toán sang một tài khoản khác, chẳng hạn như Venmo, Cash App, gì cũng được, không quan trọng. Tôi sẽ trả $25 cho ai đó, cho một tài khoản khác.
But then now I need to deduct $25 from account A, right? I need to take the $25 out, and then now I have this new balance of $75.
Nhưng giờ tôi cần trừ $25 khỏi tài khoản A, đúng không? Tôi cần lấy $25 ra, và bây giờ tôi có số dư mới là $75.
I want to write this back now to the database system to now reflect that I've transferred $25 out of this account and sent it to somebody else, right?
Giờ tôi muốn ghi giá trị này trở lại hệ quản trị cơ sở dữ liệu để phản ánh rằng tôi đã chuyển $25 ra khỏi tài khoản này và gửi cho người khác, đúng không?
Pretty straightforward. So the question we're going to try to deal with today is, what happens if the database system crashes before I update the balance?
Khá đơn giản. Vậy câu hỏi chúng ta sẽ giải quyết hôm nay là, điều gì xảy ra nếu hệ quản trị cơ sở dữ liệu bị sập trước khi tôi cập nhật số dư?
So I've sent the $25, put it in another account, and then now I crash. When I come back, what should be in the bank account, right?
Tôi đã gửi $25, đưa vào tài khoản khác, rồi bây giờ hệ thống sập. Khi quay lại, trong tài khoản ngân hàng nên có bao nhiêu tiền?
My account, and then also whoever I paid, how much should be in their account, right?
Tài khoản của tôi, và cả người mà tôi đã trả tiền nữa, trong tài khoản của họ nên có bao nhiêu tiền?
Another example is to say, run the same sort of application code again, but this time, for whatever reason, you and your best friend, your roommate, share bank accounts, and you both want to pay somebody $25 at the exact same time.
Một ví dụ khác là chạy lại cùng đoạn mã ứng dụng đó, nhưng lần này, vì lý do nào đó, bạn và người bạn thân, bạn cùng phòng của bạn, dùng chung tài khoản ngân hàng, và cả hai cùng muốn trả cho ai đó $25 vào đúng cùng một lúc.
So on the website, on the system, In the application side, you're going to run the exact same code, but it's going to run at exactly the same time.
Vậy trên trang web, trên hệ thống, ở phía ứng dụng, bạn sẽ chạy đúng cùng một đoạn mã, nhưng nó sẽ chạy vào đúng cùng một thời điểm.
So you're going to have sort of two threads or two instances of this application logic running at the same time, either on the same machine, different machine, it doesn't matter, right?
Như vậy sẽ có hai luồng hoặc hai thể hiện của logic ứng dụng này chạy cùng lúc, trên cùng một máy hay khác máy đều được, không quan trọng.
Because the database is keeping track of how much money is there. So they're going to do all the same steps. Go get the current balance. We have $100.
Vì cơ sở dữ liệu là nơi theo dõi có bao nhiêu tiền. Chúng sẽ thực hiện đúng các bước giống nhau. Lấy số dư hiện tại. Chúng ta có $100.
Check to see that at least we have $25 to send it. Yes, we do. Then go ahead and pay that $25.
Kiểm tra xem ít nhất có $25 để gửi không. Có. Rồi tiến hành trả $25 đó.
Now update the bank account with the new balance, $75, and then now try to write this new balance back to the data system.
Bây giờ cập nhật tài khoản ngân hàng với số dư mới, $75, rồi thử ghi số dư mới này trở lại hệ thống dữ liệu.
And obviously, this would be bad because if we allow this to happen, they're both trying to update with $75, but they both sent out $25, so the real account balance should be $50.
Và rõ ràng điều này sẽ tệ, vì nếu ta cho phép nó xảy ra, cả hai đều cố cập nhật thành $75, nhưng cả hai đều đã gửi đi $25, nên số dư thực tế phải là $50.
But if I let them overwrite each other, then I'm ending up with incorrect state of the database.
Nhưng nếu tôi để chúng ghi đè lên nhau, thì cuối cùng cơ sở dữ liệu sẽ rơi vào trạng thái sai.
This is talking about concurrent access. There are two main issues we care about.
Đây là vấn đề về truy cập đồng thời. Có hai vấn đề chính mà chúng ta quan tâm.
If we crash and come back, how do we make sure that the state of the database is what we expect to see?
Nếu hệ thống sập rồi khôi phục lại, làm sao đảm bảo trạng thái của cơ sở dữ liệu đúng như chúng ta mong đợi?
And then how do we handle two transactions, two or more transactions, trying to update the same thing at the same time?
Và làm sao xử lý hai hoặc nhiều giao dịch cùng cố cập nhật một thứ vào cùng một lúc?
So this is what we'll be focused on today when we talk about concurrency protocols. It's the mechanisms the database system is going to implement to prevent all these problems from occurring.
Đây là nội dung chúng ta sẽ tập trung hôm nay khi nói về các giao thức điều khiển đồng thời. Đó là các cơ chế mà hệ quản trị cơ sở dữ liệu sẽ triển khai để ngăn tất cả những vấn đề này xảy ra.
All right. So let's think of a really easy system we could use to solve this, right?
Được rồi. Hãy nghĩ đến một hệ thống thật đơn giản mà chúng ta có thể dùng để giải quyết chuyện này.
Say that we have in our database system, we only have one worker that can only execute one query or one transaction at a time. Let's say one transaction.
Giả sử trong hệ quản trị cơ sở dữ liệu của chúng ta, chúng ta chỉ có một worker, và nó chỉ có thể thực thi một truy vấn hoặc một giao dịch tại một thời điểm. Cứ cho là một giao dịch.
So that means that when the application sends requests, Even though there may be multiple requests, it's only going to execute one of them at a time. Think of a single queue.
Vậy nghĩa là khi ứng dụng gửi các yêu cầu đến, dù có thể có nhiều yêu cầu, hệ thống chỉ thực thi từng yêu cầu một. Hãy hình dung một hàng đợi duy nhất.
And then now, when a transaction begins to start updating the database, instead of overwriting existing data that we have in our pages, we're instead going to make a copy of those pages.
Và bây giờ, khi một giao dịch bắt đầu cập nhật cơ sở dữ liệu, thay vì ghi đè lên dữ liệu hiện có trong các trang của chúng ta, chúng ta sẽ tạo một bản sao của những trang đó.
Think of it again, slotted page architecture, making a copy of those pages. And then we're going to apply all our updates to those pages.
Hãy nhớ lại kiến trúc slotted page, tạo một bản sao của những trang đó. Rồi chúng ta áp dụng mọi cập nhật lên những trang này.
And then when it comes time to commit, we then just flip some internal mechanism, like the page directory, to say, here's the new version, the latest information about those two bits.
Và khi đến lúc commit, chúng ta chỉ cần lật một cơ chế nội bộ nào đó, như page directory, để nói rằng: đây là phiên bản mới, thông tin mới nhất về hai phần dữ liệu đó.
If the transaction fails or we crash, then when we come back and those pages, they were from the uncommitted transaction, we just ignore them and clean them up.
Nếu giao dịch thất bại hoặc hệ thống bị sập, thì khi khởi động lại và gặp những trang đó, vốn thuộc về giao dịch chưa được commit, chúng ta chỉ việc bỏ qua và dọn chúng đi.
So is this proposal correct? Will this guarantee that I don't have the two problems I had before, where if I crash halfway through the transaction, I end up with an invalid database state?
Vậy đề xuất này có đúng không? Liệu nó có đảm bảo rằng tôi không gặp hai vấn đề trước đó, tức là nếu hệ thống sập giữa chừng một giao dịch, tôi sẽ không rơi vào trạng thái cơ sở dữ liệu không hợp lệ?
And does this also prevent me from having two transactions, two more transactions, updating the same record at the same time? Guess what? Yes, it is correct. Is it safe?
Và nó có ngăn việc hai giao dịch, hay nhiều giao dịch, cập nhật cùng một bản ghi cùng lúc không? Đoán xem? Có, nó đúng. Nó có an toàn không?
A statement is, when a transaction commits, that's the happy part, and you're happy that you made your changes, and you go ahead and commit, you're saying there's a small window where you may not be able to flip over and say you successfully completed the transaction.
Có ý kiến cho rằng, khi một giao dịch commit, đó là phần vui vẻ, bạn vui vì đã thực hiện xong các thay đổi và tiến hành commit, thì vẫn có một khoảng thời gian nhỏ mà bạn có thể không lật sang được và báo rằng giao dịch đã hoàn tất thành công.
But let me say, when you're currently writing a disk, we made a copy of it, right? So we're updating the copy, not the original.
Nhưng để tôi nói thế này, khi bạn đang ghi xuống đĩa, chúng ta đã tạo một bản sao rồi, đúng không? Nên chúng ta cập nhật bản sao, không phải bản gốc.
The statement is, you have to save the copy in the back of the original. What if we instead just update a single page that says, here's the latest version of those pages?
Ý kiến đó là bạn phải lưu bản sao ở phía sau bản gốc. Vậy nếu thay vào đó, chúng ta chỉ cập nhật một trang duy nhất cho biết: đây là phiên bản mới nhất của những trang đó thì sao?
And we can do that atomically. OK, it works, meaning it's safe and correct. Who agrees with that it's safe? OK, who agrees that it's correct?
Và chúng ta có thể làm điều đó một cách nguyên tử. Được, nó hoạt động, nghĩa là an toàn và đúng. Ai đồng ý là nó an toàn? Được, ai đồng ý là nó đúng?
All right, for those who don't think it's safe or correct, do you think it's not safe or correct, or you just don't know? It's OK to not know.
Được rồi, với những bạn không nghĩ nó an toàn hoặc đúng, các bạn nghĩ nó không an toàn hay không đúng, hay chỉ là chưa biết? Không biết cũng không sao.
Who here says this is a terrible, sorry, who says this is not correct and/or not safe?
Ai ở đây nói rằng điều này thật tệ, xin lỗi, ai nói rằng điều này không đúng và/hoặc không an toàn?
OK, well, you're all correct, this is correct and safe. Do we think it's performant? No. Why?
Được rồi, các bạn đều đúng, cách này đúng và an toàn. Chúng ta có nghĩ nó hiệu năng tốt không? Không. Tại sao?
Well, yeah, in this case here, yes, we're copying the entire database. You could be a little more fine-grained and say, if I only update two pages, I only update those two pages, right?
Đúng rồi, trong trường hợp này, vâng, chúng ta đang sao chép toàn bộ cơ sở dữ liệu. Bạn có thể làm chi tiết hơn một chút, tức là nếu tôi chỉ cập nhật hai trang, thì tôi chỉ cập nhật hai trang đó thôi, đúng không?
You could do that. You say you don't have concurrency. Correct, yes.
Bạn có thể làm vậy. Bạn nói là không có tính đồng thời. Đúng, chính xác.
In this world, you can only allow one transaction to update the database at a time, because there's that little piece at the end where you flip and say, here's the new pages.
Trong thế giới này, bạn chỉ có thể cho phép một transaction cập nhật cơ sở dữ liệu tại một thời điểm, vì có một bước nhỏ ở cuối là bạn chuyển đổi và nói, đây là các trang mới.
That needs to be done atomically, and it can only allow one transaction to do that at a time. So yes, this technique here is called shadow paging, and we'll cover it in more detail.
Bước đó phải được thực hiện một cách nguyên tử, và chỉ cho phép một transaction làm việc đó tại một thời điểm. Vậy nên, kỹ thuật này được gọi là shadow paging, và chúng ta sẽ tìm hiểu chi tiết hơn.
This is basically what IBM did, or not basically, it is what IBM invented in the 1970s when they invented the early concept of transactions.
Về cơ bản đây là những gì IBM đã làm, mà không phải về cơ bản, chính IBM đã phát minh ra nó vào thập niên 1970 khi họ phát minh ra khái niệm ban đầu về transaction.
Like Jim Gray, the guy we talked about before, he won the Turing Award in the 90s for all of this transactional stuff that we'll talk about here.
Như Jim Gray, người mà chúng ta đã nhắc đến trước đó, ông ấy đã giành giải Turing vào thập niên 90 nhờ toàn bộ những thứ về transaction mà chúng ta sẽ nói ở đây.
This is what they did in the 70s. They abandoned it later on because of performance reasons, which we'll cover in more detail in the next two classes or so.
Đây là những gì họ đã làm vào thập niên 70. Sau này họ từ bỏ nó vì lý do hiệu năng, điều mà chúng ta sẽ tìm hiểu kỹ hơn trong khoảng hai buổi học tới.
But this would work. This is kind of what SQLite does too. If you switch on, they have a special mode to switch to shadow paging. They'll basically do this, right?
Nhưng cách này vẫn hoạt động được. SQLite cũng làm đại khái như vậy. Nếu bạn bật lên, họ có một chế độ đặc biệt để chuyển sang shadow paging. Về cơ bản họ sẽ làm như thế này, đúng không?
But as we said, like, if you only allow one transaction to run at the same time, then you're sort of not getting the full parallelism you want to have in your database system.
Nhưng như chúng ta đã nói, nếu bạn chỉ cho phép một transaction chạy tại một thời điểm, thì bạn không đạt được đầy đủ khả năng song song mà bạn muốn có trong hệ cơ sở dữ liệu của mình.
So what we really want to do, and what the next couple of lectures are trying to solve is, how do we allow for multiple transactions to run at the same time, simultaneously, and interact with the database, either reading or writing with it, at the same time?
Vậy điều chúng ta thực sự muốn làm, và cũng là điều mà vài bài giảng tới cố gắng giải quyết, là làm thế nào để cho phép nhiều transaction chạy cùng lúc, đồng thời, và tương tác với cơ sở dữ liệu, đọc hoặc ghi vào nó, tại cùng một thời điểm?
I mean, it's sort of obvious why we want to do this. We want to take advantage of all the additional parallelism we have in modern hardware, like more CPU cores.
Ý tôi là, lý do chúng ta muốn làm vậy khá hiển nhiên. Chúng ta muốn tận dụng toàn bộ khả năng song song bổ sung có trong phần cứng hiện đại, chẳng hạn nhiều lõi CPU hơn.
We'll eventually, we're talking about single node systems now, but we'll talk about distributed databases in a second. Same idea applies.
Cuối cùng thì, hiện giờ chúng ta đang nói về các hệ thống một nút, nhưng lát nữa chúng ta sẽ nói về cơ sở dữ liệu phân tán. Ý tưởng tương tự cũng áp dụng.
If I want to go across multiple nodes, that'll give me better parallelism, better scalability.
Nếu tôi muốn mở rộng ra nhiều nút, điều đó sẽ cho tôi khả năng song song và khả năng mở rộng tốt hơn.
And it'll appear to the end users that the data system is more responsive, because I'm not submitting a transaction and waiting maybe a second for whatever transaction that was queued up in front of me to finish.
Và với người dùng cuối, hệ thống dữ liệu sẽ có vẻ phản hồi nhanh hơn, vì tôi không phải gửi một transaction rồi chờ có thể một giây cho transaction nào đó đang xếp hàng trước tôi hoàn tất.
I may have to still do that in some cases, and I may end up aborting if I try to write something that somebody else has already wrote to.
Trong một số trường hợp tôi vẫn có thể phải làm vậy, và tôi có thể rốt cuộc phải hủy bỏ nếu cố ghi vào thứ gì đó mà người khác đã ghi vào rồi.
But we'll cover what that means in a second. But in general, this allows us to get better performance in our system, because we're taking more advantage of the hardware that's available to us.
Nhưng lát nữa chúng ta sẽ nói điều đó nghĩa là gì. Nhưng nhìn chung, điều này giúp hệ thống của chúng ta đạt hiệu năng tốt hơn, vì chúng ta tận dụng được nhiều hơn phần cứng sẵn có.
But as I was sort of saying before, it's great to be fast, but we also want to be correct.
Nhưng như tôi đã nói lúc nãy, nhanh thì tốt, nhưng chúng ta cũng muốn hệ thống chạy đúng.
And actually, in database systems, usually you want to care about correctness first, and then performance later.
Và thực ra, trong các hệ cơ sở dữ liệu, thường thì bạn nên quan tâm đến tính đúng đắn trước, rồi mới đến hiệu năng.
Because oftentimes it's very hard to build a fast system and then go try to make it correct later on.
Bởi vì thường rất khó để xây dựng một hệ thống nhanh rồi sau đó mới tìm cách làm cho nó đúng.
You're better off building a correct system first, and then figuring out how to optimize it without relaxing those correctness guarantees. And this is super hard.
Tốt hơn là bạn xây dựng một hệ thống đúng trước, rồi mới tìm cách tối ưu nó mà không làm yếu đi các đảm bảo về tính đúng đắn đó. Và việc này cực kỳ khó.
There was a bug found in Postgres' implementation of this like two or three years ago. Postgres has been around since the 80s, since before most of you guys were born.
Cách đây khoảng hai ba năm, người ta tìm thấy một lỗi trong phần cài đặt của Postgres cho việc này. Postgres đã có từ những năm 80, từ trước khi hầu hết các bạn ra đời.
And they're still finding errors in these protocols. It's super hard to do. Fairness, we'll talk about a little bit when we talk about two-phase locking next class.
Vậy mà họ vẫn đang tìm ra lỗi trong các giao thức này. Việc này cực kỳ khó. Về tính công bằng, chúng ta sẽ nói một chút khi bàn về khóa hai pha (two-phase locking) ở buổi sau.
But this is making sure that no one transaction or no one application is starved out indefinitely if you're trying to get access to the data.
Nhưng đây là việc đảm bảo rằng không có giao dịch nào hay ứng dụng nào bị bỏ đói vô thời hạn khi nó cố gắng truy cập dữ liệu.
Again, we'll cover that when we talk about how to break deadlocks next class. All right.
Một lần nữa, chúng ta sẽ nói đến việc đó khi bàn về cách phá bế tắc ở buổi sau. Được rồi.
So what we're trying to do here is we're trying to allow for an arbitrary interleaving of operations against the database. So read and write operations.
Vậy điều chúng ta đang cố làm ở đây là cho phép đan xen tùy ý các thao tác trên cơ sở dữ liệu. Tức là các thao tác đọc và ghi.
But during this process, while a transaction is running, there may be moments in time where the database is actually inconsistent. Means that the database is actually incorrect.
Nhưng trong quá trình này, khi một giao dịch đang chạy, có thể có những thời điểm cơ sở dữ liệu thực sự không nhất quán. Nghĩa là cơ sở dữ liệu thực sự đang sai.
Because you kind of have to apply some changes. But that's OK as long as those inconsistencies don't persist after a transaction commits or after a transaction is aborted because of restart.
Bởi vì bạn phải áp dụng một số thay đổi. Nhưng không sao, miễn là những sự không nhất quán đó không còn tồn tại sau khi giao dịch commit hoặc sau khi giao dịch bị hủy do khởi động lại.
Those things are bad. That's what we're trying to avoid.
Những thứ đó mới tệ. Đó là điều chúng ta muốn tránh.
But during transaction execution, like going back to my example here, when I took $25 out of this bank account, ignoring the running in parallel, and then before I sent $25 to somebody else, before I took out the $25 in my account, there's technically an extra $25 floating around in the system.
Nhưng trong lúc giao dịch thực thi, quay lại ví dụ của tôi ở đây, khi tôi rút $25 khỏi tài khoản ngân hàng này, bỏ qua việc chạy song song, và trước khi tôi chuyển $25 cho người khác, trước khi tôi trừ $25 trong tài khoản của mình, về mặt kỹ thuật có thêm $25 đang lơ lửng trong hệ thống.
We're talking nanoseconds here, potentially. But in that case here, technically it's incorrect, because there's $25 more than it actually should be.
Ở đây chúng ta nói đến cỡ nano giây thôi. Nhưng trong trường hợp đó, về mặt kỹ thuật là không đúng, vì có nhiều hơn $25 so với mức đáng ra phải có.
But that's OK, because we have to do that because we can't just magically apply changes atomically in one instruction at the level we're talking about here.
Nhưng không sao, vì chúng ta buộc phải làm vậy, do không thể áp dụng các thay đổi một cách nguyên tử trong một lệnh ở mức mà chúng ta đang nói đến.
So that's what I mean by the temporary stuff. It's OK. But we have to make sure we don't let things persist forever.
Đó là ý tôi về những thứ tạm thời. Không sao cả. Nhưng chúng ta phải đảm bảo không để chúng tồn tại mãi.
The other important thing to understand too when we're talking about transactions here is that we only care about, we being a database system, we only care about what's in our purview of control in our database system.
Một điều quan trọng khác cần hiểu khi nói về giao dịch ở đây là chúng ta chỉ quan tâm, chúng ta ở đây là hệ cơ sở dữ liệu, chúng ta chỉ quan tâm đến những gì nằm trong phạm vi kiểm soát của hệ cơ sở dữ liệu.
So what I mean by that is we can only handle the read and write operations on data that we manage, that we have control over.
Ý tôi là chúng ta chỉ xử lý được các thao tác đọc và ghi trên dữ liệu mà chúng ta quản lý, mà chúng ta kiểm soát.
If the application does other stuff, like send a confirmation email, or launch a missile in the middle of a transaction, and then our transaction aborts and needs to roll back, we can't roll back that email or roll back that missile.
Nếu ứng dụng làm những việc khác, như gửi email xác nhận, hoặc phóng một quả tên lửa ngay giữa một giao dịch, rồi giao dịch của chúng ta bị hủy và cần rollback, thì chúng ta không thể rollback email đó hay quả tên lửa đó.
Because the data system, not yet at least, doesn't control everything in the world.
Bởi vì hệ cơ sở dữ liệu, ít nhất là chưa, không kiểm soát mọi thứ trên thế giới.
So anything outside the scope of a transaction, the read and write operations we're talking about, the data that we manage, we can't revert those things.
Vì vậy bất cứ thứ gì nằm ngoài phạm vi của một giao dịch, tức là các thao tác đọc và ghi mà ta đang nói, dữ liệu mà ta quản lý, thì ta không thể hoàn tác được.
So there may be inconsistencies in the real world, but the data system doesn't know about it and doesn't care about it. OK?
Vì vậy có thể có những điểm không nhất quán trong thế giới thực, nhưng hệ cơ sở dữ liệu không biết và cũng không quan tâm đến điều đó. Được chứ?
All right, so in order to understand this, we've got to start defining what we mean by database and objects and what these transactions are actually doing.
Được rồi, để hiểu điều này, ta phải bắt đầu định nghĩa cơ sở dữ liệu nghĩa là gì và các đối tượng là gì, và các giao dịch này thực sự đang làm gì.
So for today's class, we're going to simplify the problem and not talk about tuples or pages or indexes or rows, anything like that.
Vậy trong buổi học hôm nay, ta sẽ đơn giản hóa bài toán và không nói về tuple, trang, chỉ mục hay hàng, bất cứ thứ gì như vậy.
We're only going to deal with abstract objects. We'll give them names A, B, C, D. It could be a tuple. It could be a table. It could be a database. It doesn't matter.
Ta chỉ làm việc với các đối tượng trừu tượng. Ta sẽ đặt tên chúng là A, B, C, D. Nó có thể là một tuple. Có thể là một bảng. Có thể là cả một cơ sở dữ liệu. Không quan trọng.
All the protocol stuff we're going to talk about here today and going forward will still work with this sort of abstract notation.
Tất cả các giao thức mà hôm nay ta sẽ nói và về sau vẫn sẽ hoạt động với kiểu ký hiệu trừu tượng này.
The other important thing to understand is that we're going to assume for this class, today's lecture, that the database is going to be fixed size, meaning all the objects that we care about, A, B, C, D, whatever, they're going to exist before a transaction starts and they're still going to exist after the transaction starts.
Một điều quan trọng khác cần hiểu là ta sẽ giả định, trong lớp này, trong bài giảng hôm nay, rằng cơ sở dữ liệu có kích thước cố định, nghĩa là tất cả các đối tượng ta quan tâm, A, B, C, D, hay gì đi nữa, đều tồn tại trước khi một giao dịch bắt đầu và vẫn tồn tại sau khi giao dịch bắt đầu.
We're not worried about inserts. We're not worried about deletes. Those complicate things, and we'll have to handle that next class. Today's class, we just assume that these objects are always there.
Ta không lo về insert. Ta không lo về delete. Chúng làm mọi thứ phức tạp hơn, và ta sẽ xử lý ở buổi sau. Hôm nay ta chỉ giả định các đối tượng này luôn có mặt.
We can update them. We can read them. But we can't delete or insert new ones. So now we're going to define transactions as a sequence of read and write operations on these database objects.
Ta có thể cập nhật, có thể đọc chúng. Nhưng không thể xóa hay chèn đối tượng mới. Bây giờ ta sẽ định nghĩa giao dịch là một chuỗi các thao tác đọc và ghi trên các đối tượng cơ sở dữ liệu này.
So I can read A or I can write A. And we'll define that when a transaction starts, when it invokes BEGIN. That's in the SQL syntax.
Tôi có thể đọc A hoặc ghi A. Và ta định nghĩa một giao dịch bắt đầu khi nó gọi BEGIN. Đó là cú pháp SQL.
I think sometimes some systems might support START, but BEGIN is usually what people use. And then we'll say that a transaction finishes either when they call COMMIT or ROLLBACK or ABORT.
Tôi nghĩ đôi khi một số hệ thống có thể hỗ trợ START, nhưng thường người ta dùng BEGIN. Và ta nói một giao dịch kết thúc khi nó gọi COMMIT hoặc ROLLBACK hoặc ABORT.
ROLLBACK and ABORT are the same thing. That I know you can do in SQL for either one.
ROLLBACK và ABORT là một. Tôi biết trong SQL bạn có thể dùng cái nào cũng được.
COMMIT means save all my changes, apply them to the database, and ROLLBACK says undo any writes that I've done and make it as if I didn't do anything.
COMMIT nghĩa là lưu mọi thay đổi của tôi, áp dụng chúng vào cơ sở dữ liệu, còn ROLLBACK nghĩa là hoàn tác mọi thao tác ghi mà tôi đã làm, như thể tôi chưa làm gì cả.
Okay? So the notion of correctness we're going to have for our transactions are going to be defined by the acronym ACID. Who here has heard ACID before? All right. Almost half. Perfect.
Được chứ? Vậy khái niệm về tính đúng đắn của các giao dịch sẽ được định nghĩa bằng từ viết tắt ACID. Ai ở đây đã nghe đến ACID rồi? Được rồi. Gần một nửa. Tốt.
So now we're going to go into more detail what each of these are. So ACID stands for Atomicity, Consistency, Isolation, and Durability.
Giờ ta sẽ đi vào chi tiết từng thành phần này. ACID là viết tắt của Atomicity, Consistency, Isolation và Durability.
And in full disclosure, Atomicity and Isolation and Durability, these will be easy for us to understand today. We're going to focus mostly on isolation. Consistency is kind of a weird one.
Và nói thẳng ra, Tính nguyên tử (Atomicity), Tính cô lập (Isolation) và Tính bền vững (Durability), những khái niệm này hôm nay sẽ khá dễ hiểu với chúng ta. Chúng ta sẽ tập trung chủ yếu vào tính cô lập. Tính nhất quán (Consistency) thì hơi kỳ lạ một chút.
It'll make more sense when we talk about distributed systems, but we'll cover it as we go along.
Nó sẽ dễ hiểu hơn khi chúng ta nói về các hệ thống phân tán, nhưng chúng ta sẽ đề cập đến nó dần dần.
So Atomicity just means that for a given transaction, all the operations that a transaction invokes or executes, either they're all going to occur or none of them are going to occur.
Vậy Atomicity chỉ có nghĩa là với một transaction nhất định, tất cả các thao tác mà transaction đó gọi hoặc thực thi, hoặc là tất cả đều xảy ra, hoặc là không thao tác nào xảy ra.
So I can't have any partial transactions. So you can think of it as, like, simplifying, it's all or nothing. Consistency means that it has to do with correctness.
Nên tôi không thể có transaction nào chỉ thực hiện một phần. Bạn có thể hiểu đơn giản là: được ăn cả, ngã về không. Consistency liên quan đến tính đúng đắn.
So if the database is currently consistent or correct, and my transaction only does consistent things, then when a transaction commits, my database is guaranteed to be consistent.
Nếu cơ sở dữ liệu hiện đang nhất quán, tức là đúng đắn, và transaction của tôi chỉ làm những việc nhất quán, thì khi transaction commit, cơ sở dữ liệu của tôi được đảm bảo là nhất quán.
That probably doesn't mean anything to you guys either, right? Again, when it's a single node system, it's kind of hard to discuss.
Chắc điều đó cũng chẳng có ý nghĩa gì với các bạn, đúng không? Một lần nữa, với hệ thống đơn nút thì khá khó để bàn luận.
But with distributed systems, another way to think about this is if I write to a data object A on this node here, and I go to commit, I can immediately reflect those changes on all other copies of the data on other nodes.
Nhưng với các hệ thống phân tán, một cách khác để hiểu là: nếu tôi ghi vào đối tượng dữ liệu A trên nút này, và tôi commit, thì tôi có thể phản ánh ngay lập tức các thay đổi đó lên tất cả các bản sao khác của dữ liệu trên các nút khác.
Immediately. They say it's physically impossible. No. Depends on who's tracking. Again, we'll cover that later.
Ngay lập tức. Người ta nói là bất khả thi về mặt vật lý. Không. Tùy vào việc ai theo dõi. Một lần nữa, chúng ta sẽ nói sau.
Isolation is the idea that a transaction is going to execute as if it has the complete access, or is the only transaction executing at that given time on the database system.
Isolation là ý tưởng rằng một transaction sẽ thực thi như thể nó có toàn quyền truy cập, hoặc là transaction duy nhất đang thực thi trên hệ quản trị cơ sở dữ liệu tại thời điểm đó.
Meaning, you can't see writes from other transactions at the same time, because you wouldn't see that if you were truly isolated.
Nghĩa là, bạn không thể thấy các thao tác ghi từ những transaction khác cùng lúc, vì bạn sẽ không thấy điều đó nếu thực sự được cô lập.
And the last one, durability, just means that if my transaction commits, then I'm guaranteed that my changes will survive no matter whether the machine catches on fire or the system crashes, the OS crashes.
Và cái cuối cùng, durability, nghĩa là nếu transaction của tôi commit, thì tôi được đảm bảo các thay đổi sẽ tồn tại bất kể máy bị cháy, hệ thống sập hay hệ điều hành sập.
Obviously, if the machine catches on fire and your disk melts, then potentially you don't get anything. But the way you handle that is through replication. Now you're talking about distributed systems.
Dĩ nhiên, nếu máy bị cháy và đĩa của bạn bị chảy ra, thì có thể bạn sẽ không còn gì cả. Nhưng cách xử lý chuyện đó là thông qua nhân bản (replication). Lúc này bạn đang nói đến các hệ thống phân tán.
And then, again, we'll cover that later. I'm trying to do baby steps into this to understand how we're actually going to do this on a single node.
Và một lần nữa, chúng ta sẽ nói về nó sau. Tôi đang cố đi từng bước nhỏ để hiểu chúng ta sẽ thực sự làm điều này như thế nào trên một nút đơn.
And then we'll expand it on a multi-node system. So again, atomicity, isolation, durability, they're pretty easy to understand.
Rồi sau đó chúng ta sẽ mở rộng sang hệ thống nhiều nút. Vậy nên, atomicity, isolation, durability khá dễ hiểu.
The German guy in the 1980s that coined this moniker, ACID, he kind of shoehorned consistency in there because he was trying to make it sound nice, like acid rather than aid.
Ông người Đức vào những năm 1980 đã đặt ra cái tên viết tắt ACID này, ông ấy kiểu như nhét consistency vào vì muốn nghe cho hay, giống như acid chứ không phải aid.
And then he was trying to make a joke against his wife.
Và rồi ông ấy muốn đùa về vợ mình.
The story goes, I've never met the guy, so I don't know, that his wife didn't like sugar and sweets, so he called her an ACID woman.
Chuyện kể rằng, tôi chưa gặp ông ấy nên không biết, vợ ông ấy không thích đường và đồ ngọt, nên ông gọi bà là người phụ nữ ACID (chua).
So that's why he had to get the C in there to make it all work.
Vì thế ông ấy phải đưa chữ C vào để mọi thứ khớp với nhau.
But again, we won't talk about much in today's class when we talk about the concurrency protocols, but it'll make more sense when we talk about distributed systems.
Nhưng một lần nữa, chúng ta sẽ không nói nhiều về nó trong buổi học hôm nay khi nói về các giao thức đồng thời, nhưng nó sẽ dễ hiểu hơn khi chúng ta nói về các hệ thống phân tán.
So today's class, we're going to go through each of these concepts one by one. I'm going to focus mostly on isolation because that's going to be the most important concept in all of this.
Vì vậy, trong buổi hôm nay, chúng ta sẽ đi qua từng khái niệm này một. Tôi sẽ tập trung chủ yếu vào tính cô lập vì đó sẽ là khái niệm quan trọng nhất trong tất cả những khái niệm này.
So for the case of atomicity transactions, as I said before, we don't want to allow partial transactions. So there's only two possible outcomes when an application starts a transaction in our database system.
Với trường hợp các giao dịch có tính nguyên tử, như tôi đã nói trước đó, chúng ta không muốn cho phép các giao dịch dở dang. Vì vậy chỉ có hai kết quả có thể xảy ra khi một ứng dụng bắt đầu một giao dịch trong hệ quản trị cơ sở dữ liệu của chúng ta.
It's either going to commit and have all of its changes apply to the database, or it's going to abort and roll it back and have all its changes reversed, as if it didn't even execute at all.
Hoặc là nó commit và toàn bộ thay đổi của nó được áp dụng vào cơ sở dữ liệu, hoặc là nó abort và rollback, và toàn bộ thay đổi của nó bị đảo ngược, như thể nó chưa từng được thực thi.
And one important concept that we'll focus more on in next class is this rollback process could either be initiated by the application itself. Like the application could say, "I don't like what I'm doing.
Và một khái niệm quan trọng mà chúng ta sẽ tập trung nhiều hơn ở buổi sau là quá trình rollback này có thể do chính ứng dụng khởi tạo. Chẳng hạn ứng dụng có thể nói: "Tôi không thích những gì mình đang làm.
Abort my transaction." Or the database system can say, "I don't like what you're doing. I'm going to make you stop and abort your transaction and roll you back."
Hãy abort giao dịch của tôi." Hoặc hệ quản trị cơ sở dữ liệu có thể nói: "Tôi không thích những gì bạn đang làm. Tôi sẽ bắt bạn dừng lại, abort giao dịch của bạn và rollback bạn."
And in your application code, which is, again, outside the database system, your application code has to be able to handle that.
Và trong mã ứng dụng của bạn, vốn nằm bên ngoài hệ quản trị cơ sở dữ liệu, mã ứng dụng của bạn phải có khả năng xử lý điều đó.
So if you start a transaction in your application, you have to catch the exception that you may get aborted. And it's up for you to decide whether you want to retry it or not.
Vì vậy, nếu bạn bắt đầu một giao dịch trong ứng dụng, bạn phải bắt ngoại lệ cho trường hợp bạn có thể bị abort. Và bạn tự quyết định có thử lại hay không.
But the question is, can a single query abort? Sure. Why not? Yeah. Let me think about whether that's true or not. Yeah. You could say, oh, now I'm getting in the weeds.
Nhưng câu hỏi là, một truy vấn đơn lẻ có thể bị abort không? Có chứ. Sao lại không? Vâng, mời em. Để tôi nghĩ xem điều đó có đúng không. Vâng. Bạn có thể nói, ồ, giờ tôi đang đi vào chi tiết vụn vặt.
So it depends on the concurrency control protocol. You could have it try to update something that another transaction tries to update at the same time. And then, therefore, you block and wait.
Điều đó phụ thuộc vào giao thức điều khiển đồng thời. Bạn có thể cho nó cố cập nhật một thứ mà một giao dịch khác cũng cố cập nhật cùng lúc. Và do đó bạn bị chặn và phải chờ.
And then you might time out and get aborted. We can do examples of that. And then it depends on the isolation level. We'll cover that next class.
Rồi có thể bị hết thời gian chờ và bị abort. Chúng ta có thể làm các ví dụ về điều đó. Và sau đó còn phụ thuộc vào mức cô lập. Chúng ta sẽ học ở buổi sau.
It gets complicated. But in general, yeah, it could. A single statement transaction is still a transaction.
Nó khá phức tạp. Nhưng nói chung, vâng, có thể. Một giao dịch chỉ gồm một câu lệnh vẫn là một giao dịch.
The statement is, implicitly, every query is a transaction. Yes. So when you open up Postgres today and you write a query, it's going to run.
Câu lệnh đó, ngầm định, mỗi truy vấn là một giao dịch. Vâng. Vì vậy, khi bạn mở Postgres hôm nay và viết một truy vấn, nó sẽ chạy.
Technically, it runs begin and commit around it, even though it runs that one query. Yes. It's called auto-commit. You can turn that off.
Về mặt kỹ thuật, nó chạy begin và commit bao quanh truy vấn đó, dù nó chỉ chạy một truy vấn. Vâng. Đó gọi là auto-commit. Bạn có thể tắt nó đi.
So you can do update, update, update, and you put that call in begin, and it creates a new transaction. But you just have to call commit or rollback at the end. I love transactions.
Vì vậy bạn có thể làm update, update, update, rồi đặt chúng trong begin, và nó tạo ra một giao dịch mới. Nhưng bạn phải gọi commit hoặc rollback ở cuối. Tôi yêu giao dịch.
They're super awesome. They're super hard. So I get excited. That's why I'm riffing on everything he's asking about, because we can give demos. It's all awesome. It's great.
Chúng cực kỳ tuyệt vời. Chúng cũng cực kỳ khó. Nên tôi rất hào hứng. Vì thế tôi cứ nói dông dài về mọi thứ bạn ấy hỏi, vì chúng ta có thể làm demo. Tất cả đều tuyệt vời. Thật tuyệt.
And it's really hard, too, even though it's an old topic. OK. So like I said, the data system guarantees to the application server that your transaction will be atomic.
Và nó cũng thực sự khó, dù là một chủ đề cũ. Được rồi. Vậy như tôi đã nói, hệ quản trị dữ liệu đảm bảo với máy chủ ứng dụng rằng giao dịch của bạn sẽ có tính nguyên tử.
So either everything's going to execute, or nothing's going to execute. So there's two high-level ways we're going to be able to provide this guarantee.
Vậy nên hoặc mọi thứ sẽ được thực thi, hoặc sẽ không có gì được thực thi cả. Có hai cách ở mức cao để chúng ta cung cấp sự đảm bảo này.
The first is going to be through logging, and this is the most common approach that most systems use.
Cách thứ nhất là thông qua ghi log, và đây là cách tiếp cận phổ biến nhất mà hầu hết các hệ thống sử dụng.
And it's challenging, because the term log has a bunch of different technical names or uses in data systems, right? You think of it like a debug log, just printing out printf statements.
Và nó khá khó hiểu, vì thuật ngữ log có rất nhiều tên gọi kỹ thuật hay cách dùng khác nhau trong các hệ thống dữ liệu, đúng không? Bạn có thể nghĩ nó như debug log, tức là chỉ in ra các câu lệnh printf.
We saw this before with a log-structured merge tree. It's kind of the same idea.
Chúng ta đã thấy điều này trước đây với log-structured merge tree. Ý tưởng cũng tương tự.
But it's basically just a record in a ledger of an ordering of, here's all the operations that a transaction applied to the database system.
Nhưng về cơ bản nó chỉ là một bản ghi trong sổ cái về thứ tự của tất cả các thao tác mà một transaction đã áp dụng lên hệ thống cơ sở dữ liệu.
And we can either store this in a separate file, like a write-ahead log file, which we'll cover in a few weeks, or we can actually just have the database itself be like the log-structured merge tree, but have that be the log we're using to figure out what transactions actually did.
Và chúng ta có thể lưu nó trong một tệp riêng, như tệp write-ahead log, mà chúng ta sẽ học trong vài tuần nữa, hoặc chúng ta thực sự có thể để chính cơ sở dữ liệu giống như log-structured merge tree, nhưng dùng nó làm log để xác định các transaction thực sự đã làm gì.
So in this log, we can keep track of all the actions that occurred, and also redo information and undo information. So undo information would be like how to reverse the change that they applied.
Vì vậy trong log này, chúng ta có thể theo dõi tất cả các hành động đã xảy ra, cũng như thông tin redo và thông tin undo. Thông tin undo là cách đảo ngược thay đổi mà chúng đã áp dụng.
And the redo would be how to reapply the change. We're actually going to end up needing both of them. And we'll have to maintain this undo log in memory as transactions are making changes.
Còn redo là cách áp dụng lại thay đổi đó. Thực ra cuối cùng chúng ta sẽ cần cả hai. Và chúng ta sẽ phải duy trì undo log này trong bộ nhớ khi các transaction đang thực hiện thay đổi.
And then we'll see this in a few weeks.
Và chúng ta sẽ thấy điều này trong vài tuần nữa.
But in our Bufferable Manager, we're going to have to make sure that when we flush out a dirty page that's been modified by a transaction, we've got to make sure the log record that corresponds to whatever that makes that page dirty, that's got to get written to disk first before the page that got modified gets written to disk.
Nhưng trong Buffer Manager của chúng ta, chúng ta sẽ phải đảm bảo rằng khi ghi một dirty page đã bị transaction sửa đổi ra đĩa, thì bản ghi log tương ứng với thao tác làm trang đó bị dirty phải được ghi xuống đĩa trước khi trang bị sửa đổi đó được ghi xuống đĩa.
And that simple ordering is going to guarantee that we can crash and come back and restore the state of the database correctly.
Và thứ tự đơn giản đó sẽ đảm bảo rằng chúng ta có thể gặp sự cố rồi khởi động lại và khôi phục đúng trạng thái của cơ sở dữ liệu.
There's those flight recorders or black boxes in airplanes that keeps track of, like, here's all the things that are occurring in my system right before the crash.
Trên máy bay có thiết bị ghi dữ liệu chuyến bay hay hộp đen để theo dõi tất cả những gì đang diễn ra trong hệ thống ngay trước khi gặp sự cố.
And they recover that to figure out why the plane failed. Same thing in our database system. It's the black box recorder that keeps track of, here's all the changes that are occurring.
Và người ta lấy dữ liệu đó ra để tìm hiểu vì sao máy bay gặp nạn. Hệ thống cơ sở dữ liệu của chúng ta cũng vậy. Nó là hộp đen ghi lại tất cả những thay đổi đang diễn ra.
Some of them have been written to disk. Some might be in memory.
Một số đã được ghi xuống đĩa. Một số có thể vẫn nằm trong bộ nhớ.
But at least when we crash and come back, we can look inside that and figure out what was going on to put the database back in the correct state.
Nhưng ít nhất khi gặp sự cố và khởi động lại, chúng ta có thể xem bên trong đó và xác định chuyện gì đã xảy ra để đưa cơ sở dữ liệu về đúng trạng thái.
Yes?
Bạn có câu hỏi không?
The question is, what are we logging? And the choices are, am I recording, like, a snapshot of the record, like the tuple itself? Or am I recording, like, what was the change?
Câu hỏi là: chúng ta đang ghi log cái gì? Và các lựa chọn là: tôi ghi lại một bản chụp của bản ghi, tức là chính tuple đó? Hay tôi ghi lại thay đổi đã diễn ra là gì?
It depends on how you implement it. The answer is both. You can do both.
Điều đó phụ thuộc vào cách em triển khai. Câu trả lời là cả hai. Em có thể làm cả hai.
So his question is, if I'm recording the aggregation, like, as an update query?
Vậy câu hỏi của bạn ấy là, liệu tôi có ghi lại phép tổng hợp như một câu truy vấn cập nhật không?
I'll say the other way around.
Tôi sẽ nói theo chiều ngược lại.
The statement is, say I do a select query and get an aggregation. And then I update some other record with the corresponding aggregation.
Giả sử tôi chạy một câu truy vấn select và nhận được một kết quả tổng hợp. Sau đó tôi cập nhật một bản ghi khác bằng kết quả tổng hợp tương ứng.
So the log will be ordered such that when you recover it, you can go back to the previous state of the database and replay that transaction.
Vậy nên log sẽ được sắp xếp thứ tự sao cho khi khôi phục, em có thể quay về trạng thái trước đó của cơ sở dữ liệu và phát lại giao dịch đó.
And I actually don't care about the, essentially I don't care about the aggregation. I only care about what's the final computation that I put in the database.
Và thực ra tôi không quan tâm đến về cơ bản là tôi không quan tâm đến phép tổng hợp. Tôi chỉ quan tâm kết quả tính toán cuối cùng mà tôi ghi vào cơ sở dữ liệu.
As long as that occurs in the same order the first time it ran, then I'm OK.
Miễn là điều đó xảy ra theo cùng thứ tự như lần chạy đầu tiên thì tôi ổn.
So that's, getting ahead of ourselves, that's called physiological logging where I'm recording the actual changes, like the byte-level changes, like a diff in git.
Phần này hơi đi trước bài một chút, đó gọi là physiological logging, tức là tôi ghi lại các thay đổi thực tế, như các thay đổi ở mức byte, giống một bản diff trong git.
You can do logical logging where it's actually, the query itself gets logged and then you re-execute the query.
Em cũng có thể làm logical logging, tức là chính câu truy vấn được ghi lại rồi em thực thi lại câu truy vấn đó.
So if the query took, you know, an hour to run the first time, when you recover the log, it takes an hour to run again.
Vậy nếu lần đầu câu truy vấn chạy mất, chẳng hạn, một giờ, thì khi khôi phục log, nó cũng sẽ chạy lại mất một giờ.
But sometimes that's OK because if I'm doing real fast things, it's actually faster for me. So like, we'll get to that in like three weeks. But like, the answer is yes.
Nhưng đôi khi vậy lại ổn, vì nếu các thao tác của tôi rất nhanh, thì cách đó thực ra nhanh hơn. Chúng ta sẽ nói về chuyện đó sau khoảng ba tuần nữa. Nhưng câu trả lời là có.
This thing is being ordered and with all the changes that are getting made so that if I crash and come back, I just replay the exact same order and I am guaranteed to get back to the correct database state.
Log này được sắp thứ tự cùng với mọi thay đổi được thực hiện, để nếu hệ thống sập rồi chạy lại, tôi chỉ cần phát lại đúng thứ tự đó và đảm bảo quay về đúng trạng thái của cơ sở dữ liệu.
All right, so we want to do this for efficiency reasons in some cases because it'll be faster for us to write a sequential log out to disk rather than random IO for pages.
Được rồi, trong một số trường hợp ta muốn làm vậy vì lý do hiệu năng, vì ghi log tuần tự xuống đĩa sẽ nhanh hơn là I/O ngẫu nhiên cho các trang.
That's the same argument we saw with the log-structured merge tree architecture versus like the heap files or the slotted pages.
Đó cũng là lập luận ta đã thấy với kiến trúc log-structured merge tree so với heap file hay slotted page.
But again, sometimes people also keep track of, keep these logs around forever or at least seven years.
Nhưng một lần nữa, đôi khi người ta cũng theo dõi, giữ các log này mãi mãi, hoặc ít nhất là bảy năm.
Like if you're a financial firm, you got to keep track of every transaction that everyone's ever made for seven years if you ever get audited by the regulators.
Chẳng hạn nếu em là một công ty tài chính, em phải lưu lại mọi giao dịch mà mọi người từng thực hiện trong bảy năm, phòng khi bị cơ quan quản lý kiểm toán.
And so this log information can be used for that as well.
Vì vậy thông tin log này cũng có thể dùng cho mục đích đó.
The question is, again, it's related to his question: what am I recording in my log? Is it the actual operations I did, or like the byte-level changes? It depends.
Câu hỏi này lại liên quan đến câu hỏi của bạn ấy: tôi ghi gì vào log? Là các thao tác thực tế tôi đã làm, hay là các thay đổi ở mức byte? Còn tùy.
For undo, you'd have to record what the previous value was, because if it's like a, if you're recording like update value plus one, I have to know what the previous value was.
Với undo, em phải ghi lại giá trị trước đó là gì, vì nếu em ghi kiểu cập nhật giá trị cộng một, thì tôi phải biết giá trị trước đó là bao nhiêu.
Again, like depending on how you're replaying the log, you may need that previous value, maybe you may not. We're getting way ahead of ourselves, but snapshots is the way to handle your problem.
Một lần nữa, tùy vào cách em phát lại log, em có thể cần giá trị trước đó, hoặc có thể không. Chúng ta đang đi trước bài khá xa, nhưng snapshot là cách để xử lý vấn đề của em.
If you don't have the undo, just go back to the previous version and replay in the same order. Again, getting way ahead of ourselves.
Nếu em không có undo, thì cứ quay về phiên bản trước đó và phát lại theo cùng thứ tự. Một lần nữa, ta đang đi trước bài khá xa.
But you guys are getting, you're understanding like this thing can be replayed so we can put the database back in the same state.
Nhưng các bạn đang dần hiểu ra, các bạn đang hiểu rằng thứ này có thể được phát lại để chúng ta đưa cơ sở dữ liệu trở về đúng trạng thái cũ.
The other technique is what we already talked about at the beginning, the shadow paging.
Kỹ thuật còn lại là thứ chúng ta đã nói đến ngay từ đầu, shadow paging.
Again, this is where you make copies of pages to allow the transactions to make those, update those copies instead of the original versions.
Nhắc lại, đây là cách bạn tạo bản sao của các trang để cho phép các giao dịch thực hiện, cập nhật trên các bản sao đó thay vì trên bản gốc.
And then when they go commit, you just flip pointers and say, here's now the latest version of the pages. Yes, in the back.
Và khi chúng commit, bạn chỉ cần đổi con trỏ và nói rằng đây là phiên bản mới nhất của các trang. Vâng, bạn ở phía sau.
Yes. The write-ahead log would be expensive? You said?
Vâng. Write-ahead log sẽ tốn kém ư? Bạn nói vậy phải không?
All right, so the statement is, can I briefly discuss like what's the performance of these two approaches? And there's two notions of performance.
Được rồi, vậy câu hỏi là, tôi có thể nói sơ qua về hiệu năng của hai cách tiếp cận này không? Và có hai khái niệm về hiệu năng.
There is normal operations when I'm running transactions, and then there's if I crash and recover, how long does that take? Most people, most places care about the normal operations.
Một là hoạt động bình thường khi tôi đang chạy các giao dịch, và hai là nếu tôi gặp sự cố rồi khôi phục thì mất bao lâu? Hầu hết mọi người, hầu hết các nơi đều quan tâm đến hoạt động bình thường.
You say, oh, my database is not going to crash that often, so I want to run as fast as I can. And then, yeah, if I crash, then I'll pay that penalty.
Họ nói, ồ, cơ sở dữ liệu của tôi sẽ không hỏng thường xuyên đâu, nên tôi muốn chạy nhanh nhất có thể. Còn nếu gặp sự cố thì tôi sẽ chịu cái giá đó.
So the write-ahead log approach is actually faster at runtime for normal operations, because I can just append to a log and write that out sequentially, right?
Cách dùng write-ahead log thực ra nhanh hơn lúc chạy trong hoạt động bình thường, vì tôi chỉ cần nối thêm vào log và ghi tuần tự ra đĩa, đúng không?
Now, when I crash and come back, depending on how I, when I'm storing my log, I got to replay it, and that could take hours, potentially. Worst case scenario, days, right?
Còn khi gặp sự cố và khởi động lại, tùy cách tôi lưu log, tôi phải phát lại nó, và việc đó có thể mất hàng giờ. Trường hợp xấu nhất là hàng ngày, đúng không?
Whereas in the case of shadow paging, it's going to be slower at runtime because I got to make a copy of the page and then apply my changes and then somehow update some pointer to point to the new pages.
Trong khi với shadow paging, lúc chạy sẽ chậm hơn vì tôi phải tạo một bản sao của trang rồi áp dụng các thay đổi, và sau đó bằng cách nào đó cập nhật một con trỏ để trỏ tới các trang mới.
But when I crash and come back, it's super fast because I just ignore all my shadow pages because those transactions didn't commit, and I come back and my database is instantly in the correct state.
Nhưng khi gặp sự cố và khởi động lại, nó cực kỳ nhanh vì tôi chỉ bỏ qua tất cả các shadow page do các giao dịch đó chưa commit, và khi quay lại thì cơ sở dữ liệu của tôi ngay lập tức ở trạng thái đúng.
So again, most systems are going to care about the normal operations and choose a write-ahead log approach.
Vì vậy, hầu hết các hệ thống sẽ quan tâm đến hoạt động bình thường và chọn cách dùng write-ahead log.
There was one system in the 1970s, I forget the name of it, it was actually built by the Puerto Rican power company.
Có một hệ thống vào thập niên 1970, tôi quên tên nó rồi, thực ra được xây dựng bởi công ty điện lực Puerto Rico.
And it was like, I don't know, the 70s of Puerto Rico, the infrastructure was not that great, although it's not much better now, but still.
Và vào những năm 70 ở Puerto Rico, tôi không rõ nữa, cơ sở hạ tầng không được tốt lắm, dù bây giờ cũng không khá hơn nhiều, nhưng thôi.
So they had a database system and they were sort of keeping track of the usage of various customers.
Họ có một hệ thống cơ sở dữ liệu và dùng nó để theo dõi mức sử dụng của các khách hàng khác nhau.
And because they were having all these power outages, they chose a shadow paging approach because three times a day, the power would go out, the database would crash, and you don't want to spend an hour waiting for the system to come back online, the database system to come back online after a power outage, because it might crash again.
Và vì họ gặp rất nhiều lần mất điện, họ chọn cách shadow paging vì ba lần mỗi ngày, điện bị cắt, cơ sở dữ liệu bị sập, và bạn không muốn mất một giờ để chờ hệ thống hoạt động trở lại, chờ hệ thống cơ sở dữ liệu hoạt động trở lại sau khi mất điện. vì nó có thể lại bị sập.
So they chose shadow paging because when they would crash, which is unpredictable, when they came back, they could have the database instantly available.
Vì vậy họ chọn shadow paging, bởi khi hệ thống sập, mà việc đó thì không thể đoán trước, thì lúc khởi động lại, họ có thể có cơ sở dữ liệu sẵn sàng ngay lập tức.
So they were choosing slower runtime performance in exchange for faster recovery. But most people are going to choose the opposite. So very few systems do this today.
Tức là họ chấp nhận thời gian chạy chậm hơn về hiệu năng để đổi lấy khả năng khôi phục nhanh hơn. Nhưng hầu hết mọi người sẽ chọn ngược lại. Vì vậy ngày nay rất ít hệ thống làm như thế này.
Again, IBM did this on System R in the 1970s, but when they built DB2, they switched to the write-ahead log, the previous slide.
Một lần nữa, IBM đã làm vậy trên System R vào những năm 1970, nhưng khi xây dựng DB2, họ chuyển sang dùng write-ahead log, như ở slide trước.
Probably one of the most famous ones doing this is LMDB. And this is... He's the opposite of me. Like, he loves mmap and he loves shadow paging, and that's what he uses.
Có lẽ một trong những hệ thống nổi tiếng nhất làm điều này là LMDB. Và đây là... Ông ấy là người đối lập với tôi. Kiểu như, ông ấy yêu mmap và yêu shadow paging, và đó là thứ ông ấy dùng.
I think CouchDB still does this. There was an early key value store called Tokyo Cabinet from, I don't know, 10 years ago that was doing this.
Tôi nghĩ CouchDB vẫn làm như vậy. Có một kho khóa-giá trị thời kỳ đầu tên là Tokyo Cabinet, từ tôi không nhớ, khoảng 10 năm trước, cũng làm như vậy.
But in general, like, I guess, it's been said many times this semester, you don't want to do this. Right-hand logging is always going to be a superior choice.
Nhưng nói chung, tôi đoán là, như đã nói nhiều lần trong học kỳ này, bạn không nên làm thế này. Write-ahead logging luôn là lựa chọn vượt trội hơn.
And there's tricks to make the recovery actually go faster. Depends on how much you want to take snapshots and so forth. Like, in general, the right-hand logging is going to be the superior approach.
Và có những mẹo để việc khôi phục thực sự nhanh hơn. Tùy vào mức độ bạn muốn chụp snapshot, v.v. Nói chung, write-ahead logging sẽ là cách tiếp cận vượt trội hơn.
Yes, I'm leaking ideas coming ahead. Yes. I should just say logging, but in actuality, you call this the write-ahead log.
Vâng, tôi đang tiết lộ trước các ý tưởng sắp tới. Vâng, mời bạn. Lẽ ra tôi chỉ nên nói là logging, nhưng thực ra, bạn gọi nó là write-ahead log.
So the idea is you're writing the changes you make to the database to the log first, then you update the actual database itself. That's the write-ahead logging, yes.
Ý tưởng là bạn ghi các thay đổi mình thực hiện lên cơ sở dữ liệu vào log trước, rồi sau đó mới cập nhật chính cơ sở dữ liệu. Đó là write-ahead logging, đúng vậy.
The question is, what happens if you write to the log, that gets written to disk, and then before the changes to the actual data gets...
Câu hỏi là, điều gì xảy ra nếu bạn ghi vào log, log đó được ghi xuống đĩa, và trước khi các thay đổi lên dữ liệu thực sự được...
Well, if you crash and come back, you replay the log and come back. And you... You can't really... If you say commit... All right, so there's another issue, too, we understand.
Thì nếu bạn sập rồi khởi động lại, bạn phát lại log và khôi phục. Và bạn... Bạn không thể thực sự... Nếu bạn nói commit... Được rồi, còn một vấn đề khác nữa, chúng ta hiểu rõ.
So if my application tells my database I want to go commit, I may crash before I get the acknowledgement that my transaction committed. And that's okay. So meaning, like, I...
Nếu ứng dụng của tôi báo cho cơ sở dữ liệu rằng tôi muốn commit, tôi có thể sập trước khi nhận được xác nhận rằng giao dịch của tôi đã commit. Và điều đó vẫn ổn. Nghĩa là, kiểu như, tôi...
If you tell me to commit, I commit your transaction, and then now I'm about to send you a message, hey, I got it, good job, right, but then I crash before you get that message, that transaction is still committed.
Nếu bạn bảo tôi commit, tôi commit giao dịch của bạn, và giờ tôi sắp gửi cho bạn một thông báo, kiểu "tôi nhận rồi, làm tốt lắm", nhưng rồi tôi sập trước khi bạn nhận được thông báo đó, thì giao dịch đó vẫn được commit.
And it's your job to go figure out whether it actually committed or not. We can't... The database system... And that's still correct. Right?
Và việc xác định xem nó có thực sự được commit hay không là trách nhiệm của bạn. Chúng ta không thể... Hệ quản trị cơ sở dữ liệu... Và điều đó vẫn đúng. Đúng không?
We're getting ahead of ourselves. Some systems will keep everything in memory. Some systems will actually write things along. You want to write things... Sorry, write the log to disk.
Chúng ta đang nói trước nội dung rồi. Một số hệ thống sẽ giữ mọi thứ trong bộ nhớ. Một số hệ thống sẽ thực sự ghi dần ra. Bạn muốn ghi... Xin lỗi, ghi log xuống đĩa.
You want to write it to disk because that means if, like, if I have...
Bạn muốn ghi nó xuống đĩa vì điều đó có nghĩa là nếu, chẳng hạn, tôi có...
If I need to update a billion pages, but I only keep 100 in memory, then the write-ahead log is how I'm going to be able to handle that.
Nếu tôi cần cập nhật một tỉ trang, nhưng chỉ giữ 100 trang trong bộ nhớ, thì write-ahead log chính là cách tôi xử lý việc đó.
If I have to keep everything in memory, then I can't do... Can't keep everything in memory.
Nếu tôi phải giữ mọi thứ trong bộ nhớ thì tôi không thể... Không thể giữ mọi thứ trong bộ nhớ.
So it's okay for me to write the log to disk before I finish, or the transaction commits, but as soon as I'm told commit, as soon as on disk it lands a commit message in the log, that transaction is committed.
Vậy việc ghi log xuống đĩa trước khi tôi kết thúc là chấp nhận được, hay trước khi giao dịch commit, nhưng ngay khi tôi được báo là commit, ngay khi một thông điệp commit được ghi xuống đĩa trong log, thì giao dịch đó đã được commit.
In the middle of the log... Yes? Yes. ...before you actually get to the database... Yeah.
Ở giữa log... Em nói đi? Vâng. ...trước khi bạn thực sự đến được cơ sở dữ liệu... Đúng vậy.
...and back up, and you don't know that, yeah, because logs are... No.
...và sao lưu, và bạn không biết điều đó, vâng, vì các log thì... Không.
The statement is, it may be the case where my transaction is updating the database, and I'm writing to this log, and some of those log records are getting written to disk, and you haven't told me to commit yet, right?
Ý em là, có thể trường hợp giao dịch của tôi đang cập nhật cơ sở dữ liệu, và tôi đang ghi vào log này, và một số bản ghi log đó đã được ghi xuống đĩa, và bạn vẫn chưa bảo tôi commit, đúng không?
So I haven't... The application hasn't told me to commit, and then I crash. Correct. The log can help us do that.
Tức là ứng dụng chưa bảo tôi commit, rồi tôi bị sập. Chính xác. Log có thể giúp chúng ta xử lý việc đó.
So there's the log, and then there's the data. The log tells me what I was trying to do to the data.
Vậy có log, và có dữ liệu. Log cho tôi biết tôi đã định làm gì với dữ liệu.
So when I crash and come back, I go look in the data and say, did I actually make those changes, yes or no?
Nên khi bị sập rồi khởi động lại, tôi xem trong dữ liệu và hỏi, liệu tôi có thực sự đã thực hiện những thay đổi đó không, có hay không?
And if I did, and they shouldn't be there, I have to roll them back. Yeah. This gets very hard. It's very complicated. The answer is yes.
Và nếu có, mà chúng lẽ ra không nên ở đó, thì tôi phải hoàn tác chúng. Vâng. Việc này rất khó. Rất phức tạp. Câu trả lời là có.
We'll spend one whole lecture on exactly that problem. Yes. Because then you've got to worry about, like, my log grows forever, right?
Chúng ta sẽ dành trọn một bài giảng cho đúng vấn đề đó. Vâng. Vì khi đó bạn còn phải lo chuyện log của tôi cứ lớn mãi, đúng không?
I don't want to run my database for five years, and then crash and have to replay the log for five years. So what do you do?
Tôi không muốn chạy cơ sở dữ liệu suốt năm năm, rồi bị sập và phải phát lại log của năm năm. Vậy bạn làm gì?
You take checkpoints or snapshots so I can truncate how far back in the log I've got to go.
Bạn tạo checkpoint hoặc snapshot để tôi có thể cắt bớt phần log phải lần ngược lại.
But what happens if I don't have a transaction started, I take a checkpoint, and then the transaction finishes, and now it spans checkpoints? How do I handle that?
Nhưng điều gì xảy ra nếu tôi chưa có giao dịch nào bắt đầu, tôi tạo một checkpoint, rồi giao dịch kết thúc, và giờ nó trải dài qua nhiều checkpoint? Tôi xử lý thế nào?
The statement is, again, we're getting ahead of ourselves. The statement is, and I like this, the statement is, well, we just don't take checkpoints when our transactions are running.
Một lần nữa, chúng ta đang đi trước nội dung rồi. Ý kiến này, và tôi thích nó, là thì cứ không tạo checkpoint khi các giao dịch đang chạy.
A checkpoint takes, say, half an hour. Do you want my website to be down for half an hour? No. Right? And in the financial world, those guys are paranoid.
Một checkpoint mất, giả sử, nửa tiếng. Bạn có muốn website của tôi ngừng hoạt động nửa tiếng không? Không. Đúng không? Và trong giới tài chính, những người đó rất hay lo xa.
They take checkpoints every five minutes. So we'll talk about how do you allow transactions to keep running while I'm taking checkpoints. They're called fuzzy checkpoints. It's hard. It's awesome. Yeah.
Họ tạo checkpoint mỗi năm phút. Vì vậy chúng ta sẽ bàn về cách cho phép các giao dịch tiếp tục chạy trong khi tôi đang tạo checkpoint. Chúng được gọi là fuzzy checkpoint. Khó lắm. Tuyệt lắm. Vâng.
And there's this book, or sorry, not a book, there's this, we'll spend a whole class on this, the algorithm is called ARIES. It's developed by IBM in the early 90s. It's 75 pages.
Và có cuốn sách này, à xin lỗi, không phải sách, có cái này, chúng ta sẽ dành cả một buổi cho nó, thuật toán này tên là ARIES. Nó do IBM phát triển vào đầu những năm 90. Dài 75 trang.
It's like, that's the Bible on how to make sure your database is fail-safe. All in a single node. Again, if the machine catches on fire, you're screwed there.
Nó giống như cuốn kinh thánh về cách đảm bảo cơ sở dữ liệu của bạn an toàn khi lỗi. Tất cả chỉ trên một nút duy nhất. Lại nói, nếu máy bị cháy thì bạn toi rồi.
Then you use Paxos or Raft, whatever, to span things out across multiple nodes. We'll get there. We'll get there. Okay. Don't do the shadow vetting. All right. Consistency, this thing, right?
Khi đó bạn dùng Paxos hay Raft, gì cũng được, để trải hệ thống ra nhiều nút. Rồi sẽ đến đó. Rồi sẽ đến đó. Được rồi. Đừng có nhìn bài người khác. Được rồi. Tính nhất quán, cái này, đúng không?
So again, we're trying to say our database is trying to model the real world.
Vậy một lần nữa, chúng ta muốn nói rằng cơ sở dữ liệu của mình cố gắng mô hình hóa thế giới thực.
So we want to make sure that we don't allow transactions to make changes that would violate, you know, parameters or aspects of the real world.
Vì vậy chúng ta muốn đảm bảo rằng không cho phép các giao dịch thực hiện những thay đổi vi phạm các tham số hay khía cạnh nào đó của thế giới thực.
So for example, if I have a database of keeping track of everyone's age as a single integer, nobody can be a negative age. Right? So I want my data system to not allow that.
Ví dụ, nếu tôi có một cơ sở dữ liệu theo dõi tuổi của mọi người dưới dạng một số nguyên, thì không ai có thể có tuổi âm. Đúng không? Vậy tôi muốn hệ thống dữ liệu không cho phép điều đó.
And therefore, if a transaction tries to update, you know, someone's age record to say now they're negative 100 years old, the data system would not, should not allow that because that would be an inconsistency of the database.
Và do đó, nếu một giao dịch cố cập nhật, bản ghi tuổi của ai đó thành âm 100 tuổi, thì hệ thống dữ liệu sẽ không, không nên cho phép điều đó, vì nó sẽ gây ra sự không nhất quán của cơ sở dữ liệu.
Right? So this is not something the data system can do for you automatically. It doesn't know what it means for someone to be a negative age or just storing integers.
Đúng không? Đây không phải là việc hệ thống dữ liệu có thể tự động làm cho bạn. Nó không biết việc ai đó có tuổi âm nghĩa là gì, nó chỉ lưu các số nguyên.
So these constraints are things that the application has to tell us. Either through like the add constraints or like when you create the table, you can call it check.
Vì vậy những ràng buộc này là thứ mà ứng dụng phải cho chúng ta biết. Hoặc thông qua add constraints, hoặc khi tạo bảng, bạn có thể dùng check.
Not null is another obvious one. Right?
Not null là một ví dụ hiển nhiên khác. Đúng không?
So these are all, it has to be told these constraints ahead of time and the data system, if it wants to be consistent, has to enforce them to make sure that no transaction actually can update the database in an invalid way.
Vậy tất cả những thứ này, hệ thống phải được cho biết các ràng buộc này từ trước, và hệ thống dữ liệu, nếu muốn nhất quán, phải thực thi chúng để đảm bảo rằng không giao dịch nào có thể cập nhật cơ sở dữ liệu theo cách không hợp lệ.
So you may have heard the term eventual consistency. Right? This is when we're getting ahead of ourselves a little bit, but this is when we start talking about multiple nodes, like distributed systems.
Có thể bạn đã nghe thuật ngữ eventual consistency. Đúng không? Chúng ta đang đi trước một chút, nhưng đây là khi bắt đầu nói về nhiều nút, tức là các hệ thống phân tán.
So eventual consistency means that if I have a copy of the data that's replicated on, say, two machines, and so when my transaction modifies something on one machine and I commit, that change should be immediately reflected on the other machine if I want to have, you know, consistency guarantees.
Eventual consistency nghĩa là nếu tôi có một bản sao của dữ liệu được nhân bản trên, giả sử, hai máy, thì khi giao dịch của tôi sửa một thứ trên một máy và tôi commit, thay đổi đó phải được phản ánh ngay lập tức trên máy kia nếu tôi muốn có các đảm bảo về tính nhất quán.
So that means if I commit here and I immediately try to read that same record on another machine, I should see my own writes.
Nghĩa là nếu tôi commit ở đây và ngay lập tức thử đọc cùng bản ghi đó trên một máy khác, tôi phải thấy những gì chính mình đã ghi.
Eventual consistency basically says, well, this is hard to do, so we'll have two copies of the data on two machines, and when I update the one machine here, I'll eventually update the other one.
Eventual consistency về cơ bản nói rằng, điều này khó làm, nên ta sẽ có hai bản sao dữ liệu trên hai máy, và khi tôi cập nhật một máy ở đây, rốt cuộc tôi sẽ cập nhật máy kia.
So there's a window, a small window, where I may do a commit on this node, then go try to read that same record on another node, and my change hasn't been propagated yet, so therefore I see the older version.
Vậy có một khoảng thời gian, một cửa sổ nhỏ, trong đó tôi có thể commit trên nút này, rồi đi đọc cùng bản ghi đó trên một nút khác, và thay đổi của tôi chưa được lan truyền, nên tôi thấy phiên bản cũ hơn.
Right? This is what people did in the, this was the hot thing out of Google in the 2000s. But we'll talk about this in the class.
Đúng không? Đây là điều người ta đã làm, đây từng là thứ thịnh hành từ Google vào những năm 2000. Nhưng chúng ta sẽ nói về điều này trong lớp.
Like, they basically said, "Oh, that was actually a mistake," because now you have a bunch of JavaScript programmers trying to reason about inconsistent, incorrect data, and that's never, that's never good.
Về cơ bản họ nói rằng, "Ồ, đó thực ra là một sai lầm," vì giờ bạn có một đống lập trình viên JavaScript phải suy luận về dữ liệu không nhất quán, không chính xác, và điều đó không bao giờ là tốt.
Right? So most of the modern transactional systems don't do this. We'll cover this briefly and see how to not do it later in the semester in lecture 23.
Đúng không? Vì vậy hầu hết các hệ thống giao dịch hiện đại không làm thế này. Chúng ta sẽ lướt qua phần này và xem cách để không nó sau trong học kỳ, ở bài giảng 23.
What is, what? Integrity constraint. Sorry. Right? Like, not null is an integrity constraint. Check that no age is greater, no age is less than zero. Right?
Cái gì, cái gì nhỉ? Ràng buộc toàn vẹn. Xin lỗi. Đúng không? Chẳng hạn, not null là một ràng buộc toàn vẹn. Kiểm tra xem không có tuổi nào lớn hơn, không có tuổi nào nhỏ hơn không. Đúng không?
Those are integrity constraints. Thank you. I should update that. All right. So the main one I want to talk about is isolation, transactions.
Đó là những ràng buộc toàn vẹn. Cảm ơn bạn. Tôi nên sửa lại chỗ đó. Được rồi. Vậy điều chính tôi muốn nói là tính cô lập, của các giao dịch.
And again, this means that when an application submits queries, sorry, submits transactions to the database system, they're going to assume that they're running by themself.
Và một lần nữa, điều này có nghĩa là khi một ứng dụng gửi các truy vấn, xin lỗi, gửi các giao dịch đến hệ quản trị cơ sở dữ liệu, chúng sẽ cho rằng mình đang chạy một mình.
So they're not going to see weird intermediate states from other transactions modifying the database. Right? It's going to be as if it's running in serial order.
Vì vậy chúng sẽ không thấy những trạng thái trung gian kỳ lạ do các giao dịch khác sửa đổi cơ sở dữ liệu. Đúng không? Nó sẽ như thể đang chạy theo thứ tự tuần tự.
And this is a good thing because this is a way easier programming model for your random application developer to reason about. Right? Think of, like, JavaScript programmers.
Và đây là điều tốt vì đây là một mô hình lập trình dễ hơn nhiều để một lập trình viên ứng dụng bình thường suy luận. Đúng không? Cứ nghĩ đến các lập trình viên JavaScript.
Like, you don't want them to start thinking about, okay, what if I update this and another guy updates the same thing at the same time? How do I handle this?
Bạn không muốn họ phải bắt đầu nghĩ, được rồi, nếu tôi cập nhật cái này mà người khác cũng cập nhật đúng cái đó cùng lúc thì sao? Tôi xử lý chuyện này thế nào?
If you just assume they're going to run in serial order, then it's as if you're running on a box by yourself. Right?
Nếu bạn chỉ cần giả định chúng chạy theo thứ tự tuần tự, thì như thể bạn đang chạy trên một máy một mình. Đúng không?
But as we already said, we want to be able to interleave these operations from these transactions at the same time so that, you know, we get better parallelism and get better performance.
Nhưng như đã nói, chúng ta muốn có thể đan xen các thao tác của những giao dịch này cùng lúc để, bạn biết đấy, có tính song song tốt hơn và hiệu năng tốt hơn.
But we still need to make sure that they're going to run as if they were running one at a time, even though they're not.
Nhưng chúng ta vẫn cần đảm bảo rằng chúng chạy như thể đang chạy lần lượt từng cái một, dù thực tế không phải vậy.
So this is what the concurrency control protocol is going to provide for us.
Và đây là điều mà giao thức điều khiển đồng thời sẽ cung cấp cho chúng ta.
In addition to the logging and all the other stuff, sort of the whole big picture, but this is basically the coordination mechanism inside of our database system that we're going to use to figure out what transaction can run at what time, what data are they allowed to read and write, and then when they go to commit, are they allowed to do that or not.
Cùng với việc ghi nhật ký và tất cả những thứ khác, tức là toàn bộ bức tranh lớn, nhưng về cơ bản đây là cơ chế điều phối bên trong hệ quản trị cơ sở dữ liệu của chúng ta mà ta dùng để xác định giao dịch nào được chạy vào lúc nào, chúng được phép đọc và ghi dữ liệu nào, và khi chúng đi đến commit thì có được phép làm vậy hay không.
There's other things that we'll talk about next class, like how to handle deadlocks, or either, you know, breaking them when they occur or prevent them from occurring. That's next class. Right?
Còn những vấn đề khác sẽ nói vào buổi sau, như cách xử lý bế tắc, hoặc là phá vỡ chúng khi xảy ra, hoặc là ngăn không cho chúng xảy ra. Đó là buổi sau. Đúng không?
Well, in general there's going to be basically two approaches to this. Right? Which I just sort of said. Right? There's going to be pessimistic and optimistic concurrency protocols.
Nói chung về cơ bản sẽ có hai cách tiếp cận. Đúng không? Điều mà tôi vừa nói qua. Đúng không? Có các giao thức đồng thời bi quan và lạc quan.
Pessimistic says that I think, sorry, I'm assuming you're going to have conflicts with other transactions, so I'm going to prevent you from doing certain things to avoid these conflicts.
Bi quan nghĩa là tôi nghĩ, xin lỗi, tôi giả định bạn sẽ xung đột với các giao dịch khác, nên tôi sẽ ngăn bạn làm một số việc nhất định để tránh những xung đột này.
Right? Trying to stop you from doing something wrong ahead of time.
Đúng không? Cố ngăn bạn làm điều sai trước khi nó xảy ra.
Optimistic assumes that the conflicts are rare, and two guys trying to, two transactions trying to read and write to the data at the same time, same data at the same time, so I'm going to allow you to just do whatever you want, but then when you go to commit, I'll go figure out what you actually did and go to clean things up.
Lạc quan giả định rằng xung đột là hiếm, và hai giao dịch cùng cố đọc và ghi vào dữ liệu cùng lúc, cùng một dữ liệu cùng lúc là hiếm, nên tôi sẽ cho phép bạn làm bất cứ điều gì bạn muốn, nhưng rồi khi bạn đi đến commit, tôi sẽ xem bạn thực sự đã làm gì và dọn dẹp lại mọi thứ.
Right? So let's look at an example here of how can you allow this interleaving and what does it mean for things to be correct, a correct interleaving.
Đúng không? Vậy chúng ta hãy xem một ví dụ về cách cho phép việc xen kẽ này và thế nào thì được coi là đúng, tức là một cách xen kẽ đúng.
So again, same, we're doing the same bank application. We have two accounts, A and B, and each one has a thousand dollars in it.
Một lần nữa, chúng ta vẫn dùng ứng dụng ngân hàng đó. Ta có hai tài khoản, A và B, và mỗi tài khoản có một nghìn đô la.
So transaction T1 wants to take a hundred dollars out of A's account and put it into B's account, and at the same time we have another transaction T2 that wants to compute Six percent interest on the accounts and, you know, give them a bump in the money.
Giao dịch T1 muốn lấy một trăm đô la từ tài khoản của A và chuyển vào tài khoản của B, và đồng thời ta có một giao dịch T2 muốn tính lãi suất sáu phần trăm cho các tài khoản và, bạn biết đấy, cộng thêm một khoản tiền cho chúng.
Right? So we want to see how we can interleave these transactions at the same time to improve the performance of the system, reduce the total amount of time it takes to execute them.
Đúng không? Vậy ta muốn xem làm thế nào để xen kẽ các giao dịch này cùng lúc nhằm cải thiện hiệu năng của hệ thống, giảm tổng thời gian cần để thực thi chúng.
So the first thing we understand is what are the possible outcomes we could have for interleaving these two transactions here? Right? The answer is a bunch, right? They're not doing that much.
Điều đầu tiên cần hiểu là các kết quả có thể xảy ra là gì khi xen kẽ hai giao dịch này? Đúng không? Câu trả lời là khá nhiều, chúng đâu có làm nhiều việc.
There's only two transactions, there's only two objects, so it's not, you know, it's not infinite. Right?
Chỉ có hai giao dịch, chỉ có hai đối tượng, nên nó không phải là vô hạn. Đúng không?
But for this application, the thing we care about at the end of the application is that there's no money missing and there's no extra money that shouldn't be there.
Nhưng với ứng dụng này, điều chúng ta quan tâm ở cuối ứng dụng là không bị mất tiền và cũng không có thêm số tiền không đáng có.
So an easy way to think about it is, if I just take the two accounts, they both have a thousand dollars, so I end up adding them together, I get two thousand dollars, and I compute one percent interest on them, or six percent interest on them, the final state of the database, the total amount of money I should have in my database, should be 2120.
Một cách dễ nghĩ là, nếu tôi lấy hai tài khoản, cả hai đều có một nghìn đô la, cộng chúng lại thì được hai nghìn đô la, và tính lãi một phần trăm cho chúng, hay sáu phần trăm, thì trạng thái cuối cùng của cơ sở dữ liệu, tổng số tiền tôi phải có trong cơ sở dữ liệu, phải là 2120.
So an important thing to understand in this world of database systems, at least what we're talking about here today, is that it doesn't matter whether T1 is submitted first by the application and then T2.
Một điều quan trọng cần hiểu trong thế giới hệ cơ sở dữ liệu này, ít nhất là những gì ta đang nói hôm nay, là việc T1 được ứng dụng gửi đến trước rồi mới đến T2 không quan trọng.
We're allowed to execute them in any order that we want. So the order of their arrival on the box doesn't matter.
Ta được phép thực thi chúng theo bất kỳ thứ tự nào ta muốn. Vậy thứ tự chúng đến máy không quan trọng.
We can still order them, you know, in any way we want to try to get the best performance. There's a, if you care about those things, that's called strict consistency or external consistency.
Ta vẫn có thể sắp xếp thứ tự chúng theo bất kỳ cách nào ta muốn để cố đạt hiệu năng tốt nhất. Nếu bạn quan tâm đến những điều này, thì nó được gọi là strict consistency hay external consistency.
Very few systems support that. Google Spanner is probably the most famous one.
Rất ít hệ thống hỗ trợ điều đó. Google Spanner có lẽ là hệ nổi tiếng nhất.
Google Spanner will guarantee that if one application submits T1 and then, like, a half a millisecond later another application submits T2, it'll guarantee that T1 commits before T2.
Google Spanner đảm bảo rằng nếu một ứng dụng gửi T1 và rồi, chẳng hạn, nửa mili giây sau một ứng dụng khác gửi T2, thì nó đảm bảo T1 commit trước T2.
To simplify our problem today, we're allowed to... we're not going to guarantee that we can still reorder them.
Để đơn giản hóa bài toán hôm nay, chúng ta được phép... chúng ta sẽ không đảm bảo điều đó, ta vẫn có thể sắp xếp lại thứ tự chúng.
But the outcome, again, we want in order to make sure that we have this 2120 number at the end is that whatever interleaving we come up with, we want to be as if they executed in serial order, meaning one after another.
Nhưng kết quả, một lần nữa, để đảm bảo rằng ta có con số 2120 này ở cuối, là dù ta đưa ra cách xen kẽ nào, ta muốn nó giống như thể chúng được thực thi theo thứ tự tuần tự, nghĩa là cái này sau cái kia.
So that means that there's only two database states. Either I run T1 first followed by T2, or run T2 followed by T1, right?
Điều đó có nghĩa là chỉ có hai trạng thái cơ sở dữ liệu. Hoặc là chạy T1 trước rồi đến T2, hoặc chạy T2 trước rồi đến T1, đúng không?
And I may end up with different values for the accounts, for A and B, but again, if I just add the total amount for each of them after the transaction is committed, I still end up with 2120.
Và có thể tôi sẽ có các giá trị khác nhau cho các tài khoản, A và B, nhưng một lần nữa, nếu tôi chỉ cộng tổng số tiền của từng tài khoản sau khi giao dịch được commit, thì tôi vẫn có kết quả là 2120.
So either one is correct, no matter how the transactions are submitted by the application.
Vì vậy cả hai thứ tự đều đúng, bất kể ứng dụng gửi các giao dịch theo cách nào.
That's a different notion than maybe you think about correctness if you're running on, like, you know, a single node parallel system, like strict memory orderings.
Đó là một khái niệm khác với những gì các bạn có thể nghĩ về tính đúng đắn nếu các bạn đang chạy trên, chẳng hạn, một hệ thống song song trên một nút đơn, như các thứ tự bộ nhớ chặt chẽ.
In this case here, the data system is given freedom to reorder this any way it wants, as long as it appears as if the transaction is executed one after another, right?
Trong trường hợp này, hệ thống dữ liệu được tự do sắp xếp lại thứ tự theo bất kỳ cách nào nó muốn, miễn là trông như thể các giao dịch được thực thi lần lượt, cái này sau cái kia, đúng không?
So again, the two possible serial orderings are T1 executes followed by T2, or T2 executes first followed by T1.
Vậy một lần nữa, hai thứ tự tuần tự có thể có là T1 thực thi rồi đến T2, hoặc T2 thực thi trước rồi đến T1.
And again, if I just look at the final outcome of the state of objects A and B, when I add them together, it's always going to be 2120.
Và một lần nữa, nếu tôi chỉ nhìn vào kết quả cuối cùng của trạng thái các đối tượng A và B, khi cộng chúng lại, nó luôn luôn là 2120.
The question is, what, let's say it again, the question is, how would I determine this algorithmically? So that would be the control protocol, right?
Câu hỏi là, để tôi nói lại, câu hỏi là, làm thế nào để xác định điều này bằng thuật toán? Đó sẽ là giao thức điều khiển, đúng không?
So today's class, we're going to talk about just identifying whether the ordering is correct or not. Next class will be, how do we enforce that? How do we make sure that doesn't happen?
Vậy trong buổi học hôm nay, chúng ta sẽ chỉ nói về việc xác định xem thứ tự có đúng hay không. Buổi sau sẽ là, làm thế nào để thực thi điều đó? Làm thế nào để đảm bảo điều đó không xảy ra?
So again, for this class, we're assuming that we're given the queries ahead of time, sorry, the operations ahead of time. So we have the schedule ahead of time.
Vậy một lần nữa, trong buổi này, chúng ta giả định rằng các truy vấn được cho trước, xin lỗi, các thao tác được cho trước. Tức là chúng ta có sẵn lịch thực thi từ trước.
So we're not worried about a transaction T3 showing up in this example here. In the back, yes.
Nên chúng ta không lo về việc giao dịch T3 xuất hiện trong ví dụ này. Bạn ở phía sau, mời bạn.
The question is, wouldn't there exist some kind of requirement or criteria that would be the same across all sequential orderings?
Câu hỏi là, liệu có tồn tại một yêu cầu hay tiêu chí nào đó giống nhau cho mọi thứ tự tuần tự không?
Yes. So her point is that I'm showing, I'm showing this example here and I'm saying A plus B equals 2120, and I'm saying that's what we're using to determine is the ordering correct?
Có. Ý của bạn ấy là tôi đang trình bày ví dụ này và nói A cộng B bằng 2120, và tôi nói đó là thứ dùng để xác định thứ tự có đúng hay không?
I'm just using that as an illustration in this example. Right? The things you would sort of really care about is like the values in the objects themselves. Right?
Tôi chỉ dùng nó để minh họa trong ví dụ này. Đúng không? Điều các bạn thực sự quan tâm là các giá trị trong chính các đối tượng. Đúng không?
And then we'll see that when we look at what the operations are actually doing inside the database system. That's how we're going to end up determining whether the ordering is correct or not.
Và chúng ta sẽ thấy điều đó khi xem xét các thao tác thực sự làm gì bên trong hệ quản trị cơ sở dữ liệu. Đó là cách chúng ta sẽ xác định xem thứ tự có đúng hay không.
For illustration purposes, I'm saying, to make it more intuitive, A plus B equals 2120, and you can see for the two serial orderings you always end up with that.
Để minh họa, cho trực quan hơn, tôi nói A cộng B bằng 2120, và bạn có thể thấy với hai thứ tự tuần tự thì lúc nào cũng ra kết quả đó.
Right? Yeah, that notion of the higher level notion of correctness, no, you can't assume someone's going to give you that. Yes.
Đúng không? Vâng, khái niệm đó, khái niệm cấp cao hơn về tính đúng đắn, không, bạn không thể giả định rằng sẽ có ai đó đưa cho bạn điều đó. Vâng.
Let me rephrase what you're saying.
Để tôi diễn đạt lại điều bạn đang nói.
Basically, what I'm trying to say is that I want to interleave these operations and these transactions, and I want the end state of the database to be equivalent to some serial ordering of those transactions.
Về cơ bản, điều tôi muốn nói là tôi muốn đan xen các thao tác này và các giao dịch này, và tôi muốn trạng thái cuối của cơ sở dữ liệu tương đương với một thứ tự tuần tự nào đó của các giao dịch đó.
But there may be multiple serial orderings, and I actually don't care which one I end up with as long as there's at least one of them.
Nhưng có thể có nhiều thứ tự tuần tự, và thực ra tôi không quan tâm mình nhận được thứ tự nào, miễn là có ít nhất một thứ tự như vậy.
Let me walk through some examples.
Để tôi đi qua một vài ví dụ.
The question is going to be, like, what's an example of a system that can't guarantee these things? A lot of them. So let me go through serializability and then, right.
Câu hỏi sẽ là, ví dụ về một hệ thống không thể đảm bảo những điều này là gì? Rất nhiều. Vậy để tôi đi qua tính khả tuần tự hóa trước rồi nhé.
But I'll just say straight up, like, when we talk about isolation levels, you say basically, I want to guarantee, for example, my transactions end up equivalent to a serial ordering.
Nhưng tôi nói thẳng luôn, khi nói về các mức cô lập, về cơ bản bạn nói rằng bạn muốn đảm bảo, ví dụ, các giao dịch của mình kết thúc tương đương với một thứ tự tuần tự.
Some systems will lie to you and say, yeah, I'll do that for you, when they actually don't do it. Oracle does this. Oracle will say, I want my transaction to be serializable.
Một số hệ thống sẽ nói dối bạn, bảo rằng được, tôi sẽ làm điều đó cho bạn, trong khi thực tế họ không làm. Oracle làm như vậy. Oracle sẽ nói, tôi muốn giao dịch của mình là serializable.
You actually get a lower level than serializable. Right? And in Postgres theirs was broken for a few years and someone fixed it two or three years ago.
Thực ra bạn nhận được mức thấp hơn serializable. Đúng không? Còn trong Postgres thì phần đó từng bị lỗi trong vài năm và có người đã sửa nó cách đây hai hoặc ba năm.
This is super hard. All right. So let's look at interleaving, a good example. Why would an interleaving occur?
Việc này cực kỳ khó. Được rồi. Hãy xem sự đan xen, một ví dụ hay. Tại sao sự đan xen lại xảy ra?
Again, so say like, you know, the transaction tries to go get data in a page and it's not in your buffer pool.
Một lần nữa, giả sử giao dịch cố gắng đi lấy dữ liệu trong một trang và nó không có trong buffer pool của bạn.
You've got to stall that transaction while you go to the disk and go get it. And meanwhile the disk is going to decide, I'm going to let somebody get something else.
Bạn phải tạm dừng giao dịch đó trong lúc đi đến đĩa để lấy dữ liệu. Và trong khi đó đĩa sẽ quyết định, tôi sẽ cho người khác lấy thứ khác.
Wrong. So let's say T1 starts, it does, takes the $100 out of A, and then it stalls because it has to go to disk, and then T2 is allowed to start.
Sai. Giả sử T1 bắt đầu, lấy $100 ra khỏi A, rồi nó bị dừng vì phải truy cập đĩa, và T2 được phép bắt đầu.
A can produce the interest on A, but then it stalls because it's waiting for something, to say the same page, to get read, B.
A có thể tính tiền lãi trên A, nhưng rồi nó bị dừng vì đang chờ một thứ gì đó, chẳng hạn cùng một trang, để được đọc, B.
So then T1 can start again, puts the $100 back in B, then commits, and then T2 starts running and then can update, compute the interest on B.
Khi đó T1 có thể chạy lại, đặt $100 vào B, rồi commit, sau đó T2 chạy tiếp và có thể cập nhật, tính tiền lãi trên B.
So in this case here, even though I'm interleaving T1 and T2, it's equivalent to a serial ordering of T1 followed by T2. Right.
Vậy trong trường hợp này, dù tôi đan xen T1 và T2, nó vẫn tương đương với thứ tự tuần tự T1 rồi đến T2. Đúng không.
And the key thing to point out is, like, the operations on A and B are always happening on T1 first before T2. Right.
Và điều then chốt cần chỉ ra là các thao tác trên A và B luôn xảy ra ở T1 trước rồi mới đến T2. Đúng không.
And again, just using this as a simple illustrative trick, you end up with the same state. A bad interleaving would look like this.
Và một lần nữa, dùng cách này như một mẹo minh họa đơn giản, bạn nhận được cùng một trạng thái. Một sự đan xen xấu sẽ trông như thế này.
Where T1 starts, it gets paused or stalled for whatever reason, T2 starts.
T1 bắt đầu, bị tạm dừng hoặc bị chặn vì lý do nào đó, T2 bắt đầu.
Alright, so T1 takes $100 out of A, T2 then computes the interest on A, then computes the interest on B, and then commits, and then T1 goes and adds the $100 back to B.
Được rồi, T1 lấy $100 ra khỏi A, rồi T2 tính tiền lãi trên A, sau đó tính tiền lãi trên B, rồi commit, và sau đó T1 quay lại cộng $100 vào B.
So when we look at the sum total value of the two accounts, we're missing $6, because we computed interest on A while this $100 was taken out of A but before it was put in B.
Vậy nên khi ta xem tổng giá trị của hai tài khoản, ta bị thiếu $6, vì ta đã tính lãi cho A trong lúc $100 này đã bị lấy ra khỏi A nhưng chưa được cộng vào B.
Right. So this is what we're trying to avoid. We're trying to avoid ending up with a state of the database for our objects that's not equivalent to any serial ordering.
Đúng không. Đây chính là điều ta đang cố tránh. Ta đang cố tránh việc kết thúc với một trạng thái của cơ sở dữ liệu cho các đối tượng của ta mà không tương đương với bất kỳ thứ tự tuần tự nào.
And again, for two transactions it's either T1, T2 or T2, T1, but think of, like, if I have a million transactions, how about I come out with a bad ordering?
Và một lần nữa, với hai transaction thì chỉ có T1, T2 hoặc T2, T1, nhưng hãy nghĩ xem, nếu tôi có một triệu transaction, thì nếu tôi ra một thứ tự sai thì sao?
Right.
Đúng không.
So as humans, in the examples here I'm showing, like, you know, A equals A minus 100, right? I'm just showing this, it's pretty easy for us to understand what's actually going on.
Với con người chúng ta, trong các ví dụ tôi đang trình bày, kiểu như A = A − 100, đúng không? Tôi chỉ đang minh họa như vậy, nên ta khá dễ hiểu thực sự đang diễn ra chuyện gì.
This is actually not what the database sees. The database sees this instead. Again, we said all we have are read and write operations on single objects.
Nhưng đây thật ra không phải điều cơ sở dữ liệu nhìn thấy. Nó thấy thế này. Như đã nói, ta chỉ có các thao tác đọc và ghi trên các đối tượng đơn lẻ.
The database doesn't know, again, the high-level meaning of what you're trying to do. It just knows whether you're trying to read or write to an object.
Cơ sở dữ liệu không biết ý nghĩa ở mức cao của việc bạn đang cố làm. Nó chỉ biết bạn đang cố đọc hay ghi một đối tượng.
So again, in this example here it's pretty easy for us to look at and say, okay, well, this is bad, right?
Vậy trong ví dụ này, ta nhìn vào là khá dễ để nói rằng, được rồi, cái này sai, đúng không?
And then I compute the sum and I see that I'm off, but how can we actually do this for real?
Rồi tôi tính tổng và thấy nó bị lệch, nhưng làm sao ta làm được điều này trong thực tế?
And so we want to determine that we have a correct ordering or schedule for our transactions if we can prove that it's equivalent to one of those serial orderings that might exist.
Vì thế ta muốn xác định rằng ta có một thứ tự đúng hay lịch biểu đúng cho các transaction nếu ta có thể chứng minh nó tương đương với một trong những thứ tự tuần tự có thể tồn tại đó.
Alright, so what does it mean to be equivalent? What's a serial order or serial schedule? So the serial schedule we already talked about just means that the transactions are executing one after another, right?
Vậy tương đương nghĩa là gì? Thứ tự tuần tự hay lịch biểu tuần tự là gì? Lịch biểu tuần tự mà ta đã nói tới chỉ có nghĩa là các transaction được thực thi lần lượt, cái này xong đến cái kia, đúng không?
And then we're going to say that two schedules of these transactions are equivalent if the end state of the database is going to be the same as if it was, you know, as if it was executed by the other schedule.
Và ta sẽ nói rằng hai lịch biểu của các transaction này là tương đương nếu trạng thái cuối của cơ sở dữ liệu giống như khi nó được thực thi theo lịch biểu kia.
So I can take any arbitrary interleaving of the transactions and then come up with another arbitrary interleaving of the transactions, and if the end state of the database is the same, then we say those two schedules are equivalent.
Tôi có thể lấy một cách đan xen bất kỳ của các transaction rồi tạo ra một cách đan xen bất kỳ khác của các transaction, và nếu trạng thái cuối của cơ sở dữ liệu giống nhau, thì ta nói hai lịch biểu đó tương đương.
Even though the interleaving might be different.
Dù cách đan xen có thể khác nhau.
And then now, I've already said this before, again I'm leaking terms ahead of time, but we're going to say that this notion, that a schedule is serializable if it is doing an interleaving, but the outcome of the database is equivalent to some serial ordering of those transactions.
Và bây giờ, tôi đã nói điều này trước đây, tôi lại nói trước thuật ngữ, nhưng ta sẽ gọi khái niệm này là một lịch biểu là khả tuần tự hóa nếu nó thực hiện đan xen, nhưng kết quả của cơ sở dữ liệu tương đương với một thứ tự tuần tự nào đó của các transaction ấy.
So this is, again, not as intuitive maybe as you understand computing and transactions and other areas, right?
Cái này, một lần nữa, có thể không trực quan bằng cách bạn hiểu về tính toán và transaction hay các lĩnh vực khác, đúng không?
But the reason why we're going to allow this interleaving to occur, and we only care about is it equivalent to any possible ordering or serial ordering, is that it gives the database more freedom to identify more opportunities for parallelism to get better performance.
Nhưng lý do ta cho phép sự đan xen này xảy ra, và ta chỉ quan tâm liệu nó có tương đương với một thứ tự khả dĩ nào đó hay thứ tự tuần tự nào không, là vì nó cho cơ sở dữ liệu nhiều tự do hơn để nhận ra thêm cơ hội song song hóa nhằm đạt hiệu năng tốt hơn.
If I can only execute transactions in exactly the same order that you submit them without interleaving things, then I'm ending up with a single threaded queue that we said before.
Nếu tôi chỉ có thể thực thi các giao dịch đúng theo thứ tự mà bạn gửi chúng, không xen kẽ gì cả, thì cuối cùng tôi chỉ có một hàng đợi đơn luồng như đã nói trước đó.
But if I can interleave them and have different notions of correctness, then that's okay, and that makes our lives a lot easier.
Nhưng nếu tôi có thể xen kẽ chúng và có những khái niệm đúng đắn khác nhau, thì không sao cả, và điều đó giúp công việc của chúng ta dễ hơn nhiều.
Alright, so now we're going to say, how do we identify whether it's actually equivalent or not?
Được rồi, bây giờ chúng ta sẽ đặt câu hỏi, làm sao xác định được nó có thực sự tương đương hay không?
And I'll say what we're going to talk about here is, in this world we're assuming that the database is fixed size and we have objects all ahead of time, and we're going to assume that we have all of the operations that each transaction wants to do ahead of time.
Tôi nói trước là điều chúng ta sẽ bàn ở đây là, trong thế giới này ta giả định cơ sở dữ liệu có kích thước cố định và ta có sẵn tất cả các đối tượng từ trước, và ta cũng giả định rằng ta có sẵn tất cả các thao tác mà mỗi giao dịch muốn thực hiện từ trước.
In most systems you don't have that, right?
Trong hầu hết các hệ thống thì không có điều đó, đúng không?
Most systems, you know, are not fixed size, they're not immutable, so you can't allow inserts and deletes, but also most systems don't have all the schedules of the transactions ahead of time.
Hầu hết các hệ thống đều không có kích thước cố định, không bất biến, nên bạn không thể cho phép insert và delete, mà hầu hết các hệ thống cũng không có sẵn toàn bộ lịch thực thi của các giao dịch từ trước.
So that's what the next class will be: how do I handle the case where transactions are submitting queries and I don't know what the next query is going to be?
Vì vậy đó sẽ là nội dung của buổi sau: xử lý thế nào trong trường hợp các giao dịch gửi truy vấn đến và tôi không biết truy vấn tiếp theo sẽ là gì?
For this class here, we're assuming that we have things ahead of time, so we have to understand what does it mean for transactions to have conflicting operations in their schedules.
Với buổi này, ta giả định là có mọi thứ từ trước, nên ta phải hiểu việc các giao dịch có các thao tác xung đột trong lịch của chúng nghĩa là gì.
So we're going to find a conflict to occur if there's two operations that are in two separate transactions, and they're trying to do something on the same object, and at least one of them is going to be a write operation.
Ta nói xung đột xảy ra nếu có hai thao tác thuộc hai giao dịch riêng biệt, cùng cố làm gì đó trên cùng một đối tượng, và ít nhất một trong chúng là thao tác ghi.
So the things we're trying to avoid are now called anomalies. These are the problems that can occur if you're not executing things in serial ordering.
Những thứ ta cố tránh bây giờ được gọi là anomaly (dị thường). Đây là những vấn đề có thể xảy ra nếu bạn không thực thi theo thứ tự tuần tự.
So we're going to identify the anomalies that can occur so that when we start interleaving transactions we avoid these problems, because if we have one of these problems then we know that it's actually not going to be equivalent to a serial ordering and therefore our schedule is not serializable.
Ta sẽ xác định các anomaly có thể xảy ra để khi bắt đầu xen kẽ các giao dịch, ta tránh được những vấn đề này, vì nếu gặp một trong các vấn đề này thì ta biết rằng nó thực ra không tương đương với một thứ tự tuần tự và do đó lịch của ta không khả tuần tự hóa.
So we're going to go through the three basic ones today: write-read, I'm sorry, read-write, write-read, and write-write. Why no read-read conflicts? Because who cares if you and I read the same thing?
Hôm nay ta sẽ đi qua ba loại cơ bản: write-read, xin lỗi, read-write, write-read và write-write. Tại sao không có xung đột read-read? Vì ai quan tâm nếu bạn và tôi cùng đọc một thứ?
Who cares? Right? There's actually two other anomalies that we're not going to talk about today, but we'll cover in upcoming weeks, called phantom reads and write skew. Phantom reads is when you do scans.
Ai quan tâm chứ? Đúng không? Thực ra còn hai anomaly khác mà hôm nay ta sẽ không bàn, nhưng sẽ học trong những tuần tới, là phantom read và write skew. Phantom read xảy ra khi bạn thực hiện quét.
If I scan a range of data and then someone inserts something or deletes something within that range, and I do that scan again and now the thing I saw before is gone, and now I get an incorrect aggregation or whatever I'm trying to compute, that's called a phantom.
Nếu tôi quét một khoảng dữ liệu rồi có người khác chèn hoặc xóa thứ gì đó trong khoảng đó, và tôi quét lại lần nữa thì thứ tôi thấy trước đó đã biến mất, và giờ tôi nhận được kết quả tổng hợp sai hoặc bất cứ thứ gì tôi đang tính, thì đó gọi là phantom.
Again, we'll cover that next class, how to handle that. And there's another anomaly called write skew. This one's a bit more complicated, this one we do multiversioning.
Một lần nữa, buổi sau ta sẽ học cách xử lý vấn đề đó. Và còn một dị thường khác gọi là write skew. Cái này phức tạp hơn một chút, và ở đây chúng ta dùng đa phiên bản (multiversioning).
This is if two transactions are trying to update the same database at the same time and they want to read what's in there and then update again, like an aggregation or something else.
Đó là khi hai giao dịch cố cập nhật cùng một cơ sở dữ liệu vào cùng một lúc và chúng muốn đọc những gì đang có trong đó rồi mới cập nhật, chẳng hạn như một phép tổng hợp hay thứ gì đó khác.
They may end up reading the same database state, but they end up having conflicting writes. It's not exactly the same as write-write.
Chúng có thể đọc cùng một trạng thái của cơ sở dữ liệu, nhưng rốt cuộc lại ghi xung đột nhau. Nó không hoàn toàn giống với write-write.
Skew again, It's a bit more nuanced; we'll cover this when we talk about multiversioning in a few more lectures. But as I'm pointing out, there's more stuff here other than these three here.
Skew thì tinh tế hơn một chút; chúng ta sẽ nói về nó khi bàn đến multiversioning trong vài bài giảng nữa. Nhưng điều tôi muốn nói là còn nhiều thứ khác ngoài ba loại này.
Alright, first one is read-write conflict; we'll also call it unrepeatable reads.
Được rồi, loại đầu tiên là xung đột đọc-ghi; chúng ta cũng gọi là unrepeatable reads.
The basic idea here is that I'm trying to read something from the database in my transaction, and then when I try to read it again in that same transaction, I get a different result.
Ý tưởng cơ bản là tôi cố đọc một thứ từ cơ sở dữ liệu trong giao dịch của mình, rồi khi đọc lại nó trong cùng giao dịch đó, tôi nhận được một kết quả khác.
So transaction T1 starts, it reads $10 from object A, then now T2 starts, it reads $10 from A, but then it writes back $19, then it goes and commits, and then now T1 starts again, and when it reads A, it gets back $19.
Giao dịch T1 bắt đầu, nó đọc được $10 từ đối tượng A, rồi T2 bắt đầu, nó đọc được $10 từ A, nhưng sau đó ghi lại $19, rồi nó commit, và sau đó T1 chạy tiếp, và khi đọc A, nó nhận về $19.
Right? If I was executing these transactions in serial ordering, this could not occur. The first transaction would read $10 from A.
Đúng không? Nếu tôi thực thi các giao dịch này theo thứ tự tuần tự, điều này không thể xảy ra. Giao dịch đầu tiên sẽ đọc $10 từ A.
When it reads A again, if it was running all by itself in serial ordering, then it should see $10 again, not $19. So we have to make sure we don't have this conflict.
Khi nó đọc A lần nữa, nếu nó chạy một mình theo thứ tự tuần tự, thì nó phải thấy $10 một lần nữa, chứ không phải $19. Vì vậy chúng ta phải đảm bảo không có xung đột này.
The next one is write-read conflicts, also called dirty reads.
Loại tiếp theo là xung đột ghi-đọc, còn gọi là dirty reads.
So T1 starts, it does a read on A, then it writes A back as $12, but then now T2 reads A and gets the update that T1 made, so it sees the $12 that T1 put in, so then it writes back, I don't know, $14.
T1 bắt đầu, đọc A, rồi ghi A lại là $12, nhưng sau đó T2 đọc A và nhận được bản cập nhật mà T1 đã thực hiện, nên nó thấy $12 mà T1 đưa vào, rồi nó ghi lại, giả sử là $14.
Right? But then T1 aborts and rolls back, but T2 has already committed.
Đúng không? Nhưng sau đó T1 hủy và rollback, trong khi T2 đã commit rồi.
Again, when you go commit, you're telling the outside world all the changes you made, they've all been applied, but again, if we were executing in serial order, this couldn't occur, because T2 should not see the update, should not be able to read the update that T1 made, because T1 has not committed yet.
Một lần nữa, khi bạn commit, bạn đang báo cho thế giới bên ngoài biết mọi thay đổi bạn đã làm, rằng tất cả đều đã được áp dụng, nhưng nếu thực thi theo thứ tự tuần tự thì điều này không thể xảy ra, vì T2 không được thấy bản cập nhật đó, không được phép đọc bản cập nhật mà T1 đã thực hiện, bởi T1 vẫn chưa commit.
So we have to avoid this kind of conflict.
Vì vậy chúng ta phải tránh loại xung đột này.
So the question is, why is this a conflict? Or what's the issue?
Câu hỏi là, tại sao đây là một xung đột? Hay vấn đề ở đây là gì?
The Statement is, like, if there's high-level semantics about what the reads and writes actually are, would this avoid this problem?
Cái phát biểu là, kiểu như, nếu có ngữ nghĩa ở mức cao về việc các thao tác đọc và ghi thực sự là gì, thì liệu điều đó có tránh được vấn đề này không?
A few more slides, we'll get there. Yes. But in this, assuming it's, like, again, all they need to know is reads and writes.
Vài slide nữa chúng ta sẽ tới đó. Vâng. Nhưng ở đây, giả sử là, một lần nữa, tất cả những gì chúng cần biết chỉ là đọc và ghi.
So I've read A, and the same on the application code there says, if my balance is more than $10, then go put $2 in or something like that.
Vậy tôi đã đọc A, và mã ứng dụng ở đó cũng nói rằng, nếu số dư của tôi nhiều hơn $10, thì hãy nạp thêm $2 hoặc đại loại như vậy.
Right? So it read something from a transaction that had not committed yet, and if you're executing a serial order, it should not be able to see that change.
Đúng không? Vậy nó đã đọc một thứ từ một giao dịch chưa commit. và nếu bạn thực thi theo thứ tự tuần tự, thì nó không được phép nhìn thấy thay đổi đó.
That's what we care about. Yes.
Đó là điều chúng ta quan tâm. Vâng, mời bạn.
The statement is, am I claiming that a transaction should not be able to read an object from the database with an updated change, unless the transaction that made that change has committed?
Câu hỏi là, thầy có đang khẳng định rằng một transaction không được phép đọc một đối tượng trong cơ sở dữ liệu mang giá trị đã được cập nhật, trừ khi transaction thực hiện thay đổi đó đã commit không?
Yes. If they were executing in a serial ordering, yes. Yes.
Đúng. Nếu chúng thực thi theo thứ tự tuần tự thì đúng vậy. Vâng.
The question is, what if a transaction committed in the middle of another transaction?
Câu hỏi là, nếu một transaction commit ở giữa lúc một transaction khác đang chạy thì sao?
Yeah. We just covered that. That's this. That's the first one. Oops, sorry. That's the read-write conflict. So that's exactly what you said.
Vâng. Ta vừa nói đến rồi. Đó là cái này. Là cái đầu tiên. Ôi, xin lỗi. Đó là xung đột đọc-ghi. Đúng như những gì bạn vừa nói.
I read A, I get $10. This guy puts $19 in it. I read it again, I get $19. I shouldn't see that. Alright. Last one is write-write conflicts.
Tôi đọc A, được $10. Transaction kia ghi vào $19. Tôi đọc lại, được $19. Lẽ ra tôi không được thấy điều đó. Được rồi. Cuối cùng là xung đột ghi-ghi.
This is also called lost updates. So I have two objects now, A and B, that I care about. T1 is going to write A, put $10 in.
Nó còn được gọi là lost updates. Giờ tôi có hai đối tượng mà ta quan tâm, A và B. T1 sẽ ghi A, đặt vào $10.
T2 is going to start, doesn't care about what's in A now. Right? It's not reading it, it just writes it. So this is called a blind write.
T2 bắt đầu, không quan tâm hiện giờ A đang chứa gì. Đúng không? Nó không đọc mà chỉ ghi. Cái này gọi là blind write.
So I'm writing into A, putting $19 in, and now I'm going to write B and put Bob in, and then T1 comes along and it puts Alice into B.
Vậy tôi ghi vào A giá trị $19, rồi ghi B giá trị Bob, sau đó T1 chạy tới và ghi Alice vào B.
So my end state of the database in this example here is going to have $19 in A and Alice in B. And that's invalid, right? That's not...
Vậy trạng thái cuối của cơ sở dữ liệu trong ví dụ này sẽ có $19 trong A và Alice trong B. Và điều đó không hợp lệ, đúng không? Không phải...
if it was true serial ordering, it would be either $10 in Alice or $19 in Bob.
nếu là thứ tự tuần tự thật sự thì sẽ là $10 và Alice, hoặc $19 và Bob.
So, you know, we want to avoid this problem. Alright, so this gets a little heavy here, but we'll go through it. I think figuring out conflict serializability is pretty straightforward.
Vì vậy, ta muốn tránh vấn đề này. Được rồi, phần này hơi nặng một chút, nhưng ta sẽ đi qua. Tôi nghĩ việc xác định conflict serializability khá đơn giản.
View serializability is a bit more nuanced. So basically we want to say, alright, so now we have these schedules, we know what these conflicts are that can occur.
View serializability thì tinh tế hơn một chút. Về cơ bản ta muốn nói rằng, giờ ta có các schedule này, và biết những xung đột nào có thể xảy ra.
Right? Annoying phantoms, annoying write skew.
Đúng không? Phantom phiền phức, write skew phiền phức.
So how can we check whether an arbitrary schedule is not going to have any of these things, other than just us looking at them, trying to manually figure them out?
Vậy làm sao kiểm tra một schedule bất kỳ có không dính những vấn đề này, ngoài việc tự nhìn và thử tìm ra bằng tay?
Because that would be laborious to do and it's not scalable. So there's now going to be two different notions of serializability.
Vì làm thế sẽ rất vất vả và không mở rộng được. Vì vậy sẽ có hai khái niệm khác nhau về serializability.
Remember, serializable schedule means that it's equivalent to some serial ordering of our transactions. But now there's other notions of correctness to say something's actually serializable.
Hãy nhớ, serializable schedule nghĩa là nó tương đương với một thứ tự tuần tự nào đó của các transaction. Nhưng giờ có những khái niệm khác về tính đúng đắn để nói rằng một thứ thực sự serializable.
The first one is the most common one, called conflict serializability, and that's just figuring out where you have conflicts between these transactions.
Khái niệm đầu tiên là phổ biến nhất, gọi là conflict serializability, và nó chỉ là tìm xem có xung đột ở đâu giữa các transaction này.
There's another notion called view serializability, which is, if you understand the high level semantics of what the application actually wants to do with the data, which is sort of what he was proposing, where it may be okay that you have conflicts because in the end it doesn't matter.
Một khái niệm khác gọi là view serializability, tức là bạn hiểu ngữ nghĩa ở mức cao về việc ứng dụng thực sự muốn làm gì với dữ liệu, đó cũng gần như là điều bạn ấy đề xuất, trong đó có thể chấp nhận có xung đột vì rốt cuộc nó không quan trọng.
So any system that's going to do transactions is going to give you conflicts, and supports serializable transactions or serializable ordering, is going to do conflict serializability, even though they don't call it that, that's implicitly what they mean.
Vì vậy bất kỳ hệ thống nào thực hiện transaction đều sẽ gây ra xung đột, và hỗ trợ transaction serializable hoặc thứ tự serializable, sẽ thực hiện tính khả tuần tự hóa theo xung đột (conflict serializability), dù họ không gọi nó như vậy, nhưng ngầm hiểu thì đó chính là ý nghĩa của nó.
View serializability is a more complicated notion because you need to...
View serializability là một khái niệm phức tạp hơn vì bạn cần...
you need to actually look in the application code or maybe even talk to the human, which is the worst thing to do, to ask them, what does it mean for things to be correct.
bạn cần thực sự xem xét mã của ứng dụng hoặc thậm chí phải trao đổi với con người, điều tệ nhất có thể làm, là đi hỏi họ, rằng thế nào thì được coi là đúng đắn.
There's even other notions of correctness and serializability that we're not going to cover in this class, and there's a whole sort of event diagram we'll cover, but this conflict serializability is the main one.
Còn có những khái niệm khác về tính đúng đắn và tính khả tuần tự hóa mà chúng ta sẽ không đề cập trong lớp này, và có cả một dạng sơ đồ sự kiện mà chúng ta sẽ học, nhưng conflict serializability mới là khái niệm chính.
View serializability I'll show briefly, because again you'll see how to handle the one case that he brought up.
View serializability thì tôi sẽ trình bày ngắn gọn, vì một lần nữa bạn sẽ thấy cách xử lý trường hợp mà bạn ấy đã nêu.
All right, so now I'm going to say that two schedules are conflict equivalent if and only if they are going to involve the same operations on the same transactions, right, and we're going to be able to identify that the ordering of those operations on those objects will occur in the same way.
Được rồi, bây giờ tôi sẽ nói rằng hai lịch biểu là tương đương xung đột nếu và chỉ nếu chúng liên quan đến cùng các thao tác trên cùng các giao dịch, đúng không, và chúng ta có thể xác định được rằng thứ tự của các thao tác đó trên các đối tượng đó sẽ diễn ra giống nhau.
So now we're going to say that a schedule is conflict serializable if it's conflict equivalent to some serial schedule that puts the database in the same state.
Vậy bây giờ ta nói một lịch biểu là khả tuần tự hóa theo xung đột nếu nó tương đương xung đột với một lịch biểu tuần tự nào đó đưa cơ sở dữ liệu về cùng một trạng thái.
So me standing up here and looking at text and being hand wavy doesn't help, so let's look at how we actually compute this in the real world.
Việc tôi đứng đây nhìn chữ và nói chung chung thì chẳng giúp ích gì, nên hãy xem thực tế ta tính điều này như thế nào.
So we're going to compute what's called a dependency graph.
Chúng ta sẽ tính cái gọi là đồ thị phụ thuộc (dependency graph).
I think Wikipedia might call them a precedence graph, they're all the same thing, but now we're basically going to have a node in this graph for every single transaction that we have running in a schedule, and then we'll have an edge between those two nodes if there's an operation that is in one transaction that conflicts with another operation on another transaction, and the other operation occurs later in the schedule.
Tôi nghĩ Wikipedia có thể gọi nó là đồ thị thứ tự trước (precedence graph), chúng đều là một thứ cả, nhưng giờ về cơ bản ta sẽ có một nút trong đồ thị này cho mỗi giao dịch đang chạy trong một lịch biểu, và ta sẽ có một cạnh giữa hai nút đó nếu có một thao tác nằm trong một giao dịch xung đột với một thao tác khác trong giao dịch khác, và thao tác kia xảy ra muộn hơn trong lịch biểu.
So the thing we care about: if we end up with a graph that has no cycles, then we know that our graph is conflict serializable and therefore it's equivalent to some serial ordering.
Điều ta quan tâm là: nếu đồ thị của ta không có chu trình nào, thì ta biết lịch biểu đó khả tuần tự hóa theo xung đột và do đó nó tương đương với một thứ tự tuần tự nào đó.
If we have a cycle, then we know that it's not serializable. So we go to an example here.
Nếu có chu trình, thì ta biết nó không khả tuần tự hóa. Hãy xem một ví dụ ở đây.
So T1 is going to read A, write A, read B, and write B, and T2 is going to do the exact same thing.
T1 sẽ đọc A, ghi A, đọc B, và ghi B, còn T2 cũng làm y hệt như vậy.
So in the first case here, we have a write on A that occurs before a read, the read on A in T2.
Trong trường hợp đầu tiên ở đây, ta có một thao tác ghi A xảy ra trước một thao tác đọc, tức đọc A trong T2.
Therefore, I'll have an edge from T1 to T2 that corresponds to this conflict here. Right? Likewise, I would have a write on B followed by a read on B, right?
Do đó, tôi sẽ có một cạnh từ T1 đến T2 tương ứng với xung đột này. Đúng không? Tương tự, tôi có một thao tác ghi B rồi đến đọc B, đúng không?
So therefore I have an edge going the other direction. So now I don't have a cycle in my dependency graph, and therefore I know I have this thing's not conflict serializable.
Vì vậy tôi có một cạnh đi theo hướng ngược lại. Vậy bây giờ tôi không có chu trình nào trong đồ thị phụ thuộc, và do đó tôi biết lịch biểu này không... à, nó khả tuần tự hóa theo xung đột.
I'm not showing there's a write on A and a write on A.
Tôi chưa vẽ trường hợp ghi A rồi lại ghi A.
That would be another conflict that would just be a redundant edge between T1 and T2, and same for the write on B and the write, the two writes on B's.
Đó sẽ là một xung đột nữa, nhưng chỉ là một cạnh thừa giữa T1 và T2, và tương tự với ghi B và ghi B, hai thao tác ghi trên B.
So again, the issue here is that the cycle in the graph basically is telling us there's a dependency between modifications that are being made by one transaction and the read, write, read or write operations in another transaction, and that they shouldn't be able to see those changes, or all the changes should go in one direction
Vậy một lần nữa, vấn đề ở đây là chu trình trong đồ thị về cơ bản cho ta biết có một sự phụ thuộc giữa các thay đổi do một giao dịch thực hiện và các thao tác đọc, ghi, đọc hoặc ghi trong một giao dịch khác, và rằng chúng không nên nhìn thấy những thay đổi đó, hoặc tất cả các thay đổi phải đi theo một hướng
and not have cycles going back to the other direction. We can expand this out now for three transactions. So same thing, we're doing reads on A and writes on A across T1, T2, T3.
và không có chu trình quay ngược về hướng còn lại. Bây giờ ta có thể mở rộng ra cho ba giao dịch. Vẫn như vậy, ta thực hiện các thao tác đọc A và ghi A trên T1, T2, T3.
So we start off with a read on A that has a conflict with the write on A.
Ta bắt đầu với một thao tác đọc A xung đột với thao tác ghi A.
Read on A and T1 has a conflict with the write on A and T3, so we have an edge from T1 to T3, and we have this write on A to a read on A between T1 and T3 again, so we just have another edge there.
Đọc A trong T1 xung đột với ghi A trong T3, nên ta có một cạnh từ T1 đến T3, và ta lại có một thao tác ghi A rồi đọc A giữa T1 và T3, nên ở đó chỉ có thêm một cạnh nữa.
Then the write on A and the write on A between T1, T2, T3, again another edge.
Rồi ghi A và ghi A giữa T1, T2, T3, lại thêm một cạnh.
Now we have this write on B to a read on B between T2 and T3, so we have an edge in this direction.
Tiếp theo ta có thao tác ghi B rồi đọc B giữa T2 và T3, nên ta có một cạnh theo hướng này.
And then we have, again, the write on B and the read on B, the write on B and the write on B between T2 and T3, actually T2 and T1, so we have the same edge.
Và rồi, một lần nữa, ghi B và đọc B, ghi B và ghi B giữa T2 và T3, à thực ra là T2 và T1, nên ta có cùng một cạnh.
So in this case here, because we have no cycles, we can say that this is conflict, this is equivalent to a serial execution of executing T2 followed by T1 followed by T3, even though T1 called begin first before T2, right?
Vậy trong trường hợp này, vì không có chu trình nào, ta có thể nói đây là xung đột, tức là tương đương với một lịch thực thi tuần tự chạy T2, rồi đến T1, rồi đến T3, dù T1 gọi begin trước T2, đúng không?
The end state of the database will be equivalent to T2 actually running first, followed by T1, followed by T3, and that's okay, right? T3 actually even commits before T1 does, right?
Trạng thái cuối của cơ sở dữ liệu sẽ tương đương với việc T2 thực sự chạy trước, tiếp theo là T1, rồi đến T3, và điều đó không sao cả, đúng không? Thậm chí T3 còn commit trước T1, đúng không?
But we're saying that T3 occurs, in this logical view of the ordering of transactions, occurs after T1 commits, even though physically it did not, and that's okay.
Nhưng ta nói rằng T3 xảy ra, trong cách nhìn logic về thứ tự các giao dịch này, sau khi T1 commit, dù trên thực tế vật lý thì không, và điều đó không sao.
Does that make sense? Pretty cool, huh? Alright, so let's look at another one.
Các em hiểu chứ? Khá hay đúng không? Được rồi, ta xem một ví dụ khác.
So now, again, we have T1 doing the read on A, write on A, read on B, and write on B, and now I'm including the application logic.
Bây giờ, một lần nữa, T1 thực hiện đọc A, ghi A, đọc B, và ghi B, và lần này tôi đưa cả logic ứng dụng vào.
Instead of having A automatically update the database, I'm having the procedural code you would have in your application to, like, take A, take $10 out, and then transfer the $10 into B's account, right?
Thay vì để A tự động cập nhật cơ sở dữ liệu, tôi dùng mã thủ tục mà các em sẽ có trong ứng dụng để, chẳng hạn, lấy từ A ra $10, rồi chuyển $10 đó vào tài khoản của B, đúng không?
And obviously you have to read the account in order to know what the value to put into it.
Và hiển nhiên là các em phải đọc tài khoản để biết giá trị cần ghi vào đó.
And then now you see also in T2 I'm computing some kind of sum, which is adding up all the money that's in accounts A and B, and then I have this little return sum thing here.
Và bây giờ các em cũng thấy trong T2 tôi tính một dạng tổng nào đó, là cộng tất cả số tiền có trong các tài khoản A và B, rồi tôi có dòng return sum nhỏ ở đây.
This is actually not valid SQL, I'm just trying to show you that after the transaction commits you would report back whatever the sum is to whoever asked for it.
Cái này thực ra không phải SQL hợp lệ, tôi chỉ muốn cho các em thấy rằng sau khi giao dịch commit thì các em sẽ báo lại tổng đó cho bất cứ ai đã yêu cầu.
So in this case here, T1 does a write on A, that's going to have a conflict with the read on A in T2, so therefore we have an edge from T1 to T2.
Vậy trong trường hợp này, T1 thực hiện ghi A, điều này sẽ xung đột với thao tác đọc A trong T2, do đó ta có một cạnh từ T1 đến T2.
But then later on I have a read on B followed by the write on B, so T2 to T1. So then I have another edge going the other direction.
Nhưng sau đó tôi có thao tác đọc B rồi đến ghi B, nên có cạnh từ T2 đến T1. Vậy là tôi có thêm một cạnh theo chiều ngược lại.
So at this point here, we know that it's, again, it's not conflict serializable because we have a cycle.
Đến đây, chúng ta biết rằng lịch này một lần nữa là không khả tuần tự hóa xung đột, vì có một chu trình.
But can we modify the application logic in T2 where we don't actually care about what the values actually are and then still produce the same correct result, even though we have a conflict or have a cycle in our graph?
Nhưng liệu chúng ta có thể sửa logic ứng dụng trong T2 sao cho chúng ta không thực sự quan tâm giá trị cụ thể là gì, và vẫn cho ra cùng một kết quả đúng, dù trong đồ thị có xung đột, tức là có chu trình?
So if I change from getting the total amount that I have in my bank accounts to just counting the number of bank accounts that have zero dollars or more, and the only thing I care about is reporting that count rather than the actual total amount that's in the bank accounts, then this actually would be correct if I order them in this way,
Giả sử tôi đổi từ việc lấy tổng số tiền có trong các tài khoản ngân hàng sang việc chỉ đếm số tài khoản có từ không đô la trở lên, và điều duy nhất tôi quan tâm là báo cáo con số đếm đó chứ không phải tổng số tiền thực sự trong các tài khoản, thì khi đó nếu tôi sắp xếp theo cách này, kết quả thực sự vẫn đúng,
right? So again, this is going back to that same board.
đúng không? Vậy là, một lần nữa, quay lại cái bảng ban nãy.
If you understand what the application actually cares about, some higher-level semantics, where for this application or this transaction I don't care about the total amount, I just care about counting the number of accounts, then if you have an interleaving like this, it's still considered correct.
Nếu bạn hiểu ứng dụng thực sự quan tâm đến điều gì, tức là một ngữ nghĩa ở mức cao hơn, trong đó với ứng dụng này hoặc giao dịch này, tôi không quan tâm tổng số tiền, tôi chỉ quan tâm việc đếm số tài khoản, thì nếu có một cách đan xen như thế này, nó vẫn được coi là đúng.
So this is what view serializability is. It's a broader, more relaxed notion of correctness than conflict serializability, but it requires you to understand what the hell the application actually wants.
Đó chính là khả tuần tự hóa theo view. Đây là một khái niệm về tính đúng đắn rộng hơn, lỏng hơn so với khả tuần tự hóa xung đột, nhưng nó đòi hỏi bạn phải hiểu ứng dụng thực sự muốn cái quái gì.
And again, if you either have to examine application code, which is, that's a nightmare, or you can talk to a human, ask them what they actually mean, and that's the worst of the worst, because people don't know what the hell I'm talking about.
Và một lần nữa, bạn hoặc phải xem xét mã ứng dụng, việc đó là một cơn ác mộng, hoặc phải nói chuyện với một con người, hỏi họ thực sự muốn nói gì, mà đó là điều tệ nhất trong những điều tệ, vì người ta không hiểu tôi đang nói cái quái gì.
So that's why no system can actually do this. Okay, so rather than going through the more formal semantics, let's look at another example. So here I have two transactions, T2, T3, T1, T2, T3.
Vì vậy không có hệ thống nào thực sự làm được điều này. Được rồi, thay vì đi vào ngữ nghĩa hình thức hơn, chúng ta hãy xem một ví dụ khác. Ở đây tôi có ba giao dịch: T1, T2, T3.
So T1 is going to read on A and then write on A, and then T2 and T3 are just doing, again, blind writes on A.
T1 sẽ đọc A rồi ghi A, còn T2 và T3 chỉ thực hiện, một lần nữa, các thao tác ghi mù trên A.
Doesn't read the values, just overwrites whatever is in there.
Không đọc giá trị, chỉ ghi đè lên bất cứ thứ gì đang có ở đó.
So if I go through and generate my dependency graph using what we talked about before, right, you end up seeing that it sort of looks like this, and clearly we have a cycle between T1 and T2.
Nếu tôi lần lượt xây dựng đồ thị phụ thuộc theo những gì ta đã nói trước đó, bạn sẽ thấy nó trông như thế này, và rõ ràng có một chu trình giữa T1 và T2.
So in this case here, this is not conflict serializable, because, again, there's a dependency between T2, like T1 is reading A, T2 is then writing it, and then T1 is overwriting it.
Vậy trong trường hợp này, lịch này không khả tuần tự hóa xung đột, vì, một lần nữa, có một phụ thuộc giữa T2 và T1: T1 đọc A, rồi T2 ghi A, và sau đó T1 ghi đè lên nó.
As again, but if you look at the transaction, who cares actually what happens, you know, while the transactions are running in this schedule here.
Nhưng nếu bạn nhìn vào các giao dịch, thật ra ai quan tâm chuyện gì xảy ra trong lúc các giao dịch chạy theo lịch này.
The only thing I care about is that T3 writes whatever was in A last. It does that blind write.
Điều duy nhất tôi quan tâm là T3 ghi giá trị cuối cùng vào A. Nó thực hiện phép ghi mù đó.
So in this example here, this ordering is not conflict serializable, but it is actually view serializable, because it's equivalent to a serial ordering like this, where I don't care that, you know, that T2 overwrote something on A and then T1 overwrote that, you know, that wouldn't have happened if I was doing serial ordering.
Vậy trong ví dụ này, thứ tự này không khả tuần tự hóa xung đột, nhưng thực ra nó là view serializable, vì nó tương đương với một thứ tự tuần tự như thế này, trong đó tôi không quan tâm việc, T2 đã ghi đè lên A rồi T1 lại ghi đè lên đó, điều đó sẽ không xảy ra nếu tôi thực hiện theo thứ tự tuần tự.
But if my end state of the database, the only thing I care about is that A is written last by T3, and that's all that's all I care about.
Nhưng nếu xét trạng thái cuối của cơ sở dữ liệu, thì điều duy nhất tôi quan tâm là A được T3 ghi sau cùng, và đó là tất cả những gì tôi quan tâm.
So the main takeaway from all this is that view serializability is gonna allow for slightly more schedules than you would have with conflict serializability, but because you have to understand, you know, what the application actually wants to do with the data and what does it mean for things to be correct or consistent, then you can't, you can't do this.
Vậy điều rút ra chính từ đây là view serializability sẽ cho phép nhiều lịch biểu hơn một chút so với conflict serializability, nhưng vì bạn phải hiểu được ứng dụng thực sự muốn làm gì với dữ liệu và thế nào là đúng đắn hay nhất quán, nên bạn không thể làm điều này.
So that means that if we're gonna use conflict serializability as the sort of the standard in which we determine whether an ordering is correct or not, there may be some cases where We could have more parallel interleavings of our transactions, but we can't, because we just don't know what is actually going on up above in the application stack.
Điều đó có nghĩa là nếu ta dùng conflict serializability làm chuẩn để xác định một thứ tự có đúng hay không, thì có thể sẽ có những trường hợp mà ta có thể xen kẽ song song nhiều hơn các giao dịch, nhưng ta không thể, vì ta đơn giản là không biết thực sự đang diễn ra điều gì ở tầng ứng dụng phía trên.
The question is, why can't I expand conflict serializability in my implementation of the database system to allow for this? Because in most systems you don't have the transactions all ahead of time.
Câu hỏi là, tại sao tôi không mở rộng conflict serializability trong phần cài đặt hệ cơ sở dữ liệu của mình để cho phép điều này? Vì trong hầu hết các hệ thống, bạn không có sẵn tất cả giao dịch từ trước.
So it would sort of be like this: I would see, like, T1 would start, and then T2 arrives, wants to start something, and then T3 later arrives, wants to start something, right?
Nên nó sẽ giống như thế này: tôi thấy T1 bắt đầu, rồi T2 đến, muốn bắt đầu làm gì đó, rồi sau đó T3 đến, cũng muốn bắt đầu làm gì đó, đúng không?
And I don't know, in the case of, like, T3, is it gonna now do more things after that write on it? Some systems you can do that, right?
Và tôi không biết, trong trường hợp T3, liệu sau lần ghi đó nó có làm thêm việc gì nữa không? Ở một số hệ thống thì bạn làm được điều đó, đúng không?
And so in the case of the blind write, one sometimes you could get away with this, but my example of, like, if I'm just summing things up, rather counting things rather than summing them, I may not be able to do that.
Và với blind write, đôi khi bạn có thể xoay xở được, nhưng ví dụ của tôi, chẳng hạn nếu tôi chỉ cộng dồn các giá trị, hay đúng hơn là đếm chứ không phải cộng, thì tôi có thể không làm được.
So we're getting ahead of ourselves. So Amazon DB, there was a system called Fauna that went bankrupt this year.
Vậy là ta đang đi trước hơi xa. Amazon DB, và có một hệ thống tên Fauna đã phá sản trong năm nay.
There's some systems that do what we call deterministic scheduling, where in the case of Amazon DB, your application starts a transaction, it does a bunch of reads and writes but doesn't actually apply any of the changes to the database, and then when you go commit, then it actually goes back and replays the transaction and sees whether it gets the same results as it did when it sort of ran in pretend mode.
Có một số hệ thống làm cái mà ta gọi là lập lịch tất định, trong đó với Amazon DB, ứng dụng của bạn bắt đầu một giao dịch, nó thực hiện một loạt đọc và ghi nhưng thực ra không áp dụng thay đổi nào vào cơ sở dữ liệu, và rồi khi bạn commit, nó mới quay lại chạy lại giao dịch và xem liệu nó có cho ra cùng kết quả như lúc chạy ở chế độ giả lập hay không.
And if it does, then it's going to allow it to commit. And now, if you have your schedule, now you can reorder things and do stuff like this.
Và nếu có, thì nó sẽ cho phép commit. Và bây giờ, nếu bạn có lịch biểu của mình, bạn có thể sắp xếp lại thứ tự và làm những việc như thế này.
The same as, is it like a copy-on-write approach?
Có giống như cách tiếp cận copy-on-write không?
Uh Not even that, just like I run it but don't apply any changes without making a copy, and then just run it again and see whether I get the same result.
Ừm, thậm chí không phải vậy, chỉ là tôi chạy nó nhưng không áp dụng thay đổi nào và cũng không tạo bản sao, rồi chạy lại một lần nữa và xem có cho ra cùng kết quả không.
If no, if yes, then I know I didn't have any conflicts.
Nếu không, à nếu có, thì tôi biết là mình không gặp xung đột nào.
The question is, can you have rule-based serializability? What do you mean by rule-based?
Câu hỏi là: liệu có thể có khả năng tuần tự hóa dựa trên luật không? Ý em về "dựa trên luật" là gì?
Yeah, transactions are...
Vâng, các giao dịch...
so the statement is, could I programmatically tell the data system it's okay for me for me to have certain interleavings? Yes, no system actually supports that as far as I know.
vậy ý của câu hỏi là, liệu tôi có thể chủ động nói với hệ quản trị dữ liệu bằng chương trình rằng tôi chấp nhận một số cách đan xen nhất định không? Có, nhưng theo tôi biết thì không hệ thống nào thực sự hỗ trợ điều đó.
You do this at a high level, at the application level. So you would do this. Let me give an example. So, uh, there's high-level notions of transactions.
Bạn làm việc này ở mức cao, ở tầng ứng dụng. Nên bạn sẽ làm như vậy. Để tôi lấy một ví dụ. Có những khái niệm giao dịch ở mức cao.
One would be like, say I'm trying to sell tickets to, uh, Taylor Swift concert.
Chẳng hạn, giả sử tôi đang bán vé cho buổi hòa nhạc của Taylor Swift.
And actually, the Taylor Swift concert was, it last year, whatever, whoever made this tour, the database crashed because they didn't do any of this, right?
Thực ra, buổi hòa nhạc của Taylor Swift năm ngoái, mà thôi, ai tổ chức chuyến lưu diễn này cũng vậy, cơ sở dữ liệu đã bị sập vì họ không làm gì trong số này, đúng không?
But the way, because everyone's trying to update the same database and try to buy seats at the same time, so it crashed.
Vì mọi người đều cố cập nhật cùng một cơ sở dữ liệu và cố mua ghế cùng một lúc, nên nó sập.
So the way to handle this would be, if I know I have like East Coast people and West Coast people, and I don't have to communicate between each one, because that's like I got to go across the country and that's slow, how do I make, how do I allow them to update things at the same time?
Vậy cách xử lý sẽ là, nếu tôi biết có người ở Bờ Đông và người ở Bờ Tây, và tôi không cần liên lạc giữa hai bên, vì như thế phải đi xuyên nước Mỹ và rất chậm, thì làm sao để cho phép họ cập nhật cùng một lúc?
You can do what's called escrow transactions.
Bạn có thể dùng cái gọi là escrow transactions.
You can say, say I'm trying to sell, you know, sell items, like I'm trying to sell Taylor Swift, Taylor Swift tickets, and ignore seats because that's hard, right?
Giả sử tôi đang bán các mặt hàng, chẳng hạn bán vé Taylor Swift, và bỏ qua chuyện chỗ ngồi vì nó phức tạp, đúng không?
Say I'm just trying, I have a fixed number of seats. How do I make sure that I don't sell more than I actually do have? So you just basically do what's called escrow transactions.
Giả sử tôi có một số lượng ghế cố định. Làm sao để đảm bảo tôi không bán nhiều hơn số ghế thực có? Về cơ bản bạn dùng cái gọi là escrow transactions.
You say, alright, East Coast, you get, you get 50 seats, West Coast gets 50 seats, and only coordinate when you run out and need to get the next 50 seats.
Bạn nói: được rồi, Bờ Đông được 50 ghế, Bờ Tây được 50 ghế, và chỉ phối hợp với nhau khi hết ghế và cần lấy 50 ghế tiếp theo.
So there's High-level things you can do to handle all these cases, but no system supports that natively.
Vậy có những việc ở mức cao bạn có thể làm để xử lý các trường hợp này, nhưng không hệ thống nào hỗ trợ sẵn.
If you start doing stored procedures, where I have procedural code, like a function that has all the transaction logic directly inside the database system, then you can start doing some of these tricks.
Nếu bạn bắt đầu dùng stored procedure, nơi tôi có mã thủ tục, như một hàm chứa toàn bộ logic giao dịch ngay bên trong hệ quản trị cơ sở dữ liệu, thì bạn có thể bắt đầu dùng một số mẹo này.
But no, no database system, as far as I know, looks inside the program logic within the stored procedure to figure out what the interleaving should be.
Nhưng không, theo tôi biết thì không hệ quản trị cơ sở dữ liệu nào nhìn vào logic chương trình bên trong stored procedure để xác định cách đan xen nên như thế nào.
Alright, alright. Let me just show one last thing before we go. I know we're over time.
Được rồi. Để tôi cho xem một điều cuối cùng trước khi kết thúc. Tôi biết là đã quá giờ.
So the way to think about these scheduling stuff is, think of, like, there's this giant universe of all the possible schedules you could have for a set of transactions, and there's a very small region in the middle that corresponds to the serial orderings.
Cách nghĩ về những chuyện lập lịch này là, hãy hình dung có một vũ trụ khổng lồ gồm tất cả lịch biểu có thể có cho một tập giao dịch, và có một vùng rất nhỏ ở giữa tương ứng với các thứ tự tuần tự.
Alright, we just execute the transactions one after another. And then around that there's a slightly larger region of conflict serializable schedules. You do allow interleavings, again, and then they're equivalent to a serial ordering.
Tức là ta chỉ thực thi các giao dịch lần lượt cái này sau cái kia. Và xung quanh đó có một vùng lớn hơn một chút vùng các lịch biểu conflict serializable. Ở đây người ta lại cho phép đan xen các thao tác, và chúng tương đương với một thứ tự tuần tự.
And around that it's going to be view serializable, because anything that's view serializable, sorry, anything that's a serial ordering is, by definition, has to be view serializable.
Bao quanh vùng đó là view serializable, vì bất cứ thứ gì là view serializable, xin lỗi, bất cứ thứ tự tuần tự nào thì theo định nghĩa đều phải là view serializable.
So around that you have a larger region, and it's hard to figure out how to get into that larger region.
Vì vậy xung quanh đó có một vùng lớn hơn, và rất khó biết cách làm sao để vào được vùng lớn hơn đó.
And we'll see next class there's other regions that span in other directions that can be all schedules, some may be serializable, some may not be.
Và ở buổi sau chúng ta sẽ thấy còn có những vùng khác trải ra theo các hướng khác có thể chứa mọi lịch biểu, một số có thể serializable, một số thì không.
Right, this is awesome stuff, and we'll cover more of this in the next couple classes. Alright, let me just finish up and say durability.
Đúng không, nội dung này thật tuyệt vời, và chúng ta sẽ nói thêm về phần này trong vài buổi tới. Được rồi, để tôi kết thúc bằng tính bền vững (durability).
We talked about this already before: how to make sure that we crash and we come back and we see all our changes and roll back any changes.
Chúng ta đã nói về điều này trước đây: làm sao để khi hệ thống bị sập và khởi động lại, ta vẫn thấy các thay đổi của mình và hoàn tác các thay đổi cần hoàn tác.
And logging and shadow paging is how we're going to do that, right? Alright, so to finish up. This stuff is awesome.
Và ghi nhật ký (logging) cùng shadow paging là cách chúng ta sẽ làm điều đó, đúng không? Được rồi, để kết thúc. Nội dung này thật tuyệt.
Hopefully I'm not getting, like, you know, too excited, but, like, this is super hard to do.
Hy vọng là tôi không quá phấn khích, nhưng điều này cực kỳ khó làm.
This is why all those NoSQL systems that came out, I don't know, 2010, like the Mongos and the Cassandras, all those people didn't do transactions.
Đó là lý do tại sao tất cả các hệ thống NoSQL xuất hiện khoảng năm 2010, chẳng hạn như Mongo và Cassandra, đều không hỗ trợ transaction.
They told you, they told everyone, transactions were a bad idea because it's really hard to do and really hard to get correct.
Họ nói với bạn, nói với mọi người rằng transaction là ý tưởng tồi vì nó thật sự rất khó làm và rất khó làm cho đúng.
And now people realize, oh, transactions are a really important idea, really good, because you don't want your JavaScript programmer writing random, and, you know, coming up with invalid state, right?
Còn giờ người ta nhận ra, ồ, transaction là một ý tưởng rất quan trọng, rất tốt, vì bạn không muốn lập trình viên JavaScript viết bừa, và rồi tạo ra trạng thái không hợp lệ, đúng không?
We'll talk about vector clocks. Like, if you have to, if you have to have people reading about vector clocks, that's terrible. That's, like, they can't do that.
Chúng ta sẽ nói về vector clock. Kiểu như, nếu bạn phải bắt mọi người đọc về vector clock thì thật tệ. Họ không thể làm được điều đó.
So basically there was this big movement in the 2000s, everyone was saying, oh, transactions are a great idea, we should do that.
Về cơ bản đã có một phong trào lớn vào những năm 2000, mọi người nói, ồ, transaction là ý tưởng tuyệt vời, chúng ta nên làm.
Sorry, transactions are a bad idea, we're not going to do that, we're not going to support SQL, we're not going to support the relational model.
Xin lỗi, transaction là ý tưởng tồi, chúng ta sẽ không làm, chúng ta sẽ không hỗ trợ SQL, sẽ không hỗ trợ mô hình quan hệ.
And then they've all come back around, basically, and now support all these things. Can anybody name the one company that was sort of inadvertently pushing this idea that transactions are a bad idea?
Rồi về cơ bản tất cả đều quay lại, và giờ hỗ trợ tất cả những thứ này. Có ai kể tên được công ty duy nhất đã vô tình thúc đẩy ý tưởng rằng transaction là ý tưởng tồi không?
There was one company that was at the forefront of all this in the 2000s. Starts with a G. Google. Google had this system called Bigtable.
Có một công ty đứng đầu xu hướng này vào những năm 2000. Bắt đầu bằng chữ G. Google. Google có hệ thống tên là Bigtable.
In the paper they said, we're not doing transactions, we're not doing SQL, we're not doing relational model.
Trong bài báo họ nói, chúng tôi không làm transaction, không làm SQL, không làm mô hình quan hệ.
Everybody saw that and said, oh, Google's going to make a ton of money, they must know what's going on, let's do the same thing, let's not do transactions.
Mọi người thấy vậy và nói, ồ, Google sẽ kiếm được cả đống tiền, họ chắc chắn biết mình đang làm gì, ta cũng làm vậy thôi, không làm transaction.
And then they've all come back around and said, oh yeah, transactions are a good idea now. Google figured this out too with Spanner. So the Spanner paper came in 2012.
Rồi tất cả lại quay lại và nói, ồ đúng rồi, giờ transaction là ý tưởng tốt. Google cũng nhận ra điều này với Spanner. Bài báo về Spanner ra đời năm 2012.
So meanwhile, while everyone was saying we're not going to do transactions, internally Google's like, oh shit, we need transactions, and eventually added it.
Trong khi đó, lúc mọi người còn nói là chúng ta sẽ không làm giao dịch, thì nội bộ Google lại thấy: ôi trời, mình cần giao dịch, và cuối cùng họ đã bổ sung nó.
If you go read this paper, there's this great little There's this great little blurb right here. Oh, it's disappointing. Ah, all right.
Nếu đọc bài báo này, các em sẽ thấy có một đoạn nhỏ rất hay. Có một đoạn nhỏ rất hay ngay đây. Ôi, thất vọng quá. À, được rồi.
There's this great little blurb, let me just show it without the animations, where they basically admit, oh yeah, not having transactions was a bad idea, because you're better off having your rando programmers, aka JavaScript programmers, ah, not worry about correctness issues.
Có một đoạn nhỏ rất hay, để thầy chiếu lên mà không có hiệu ứng, trong đó họ gần như thừa nhận: ừ, không có giao dịch là một ý tưởng tệ, vì tốt hơn là để mấy lập trình viên bình thường, tức là mấy lập trình viên JavaScript, à, khỏi phải lo về các vấn đề tính đúng đắn.
It's this blurb here, right?
Đoạn này đây, đúng không?
There's this great line: "We believe it's better to have application programmers", JavaScript programmers, "deal with performance problems due to overuse of transactions as the bottlenecks arise, rather than coding around the lack of transactions."
Có một câu rất hay: "Chúng tôi tin rằng tốt hơn là để các lập trình viên ứng dụng", các lập trình viên JavaScript, "xử lý các vấn đề hiệu năng do lạm dụng giao dịch khi các nút thắt cổ chai xuất hiện, thay vì phải viết mã lách quanh việc thiếu giao dịch."
They're basically saying, get, like, Jeff Dean and really smart people, ah, and you pay him a lot of money, make your transactional data system work really, really well, and that way the unwashed masses can take advantage of them and not spend the time reasoning about eventual consistency and other correctness issues.
Về cơ bản họ nói rằng: hãy lấy Jeff Dean và những người thật sự thông minh, à, trả họ thật nhiều tiền, để làm cho hệ thống dữ liệu có giao dịch chạy thật sự thật sự tốt, và như vậy đám đông bình thường có thể tận dụng nó mà không phải tốn thời gian suy luận về tính nhất quán cuối cùng và các vấn đề về tính đúng đắn khác.
Okay.
Được rồi.
All right, next class we'll talk about how we actually do this at runtime with using two-phase locking, and we'll talk about these sort of more relaxed notions of serializability, actually not even call that relaxed notions of correctness, with isolation levels.
Được rồi, buổi sau chúng ta sẽ nói về cách thực sự làm điều này lúc chạy bằng khóa hai pha (two-phase locking), và sẽ nói về những khái niệm nới lỏng hơn của tính khả tuần tự hóa, thật ra không nên gọi đó là các khái niệm nới lỏng về tính đúng đắn, mà là các mức cô lập.
Ah, and then we'll do some demos and see where things go wrong.
À, rồi chúng ta sẽ làm vài bản demo để xem lỗi xảy ra ở đâu.
Okay, I don't know if it's going to work, but go for it, try it, and I'll see you next time.
Được rồi, thầy không biết nó có chạy được không, nhưng cứ thử xem, và hẹn gặp lại các em lần sau.
Bye bye bye bye bye bye bye bye bye.
Tạm biệt các em.
Đă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.