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ả.
Thank you for coming. You were here early. Nobody was here. We got here early. The other class before us wasn't here. So we didn't think there was class.
Cảm ơn các em đã đến. Các em đến sớm đấy. Lúc nãy chẳng có ai ở đây. Bọn em đến sớm. Lớp học trước chúng em không có ở đây. Nên chúng em không nghĩ là có lớp.
But you still set up your DJ equipment. It shows you dedication. It's a craft. I appreciate that. All right, guys. A lot to cover. Unfortunately, we wouldn't have the speaker from Yellow Brick today.
Nhưng em vẫn bày thiết bị DJ ra. Điều đó cho thấy sự tận tâm của em. Đó là một nghề thủ công. Thầy trân trọng điều đó. Được rồi các em. Hôm nay có rất nhiều nội dung cần học. Đáng tiếc là hôm nay chúng ta sẽ không có diễn giả đến từ Yellow Brick.
That got rescheduled due to a scheduling issue. So today is just me, no outside speaker. But it's fine, because there's a lot we want to cover for multi-versioning, because it's a super cool topic.
Buổi đó bị dời lịch do một vấn đề về sắp xếp lịch. Vậy nên hôm nay chỉ có thầy, không có diễn giả bên ngoài. Nhưng không sao, vì có rất nhiều điều chúng ta muốn trình bày về đa phiên bản (multi-versioning), vì đây là một chủ đề cực kỳ thú vị.
And you're going to see this everywhere. All right. So again, for you guys in class, Project 3 is going to be due this Sunday coming up.
Và các em sẽ thấy nó ở khắp nơi. Được rồi. Nhắc lại với các em trong lớp, Project 3 sẽ đến hạn vào Chủ nhật này.
The special office hours will be this Saturday at 3 o'clock in Gates. Homework 5 is going to be due, again, it was extended for another week.
Giờ hỗ trợ đặc biệt sẽ diễn ra vào thứ Bảy này lúc 3 giờ tại Gates. Homework 5 sẽ đến hạn, và như đã nói, hạn đã được gia hạn thêm một tuần.
So that'll be due on the 23rd. And then Project 4 went out earlier this week. And that'll be due on Sunday, December 7th. And then we'll announce the recitation.
Vậy hạn nộp là ngày 23. Còn Project 4 đã được công bố từ đầu tuần này. Và hạn nộp là Chủ nhật, ngày 7 tháng 12. Sau đó chúng ta sẽ thông báo buổi thảo luận.
Probably schedule that for next week, obviously, before Thanksgiving. So we'll try to do that next week.
Có lẽ sẽ xếp vào tuần sau, dĩ nhiên là trước Lễ Tạ ơn. Nên chúng ta sẽ cố gắng làm vào tuần sau.
And then, again, you want to finish Project 3, make sure you pass all the tests, and then do the merge of the latest version of the code from the public repo.
Và một lần nữa, các em cần hoàn thành Project 3, đảm bảo vượt qua tất cả các bài kiểm thử, rồi merge phiên bản mã mới nhất từ repo công khai.
And you can get started on Project 4. So any questions about Project 3? Yes.
Và các em có thể bắt đầu Project 4. Có câu hỏi nào về Project 3 không? Mời em.
The question is, should the nested loop join be a naive nested loop join or a block nested loop join? What do you want to do? Yes.
Câu hỏi là nested loop join nên là naive nested loop join hay block nested loop join? Em muốn làm cách nào? Mời em.
Yeah, you can do that. Yes. It's up to you to decide. But yes. Yes. Other questions? All right. So last class, we were talking about OCC.
Ừ, em có thể làm vậy. Đúng. Tùy em quyết định. Nhưng đúng vậy. Còn câu hỏi nào khác không? Được rồi. Vậy ở buổi trước, chúng ta đã nói về OCC.
And again, there was the OCC, there's the optimistic concurrency protocol category. And we were contrasting that with the pessimistic protocols, like in two-phase locking.
Và nhắc lại, có OCC, thuộc nhóm giao thức điều khiển đồng thời lạc quan. Và chúng ta đã đối chiếu nó với các giao thức bi quan, như khóa hai pha (two-phase locking).
In optimistic, you assume that it's not going to be complex. So you let transactions do whatever they want.
Với giao thức lạc quan, ta giả định rằng sẽ không có xung đột phức tạp. Nên ta để các giao dịch làm bất cứ điều gì chúng muốn.
And then only when they go to commit, then you check to see whether they would have violated any of the serializable ordering.
Và chỉ khi chúng đến lúc commit, ta mới kiểm tra xem chúng có vi phạm thứ tự khả tuần tự hóa nào không.
And in the case of the protocol we looked at, OCC, we talked about how when transactions make changes to the database, they don't apply them to the shared global database that every other transaction can read from.
Và với giao thức mà chúng ta đã xem, là OCC, chúng ta đã nói rằng khi các giao dịch thay đổi cơ sở dữ liệu, chúng không áp dụng các thay đổi đó vào cơ sở dữ liệu chung toàn cục mà mọi giao dịch khác đều có thể đọc.
They're going to instead make a copy of the tuple they want to modify, put it in their own private workspace, do whatever manipulation they want on it.
Thay vào đó, chúng sẽ tạo một bản sao của tuple muốn sửa đổi, đặt vào không gian làm việc riêng của chúng, và thao tác tùy ý trên đó.
And then when they go to commit, if they're allowed to commit, they pass the validation phase. In the write phase, we then push that into the global shared database.
Và khi đến lúc commit, nếu được phép commit, tức là vượt qua pha xác thực (validation). Ở pha ghi (write phase), ta mới đẩy chúng vào cơ sở dữ liệu chung toàn cục.
So we're basically going to see the same thing today in multiversioning. But instead of putting things in a private workspace, we're going to put things in the global database.
Về cơ bản, hôm nay chúng ta sẽ thấy điều tương tự trong đa phiên bản. Nhưng thay vì đặt dữ liệu vào không gian làm việc riêng, chúng ta sẽ đặt chúng vào cơ sở dữ liệu toàn cục.
But we still have this idea that transactions will work on versions of the data that in theory could be invisible or not visible to other transactions that are running at the same time.
Nhưng chúng ta vẫn giữ ý tưởng rằng các giao dịch sẽ làm việc trên các phiên bản của dữ liệu mà về lý thuyết có thể không thấy được hoặc không hiển thị với các giao dịch khác đang chạy cùng lúc.
And we'll see that in a second. And then we spent time at the end talking about how to handle the Theta read problem.
Lát nữa chúng ta sẽ thấy điều đó. Sau đó ở cuối bài, chúng ta đã dành thời gian nói về cách xử lý vấn đề phantom read.
This is an additional anomaly that occurs when you have reasoned writes on ranges of data where tuples may be appearing or disappearing within the same transaction because some other transaction made those changes.
Đây là một dạng bất thường bổ sung xảy ra khi bạn có các thao tác đọc ghi trên một khoảng dữ liệu, nơi các tuple có thể xuất hiện hoặc biến mất ngay trong cùng một giao dịch vì một giao dịch khác đã thực hiện những thay đổi đó.
And we said how this is a problem. This could occur in case of OCC and two-phase locking because you can't acquire locks.
Và chúng ta đã nói rằng đây là một vấn đề. Điều này có thể xảy ra với OCC và khóa hai pha vì bạn không thể lấy khóa.
You can't check for things that don't exist the first time you run. So we showed how to use a bunch of different mechanisms to overcome this.
Bạn không thể kiểm tra những thứ chưa tồn tại ở lần chạy đầu tiên. Vì vậy chúng ta đã chỉ ra cách dùng nhiều cơ chế khác nhau để khắc phục điều này.
Index locks is probably the most common one. There's other variations. Locking the whole table prevents all these problems. That's obviously a blunt-based approach to solving it.
Khóa chỉ mục có lẽ là cách phổ biến nhất. Còn có những biến thể khác. Khóa toàn bộ bảng sẽ ngăn chặn mọi vấn đề này. Rõ ràng đó là một cách giải quyết thô bạo.
So today now we're going to talk about multiversion concurrency control.
Vậy hôm nay chúng ta sẽ nói về điều khiển đồng thời đa phiên bản.
And the confusing name is going to be, it's not going to be, even though it has concurrency control in the name, it's not going to be a locking or timestamp ordering protocol in the same way we saw in the last two lectures.
Và cái tên này gây nhầm lẫn, vì nó sẽ không phải là, dù trong tên có chữ điều khiển đồng thời, nó không phải là một giao thức khóa hay sắp xếp theo timestamp như những gì chúng ta đã thấy trong hai bài giảng trước.
Rather, you're still going to do 2PL, you're still going to do OCC, you're still going to do whatever part of you want.
Thay vào đó, bạn vẫn sẽ làm 2PL, vẫn sẽ làm OCC, vẫn làm bất cứ phần nào bạn muốn.
But now there's going to be the initial concept of versioning in our database system that's going to open up some new opportunities to get some better parallelism than we would if we're just having everything in single version.
Nhưng bây giờ sẽ có khái niệm ban đầu về việc tạo phiên bản trong hệ cơ sở dữ liệu của chúng ta, điều này sẽ mở ra những cơ hội để đạt được tính song song tốt hơn so với khi chúng ta chỉ để mọi thứ ở dạng một phiên bản duy nhất.
So all the work you've done in BusTub so far in the class, that's a single version database system. Project 4, we'll see how to make it multiversion.
Vậy toàn bộ công việc bạn đã làm trong BusTub cho đến giờ trong lớp, đó là một hệ cơ sở dữ liệu đơn phiên bản. Ở Project 4, chúng ta sẽ thấy cách biến nó thành đa phiên bản.
So the idea with multiversioning is that the database system is now going to maintain multiple physical versions of logical tuples that exist in the database.
Ý tưởng của đa phiên bản là hệ cơ sở dữ liệu giờ đây sẽ duy trì nhiều phiên bản vật lý của các tuple logic tồn tại trong cơ sở dữ liệu.
So a logical tuple would be something that you can identify based on the primary key, a logical concept within your application.
Một tuple logic là thứ mà bạn có thể xác định dựa trên khóa chính, một khái niệm logic trong ứng dụng của bạn.
But then underneath the covers, we're going to create multiple versions of that logical tuple as transactions go ahead and modify them. So we're never going to do updates.
Nhưng bên dưới lớp vỏ, chúng ta sẽ tạo ra nhiều phiên bản của tuple logic đó khi các giao dịch tiến hành sửa đổi chúng. Vì vậy chúng ta sẽ không bao giờ cập nhật tại chỗ.
We're never going to overwrite any tuple, any sort of physical version that exists, as we did in two-phase locking or as we did in OCC. Instead, we're always going to create new physical versions.
Chúng ta sẽ không bao giờ ghi đè bất kỳ tuple nào, bất kỳ phiên bản vật lý nào đang tồn tại, như chúng ta đã làm trong khóa hai pha hay trong OCC. Thay vào đó, chúng ta luôn tạo ra các phiên bản vật lý mới.
So now when transactions go to read data, they're going to go check to see whether they're going to find, for any logical object or logical tuple they're trying to find, they're going to check the version information, the version metadata we're going to store in every single object to determine which physical version is visible to them.
Vậy bây giờ khi các giao dịch đọc dữ liệu, chúng sẽ đi kiểm tra xem liệu chúng có tìm thấy, với bất kỳ đối tượng logic hay tuple logic nào chúng đang cố tìm, chúng sẽ kiểm tra thông tin phiên bản, tức siêu dữ liệu phiên bản mà ta lưu trong từng đối tượng để xác định phiên bản vật lý nào hiển thị đối với chúng.
And at any given time, there should be only one physical version that a transaction can see.
Và tại bất kỳ thời điểm nào, chỉ nên có một phiên bản vật lý mà giao dịch có thể nhìn thấy.
So now, since we're not going to overwrite any existing tuples or any object in our database, that means that over time, as we update records, we're creating a bunch of physical versions.
Bây giờ, vì ta sẽ không ghi đè bất kỳ tuple hiện có nào hay bất kỳ đối tượng nào trong cơ sở dữ liệu, nên điều đó có nghĩa là theo thời gian, khi ta cập nhật các bản ghi, ta tạo ra rất nhiều phiên bản vật lý.
At some point, those physical versions are not going to be viewable anymore by any active transaction.
Đến một lúc nào đó, các phiên bản vật lý đó sẽ không còn được giao dịch đang hoạt động nào nhìn thấy nữa.
And therefore, we need to go through and run a garbage collection mechanism or protocol to go clean up these physical versions and reclaim the space and make things go faster.
Do đó, ta cần chạy một cơ chế thu gom rác hay giao thức để dọn dẹp các phiên bản vật lý này, thu hồi không gian và làm mọi thứ chạy nhanh hơn.
So we'll see this later on, but one of the things you can do if you don't want to do garbage collection, you get this thing called time travel queries.
Ta sẽ thấy điều này sau, nhưng một điều bạn có thể làm nếu không muốn thu gom rác, là có thứ gọi là truy vấn du hành thời gian.
And that basically means it allows you to write queries like SELECT * FROM table foo AT timestamp x, y, z.
Về cơ bản, nó cho phép bạn viết các truy vấn như SELECT * FROM table foo AT timestamp x, y, z.
And assuming you have all the history of all the previous versions you've created, if your database is in support of multiversioning, then you can go back in time and say, run on the state of the database as it existed at the timestamp that you want.
Và giả sử bạn giữ toàn bộ lịch sử của mọi phiên bản trước đó đã tạo, nếu cơ sở dữ liệu của bạn hỗ trợ đa phiên bản, thì bạn có thể quay ngược thời gian và nói, hãy chạy trên trạng thái của cơ sở dữ liệu như nó tồn tại tại mốc thời gian bạn muốn.
By default, I run a select query, I always get the latest version, but sometimes you want to go back in time and try to find the previous versions.
Mặc định, khi tôi chạy truy vấn select, tôi luôn nhận phiên bản mới nhất, nhưng đôi khi bạn muốn quay ngược thời gian để tìm các phiên bản trước.
This mostly shows up in financial systems.
Điều này chủ yếu xuất hiện trong các hệ thống tài chính.
If you're going to get audited, you want to be able to say, here's the state of the database at this time when I made this trade, and the time travel queries give you that.
Nếu bạn bị kiểm toán, bạn muốn có thể nói rằng, đây là trạng thái của cơ sở dữ liệu vào lúc tôi thực hiện giao dịch này, và truy vấn du hành thời gian cho bạn điều đó.
The question is, is that commercial systems do this? Yes. And they'll pay extra for it. Postgres had this originally in the 1980s. The question is, why did they kill it?
Câu hỏi là các hệ thống thương mại có làm vậy không? Có. Và họ sẽ trả thêm tiền cho nó. Postgres ban đầu có tính năng này vào những năm 1980. Câu hỏi là tại sao họ bỏ nó?
Well, because in the 1990s, they realized, oh, we don't really need time travel queries for what we want to do. And the database is getting bigger and bigger and bigger, running out of space.
À, vì vào những năm 1990, họ nhận ra, ta không thực sự cần truy vấn du hành thời gian cho những gì mình muốn làm. Và cơ sở dữ liệu ngày càng lớn, lớn dần, hết cả dung lượng.
We need a way to clean it up. Then they added the vacuum or the garbage collector. I think SQL Server, how do you say this?
Cần một cách để dọn nó. Sau đó họ thêm vacuum, hay trình thu gom rác. Tôi nghĩ SQL Server, nói thế nào nhỉ?
It's more than just saying, "I'm not going to do garbage collection," but at the end of the day, that's what it is.
Nó không chỉ đơn giản là nói "tôi sẽ không thu gom rác", nhưng rốt cuộc thì bản chất là vậy.
I'm just going to run the garbage collection, and then I need to have the ability in my query to say, "SELECT * FROM table2 AT this timestamp." That's basically it.
Tôi chỉ việc chạy thu gom rác, và rồi tôi cần có khả năng nói trong truy vấn của mình, "SELECT * FROM table2 AT mốc thời gian này." Về cơ bản là vậy.
And then SQL Server will charge you an extra $100,000 for that feature. For not running the garbage collector, yes.
Và SQL Server sẽ tính thêm của bạn 100.000 đô la cho tính năng đó. Vì không chạy trình thu gom rác, đúng vậy.
You're also going to pay for the storage space, extra storage space for stuff you're storing.
Bạn cũng sẽ phải trả tiền cho không gian lưu trữ, không gian lưu trữ bổ sung cho những thứ bạn lưu.
All right, so there are going to be two important properties we're going to have in multi-version concurrency control that we didn't necessarily have, certainly not with 2PL.
Được rồi, vậy sẽ có hai thuộc tính quan trọng mà ta có trong điều khiển đồng thời đa phiên bản mà không nhất thiết có trước đây, chắc chắn là không có với 2PL.
And some of these we would get with OCC, but not others. So the first of that: writers are not going to block the readers.
Một số thuộc tính trong đó ta cũng có được với OCC, nhưng một số khác thì không. Thứ nhất: các writer sẽ không chặn các reader.
So readers can always read whatever version is going to be visible to them.
Vì vậy reader luôn có thể đọc bất kỳ phiên bản nào hiển thị đối với nó.
Even if another transaction is creating a new physical version of that logical record they're reading, the reader transaction, or either reading query, can go read a previous version.
Ngay cả khi một giao dịch khác đang tạo ra một phiên bản vật lý mới của bản ghi logic mà họ đang đọc, giao dịch đọc, hay truy vấn đọc, vẫn có thể đọc một phiên bản trước đó.
And likewise, when a transaction reads an object, that's not going to interfere with any writing transaction trying to update it.
Tương tự, khi một giao dịch đọc một đối tượng, việc đó sẽ không cản trở bất kỳ giao dịch ghi nào đang cố cập nhật đối tượng đó.
Again, going back to strict 2PL and that pessimistic protocol, in order for me to read an object, I've got to get a shared lock on it.
Hãy quay lại strict 2PL và giao thức bi quan đó: để đọc một đối tượng, tôi phải lấy khóa chia sẻ (shared lock) trên nó.
And in order for me to write an object, I've got to get an exclusive lock on it. And those locks are not compatible.
Và để ghi một đối tượng, tôi phải lấy khóa độc quyền (exclusive lock) trên nó. Và các khóa đó không tương thích với nhau.
So if a reader got a shared lock on an object, the writer can't get the exclusive lock. Likewise, if I have the exclusive lock, nobody else can get the reader lock.
Vì vậy nếu một reader đã có khóa chia sẻ trên một đối tượng, thì writer không thể lấy khóa độc quyền. Tương tự, nếu tôi giữ khóa độc quyền, không ai khác có thể lấy khóa đọc.
We're not going to have that problem in sort of vanilla multi-version concurrency control.
Chúng ta sẽ không gặp vấn đề đó trong multi-version concurrency control thông thường.
The question is, how do interactions with indexes work? Well, give me like an intellectual, yes, it makes it harder, absolutely. So MVCC is an old idea.
Câu hỏi là, tương tác với các chỉ mục hoạt động như thế nào? Về mặt lý thuyết thì, đúng vậy, nó làm mọi thứ khó hơn, chắc chắn rồi. MVCC là một ý tưởng cũ.
It goes back to 1978, but what is considered the first description of it wasn't necessarily in databases. It was more like an OS or file system paper.
Nó có từ năm 1978, nhưng bản mô tả đầu tiên của nó không nhất thiết nằm trong lĩnh vực cơ sở dữ liệu. Nó giống một bài báo về hệ điều hành hoặc hệ thống tệp hơn.
There's a PhD dissertation in 1978 at MIT.
Có một luận án tiến sĩ năm 1978 tại MIT.
But in the early 1980s, it was when the data people realized, oh, this is actually useful for what we want to do in our database system for transactions.
Nhưng đầu những năm 1980, những người làm cơ sở dữ liệu nhận ra, ồ, cái này thực ra hữu ích cho những gì chúng ta muốn làm với giao dịch trong hệ cơ sở dữ liệu của mình.
And what is considered the first two implementations of MVCC is an early relational data system called RDB-VMS. This is written by DEC. You've probably never heard of DEC.
Hai hiện thực đầu tiên của MVCC được coi là một hệ cơ sở dữ liệu quan hệ thời kỳ đầu tên là RDB-VMS. Nó do DEC viết. Có lẽ các em chưa từng nghe đến DEC.
DEC was like the Google of the 80s. It was the hot technology company. If you've ever heard of VAX, that came from DEC. So they were building database systems for the VAX machines.
DEC giống như Google của thập niên 80. Đó là công ty công nghệ đình đám. Nếu các em từng nghe đến VAX, thì nó đến từ DEC. Họ xây dựng các hệ cơ sở dữ liệu cho các máy VAX.
DEC got acquired by Compaq, and then Compaq got acquired by HP, and it's pretty much been gutted at this point. But then there was another system called Interbase that was more lightweight than RDB.
DEC bị Compaq mua lại, rồi Compaq bị HP mua lại, và đến giờ về cơ bản nó đã bị rút ruột. Nhưng sau đó còn một hệ thống khác tên là Interbase nhẹ hơn RDB.
And I think that also ran on VAX.
Và tôi nghĩ nó cũng chạy trên VAX.
And both were written by this one guy, Jim Starkey, who was a co-founder of NuoDB and did a bunch of other stuff in databases for several years. So Interbase and RDB-VMS are still around.
Cả hai đều do một người viết, Jim Starkey, đồng sáng lập NuoDB và đã làm nhiều việc khác về cơ sở dữ liệu trong nhiều năm. Interbase và RDB-VMS vẫn còn tồn tại.
So Interbase has been forked off the commercial code. You still can get the commercial version of Interbase, but there's an open source version called Firebird that is available now.
Interbase đã được tách nhánh (fork) từ mã nguồn thương mại. Các em vẫn có thể lấy bản thương mại của Interbase, nhưng hiện có một bản mã nguồn mở tên là Firebird.
And I think there's a fork of Firebird out of Russia called Red Database, RedDB, something like that.
Và tôi nghĩ có một nhánh của Firebird từ Nga tên là Red Database, RedDB, đại loại vậy.
If you ever wonder why Firefox is called Firefox, it's because when it was originally Netscape, and then Netscape, the company, went under, and then they wanted to turn the source code over to make it an open source browser, they wanted to call it Phoenix first, because it was like the phoenix of Netscape rising out of the ashes.
Nếu các em từng thắc mắc vì sao Firefox lại tên là Firefox, thì đó là vì khi nó còn là Netscape ban đầu, rồi công ty Netscape sụp đổ, và họ muốn chuyển mã nguồn sang để biến nó thành một trình duyệt mã nguồn mở, lúc đầu họ muốn gọi nó là Phoenix, vì nó giống như con phượng hoàng Netscape tái sinh từ đống tro tàn.
But there was other pieces of software called that, so they couldn't call it that. Then they were going to call it Firebird. And then because this database system exists, they couldn't call it that.
Nhưng đã có những phần mềm khác mang tên đó, nên họ không thể gọi như vậy. Sau đó họ định gọi nó là Firebird. Và vì hệ quản trị cơ sở dữ liệu này đã tồn tại, họ không thể dùng tên đó.
So then they became Firefox. RDB-VMS, even though DEC got bought by Compaq, Compaq got bought by HP, Oracle bought it. Oracle buys a lot of databases. And so it still exists today. You wouldn't...
Thế là cuối cùng nó thành Firefox. RDB-VMS, dù DEC bị Compaq mua lại, Compaq bị HP mua lại, rồi Oracle mua nó. Oracle mua rất nhiều cơ sở dữ liệu. Nên nó vẫn còn tồn tại đến ngày nay. Bạn sẽ không...
This is basically a maintenance mode. You wouldn't build a new startup based on it, but they have a product called Oracle RDB.
Về cơ bản nó đang ở chế độ bảo trì. Bạn sẽ không xây dựng một công ty khởi nghiệp mới dựa trên nó, nhưng họ có một sản phẩm gọi là Oracle RDB.
And it's confusing, because there's Oracle the company, and there's Oracle the database, which is a relational database, and then there's also now Oracle RDB, which is a relational database, but it came from DEC.
Và điều này gây nhầm lẫn, vì có Oracle là công ty, có Oracle là cơ sở dữ liệu, một cơ sở dữ liệu quan hệ, và bây giờ còn có cả Oracle RDB, cũng là một cơ sở dữ liệu quan hệ, nhưng xuất phát từ DEC.
But when people say Oracle, they don't mean this one, they mean the big behemoth one that makes a lot of money on. All right. So let's look at an example of MVCC in action.
Nhưng khi người ta nói Oracle, họ không có ý nói cái này, mà là cái khổng lồ kiếm được rất nhiều tiền kia. Được rồi. Hãy xem một ví dụ về MVCC trong thực tế.
So first thing I want to point out is now my diagrams are going to have these columns here that are going to show the version IDs.
Điều đầu tiên tôi muốn chỉ ra là các sơ đồ của tôi bây giờ sẽ có những cột này để hiển thị các ID phiên bản.
In actuality, you don't store explicitly, like, oh, I'm version one, version two, like, in this way. I'm just doing this for illustrative purposes in PowerPoint.
Thực tế, bạn không lưu tường minh kiểu như, tôi là phiên bản một, phiên bản hai, theo cách này. Tôi chỉ làm vậy để minh họa trong PowerPoint.
So it's going to be A0, B0, it's going to have subscripts to the versions, but we're not actually storing that. What we're instead going to store are timestamps. So we saw this in OCC.
Nên sẽ có A0, B0, với chỉ số dưới là các phiên bản, nhưng thực ra chúng ta không lưu điều đó. Thay vào đó, chúng ta sẽ lưu các timestamp. Chúng ta đã thấy điều này trong OCC.
We had this write timestamp for every single object or every single tuple on the database, and every time you updated something, you updated this write timestamp.
Chúng ta có write timestamp cho mỗi đối tượng hay mỗi tuple trong cơ sở dữ liệu, và mỗi khi bạn cập nhật thứ gì đó, bạn cập nhật write timestamp này.
Now we're going to include a begin and an end timestamp. And this is going to represent the range in our transactional time domain of when this object is considered visible.
Bây giờ chúng ta sẽ thêm một begin timestamp và một end timestamp. Và chúng biểu diễn khoảng trong miền thời gian của giao dịch mà đối tượng này được coi là hiển thị.
And now the logic is going to be, when a transaction is run, they're going to be assigned timestamps when they start, like at begin, and then they're going to use that timestamp to determine whether the object that they're looking at is visible to them based on these begin and end timestamps.
Và logic bây giờ là, khi một giao dịch chạy, nó sẽ được gán timestamp lúc bắt đầu, tức là tại begin, rồi dùng timestamp đó để xác định liệu đối tượng mà nó đang xem có hiển thị với nó hay không dựa trên các begin và end timestamp này.
So my example here, I only have one tuple, it's A, right? And so I have a begin timestamp of zero, because there was some transaction that modified this, and they had timestamp zero.
Trong ví dụ của tôi, tôi chỉ có một tuple, là A, đúng không? Và tôi có begin timestamp bằng không, vì đã có một giao dịch nào đó sửa đổi nó, và giao dịch đó có timestamp bằng không.
And then for the end timestamp, it's going to be null or infinity.
Còn end timestamp thì sẽ là null hoặc vô cùng.
And this just means that this is the latest version, the newest version, newest committed version of this transaction at this, actually I don't want to say committed, it's the newest version of this transaction, I'm sorry, newest version of this record in my database right now, because there's no end timestamp.
Điều này chỉ có nghĩa đây là phiên bản mới nhất, phiên bản đã commit mới nhất của giao dịch này tại thời điểm này, thực ra tôi không muốn nói là đã commit, mà là phiên bản mới nhất của giao dịch này, Xin lỗi, là phiên bản mới nhất của bản ghi này trong cơ sở dữ liệu của tôi ngay lúc này, vì không có timestamp kết thúc.
All right, so we get transactions, T1 starts, it's going to get timestamp one, and the first thing it wants to do is a read on A.
Được rồi, giả sử có các giao dịch, T1 bắt đầu và nhận timestamp một, và việc đầu tiên nó muốn làm là đọc A.
So now we're going to go look in our database, ignoring how we got to A, usually an index, but we'll cover that in a second.
Vậy bây giờ ta sẽ đi tìm trong cơ sở dữ liệu, bỏ qua việc ta đến được A bằng cách nào, thường là qua một chỉ mục, nhưng lát nữa ta sẽ nói về điều đó.
So now I say, all right, my timestamp is one, I'm looking for object, the latest version of object A. In this case here, the begin timestamp is zero, the end timestamp is infinity.
Giờ tôi nói rằng, được rồi, timestamp của tôi là một, tôi đang tìm đối tượng, phiên bản mới nhất của đối tượng A. Trong trường hợp này, timestamp bắt đầu là không, timestamp kết thúc là vô cực.
Timestamp one follows in that range, and therefore, this transaction will read object A, or version A zero. Now we have a context switch, T2 starts, T2 gets timestamp two.
Timestamp một nằm trong khoảng đó, và do đó, giao dịch này sẽ đọc đối tượng A, hay phiên bản A0. Bây giờ có một lần chuyển ngữ cảnh, T2 bắt đầu, T2 nhận timestamp hai.
It's now going to do a write on A.
Giờ nó sẽ ghi lên A.
In this case here, because now we're not taking locks in the same way we did with 2PL, even though transaction one read A, and under 2PL, there's a single version, you get a shared lock, and then you wouldn't be able to write it.
Trong trường hợp này, vì giờ ta không khóa theo cách ta đã làm với 2PL, dù giao dịch một đã đọc A, và với 2PL, chỉ có một phiên bản, bạn lấy khóa chia sẻ, và khi đó bạn sẽ không thể ghi nó.
T1, sorry, T2 is allowed to create a new version A, and it's going to go install that. It's not going to modify the A zero, it's going to create a new one, A1.
T1, xin lỗi, T2 được phép tạo một phiên bản A mới, và nó sẽ cài đặt phiên bản đó. Nó sẽ không sửa A0, mà tạo một phiên bản mới, A1.
It's going to set its begin timestamp to what its timestamp is, two, but then it's also going to go back now to A zero, and it'll update its end timestamp to now be two, Right?
Nó sẽ đặt timestamp bắt đầu bằng timestamp của nó, là hai, nhưng sau đó nó cũng quay lại A0, và cập nhật timestamp kết thúc của A0 thành hai, đúng không?
Because this is saying that the A0 is only visible from zero inclusive to two exclusive.
Vì điều này nói rằng A0 chỉ hiển thị từ không, tính cả không, đến hai, không tính hai.
Why do you need the end timestamp?
Tại sao cần timestamp kết thúc?
The question is, why do we need the end timestamp, if you just look at the, what, sorry?
Câu hỏi là, tại sao ta cần timestamp kết thúc, nếu bạn chỉ nhìn vào, gì cơ, xin lỗi?
The question is, why do I need the end timestamp, right? Because now I had to install the update in A1, right, and then I have to also go update A0, right?
Câu hỏi là, tại sao tôi cần timestamp kết thúc, đúng không? Vì giờ tôi phải cài đặt bản cập nhật trong A1, rồi tôi cũng phải đi cập nhật A0, đúng không?
So now, if I have another transaction that shows up, now they're T3, what version should they see?
Vậy giờ nếu có một giao dịch khác xuất hiện, giờ là T3, nó nên thấy phiên bản nào?
Say A1. All right, so what about, sorry, what if instead of T2, it gets timestamp three, and now I have another T2, so T3 installs A1 and sets the begin timestamp three.
Giả sử là A1. Được rồi, vậy nếu thay vì T2, nó nhận timestamp ba thì sao, và giờ tôi có một T2 khác, nên T3 cài đặt A1 và đặt timestamp bắt đầu là ba.
What timestamp should I be seeing now, right, for my other transaction shows up? I need to know what the boundary is for certain things.
Vậy tôi nên thấy timestamp nào khi giao dịch khác của tôi xuất hiện? Tôi cần biết ranh giới của một số thứ.
I'm also going to use this to determine that, this is how I'm also going to determine that these tuples are no longer visible in any transaction, and therefore, I want to go clean them up.
Tôi cũng sẽ dùng nó để xác định rằng, đây cũng là cách tôi xác định rằng các tuple này không còn hiển thị với bất kỳ giao dịch nào, và do đó tôi muốn dọn chúng đi.
But he brings up another point, and that is, all right, well, if I'm just storing begin and end timestamp, at this point in time, T1 and T2 are active.
Nhưng bạn ấy nêu ra một điểm khác, đó là, được rồi, nếu tôi chỉ lưu timestamp bắt đầu và kết thúc, tại thời điểm này, T1 và T2 đang hoạt động.
So if I show up, what version should I see?
Vậy nếu tôi xuất hiện, tôi nên thấy phiên bản nào?
There's not enough information, just begin and end timestamp, to give me that information, to tell me whether the transaction that made this change actually committed or not.
Không đủ thông tin, chỉ với timestamp bắt đầu và kết thúc, để cho tôi biết điều đó, để cho tôi biết liệu giao dịch đã thực hiện thay đổi này có thực sự commit hay chưa.
It just tells me when the version was visible.
Nó chỉ cho tôi biết khi nào phiên bản đó có thể nhìn thấy.
So the other thing I'm going to add now is a separate transaction status table, a global data structure, like a hash table, that's going to keep track of, here's all the transactions that are running in my system at this given time.
Vì vậy, thứ khác mà bây giờ tôi sẽ thêm vào là một bảng trạng thái giao dịch riêng, một cấu trúc dữ liệu toàn cục, chẳng hạn như bảng băm, dùng để theo dõi, đây là tất cả các giao dịch đang chạy trong hệ thống của tôi tại thời điểm này.
So now, in there, I have T1, they're considered active, and I have T2, which is active, and now I also know their timestamps.
Vậy bây giờ, trong đó tôi có T1, nó được coi là đang hoạt động, và tôi có T2, cũng đang hoạt động, và giờ tôi cũng biết các timestamp của chúng.
So then now, when [we] context switch back to T1, T1's going to read A, and at this point, again, it's going to be able to go back and read the same version that it saw before, so it guarantees that it has a repeatable read here, right?
Thế nên bây giờ, khi chuyển ngữ cảnh trở lại T1, T1 sẽ đọc A, và tại thời điểm này, một lần nữa, nó có thể quay lại và đọc đúng phiên bản mà nó đã thấy trước đó, nên nó đảm bảo có một lần đọc lặp lại được ở đây, đúng không?
And then now, when the transaction commits at some later point for T1 and T2, I know that there's never going to be another transaction that comes along that's going to be, that can see version A0, so I want to go ahead and clean that up.
Và rồi bây giờ, khi giao dịch commit vào một thời điểm nào đó sau này đối với T1 và T2, tôi biết rằng sẽ không bao giờ có một giao dịch nào khác xuất hiện mà sẽ có thể, thấy được phiên bản A0, nên tôi muốn tiến hành dọn dẹp nó.
So the beginning timestamp gives me that bound to say, and I can look now in this transaction status table and say, well, I have a transaction that is timestamp three, three can never see A0, because three is greater than two, so it's safe for me to go ahead and clean up A0.
Vậy timestamp bắt đầu cho tôi cận đó để nói rằng, và bây giờ tôi có thể xem trong bảng trạng thái giao dịch này và nói rằng, à, tôi có một giao dịch có timestamp là ba, ba không bao giờ thấy được A0, vì ba lớn hơn hai, nên tôi có thể yên tâm dọn dẹp A0.
All right, and let's look at another example.
Được rồi, hãy xem một ví dụ khác.
Same thing, so now T1's going to do a read on A, write on A, read on A, and now T2 is going to do a read on A and write on A.
Tương tự, bây giờ T1 sẽ đọc A, ghi A, đọc A, và T2 sẽ đọc A và ghi A.
So again, we start like before, we read A, we read version A0, that's fine, then we do a write on A, we create a new version A1, that's fine, right?
Vậy một lần nữa, ta bắt đầu như trước, ta đọc A, đọc phiên bản A0, không sao, rồi ta ghi A, tạo ra một phiên bản mới A1, không sao, đúng không?
Go update the end timestamp for A0 to be our transaction timestamp T1.
Cập nhật timestamp kết thúc của A0 thành timestamp giao dịch của ta là T1.
Now we context switch over here, T2 can read A, that's fine, again, it's not going to be the newer version, and then now it's going to write on A here.
Bây giờ ta chuyển ngữ cảnh sang đây, T2 có thể đọc A, không sao, một lần nữa, nó sẽ không đọc phiên bản mới hơn, và rồi bây giờ nó sẽ ghi A ở đây.
And so in a sort of naive scheme like this, but I'm not taking locks, right, the T2 could detect that if I go try to write now a new version, like an A2, I would see that there's an A1 there that has no end timestamp, therefore this is the latest version.
Và trong một lược đồ khá ngây thơ như thế này, nhưng tôi không dùng khóa, đúng không, T2 có thể phát hiện ra rằng nếu bây giờ tôi thử ghi một phiên bản mới, như A2, tôi sẽ thấy có một A1 ở đó không có timestamp kết thúc, do đó đây là phiên bản mới nhất.
So then now I can consult the transaction table and say, for the transaction that created version A1, I know what it is, because begin timestamp tells me that, So I go find the transaction T1 that has timestamp 1.
Vậy bây giờ tôi có thể tra bảng giao dịch và nói rằng, với giao dịch đã tạo ra phiên bản A1, tôi biết đó là giao dịch nào, vì timestamp bắt đầu cho tôi biết điều đó, Nên tôi đi tìm giao dịch T1 có timestamp 1.
This transaction is still active, this transaction is not committed yet, so therefore I can't write a new version, because then that would be a write-write conflict, and I have to go ahead and abort T2.
Giao dịch này vẫn đang hoạt động, giao dịch này chưa commit, vì vậy tôi không thể ghi phiên bản mới, vì như thế sẽ là xung đột ghi-ghi, và tôi phải tiến hành hủy T2.
So now in my transaction table I would say its status is aborted, and at some later point this will get cleaned up when we know we don't care about T2 anymore.
Vậy bây giờ trong bảng giao dịch tôi sẽ ghi trạng thái của nó là đã hủy, và vào một thời điểm nào đó sau này nó sẽ được dọn dẹp khi ta biết rằng ta không còn quan tâm đến T2 nữa.
Yes?
Vâng, mời bạn?
The question is, how does T2 need to know that it needs to read A0, not A1?
Câu hỏi là, làm sao T2 biết rằng nó cần đọc A0, chứ không phải A1?
So again, ignoring how I got to these versions, right, assume I just read all of them, but in actuality it would be a linked list, but we'll get there in a second.
Vậy nên, một lần nữa, hãy bỏ qua việc tôi đã tìm ra các phiên bản này bằng cách nào, cứ giả sử là tôi đọc tất cả chúng, nhưng thực tế nó sẽ là một danh sách liên kết, chúng ta sẽ nói tới điều đó ngay sau đây.
So I scan through and I see, all right, here's all the versions of A that I could possibly read: there's A0 and A1.
Vậy tôi quét qua và thấy rằng, đây là tất cả các phiên bản của A mà tôi có thể đọc: có A0 và A1.
A0 is the older version that should not be visible to me, because my timestamp is 2, the end timestamp of A0 is 1, therefore I can't read that, it's not visible to me.
A0 là phiên bản cũ hơn và không được hiển thị với tôi, vì timestamp của tôi là 2, còn timestamp kết thúc của A0 là 1, do đó tôi không thể đọc nó, nó không hiển thị với tôi.
Then now I should be able to go now see A1, but A1 was modified, there's a new version created by a transaction that has not committed yet, therefore I can't create a new version after that.
Tiếp theo tôi lẽ ra có thể thấy A1, nhưng A1 đã bị sửa đổi, có một phiên bản mới được tạo bởi một transaction chưa commit, do đó tôi không thể tạo một phiên bản mới sau nó.
Physically it would read it, logically it does not. Physically it has to see it, like, assuming we're just scanning through everything, there's other ways to get around that.
Về mặt vật lý thì nó sẽ đọc phiên bản đó, về mặt logic thì không. Về mặt vật lý thì nó phải thấy phiên bản đó, ví dụ, giả sử ta chỉ quét qua mọi thứ, còn có những cách khác để tránh điều đó.
Logically it should only see A1 and know that, okay, I want to create a new version A2, but because the transaction that made A1 has not committed yet, I can't overwrite it.
Về mặt logic thì nó chỉ nên thấy A1 và biết rằng, được rồi, tôi muốn tạo một phiên bản mới A2, nhưng vì transaction đã tạo A1 vẫn chưa commit, nên tôi không thể ghi đè lên nó.
That would be a write-write conflict, it would be a lost update in this example here.
Đó sẽ là một xung đột ghi-ghi, và trong ví dụ này nó sẽ là một lost update.
Yeah, so the point is, yes, you would end up reading something that has not committed yet.
Vâng, vậy điểm mấu chốt là, đúng, bạn sẽ đọc phải thứ chưa được commit.
In this case here, you would say, If I'm having a consistent snapshot on a snapshot isolation, then I would actually see A0, not A1, because A1 is not committed yet.
Trong trường hợp này, bạn sẽ nói, Nếu tôi có một snapshot nhất quán trong snapshot isolation, thì thực ra tôi sẽ thấy A0, không phải A1, vì A1 chưa được commit.
So I would see A0, but then if I try to write to make it A2, then I have a problem. You're getting to the problem, yes. Next slide, yes.
Vậy tôi sẽ thấy A0, nhưng nếu tôi cố ghi để tạo A2 thì tôi gặp vấn đề. Bạn đang đi đến đúng vấn đề đó. Slide tiếp theo, vâng.
Yes.
Vâng.
Yeah, so back here, when it reads A, it reads A0, because the transaction that modified and made the latest version A1, which is T1, has not committed yet, so it would not see that.
Vâng, quay lại đây, khi nó đọc A, nó đọc A0, vì transaction đã sửa đổi và tạo ra phiên bản mới nhất A1, tức là T1, vẫn chưa commit, nên nó sẽ không thấy phiên bản đó.
But then when it tries to install and create a new version, it's not allowed to do that.
Nhưng khi nó cố cài đặt và tạo một phiên bản mới, thì nó không được phép làm vậy.
Sorry, maybe I misspoke.
Xin lỗi, có lẽ tôi đã nói nhầm.
It does, it reads A0 here, but when it's trying to figure out what to then write to, it has to keep going to A1, assuming we have to create a new version after that.
Đúng là nó đọc A0 ở đây, nhưng khi nó cố xác định xem sẽ ghi vào đâu, nó phải tiếp tục đến A1, giả sử ta phải tạo một phiên bản mới sau đó.
The question is, why is it allowed to read A0?
Câu hỏi là, tại sao nó được phép đọc A0?
Next slide, hold on.
Slide tiếp theo, khoan đã.
All right, so the behavior we're seeing here is what is called snapshot isolation, and there's another isolation level similar to serializable, read committed, repeatable read, the things we talked about last class.
Được rồi, hành vi mà chúng ta đang thấy ở đây được gọi là snapshot isolation, và còn một mức cô lập khác tương tự như serializable, read committed, repeatable read, những thứ chúng ta đã nói ở buổi trước.
And so the guarantee on a snapshot isolation is that it will see a consistent snapshot of the database that existed when the transaction started, and consistent means that it only contains updates from transactions that have committed, that committed before the transaction started.
Và như vậy, sự đảm bảo của snapshot isolation là nó sẽ thấy một snapshot nhất quán của cơ sở dữ liệu tồn tại khi transaction bắt đầu, và nhất quán nghĩa là nó chỉ chứa các cập nhật từ những transaction đã commit, đã commit trước khi transaction đó bắt đầu.
And so that means you're not going to see any torn writes from actual transactions.
Và điều đó có nghĩa là bạn sẽ không thấy bất kỳ torn write nào từ các giao dịch thực sự.
You won't see, like, if T1 updated A and updated B, transaction T2 can't see the update on A and not see the update on B.
Bạn sẽ không gặp trường hợp, chẳng hạn, T1 cập nhật A và cập nhật B, mà giao dịch T2 lại thấy bản cập nhật trên A nhưng không thấy bản cập nhật trên B.
It has to see the state of the database as it existed from only committed transactions.
Nó phải thấy trạng thái của cơ sở dữ liệu như nó tồn tại chỉ từ các giao dịch đã commit.
So in that case, it is like repeatable reads, or sorry, read committed, but it has this additional anomaly we'll talk about next that we have to handle.
Vậy trong trường hợp đó, nó giống như repeatable read, à xin lỗi, read committed, nhưng nó có thêm một dị thường mà chúng ta sẽ nói tiếp theo và phải xử lý.
And in the simplest case, you basically, if you have two transactions try to update the same object, that'd be first writer. And the first writer wins, not the last, sorry.
Và trong trường hợp đơn giản nhất, về cơ bản, nếu có hai giao dịch cùng cố cập nhật một đối tượng, thì đó là first writer. Và người ghi đầu tiên thắng, không phải người cuối, xin lỗi.
Let me just fix that now immediately.
Để tôi sửa ngay bây giờ.
That's important. OK, yes, first writer wins. And then we saw that in my example there, right?
Điều đó quan trọng. Được rồi, đúng, người ghi đầu tiên thắng. Và chúng ta đã thấy điều đó trong ví dụ của tôi, đúng không?
The transaction T2 was trying to create a new version on A, but because T1 wrote a new version A, T1 is the first writer. It's going to win. T2 has to abort.
Giao dịch T2 đang cố tạo một phiên bản mới của A, nhưng vì T1 đã ghi phiên bản mới của A, T1 là người ghi đầu tiên. Nó sẽ thắng. T2 phải abort.
That's the basic version of snapshot isolation, I'll give you that. But it is susceptible to a different phenomenon, or a different anomaly, that two-phase locking, OCC is not going to hit.
Đó là phiên bản cơ bản của snapshot isolation, tôi công nhận vậy. Nhưng nó dễ bị một hiện tượng khác, hay một dị thường khác, mà two-phase locking và OCC sẽ không gặp phải.
And that's the thing called the write skew. And the basic idea of the write skew is that you're allowed to read things as a consistent snapshot.
Và đó là thứ gọi là write skew. Và ý tưởng cơ bản của write skew là bạn được phép đọc mọi thứ như một snapshot nhất quán.
And you may make decisions about that consistent snapshot view you saw where you end up writing things in a certain way.
Và bạn có thể đưa ra quyết định dựa trên góc nhìn snapshot nhất quán mà bạn thấy khiến bạn cuối cùng ghi các thứ theo một cách nào đó.
And the right behavior could not occur in that manner if you were actually truly running in serial order.
Và hành vi đúng đắn sẽ không thể xảy ra theo cách đó nếu bạn thực sự chạy theo thứ tự tuần tự.
So me standing here and saying words and being hand-wavy doesn't make any sense. Let's look at a sort of a simplified example. So this comes from Jim Gray.
Vậy nên việc tôi đứng đây nói chung chung thì chẳng có ý nghĩa gì. Hãy xem một ví dụ đơn giản hóa. Ví dụ này đến từ Jim Gray.
Again, he won the Turing Award in databases in the 1990s. He invented two-phase locking and a bunch of other stuff at System R.
Một lần nữa, ông ấy đã nhận Giải Turing về cơ sở dữ liệu vào những năm 1990. Ông ấy đã phát minh two-phase locking và nhiều thứ khác ở System R.
So this is sort of like a metaphor he likes to use to explain this. So say I have a database containing marbles.
Đây là một kiểu ẩn dụ mà ông ấy thích dùng để giải thích điều này. Giả sử tôi có một cơ sở dữ liệu chứa các viên bi.
And I have four marbles, and they're two colors. They're either black or white. And so I'm going to have one transaction come along and change all the white marbles to black.
Tôi có bốn viên bi, và chúng có hai màu. Hoặc đen hoặc trắng. Và tôi sẽ có một giao dịch chạy đến và đổi tất cả bi trắng thành đen.
And then another transaction is going to come along and change all the black marbles to white. So these two transactions are going to run at exactly the same time in separate workers.
Rồi một giao dịch khác chạy đến và đổi tất cả bi đen thành trắng. Hai giao dịch này sẽ chạy vào đúng cùng một lúc trên các worker riêng biệt.
So when they start, again, under snapshot isolation, they have a consistent snapshot of the database. They see two black marbles and two white marbles, for both of them.
Vậy khi chúng bắt đầu, một lần nữa, dưới snapshot isolation, chúng có một snapshot nhất quán của cơ sở dữ liệu. Cả hai đều thấy hai viên bi đen và hai viên bi trắng.
Then now they're going to say, "All right, my job is to flip all the black marbles to white" in the bottom. The top one is to flip all the white marbles to black.
Rồi bây giờ chúng sẽ nói: "Được rồi, việc của tôi là lật tất cả bi đen thành trắng" ở giao dịch dưới. Giao dịch trên thì lật tất cả bi trắng thành đen.
So they go ahead and do that.
Thế là chúng tiến hành làm vậy.
So what I have in the red box, that's the write set of these transactions. That's the new versions that they're going to create.
Phần trong ô đỏ chính là write set của các giao dịch này. Đó là các phiên bản mới mà chúng sẽ tạo ra.
So then now, when I install it in the database, I end up like this, right? Two white marbles, two black marbles.
Vậy bây giờ, khi tôi cài đặt nó vào cơ sở dữ liệu, tôi sẽ có kết quả như thế này, đúng không? Hai viên bi trắng, hai viên bi đen.
So that issue right there is the write skew, where you're updating things in a certain way that, if you're running in serial order, could not happen, right?
Vậy vấn đề ở đây chính là write skew, tức là bạn cập nhật dữ liệu theo một cách mà, nếu chạy theo thứ tự tuần tự thì không thể xảy ra, đúng không?
Because I have two whites and two blacks. And if I was running in true serial order, then say I run transaction T1 first, changes all the white marbles to black.
Vì tôi có hai viên trắng và hai viên đen. Và nếu tôi chạy theo đúng thứ tự tuần tự, giả sử tôi chạy giao dịch T1 trước, đổi tất cả bi trắng thành đen.
Then I run transaction T2 next, and I change all the black marbles to white. So in a true serial order, it would be all one color.
Rồi tôi chạy giao dịch T2, đổi tất cả bi đen thành trắng. Vậy với thứ tự tuần tự thực sự, tất cả sẽ cùng một màu.
But under snapshot isolation, that schedule I showed before is allowed to happen. And you end up with two sets of colors, two colors.
Nhưng với snapshot isolation, lịch trình tôi vừa trình bày được phép xảy ra. Và bạn kết thúc với hai nhóm màu, hai màu.
So two-phase locking wouldn't have this problem, right, going back here. Because when I do the read at this first step, I would take shared locks on everything that I want to read.
Còn two-phase locking sẽ không gặp vấn đề này, quay lại chỗ này nhé. Vì khi tôi thực hiện thao tác đọc ở bước đầu tiên, tôi sẽ lấy khóa chia sẻ trên mọi thứ tôi muốn đọc.
And the other transaction wouldn't be able to take an exclusive lock and write it.
Và giao dịch kia sẽ không thể lấy khóa độc quyền để ghi.
But under snapshot isolation, because I'm creating these new versions, and my readers don't end up blocking the writers, this anomaly can happen.
Nhưng với snapshot isolation, vì tôi tạo ra các phiên bản mới này, và các thao tác đọc không chặn các thao tác ghi, nên dị thường này có thể xảy ra.
So the original specification of two-phase locking, or sorry, of the SQL standard isolation levels that came out in 1992, didn't account for this problem.
Vậy đặc tả ban đầu của two-phase locking, à xin lỗi, của các mức cô lập trong chuẩn SQL ra đời năm 1992, đã không tính đến vấn đề này.
And they only considered isolation levels in the context of two-phase locking systems. And then this was done. A lot of people working on this were at Microsoft at the time, in the early 90s.
Họ chỉ xem xét các mức cô lập trong bối cảnh các hệ thống two-phase locking. Và việc đó đã được thực hiện. Nhiều người làm việc này khi đó ở Microsoft, vào đầu những năm 90.
And then they realized that they made a mistake and forgot this particular issue.
Rồi họ nhận ra mình đã mắc sai sót và quên mất vấn đề cụ thể này.
And then there's a subsequent paper that came after the standard came out saying, "Oh yeah, by the way, here's this other phenomenon that can occur if you have snapshot isolation on a multi-version DBMS."
Sau khi chuẩn ra đời có một bài báo tiếp theo nói rằng, "À, nhân tiện, còn một hiện tượng khác có thể xảy ra nếu bạn dùng snapshot isolation trên một DBMS đa phiên bản."
And one of the guys that wrote the paper sent me an email once saying the mistake was because the other person that was supposed to check the spec was not paying attention, was writing code at the time.
Và một trong những người viết bài báo từng gửi email cho tôi nói rằng sai sót đó là do người kia vốn phải kiểm tra đặc tả đã không chú ý, vì lúc đó đang viết code.
He was like, "Yeah, whatever, that seems OK." And only after the fact, they realized this was a mistake, and then they had to follow up on it.
Anh ta kiểu như, "Ừ, sao cũng được, có vẻ ổn." Và chỉ sau đó họ mới nhận ra đây là một sai sót, rồi họ phải bổ sung.
Again, Jim Gray is very famous, again, for winning the Turing Award, but he was very good at simplifying really complex database concepts into easy things to understand.
Jim Gray rất nổi tiếng, một lần nữa, vì đoạt giải Turing, nhưng ông rất giỏi trong việc đơn giản hóa những khái niệm cơ sở dữ liệu rất phức tạp thành những điều dễ hiểu.
So if you've ever heard of things like the five-minute rule, like how long should you keep data in memory before evicting it to your cache, that comes from Jim Gray.
Nếu bạn từng nghe về những thứ như quy tắc năm phút, tức là nên giữ dữ liệu trong bộ nhớ bao lâu trước khi loại nó khỏi cache, thì nó đến từ Jim Gray.
If you've ever heard of, like, five nines or six nines latency, that's from Jim Gray as well. So he's very famous and very prolific in databases. What's that?
Nếu bạn từng nghe về độ trễ five nines hay six nines, thì cũng từ Jim Gray. Ông rất nổi tiếng và rất có nhiều đóng góp trong lĩnh vực cơ sở dữ liệu. Gì vậy?
The question is, is it weaker than read committed? No. So remember, last class, I sort of showed sort of parallel tracks.
Câu hỏi là liệu nó có yếu hơn read committed không? Không. Hãy nhớ, buổi trước tôi đã trình bày một dạng hai nhánh song song.
There was, like, one side was going read committed, repeatable read, up to serializability. Another one is, like, snapshot isolation. So they're, like, orthogonal. All right.
Một bên là đi từ read committed, repeatable read, lên đến serializability. Bên kia là snapshot isolation. Vậy chúng trực giao với nhau. Được rồi.
So multi-version control is more than just, again, that I'm creating multiple versions.
Vậy kiểm soát đa phiên bản không chỉ đơn giản là việc tạo ra nhiều phiên bản.
If you're going to build a database system, like we do in this class, we care about, then choosing to do multi-version control is going to have a bunch of other design decisions you have to make, how to support multi-versioning, that's going to affect the entire system.
Nếu bạn xây dựng một hệ cơ sở dữ liệu, như chúng ta làm trong lớp này, thứ chúng ta quan tâm, thì việc chọn kiểm soát đa phiên bản sẽ kéo theo hàng loạt quyết định thiết kế khác mà bạn phải đưa ra, cách hỗ trợ đa phiên bản sẽ ảnh hưởng đến toàn bộ hệ thống.
For pretty much all the lectures we've talked about so far, if you now do multiversion, you have to consider that in all of that.
Với hầu như tất cả các bài giảng chúng ta đã học đến giờ, nếu bây giờ bạn dùng đa phiên bản, bạn phải tính đến điều đó trong tất cả những phần ấy.
And again, pretty much every modern data system that's around today is doing some variation of multiversioning. The question is, what's that for? That's a special project. We'll cover that later.
Và một lần nữa, hầu như mọi hệ quản trị dữ liệu hiện đại ngày nay đều dùng một biến thể nào đó của đa phiên bản. Câu hỏi là cái đó để làm gì? Đó là một dự án đặc biệt. Chúng ta sẽ nói sau.
All right. So what are these design decisions? So the first is, like, what is the concurrency control protocol going to use? Because as I said, it's called multiversion concurrency control.
Được rồi. Vậy những quyết định thiết kế này là gì? Đầu tiên là giao thức kiểm soát đồng thời nào sẽ được dùng? Vì như tôi đã nói, nó được gọi là kiểm soát đồng thời đa phiên bản.
And I showed sort of a naive implementation of it where you have that, you know, two guys try to write and you prevent that.
Và tôi đã cho xem một cách cài đặt ngây thơ của nó, trong đó hai giao dịch cùng cố ghi và bạn ngăn điều đó lại.
But you can still do two-phase locking or OCC on top of multiversion concurrency control, or having a multiversioning system. So we'll discuss what that looks like.
Nhưng bạn vẫn có thể dùng khóa hai pha hoặc OCC trên nền kiểm soát đồng thời đa phiên bản, hay trên một hệ thống đa phiên bản. Chúng ta sẽ xem nó trông như thế nào.
Then we'll talk about how we're going to store these different versions, how we do garbage collection, how to handle indexes, and then how to handle deletes. All right. All right.
Sau đó chúng ta sẽ nói về cách lưu trữ các phiên bản khác nhau này, cách thu gom rác, cách xử lý chỉ mục, rồi cách xử lý thao tác xóa. Được rồi. Được rồi.
So the first one is, as I said, there's a bunch of different, you take all the protocols we talked about in the last two classes, and you can apply that to, you know, apply that into a multiversion environment.
Vậy điều đầu tiên, như tôi đã nói, có nhiều giao thức khác nhau, bạn lấy tất cả các giao thức chúng ta đã nói trong hai buổi trước, và bạn có thể áp dụng chúng vào môi trường đa phiên bản.
So the one I showed before at the beginning was a basic version of timestamp ordering, which is assigning timestamps and using that to determine the serial ordering.
Giao thức tôi cho xem lúc đầu là phiên bản cơ bản của sắp thứ tự theo timestamp, tức là gán timestamp và dùng nó để xác định thứ tự tuần tự.
But you still can do OCC and you still can do two-phase locking in the context of multiversioning.
Nhưng bạn vẫn có thể dùng OCC và vẫn có thể dùng khóa hai pha trong bối cảnh đa phiên bản.
So let's look and see what this looks like with 2PL, and then we'll open up Postgres and see what they do. All right. Again, so this is the same setup I had before.
Vậy hãy xem nó trông thế nào với 2PL, rồi chúng ta sẽ mở Postgres lên xem họ làm gì. Được rồi. Đây là thiết lập giống như tôi đã có trước đó.
I'm going to begin for T1, do a read on A, write on A, and read on A.
Tôi bắt đầu với T1: đọc A, ghi A, rồi đọc A.
And then T2 is going to do a read on A and write on A. So then we start off. I can read, sorry, T1 can read A0. That's fine.
Và T2 sẽ đọc A rồi ghi A. Vậy ta bắt đầu. Tôi có thể đọc, xin lỗi, T1 có thể đọc A0. Không sao.
T1 is going to write to A, creates a new version A1, goes back and updates the end timestamp for A0.
T1 sẽ ghi vào A, tạo ra một phiên bản mới A1, rồi quay lại cập nhật timestamp kết thúc của A0.
That's fine. Now I context switch over here, and now I'm going to try to read A. In this case here, I can read A0 because T1 is not committed yet.
Không sao. Giờ tôi chuyển ngữ cảnh sang đây, và bây giờ tôi sẽ thử đọc A. Trong trường hợp này, tôi có thể đọc A0 vì T1 chưa commit.
But then now when I go to try to write A, under the scheme I showed before, the basic timestamp ordering, this write is going to be denied and the transaction has to abort.
Nhưng bây giờ khi tôi thử ghi A, theo cơ chế tôi đã cho xem trước đó, sắp thứ tự theo timestamp cơ bản, thao tác ghi này sẽ bị từ chối và giao dịch phải abort.
But if I'm doing two-phase locking, then it's going to try to get the exclusive lock on A, the logical A, not the physical version. It's always the logical version.
Nhưng nếu tôi dùng khóa hai pha, thì nó sẽ cố lấy khóa độc quyền trên A, A logic, không phải phiên bản vật lý. Luôn luôn là phiên bản logic.
I'm going to try to get the exclusive lock on A, but that's going to get stalled by the lock manager because T1 already has the exclusive lock on A.
Tôi sẽ cố lấy khóa độc quyền trên A, nhưng yêu cầu đó sẽ bị trình quản lý khóa làm cho bị chặn lại vì T1 đã giữ khóa độc quyền trên A rồi.
So it has to wait. Then T1 can do the read on A, sees the same version it had before. That's fine.
Nên nó phải chờ. Sau đó T1 có thể đọc A và thấy phiên bản giống như trước đó. Vậy là ổn.
Then now the lock gets released for, after we commit, because the update is now committed.
Rồi bây giờ khóa được giải phóng, sau khi chúng ta commit, vì bản cập nhật giờ đã được commit.
Then the lock gets released over here, and T2 can then now create the new version and updates the end timestamp just like it did before.
Rồi khóa được giải phóng ở đây, và lúc này T2 có thể tạo phiên bản mới và cập nhật timestamp kết thúc giống như trước.
Why? Because when T1 committed, T2, that releases the exclusive lock, T2 can then apply the exclusive lock and do the write.
Tại sao? Bởi vì khi T1 commit, T2, việc đó giải phóng khóa độc quyền, thì T2 có thể lấy khóa độc quyền và thực hiện thao tác ghi.
The question is, why is this useful? Because T2 was able to read A without, even though T1 had an exclusive lock on it.
Câu hỏi là, điều này hữu ích ở chỗ nào? Bởi vì T2 đã có thể đọc A mà không cần, dù T1 đang giữ khóa độc quyền trên nó.
You can't do that on a GPO, no, because I'm reading the older version of it.
Bạn không thể làm vậy trên GPO, không, vì tôi đang đọc phiên bản cũ hơn của nó.
Well, you can only allow one writer anyway, like only one transaction can install a new version. So the exclusive lock is like preventing any other transactions from doing that.
Thì dù sao bạn cũng chỉ cho phép một bộ ghi, tức là chỉ một transaction có thể cài đặt một phiên bản mới. Nên khóa độc quyền ngăn mọi transaction khác làm điều đó.
There are no share locks. Yes. All right. So let's talk Postgres, and hopefully this will be more clear. So you all see that?
Không có khóa chia sẻ. Vâng. Được rồi. Vậy hãy nói về Postgres, và hy vọng điều này sẽ rõ hơn. Mọi người thấy chứ?
So I have a simple table in Postgres that has two tuples, has an ID and a value. Okay?
Tôi có một bảng đơn giản trong Postgres có hai tuple, gồm một ID và một giá trị. Được chứ?
And now you see I have two terminals at the same time, so I can do the same thing.
Và giờ các bạn thấy tôi có hai terminal cùng lúc, nên tôi có thể làm điều tương tự.
Select star from transaction demo, right, because I want to run two transactions at the same time and see what happens. All right.
Select star from transaction demo, đúng không, vì tôi muốn chạy hai transaction cùng lúc và xem điều gì xảy ra. Được rồi.
So we're going to run this now in the default isolation, which I, so maybe I got to come back and quit out and come back, make sure I get the default.
Giờ chúng ta sẽ chạy ở mức cô lập mặc định, mà tôi, có lẽ tôi phải quay lại và thoát ra rồi vào lại, để chắc chắn là mức mặc định.
Okay. All right.
Được rồi.
So we're going to run in Postgres, but I'm going to set the deadlock timeout for Postgres to be 30 seconds, right, because otherwise I think the default is maybe a minute or something like that.
Vậy chúng ta sẽ chạy trong Postgres, nhưng tôi sẽ đặt thời gian chờ bế tắc của Postgres là 30 giây, vì nếu không thì tôi nghĩ mặc định có thể là một phút hay gì đó tương tự.
So I'm going to start a transaction up here, start a transaction down below, right, and then now I'm going to go read a single tuple.
Tôi sẽ bắt đầu một transaction ở trên này, bắt đầu một transaction ở bên dưới, rồi bây giờ tôi sẽ đọc một tuple đơn.
So select star from transaction demo, or actually let me just do it this way.
Select star from transaction demo, hoặc thực ra để tôi làm theo cách này.
Yeah. So I can go read a single tuple there. That's fine. Now I go down below, and I can go read the same tuple, right? That's fine.
Vâng. Vậy là tôi đọc được một tuple ở đó. Ổn rồi. Giờ tôi xuống bên dưới và có thể đọc cùng tuple đó, đúng không? Cũng ổn.
But now the top guy is going to then update it, right, which is I committed the counter increment by one.
Nhưng bây giờ người ở trên sẽ cập nhật nó, tức là tôi đã commit việc tăng bộ đếm thêm một.
So now if I go read it, right, now I see the value is 101, it was 100, so I added one to it.
Nên nếu giờ tôi đọc nó, giờ tôi thấy giá trị là 101, trước đó là 100, nên tôi đã cộng thêm một.
We're good there. Now down below, if I read it, what should I see? 100. Correct. Because the one up above has not committed yet.
Đến đây thì ổn. Giờ ở bên dưới, nếu em đọc thì sẽ thấy gì? 100. Đúng. Vì giao dịch ở phía trên vẫn chưa commit.
But now what's going to happen if I try to also update the object, that same record down below in transaction T1? What should happen?
Nhưng chuyện gì sẽ xảy ra nếu tôi cũng cố cập nhật đối tượng đó, cùng bản ghi đó ở bên dưới, trong giao dịch T1? Điều gì nên xảy ra?
Stalls, right, because the transaction at the top has the exclusive lock on the logical object where ID equals one, the logical tuple, therefore it has to wait.
Bị treo lại, đúng không, vì giao dịch ở trên đang giữ khóa độc quyền trên đối tượng logic có ID bằng một, tức tuple logic đó, nên nó phải chờ.
And then now if I go up here, now I commit, what's going to happen? The lock gets released by the top transaction, and the bottom transaction can then acquire it.
Và giờ nếu tôi lên trên này và commit thì chuyện gì sẽ xảy ra? Khóa được giao dịch ở trên giải phóng, và giao dịch ở dưới khi đó có thể lấy được khóa.
Now here's the question. So it started off at 100, the transaction at the top made it 101. What is going to be the value down below now? They say 101.
Đây là câu hỏi. Giá trị ban đầu là 100, giao dịch ở trên đã làm nó thành 101. Vậy giá trị ở bên dưới bây giờ sẽ là bao nhiêu? Có bạn nói 101.
Raise your hand if you're saying 100. Nobody, good. Raise your hand if you're saying 101. Raise your hand if you're saying 102.
Ai nghĩ là 100 thì giơ tay. Không ai, tốt. Ai nghĩ là 101 thì giơ tay. Ai nghĩ là 102 thì giơ tay.
102. Right, because we're still in the transaction down below. This is still an active transaction. The one at the top has committed, the one down below is still active.
102. Đúng, vì chúng ta vẫn đang ở trong giao dịch bên dưới. Đây vẫn là một giao dịch đang hoạt động. Giao dịch ở trên đã commit, còn giao dịch bên dưới vẫn đang hoạt động.
So it was then, now when it does the write, it then gets the latest version and then can actually update it.
Nên khi nó thực hiện thao tác ghi, nó lấy phiên bản mới nhất rồi mới thực sự cập nhật được.
Because the default in Postgres is read committed. Not repeatable read. So when I do my update, how do you do an update? You got to go update it first.
Vì mặc định trong Postgres là read committed, không phải repeatable read. Vậy khi tôi cập nhật thì làm thế nào? Phải cập nhật nó trước đã.
Or sorry, you got to go read it, find the thing you want to update, then update it.
À xin lỗi, phải đọc nó trước, tìm thứ cần cập nhật, rồi mới cập nhật.
So in this case here, because the transaction at the top committed, under read committed, the bottom transaction now reads that version, and then goes and updates it and increments the counter.
Trong trường hợp này, vì giao dịch ở trên đã commit, nên với read committed, giao dịch bên dưới giờ đọc phiên bản đó, rồi cập nhật nó và tăng bộ đếm.
So we can prove that again. So watch. So I'll start a transaction at the top. And we see now it's 101. Start a transaction at the bottom. Read it now.
Ta có thể chứng minh lại điều này. Xem nhé. Tôi bắt đầu một giao dịch ở trên. Và giờ ta thấy là 101. Bắt đầu một giao dịch ở dưới. Đọc nó bây giờ.
It's 101 as expected. Now I do my update up here. Down below, I can't see it because the transaction at the bottom has not, sorry, the transaction at the top has not committed yet.
Là 101 như mong đợi. Giờ tôi cập nhật ở trên này. Ở dưới, tôi không thấy được vì giao dịch ở dưới chưa, xin lỗi, giao dịch ở trên chưa commit.
But now when I go to commit, right, I can see the change.
Nhưng giờ khi tôi commit thì tôi thấy được thay đổi.
All right. All right, let's try MySQL.
Được rồi. Giờ thử MySQL.
Same thing. I have a simple table with two records. So make sure I'm not serializable.
Cũng vậy. Tôi có một bảng đơn giản với hai bản ghi. Nên hãy chắc là tôi không ở chế độ serializable.
All right, so I'll start a transaction at the top, start a transaction at the bottom, do the same thing.
Được rồi, tôi bắt đầu một giao dịch ở trên, bắt đầu một giao dịch ở dưới, làm y như vậy.
I'm going to read that one record. Where am I?
Tôi sẽ đọc bản ghi đó. Tôi đang ở đâu đây?
I think it's copy and paste, sorry.
Chắc là do sao chép và dán, xin lỗi.
I'm surprised they let me be in a transaction for that. All right, actually, MySQL, I think, lets you do transactions across databases. Postgres does not.
Tôi ngạc nhiên là nó cho tôi ở trong giao dịch với thao tác đó. Mà thực ra, MySQL tôi nghĩ cho phép thực hiện giao dịch xuyên nhiều cơ sở dữ liệu. Postgres thì không.
All right. Try this again. So now I'll start a transaction. I see 100. Start a transaction. I see 100.
Được rồi. Thử lại nhé. Giờ tôi bắt đầu một giao dịch. Tôi thấy 100. Bắt đầu một giao dịch. Tôi thấy 100.
And then now I'm going to do that same update for one, which I see at the bottom, 100, correct?
Và giờ tôi sẽ thực hiện cùng phép cập nhật đó cho bản ghi một, mà tôi thấy ở bên dưới, là 100, đúng không?
Yes. Right? Under SAP's isolation or under multi-versioning, you're not going to see the changes for uncommitted transactions.
Đúng. Phải không? Với cô lập kiểu SAP hay với đa phiên bản, bạn sẽ không thấy các thay đổi của những giao dịch chưa commit.
But then now, if I commit this transaction at the top, and of course, if I go read it from the top, I see 101 for ID equals 1.
Nhưng bây giờ, nếu tôi commit giao dịch ở phía trên, và tất nhiên, nếu tôi đọc lại từ phía trên, tôi thấy 101 với ID bằng 1.
Now at the bottom, still in this transaction, if I run this query, what will I see, 100 or 101? 100. Because by default, MySQL runs with repeatable reads.
Còn ở phía dưới, vẫn trong giao dịch này, nếu tôi chạy truy vấn này thì sẽ thấy gì, 100 hay 101? 100. Vì mặc định MySQL chạy với repeatable read.
So even though the transaction at the top is committed, the one at the bottom wants to see what it saw before, so it's not going to see that.
Nên dù giao dịch ở phía trên đã commit, giao dịch ở phía dưới muốn thấy lại đúng những gì nó đã thấy trước đó, nên nó sẽ không thấy thay đổi đó.
But then let's try this now. Let's try a new transaction at the top. Let me kill this one at the bottom. Start a new transaction here, right?
Nhưng giờ hãy thử cái này. Thử một giao dịch mới ở phía trên. Tôi tắt giao dịch ở phía dưới. Bắt đầu một giao dịch mới ở đây, được chứ?
We see 101, 200. Now I'm going to update it. I haven't read it at the bottom yet. What should I see? 102 or 101?
Ta thấy 101, 200. Bây giờ tôi sẽ cập nhật nó. Tôi chưa đọc ở phía dưới. Tôi sẽ thấy gì? 102 hay 101?
101. Right? In this case here, even though it is a repeatable read, because with multi-versioning, the top transaction has not committed yet, it can't see it.
101. Đúng không? Trong trường hợp này, dù là repeatable read, thì do có đa phiên bản, giao dịch phía trên chưa commit, nên nó không thể thấy được.
So if I now commit, it should be just like before, right? I don't see it. So how can we see what's actually going on?
Giờ nếu tôi commit thì sẽ giống như lúc nãy, đúng không? Tôi không thấy nó. Vậy làm sao xem được chuyện gì đang thực sự xảy ra?
So in Postgres, we didn't do this before. I don't think I gave a demo of how it's actually storing.
Với Postgres, trước đây ta chưa làm việc này. Tôi không nghĩ là tôi đã demo cách nó thực sự lưu trữ.
It might be in a transaction. That's why. Yeah, it was. So now, all right.
Có thể nó đang nằm trong một giao dịch. Đó là lý do. Vâng, đúng vậy. Được rồi.
So I haven't talked about this before in Postgres, but of how it's actually storing records and what it's actually storing in the metadata.
Trước đây tôi chưa nói về điều này trong Postgres, tức là cách nó thực sự lưu các bản ghi và nó thực sự lưu những gì trong siêu dữ liệu.
But in Postgres, it's going to store the timestamps physically in the tuple with the xmin and xmax.
Nhưng trong Postgres, nó lưu các timestamp một cách vật lý trong tuple, với xmin và xmax.
So now for my table here, you see that now I have xmin, there's some timestamp, 1396. That's going to correspond to whatever transaction I created it.
Với bảng của tôi ở đây, bạn thấy giờ có xmin, là một timestamp nào đó, 1396. Nó tương ứng với giao dịch nào đã tạo ra bản ghi này.
And then the xmax 0 just means it's the latest version. And then that ctid thing, that one I don't think I talked about, but that's basically the record ID.
Còn xmax bằng 0 nghĩa là đây là phiên bản mới nhất. Và cái ctid này, tôi nghĩ tôi chưa nói tới, nhưng về cơ bản đó là record ID.
That's the page number and the slot number for any tuple. So that's not actually physically stored the same way the timestamps are.
Đó là số trang và số slot của một tuple bất kỳ. Nên nó không được lưu vật lý theo cách giống như các timestamp.
It's derived from the, as it's scanning the data, I know I'm reading this page and this offset number. And in case of Postgres, you can actually do lookups like this.
Nó được suy ra từ, khi quét dữ liệu, tôi biết mình đang đọc trang này và số offset này. Và với Postgres, bạn thực sự có thể tra cứu như thế này.
You can physically address it like transaction demo where ctid equals, and then you can pass in this.
Bạn có thể định địa chỉ vật lý, như transaction demo where ctid bằng, rồi truyền giá trị này vào.
Right? And you can actually read tuples that way. You don't want to do it that way because, again, when I create new versions, it's going to get moved around.
Đúng không? Và bạn thực sự có thể đọc các tuple theo cách đó. Bạn không nên làm theo cách đó vì, khi tôi tạo các phiên bản mới, nó sẽ bị di chuyển đi chỗ khác.
But let me now do this with serializable isolation.
Nhưng giờ hãy làm điều này với cô lập serializable.
I don't think I'm going to transaction. Let me see. Yeah. Okay. So in Postgres, when you call begin, you can set what isolation level you want.
Tôi nghĩ là mình chưa vào giao dịch. Để xem nào. Vâng. Được rồi. Trong Postgres, khi bạn gọi begin, bạn có thể đặt mức cô lập mà bạn muốn.
So now I'm going to say I want it to be serializable. So now I'm going to read the, in the top transaction, I'm going to read the data.
Bây giờ tôi sẽ chọn mức cô lập là serializable. Giờ ở giao dịch phía trên, tôi sẽ đọc dữ liệu.
And again, now I see the ctid and I see the xmin xmax timestamps for this transaction. So now in the bottom transaction, I'm going to update it.
Và một lần nữa, giờ tôi thấy ctid và thấy các dấu thời gian xmin xmax của giao dịch này. Giờ ở giao dịch phía dưới, tôi sẽ cập nhật nó.
And so now what I'm doing here, I'm adding this returning clause here. This is saying, run this update query and return back something for me.
Và ở đây tôi thêm mệnh đề returning vào. Nó có nghĩa là: chạy câu truy vấn update này và trả về cho tôi một thứ gì đó.
This is here. I think of it like the projection output of a select statement. This, I wanted to call this function transaction ID current.
Ở đây, hãy coi nó như đầu ra phép chiếu của một câu lệnh select. Tôi muốn gọi hàm transaction ID current này.
And this gives you, in Postgres, what's the ID of my transaction. So now it calls my update. And now I see I get transaction ID 1397.
Và trong Postgres, nó cho bạn biết ID của giao dịch của tôi là gì. Giờ nó chạy update của tôi. Và tôi thấy mình nhận được transaction ID 1397.
So now If I go back to the top terminal and I run this query, what should I see?
Giờ nếu tôi quay lại terminal phía trên và chạy truy vấn này, bạn nghĩ tôi sẽ thấy gì?
Still see the previous version I saw before, but now you can see where before the X max was zero or null, now it's 1397, which is the transaction ID of my transaction at the bottom.
Vẫn thấy phiên bản trước đó như lúc nãy, nhưng giờ bạn thấy chỗ xmax trước đây bằng 0 hoặc null, giờ là 1397, chính là ID giao dịch của giao dịch phía dưới.
This is like proving that, like, this is actually updating things in the way that we discussed. Postgres is like a textbook definition of a data system like this.
Điều này giống như chứng minh rằng việc cập nhật thực sự diễn ra đúng như chúng ta đã thảo luận. Postgres giống như định nghĩa trong sách giáo khoa về một hệ thống dữ liệu kiểu này.
But you also see now too, if I run the same query down here, the one at the top sees the latest version.
Nhưng giờ bạn cũng thấy, nếu tôi chạy cùng truy vấn ở dưới này, thì giao dịch phía trên thấy phiên bản mới nhất.
And if you look at the... Let me bring it down a little bit, sorry.
Và nếu bạn nhìn vào... Để tôi kéo xuống một chút, xin lỗi.
The one at the top, when I run select star on the table, you see that, look at the CTID.
Ở giao dịch phía trên, khi tôi chạy select star trên bảng, bạn thấy đấy, hãy nhìn CTID.
I'm seeing the tuple at page zero offset slot one and page zero offset slot two.
Tôi thấy các tuple ở trang 0 khe offset 1 và trang 0 khe offset 2.
Down below, since this is the transaction that modified the table, I'm seeing the first version of the second tuple at zero two, but I'm also now seeing my new version, zero three.
Ở phía dưới, vì đây là giao dịch đã sửa đổi bảng, tôi thấy phiên bản đầu tiên của tuple thứ hai ở 0 2, nhưng giờ tôi cũng thấy phiên bản mới của mình, 0 3.
So Postgres is actually storing the new version in another slot inside the page, which is a terrible way to do it, but we'll cover that in a second.
Vậy Postgres thực sự lưu phiên bản mới ở một khe khác trong trang, đó là một cách làm tệ, nhưng chúng ta sẽ bàn ngay sau đây.
All right, let me roll these back.
Được rồi, để tôi rollback những giao dịch này.
And we can prove that Postgres is doing deadlock detection, because if I run transactions and have a deadlock, it'll kill it.
Và chúng ta có thể chứng minh rằng Postgres có phát hiện bế tắc, vì nếu tôi chạy các giao dịch và gây ra bế tắc, nó sẽ hủy một giao dịch.
So what I'm going to do now is tell Postgres, check for a deadlock in 10 seconds to kill something.
Giờ tôi sẽ bảo Postgres rằng hãy kiểm tra bế tắc sau 10 giây để hủy một giao dịch.
So I'll have my transaction at the top start, transaction at the bottom start, we're good there. The transaction at the top is going to modify where ID equals one, right?
Vậy tôi cho giao dịch phía trên bắt đầu, giao dịch phía dưới bắt đầu, thế là ổn. Giao dịch phía trên sẽ sửa dòng có ID bằng 1, đúng không?
I'm allowed to do that. I get the exclusive lock on it. Transaction at the bottom is going to update ID equals two. That's allowed to happen. That's fine.
Tôi được phép làm vậy. Tôi lấy được khóa độc quyền trên nó. Giao dịch phía dưới sẽ cập nhật dòng có ID bằng 2. Điều đó được phép xảy ra. Không sao cả.
But now the one at the top is now going to try to update ID equals two. It has to stall because it can't get the exclusive lock on that.
Nhưng giờ giao dịch phía trên sẽ thử cập nhật dòng có ID bằng 2. Nó phải bị treo vì không lấy được khóa độc quyền trên dòng đó.
The one at the bottom is going to try to update one. It's going to stall two because the top guy has the exclusive lock on that.
Giao dịch phía dưới sẽ thử cập nhật dòng 1. Nó sẽ bị treo ở bản ghi hai vì giao dịch ở trên đang giữ khóa độc quyền trên đó.
And then within 10 seconds, the deadlock detector is going to run, and it's going to kill one of them. And there you see this. The one at the top got killed.
Và trong vòng 10 giây, bộ phát hiện bế tắc sẽ chạy, và nó sẽ hủy một trong hai giao dịch. Và các em thấy đây. Giao dịch ở trên đã bị hủy.
See deadlock report, right?
Thấy báo cáo bế tắc chứ?
Killed the one at the top, and then my one at the bottom, as soon as the one at the top got killed, the bottom one was allowed to run immediately, because the lock gets released.
Nó hủy giao dịch ở trên, và giao dịch ở dưới của tôi, ngay khi giao dịch ở trên bị hủy, giao dịch ở dưới được phép chạy ngay lập tức, vì khóa được giải phóng.
All right, one more thing. So that was with serializability, or serializable isolation level.
Được rồi, còn một điều nữa. Đó là với tính khả tuần tự hóa, hay mức cô lập serializable.
Let's now run this at a lower isolation level. Let's do read uncommitted.
Bây giờ ta chạy ở mức cô lập thấp hơn. Ta dùng read uncommitted.
Right? Both transactions are running with that isolation level. And now, again, I can run my query at the top.
Đúng không? Cả hai giao dịch đều chạy với mức cô lập đó. Và bây giờ, tôi lại có thể chạy truy vấn ở trên.
I see the two versions I expect to see. I see the one at the bottom as well.
Tôi thấy hai phiên bản như mong đợi. Tôi cũng thấy phiên bản ở dưới.
The xmax, the max timestamp, the end timestamp got updated with $13 .99. This is where, I'm not showing this.
xmax, tức mốc thời gian lớn nhất, mốc thời gian kết thúc, đã được cập nhật thành $13 .99. Đây là chỗ mà tôi không hiển thị.
There's a transaction table that's going to tell you whether the transaction that last modified this, whether this actually has committed or not.
Có một bảng giao dịch sẽ cho biết giao dịch đã sửa đổi lần cuối bản ghi này thực sự đã commit hay chưa.
In this case here, $13 .99 did not commit. It's something I rolled back.
Trong trường hợp này, $13 .99 chưa commit. Tôi đã rollback nó.
So when they go read a version, they would say, I know this one has an xmax, but it's in the range of a little down to the C, but this is actually the latest version.
Vì vậy khi đọc một phiên bản, hệ thống sẽ nói: tôi biết bản này có xmax, nhưng nó nằm trong khoảng một chút xuống đến C, nhưng thực ra đây là phiên bản mới nhất.
There isn't anything else after that I want to look at. But that's a minor detail. All right, so now, we're going to have the one at the top.
Không có gì sau đó mà tôi cần xem nữa. Nhưng đó chỉ là chi tiết nhỏ. Được rồi, bây giờ ta có giao dịch ở trên.
They're going to update the record.
Nó sẽ cập nhật bản ghi.
All right, admin value return, my transaction ID is 1,400. Now at the bottom, if I run this query, what should I see?
Được rồi, giá trị admin trả về, ID giao dịch của tôi là 1,400. Bây giờ ở dưới, nếu tôi chạy truy vấn này, tôi sẽ thấy gì?
Should I see the version that the top created, or should I see whatever the latest version that I saw when I ran it the first time? And again, I'm running on a read uncommitted.
Tôi sẽ thấy phiên bản mà giao dịch ở trên tạo ra, hay tôi sẽ thấy phiên bản mới nhất mà tôi đã thấy khi chạy lần đầu? Và nhắc lại, tôi đang chạy ở read uncommitted.
The top transaction is uncommitted.
Giao dịch ở trên chưa commit.
Should the bottom transaction see the top transaction's change? Yes. What's that? Could. Right? It does not.
Giao dịch ở dưới có nên thấy thay đổi của giao dịch ở trên không? Có. Gì cơ? Có thể. Đúng không? Nhưng nó không thấy.
So Postgres is lying to you, but in a good way. So you tell Postgres, I want to run read uncommitted. It doesn't actually give you that. It'll still give you read committed.
Vậy là Postgres nói dối các em, nhưng theo hướng tốt. Các em bảo Postgres, tôi muốn chạy read uncommitted. Nó thực ra không cho các em mức đó. Nó vẫn cho read committed.
Because it's more work and more engineering to go add support for read uncommitted, let you go read things that haven't committed yet, so they didn't implement it.
Vì tốn nhiều công sức và kỹ thuật hơn để bổ sung hỗ trợ read uncommitted, cho phép đọc những thứ chưa commit, nên họ không triển khai.
So by default, it's just read committed. You need to be asked for something lower. Oracle's the opposite. Oracle says, you say I want something higher.
Vì vậy mặc định nó chỉ là read committed. Các em phải yêu cầu mức thấp hơn nữa. Oracle thì ngược lại. Các em yêu cầu mức cao hơn.
The lighting will say, yeah, you got it, but it's actually something lower. So it's better to lie, I guess, better to overperform rather than underperform when people ask for certain things.
Nó sẽ nói, vâng, được thôi, nhưng thực ra là mức thấp hơn. Nên tôi đoán nói dối theo hướng tốt thì hơn, cung cấp vượt mức tốt hơn so với kém hơn khi người ta yêu cầu một số thứ.
But it's debatable whether how much read uncommitted could actually help performance. In this case here, since I can always read a consistent snapshot, that's probably OK.
Nhưng còn tranh cãi là read đến mức nào uncommitted thực ra có thể giúp cải thiện hiệu năng. Trong trường hợp này, vì tôi luôn có thể đọc một snapshot nhất quán, nên có lẽ như vậy cũng ổn.
Their statement is, under MVCC, is read uncommitted not going to give you anything meaningful? No. I'm saying the Postgres implementation of MVCC is not going to do that for you.
Ý của bạn là, với MVCC, read uncommitted sẽ không mang lại cho bạn điều gì có ý nghĩa, đúng không? Không. Tôi đang nói là cách Postgres cài đặt MVCC sẽ không làm điều đó cho bạn.
The question is, in my examples, I was reading the table when I was getting the shared lock. Or what are you saying?
Câu hỏi là, trong các ví dụ của tôi, tôi đã đọc bảng khi đang lấy khóa chia sẻ (shared lock). Hay bạn muốn nói điều gì khác?
For this one, it would be ID was the primary key. So whatever.
Với trường hợp này thì ID là khóa chính. Thôi kệ.
Sure. OK. Would it execute the read?
Được. OK. Nó có thực thi thao tác đọc không?
OK.
OK.
So the locks are on logical objects. So I can physically read all the versions. So if I had to scan everything, I'm going to physically read all the versions.
Vậy các khóa được đặt trên các đối tượng logic. Nên tôi có thể đọc vật lý tất cả các phiên bản. Vậy nếu phải quét mọi thứ, tôi sẽ đọc vật lý tất cả các phiên bản.
I'm allowed to do that because I have to go check to see whether timestamps are actually Visible to me.
Tôi được phép làm vậy vì tôi phải kiểm tra xem các timestamp có thực sự hiển thị (visible) với tôi hay không.
And I know that because I'm not overwriting anything, it's not like something's going to get swapped out when I'm trying to read stuff.
Và tôi biết điều đó vì tôi không ghi đè lên bất cứ thứ gì, nên không có chuyện thứ gì đó bị hoán đổi mất khi tôi đang đọc dữ liệu.
So then it's only when I go then try to say, I want to update stuff, then I would acquire the lock on the logical object I want to modify.
Vậy chỉ khi tôi muốn cập nhật dữ liệu, thì tôi mới lấy khóa trên đối tượng logic mà tôi muốn sửa đổi.
AUDIENCE MEMBER 3: So you apply the change, you apply the change, you agree to a lock, and then you separate between the update and the update executor? Yes.
KHÁN GIẢ 3: Vậy bạn áp dụng thay đổi, bạn áp dụng thay đổi, bạn đồng ý lấy khóa, rồi bạn tách biệt giữa bản cập nhật và update executor? Đúng.
Whether or not it happens in the update executor or not, beforehand, it depends on the implementation. But you would know, it depends on how your lock manager, how you're organizing, keeping track of locks.
Việc nó có xảy ra trong update executor hay trước đó hay không phụ thuộc vào cách cài đặt. Nhưng bạn sẽ biết, nó phụ thuộc vào lock manager của bạn, cách bạn tổ chức và theo dõi các khóa.
Do I keep track of them on the record ID level? No, because those record IDs could get moved around. So you would maybe, you typically do it on the primary key level.
Tôi có theo dõi chúng ở mức record ID không? Không, vì các record ID đó có thể bị di chuyển. Nên thường bạn sẽ làm ở mức khóa chính.
So in that case, if I have the primary key, I can lock it before I get to the update executor, because I know what it is. Yes.
Như vậy, nếu tôi có khóa chính, tôi có thể khóa nó trước khi đến update executor, vì tôi biết nó là gì. Đúng.
Question is, do I need a multi-version indexes? Yes. Let's keep going, we'll get to that. We only have 30 minutes left, there's still a lot of cover. All right, so version storage.
Câu hỏi là, tôi có cần chỉ mục đa phiên bản không? Có. Hãy tiếp tục, chúng ta sẽ nói đến phần đó. Chúng ta chỉ còn 30 phút, vẫn còn rất nhiều nội dung. Được rồi, vậy là lưu trữ phiên bản (version storage).
This is the most important thing, is how we're actually going to be storing these different versions. And the idea is that we're not going to have all the tuples just randomly in our table.
Đây là điều quan trọng nhất, đó là chúng ta thực sự sẽ lưu các phiên bản khác nhau này như thế nào. Ý tưởng là chúng ta sẽ không để tất cả các tuple nằm ngẫu nhiên trong bảng.
Well, they could be still random, but I don't have to scan and try to find what versions are visible to me every time you run.
Ừ thì chúng vẫn có thể ngẫu nhiên, nhưng tôi không phải quét và tìm xem phiên bản nào hiển thị với tôi mỗi lần chạy.
Instead, we're going to maintain basically a linked list, using the header of every tuple to keep track of what's the next version in the version chain for a logical tuple.
Thay vào đó, về cơ bản chúng ta sẽ duy trì một danh sách liên kết, dùng phần header của mỗi tuple để theo dõi phiên bản kế tiếp trong chuỗi phiên bản của một tuple logic là gì.
What's the next physical version I should be looking at? So indexes are always going to point to the head of the chain.
Phiên bản vật lý tiếp theo mà tôi nên xem là gì? Vì vậy, các chỉ mục luôn trỏ đến đầu của chuỗi.
And then the different storage schemes that we'll talk about will vary in whether it's going to be, what is at the head of the version chain, and what is inside the actual version chain itself.
Và các lược đồ lưu trữ khác nhau mà chúng ta sẽ nói đến sẽ khác nhau ở chỗ cái gì nằm ở đầu chuỗi phiên bản, và cái gì nằm bên trong chính chuỗi phiên bản đó.
So the three approaches are to do append-only, time travel, and delta storage. Append-only is the basic idea of what I've been showing so far.
Ba cách tiếp cận là append-only, time travel, và delta storage. Append-only là ý tưởng cơ bản mà tôi đã trình bày cho đến giờ.
Anytime I want to update a tuple, I make a complete copy of that tuple and write my changes into that copy.
Bất cứ khi nào tôi muốn cập nhật một tuple, tôi tạo một bản sao hoàn chỉnh của tuple đó và ghi các thay đổi vào bản sao này.
And I'm just appending that into the same storage space I would have for all my tuples.
Và tôi chỉ nối nó vào cùng một không gian lưu trữ dùng cho tất cả các tuple của tôi.
Time travel storage is similar to append-only, but instead of storing the different versions in the same table space as your regular tuples, I'm actually going to have a separate virtual table that's tied to the main table, where I'm just going to put all my versions inside of that.
Time travel storage tương tự append-only, nhưng thay vì lưu các phiên bản khác nhau trong cùng không gian bảng với các tuple thông thường, tôi sẽ có một bảng ảo riêng gắn với bảng chính, và tôi sẽ đặt tất cả các phiên bản vào trong đó.
So I still make a copy of the tuple, but instead of making a new copy in the same page where the tuple originally was existing, I'm going to put it into some other storage space.
Vậy tôi vẫn tạo một bản sao của tuple, nhưng thay vì tạo bản sao mới trong cùng trang nơi tuple ban đầu đang nằm, tôi sẽ đặt nó vào một không gian lưu trữ khác.
The last approach, which is the best approach, is to do what's called delta storage, where I don't actually make a complete copy of the tuple any time I'm going to modify it.
Cách tiếp cận cuối cùng, và cũng là cách tốt nhất, là cái gọi là delta storage, trong đó tôi không thực sự tạo một bản sao hoàn chỉnh của tuple mỗi khi tôi sửa đổi nó.
I only create a delta record, like a diff, that keeps track of, here's the changes of the columns that were modified.
Tôi chỉ tạo một bản ghi delta, giống như một diff, theo dõi các thay đổi của những cột đã bị sửa.
And so you just copy what the old values are of the things that you modified, and you overwrite the main table tuple with the latest version.
Như vậy bạn chỉ sao chép các giá trị cũ của những phần đã sửa, và ghi đè tuple ở bảng chính bằng phiên bản mới nhất.
So delta storage is the most common one. This is how pretty much everyone builds a modern multi-versioning system today. The append-only one is less common, but it's what Postgres does.
Delta storage là cách phổ biến nhất. Hầu như tất cả mọi người ngày nay đều xây dựng hệ thống đa phiên bản hiện đại theo cách này. Append-only ít phổ biến hơn, nhưng đó là cách Postgres làm.
So pretty much anybody that forks Postgres is going to be doing this. Yes?
Nên hầu như bất kỳ ai fork Postgres cũng sẽ làm theo cách này. Bạn hỏi gì?
The question is, for time travel storage, am I storing the last version or all versions, all older versions?
Câu hỏi là, với time travel storage, tôi lưu phiên bản cuối cùng hay tất cả các phiên bản, tức mọi phiên bản cũ hơn?
SAP HANA put the newest version, for whatever reason, in the time travel storage, and they flipped it. They got rid of that. But in general, yeah. I saw the main table.
SAP HANA đã đặt phiên bản mới nhất vào time travel storage, không rõ vì sao, và họ đã đảo ngược lại. Họ bỏ cách đó rồi. Nhưng nhìn chung, đúng vậy. Tôi thấy bảng chính.
I'll go through tables. Before I overwrite the one in the main table, I make a copy of the old version, put that in the time travel storage.
Tôi sẽ đi qua các bảng. Trước khi ghi đè bản trong bảng chính, tôi tạo một bản sao của phiên bản cũ, và đặt nó vào time travel storage.
It's, at a high level, it's the same as the first approach. It's just because you're copying the entire tuple, but the way you're storing it is separate and has some benefits.
Ở mức tổng quát, nó giống cách tiếp cận đầu tiên. Chỉ là vì bạn sao chép toàn bộ tuple, nhưng cách lưu trữ thì tách biệt và có một số lợi ích.
All right, so the second one is rare. The first one, again, it's easy to do, because you just make a copy of the tuple and update things.
Được rồi, cách thứ hai thì hiếm. Cách đầu tiên, một lần nữa, dễ làm, vì bạn chỉ sao chép tuple rồi cập nhật.
But it's actually terrible. And so my takeaway for this is, don't do this. Even though Postgres does this, don't do this.
Nhưng thực ra nó rất tệ. Nên điều rút ra ở đây là: đừng làm cách này. Dù Postgres làm vậy, cũng đừng làm cách này.
Postgres, as great as it is as a database system, this is actually the worst part of its implementation. It's got a terrible back end. I've said this publicly.
Postgres, dù là một hệ quản trị cơ sở dữ liệu tuyệt vời, thì đây thực ra là phần tệ nhất trong cách triển khai của nó. Phần back end của nó rất tệ. Tôi đã nói công khai điều này rồi.
I have a blog article that says, the part of Postgres we hate the most, it's this. It's what I'm talking about right now.
Tôi có một bài blog nói rằng phần của Postgres mà chúng tôi ghét nhất chính là cái này. Chính là thứ tôi đang nói đến bây giờ.
They did it in the 80s, but nobody would do this now today. MySQL and Oracle do the last approach, the delta storage, and that's the right way to do it.
Họ làm vậy từ những năm 80, nhưng ngày nay không ai làm thế này nữa. MySQL và Oracle dùng cách cuối cùng, delta storage, và đó là cách làm đúng.
Let's see why. All right, so append-only storage. Again, it just means that any time I'm going to modify a tuple, I append a new version of that tuple into my regular table space.
Hãy xem tại sao. Được rồi, đầu tiên là append-only storage. Một lần nữa, nó nghĩa là mỗi khi tôi sửa một tuple, tôi sẽ thêm vào cuối một phiên bản mới của tuple đó trong table space thông thường của mình.
So say I'm going to update object A.
Giả sử tôi sắp cập nhật đối tượng A.
I'll first copy the current version for all its values in some kind of memory buffer, and then I'll install the change into the page with the latest version.
Trước tiên tôi sẽ sao chép phiên bản hiện tại cùng mọi giá trị của nó vào một vùng đệm bộ nhớ nào đó, rồi áp dụng thay đổi vào trang chứa phiên bản mới nhất.
But then now I've got to go update the pointer in the tuple.
Nhưng sau đó tôi còn phải cập nhật con trỏ trong tuple.
I'm showing at the end because it's PowerPoint, but it's in the header of the tuple to now reflect that I have a new version here, and then I update things in my version chain.
Tôi vẽ nó ở cuối vì đây là PowerPoint, nhưng thực ra nó nằm trong header của tuple, để phản ánh rằng giờ đã có một phiên bản mới ở đây, rồi tôi cập nhật version chain của mình.
But in my example here, the way I'm ordering the versions is by oldest to newest. So the oldest version is A0. The indexes would point to A0.
Nhưng trong ví dụ này, cách tôi sắp xếp các phiên bản là từ cũ nhất đến mới nhất. Vậy phiên bản cũ nhất là A0. Các index sẽ trỏ tới A0.
So now if I want to find the newest version, I've got to scan along, look at the different versions, follow the pointer until I find the one that's visible to me based on the begin and end timestamps.
Giờ nếu muốn tìm phiên bản mới nhất, tôi phải duyệt dọc theo chuỗi, xem từng phiên bản, lần theo con trỏ cho đến khi tìm được phiên bản hiển thị với mình, dựa trên các timestamp bắt đầu và kết thúc.
So the version chain ordering can go a bunch of different ways. So what I've shown so far is the oldest and newest.
Thứ tự của version chain có thể theo nhiều cách khác nhau. Những gì tôi trình bày đến giờ là từ cũ nhất đến mới nhất.
The basic idea is that any time I want to make a new version, I just append it to the end. But now, of course, most of your transactions want the latest version.
Ý tưởng cơ bản là mỗi khi muốn tạo một phiên bản mới, tôi chỉ thêm nó vào cuối. Nhưng tất nhiên, hầu hết các transaction đều muốn phiên bản mới nhất.
I don't care about the oldest version, usually.
Thường thì tôi không quan tâm đến phiên bản cũ nhất.
So that means that when I want to find the latest version of this object A, I've got to follow into the head of the version chain through an index, or however I got there, with a record ID.
Nghĩa là khi muốn tìm phiên bản mới nhất của đối tượng A này, tôi phải đi vào đầu của version chain qua một index, hoặc bằng cách nào đó đến được đó, với một record ID.
And then I scan along until I find the end, or find the version that's actually visible to me.
Rồi tôi duyệt dọc theo cho đến khi tới cuối, hoặc tìm được phiên bản thực sự hiển thị với mình.
So if your version chain is really, really long, then this is going to suck and be slow. But it does have some other benefits we'll talk about in a second.
Nên nếu version chain của bạn rất, rất dài, thì cách này sẽ tệ và chậm. Nhưng nó cũng có vài lợi ích khác mà lát nữa chúng ta sẽ nói.
The alternative is to do newest to oldest, where this just says now the version chain is ordered by where the head is the newest version.
Cách khác là sắp xếp từ mới nhất đến cũ nhất, nghĩa là giờ version chain được sắp xếp sao cho phần đầu là phiên bản mới nhất.
So if I want to create now a new version for this object, then I slide everybody over, put something at the head of the version chain, and just update my pointer that way.
Vậy nếu giờ tôi muốn tạo một phiên bản mới cho đối tượng này, thì tôi dịch mọi phiên bản sang một vị trí, đặt phiên bản mới vào đầu version chain, và chỉ cập nhật con trỏ theo cách đó.
But I also have to update now whatever the record ID is that corresponds to this logical tuple in an index, or indexes, plural.
Nhưng giờ tôi cũng phải cập nhật record ID tương ứng với tuple logic này trong một index, hoặc nhiều index.
Because now the head is not where A3 was. Head is where A4 is. Again, I'm creating a new version. I'm appending that into my table space.
Vì giờ phần đầu không còn là chỗ của A3 nữa. Phần đầu là chỗ của A4. Một lần nữa, tôi tạo ra một phiên bản mới. Tôi nối nó vào table space của mình.
So now I've got to go update all those indexes to reflect this.
Vì vậy bây giờ tôi phải đi cập nhật tất cả các chỉ mục đó để phản ánh điều này.
Of course, now if my transactions only need the latest version, then that's super easy to do, because I just pop to the head and I'm done.
Tất nhiên, nếu các transaction của tôi chỉ cần phiên bản mới nhất, thì việc đó cực kỳ dễ, vì tôi chỉ cần nhảy tới đầu chuỗi là xong.
All right, time travel storage.
Được rồi, time travel storage.
Again, the idea is that instead of making a copy of a tuple and appending it to the regular table space, I'll first make a copy of it, the old version, into this separate table space.
Ý tưởng là thay vì tạo một bản sao của tuple rồi nối nó vào table space thông thường, trước tiên tôi sẽ sao chép phiên bản cũ vào một table space riêng biệt này.
It just looks like a regular table, just internally you treat it differently. And then I update my version pointers to point to these things now.
Nó trông giống một bảng bình thường, chỉ là bên trong bạn xử lý nó khác đi. Sau đó tôi cập nhật các con trỏ phiên bản để trỏ tới những phiên bản này.
And then I can overwrite now the master version, the main version in the main table. And I just have to update the pointer to point to the latest version in the version chain.
Rồi tôi có thể ghi đè lên phiên bản chính, phiên bản chính trong bảng chính. Và tôi chỉ cần cập nhật con trỏ để trỏ tới phiên bản mới nhất trong chuỗi phiên bản.
In this case here, we're going newest to oldest. This is what SQL Server does. SAP HANA was doing oldest to newest, and then they flipped that and got rid of that.
Trong trường hợp này, ta đi từ mới nhất đến cũ nhất. Đây là cách SQL Server làm. SAP HANA từng đi từ cũ nhất đến mới nhất, rồi sau đó họ đảo lại và bỏ cách đó.
So this seems like a trivial thing. Why would I store it in a separate table instead of the main table?
Nghe có vẻ đây là chuyện nhỏ. Tại sao lại lưu vào một bảng riêng thay vì bảng chính?
But now, because I know that this table over here is going to contain only old versions, assuming I'm going newest to oldest, then when I want to start doing garbage collection, I can just look at the time travel table and not interfere with the main table.
Nhưng bây giờ, vì tôi biết bảng ở đây sẽ chỉ chứa các phiên bản cũ, giả sử ta đi từ mới nhất đến cũ nhất, nên khi muốn bắt đầu thu gom rác, tôi chỉ cần xem bảng time travel mà không gây ảnh hưởng tới bảng chính.
In the case of Postgres, when the vacuum runs, the garbage collector runs, they got to touch the main table where all your other transactions are executing, and you potentially interfere with that.
Với Postgres, khi vacuum chạy, tức là bộ thu gom rác chạy, nó phải đụng tới bảng chính, nơi tất cả các transaction khác đang thực thi, và có thể gây ảnh hưởng tới chúng.
But as I said, the best way to do this, the preferable way to do this, is to do delta storage.
Nhưng như tôi đã nói, cách tốt nhất để làm việc này, cách nên dùng hơn, là dùng delta storage.
Again, the idea here is that any time I'm going to update a record, I first copy the columns that I'm going to modify into this separate space over here called the delta storage.
Ý tưởng ở đây là mỗi khi tôi cập nhật một bản ghi, trước tiên tôi sao chép các cột mà tôi sắp sửa đổi vào một không gian riêng ở đây gọi là delta storage.
I think Oracle and MySQL call it rollback segments. Basically, this is where I'm going to store all my deltas.
Tôi nghĩ Oracle và MySQL gọi nó là rollback segment. Về cơ bản, đây là nơi tôi lưu tất cả các delta.
So I'm going to put all the old versions of the tuples, just the columns that I modified, the attributes that I modified. All that goes over there.
Vì vậy tôi sẽ đặt tất cả các phiên bản cũ của tuple vào đó, chỉ gồm những cột mà tôi đã sửa, những thuộc tính mà tôi đã sửa. Tất cả những thứ đó đều nằm ở đó.
Once that's now installed, then I can overwrite whatever the latest version is in the main table, and then I'll update the pointer to point to this version.
Khi việc đó đã được cài đặt xong, tôi có thể ghi đè lên phiên bản mới nhất trong bảng chính, rồi cập nhật con trỏ để trỏ tới phiên bản này.
So then now, again, if I create much more versions, I update this record again, I just update the pointer to the head of the rollback segment for this version.
Vậy bây giờ, nếu tôi tạo thêm nhiều phiên bản nữa, cập nhật bản ghi này lần nữa, tôi chỉ cập nhật con trỏ tới đầu của rollback segment cho phiên bản này.
And I just update my pointers to maintain the version chain so I can go back and find the older versions.
Và tôi chỉ cập nhật các con trỏ để duy trì chuỗi phiên bản để có thể quay lại tìm các phiên bản cũ hơn.
And again, just like before, when I do garbage collection, which I'll talk about in a second, this is trivial to do.
Và cũng như trước, khi tôi thực hiện thu gom rác, mà tôi sẽ nói ngay sau đây, việc này rất đơn giản.
It's easier to do now because I can just, in some cases, if I keep track of the watermarks of what versions are visible to me, and I know that some big chunk of my rollback segment or delta storage is not visible to me at all, I just blow it away.
Giờ nó dễ làm hơn vì trong một số trường hợp tôi có thể nếu tôi theo dõi các watermark của những phiên bản mà tôi nhìn thấy được, và tôi biết rằng một phần lớn của rollback segment hay delta storage hoàn toàn không còn hiển thị với tôi, thì tôi chỉ việc xóa bỏ nó đi.
And I don't have to do any mucking around on the main table.
Và tôi không phải động chạm gì đến bảng chính cả.
So now if I want to go find an older version, it's just like playing a diff or a patch.
Bây giờ, nếu tôi muốn tìm một phiên bản cũ hơn, thì nó giống như áp dụng một diff hay một bản vá.
If I need to get version A2, then I would start by materializing in memory, here's my buffer space for my transaction, my query, here's A3, and go apply now the changes in this order.
Nếu tôi cần phiên bản A2, thì tôi sẽ bắt đầu bằng việc dựng lại trong bộ nhớ, đây là vùng đệm cho giao dịch của tôi, cho truy vấn của tôi, đây là A3, rồi áp dụng các thay đổi theo thứ tự này.
And that puts me back to the version I had before. In my example here, I'm only showing tuples with one attribute.
Và điều đó đưa tôi trở về phiên bản mà tôi có trước đó. Trong ví dụ này, tôi chỉ minh họa các tuple có một thuộc tính.
If you have 1,000 attributes and you only update one of them, this is way more efficient. All right, so how are we going to do this garbage collecting piece?
Nếu bạn có 1.000 thuộc tính và chỉ cập nhật một thuộc tính, thì cách này hiệu quả hơn rất nhiều. Được rồi, vậy chúng ta sẽ thực hiện phần garbage collection này như thế nào?
So the idea is that we're going to use those timestamps, the begin and end timestamps, and the transaction status table to determine what versions cannot be seen by any active transaction running right now.
Ý tưởng là chúng ta sẽ dùng các timestamp đó, tức timestamp bắt đầu và kết thúc, cùng với bảng trạng thái giao dịch để xác định những phiên bản nào không thể được nhìn thấy bởi bất kỳ giao dịch đang hoạt động nào ngay lúc này.
And again, remember, it's snapshot isolation. It says that transactions have a consistent view of the database. It means they can only see the versions that were committed before that transaction started.
Và hãy nhớ lại, đây là snapshot isolation. Nó nói rằng các giao dịch có một góc nhìn nhất quán về cơ sở dữ liệu. Nghĩa là chúng chỉ có thể thấy những phiên bản đã được commit trước khi giao dịch đó bắt đầu.
So if I have a newer version of an object from a committed transaction, then any other previous version could potentially be thrown away and deleted and removed, because no other transaction will be able to see it, because they'll always see that latest committed version.
Vì vậy, nếu tôi có một phiên bản mới hơn của một đối tượng từ một giao dịch đã commit, thì bất kỳ phiên bản trước đó nào đều có thể bị vứt bỏ, xóa và loại bỏ, vì không giao dịch nào khác có thể thấy nó, bởi vì chúng sẽ luôn thấy phiên bản đã commit mới nhất đó.
So now the challenge is going to be, how do we find these expired versions? And then how do we decide when it's safe to go ahead and reclaim them?
Vậy thách thức bây giờ là, làm sao chúng ta tìm ra những phiên bản hết hạn này? Và sau đó làm sao quyết định khi nào thì an toàn để thu hồi chúng?
I'll say also, too, it's not just versions that were created by committed transactions.
Tôi cũng xin nói thêm, không chỉ là các phiên bản được tạo ra bởi các giao dịch đã commit.
If my transaction made too much of changes and then it aborts, I got to go ahead and clean those versions up as well, because I know definitely no one could ever see them, because the transaction didn't finish.
Nếu giao dịch của tôi thực hiện quá nhiều thay đổi rồi bị hủy bỏ, thì tôi cũng phải dọn dẹp những phiên bản đó, vì tôi biết chắc chắn không ai có thể thấy chúng, bởi vì giao dịch đó đã không hoàn tất.
So the basic idea, we do this in the transaction status table.
Vậy ý tưởng cơ bản, chúng ta thực hiện việc này trong bảng trạng thái giao dịch.
You keep track of a watermark, a threshold that says, here's the global minimum transaction ID that could still see some versions of tuples or objects.
Bạn theo dõi một watermark, một ngưỡng cho biết đây là ID giao dịch nhỏ nhất toàn cục mà vẫn có thể thấy một số phiên bản của tuple hay đối tượng.
And once I know that that thing is always moving forward in time, assuming I don't have transactions around for days, then at some point, I can say, all right, I know there's no transactions active that could see this version, so I go ahead and remove them.
Và một khi tôi biết rằng nó luôn tiến về phía trước theo thời gian, giả sử tôi không có những giao dịch tồn tại hàng ngày trời, thì đến một lúc nào đó, tôi có thể nói rằng, tôi biết không có giao dịch nào đang hoạt động có thể thấy phiên bản này, nên tôi cứ thế xóa chúng đi.
So let's see how we want to go ahead and reclaim them. So the first is tuple-level garbage collection.
Vậy hãy xem chúng ta muốn thu hồi chúng như thế nào. Cách đầu tiên là garbage collection ở mức tuple.
And this is where we're just going to scan the data and try to find versions that aren't visible to us. And we go ahead and throw them away.
Và ở đây chúng ta sẽ quét dữ liệu và cố gắng tìm những phiên bản không hiển thị với chúng ta. Rồi chúng ta vứt bỏ chúng.
And we can either do this by separate dedicated workers running in the background, or we can do this while transactions are actually running.
Và chúng ta có thể làm việc này bằng các worker chuyên dụng riêng biệt chạy ngầm ở nền, hoặc làm ngay trong lúc các giao dịch đang thực sự chạy.
If they encounter versions that aren't visible to any transaction, then they will actually go ahead and remove things.
Nếu gặp những phiên bản không còn hiển thị với bất kỳ giao dịch nào, thì chúng sẽ tiến hành xóa những phiên bản đó.
And the last one would be just keeping track of the rewrite set, or sorry, the write set of transactions while they run, so that when they go ahead and commit, we know which versions they've invalidated and we go ahead and remove them.
Cách cuối cùng là theo dõi tập ghi lại, à xin lỗi, tập ghi (write set) của các giao dịch trong lúc chúng chạy, để khi chúng tiến hành commit, ta biết chúng đã làm mất hiệu lực những phiên bản nào và ta xóa các phiên bản đó.
So the first one is tuple-level garbage collection. Again, there's two approaches. There's vacuuming, there's dedicated workers, and then there's cooperative vacuuming. So say I have two transactions that are actually running, T1, T2.
Cách đầu tiên là garbage collection ở mức tuple. Một lần nữa, có hai hướng tiếp cận. Một là vacuuming với các worker chuyên dụng, và hai là cooperative vacuuming. Giả sử tôi có hai giao dịch đang chạy, T1 và T2.
T1 has timestamp 12. T2 has timestamp 25. So now this information on what timestamps are still active will be sent to the vacuum.
T1 có timestamp 12. T2 có timestamp 25. Bây giờ thông tin về những timestamp còn đang hoạt động sẽ được gửi cho vacuum.
It's now just going to do a sequential scan on the table and look at the beginning timestamps and identify which versions are not visible by any active transaction.
Nó sẽ chỉ quét tuần tự bảng, xem các timestamp bắt đầu và xác định phiên bản nào không hiển thị với bất kỳ giao dịch đang hoạt động nào.
So in this case here, I have A100, B100. They have begin timestamps from 1 to 9. The smallest timestamp I have is 12.
Trong trường hợp này, tôi có A100, B100. Chúng có timestamp bắt đầu từ 1 đến 9. Timestamp nhỏ nhất tôi có là 12.
12 can't view either of those versions, so I know it's safe for me to go ahead and remove them. What's that? Question is, 12 can read those versions?
12 không thể nhìn thấy phiên bản nào trong số đó, nên tôi biết là có thể xóa chúng một cách an toàn. Gì vậy? Câu hỏi là 12 có đọc được những phiên bản đó không?
Well, assuming there's another A there. There's another A somewhere. And you would know that based on how you would know, the system would know I'm doing oldest, newest, newest, oldest.
Ừ, giả sử có một A khác ở đó. Có một A khác ở đâu đó. Và bạn sẽ biết điều đó dựa trên cách mà bạn biết, hệ thống sẽ biết là tôi đang dùng thứ tự cũ nhất, mới nhất, mới nhất, cũ nhất.
It would know something about what the pointer, like am I in the middle, or the end, or whatever, right?
Nó sẽ biết đôi điều về con trỏ, kiểu tôi đang ở giữa, hay ở cuối, hay gì đó, đúng không?
But you're correct, yes, that there should be another version A to make this more clear.
Nhưng bạn nói đúng, nên có thêm một phiên bản A khác để ví dụ này rõ ràng hơn.
So sequential scanning sucks because just to do this vacuuming, because what if there's a bunch of pages that haven't been modified since the last time I ran vacuuming?
Quét tuần tự rất tệ, chỉ để làm vacuuming thôi, vì nếu có hàng loạt trang chưa bị sửa đổi kể từ lần cuối tôi chạy vacuuming thì sao?
I don't want to fetch them in from disk, bring them to memory, pollute my buffer pool, and in fact, maybe useful data, right?
Tôi không muốn nạp chúng từ đĩa, đưa vào bộ nhớ, làm ô nhiễm buffer pool, mà thực tế có thể đó là dữ liệu hữu ích, đúng không?
So the way Postgres handles that is they maintain a bitmap of what blocks or pages have been modified since the last time the vacuum ran.
Cách Postgres xử lý là duy trì một bitmap cho biết những block hay trang nào đã bị sửa đổi kể từ lần vacuum chạy gần nhất.
So now it says, when it runs, it just looks at this, scans all this, and figures out, well, here's all the page IDs that have been modified since the last time I ran.
Vậy khi chạy, nó chỉ nhìn vào đây, quét toàn bộ, và xác định: đây là tất cả các ID trang đã bị sửa đổi kể từ lần chạy trước.
Those are the only ones I need to bring in and go clean up. It doesn't know how they were modified. It just knows that they were modified in some way.
Đó là những trang duy nhất tôi cần nạp vào và dọn dẹp. Nó không biết chúng bị sửa đổi như thế nào. Nó chỉ biết là chúng đã bị sửa đổi theo cách nào đó.
And this reduces unnecessarily bringing in pages that you don't need to clean. Cooperative cleaning, the basic idea is that when transactions run, they're responsible for cleaning things up of any older versions they find.
Và điều này giảm việc nạp vào những trang không cần dọn một cách không cần thiết. Với cooperative cleaning, ý tưởng cơ bản là khi các giao dịch chạy, chúng chịu trách nhiệm dọn dẹp mọi phiên bản cũ mà chúng gặp.
So say T1 starts and does a lookup, get object A, and it follows the index. And today, the index here, we're doing oldest and newest.
Giả sử T1 bắt đầu và thực hiện tra cứu, lấy đối tượng A, và đi theo index. Và hôm nay, index ở đây, ta dùng thứ tự cũ nhất đến mới nhất.
So when it lands to the head of the version chain, it's the oldest version. And now it's going to know from the global transaction status table what's the smallest timestamp of any actual transaction.
Nên khi đến đầu của chuỗi phiên bản, đó là phiên bản cũ nhất. Và bây giờ nó sẽ biết từ thông tin toàn cục bảng trạng thái giao dịch toàn cục để biết timestamp nhỏ nhất của bất kỳ giao dịch đang hoạt động nào.
And therefore, as it scans along, it may encounter versions that are not visible by any actual transaction. Therefore, it's this transaction's responsibility to go ahead and clean them up as you scan along.
Và do đó, khi quét dọc theo chuỗi, nó có thể gặp những phiên bản mà không giao dịch đang hoạt động nào nhìn thấy được. Vì vậy, giao dịch này có trách nhiệm dọn dẹp chúng ngay trong lúc quét.
Sorry, say that again? That's why oldest and newest? The statement, this is why oldest and newest is an invitation in some cases, yes, because if I'm doing this cooperative cleaning, I can handle that.
Xin lỗi, em nói lại được không? Đó là lý do có oldest và newest à? Câu em nói, đây là lý do oldest và newest là một lời mời gọi trong một số trường hợp, đúng vậy, vì nếu tôi dọn dẹp hợp tác thế này thì tôi xử lý được việc đó.
But of course now, this makes read queries end up being doing writes, because I'm doing writes here.
Nhưng tất nhiên lúc này, các truy vấn đọc lại hóa ra đang thực hiện thao tác ghi, vì tôi đang ghi ở đây.
I have to update version information, because now I've got to go update the index and now point to the new head of the version chain.
Tôi phải cập nhật thông tin phiên bản, vì giờ tôi phải cập nhật chỉ mục và trỏ đến đầu mới của chuỗi phiên bản.
So what was a select query that should have been read-only is now actually doing an update. Now, logically, it's not updating the database. Physically, it is.
Vậy một truy vấn select lẽ ra chỉ đọc thì giờ thực sự đang thực hiện cập nhật. Về mặt logic, nó không cập nhật cơ sở dữ liệu. Về mặt vật lý thì có.
So it's not taking logical locks on A, but it is taking physical latches on the data structure to update things.
Nên nó không lấy khóa logic trên A, nhưng nó lấy latch vật lý trên cấu trúc dữ liệu để cập nhật.
Transaction-level GC, the basic idea is that when transactions are updating records, updating objects, they just keep track of what things they've invalidated.
GC cấp giao dịch, ý tưởng cơ bản là khi các giao dịch cập nhật bản ghi, cập nhật đối tượng, chúng chỉ cần ghi lại những gì chúng đã làm mất hiệu lực.
So I don't have to go hunt and peck and try to find where these older versions are now when my background vacuum wants to run. I know exactly where they would be.
Nhờ vậy tôi không phải mò mẫm đi tìm các phiên bản cũ này nằm ở đâu khi vacuum chạy nền muốn chạy. Tôi biết chính xác chúng ở đâu.
Actually, going back here for the cooperative cleaning, I also mentioned, too, that B0 has a bunch of old versions, too, that need to be cleaned up.
Thực ra, quay lại phần dọn dẹp hợp tác ở đây, tôi cũng đã nói rằng B0 cũng có một loạt phiên bản cũ cần được dọn dẹp.
But if nobody ever reads them, then they never get reclaimed. So Microsoft calls these dusty corners.
Nhưng nếu không ai đọc chúng thì chúng không bao giờ được thu hồi. Microsoft gọi những chỗ này là dusty corners.
So you still actually need both if you want to do these, because periodically, every so often, you're going to run the background vacuum and it'll clean up the things that nobody's ever read.
Nên thực tế bạn vẫn cần cả hai nếu muốn làm vậy, vì định kỳ, cứ một khoảng thời gian, bạn sẽ chạy vacuum nền và nó sẽ dọn những thứ chưa từng được ai đọc.
Because eventually, you want to clean up everything.
Vì cuối cùng, bạn muốn dọn sạch mọi thứ.
So transaction-level GC, the idea is that as transactions make changes, they keep track of the versions that they invalidate. So in this case here, I create a new version of A, make A3.
Vậy với GC cấp giao dịch, ý tưởng là khi các giao dịch thực hiện thay đổi, chúng ghi lại các phiên bản mà chúng làm mất hiệu lực. Trong trường hợp này, tôi tạo một phiên bản mới của A, tạo ra A3.
But I know, therefore, that I've invalidated A2. Assuming my transaction is going to commit, that this thing should eventually be reclaimed. I know it's not visible.
Nhưng tôi biết rằng như vậy tôi đã làm A2 mất hiệu lực. Giả sử giao dịch của tôi sẽ commit, thì phiên bản này cuối cùng sẽ được thu hồi. Tôi biết nó không còn nhìn thấy được.
So then now, if I update other things, same thing, B6, put that in my old version set.
Rồi nếu tôi cập nhật những thứ khác, cũng tương tự, B6, đưa nó vào tập phiên bản cũ của tôi.
So now when the transaction commits, the vacuum says, "OK, these are the versions that have been modified. I know the end timestamp for these is going to be less than 10."
Vậy khi giao dịch commit, vacuum nói: "OK, đây là các phiên bản đã bị sửa đổi. Tôi biết timestamp kết thúc của chúng sẽ nhỏ hơn 10."
So therefore, if there's any transactions that are still... there are no transactions that could potentially view these versions, I know I want to clean them up.
Vì vậy, nếu có giao dịch nào vẫn còn... không có giao dịch nào có thể nhìn thấy các phiên bản này, Tôi biết là mình muốn dọn dẹp chúng.
So again, instead of having a decentralized approach to doing the vacuuming, this is like putting everything in a centralized data structure.
Vậy nên, thay vì có một cách tiếp cận phi tập trung để vacuum, thì cách này giống như đưa mọi thứ vào một cấu trúc dữ liệu tập trung.
All right, so now we get to the point that people keep asking about. How do we actually manage indexes? So primary key indexes are going to be super easy, easy-ish.
Được rồi, giờ ta đến phần mà mọi người cứ hỏi mãi. Làm thế nào để thực sự quản lý các chỉ mục? Chỉ mục khóa chính thì sẽ rất dễ, hoặc cũng khá dễ.
Because the primary key index is always going to be resolved from pointing to the head of the version chain.
Vì chỉ mục khóa chính luôn được phân giải bằng cách trỏ tới phần đầu của chuỗi phiên bản.
In the case of index-organized storage, like MySQL, the tuple itself is going to be in the leaf pages, that you still can consider that as the logical head of the version chain.
Với lưu trữ theo kiểu index-organized, như MySQL, bản thân tuple nằm trong các trang lá, mà bạn vẫn có thể coi đó là phần đầu logic của chuỗi phiên bản.
And then they have the separate rollback segment where they restore all the previous versions. So then now, the challenge is going to be, how do we handle secondary indexes?
Và sau đó họ có một rollback segment riêng nơi họ lưu lại tất cả các phiên bản trước đó. Vậy thách thức bây giờ là: ta xử lý các chỉ mục thứ cấp như thế nào?
In the case of primary key indexes too, if you modify the attributes that is the primary key of the tuple, then you just treat that as a delete followed by an insert.
Với chỉ mục khóa chính cũng vậy, nếu bạn sửa các thuộc tính là khóa chính của tuple, thì bạn chỉ coi đó là một thao tác xóa rồi chèn.
You still have to handle the case where someone deletes something, the primary key. And then you commit. And then you need to now insert that primary key again.
Bạn vẫn phải xử lý trường hợp ai đó xóa một thứ gì đó, tức là khóa chính. Rồi bạn commit. Và sau đó bạn cần chèn lại khóa chính đó.
We'll see that in a second. Got to handle that. That's a corner case. But in general, you just treat it as two distinct tuples.
Lát nữa ta sẽ thấy. Phải xử lý nó. Đó là một trường hợp biên. Nhưng nói chung, bạn chỉ coi chúng là hai tuple riêng biệt.
I delete it, and then I insert it if I update. It's the secondary indexes that are going to be problematic.
Nếu cập nhật thì tôi xóa nó, rồi chèn nó. Chính các chỉ mục thứ cấp mới là vấn đề.
And again, now you see why I was trying to say at the beginning, the ways we decide how we're going to store versions, and whether it's oldest, newest, newest, oldest, whether it's append-only or dumpster storage, that's going to affect all parts of our system.
Và giờ bạn thấy vì sao ngay từ đầu tôi đã cố nói rằng cách ta quyết định lưu trữ các phiên bản, cũng như là cũ nhất tới mới nhất hay mới nhất tới cũ nhất, là chỉ nối thêm (append-only) hay lưu trữ kiểu dumpster, sẽ ảnh hưởng đến mọi phần của hệ thống.
Because now we need to account for that in our secondary indexes. What are they actually going to be pointing to?
Vì giờ ta cần tính đến điều đó trong các chỉ mục thứ cấp. Chúng thực sự sẽ trỏ tới cái gì?
Because if I'm moving things around ahead of version chain, I may have to go update that thing if I'm pointing to the newest version.
Vì nếu tôi di chuyển các thứ ở đầu chuỗi phiên bản, tôi có thể phải cập nhật nó nếu đang trỏ tới phiên bản mới nhất.
The question is, why do I treat an update as a delete followed by an insert?
Câu hỏi là: tại sao tôi coi cập nhật là xóa rồi chèn?
Rather, the proposing optimization where my primary key is ID. I have ID equals 1. I then update the tuple and say ID equals 2.
Mà thay vào đó, bạn đề xuất tối ưu hóa trong đó khóa chính của tôi là ID. Tôi có ID bằng 1. Rồi tôi cập nhật tuple và đặt ID bằng 2.
And what I'm saying is you first delete ID equals 1 from the index, then you insert it. You're proposing that you insert it first to see whether it would conflict.
Và điều tôi nói là trước hết bạn xóa ID bằng 1 khỏi chỉ mục, rồi mới chèn nó. Bạn đang đề xuất chèn trước để xem có xung đột hay không.
That's an optimization you could do, yes, I suppose. But it's the same.
Đó là một tối ưu hóa bạn có thể làm, tôi cho là vậy. Nhưng về bản chất thì giống nhau.
So again, to show you why thinking about multi-version throughout the entire system matters, it's because depending on your environment, depending on your workload, depending on your hardware, these different design choices for how you're going to implement multi-version concurrency control can have pretty significant difference in performance and behaviors.
Vậy nên, để cho các bạn thấy vì sao việc suy nghĩ về đa phiên bản trong toàn bộ hệ thống là quan trọng, là bởi tùy vào môi trường của bạn, tùy vào khối lượng công việc, tùy vào phần cứng, những lựa chọn thiết kế khác nhau về cách bạn triển khai điều khiển đồng thời đa phiên bản có thể tạo ra khác biệt khá lớn về hiệu năng và hành vi.
And so there's a great blog article, which is over 10 years old now from Uber, about their journey from going from Postgres to MySQL.
Và có một bài blog rất hay, đã hơn 10 năm tuổi rồi, của Uber, về hành trình chuyển từ Postgres sang MySQL của họ.
And the reason why they had to switch from Postgres to MySQL is because the way Postgres was doing multi-version, in particular, and how they handle secondary indexes was actually less efficient in Postgres than it was in MySQL.
Và lý do họ phải chuyển từ Postgres sang MySQL là vì cách Postgres thực hiện đa phiên bản, cụ thể là cách nó xử lý các chỉ mục phụ, thực ra kém hiệu quả hơn trong Postgres so với trong MySQL.
The real name of this blog article should actually be why Uber went from MySQL to Postgres back to MySQL. Because they started with MySQL.
Tên đúng của bài blog này lẽ ra phải là tại sao Uber đi từ MySQL sang Postgres rồi lại quay về MySQL. Vì họ bắt đầu với MySQL.
They hired some guy who said, let's go to Postgres. And they switched. They realized that was a mistake, and they had to go back to MySQL.
Họ thuê một anh nói là hãy chuyển sang Postgres. Và họ đã chuyển. Họ nhận ra đó là một sai lầm, và phải quay lại MySQL.
I'm sure they paid millions and millions of dollars to do this. They could have paid us to tell them not to do it for less. Well, let's see what's going on.
Tôi chắc là họ đã tốn hàng triệu hàng triệu đô la để làm việc này. Họ có thể trả cho chúng tôi để bảo họ đừng làm, với giá rẻ hơn nhiều. Nào, hãy xem chuyện gì đang xảy ra.
All right, so the challenge, again, with secondary indexes is that I've got to point to something as my value portion of my index, of my record.
Được rồi, vậy thách thức, một lần nữa, với các chỉ mục phụ là tôi phải trỏ tới một thứ gì đó làm phần giá trị của chỉ mục, cho bản ghi của tôi.
But if I'm starting to change what it means to be the head of the version chain, based on the ordering I'm doing, then I potentially have to go update all my secondary indexes.
Nhưng nếu tôi bắt đầu thay đổi ý nghĩa của việc là đầu chuỗi phiên bản, dựa trên thứ tự mà tôi đang dùng, thì có thể tôi phải cập nhật tất cả các chỉ mục phụ.
So one way to get around having to update everything is to use a logical pointer, Where it's like a proxy to represent a key that allows you to then find what the true head of the version chain is.
Vậy một cách để tránh phải cập nhật mọi thứ là dùng con trỏ logic, tức là một dạng đại diện cho một khóa cho phép bạn sau đó tìm ra đâu là đầu thật sự của chuỗi phiên bản.
What is the true current record ID for this given tuple?
ID bản ghi hiện tại thật sự của tuple này là gì?
The challenge, though, is going to be basically an additional indirection layer, because when I do my lookup in my secondary index, I now have this logical pointer, and I got to go figure out how to get the physical pointer where the actual tuple actually is.
Tuy nhiên, thách thức là về cơ bản sẽ có thêm một tầng gián tiếp, vì khi tôi tra cứu trong chỉ mục phụ, tôi giờ có con trỏ logic này, và tôi phải tìm cách lấy con trỏ vật lý nơi tuple thật sự nằm.
So I do a lookup on another index. The other approach is to update physical pointers, like what is actually the true head of the version chain? Let's see a basic example.
Nên tôi phải tra cứu trên một chỉ mục khác. Cách tiếp cận còn lại là cập nhật các con trỏ vật lý, tức là đâu thật sự là đầu của chuỗi phiên bản? Hãy xem một ví dụ cơ bản.
So this is doing append-only storage with newest-to-oldest. So not Postgres' oldest-to-newest, the newest-to-oldest.
Đây là lưu trữ chỉ-nối-thêm theo thứ tự từ mới nhất đến cũ nhất. Không phải từ cũ nhất đến mới nhất như Postgres, mà là từ mới nhất đến cũ nhất.
So if I do a lookup on the primary key, the primary key is always going to have the record ID as the value, and that's going to always be the head of the version chain.
Nếu tôi tra cứu theo khóa chính, khóa chính luôn có ID bản ghi làm giá trị, và đó sẽ luôn là đầu của chuỗi phiên bản.
So that's fast-ish. I can always go exactly to where I want.
Vậy là khá nhanh. Tôi luôn đi thẳng được tới chỗ mình muốn.
And depending on whether my transaction is the newest version or the oldest version, I still have to maybe scan along the version chain, but the index part is straightforward.
Và tùy giao dịch của tôi là phiên bản mới nhất hay cũ nhất, tôi vẫn có thể phải quét dọc theo chuỗi phiên bản, nhưng phần chỉ mục thì đơn giản.
But now the problem is going to be when I do a lookup on the secondary indexes.
Nhưng vấn đề sẽ xuất hiện khi tôi tra cứu trên các chỉ mục phụ.
If I store the record ID, the same idea for the primary key, then in this example here, every single time I update the version chain or the version and I append a new version at the beginning of the version chain, I have to now update any index that's pointing to it.
Nếu tôi lưu ID bản ghi, cùng ý tưởng như khóa chính, thì trong ví dụ này, mỗi lần tôi cập nhật chuỗi phiên bản hay phiên bản và nối thêm một phiên bản mới vào đầu chuỗi phiên bản, tôi giờ phải cập nhật mọi chỉ mục đang trỏ tới nó.
So yeah, I update the primary key index, but then I also update all my secondary key indexes as well. So for one index, maybe that's not that big of a deal.
Đúng vậy, tôi cập nhật chỉ mục khóa chính, nhưng tôi cũng phải cập nhật tất cả các chỉ mục khóa phụ nữa. Với một chỉ mục thì có lẽ cũng không phải vấn đề lớn.
But if I have a lot of them, then to do one update on the tuple, Not even for the keys that this thing might be indexed on.
Nhưng nếu có nhiều chỉ mục, thì chỉ để thực hiện một lần cập nhật trên tuple, thậm chí không cần là các khóa mà nó được đánh chỉ mục.
If I update an attribute that I don't even have an index on, because now I'm storing the physical ID, the location of the head of the version chain, I have to update all these indexes.
Nếu tôi cập nhật một thuộc tính mà thậm chí tôi không có chỉ mục nào trên đó, vì bây giờ tôi đang lưu ID vật lý, tức vị trí của đầu chuỗi phiên bản, tôi vẫn phải cập nhật tất cả các chỉ mục này.
It means I have to do latch grabbing or whatever data structure I'm using and do all that.
Nghĩa là tôi phải giành latch hoặc cấu trúc dữ liệu nào đó mà tôi đang dùng, và làm tất cả những việc đó.
An alternative is to use a logical ID as a way to represent an additional indirection layer to take some logical value and get to that version chain.
Một giải pháp thay thế là dùng ID logic như một cách biểu diễn thêm một tầng gián tiếp, để lấy một giá trị logic rồi đi đến chuỗi phiên bản đó.
So now when I update the head of the version chain, I don't have to update all my secondary indexes. So this is what MySQL does.
Như vậy bây giờ khi tôi cập nhật đầu chuỗi phiên bản, tôi không phải cập nhật tất cả các chỉ mục thứ cấp. Đây chính là cách MySQL làm.
So MySQL actually stores the primary key of your tuple as the value of any secondary index.
MySQL thực sự lưu khóa chính của tuple làm giá trị của mọi chỉ mục thứ cấp.
So when I do my lookup on my secondary index from one key, I get out the primary key and then I do another lookup in the primary key index to then get to the head of the version chain.
Vì vậy khi tôi tra cứu trên chỉ mục thứ cấp từ một khóa, tôi lấy ra khóa chính rồi thực hiện thêm một lần tra cứu trong chỉ mục khóa chính để đến đầu chuỗi phiên bản.
In the case of MySQL, because it's index-organized storage, once I get to the leaf node, I get my tuple anyway. So it's not that big of a deal.
Trong trường hợp của MySQL, vì là lưu trữ tổ chức theo chỉ mục, nên khi tôi đến nút lá, dù sao tôi cũng nhận được tuple của mình. Nên cũng không phải vấn đề lớn.
But now if I have to update multiple, if I have many secondary indexes, I don't have to update all of them whenever I update my tuple, head of my version chain, because they're still always going to point to the primary key index.
Nhưng bây giờ nếu tôi phải cập nhật nhiều chỉ mục, tức có nhiều chỉ mục thứ cấp, tôi không cần cập nhật tất cả chúng mỗi khi cập nhật tuple, đầu chuỗi phiên bản của tôi, vì chúng vẫn luôn trỏ đến chỉ mục khóa chính.
And if I do that trick I said before, I change or modify the primary key of a tuple, if I treat that as a delete followed by an insert, then again, I update all my secondary indexes that way as well.
Và nếu tôi dùng mẹo đã nói trước đó, khi tôi thay đổi hoặc sửa khóa chính của một tuple, nếu tôi coi đó là một thao tác xóa rồi theo sau là chèn, thì một lần nữa, tôi cũng cập nhật tất cả các chỉ mục thứ cấp theo cách đó.
So most data systems that do multi-versioning are not going to store version information in the index itself. And if it's index-organized storage, implicitly, it's down in there. But typically, they don't do this.
Vì vậy hầu hết các hệ thống dữ liệu dùng đa phiên bản sẽ không lưu thông tin phiên bản trong chính chỉ mục. Còn nếu là lưu trữ tổ chức theo chỉ mục thì về mặt ngầm định, nó nằm sâu bên trong đó. Nhưng thông thường họ không làm vậy.
Postgres is going to do this, because since they're doing oldest-to-newest, and since the version chain may span multiple pages, to go look at one tuple, I may have to go read multiple pages.
Postgres sẽ làm vậy, vì họ dùng thứ tự từ cũ nhất đến mới nhất, và vì chuỗi phiên bản có thể trải qua nhiều trang, nên để xem một tuple, tôi có thể phải đọc nhiều trang.
To avoid having to scan the entire version chain, they'll have multiple entries in the index for different versions that allow you to jump to different offsets within the version chain.
Để tránh phải quét toàn bộ chuỗi phiên bản, họ sẽ có nhiều mục trong chỉ mục cho các phiên bản khác nhau cho phép bạn nhảy đến các offset khác nhau trong chuỗi phiên bản.
Of course, now when I clean things up, I've got to go delete those old version references.
Dĩ nhiên, bây giờ khi tôi dọn dẹp, tôi phải đi xóa các tham chiếu phiên bản cũ đó.
But they decided it would be faster to do that. It makes the scans faster, but it deletes slower.
Nhưng họ quyết định làm vậy sẽ nhanh hơn. Nó làm việc quét nhanh hơn, nhưng xóa thì chậm hơn.
The challenge is also going to be now our index has to support duplicate keys from different snapshots.
Thách thức bây giờ còn là chỉ mục của chúng ta phải hỗ trợ các khóa trùng lặp từ những snapshot khác nhau.
So we talked about how we would handle this in secondary indexes: if we make the data structure in our B+tree handle only unique keys, then if we just append the record ID into the key itself, that guarantees that every key I store is unique.
Chúng ta đã nói về cách xử lý điều này trong các chỉ mục thứ cấp: nếu ta làm cho cấu trúc dữ liệu B+tree chỉ xử lý các khóa duy nhất, thì nếu ta chỉ cần nối ID bản ghi vào chính khóa, điều đó đảm bảo mọi khóa tôi lưu đều là duy nhất.
But the same idea applies here, that if I store the record ID and some extra metadata in my key that I'm storing, then now I could potentially have two keys get inserted into my index that would normally conflict logically, but physically they don't conflict because the bytes I'm actually storing will not match.
Nhưng ý tưởng tương tự cũng áp dụng ở đây, tức là nếu tôi lưu record ID và một số metadata bổ sung vào trong khóa mà tôi đang lưu, thì giờ đây có thể có hai khóa được chèn vào chỉ mục của tôi mà về mặt logic thì bình thường sẽ xung đột, nhưng về mặt vật lý thì chúng không xung đột vì các byte tôi thực sự lưu sẽ không giống nhau.
And the reason you need to do this is because the garbage collector may not have come through and cleaned things up.
Và lý do bạn cần làm như vậy là vì bộ thu gom rác có thể chưa chạy qua và dọn dẹp.
So in the same way I've got to go clean up the version chains, I've got to go clean up the indexes as well to make sure they're not pointing to things in my version chain that don't exist anymore.
Vì vậy, cũng như tôi phải đi dọn các chuỗi phiên bản, tôi cũng phải dọn các chỉ mục để đảm bảo chúng không trỏ tới những thứ trong chuỗi phiên bản của tôi mà không còn tồn tại nữa.
So say every transaction T1 starts, it does a read on A. Transaction T2 starts, and they're going to update A.
Giả sử giao dịch T1 bắt đầu, nó thực hiện đọc A. Giao dịch T2 bắt đầu, và nó sẽ cập nhật A.
And that's going to create a new version like this, but then it's going to delete A. So now, say this transaction goes ahead and commits. The garbage collector hasn't run yet.
Việc đó sẽ tạo ra một phiên bản mới như thế này, nhưng sau đó nó sẽ xóa A. Giờ giả sử giao dịch này tiếp tục và commit. Bộ thu gom rác vẫn chưa chạy.
So my index still has a pointer for object A, on key A, still points to the head of my version chain down here.
Vậy chỉ mục của tôi vẫn có con trỏ cho đối tượng A, tại khóa A, vẫn trỏ tới đầu chuỗi phiên bản của tôi ở dưới này.
But then another transaction comes along after the second one is committed, and it creates and does insert on A. So now I need to be able to then also update that pointer here.
Nhưng rồi một giao dịch khác xuất hiện sau khi giao dịch thứ hai đã commit, và nó tạo ra và thực hiện insert A. Vậy giờ tôi cũng cần cập nhật con trỏ ở đây.
Again, logically, that's allowed to happen because T2 is already committed. Physically, I'm storing multiple versions of A, and the keys technically conflict. Logically, they don't conflict because T2 is gone.
Một lần nữa, về mặt logic thì điều đó được phép xảy ra vì T2 đã commit rồi. Về mặt vật lý, tôi đang lưu nhiều phiên bản của A, và về mặt kỹ thuật các khóa xung đột. Về mặt logic thì chúng không xung đột vì T2 đã không còn.
T3 is allowed to go ahead and do the update because T1 is still running at the top.
T3 được phép tiếp tục thực hiện cập nhật vì T1 vẫn đang chạy ở phía trên.
So now when it reads A, you need to be guaranteed that it sees the version A1 and not the newer uncommitted version, A3.
Vậy khi nó đọc A, bạn cần được đảm bảo rằng nó thấy phiên bản A1 chứ không phải phiên bản mới hơn chưa commit, A3.
Or even if A3, the bottom one, commits, it still needs to be able to see A1.
Hoặc ngay cả khi A3, cái ở dưới cùng, đã commit, nó vẫn phải thấy được A1.
So the way we would handle this is that since we need to now support non-unique keys, we can store some basic versioning information in the keys itself that guarantee the uniqueness and that allows us to find the version that we actually want.
Vậy cách chúng ta xử lý việc này là vì giờ chúng ta cần hỗ trợ các khóa không duy nhất, chúng ta có thể lưu một số thông tin phiên bản cơ bản ngay trong khóa để đảm bảo tính duy nhất và điều đó cho phép chúng ta tìm đúng phiên bản mình thực sự muốn.
Because going back here, the version chain is not connected because logically, the insert A in T3 is not the same tuple, same logical tuple, that the other two transactions are modifying.
Vì quay lại đây, chuỗi phiên bản không được nối với nhau vì về mặt logic, lệnh insert A trong T3 không phải là cùng một tuple, cùng một tuple logic, mà hai giao dịch kia đang sửa đổi.
They're logically distinct, even though the keys are the same, and physically, I'm storing them together in the index.
Chúng khác biệt về mặt logic, dù các khóa giống nhau, và về mặt vật lý, tôi đang lưu chúng cùng nhau trong chỉ mục.
So then we need to be able to guarantee that the other transactions can still find, the older transactions can still find the older versions.
Vì vậy chúng ta cần đảm bảo được rằng các giao dịch khác vẫn có thể tìm thấy, các giao dịch cũ hơn vẫn có thể tìm thấy các phiên bản cũ hơn.
And the last thing I want to cover quickly before we go is, how do we handle deletes? So again, we're going to be physically deleting old versions.
Và điều cuối cùng tôi muốn nói nhanh trước khi kết thúc là, chúng ta xử lý việc xóa như thế nào? Một lần nữa, chúng ta sẽ xóa vật lý các phiên bản cũ.
But at some point, we've got to be able to logically delete them and remove the entire version chain.
Nhưng đến một lúc nào đó, chúng ta phải có khả năng xóa chúng về mặt logic và loại bỏ toàn bộ chuỗi phiên bản.
And so we just need a way to keep track of that a tuple has been deleted.
Và vì vậy chúng ta chỉ cần một cách để theo dõi rằng một tuple đã bị xóa.
And the easiest way to do this would be, you just store a, one way to do this is to just store in the header a little flag that said, "This is the latest version of this transaction," sorry, "the latest version of this logical tuple has been deleted."
Cách dễ nhất để làm việc này là bạn chỉ cần lưu một, một cách là lưu trong header một cờ nhỏ cho biết, "Đây là phiên bản mới nhất của giao dịch này," xin lỗi, "phiên bản mới nhất của tuple logic này đã bị xóa."
So as I'm scanning along my version chain, if I come across that flag, I know that, OK, this thing has been logically deleted, even though physically, I can still see it.
Vậy khi tôi quét dọc theo chuỗi phiên bản, nếu gặp cờ đó, tôi biết rằng, OK, thứ này đã bị xóa về mặt logic, dù về mặt vật lý tôi vẫn còn thấy nó.
And then you can determine, the data system can determine whether a transaction is allowed to see that or not.
Và sau đó bạn có thể xác định, hệ thống dữ liệu có thể xác định một giao dịch có được phép nhìn thấy nó hay không.
The other approach is actually make a special tombstone tuple that's the end of your version chain, so that if you come along, you just see that, and you know, "You've been deleted."
Cách tiếp cận còn lại là tạo ra một tombstone tuple đặt ở cuối chuỗi phiên bản của bạn, để khi bạn duyệt tới, bạn chỉ cần thấy nó và biết rằng "Bạn đã bị xóa."
All right, so here's a quick summary of a bunch of systems that are out there and various ways that they're implementing multi-version concurrency control. As you can see, Postgres is there as append-only.
Được rồi, đây là bản tóm tắt nhanh về một loạt hệ thống hiện có và các cách khác nhau mà chúng triển khai điều khiển đồng thời đa phiên bản. Như bạn thấy, Postgres ở đây là append-only.
Hekaton, which is an in-memory advanced system for SQL Server for transactions, they're the only ones that are still kind of doing append-only now.
Hekaton, một hệ thống in-memory tiên tiến của SQL Server dành cho giao dịch, là những hệ thống duy nhất hiện nay vẫn còn làm kiểu append-only.
Any modern system is doing the delta storage approach, because it's just way more efficient. The engineering complexity to get good performance is much lower than it is with append-only.
Mọi hệ thống hiện đại đều dùng cách lưu trữ delta, vì nó hiệu quả hơn rất nhiều. Độ phức tạp về kỹ thuật để đạt hiệu năng tốt thấp hơn nhiều so với append-only.
Like in Postgres, when you run the vacuum and it deletes old versions, it doesn't actually reclaim the main memory.
Ví dụ trong Postgres, khi bạn chạy vacuum và nó xóa các phiên bản cũ, nó không thực sự thu hồi bộ nhớ chính.
It's only when you run VACUUM FULL or run pg_repack does it actually clean things up.
Chỉ khi bạn chạy VACUUM FULL hoặc chạy pg_repack thì nó mới thực sự dọn dẹp.
So I can insert a billion tuples, commit that transaction, then delete a billion tuples, and then commit that transaction, and Postgres won't actually reclaim the storage space.
Vậy tôi có thể chèn một tỉ tuple, commit giao dịch đó, rồi xóa một tỉ tuple, rồi commit giao dịch đó, và Postgres sẽ không thực sự thu hồi không gian lưu trữ.
It just has that much empty space where it can store things. All right, so again, MVCC is the most widely used storage scheme for managing transactions and data in a data system.
Nó chỉ có chừng đó không gian trống để có thể lưu dữ liệu. Được rồi, vậy một lần nữa, MVCC là sơ đồ lưu trữ được dùng rộng rãi nhất để quản lý giao dịch và dữ liệu trong một hệ thống dữ liệu.
But we kind of need to cover all the basics throughout the semester before we can get to everything we're talking about here today. So now you understand what secondary indexes are doing.
Nhưng chúng ta cần đi qua tất cả những kiến thức cơ bản trong suốt học kỳ trước khi có thể bàn đến mọi thứ chúng ta nói hôm nay. Giờ bạn đã hiểu các secondary index làm gì.
Now you can understand what the scan operator is doing when it goes to try to read things.
Giờ bạn có thể hiểu toán tử scan làm gì khi nó đi đọc dữ liệu.
And even database systems that do not support multi-statement transactions, like I can call update, update, update, and commit atomically, even those systems are going to still do some variation of multi-versioning.
Và ngay cả các hệ cơ sở dữ liệu không hỗ trợ giao dịch nhiều câu lệnh, như việc tôi gọi update, update, update rồi commit một cách nguyên tử, những hệ thống đó vẫn sẽ làm một biến thể nào đó của đa phiên bản.
They just don't support more complex transactions. All right, next class, we'll be switching over to talk about log and recovery.
Chỉ là chúng không hỗ trợ các giao dịch phức tạp hơn. Được rồi, buổi sau chúng ta sẽ chuyển sang nói về log và khôi phục.
And then so next week will be the last two lectures you need to actually build a safe, reliable database system, even though we're not near the end of the semester.
Và tuần sau sẽ là hai bài giảng cuối cùng bạn cần để thực sự xây dựng một hệ cơ sở dữ liệu an toàn, đáng tin cậy, dù chúng ta còn chưa gần cuối học kỳ.
But the last two pieces are what you need to make sure you don't lose data.
Nhưng hai phần cuối này là thứ bạn cần để đảm bảo không mất dữ liệu.
And then once we finish next week, then we'll talk about what happens when we go distributed, because that just makes everything harder, OK? Hit it.
Và khi chúng ta xong phần tuần sau, chúng ta sẽ nói về chuyện gì xảy ra khi chuyển sang phân tán, vì điều đó khiến mọi thứ khó hơn, được chứ? Bắt đầu thôi.
Motherfucker can't maintain, but I'm a straight flow in the drain.
Thằng khốn đó không trụ nổi, còn tôi thì cứ chảy thẳng một mạch xuống cống.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.