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ả.
All right, guys, let's get started. Round of applause for DJ Cash. Awesome. Welcome back. Thank you. How did it go last week? It could have been a little better.
Được rồi các bạn, chúng ta bắt đầu nhé. Hãy vỗ tay chào DJ Cash. Tuyệt vời. Chào mừng em trở lại. Cảm ơn em. Tuần trước thế nào? Lẽ ra có thể tốt hơn một chút ạ.
They were saying I have to pay taxes on my beats, so. Your tax counter said you have to pay taxes on your beats? Yeah. Well, you're not paying taxes on the beats.
Họ bảo em phải đóng thuế cho các beat của em, nên là vậy ạ. Nhân viên thuế bảo em phải đóng thuế cho các beat của em à? Vâng. Thực ra em đâu có đóng thuế cho các beat.
You're paying taxes on the money you made with your beats. Right. Yeah. You've got to do that. All right. Yeah. Pay your taxes. All right.
Em đóng thuế trên số tiền em kiếm được từ các beat đó. Đúng vậy. Vâng. Em phải làm vậy thôi. Được rồi. Vâng. Hãy đóng thuế đầy đủ nhé. Được rồi.
But it's good, again, good you're getting back to where you need to be in life. All right, guys, a lot to cover.
Nhưng như vậy là tốt, thật tốt khi em đang trở lại đúng quỹ đạo trong cuộc sống. Được rồi các bạn, hôm nay có rất nhiều nội dung cần đề cập.
And today's lecture is awesome because it's transactions, and I get very excited. So let's jump into it. So, all right, for you guys in the class, project three is coming up this Sunday.
Và bài giảng hôm nay rất tuyệt vì nói về giao dịch, và tôi rất hào hứng. Vậy chúng ta bắt đầu thôi. Được rồi, với các bạn trong lớp, đồ án 3 sẽ đến hạn vào Chủ nhật này.
That's due. And we have the special office hours this, that should be the 15th, not the 5th. I'm missing a one. Sorry. Coming up on the 15th, this Saturday, from 3 to 5 p.m.
Đó là hạn nộp. Và chúng ta có giờ hỗ trợ đặc biệt, ngày này phải là ngày 15, không phải ngày 5. Tôi thiếu một số 1. Xin lỗi. Diễn ra vào ngày 15, thứ Bảy này, từ 3 đến 5 giờ chiều tại Gates.
in Gates. And again, post on Piazza, post if you have questions or come to office hours. And then I messed up the due date for homework five.
Và một lần nữa, hãy đăng lên Piazza nếu có câu hỏi, hoặc đến giờ hỗ trợ. Và tôi đã nhầm hạn nộp của bài tập về nhà 5.
That was also due the 16th, this Sunday, coming up. That's been pushed out a week, and that'll be due on the 23rd. And Gates, and Piazza, and the website should be updated for that.
Bài đó cũng đến hạn vào ngày 16, Chủ nhật này. Hạn đó được dời lại một tuần, và sẽ đến hạn vào ngày 23. Và Gates, Piazza, cùng trang web sẽ được cập nhật theo.
Any questions about project three? Who here has not started project three?
Có câu hỏi nào về đồ án 3 không? Ai ở đây chưa bắt đầu đồ án 3?
Okay. And I'll post this on Piazza, too.
Được rồi. Tôi cũng sẽ đăng điều này lên Piazza.
If you are concerned about your buffer pool manager from project one or your B+tree from project two not being completely thread safe, just put a latch in front of it.
Nếu các bạn lo lắng rằng buffer pool manager từ đồ án 1 hoặc B+tree từ đồ án 2 của mình chưa hoàn toàn an toàn luồng, thì cứ đặt một latch phía trước nó.
Put a global latch in front of the entire page table. And, you know, what's that?
Đặt một latch toàn cục phía trước toàn bộ page table. Và, bạn biết đấy, gì vậy?
Yeah, but, like, the things that will slow you down for project three will be, like, transactional, like, the lock manager stuff. Not the, not, like, the page table latch. Right?
Vâng, nhưng những thứ làm các bạn chậm lại ở đồ án 3 sẽ là phần giao dịch, như phần lock manager. Chứ không phải latch của page table. Đúng không?
Other questions or comments about project three? All right. And then for database talks, after this class today, we have the co-founder from Mooncake.
Còn câu hỏi hay ý kiến nào khác về đồ án 3 không? Được rồi. Và về các buổi nói chuyện về cơ sở dữ liệu, sau buổi học hôm nay, chúng ta có người đồng sáng lập của Mooncake.
It was a database startup that had extensions for Postgres that could read Iceberg tables. That's been, they got acquired by Databricks, so that guy's giving a talk.
Đó là một startup cơ sở dữ liệu có các phần mở rộng cho Postgres có thể đọc các bảng Iceberg. Họ đã được Databricks mua lại, nên anh ấy sẽ có buổi nói chuyện.
Tomorrow, as I posted on Piazza, we're having one of the co-founders of DBT flying in from Philadelphia.
Ngày mai, như tôi đã đăng trên Piazza, một trong những người đồng sáng lập của DBT sẽ bay từ Philadelphia đến.
So he's giving a talk at noon on the eighth floor in Gates, and there'll be pizza at that.
Anh ấy sẽ nói chuyện lúc 12 giờ trưa ở tầng tám tại Gates, và sẽ có pizza.
And then there'll be an info session for hiring and internships with him at 2:30, also in 8115. And I posted that on Piazza. Again, you know the RSVP for that. Just show up.
Sau đó sẽ có buổi giới thiệu về tuyển dụng và thực tập với anh ấy lúc 2:30, cũng ở phòng 8115. Tôi đã đăng điều đó lên Piazza. Một lần nữa, không cần đăng ký trước. Cứ đến thôi.
Talk to the guy. And then the Firebolt guy is Ben, who gave a talk with us on Wednesday. I said he was giving a talk today. I was wrong. It was Mooncake.
Hãy trò chuyện với anh ấy. Còn người của Firebolt là Ben, người đã nói chuyện với chúng ta hôm thứ Tư. Tôi đã nói anh ấy sẽ nói chuyện hôm nay. Tôi nhầm. Đó là Mooncake.
But he's coming back to give a talk in a seminar series a week from today. Again, that'll be on Zoom. Okay. All right.
Nhưng anh ấy sẽ quay lại nói chuyện trong chuỗi hội thảo vào đúng một tuần kể từ hôm nay. Một lần nữa, buổi đó sẽ qua Zoom. Được rồi. Được rồi.
So last class, we talked about concurrency protocols, and in particular, we talked about two-phase locking.
Vậy ở buổi trước, chúng ta đã nói về các giao thức điều khiển đồng thời, và cụ thể là giao thức khóa hai pha (two-phase locking).
We said this was a protocol that the DBMS can use at runtime to allow it to schedule the behavior or the ordering of transactions in such a way that you can guarantee serializability.
Chúng ta nói đây là một giao thức mà DBMS có thể dùng lúc chạy để lập lịch hành vi hay thứ tự thực thi của các giao dịch theo cách đảm bảo được tính khả tuần tự hóa (serializability).
And we said this was a pessimistic protocol where the DBMS assumes that transactions are going to have conflicts.
Và chúng ta nói đây là một giao thức bi quan, trong đó DBMS giả định rằng các giao dịch sẽ xung đột với nhau.
Therefore, it requires them to acquire locks in different modes on the objects that they were going to access before they're allowed to access them. And we showed different variations of two-phase locking.
Do đó, nó yêu cầu các giao dịch phải lấy khóa ở các chế độ khác nhau trên những đối tượng mà chúng sắp truy cập, trước khi được phép truy cập. Và chúng ta đã xem các biến thể khác nhau của khóa hai pha.
And in most systems, they're going to implement the strong strict one, where you just end up holding all the locks to the very end.
Trong hầu hết các hệ thống, người ta cài đặt biến thể strong strict, trong đó bạn giữ tất cả các khóa cho đến tận cuối.
So in the two-phase locking protocol, as I was saying, it's a pessimistic approach. Again, so you're going to assume transactions are going to conflict.
Như tôi vừa nói, giao thức khóa hai pha là một cách tiếp cận bi quan. Tức là bạn giả định các giao dịch sẽ xung đột với nhau.
But if you assume that they're not going to conflict and that most of the transactions are not going to interfere with each other, and most of your transactions are going to be pretty fast, pretty quick.
Nhưng nếu bạn giả định rằng chúng sẽ không xung đột và hầu hết các giao dịch sẽ không cản trở lẫn nhau, và hầu hết giao dịch của bạn đều khá nhanh, khá ngắn.
I think, like, loading a web page, that's basically a transaction. Like, you're going to get some queries, get a small amount of data, and then you're done real quickly.
Tôi nghĩ, chẳng hạn, tải một trang web về cơ bản là một giao dịch. Bạn chạy một vài truy vấn, lấy một lượng dữ liệu nhỏ, rồi xong rất nhanh.
Like, in the order of milliseconds. It's rare that transactions will take more than a second on modern systems.
Cỡ mili giây. Hiếm khi giao dịch mất hơn một giây trên các hệ thống hiện đại.
Or minutes or hours, days, worst case, weeks. They were more common in the old days. Sometimes they're common because you have to do, like, big bulk updates.
Hay hàng phút, hàng giờ, hàng ngày, tệ nhất là hàng tuần. Ngày xưa những trường hợp đó phổ biến hơn. Đôi khi chúng vẫn phổ biến vì bạn phải làm những cập nhật hàng loạt lớn.
But most of the transactions don't look like that. The majority of transactions that are existing in the world are going to be pretty fast.
Nhưng phần lớn giao dịch không như vậy. Đa số các giao dịch đang tồn tại trên thế giới đều khá nhanh.
So therefore, if you assume these properties about transactions, you assume that they're not going to conflict. You assume they're going to be pretty fast.
Then an alternative protocol might be to not require them to acquire locks. Let them do whatever they want to do.
Vì vậy, nếu bạn giả định những tính chất này về giao dịch, rằng chúng sẽ không xung đột, rằng chúng sẽ khá nhanh, thì một giao thức thay thế có thể là không bắt chúng phải lấy khóa. Cứ để chúng làm bất cứ điều gì chúng muốn.
And then at the end, when they go to commit, figure out whether there was actually a conflict. Because you assume most of the times there won't be.
Rồi đến cuối, khi chúng chuẩn bị commit, mới xác định xem có thực sự xảy ra xung đột hay không. Vì bạn giả định phần lớn thời gian sẽ không có xung đột.
And therefore, you'll be faster off than you would have been in a pessimistic approach like two-phase locking. Sound plausible? So that's what today is about. Today is about optimistic concurrency protocols.
Và do đó, bạn sẽ chạy nhanh hơn so với việc dùng cách tiếp cận bi quan như khóa hai pha. Nghe hợp lý chứ? Đó chính là nội dung của hôm nay. Hôm nay nói về các giao thức điều khiển đồng thời lạc quan.
And these sort of fall under the umbrella of what are called timestamp ordering concurrency protocols.
Và những giao thức này thuộc nhóm gọi là các giao thức điều khiển đồng thời sắp thứ tự theo nhãn thời gian (timestamp ordering).
And the idea is that rather than using locks to enforce the ordering of the operations within transactions, we're going to use timestamps to keep track of the order in which these things occur or should occur.
Ý tưởng là thay vì dùng khóa để áp đặt thứ tự của các thao tác trong giao dịch, chúng ta sẽ dùng nhãn thời gian để theo dõi thứ tự mà các việc này xảy ra hoặc nên xảy ra.
And then when transactions go to commit, we need to make sure that we generate timestamps for these transactions, or the operations are ordered in some kind of timestamp sequence in such a way that it's equivalent to executing the transactions in serial order.
Và khi các giao dịch chuẩn bị commit, chúng ta cần đảm bảo tạo ra nhãn thời gian cho các giao dịch này, hoặc các thao tác được sắp xếp theo một trình tự nhãn thời gian nào đó sao cho sao cho nó tương đương với việc thực thi các giao dịch theo thứ tự tuần tự.
Where you have TI, TJ. TI is going to execute all its operations first, followed by TJ.
Ví dụ bạn có TI, TJ. TI sẽ thực thi toàn bộ các thao tác của nó trước, rồi đến TJ.
But again, when there's concurrency protocols, I can actually interleave their operations, where they don't actually have to physically occur immediately one after another. They can actually be intertwined.
Nhưng một lần nữa, khi có các giao thức điều khiển đồng thời, tôi thực ra có thể xen kẽ các thao tác của chúng, tức là chúng không nhất thiết phải diễn ra vật lý ngay lập tức nối tiếp nhau. Chúng thực sự có thể đan xen vào nhau.
So the way we're going to make this work is that we're now going to maintain these timestamps for not only the transactions as they're actually doing operations in the database, we're also going to maintain timestamps for the database objects that are in our database.
Vậy cách chúng ta làm cho việc này hoạt động là bây giờ chúng ta sẽ duy trì các timestamp này không chỉ cho các giao dịch khi chúng đang thực hiện các thao tác trong cơ sở dữ liệu, mà chúng ta cũng sẽ duy trì timestamp cho các đối tượng cơ sở dữ liệu có trong cơ sở dữ liệu của chúng ta.
And again, we're being vague here. We're not saying whether it's a tuple or a page or a table or a database. It doesn't matter. The protocol still works.
Và một lần nữa, ở đây chúng ta đang nói khá mơ hồ. Chúng ta không nói đó là tuple, trang, bảng hay cả cơ sở dữ liệu. Điều đó không quan trọng. Giao thức vẫn hoạt động.
But now we're going to keep track of the timestamps of every single object in our database. Like, when were they accessed? When were they modified?
Nhưng bây giờ chúng ta sẽ theo dõi các timestamp của từng đối tượng một trong cơ sở dữ liệu. Ví dụ, chúng được truy cập khi nào? Được sửa đổi khi nào?
Who was the last transaction? What timestamp did they modify? We're going to maintain all that internally. We'll see next class how we actually can, in some systems, in SQL, we can see these things.
Giao dịch cuối cùng là ai? Nó đã sửa đổi ở timestamp nào? Chúng ta sẽ duy trì tất cả những thứ đó ở bên trong. Buổi sau chúng ta sẽ thấy ở một số hệ thống, bằng SQL, chúng ta có thể xem được những thứ này.
In the case of Postgres, it'll expose it to you. So it's maintaining a separation for you, but it's not always...
Với Postgres, nó sẽ cho bạn thấy. Vậy là nó duy trì sự tách biệt cho bạn, nhưng không phải lúc nào cũng...
They don't show it normally when you see queries, because at the end of the day, the application programmer shouldn't know about these timestamps.
Bình thường họ không hiển thị nó khi bạn thực hiện truy vấn, vì xét cho cùng, lập trình viên ứng dụng không cần biết về các timestamp này.
But underneath the covers, we're going to use them to keep track of things. And then at the beginning of the semester, we talked about how pages have headers and tuples have headers.
Nhưng ở bên dưới, chúng ta sẽ dùng chúng để theo dõi mọi thứ. Và vào đầu học kỳ, chúng ta đã nói về việc trang có header và tuple có header.
In that header, that's where we're going to start storing these timestamps. So now the question is, how do we generate timestamps?
Trong header đó là nơi chúng ta sẽ bắt đầu lưu các timestamp này. Vậy câu hỏi bây giờ là, làm thế nào để tạo ra timestamp?
They're saying satellites. Two systems do that. But we'll get there. When you say satellite, what is the satellite giving you? What kind of time?
Bạn nói là vệ tinh. Có hai hệ thống làm vậy. Nhưng chúng ta sẽ đến đó sau. Khi bạn nói vệ tinh, vệ tinh cung cấp cho bạn cái gì? Loại thời gian nào?
Wall clock. So we're getting ahead of ourselves.
Đồng hồ treo tường. Vậy là chúng ta đang đi trước hơi xa.
For a given transaction TI, we're going to say that it's going to be assigned a unique fixed timestamp, where this timestamp domain is always increasing in value.
Với một giao dịch TI bất kỳ, chúng ta sẽ nói rằng nó được gán một timestamp cố định và duy nhất, trong đó miền timestamp này luôn tăng dần về giá trị.
Meaning you can never have a transaction show up in the future that has a timestamp that's less than one that exceeded before. You have to deal with wraparound when the number gets really big.
Nghĩa là bạn không thể có một giao dịch xuất hiện sau mà lại có timestamp nhỏ hơn timestamp của một giao dịch đã xuất hiện trước đó. Bạn phải xử lý hiện tượng quay vòng khi con số trở nên rất lớn.
But if you use a 64-bit integer, it's going to take a while.
Nhưng nếu dùng số nguyên 64 bit thì sẽ mất khá lâu.
And so the different protocols that are out there will assign these timestamps to transactions at different points of their execution.
Và các giao thức khác nhau hiện có sẽ gán các timestamp này cho giao dịch ở những thời điểm khác nhau trong quá trình thực thi.
So the protocol we're going to talk about today, you're not going to get a timestamp until you actually commit at the end. You don't get one at the beginning.
Vậy giao thức mà hôm nay chúng ta sẽ nói tới, bạn sẽ không nhận được timestamp cho đến khi thực sự commit ở cuối. Bạn không nhận được nó ngay từ đầu.
In the case of something like Postgres, the way they do concurrency protocol, their concurrency protocol, which we'll discuss next class, you're actually going to get two timestamps. One beginning, one at the end.
Với một hệ thống như Postgres, cách họ thực hiện giao thức điều khiển đồng thời, giao thức đồng thời của họ, mà chúng ta sẽ thảo luận ở buổi sau, thực ra bạn sẽ nhận được hai timestamp. Một ở lúc bắt đầu, một ở lúc kết thúc.
But for today's class, we'll just have one timestamp. So they were jumping ahead a little bit and saying, oh, we can get these timestamps from satellites.
Nhưng với buổi học hôm nay, chúng ta chỉ có một timestamp. Vậy là họ đã nói trước một chút và bảo rằng, ồ, chúng ta có thể lấy các timestamp này từ vệ tinh.
But again, what you're really getting is what I call a system clock or a wall clock. An actual physical time that we keep track of as humans.
Nhưng một lần nữa, thứ bạn thực sự nhận được là cái tôi gọi là đồng hồ hệ thống hay đồng hồ treo tường. Tức là thời gian vật lý thực tế mà con người chúng ta theo dõi.
And typically, you want to use UTC because you're not worried about daylight savings. You don't want to have the clock roll back, and now your timestamps are now in the past.
Và thông thường, bạn nên dùng UTC vì bạn không phải lo về giờ mùa hè. Bạn không muốn đồng hồ bị quay ngược lại, khiến các timestamp của bạn giờ nằm trong quá khứ.
That's going to mess everything up. So daylight savings screws things up, and you want to use UTC.
Điều đó sẽ làm hỏng mọi thứ. Vậy nên giờ mùa hè gây rối mọi thứ, và bạn nên dùng UTC.
It doesn't have to be coming from the wall clock, getting from a satellite, GPS satellites, or getting it from an atomic clock. We'll see that later when we talk about Google Spanner.
Nó không nhất thiết phải đến từ đồng hồ treo tường, mà có thể lấy từ vệ tinh, vệ tinh GPS, hoặc từ đồng hồ nguyên tử. Chúng ta sẽ thấy điều này sau, khi nói về Google Spanner.
That gives you really accurate timestamps. But there's only two systems that use that kind of thing. DSQL from Amazon. That just came out. The guy gave a talk last class. Sorry.
Cách đó cho bạn các timestamp rất chính xác. Nhưng chỉ có hai hệ thống dùng kiểu này. DSQL của Amazon. Nó vừa mới ra mắt. Anh ấy đã có một buổi nói chuyện ở buổi trước. Xin lỗi.
There's the advanced database class happening at the same time as this class. The DSQL guy gave a talk, and it's on YouTube.
Có một lớp cơ sở dữ liệu nâng cao diễn ra cùng lúc với lớp này. Anh chàng DSQL đã có một buổi nói chuyện, và nó có trên YouTube.
I'll post some thoughts about this. It could just be also a logical counter.
Tôi sẽ đăng vài suy nghĩ về việc này. Nó cũng có thể chỉ là một bộ đếm logic.
You could just say, increment a counter by one, and every time a new transaction comes along, you just add one to it.
Bạn có thể chỉ cần tăng một bộ đếm lên một, và mỗi khi có một giao dịch mới đến, bạn cộng thêm một vào đó.
Problem with that one, and we'll see this when we're talking about distributed systems: how do you make sure that your counter is in sync with another node's counter?
Vấn đề với cách này, và chúng ta sẽ thấy khi nói về các hệ thống phân tán: làm sao bạn đảm bảo bộ đếm của mình đồng bộ với bộ đếm của một nút khác?
You can't. Typically, sometimes you can do a hybrid of these things.
Bạn không thể. Thông thường, đôi khi bạn có thể kết hợp lai giữa các cách này.
But in general, for our purposes here today, just assume that there's timestamps, assume that they're unique, and assume that they're always increasing in time, and that we're never going to go magically back in time with these things.
Nhưng nói chung, với mục đích của chúng ta hôm nay, cứ giả sử là có các timestamp, giả sử chúng là duy nhất, và giả sử chúng luôn tăng theo thời gian, và chúng ta sẽ không bao giờ quay ngược thời gian một cách kỳ diệu với chúng.
In Postgres, by default, the timestamps are 32-bit integers, so you wrap around eventually, and that causes problems. We'll talk about this next class, how you handle this.
Trong Postgres, theo mặc định, các timestamp là số nguyên 32 bit, nên cuối cùng chúng sẽ bị quay vòng, và điều đó gây ra vấn đề. Chúng ta sẽ nói về cách xử lý chuyện này ở buổi sau.
Postgres has to deal with the 32-bit number wrapping around, and now you have a bunch of timestamps that are in the past, even though logically they're in the past, but physically they're in the future.
Postgres phải xử lý việc số 32 bit bị quay vòng, và giờ bạn có hàng loạt timestamp nằm trong quá khứ, dù về mặt logic chúng ở quá khứ, nhưng về mặt vật lý lại ở tương lai.
And this idea of logical time and physical time will come up today.
Và ý tưởng về thời gian logic và thời gian vật lý sẽ xuất hiện trong buổi hôm nay.
So again, today we're going to talk about the Optimistic Concurrency Control protocol, which is the primary protocol, the most common protocol people use in a timestamp ordering database system.
Vậy một lần nữa, hôm nay chúng ta sẽ nói về giao thức Optimistic Concurrency Control, là giao thức chính, giao thức phổ biến nhất mà mọi người dùng trong một hệ cơ sở dữ liệu sắp xếp theo timestamp.
And again, the confusing part about this is that the protocol's name is the Optimistic Concurrency Control protocol. It is in the category of optimistic concurrency control protocols.
Và một lần nữa, điều gây nhầm lẫn ở đây là tên của giao thức là giao thức Optimistic Concurrency Control. Nó thuộc nhóm các giao thức điều khiển đồng thời lạc quan.
But you just say OCC, and everyone will know what you're talking about.
Nhưng bạn cứ nói OCC, và ai cũng sẽ hiểu bạn đang nói về cái gì.
And then we'll talk about, at the end, how we're going to handle additional anomalies that we're not going to be able to handle out of the box, at least so far what we've talked about in two-phase locking and OCC, and how some systems might be okay with these additional anomalies.
Và sau đó, ở cuối buổi, chúng ta sẽ nói về cách xử lý thêm các dị thường khác mà chúng ta sẽ không thể xử lý ngay từ đầu, ít nhất là với những gì chúng ta đã nói đến cho đến giờ về khóa hai pha và OCC, và cách một số hệ thống có thể chấp nhận những dị thường bổ sung này.
And we can run at lower isolation levels and get better performance.
Và chúng ta có thể chạy ở các mức cô lập thấp hơn để có hiệu năng tốt hơn.
So the original Optimistic Concurrency Control protocol that was based on timestamps is called OCC.
Vậy giao thức Optimistic Concurrency Control gốc dựa trên dấu thời gian được gọi là OCC.
And the basic idea is that when transactions run, the database system is going to create a private workspace for them, like a little area in memory where they're going to store all the things that they read and write from the database.
Và ý tưởng cơ bản là khi các giao dịch chạy, hệ cơ sở dữ liệu sẽ tạo một không gian làm việc riêng cho chúng, giống như một vùng nhỏ trong bộ nhớ, nơi chúng sẽ lưu tất cả những thứ mà chúng đọc và ghi từ cơ sở dữ liệu.
So anytime I'm going to read something in the database, I'm going to make a copy of it first in the global database that all the transactions can read from, and I'm going to copy it into my private workspace.
Vậy mỗi khi tôi đọc một thứ gì đó trong cơ sở dữ liệu, trước tiên tôi sẽ tạo một bản sao của nó từ cơ sở dữ liệu toàn cục mà tất cả các giao dịch đều có thể đọc, và tôi sao chép nó vào không gian làm việc riêng của mình.
And therefore, I can make changes in that private workspace, and no other transaction can see those changes.
Do đó, tôi có thể thực hiện các thay đổi trong không gian làm việc riêng đó, và không giao dịch nào khác nhìn thấy những thay đổi ấy.
And then when it comes time to commit, now we have to go look at the other transactions that either have run in the past or are running right now, depending how we want to do this, and we have to see whether they have read or written to anything that we have potentially modified or read in our private workspace.
Rồi đến khi cần commit, lúc này chúng ta phải xem xét các giao dịch khác đã chạy trong quá khứ hoặc đang chạy ngay lúc này, tùy cách chúng ta muốn làm, và chúng ta phải kiểm tra xem chúng có đọc hoặc ghi vào thứ gì mà chúng ta có thể đã sửa đổi hoặc đọc trong không gian làm việc riêng của mình hay không.
And again, depending on the way we're going to do this validation step, we may be allowed to commit, we may have to kill ourselves and retry.
Và một lần nữa, tùy cách chúng ta thực hiện bước kiểm tra hợp lệ này, chúng ta có thể được phép commit, hoặc có thể phải tự hủy và thử lại.
But the key idea is that this private workspace part is where we can do all our changes in like a private scratch phase, and no one can see them.
Nhưng ý tưởng chính là phần không gian làm việc riêng này là nơi chúng ta thực hiện mọi thay đổi trong một pha nháp riêng tư, và không ai nhìn thấy chúng.
So two-phase locking was invented at IBM in 1976 at IBM working in System R. OCC was invented in 1981 here at CMU.
Khóa hai pha được phát minh tại IBM vào năm 1976 tại IBM, khi làm việc trong System R. OCC được phát minh vào năm 1981 ngay tại CMU.
The inventor, H. T. Kung, he's not a database person, he was a networking person. But he came up with this protocol for interacting with databases.
Người phát minh là H. T. Kung, ông ấy không phải người làm cơ sở dữ liệu mà là người làm mạng. Nhưng ông ấy đã nghĩ ra giao thức này để tương tác với cơ sở dữ liệu.
I think it's a very famous paper written by a non-database person. Of course, at the end of the day, what do you need a network for?
Tôi nghĩ đây là một bài báo rất nổi tiếng do một người không thuộc lĩnh vực cơ sở dữ liệu viết. Dĩ nhiên, cuối cùng thì bạn cần mạng để làm gì?
To talk to a database. So it makes sense that they were looking at these things. The whole point of a network is so you can talk to databases.
Để giao tiếp với cơ sở dữ liệu. Nên việc họ xem xét những thứ này là hợp lý. Toàn bộ mục đích của mạng là để bạn có thể giao tiếp với cơ sở dữ liệu.
So the protocol is going to have three phases. And again, because he's a networking person, the names of the phases might be a little weird.
Vậy giao thức này sẽ có ba pha. Và một lần nữa, vì ông ấy là người làm mạng, tên của các pha có thể hơi lạ.
Just bear with me. So in the first phase, it's called the read phase. And despite the name read, you actually can do reads and writes.
Các bạn cứ kiên nhẫn nhé. Pha đầu tiên được gọi là pha đọc (read phase). Và dù tên là đọc, thực ra bạn có thể vừa đọc vừa ghi.
But this is where the data system creates the private workspace at the beginning for this transaction. And anything that it writes will have to be stored in this private workspace.
Nhưng đây là lúc hệ thống dữ liệu tạo ra không gian làm việc riêng ngay từ đầu cho giao dịch này. Và bất cứ thứ gì nó ghi đều phải được lưu trong không gian làm việc riêng này.
Anything that it reads, you don't have to copy it into your private workspace.
Còn thứ gì nó đọc thì bạn không nhất thiết phải sao chép vào không gian làm việc riêng.
But if you want to guarantee that you have repeatable reads, meaning if I read the same thing over and over again, I want to see the same value, then you make a copy into your private workspace.
Nhưng nếu bạn muốn đảm bảo có các lần đọc lặp lại được (repeatable reads), nghĩa là nếu tôi đọc cùng một thứ nhiều lần, tôi muốn thấy cùng một giá trị, thì bạn tạo một bản sao vào không gian làm việc riêng của mình.
And then when you complete all your read and write operations and the transaction calls commit, then you automatically switch into this validation phase.
Và khi bạn hoàn tất mọi thao tác đọc và ghi, rồi giao dịch gọi commit, thì nó tự động chuyển sang giai đoạn xác thực (validation).
And this is where the data system is going to figure out, is this transaction allowed to commit?
Và đây là lúc hệ thống cơ sở dữ liệu sẽ xác định xem giao dịch này có được phép commit hay không?
And based on whether it's applying the changes, would violate a timestamp ordering that is equivalent to a serial ordering of the transactions.
Dựa trên việc nếu áp dụng các thay đổi này, liệu nó có vi phạm thứ tự dấu thời gian (timestamp) tương đương với một thứ tự tuần tự của các giao dịch hay không.
I'll go through examples of how we're going to do this.
Tôi sẽ đi qua các ví dụ về cách chúng ta thực hiện việc này.
And then if you pass the validation phase, then you enter the write phase, where the transaction is allowed to apply its changes that are in its private workspace into the global database.
Và sau đó nếu bạn vượt qua giai đoạn xác thực, thì bạn bước vào giai đoạn ghi, nơi giao dịch được phép áp dụng các thay đổi của nó từ không gian làm việc riêng vào cơ sở dữ liệu toàn cục.
And we're going to be hand-waving how we're going to do this write phase. But obviously, you want this to be atomic because you want all your changes to appear once.
Và chúng ta sẽ nói lướt qua cách thực hiện giai đoạn ghi này. Nhưng rõ ràng là bạn muốn việc này có tính nguyên tử vì bạn muốn mọi thay đổi chỉ xuất hiện một lần.
So one way to do that is put a global lock on the entire thing. But for simplicity, we'll do that. But in real systems, you wouldn't do that.
Một cách để làm vậy là đặt một khóa toàn cục lên toàn bộ quá trình. Để đơn giản, chúng ta sẽ làm vậy. Nhưng trong các hệ thống thực tế, bạn sẽ không làm như thế.
So then when you pass the validation phase, when you enter the validation phase, that's when you get a timestamp.
Vậy khi bạn vượt qua giai đoạn xác thực, khi bạn bước vào giai đoạn xác thực, đó là lúc bạn nhận timestamp.
Then if you pass the validation phase, All the objects that you modified are now assigned a write timestamp for this transaction that it got during the validation phase.
Sau đó nếu bạn vượt qua giai đoạn xác thực, tất cả các đối tượng mà bạn đã sửa đổi giờ được gán một write timestamp của giao dịch này, là timestamp mà nó nhận được trong giai đoạn xác thực.
So you don't get your timestamp when you start, you get the timestamp when you hit the validation phase.
Vậy bạn không nhận timestamp khi bắt đầu, mà nhận timestamp khi đến giai đoạn xác thực.
And then if you succeed at that, then you're allowed to go update the global database with the timestamp you got in the commit process.
Và nếu bạn thành công ở bước đó, thì bạn được phép cập nhật cơ sở dữ liệu toàn cục bằng timestamp mà bạn nhận được trong quá trình commit.
So the read phase, which we'll focus on first, this is basically where all the work happens for the transaction. Then everything else is the commit protocol.
Vậy giai đoạn đọc, mà chúng ta sẽ tập trung trước, về cơ bản là nơi toàn bộ công việc của giao dịch diễn ra. Còn mọi thứ khác là giao thức commit.
You're making sure that things are allowed to happen, or things will happen in the order that it should happen. That's equivalent to a serial ordering.
Bạn đang đảm bảo rằng mọi việc được phép xảy ra, hoặc mọi việc sẽ xảy ra theo đúng thứ tự cần thiết. Tức là tương đương với một thứ tự tuần tự.
All right, so let's look at the schedule now. We have two transactions, T1 and T2. T1 is going to read on A, write on A, then read A again.
Được rồi, giờ hãy xem lịch thực thi. Chúng ta có hai giao dịch, T1 và T2. T1 sẽ đọc A, ghi A, rồi đọc A lần nữa.
And T2 is just going to do a read on A. And so I'm showing the boundaries here for the three phases: read, validate, and write.
Còn T2 chỉ đọc A. Và tôi đang chỉ ra ranh giới của ba giai đoạn ở đây: đọc, xác thực, và ghi.
Again, just like in the lock and unlock stuff in two-phase locking, you don't explicitly call this in your application code.
Một lần nữa, giống như phần lock và unlock trong khóa hai pha, bạn không gọi tường minh những thứ này trong mã ứng dụng của mình.
I'm just showing you the boxes to say where the boundaries are for these phases. So when the...
Tôi chỉ vẽ các ô này để cho thấy ranh giới của các giai đoạn. Vậy khi...
And so also, too, now in our database, now we have the key-value pairs, an object and a value, like A, and the value is 123.
Ngoài ra, giờ trong cơ sở dữ liệu của chúng ta, chúng ta có các cặp khóa-giá trị, một đối tượng và một giá trị, chẳng hạn A, và giá trị là 123.
And then we have this write timestamp that corresponds to the last committed transaction that wrote that value.
Và sau đó chúng ta có write timestamp này tương ứng với giao dịch đã commit gần nhất đã ghi giá trị đó.
In this case here, assume there was another transaction, T0, that got timestamped 0, and therefore the write timestamp for this object in the database is 0.
Trong trường hợp này, giả sử có một giao dịch khác, T0, được gán timestamp 0, và do đó write timestamp của đối tượng này trong cơ sở dữ liệu là 0.
And again, we have the three phases here. All right, so our transaction, T1, starts.
Và một lần nữa, chúng ta có ba pha ở đây. Được rồi, giao dịch T1 của chúng ta bắt đầu.
All right, as soon as we call begin, we enter the read phase, and then we create this private workspace that has nothing in it right now.
Được rồi, ngay khi gọi begin, chúng ta bước vào pha đọc, và sau đó tạo ra không gian làm việc riêng này, hiện tại chưa có gì trong đó.
Then when it runs a read on object A, assuming we're going to copy everything to our workspace because we want to have repeatable reads, it's going to copy the current value of A, the entire tuple, and put it into our private workspace.
Rồi khi nó thực hiện đọc đối tượng A, giả sử chúng ta sao chép mọi thứ vào không gian làm việc của mình vì chúng ta muốn có các lần đọc lặp lại được (repeatable reads), nó sẽ sao chép giá trị hiện tại của A, toàn bộ tuple, và đặt vào không gian làm việc riêng của chúng ta.
Now there's a context switch, and T2 starts running. So again, it enters the read phase. We create the workspace for it.
Bây giờ có một lần chuyển ngữ cảnh, và T2 bắt đầu chạy. Vậy nên nó cũng bước vào pha đọc. Chúng ta tạo không gian làm việc cho nó.
And then when it reads A, we copy the latest version, or we copy A from the global database into its workspace.
Và khi nó đọc A, chúng ta sao chép phiên bản mới nhất, hay sao chép A từ cơ sở dữ liệu toàn cục vào không gian làm việc của nó.
Then now it goes to commit. So now we enter the validation phase. So this is when, again, the data system assigns a timestamp to the transaction.
Rồi bây giờ nó đi đến commit. Vậy là chúng ta bước vào pha xác thực. Đây là lúc hệ quản trị dữ liệu gán một timestamp cho giao dịch.
So T2 is committing first. It's going to get timestamp 1.
Vậy T2 commit trước. Nó sẽ nhận timestamp 1.
So now we're going to run this validation protocol to see whether this thing has read or written to anything else that any other active transaction could have modified or also read.
Giờ chúng ta sẽ chạy giao thức xác thực này để xem liệu giao dịch này đã đọc hoặc ghi thứ gì mà bất kỳ giao dịch đang hoạt động nào khác có thể đã sửa đổi hoặc cũng đã đọc hay không.
In this case here, T2 read A. T1 read A, but hasn't written to it yet. So therefore there's no conflict, and T2 is allowed to commit.
Trong trường hợp này, T2 đọc A. T1 đọc A, nhưng chưa ghi vào nó. Vì vậy không có xung đột, và T2 được phép commit.
So when we enter the write phase, there's nothing for us to do because there's no modifications in the private workspace. So we just blow it away and we're done.
Khi bước vào pha ghi, chúng ta không có gì để làm vì không có sửa đổi nào trong không gian làm việc riêng. Nên chúng ta chỉ việc xóa nó đi và xong.
Now we context switch back over to T1. T1 does a write on A. So in this case here, we're going to update in our private workspace with the new value.
Giờ chúng ta chuyển ngữ cảnh trở lại T1. T1 thực hiện ghi lên A. Vậy trong trường hợp này, chúng ta sẽ cập nhật giá trị mới trong không gian làm việc riêng.
Now we're going to set the write timestamp to infinity, just to say that this is something that we've modified, but we don't have a timestamp yet, because we don't get one for our transactions until we enter the validate phase.
Giờ chúng ta đặt write timestamp bằng vô cực, chỉ để cho biết đây là thứ chúng ta đã sửa đổi, nhưng chúng ta chưa có timestamp, vì giao dịch của chúng ta không nhận timestamp cho đến khi bước vào pha xác thực.
So then now it reads A. And again, you can go read the same record that it modified in its private workspace. So again, that guarantees repeatable reads. Then now it enters the validation phase.
Rồi bây giờ nó đọc A. Và một lần nữa, bạn có thể đọc cùng bản ghi mà nó đã sửa đổi trong không gian làm việc riêng. Vậy nên điều đó đảm bảo các lần đọc lặp lại được. Rồi bây giờ nó bước vào pha xác thực.
It gets its assigned timestamp, T2. Check to see whether there's any conflicts. There isn't, because there's no other active transactions.
Nó được gán timestamp, T2. Kiểm tra xem có xung đột nào không. Không có, vì không có giao dịch nào khác đang hoạt động.
So now when it enters the write phase, it then applies the timestamp that was given to it in the validation phase into its private workspace for the object that it modified.
Vậy khi bước vào pha ghi, nó áp dụng timestamp được cấp trong pha xác thực vào không gian làm việc riêng cho đối tượng mà nó đã sửa đổi.
So it got timestamp 2. So now it sets the write timestamp of this object in the private workspace to 2. And then it pushes the change up into the global database. Yes.
Vậy nó nhận timestamp 2. Giờ nó đặt write timestamp của đối tượng này trong không gian làm việc riêng thành 2. Và sau đó nó đẩy thay đổi lên cơ sở dữ liệu toàn cục. Vâng.
The question is, why is the timestamp assigned at the validation phase, after you've done everything, rather than when the transaction started?
Câu hỏi là, tại sao timestamp được gán ở pha xác thực, sau khi bạn đã làm xong mọi thứ, thay vì khi giao dịch bắt đầu?
Because you don't know what the logical ordering should be before all the transactions finish. So in this case here, T1 started before T2 did. So physically, T1 started before T2.
Vì bạn không biết thứ tự logic nên là gì trước khi tất cả các giao dịch kết thúc. Vậy trong trường hợp này, T1 bắt đầu trước T2. Tức là về mặt vật lý, T1 bắt đầu trước T2.
But T2 logically committed before T1 does. So therefore, it has a lower timestamp. So getting it at the beginning doesn't make a difference here.
Nhưng về mặt logic, T2 commit trước T1. Vì vậy nó có timestamp thấp hơn. Nên việc lấy timestamp ngay từ đầu không tạo ra khác biệt ở đây.
Getting it at the beginning would restrain you to make sure that the ordering of the operations for the transactions matches the timestamps you were given when they show up.
Lấy ngay từ đầu sẽ ràng buộc bạn phải bảo đảm rằng thứ tự các thao tác của các giao dịch khớp với các timestamp bạn được cấp khi chúng xuất hiện.
And that limits parallelism. What's that?
Và điều đó hạn chế tính song song. Bạn hỏi gì ạ?
The statement is, because we assign it when they validate, that it gives us more flexibility to get better parallelism? Yes. Other questions?
Ý bạn là, vì ta gán timestamp khi chúng validate, nên ta có thêm sự linh hoạt để đạt tính song song tốt hơn phải không? Đúng vậy. Còn câu hỏi nào khác không?
All right, so this is obviously a simple example. But again, just re-emphasizing the same point I was just making, that physically, T1 started before T2 did. But logically, T2 committed before T1 did.
Được rồi, đây rõ ràng là một ví dụ đơn giản. Nhưng một lần nữa, nhấn mạnh lại đúng điều tôi vừa nói, là về mặt vật lý, T1 bắt đầu trước T2. Nhưng về mặt logic, T2 commit trước T1.
That's why T2 has a timestamp in the past from T1. And it makes sense, right? Because T1 wrote to A. It wrote to A after T2 committed.
Đó là lý do T2 có timestamp nằm trước T1. Và điều này hợp lý, đúng không? Vì T1 ghi vào A. Nó ghi vào A sau khi T2 đã commit.
If T2 would have committed after T1 did, then it should have seen that write on A. But it didn't.
Nếu T2 commit sau T1, thì nó lẽ ra phải thấy lần ghi đó trên A. Nhưng nó đã không thấy.
And that's why getting the timestamp later rather than at the beginning allows you to order things in a way that's still correct, even though it's not the same order in which they arrived, But it is still equivalent to a serial ordering.
Và đó là lý do việc lấy timestamp muộn thay vì lúc đầu cho phép bạn sắp xếp mọi thứ theo cách vẫn đúng đắn, dù không cùng thứ tự mà chúng đến, nhưng vẫn tương đương với một thứ tự tuần tự.
And as we said two classes ago, that's correct. That's our metric for correctness.
Và như đã nói hai buổi trước, như vậy là đúng. Đó là thước đo tính đúng đắn của chúng ta.
So the question is, is this protocol going to handle the memory overhead of having to make all these extra copies?
Vậy câu hỏi là, giao thức này sẽ xử lý thế nào với chi phí bộ nhớ khi phải tạo tất cả những bản sao thừa này?
I mean, if you have to update a billion things, then you have to make a billion copies in this protocol.
Ý tôi là, nếu bạn phải cập nhật một tỉ thứ, thì bạn phải tạo một tỉ bản sao trong giao thức này.
We'll see next class in MVCC where you can basically take diffs of the changes you make. And those will be much smaller.
Buổi sau ta sẽ thấy ở MVCC, về cơ bản bạn có thể lưu các diff của những thay đổi bạn thực hiện. Và chúng sẽ nhỏ hơn nhiều.
But again, I can back all my intermediate results to my buffer pool. And if they get swapped out to disk, that's OK, because I can always bring them back in.
Nhưng, tôi cũng có thể lưu các kết quả trung gian vào buffer pool. Và nếu chúng bị đẩy xuống đĩa thì cũng không sao, vì tôi luôn có thể nạp chúng trở lại.
Yes?
Bạn hỏi ạ?
The question is, how do you make sure this isn't happening atomically? So I'm showing one tuple getting written. I can do that pretty easily, atomically.
Câu hỏi là, làm sao bảo đảm việc này không diễn ra một cách nguyên tử? Tôi đang minh họa việc ghi một tuple. Cái đó tôi làm nguyên tử khá dễ.
What do I have to update? Multiple tables, multiple pages. We'll come to that in a second. The original protocol from 1981 just had a single latch.
Nhưng nếu phải cập nhật nhiều bảng, nhiều trang thì sao? Lát nữa ta sẽ nói đến. Giao thức gốc từ năm 1981 chỉ có một latch duy nhất.
A single lock for everything, right? I think so, yes. Yes, for all of them. Because again, think back back then.
Một khóa duy nhất cho mọi thứ, đúng không? Tôi nghĩ vậy, đúng. Đúng, cho tất cả. Vì hãy nghĩ lại thời đó.
You had one core on your CPUs. It's not like you had a bunch of threads active. There's other tricks, a way to get around that.
CPU chỉ có một lõi. Không có nhiều luồng chạy cùng lúc như bây giờ. Có những mẹo khác để tránh vấn đề đó.
It'll make more sense when we do MVCC, but I'll talk a little bit about it in a second. There's other tricks you can do.
Nó sẽ dễ hiểu hơn khi ta học MVCC, nhưng lát nữa tôi sẽ nói thêm một chút về nó. Còn có những mẹo khác mà bạn có thể dùng.
You can make sure that when you do the validation, if you have parallel, you have multiple workers doing validation in the same phase, that they're all going in the same lexicographical ordering of the keys.
Bạn có thể đảm bảo rằng khi thực hiện validation, nếu có chạy song song, tức là có nhiều worker cùng validation trong cùng một pha, thì tất cả chúng đều đi theo cùng một thứ tự từ điển của các khóa.
So if I updated key A, B, C, and you updated key A, B, C, then I'm going to check A, then B, then C, and you'll go in the same order.
Nên nếu tôi cập nhật các khóa A, B, C, và bạn cũng cập nhật các khóa A, B, C, thì tôi sẽ kiểm tra A, rồi B, rồi C, và bạn cũng đi theo đúng thứ tự đó.
So that way, you're not checking B, and you need to check A, and I'm checking A. Yes, yes. The statement is you need a fairness guarantee, yes.
Như vậy sẽ không xảy ra chuyện bạn đang kiểm tra B mà cần kiểm tra A, trong khi tôi đang kiểm tra A. Vâng, đúng. Ý bạn là cần có một đảm bảo về tính công bằng, đúng vậy.
That's outside the scope of what we're talking about here today. All right, so the read phase is repeating what I already said.
Điều đó nằm ngoài phạm vi những gì chúng ta bàn hôm nay. Được rồi, pha đọc thì chỉ là lặp lại những gì tôi đã nói.
All right, so we're going to track the read/write set of all the transactions. And any time they want to modify something, again, we're not doing inserts and deletes, we're just doing updates right now.
Được rồi, chúng ta sẽ theo dõi tập đọc/ghi của tất cả các giao dịch. Và bất cứ khi nào chúng muốn sửa đổi thứ gì đó, một lần nữa, chúng ta không xét thao tác chèn và xóa, mà bây giờ chỉ xét thao tác cập nhật.
Any time I want to update something, I'm going to do it in my private workspace.
Bất cứ khi nào muốn cập nhật thứ gì, tôi sẽ làm trong không gian làm việc riêng của mình.
And so if I want to have repeatable reads, I want to make sure that I copy everything I'm going to read also in my private workspace as well, so that way when I go read it again, I'm guaranteed to see the same thing.
Và nếu tôi muốn có các lần đọc lặp lại được, tôi phải đảm bảo sao chép mọi thứ mình sắp đọc vào không gian làm việc riêng của mình nữa, để khi đọc lại, tôi được đảm bảo thấy đúng dữ liệu như trước.
We'll see multi-version control next class. This is where having two timestamps can help you, because now you can say not only the timestamp of, was this thing modified since I started?
Chúng ta sẽ học điều khiển đa phiên bản ở buổi sau. Đây là chỗ việc có hai dấu thời gian có thể giúp ích, bởi vì lúc này bạn có thể nói không chỉ về dấu thời gian của việc thứ này có bị sửa đổi kể từ khi tôi bắt đầu hay không?
And then if it was, what's the timestamp of when it was last considered the latest version? So I can figure out where I land in my ranges.
Và nếu có, thì dấu thời gian lúc nó được coi là phiên bản mới nhất lần cuối là gì? Nhờ vậy tôi có thể xác định mình nằm ở đâu trong các khoảng.
Again, I'm jumping ahead of myself, but that's where the two timestamps help us.
Một lần nữa, tôi đang nói trước, nhưng đó là chỗ hai dấu thời gian giúp ích cho chúng ta.
The other thing I haven't talked about also, too, is in here I'm just saying, all right, it's a bunch of boxes in PowerPoint. Obviously, in a real system, you have indexes.
Một điều nữa tôi cũng chưa nói tới, là ở đây tôi chỉ nói rằng, đây là một loạt các ô vẽ trong PowerPoint. Rõ ràng, trong một hệ thống thực tế thì bạn có các chỉ mục.
So how do I make sure that if I'm updating something and I'm going to go read it again, I can do this efficiently?
Vậy làm sao đảm bảo rằng nếu tôi đang cập nhật thứ gì đó và sắp đọc lại nó, tôi có thể làm việc này một cách hiệu quả?
Because if I go check the global index of this table, it's going to point to the database at the top, not to my private workspace.
Bởi vì nếu tôi kiểm tra chỉ mục toàn cục của bảng này, nó sẽ trỏ tới cơ sở dữ liệu ở trên cùng, chứ không phải không gian làm việc riêng của tôi.
So a little extra metadata I've got to keep track of. OK, if I'm looking for A on this table, I actually have a copy of it.
Nên có thêm một chút siêu dữ liệu mà tôi phải theo dõi. Được rồi, nếu tôi tìm A trên bảng này, thì thực ra tôi đã có một bản sao của nó.
Don't check the B+tree. But we can ignore that for now. So the real magic happens with the validation phase.
Đừng kiểm tra B+tree. Nhưng giờ chúng ta có thể bỏ qua điều đó. Vậy phần thực sự thú vị nằm ở pha validation.
This is how we're going to enforce that the ordering of the operations within our transactions end up matching, or equivalent to, a serial ordering, right?
Đây là cách chúng ta đảm bảo rằng thứ tự của các thao tác trong các giao dịch cuối cùng sẽ khớp với, hay tương đương với, một thứ tự tuần tự, đúng không?
And so, related to what they brought up, in the original protocol it was all serial validation, meaning I can only have one transaction in the validation phase at any given time.
Và liên quan đến điều bạn vừa nêu, trong giao thức gốc thì validation hoàn toàn tuần tự, nghĩa là tại bất kỳ thời điểm nào chỉ có một giao dịch được ở pha validation.
If I now have to have multiple transactions validating, it becomes more tricky, because there's potential deadlock issues. I'm taking latches on these write sets and read-write sets of the different private workspaces.
Nếu bây giờ có nhiều giao dịch cùng validation, thì sẽ phức tạp hơn, vì có khả năng xảy ra vấn đề bế tắc. Tôi đang lấy các latch trên những tập ghi này và các tập đọc-ghi của những không gian làm việc riêng khác nhau.
It starts to get expensive. But the overall high-level protocol doesn't change. I need more machinery to make sure that I don't have race conditions and other problems.
Chi phí bắt đầu tăng lên. Nhưng giao thức tổng thể ở mức cao thì không thay đổi. Tôi cần thêm cơ chế để đảm bảo rằng mình không gặp các race condition và những vấn đề khác.
All right, so there's two ways to do validation. And if your system's going to implement OCC, you do one of these two. And at a high level, they're the same, right?
Được rồi, vậy có hai cách để thực hiện kiểm tra hợp lệ. Và nếu hệ thống của bạn triển khai OCC, bạn sẽ dùng một trong hai cách này. Và ở mức cao thì chúng giống nhau, đúng không?
In the end, you're checking to see, for each transaction, you're trying to see, am I allowed to commit?
Rốt cuộc, bạn đang kiểm tra xem, với mỗi giao dịch, bạn cố xem: tôi có được phép commit không?
And the question is, are you looking back in time or forward in time to see whether you potentially have a conflict?
Và câu hỏi là, bạn nhìn ngược về quá khứ hay nhìn tới tương lai để xem liệu có khả năng xảy ra xung đột hay không?
So with forward validation, the idea is that you're going to check to see whether you, the transaction that's trying to commit, whether your read-write set has a conflict with any other active transaction running in that system right now.
Với forward validation, ý tưởng là bạn sẽ kiểm tra xem giao dịch đang cố commit, liệu tập đọc-ghi của nó có xung đột với bất kỳ giao dịch đang hoạt động nào khác đang chạy trong hệ thống ngay lúc này hay không.
Because you can peek in their read-write sets. You know what things they're looking at. You see, have I modified something that some transaction has read? And I'm trying to commit now.
Vì bạn có thể xem trộm tập đọc-ghi của chúng. Bạn biết chúng đang xem những dữ liệu nào. Bạn xem liệu tôi có sửa thứ gì mà một giao dịch nào đó đã đọc hay không. Và bây giờ tôi đang cố commit.
And I'm going to be in the past where that other transaction is going to be in the future. And it's going to miss my write. And again, that would violate serial ordering.
Và tôi sẽ nằm trong quá khứ, còn giao dịch kia sẽ nằm trong tương lai. Và nó sẽ bỏ lỡ thao tác ghi của tôi. Và một lần nữa, điều đó sẽ vi phạm thứ tự tuần tự.
Backward validation is where you go to see whether there's a read or write that was made by a transaction that has already committed in the past and that you missed it.
Backward validation là khi bạn kiểm tra xem có thao tác đọc hoặc ghi nào do một giao dịch đã commit trong quá khứ thực hiện mà bạn đã bỏ lỡ hay không.
Like, you didn't read their changes.
Tức là, bạn đã không đọc những thay đổi của chúng.
And therefore, again, that would violate the serial ordering because now you're traveling back in time and seeing the state of the database as it was before that other transaction committed and missed that read.
Và do đó, một lần nữa, điều đó sẽ vi phạm thứ tự tuần tự vì lúc này bạn đang quay ngược thời gian và thấy trạng thái của cơ sở dữ liệu như trước khi giao dịch kia commit, và đã bỏ lỡ thao tác đọc đó.
So the second one is the most common one.
Cách thứ hai là cách phổ biến nhất.
Any system that's implementing OCC, including the DSQL stuff that we just mentioned on Amazon and a couple other famous systems, they're going to be doing this, the second approach, because it's easier.
Bất kỳ hệ thống nào triển khai OCC, kể cả DSQL mà chúng ta vừa nhắc đến của Amazon và một vài hệ thống nổi tiếng khác, đều sẽ dùng cách thứ hai này, vì nó dễ hơn.
Because I just go check to see what's the read-write set of any transaction in the last certain time range or something.
Vì tôi chỉ cần đi kiểm tra tập đọc-ghi của các giao dịch trong một khoảng thời gian gần đây nào đó.
Or I check the timestamp of the latest version of the transaction and see whether it's in the future from when I read it. And therefore, I have a conflict.
Hoặc tôi kiểm tra timestamp của phiên bản mới nhất của giao dịch và xem nó có nằm sau thời điểm tôi đọc hay không. Và như vậy, tôi có một xung đột.
But I want to go through forward validation just because that really clearly shows you the idea of things may physically happen in a different order than the logical way we want to store this in the database.
Nhưng tôi vẫn muốn đi qua forward validation chỉ vì nó thể hiện rất rõ ràng ý tưởng rằng mọi việc có thể xảy ra về mặt vật lý theo một thứ tự khác với cách logic mà chúng ta muốn lưu trong cơ sở dữ liệu.
So as we already said, when a transaction enters the validation phase, the data system is going to assign it a timestamp. Those timestamps are always going forward, increasing in time.
Như đã nói, khi một giao dịch bước vào pha kiểm tra hợp lệ, hệ thống dữ liệu sẽ gán cho nó một timestamp. Những timestamp đó luôn đi về phía trước, tăng dần theo thời gian.
And then now we're going to check for the transaction that it's trying to commit in the validation phase. We're going to check the read-write set of all the other active transactions in the system.
Và bây giờ chúng ta sẽ kiểm tra giao dịch đang cố commit trong pha xác thực. Chúng ta sẽ kiểm tra tập đọc-ghi của tất cả các giao dịch đang hoạt động khác trong hệ thống.
Again, for simplicity, assume they are just in the read phase. They're not in the validation phase. In the validation phase, again, you do the same check. For simplicity, we'll keep them separate.
Một lần nữa, để đơn giản, giả sử chúng chỉ đang ở pha đọc. Chúng chưa ở pha xác thực. Ở pha xác thực, một lần nữa, bạn thực hiện kiểm tra tương tự. Để đơn giản, chúng ta sẽ tách riêng chúng ra.
So we're going to say that the timestamp for our transaction, if it's less than any other transaction that's still running, which, again, if you don't have a timestamp, then it's infinity.
Vậy chúng ta sẽ nói rằng nếu timestamp của giao dịch của ta nhỏ hơn timestamp của bất kỳ giao dịch nào khác vẫn đang chạy, mà, nhắc lại, nếu chưa có timestamp thì nó là vô cùng.
So you're definitely less than them. Then one of the three following conditions must hold in order for you to pass the validation phase and say your transaction is allowed to commit.
Vậy chắc chắn bạn nhỏ hơn chúng. Thì một trong ba điều kiện sau phải thỏa mãn để bạn vượt qua pha xác thực và giao dịch của bạn được phép commit.
So the first one's pretty easy to understand. So say you're T1. T1 wants to commit.
Điều kiện đầu tiên khá dễ hiểu. Giả sử bạn là T1. T1 muốn commit.
And so the first check has to be: if my timestamp is less than the other transaction's timestamp, and again, if it hasn't been assigned one, it's infinity, then if my transaction is going to complete its validation phase before the other transaction has even started, then it's safe for me to go ahead and commit.
Và kiểm tra đầu tiên phải là: nếu timestamp của tôi nhỏ hơn timestamp của giao dịch kia, và nhắc lại, nếu nó chưa được gán thì là vô cùng, thì nếu giao dịch của tôi hoàn tất pha xác thực trước khi giao dịch kia thậm chí bắt đầu, thì tôi có thể an toàn commit.
So T1 starts, makes whatever changes it wants in the read phase, then it hits the validation phase. And T2 hasn't started at all.
Vậy T1 bắt đầu, thực hiện bất kỳ thay đổi nào nó muốn trong pha đọc, rồi đến pha xác thực. Còn T2 hoàn toàn chưa bắt đầu.
So it can't possibly conflict, because T2 hasn't read anything in the database. It just hasn't started. So if I make a bunch of changes, it'll see it.
Nên không thể xung đột, vì T2 chưa đọc gì trong cơ sở dữ liệu. Nó chưa bắt đầu. Nên nếu tôi thực hiện một loạt thay đổi, nó sẽ thấy.
The second transaction will see it when it starts. So this one's pretty obvious. Basically saying it's a serial ordering.
Giao dịch thứ hai sẽ thấy khi nó bắt đầu. Nên trường hợp này khá hiển nhiên. Về cơ bản đó là một thứ tự tuần tự.
I would say also too, for this one, I'm showing two transactions. If you had hundreds of transactions, the write set is empty.
Tôi cũng muốn nói thêm, ở đây tôi chỉ minh họa hai giao dịch. Nếu có hàng trăm giao dịch mà tập ghi rỗng, chúng chưa làm gì cả, thì việc này cũng tầm thường.
They haven't done anything. Then this is trivial to do too as well.
All right, the next more complicated one is if T1 wants to commit, if T1 is going to complete its write phase before T2 starts its write phase, and T1 doesn't modify anything that's been read by T2, then there's no conflict and it's safe to commit T1.
Được rồi, trường hợp phức tạp hơn tiếp theo là nếu T1 muốn commit, nếu T1 hoàn tất pha ghi của nó trước khi T2 bắt đầu pha ghi, và T1 không sửa đổi bất cứ thứ gì mà T2 đã đọc, thì không có xung đột và T1 có thể an toàn commit.
Another way to think about it is, T1 makes a bunch of changes. T2 read a bunch of stuff.
Một cách nghĩ khác là, T1 thực hiện một loạt thay đổi. T2 đọc một loạt dữ liệu.
If I take the intersection of those two sets, if it's the empty set, then I know there's no conflict.
Nếu tôi lấy giao của hai tập đó, và nó là tập rỗng, thì tôi biết không có xung đột.
And what this is doing, this is preventing a transaction in the future from reading an older version of an object that we modified.
Và điều này giúp ngăn một giao dịch trong tương lai đọc phải một phiên bản cũ của đối tượng mà chúng ta đã sửa đổi.
Yes. The question is, why are we not looking at the write set? That's case three. We're building up. So simple one is like, you haven't even started running yet? No conflict.
Vâng. Câu hỏi là, tại sao chúng ta không xem xét tập ghi? Đó là trường hợp ba. Chúng ta đang xây dựng dần. Trường hợp đơn giản là, bạn thậm chí chưa bắt đầu chạy? Không xung đột.
This one is, you have started running yet, but you didn't read anything that I wrote to. So no conflict. Third one, we'll handle the write-write conflict. OK, so T1 starts. We create the workspace.
Trường hợp này là, bạn đã bắt đầu chạy, nhưng bạn không đọc thứ gì mà tôi đã ghi vào. Nên không xung đột. Trường hợp thứ ba, ta sẽ xử lý xung đột ghi-ghi. Được rồi, T1 bắt đầu. Chúng ta tạo không gian làm việc.
It does a read on A, copy that in our workspace, does a write on A. We update that in our workspace. Then now, T2 starts running and it does the read on A.
Nó đọc A, sao chép giá trị đó vào không gian làm việc của nó, rồi ghi lên A. Ta cập nhật giá trị đó trong không gian làm việc. Bây giờ T2 bắt đầu chạy và nó đọc A.
And then now, when T1 wants to go commit, we're going to check the write set of T1 with the read set of T2.
Và khi T1 muốn commit, ta sẽ kiểm tra tập ghi của T1 với tập đọc của T2.
In this case here, we have a conflict, because T2 read the object with timestamp 0.
Trong trường hợp này, ta có xung đột, vì T2 đã đọc đối tượng với timestamp 0.
But now we're trying to write a new version of it at a future timestamp that's going to be greater than 0.
Nhưng giờ ta đang cố ghi một phiên bản mới của nó tại một timestamp trong tương lai, lớn hơn 0.
So if T2 was really being executed in serial ordering, where it would execute after T1 committed, then it would have read whatever the version is. I don't use the word version.
Nên nếu T2 thực sự được thực thi theo thứ tự tuần tự, tức là nó chạy sau khi T1 commit, thì nó sẽ đọc phiên bản nào đang có. Tôi không dùng từ phiên bản.
It would have read the value at the timestamp that T1 was going to install. But it hasn't, right? So therefore, T1 has to abort, even though T2 hasn't touched anything.
Nó sẽ đọc giá trị tại timestamp mà T1 sắp cài đặt. Nhưng nó đã không đọc như vậy, đúng không? Vì thế T1 phải abort, dù T2 chưa đụng đến gì cả.
So it's not a write conflict. But it read something in the past that it shouldn't have seen, because it should be executing in the future.
Nên đây không phải xung đột ghi. Mà là nó đã đọc một thứ trong quá khứ mà lẽ ra không được thấy, vì nó phải được thực thi ở tương lai.
The question is, why not kill T2? T2 didn't do anything wrong. It's your fault, right? Let me say it again.
Câu hỏi là, sao không giết T2? T2 đâu có làm gì sai. Là lỗi của bạn mà, đúng không? Để tôi nói lại.
So his comment is like, T1 did a bunch of stuff. T2 barely has done anything yet. Isn't it better to allow?
Ý của bạn ấy là, T1 đã làm cả đống việc. T2 hầu như chưa làm gì.
Would it be better to kill T1, sorry, T2, instead of rolling back the changes of T1? Would that still be correct? I mean, for serial ordering, you could play that game.
Chẳng phải tốt hơn nếu cho phép giết T1, xin lỗi, T2, thay vì rollback các thay đổi của T1 sao? Như vậy có còn đúng không? Với thứ tự tuần tự thì bạn có thể chơi kiểu đó.
When you start doing parallel ones, then you're like, you and I conflict. Now we need to coordinate who's going to die. Right? It's just easier to kill yourself.
Khi bắt đầu chạy song song, thì sẽ là: bạn và tôi xung đột. Giờ ta cần phối hợp xem ai sẽ chết. Đúng không? Tự giết mình thì dễ hơn.
It's like the latching stuff with the B+tree.
Nó giống chuyện latch với B+tree.
All right, the statement is, in my example here, I said that the order of the transaction has to be one where T1 has a lower timestamp than T2.
Được rồi, phát biểu là, trong ví dụ của tôi ở đây, tôi nói thứ tự của các transaction phải là thứ tự mà T1 có timestamp thấp hơn T2.
And then that's the serial ordering. But in my example here, where my black arrow is, think of the black arrow as like the program counter.
Và đó là thứ tự tuần tự. Nhưng trong ví dụ này, chỗ mũi tên đen, hãy coi mũi tên đen như bộ đếm chương trình.
T2 does not have a timestamp yet. It's infinity. Right? So at this point here, T1 is going to get timestamp 1.
T2 chưa có timestamp. Nó là vô cực. Đúng không? Nên tại điểm này, T1 sẽ nhận timestamp 1.
And 1 is less than infinity. So T1 occurs logically before T2 does, at the moment where I'm pointing at where the black arrow is.
Và 1 nhỏ hơn vô cực. Vậy về mặt logic T1 xảy ra trước T2, tại thời điểm tôi đang chỉ vào chỗ mũi tên đen.
The question is, what's the benefit of using timestamps versus what? Using values?
Câu hỏi là, lợi ích của việc dùng timestamp so với cái gì? So với dùng giá trị?
Yeah, so their statement is, why do I want to, why even bother just looking at these timestamps rather than just comparing the values and seeing that they're not the same?
Vâng, ý bạn ấy là, tại sao tôi phải bận tâm nhìn vào các timestamp này thay vì chỉ so sánh các giá trị và xem chúng có khác nhau không?
Because comparing timestamps is cheap. 264 integers, that's a single instruction. If I have these huge strings, I've got to do diffs on them? No way. Yes?
Vì so sánh timestamp rất rẻ. Số nguyên 64 bit, đó chỉ là một lệnh. Nếu có những chuỗi khổng lồ, tôi phải diff chúng sao? Không đời nào. Vâng, bạn?
Can you what? Sorry? Livelock, in this case?
Bạn có thể gì cơ? Xin lỗi, bạn nói sao? Livelock, trong trường hợp này à?
Oh. Yeah. Yes.
Ồ. Vâng. Đúng vậy.
So their statement, and they are correct, is that in a highly contentious system where there's a lot of conflicts, you may end up just burning a bunch of cycles trying to do a bunch of work on transactions, and then only find out that you're not going to be able to commit until the end.
Vậy nhận định của bạn ấy, và bạn ấy nói đúng, là trong một hệ thống có tranh chấp rất cao, nơi có nhiều xung đột, bạn có thể chỉ đang đốt rất nhiều chu kỳ CPU để thực hiện hàng loạt công việc trên các giao dịch, rồi đến cuối mới phát hiện ra là mình không thể commit được.
So you did a bunch of wasted work. Absolutely, yes. You could do that. So in that case, the pessimistic protocol of two-phase locking would be better.
Thế là bạn đã làm một loạt công việc vô ích. Hoàn toàn đúng, vâng. Có thể xảy ra như vậy. Vậy trong trường hợp đó, giao thức bi quan là khóa hai pha sẽ tốt hơn.
So we've done some research about 10 years ago. We basically tried every single concurrency control protocol at extreme scale, like 10,000 or 1,000 cores.
Cách đây khoảng 10 năm, chúng tôi đã làm một nghiên cứu. Về cơ bản, chúng tôi đã thử mọi giao thức điều khiển đồng thời ở quy mô cực lớn, như 10.000 hay 1.000 lõi.
And in the end, if everyone's trying to update the same key, it's all the same. You get one transaction at a time. It basically becomes a serial ordering.
Và rốt cuộc, nếu mọi người đều cố cập nhật cùng một khóa thì tất cả đều như nhau. Mỗi lần chỉ có một giao dịch chạy. Về cơ bản nó trở thành một thứ tự tuần tự.
So if you have light contention, this would be better than two-phase locking. A little bit more contention, two-phase locking would be better. But then extreme contention, they're all the same.
Nên nếu tranh chấp nhẹ, cách này sẽ tốt hơn khóa hai pha. Tranh chấp nhiều hơn một chút thì khóa hai pha sẽ tốt hơn. Nhưng khi tranh chấp cực cao thì tất cả đều như nhau.
So now there are some academic systems that try to be clever and say, try to measure how much contention you have, and can dynamically switch or adapt what commercial protocol they're using.
Hiện có một số hệ thống học thuật tìm cách khôn khéo hơn, họ nói rằng hãy đo xem mức tranh chấp là bao nhiêu, rồi tự động chuyển đổi hoặc điều chỉnh giao thức mà họ đang dùng.
They switch to OCC, or two-phase locking, based on the workload. No real system implements that, because it's so hard to do one of these.
Họ chuyển giữa OCC và khóa hai pha tùy theo khối lượng công việc. Không hệ thống thực tế nào cài đặt điều đó, vì làm một trong hai thứ này đã rất khó rồi.
Now you've got to do two of them? No way, yeah. No one's going to touch that from an engineering perspective.
Giờ phải làm cả hai ư? Không đời nào, đúng vậy. Về mặt kỹ thuật, sẽ không ai đụng vào chuyện đó.
All right, so again, with forward validation, the basic idea is that we want to make sure that transactions don't miss changes that they should have seen if we were following along in the proper serial ordering.
Được rồi, nhắc lại, với kiểm tra hợp lệ tiến, ý tưởng cơ bản là chúng ta muốn đảm bảo các giao dịch không bỏ lỡ những thay đổi mà lẽ ra chúng phải thấy nếu chúng ta đi theo đúng thứ tự tuần tự.
So T2, when it committed, should have seen the update that T1 did. But it missed it because it read the global database before T1 installed the change in the global database.
Vậy T2, khi commit, lẽ ra phải thấy bản cập nhật mà T1 đã làm. Nhưng nó đã bỏ lỡ vì nó đọc cơ sở dữ liệu toàn cục trước khi T1 cài đặt thay đổi vào cơ sở dữ liệu toàn cục.
Therefore, T1 is not allowed to commit. So an easy fix for this would be just changing the schedule.
Do đó, T1 không được phép commit. Một cách sửa dễ dàng là chỉ cần thay đổi lịch trình.
T1 starts, does a read on A, write on A. That all goes into the private workspace. Then now, T2 is going to start, does the read on A.
T1 bắt đầu, đọc A, ghi A. Tất cả đều nằm trong không gian làm việc riêng. Sau đó T2 bắt đầu, đọc A.
Then it enters the validation phase. So again, at this point here, even though it's the same workload, just the order in which they're doing validation has now changed.
Rồi nó bước vào pha kiểm tra hợp lệ. Vậy nên ở thời điểm này, dù là cùng một khối lượng công việc, chỉ có thứ tự thực hiện kiểm tra hợp lệ là đã thay đổi.
So the same operations, but physically, they're occurring the same way. But logically, the validation for T2 is occurring before the validation for T1.
Các thao tác vẫn như cũ, và về mặt vật lý chúng diễn ra theo cùng một cách. Nhưng về mặt logic, kiểm tra hợp lệ của T2 diễn ra trước kiểm tra hợp lệ của T1.
So T2 checks, have I read anything that has been modified by any other transaction?
Vậy T2 kiểm tra: mình có đọc thứ gì đã bị giao dịch nào khác sửa đổi không?
Again, we're only checking for whether I modified something that somebody else read, not whether I did not read something that somebody else modified. So again, T2 is occurring logically in the past.
Một lần nữa, chúng ta chỉ kiểm tra xem mình có sửa thứ mà người khác đã đọc hay không, chứ không phải mình có không đọc thứ mà người khác đã sửa hay không. Vậy T2 về mặt logic xảy ra ở quá khứ.
So it's allowed to read the older version of A and allowed to commit.
Nên nó được phép đọc phiên bản cũ hơn của A và được phép commit.
Then now, when T1 does its commit, the validation, It's allowed to commit because logically, the update to object A is occurring after T2 had committed.
Rồi bây giờ, khi T1 commit, bước kiểm tra hợp lệ, Nó được phép commit vì về mặt logic, việc cập nhật đối tượng A xảy ra sau khi T2 đã commit.
So physically, the update happened before, but it was in the private workspace that nobody could see.
Vậy về mặt vật lý, bản cập nhật xảy ra trước, nhưng nó nằm trong không gian làm việc riêng mà không ai nhìn thấy được.
But then now, when I go to commit, when I install it, it's OK to happen, it's allowed to happen, because T1, sorry, T2 was in the past and wouldn't have seen my change.
Nhưng bây giờ, khi tôi commit, khi tôi cài đặt nó vào, thì điều đó ổn, được phép xảy ra, vì T1, xin lỗi, T2 nằm ở quá khứ và sẽ không thấy thay đổi của tôi.
The last one is the write-write conflict and the write-read conflict that they were mentioning. So again, it's basically the same logic.
Trường hợp cuối cùng là xung đột ghi-ghi và xung đột ghi-đọc mà các bạn đã nhắc tới. Vậy một lần nữa, về cơ bản logic vẫn như vậy.
Again, we check to see whether the intersection of our write set with the write set of the other transaction and the read set, if those are all empty, then we know that we have not modified anything that they have written to or they have read.
Ta lại kiểm tra xem giao của tập ghi của chúng ta với tập ghi của giao dịch kia và tập đọc của nó, nếu tất cả đều rỗng thì ta biết rằng ta chưa sửa bất cứ thứ gì mà họ đã ghi vào hoặc đã đọc.
So going back here again, say now T1 wants to do a read on A and a write on A. T2 wants to do a read on B and a read on A.
Quay lại ví dụ ở đây, giả sử T1 muốn đọc A và ghi A. T2 muốn đọc B và đọc A.
So in this case here, when T1 goes to commit, we'll give it timestamp 1. We go update the write timestamp for its private workspace.
Trong trường hợp này, khi T1 commit, ta gán cho nó timestamp 1. Ta cập nhật timestamp ghi cho không gian làm việc riêng của nó.
Because T2 has not physically read A yet, there's no conflict, allowing T1 to commit.
Vì T2 chưa thực sự đọc A, nên không có xung đột, cho phép T1 commit.
So there's no conflict between the write set here and the read set of this, because this is read B, and this only wrote to A. So T1 is allowed to commit.
Vậy không có xung đột giữa tập ghi ở đây và tập đọc của giao dịch này, vì giao dịch này đọc B, còn bên kia chỉ ghi vào A. Vậy T1 được phép commit.
Install that change now in the database. Then now, when T2 starts running again and it reads A, it's going to read the newest version of A that was modified by T1.
Giờ cài đặt thay đổi đó vào cơ sở dữ liệu. Sau đó, khi T2 chạy lại và đọc A, nó sẽ đọc phiên bản mới nhất của A do T1 sửa đổi.
And again, this is equivalent to the transactions executing in serial order. So it's given timestamp 2, right? And we didn't do any write, so there's nothing to install.
Và một lần nữa, điều này tương đương với việc các giao dịch thực thi theo thứ tự tuần tự. Nó được gán timestamp 2, đúng không? Và ta không ghi gì cả, nên không có gì để cài đặt.
So we just blow it all away. Make sense?
Vậy ta chỉ việc bỏ hết đi. Hiểu chứ?
So at a high level, again, what forward validation is basically doing is you're checking to see whether your write set conflicts with any other transaction that is still actively running, Even if that transaction had started before you did.
Vậy ở mức tổng quát, forward validation về cơ bản là kiểm tra xem tập ghi của bạn có xung đột với giao dịch nào khác đang chạy hay không, kể cả khi giao dịch đó đã bắt đầu trước bạn.
But if they're still in the read phase, they haven't started the validation phase yet, then logically, they're going to be in the future view, even though physically they started before you did.
Nhưng nếu chúng vẫn đang ở pha đọc, chưa bắt đầu pha validation, thì về mặt logic, chúng sẽ nằm ở góc nhìn tương lai, dù về mặt vật lý chúng bắt đầu trước bạn.
So say again, T1 is the one that wants to commit.
Vậy lại giả sử T1 là giao dịch muốn commit.
So we care about, at this point here in the timeline, the validation scope is at the moment that we committed, going back in time all the way back to any transaction that is still active.
Tại thời điểm này trên dòng thời gian, điều ta quan tâm là phạm vi validation tính từ lúc ta commit, ngược về quá khứ tới tận mọi giao dịch vẫn đang hoạt động.
So you've got to keep around the write set of every transaction. So T3 started physically before T1 did, but we can go back in time and look at what T3 actually read.
Vậy bạn phải giữ lại tập ghi của mọi giao dịch. T3 bắt đầu trước T1 về mặt vật lý, nhưng ta có thể quay ngược thời gian và xem T3 thực sự đã đọc gì.
Backward validation, which is the more common one, this one's easier to implement.
Backward validation, là loại phổ biến hơn, loại này dễ cài đặt hơn.
And there's less interference with other transactions running at the same time as you, because you're not checking the write sets of transactions that are trying to modify their own write sets.
Và ít gây ảnh hưởng hơn tới các giao dịch chạy cùng lúc với bạn. vì bạn không kiểm tra các tập ghi của những giao dịch đang cố sửa đổi các tập ghi của chính chúng.
You're just going back and looking at what are the other transactions that I've committed that were at least active when I started and committed before I committed?
Bạn chỉ quay lại và xem xét những giao dịch khác nào đã commit mà ít nhất đang hoạt động khi tôi bắt đầu và đã commit trước khi tôi commit?
So again, the validation scope for that one, it would be this range here, just for T2.
Vậy một lần nữa, phạm vi xác thực của trường hợp này sẽ là khoảng này ở đây, chỉ cho T2.
Yes? Yes.
Bạn có câu hỏi? Vâng.
Right.
Được.
So their statement is, and they are correct, mostly correct, like, don't I need to make sure that when a transaction goes to validate that, are we talking about the validation or the write phase?
Ý của bạn là, và bạn nói đúng, phần lớn là đúng, kiểu như, chẳng phải tôi cần đảm bảo rằng khi một giao dịch đi xác thực thì chúng ta đang nói về giai đoạn xác thực hay giai đoạn ghi?
Which part? Have I gotten past validation yet?
Phần nào? Tôi đã vượt qua xác thực chưa?
Yes. So if you do serial validation, yes. Simplest way is you stop the world, right?
Rồi. Nếu bạn làm xác thực tuần tự thì đúng vậy. Cách đơn giản nhất là bạn dừng toàn bộ hệ thống, đúng không?
Or you could put hints up and say, I'm in the global database or in a posting table somewhere that says, I'm trying to validate now. Here are the things that I've modified.
Hoặc bạn có thể đưa ra các gợi ý và nói rằng, tôi ở trong cơ sở dữ liệu toàn cục hoặc trong một bảng thông báo nào đó cho biết, tôi đang cố xác thực lúc này. Đây là những thứ tôi đã sửa đổi.
So I'm going to go check to see whether anybody else interferes with me. But anybody else that tries to read this, the thing I'm trying to validate on, wait.
Vì vậy tôi sẽ đi kiểm tra xem có ai khác xung đột với tôi không. Nhưng bất kỳ ai khác cố đọc thứ này, thứ tôi đang xác thực, thì phải chờ.
Their statement isn't correct.
Phát biểu của bạn ấy không chính xác.
Like, there's a little bit of backward validation being done by transactions when they start, because you have to check to see whether this thing is in the process of being committed.
Có một chút xác thực ngược được các giao dịch thực hiện khi chúng bắt đầu, vì bạn phải kiểm tra xem thứ này có đang trong quá trình được commit hay không.
But that's what I'm saying. So if you assume the transactions are fast and the rewrite sets are small, then there's a window, yes.
Nhưng đó là điều tôi đang nói. Nếu bạn giả định các giao dịch nhanh và các tập ghi nhỏ, thì có một khoảng thời gian như vậy, đúng.
But it's going to be a fraction of a millisecond, less than a millisecond. You're just checking things in memory.
Nhưng nó chỉ là một phần nhỏ của mili giây, dưới một mili giây. Bạn chỉ đang kiểm tra các thứ trong bộ nhớ.
But again, if my transaction ran for hours or days, then yeah, that's going to be basically locking the whole set down to be a single thread executing. Absolutely, yes. It's unavoidable.
Nhưng một lần nữa, nếu giao dịch của tôi chạy hàng giờ hoặc hàng ngày, thì đúng, về cơ bản điều đó sẽ khóa toàn bộ tập dữ liệu và chỉ còn một luồng thực thi. Chắc chắn rồi, đúng vậy. Không thể tránh được.
MVCC will handle a little bit of that, because they'll do, basically, they'll store in the tuple itself the metadata about what's being committed or not.
MVCC sẽ xử lý phần nào điều đó, vì về cơ bản chúng sẽ lưu ngay trong tuple siêu dữ liệu về việc nó đã được commit hay chưa.
You still have to check. There's an actual transaction table to keep track of. Like, here's all the transactions that are still running.
Bạn vẫn phải kiểm tra. Có một bảng giao dịch thực sự để theo dõi. Kiểu như, đây là tất cả các giao dịch vẫn đang chạy.
And you've got to go look at them. But you don't have to check.
Và bạn phải đi xem chúng. Nhưng bạn không cần kiểm tra.
Like, I can get information about whether the current version of the object I'm looking at is the one I should be reading directly by looking at the object, but without checking a global thing.
Tức là, tôi có thể biết phiên bản hiện tại của đối tượng mà tôi đang xem có phải là phiên bản tôi nên đọc hay không ngay từ chính đối tượng, mà không cần kiểm tra một cấu trúc toàn cục.
That'll be the next class. Yes. AUDIENCE MEMBER 2: So do you have to do the backward validation?
Đó sẽ là nội dung buổi sau. Bạn hỏi đi. KHÁN GIẢ 2: Vậy bạn có phải thực hiện xác thực ngược không?
Yeah, so the question is, with backward validation, I said you have to check all of the transactions that have committed since I started.
Vâng, câu hỏi là, với xác thực ngược, tôi đã nói bạn phải kiểm tra tất cả các giao dịch đã commit kể từ khi tôi bắt đầu.
Yes. So there would be a transaction table we'll cover next class. There's basically an internal table that says, here's all the transactions that are in some state in my system.
Đúng vậy. Sẽ có một bảng giao dịch, chúng ta sẽ học vào buổi sau. Về cơ bản đó là một bảng nội bộ cho biết, đây là tất cả các giao dịch đang ở một trạng thái nào đó trong hệ thống của tôi.
And they could either be waiting to start, running in my read phase, validation phase, write phase, and then also committed, but not completely gone.
Chúng có thể đang chờ bắt đầu, đang chạy trong pha đọc, pha xác thực, pha ghi, và cũng có thể đã commit nhưng chưa bị xóa hoàn toàn.
Because someone is still depending on a note, maybe depending on to see whether they conflict with them.
Vì vẫn còn giao dịch khác đang phụ thuộc vào một ghi chú, có thể đang dựa vào đó để xem chúng có xung đột với nhau hay không.
Yes. And for validation, once something commits, and we pass the validation step, then we're done with them. Yes. Yes.
Đúng. Còn với xác thực, một khi giao dịch commit và vượt qua bước xác thực, thì chúng ta xong với chúng. Đúng. Đúng.
I think the answer is yes.
Tôi nghĩ câu trả lời là đúng.
So the question is, it'd be very clear when you say check, who's checking and when are they checking? Which is, so.
Vậy câu hỏi là, cần nói rõ khi bạn nói kiểm tra thì ai kiểm tra và kiểm tra khi nào? Tức là, vậy nên.
Yeah, they're correct. So in this step here, why do I need to keep track of the transactions that are around?
Vâng, bạn nói đúng. Vậy ở bước này, tại sao tôi cần theo dõi các giao dịch đang có mặt?
Why do I need to check the object that I wrote to, or read to? Read, you've got to check the reads as well.
Tại sao tôi cần kiểm tra đối tượng mà tôi đã ghi hoặc đã đọc? Đọc thì bạn cũng phải kiểm tra các lần đọc.
So why not check every individual tuple, versus just checking this state table I'm mentioning?
Vậy tại sao không kiểm tra từng tuple riêng lẻ, thay vì chỉ kiểm tra bảng trạng thái mà tôi đang nói?
Because for correctness, what you're proposing is still correct. Whether you check the state table, the transaction state table, or individual tuples, it'll still be correct.
Vì xét về tính đúng đắn, điều bạn đề xuất vẫn đúng. Dù bạn kiểm tra bảng trạng thái, bảng trạng thái giao dịch, hay từng tuple, nó vẫn đúng.
It's way faster to go check a single state table that doesn't have all your information, because that'll be in memory.
Kiểm tra một bảng trạng thái duy nhất nhanh hơn nhiều, bảng đó không chứa toàn bộ thông tin của bạn, vì nó nằm trong bộ nhớ.
Whereas if the tuples that they modified that I read, but I didn't write to, so I read them, and maybe they got swapped out to disk, now I've got to go read them again to see whether someone has modified them since the last time.
Trong khi nếu là các tuple mà họ đã sửa mà tôi có đọc, nhưng tôi không ghi vào, tức là tôi chỉ đọc chúng, và có thể chúng đã bị đẩy ra đĩa, thì giờ tôi phải đọc lại chúng để xem có ai đã sửa chúng kể từ lần trước hay không.
We'll see this in, it sounds like a crazy idea. You're basically trying to say, I've got to read it twice. Some systems will actually do that. We'll cover that in this class.
Chúng ta sẽ thấy điều này, nghe có vẻ là một ý tưởng điên rồ. Về cơ bản bạn đang nói là tôi phải đọc hai lần. Một số hệ thống thực sự làm vậy. Chúng ta sẽ học trong môn này.
The question is, backward validation versus forward validation faster? In the end, I think performance is the same. Engineering-wise, backward is easier. That's why most systems do that.
Câu hỏi là, xác thực lùi hay xác thực tiến thì nhanh hơn? Rốt cuộc tôi nghĩ hiệu năng là như nhau. Về mặt kỹ thuật, xác thực lùi dễ hơn. Đó là lý do hầu hết hệ thống dùng nó.
Because there's less interference with the runtime of other transactions. With backward, I'm just going to see whether things have already committed. They've already done.
Vì ít gây nhiễu hơn đến thời gian chạy của các giao dịch khác. Với xác thực lùi, tôi chỉ xem những giao dịch nào đã commit rồi. Chúng đã xong rồi.
So I'm not really interfering with them, because they're dead. Or they've moved on. And most systems implement the backward one.
Nên tôi không thực sự can thiệp vào chúng, vì chúng đã chết. Hoặc đã đi tiếp. Và hầu hết các hệ thống cài đặt kiểu lùi.
All right, so then this one we covered already, about the serial commits and the parallel commits. Again, it's a bit more complicated. You have to make sure things happen in the same order.
Được rồi, vậy phần này chúng ta đã học rồi, về commit tuần tự và commit song song. Một lần nữa, nó phức tạp hơn một chút. Bạn phải đảm bảo mọi thứ xảy ra theo cùng một thứ tự.
And you require latches on the various data structures you're using to check different things. We already covered a lot of these points.
Và bạn cần latch trên các cấu trúc dữ liệu khác nhau mà bạn dùng để kiểm tra những việc khác nhau. Chúng ta đã đề cập đến khá nhiều điểm này rồi.
So the main takeaway from OCC is that this is going to work really great if the number of conflicts are low. If all the transactions are read-only, then that's the best situation.
Vậy điều rút ra chính về OCC là nó sẽ hoạt động rất tốt nếu số lượng xung đột thấp. Nếu tất cả các giao dịch đều chỉ đọc thì đó là tình huống tốt nhất.
Because who cares whether you and I read the same thing? Because we did. So we can commit right away, right?
Vì ai quan tâm việc em và tôi đọc cùng một thứ chứ? Vì chúng ta đã đọc rồi mà. Nên ta có thể commit ngay, đúng không?
But as I've already said before, if you have high contention, you actually do have a lot of conflicts, then this is going to perform worse than two-phase locking.
Nhưng như tôi đã nói trước đây, nếu có tranh chấp cao, tức là thực sự có rất nhiều xung đột, thì cách này sẽ chạy kém hơn khóa hai pha (two-phase locking).
Because in the case of two-phase locking, if I find out I have a deadlock, I'll find out the moment I try to acquire the lock.
Vì với khóa hai pha, nếu tôi phát hiện có bế tắc, tôi sẽ biết ngay khi cố lấy khóa.
I won't do a bunch of work and then realize that was a mistake and have to throw all the work away.
Tôi sẽ không làm một đống việc rồi mới nhận ra đó là sai lầm và phải vứt bỏ toàn bộ công việc.
I may do a bunch of work and then try to get the last lock I need after doing a million things and then get a deadlock and get killed.
Có thể tôi làm một đống việc rồi mới cố lấy khóa cuối cùng mình cần sau hàng triệu thao tác, rồi gặp bế tắc và bị hủy.
So you can't solve the same problem. But in many cases, because two-phase locking is pessimistic, you can't do things until you get the locks.
Nên bạn không thể giải quyết cùng một vấn đề. Nhưng trong nhiều trường hợp, vì khóa hai pha mang tính bi quan, bạn không thể làm gì cho đến khi có được khóa.
So if something is high contention, you won't get the lock for it, and you don't end up wasting time.
Nên nếu có tranh chấp cao, bạn sẽ không lấy được khóa, và cuối cùng không lãng phí thời gian.
The other thing that we'll see next class, the big problem with OCC is that copying from the private workspace, that sucks.
Một điều khác mà ta sẽ thấy ở buổi sau, vấn đề lớn của OCC là việc sao chép từ không gian làm việc riêng, thật tệ.
That's a mem copy. That's a terrible thing to do. It's always going to be slow.
Đó là một phép mem copy. Làm vậy rất tệ. Lúc nào cũng sẽ chậm.
And in the case of multiversion concurrency control, what we'll see is that you can basically take a diff of things and only copy the things that you actually modified.
Còn với điều khiển đồng thời đa phiên bản, ta sẽ thấy về cơ bản có thể lấy phần khác biệt (diff) và chỉ sao chép những thứ bạn thực sự đã sửa.
And that can be much smaller. If I have 1,000 attributes and I only update one of them, and what I'm showing here today, you have to copy all 1,000 attributes into your private workspace.
Và lượng đó có thể nhỏ hơn nhiều. Nếu tôi có 1.000 thuộc tính và chỉ cập nhật một thuộc tính, thì với những gì tôi trình bày hôm nay, bạn phải sao chép cả 1.000 thuộc tính vào không gian làm việc riêng.
In the case of when we see Delta records in MVCC, I just copy the things that I modified. What's that? The question is, what about non-repeatable reads?
Còn khi ta xem các bản ghi Delta trong MVCC, tôi chỉ sao chép những thứ mình đã sửa. Gì vậy? Câu hỏi là còn non-repeatable read thì sao?
Timestamps will fix that for us next class. Yes. So Postgres is basically going to be doing what I'm describing here today.
Timestamp sẽ giải quyết việc đó cho ta ở buổi sau. Vâng. Postgres về cơ bản sẽ làm điều tôi mô tả hôm nay.
Instead of copying to the private workspace, they're going to copy tuples back into another page in the table.
Thay vì sao chép vào không gian làm việc riêng, họ sẽ sao chép các tuple vào một trang khác trong bảng.
This is where things get muddy. They're doing multiversion concurrency control, which is going to look like MVCC, but they're using two-phase locking to protect things. But also predicate locking for serializability.
Đây là chỗ mọi thứ trở nên rối. Họ dùng điều khiển đồng thời đa phiên bản, trông giống MVCC, nhưng lại dùng khóa hai pha để bảo vệ dữ liệu. Và cả khóa vị từ (predicate locking) để đảm bảo khả tuần tự hóa.
We'll get there in a second. Okay. All right. So any questions about OCC before we jump into more stuff? Because now we're talking about how we handle inserts and deletes.
Lát nữa ta sẽ tới đó. Được rồi. Vậy có câu hỏi nào về OCC trước khi ta sang phần tiếp theo không? Vì giờ ta sẽ bàn về cách xử lý insert và delete.
Because this is where everything we've talked about so far is going to break. We still need it, but we need to make it better.
Vì đây là chỗ mọi thứ ta nói từ đầu đến giờ sẽ bị phá vỡ. Ta vẫn cần chúng, nhưng phải cải tiến chúng.
So again, if it's just updates and reads, that's fine because the set of the objects, the number of objects in our database is not, the tables are not going to change.
Nên một lần nữa, nếu chỉ có update và đọc, thì không sao vì tập các đối tượng, số đối tượng trong cơ sở dữ liệu, các bảng sẽ không thay đổi.
But when we start now having modifications that can affect the results of queries within our transactions, like looking at high-level concepts instead of just reads and writes, then we have to be, then these protocols aren't going to work.
Nhưng khi bây giờ chúng ta có các thao tác sửa đổi có thể ảnh hưởng đến kết quả của các truy vấn trong giao dịch của mình, tức là xét các khái niệm ở mức cao hơn thay vì chỉ đọc và ghi, thì lúc đó các giao thức này sẽ không còn hoạt động được.
So look at two transactions now, where now we're actually going to be doing queries, right? Instead of just doing simple reads and writes.
Vậy bây giờ hãy xem hai giao dịch, trong đó giờ chúng ta thực sự sẽ chạy các truy vấn, đúng không? Thay vì chỉ thực hiện các thao tác đọc và ghi đơn giản.
But again, the data systems, at the end of the day, you're just going to see reads and writes on objects. But SQL queries, it's easier to understand. So we have a table of people.
Nhưng một lần nữa, suy cho cùng, đối với hệ thống dữ liệu, bạn chỉ thấy các thao tác đọc và ghi trên các đối tượng. Nhưng với các truy vấn SQL thì dễ hiểu hơn. Vậy chúng ta có một bảng người dùng.
We have their ID, a name, and a status. And so T1's going to start. It's going to run this aggregation query. It's going to count all the people where the status is paid.
Có ID, tên và trạng thái. Và T1 sẽ bắt đầu. Nó sẽ chạy truy vấn tổng hợp này. Nó sẽ đếm tất cả những người có trạng thái là paid.
Then there's a context switch, right? And it gets a value of 99. Then there's a context switch over to T2.
Sau đó có một lần chuyển ngữ cảnh, đúng không? Và nó nhận được giá trị 99. Rồi có một lần chuyển ngữ cảnh sang T2.
T2's going to insert DJ Cash into the table and set a status to paid. Good job, all right? And then it commits. And again, install our change into the database.
T2 sẽ chèn DJ Cash vào bảng và đặt trạng thái là paid. Tốt lắm, được chưa? Rồi nó commit. Và một lần nữa, thay đổi của chúng ta được ghi vào cơ sở dữ liệu.
Then now, T1's going to run again, run that exact same query, but now the count of the number of people paid is 100.
Sau đó, T1 sẽ chạy lại, chạy đúng truy vấn đó, nhưng bây giờ số người đã paid là 100.
All right? So again, this is an unrepeatable read. But it's not unrepeatable on a single object. It's unrepeatable on a range of objects. All right?
Được chứ? Vậy đây lại là một lần đọc không lặp lại được. Nhưng nó không phải không lặp lại được trên một đối tượng đơn lẻ. Nó không lặp lại được trên một phạm vi các đối tượng. Được chứ?
So two-phase locking and OCC will have this problem. So what is the problem? Well, assume we're doing 2PL for simplicity.
Vậy khóa hai pha và OCC đều sẽ gặp vấn đề này. Vậy vấn đề là gì? Giả sử để đơn giản, chúng ta dùng 2PL.
The problem is that you can't acquire a lock on something that doesn't exist. Right? He wasn't in the database, the table, the time the first query ran.
Vấn đề là bạn không thể lấy khóa trên thứ không tồn tại. Đúng không? Anh ta không có trong cơ sở dữ liệu, trong bảng, vào lúc truy vấn đầu tiên chạy.
So even though it took a share lock on everything, right, again, yes, you can take a share lock on the entire table. Assume it didn't do that.
Nên dù nó đã lấy khóa chia sẻ trên mọi thứ, đúng không, một lần nữa, đúng, bạn có thể lấy khóa chia sẻ trên toàn bộ bảng. Giả sử nó không làm vậy.
It didn't, you know, it couldn't take the lock on his record. Therefore, I was allowed to insert a new record with his information. And then I run the same query.
Nó không thể lấy khóa trên bản ghi của anh ta. Do đó, tôi được phép chèn một bản ghi mới với thông tin của anh ta. Rồi tôi chạy cùng truy vấn đó.
And then now I'm seeing things that weren't there before. Right? And again, if we were running in serial ordering of our transactions, we shouldn't have that phenomenon.
Và bây giờ tôi thấy những thứ mà trước đó không có. Đúng không? Và một lần nữa, nếu chúng ta chạy theo thứ tự tuần tự của các giao dịch, thì không được có hiện tượng đó.
We shouldn't have that problem. So this is what is called a phantom read. Right? Phantom or ghost, you know, apparition, whatever.
Không được có vấn đề đó. Đây gọi là phantom read. Đúng không? Phantom hay ma, bóng ma, sao cũng được.
And the idea that these tuples are magically going to appear and disappear and cause us to get incorrect results in our queries that should not happen if you are running in true serial ordering.
Và ý tưởng rằng các tuple này tự nhiên xuất hiện rồi biến mất và khiến truy vấn của chúng ta cho kết quả sai thì không được xảy ra nếu bạn chạy theo thứ tự tuần tự thực sự.
Right? So range scan is the most obvious way to think about this. Something, I read a range once. I don't see it. There's no value in there.
Đúng không? Quét phạm vi là cách dễ hình dung nhất. Tôi đọc một phạm vi một lần. Tôi không thấy gì. Không có giá trị nào trong đó.
Then I read it again. And now there's a value in there that I didn't see before. Or the value that I saw before now has been deleted. Right?
Rồi tôi đọc lại. Và bây giờ có một giá trị mà trước đó tôi không thấy. Hoặc giá trị tôi thấy trước đó giờ đã bị xóa. Đúng không?
Question, how can another transaction delete it if you hold a share lock on it?
Câu hỏi: làm sao giao dịch khác xóa được nếu bạn đang giữ khóa chia sẻ trên nó?
Depending on how you're defining the ranges. Keep it simple. Yes. Let's assume that someone inserted something. But the idea is the same. Right?
Tùy cách bạn định nghĩa các phạm vi. Cứ giữ cho đơn giản. Vâng. Giả sử có ai đó chèn một thứ gì đó. Nhưng ý tưởng thì vẫn như vậy. Đúng không?
Or, again, for two-phase locking, that wouldn't occur, but OCC, that could still happen. All right. So how can we fix this problem? Yes, question.
Hoặc, một lần nữa, với khóa hai pha, điều đó sẽ không xảy ra, nhưng với OCC thì vẫn có thể xảy ra. Được rồi. Vậy làm sao để khắc phục vấn đề này? Vâng, em hỏi đi.
Their statement is, this phantom problem is because, within one transaction, I'm not seeing the same results.
Ý của bạn là, vấn đề phantom này xảy ra vì, trong cùng một giao dịch, tôi không thấy cùng một kết quả.
Yes. So if I run and I get 99, and then you run and you get 100, that's okay. Because, again, that insert should have happened in between my query and your query.
Vâng. Nếu tôi chạy và nhận được 99, rồi bạn chạy và nhận được 100, thì vẫn ổn. Bởi vì, một lần nữa, lệnh insert đó lẽ ra đã xảy ra giữa truy vấn của tôi và truy vấn của bạn.
Right? And that's equivalent to a serial ordering. It's like, within one transaction, are things disappearing? Okay. So how can we solve this? There's four basic categories of approaches. Right?
Đúng không? Và điều đó tương đương với một thứ tự tuần tự. Vấn đề là, trong một giao dịch, có thứ gì đó biến mất không? Được rồi. Vậy làm sao giải quyết? Có bốn nhóm cách tiếp cận cơ bản. Đúng không?
So the most obvious thing is just lock everything. Lock the table, lock the database, lock the pages, whatever. And then that way you can't insert anything into a range that I've read.
Cách hiển nhiên nhất là khóa tất cả mọi thứ. Khóa bảng, khóa cơ sở dữ liệu, khóa các trang, gì cũng được. Như vậy bạn sẽ không thể chèn gì vào một phạm vi mà tôi đã đọc.
Right? If I lock the entire table, you can't do any modifications. Problem solved.
Đúng không? Nếu tôi khóa toàn bộ bảng, bạn không thể sửa đổi gì cả. Vấn đề được giải quyết.
Again, if I have a billion tuples in my table, and I'm only reading small ranges, that's probably not a good idea, because now I'm locking more things than I actually need.
Nhưng nếu bảng của tôi có một tỉ tuple, mà tôi chỉ đọc những phạm vi nhỏ, thì đó có lẽ không phải ý hay, vì lúc này tôi khóa nhiều thứ hơn mức thực sự cần.
Another approach is what sort of we'll talk about here, is you just rerun your scan again when you commit and see whether you see things that you shouldn't have seen, or things have changed.
Một cách khác mà ta sẽ bàn ở đây, là chạy lại lần quét của bạn khi commit và xem bạn có thấy những thứ lẽ ra không được thấy hay không, hoặc dữ liệu có thay đổi hay không.
How would you know? You gotta keep track of your read set.
Làm sao biết được? Bạn phải theo dõi tập đọc của mình.
They said that that's potentially billions of rows. Yes. We'll come to that in a second. You can do the reverse.
Bạn ấy nói rằng đó có thể là hàng tỉ hàng. Vâng. Chúng ta sẽ nói tới ngay. Bạn cũng có thể làm ngược lại.
The question is, do I keep track of all the billion rows again? Yes. Or some kind of fingerprint of it or something like that. But again, this is what I'm saying.
Câu hỏi là, tôi có phải theo dõi cả một tỉ hàng không? Vâng. Hoặc một dạng dấu vân tay của nó, đại loại như vậy. Nhưng một lần nữa, đây là điều tôi muốn nói.
If you assume your transactions are small, most transactions are, then this is okay. If I go read your account record once and then read it again, no big deal.
Nếu bạn giả định các giao dịch nhỏ, mà hầu hết đều nhỏ, thì cách này ổn. Nếu tôi đọc bản ghi tài khoản của bạn một lần rồi đọc lại, không vấn đề gì.
Or I read all your orders, say you bought 10 things on Amazon, you have 10 orders on Amazon, read 10 orders, no big deal.
Hoặc tôi đọc tất cả đơn hàng của bạn, giả sử bạn mua 10 món trên Amazon, bạn có 10 đơn hàng trên Amazon, đọc 10 đơn hàng, không vấn đề gì.
It's not for free. But you have to do it. What's that? Not that expensive, yes. Again, there's no free lunch. And then predicate locking and index locking, we'll cover that in more detail.
Nó không miễn phí. Nhưng bạn phải làm. Sao cơ? Không đắt lắm, vâng. Một lần nữa, không có bữa trưa miễn phí. Còn khóa vị từ và khóa chỉ mục, ta sẽ nói chi tiết hơn.
So again, this is what IBM figured out in the 1970s, 1976.
Đây là điều IBM đã tìm ra vào thập niên 1970, năm 1976.
They figured out that the ordering, they're trying to figure out how to do this efficiently, at least in the case of predicate locking, is going to be an NP-complete problem or NP-hard.
Họ nhận ra rằng thứ tự, khi họ cố tìm cách làm việc này hiệu quả, ít nhất trong trường hợp khóa vị từ, sẽ là một bài toán NP-complete hoặc NP-hard.
Re-executing scans, that's easy to do if everything's in memory, everything's fast. But again, larger things are problematic. So the most common of these is going to be the bottom one, index locking.
Chạy lại các lần quét thì dễ làm nếu mọi thứ nằm trong bộ nhớ và nhanh. Nhưng với dữ liệu lớn hơn thì có vấn đề. Vì vậy cách phổ biến nhất sẽ là cách cuối cùng, khóa chỉ mục.
We'll see that in a second. The two middle ones are kind of pretty rare. For re-execute scans, you normally see this in memory queries. And then the one at the top, lock everything.
Lát nữa ta sẽ xem. Hai cách ở giữa khá hiếm. Với chạy lại lần quét, bạn thường thấy nó trong các truy vấn trong bộ nhớ. Còn cách ở trên cùng, khóa tất cả.
Again, it's, some systems will do it if you care about serializability. All right, so let's move on to talk about re-execute scans.
Một số hệ thống sẽ làm vậy nếu bạn quan tâm đến tính khả tuần tự. Được rồi, ta chuyển sang nói về chạy lại lần quét.
So again, you basically keep track of all the where clauses for any query you run.
Vậy nên, về cơ bản bạn theo dõi tất cả các mệnh đề where của bất kỳ truy vấn nào bạn chạy.
And then you, when a transaction commits, you just check to see whether the output of those where clauses match what you saw when you ran it the first time.
Và sau đó, khi một giao dịch commit, bạn chỉ cần kiểm tra xem kết quả của các mệnh đề where đó có khớp với những gì bạn thấy ở lần chạy đầu tiên hay không.
So you don't need to, like, if it's a, say, a select query that computes that aggregation, I don't need to keep track of the aggregation result or whatever computation I'm doing or the joins.
Nên bạn không cần, ví dụ như nếu đó là, một truy vấn select tính toán phép tổng hợp, thì tôi không cần theo dõi kết quả tổng hợp hay bất kỳ phép tính nào tôi đang làm, hay các phép join.
I just need to know, for all the base tables, what data did I see? Right? So I just run it again and see whether I get the same result. So Hekaton does this.
Tôi chỉ cần biết, với tất cả các bảng cơ sở, tôi đã thấy dữ liệu nào? Đúng không? Nên tôi chỉ chạy lại và xem có nhận được cùng kết quả không. Hekaton làm như vậy.
DynamoDB and Fauna kind of do the opposite, reverse it, meaning they run your queries first, but don't make any changes to the database. They call them, like, reconnaissance transactions.
DynamoDB và Fauna thì làm ngược lại, đảo ngược nó, nghĩa là họ chạy các truy vấn của bạn trước, nhưng không thực hiện bất kỳ thay đổi nào lên cơ sở dữ liệu. Họ gọi đó là các giao dịch trinh sát (reconnaissance transactions).
They run your queries and see what it's going to do. Keep track of your scan sets.
Họ chạy các truy vấn của bạn để xem nó sẽ làm gì. Theo dõi các tập quét (scan set) của bạn.
Then you go to commit, and then you actually run the queries for real and see whether you match what you did when you ran it the first time.
Sau đó bạn tiến hành commit, và lúc đó bạn mới chạy các truy vấn thật sự và xem có khớp với những gì bạn đã làm ở lần chạy đầu tiên không.
If yes, then you know you got things in the right order.
Nếu có, thì bạn biết mọi thứ đã đúng thứ tự.
So you're still doing the, whatever, the timestamp ordering or the two-phase locking part when the fake transactions run first, or the fake queries run first.
Vậy bạn vẫn đang thực hiện phần sắp xếp theo timestamp hoặc khóa hai pha khi các giao dịch giả chạy trước, hay các truy vấn giả chạy trước.
And then now that I know that I got the right ordering, if I run them again, if I get the same result, since I scheduled you in a serializable way the first time, and when I run it for real and I get the same result, then I know it's the same and you're safe to commit.
Và giờ khi tôi biết mình đã có thứ tự đúng, nếu tôi chạy lại và nhận được cùng kết quả, vì lần đầu tôi đã lập lịch cho bạn theo cách khả tuần tự, và khi chạy thật tôi nhận được cùng kết quả, thì tôi biết nó giống nhau và bạn có thể commit an toàn.
In the back, yes.
Bạn ở phía sau, mời.
So your setup is, the first transaction is, you said long in time, or long in, like, they're updating a billion things?
Vậy tình huống của bạn là, giao dịch đầu tiên, bạn nói là dài về thời gian, hay dài theo kiểu, chẳng hạn, nó cập nhật một tỉ thứ?
Okay, you're updating a billion things, and then you have another transaction that's really short.
Được, nó cập nhật một tỉ thứ, và rồi bạn có một giao dịch khác rất ngắn.
Yes, yes, yes, yes.
Vâng, vâng, vâng, vâng.
All right, so there's scenarios. I have transaction T1, it updates a billion things.
Được rồi, vậy có các kịch bản. Tôi có giao dịch T1, nó cập nhật một tỉ thứ.
Transaction T2, while T1 is running, comes in, reads something that T1 modified, and then it goes ahead and goes to commit. Right, that's your setup.
Giao dịch T2, trong khi T1 đang chạy, đi vào, đọc một thứ mà T1 đã sửa, rồi cứ thế tiến hành commit. Đúng, đó là tình huống của bạn.
If you care about serial ordering or serializability, T2 is not allowed to commit until T1 commits, because it did a dirty read. It read something that T1 modified, and T1 has not committed yet.
Nếu bạn quan tâm đến thứ tự tuần tự hay tính khả tuần tự, thì T2 không được phép commit cho đến khi T1 commit, vì nó đã thực hiện một lần đọc bẩn. Nó đã đọc thứ mà T1 sửa, và T1 thì chưa commit.
So if you care about serializability, then you have to wait.
Vậy nếu bạn quan tâm đến tính khả tuần tự, thì bạn phải chờ.
If you don't, we'll cover that in a second, then you commit, and then you, not you, well, you as the application programmer, deal with whatever the consequence of that, right?
Nếu không, lát nữa chúng ta sẽ nói đến, thì bạn commit, và rồi bạn, không phải bạn, à, bạn với tư cách là lập trình viên ứng dụng, phải xử lý mọi hậu quả của việc đó, đúng không?
Database doesn't, database did what you told it to do.
Cơ sở dữ liệu không, cơ sở dữ liệu đã làm đúng những gì bạn bảo nó làm.
All right, predicate locking.
Được rồi, khóa theo vị từ (predicate locking).
The idea, again, this is what they sort of were proposed to do in IBM in the 1970s and realized it was super hard to do on the hardware they had at the time, and also doing this exactly is NP-hard.
Ý tưởng là, đây là thứ mà người ta đã đề xuất làm ở IBM vào những năm 1970 và nhận ra rằng việc này cực kỳ khó thực hiện trên phần cứng thời đó, và làm chính xác thì còn là bài toán NP-hard.
The basic idea, the way I think about this, is that you're going to maintain this high-dimensional space of all the possible locks you could have in your database based on predicates.
Ý tưởng cơ bản, cách tôi hình dung về nó, là bạn sẽ duy trì một không gian nhiều chiều gồm tất cả các khóa có thể có trong cơ sở dữ liệu, dựa trên các vị từ.
So not locks on individual tuples, like we did in two-phase locking, where like there's a lock table and I acquire a lock on, you know, record one, two, three, right?
Vậy đây không phải khóa trên từng tuple riêng lẻ như trong two-phase locking, nơi có một bảng khóa và tôi lấy khóa trên bản ghi một, hai, ba, đúng không?
Think of it, it's a more abstract concept, and then I'm going to check to see whether I have any of these polygons or these high-dimensional objects that are defined based on my predicates.
Hãy nghĩ nó là một khái niệm trừu tượng hơn, rồi tôi sẽ kiểm tra xem có đa giác nào trong số này không, hay các đối tượng nhiều chiều này, được xác định dựa trên các vị từ của tôi.
If they intersect, then I know I have a conflict in those transactions, and then I just do two-phase locking or whatever to figure out the order in which things should occur, whether you have to wait or kill yourself or whether I have deadlocks.
Nếu chúng giao nhau thì tôi biết các transaction đó có xung đột, và khi đó tôi chỉ việc dùng two-phase locking hoặc cách nào đó để xác định thứ tự các thao tác diễn ra, xem bạn phải chờ, hay tự hủy, hay có xảy ra bế tắc.
So again, this is obviously very difficult to do if you have a lot of predicates on a lot of tables, and so you can approximate this using precision locking, where you just look at the rewrite sets and you figure out whether there's overlap, so you've got to keep those things around.
Vậy nên, rõ ràng việc này rất khó làm nếu bạn có nhiều vị từ trên nhiều bảng, và do đó có thể xấp xỉ bằng precision locking, trong đó bạn chỉ xem các tập ghi lại và xác định xem có chồng lấn hay không, nên bạn phải giữ các tập đó lại.
In the case of Postgres and a bunch of other systems, they're going to approximate this using index locking, which we'll talk about in a second.
Với Postgres và một loạt hệ thống khác, họ xấp xỉ việc này bằng index locking, mà lát nữa chúng ta sẽ nói tới.
So no one does this exactly, because again it's kind of too hard, too difficult to do, but again, you can kind of get away with it using, well, you can get away with this precision locking stuff, which is basically you look at the rewrite sets and you see whether there's conflict, therefore you know the predicates overlap.
Vậy không ai làm điều này một cách chính xác, vì như đã nói nó quá khó để thực hiện, nhưng bạn vẫn có thể xoay xở bằng cách, ừ, bạn có thể dùng precision locking này, về cơ bản là bạn xem các tập ghi lại và xem có xung đột hay không, từ đó biết các vị từ có chồng lấn.
So the only system that does this with precision locking is these German systems, and they're all written by one guy, right?
Hệ thống duy nhất dùng precision locking là các hệ thống của Đức này, và tất cả đều do một người viết, đúng không?
So CWB, Umbra, and Hyper, it's all written by this one guy in Munich, and the precision locking paper is like from 1983.
Đó là CWB, Umbra và Hyper, tất cả đều do một người ở Munich viết, còn bài báo về precision locking là từ năm 1983.
It had like 30 citations when the German guy found it, and it's like, this solves exactly my problem, right? And he implements exactly what they're doing here, and it guarantees serializability.
Nó chỉ có khoảng 30 lượt trích dẫn khi anh chàng người Đức tìm ra, và anh ấy nghĩ: cái này giải quyết đúng vấn đề của mình, đúng không? Và anh ấy cài đặt chính xác những gì họ mô tả ở đây, và nó đảm bảo tính khả tuần tự.
All right, but the original proposal of predicate locking looked like this.
Được rồi, nhưng đề xuất ban đầu của predicate locking trông như thế này.
So I have my, my predicates and my two queries, and I just extract out the where clause, and I'm going to map that to some region in this high dimensional space.
Tôi có các vị từ và hai truy vấn của mình, tôi chỉ trích ra mệnh đề where, và ánh xạ nó tới một vùng nào đó trong không gian nhiều chiều này.
So simplicity, I assume that there's only two dimensions. There's the status and the person, right?
Cho đơn giản, tôi giả sử chỉ có hai chiều. Đó là trạng thái và người, đúng không?
So then now for this other one here, when I insert this query, that's the same as acquiring a lock on the name DJ Cash and the status is paid.
Giờ với truy vấn còn lại ở đây, khi tôi chèn truy vấn này, nó tương đương với việc lấy khóa trên tên DJ Cash và trạng thái là paid.
And then if I know that the two regions overlap, I know that there's a conflict in their predicates, and therefore I have to decide now, my protocol, who's allowed to acquire the lock and who's allowed to commit and so forth.
Và nếu tôi biết hai vùng này giao nhau, thì tôi biết các vị từ của chúng có xung đột, và do đó bây giờ tôi phải quyết định, giao thức của tôi, ai được phép lấy khóa, ai được phép commit, v.v.
Again, for two dimensions, it's easy, but think of like a table of 10,000 columns. This becomes unmaintainable. Yes.
Một lần nữa, với hai chiều thì dễ, nhưng hãy thử nghĩ đến một bảng có 10.000 cột. Việc này trở nên không thể duy trì được. Vâng, mời bạn.
Decision locking, I mean, I teach this in advanced class down here. The basic gist of it is you look at the rewrite sets of the transactions.
Về khóa theo quyết định, tôi có dạy phần này ở lớp nâng cao dưới này. Ý chính cơ bản là bạn xem xét các tập ghi lại (rewrite set) của các giao dịch.
Yeah, the exact rows, and you just check to see whether like their predicates, whether you're, you're basically running the, how do you say this, you're taking the where clause of the other query and you're seeing whether it matches any tuples in the rewrite set of the other transactions.
Vâng, chính xác các hàng, và bạn chỉ kiểm tra xem các vị từ của chúng có có phải về cơ bản bạn đang chạy, nói thế nào nhỉ, bạn lấy mệnh đề where của truy vấn kia và xem nó có khớp với bộ giá trị (tuple) nào không trong tập ghi lại của các giao dịch khác.
You'll see something, you'll see a watered down version of this in project four. All right, but think of like the rewrite set is just another table.
Các bạn sẽ thấy một phiên bản đơn giản hóa của việc này trong project 4. Được rồi, hãy nghĩ tập ghi lại chỉ là một bảng khác.
So I just run my query that I'm going to run in my transaction on that rewrite set and see whether it matches.
Vậy tôi chạy truy vấn mà tôi sắp chạy trong giao dịch của mình trên tập ghi lại đó và xem nó có khớp hay không.
All right, so most systems are going to do predicate locking, and you can kind of think of this as a special case of index locking, where we're going to use the indexes themselves as the mechanism or the data structure to keep track of what locks are being held by transactions.
Được rồi, hầu hết các hệ thống sẽ dùng khóa vị từ (predicate locking), và bạn có thể xem đây là một trường hợp đặc biệt của khóa chỉ mục (index locking), trong đó chúng ta dùng chính các chỉ mục làm cơ chế hay cấu trúc dữ liệu để theo dõi những khóa nào đang được các giao dịch giữ.
And this will cover the values that don't exist yet and allows me to lock them.
Cách này bao phủ cả các giá trị chưa tồn tại và cho phép tôi khóa chúng.
Because again, I don't want to have my, in my, if I'm doing two-phase locking in my lock table, I don't want to have a, you know, entries for ranges or things that don't exist, because that's going to become difficult to maintain and actually build.
Bởi vì, một lần nữa, tôi không muốn trong bảng khóa của mình, nếu tôi đang dùng khóa hai pha, tôi không muốn có các mục cho những khoảng giá trị hay những thứ không tồn tại, vì như vậy sẽ rất khó duy trì và khó xây dựng thực sự.
So I'm going to use indexes themselves, because that's, they're already going to have data in an ordered manner, and I can use them as the way to figure out how to lock things.
Nên tôi sẽ dùng chính các chỉ mục, vì chúng vốn đã chứa dữ liệu theo thứ tự, và tôi có thể dùng chúng để xác định cách khóa các thứ.
So there are going to be four different approaches, and we're going to build up and use some of the basic ones like the key value locks, but then we can combine all these together and include the hierarchical locking that we talked about last time to see how we actually implement this in a real system.
Có bốn cách tiếp cận khác nhau, và chúng ta sẽ xây dựng dần lên và dùng một số cách cơ bản như khóa giá trị khóa (key value lock), nhưng sau đó chúng ta có thể kết hợp tất cả chúng lại và bao gồm cả khóa phân cấp mà chúng ta đã nói lần trước để xem thực sự triển khai việc này trong một hệ thống thực tế như thế nào.
Yes. The question is, if you have no index on the keys, do you have to fall back to scans? How do you what? Question, how would you lock this? You'd lock the entire table.
Vâng. Câu hỏi là, nếu không có chỉ mục trên các khóa, thì có phải quay về quét bảng không? Bạn hỏi sao ạ? Câu hỏi là làm sao khóa nó? Bạn sẽ khóa toàn bộ bảng.
Yeah. Question is, how do you lock something that doesn't exist? Gap locks. Two slides. All right. So the most basic one is a key value lock in your index.
Vâng. Câu hỏi là làm sao khóa thứ không tồn tại? Khóa khoảng trống (gap lock). Hai slide nữa. Được rồi. Cách cơ bản nhất là khóa giá trị khóa trong chỉ mục của bạn.
Right. This is where you have a thing that you know it exists. Right. And then I can just, I can just take a lock on it. Right.
Đúng không. Đây là khi bạn có một thứ mà bạn biết là nó tồn tại. Và khi đó tôi có thể lấy khóa trên nó. Đúng không.
And you can, you don't store this in the actual B+tree node itself.
Và bạn không lưu khóa này trong chính nút B+tree.
You're going to store this in a lock manager, but now you're keeping track of, like, within this value, within this index, this, this transaction holds the lock for it.
Bạn sẽ lưu nó trong bộ quản lý khóa (lock manager), nhưng giờ bạn theo dõi rằng, trong giá trị này, trong chỉ mục này, giao dịch này đang giữ khóa của nó.
Right. For an exact match. For things like infinity, right, the upper bounds, the lower bounds, right, you can just have virtual keys for those, but it works basically the same way.
Đúng không. Với một khớp chính xác. Với những thứ như vô cực, tức là cận trên, cận dưới, bạn có thể dùng các khóa ảo cho chúng, nhưng về cơ bản hoạt động giống nhau.
Right. So then now, to handle the case he was, they were asking about, is how do I lock things that don't exist?
Đúng không. Vậy bây giờ, để xử lý trường hợp mà bạn ấy vừa hỏi, họ đang hỏi là: làm sao khóa những thứ không tồn tại?
Well, again, say that I have now a transaction that wants to insert value 15. Right. Between 14 and 16. 15 doesn't exist yet.
Ví dụ, giờ tôi có một transaction muốn chèn giá trị 15. Đúng không. Nằm giữa 14 và 16. 15 thì chưa tồn tại.
So I'm just going to keep track of all the gaps between the keys that I do have in my, my index.
Vậy tôi sẽ theo dõi tất cả các khoảng trống giữa các khóa mà tôi đang có trong index của mình.
And then now I can take keys on the gaps. Sorry, take locks on the gaps.
Và giờ tôi có thể lấy khóa trên các khoảng trống. Xin lỗi, lấy lock trên các khoảng trống.
So this is going to say I'm going to have a, a lock on the, the gap between 14 and 16 exclusive.
Như vậy nghĩa là tôi sẽ có một lock trên khoảng trống giữa 14 và 16, không bao gồm hai đầu.
So again, these are all integers, but say someone inserts, like, 15.1, 15.2, 15.3. All of that would be covered by this single gap lock. Right. If it's integers, it's only 15.
Ở đây đều là số nguyên, nhưng giả sử có người chèn 15.1, 15.2, 15.3. Tất cả những giá trị đó sẽ được bao phủ bởi một gap lock duy nhất này. Đúng không. Nếu là số nguyên thì chỉ có 15.
Or any possible value, think of strings. I have key AA and key ABC. I need a gap between the two of them. And the gap lock would handle that.
Hoặc bất kỳ giá trị nào có thể, hãy nghĩ đến chuỗi. Tôi có khóa AA và khóa ABC. Tôi cần một khoảng trống giữa hai khóa đó. Và gap lock sẽ xử lý việc này.
But then now, I don't want to have to keep track of a, or keep, maintain a lock for every single key value pair that are a key that I want to maintain and every single possible gaps that I may have within a range of values.
Nhưng giờ tôi không muốn phải theo dõi hay duy trì một lock cho từng cặp khóa-giá trị, tức từng khóa mà tôi muốn duy trì, và cho từng khoảng trống có thể có trong một dải giá trị.
So now I start combining them together and take key range locks. So my lock tables, I'll basically keep track of, like, you know, here's the starting point, 14 inclusive.
Vì vậy tôi bắt đầu kết hợp chúng lại và dùng key range lock. Trong lock table, về cơ bản tôi sẽ theo dõi, ví dụ, đây là điểm bắt đầu, 14 bao gồm.
And then the key range lock goes up to 16 exclusive.
Và key range lock kéo dài đến 16, không bao gồm.
So now if anybody wants to insert something in this range, they gotta go acquire the key range lock for this that covers the gap.
Như vậy giờ nếu ai muốn chèn gì đó vào dải này, họ phải đi lấy key range lock bao phủ khoảng trống đó.
And it would tell me whether I'm allowed to put something there.
Và nó sẽ cho tôi biết liệu họ có được phép đặt thứ gì vào đó không.
So I'm going back to that query I had at the beginning where I'm doing that scan to try to find people within the status. Right.
Giờ quay lại truy vấn tôi có lúc đầu, khi tôi thực hiện phép quét để tìm những người có trạng thái nhất định. Đúng không.
I could take the key range lock from that status equals, you know, paid up until whatever the next key is, including the gap.
Tôi có thể lấy key range lock từ status bằng paid cho đến khóa kế tiếp, bao gồm cả khoảng trống.
And that'll prevent somebody, you know, another transaction, from inserting a value in that range. Right. You can go in other directions. Typically, in your system, you only go one direction.
Và điều đó sẽ ngăn một transaction khác chèn một giá trị vào dải đó. Đúng không. Bạn có thể đi theo các hướng khác. Thông thường, trong hệ thống của bạn, chỉ đi một hướng.
You either go to the current key and going backwards in the ordering, or the current key and going forwards. But you only do one. All right.
Hoặc là khóa hiện tại và đi ngược theo thứ tự, hoặc khóa hiện tại và đi xuôi. Nhưng chỉ làm một hướng. Được rồi.
So now we can put this all together and start doing hierarchical locking that we had before.
Giờ chúng ta có thể ghép tất cả lại và bắt đầu thực hiện hierarchical locking như trước đây.
So again, this is kind of different than we talked about before, because I was taking locks on tuples and tables and so forth.
Điều này hơi khác với những gì ta đã nói trước đó, vì khi đó tôi lấy lock trên tuple, bảng, v.v.
But now I'm taking locks on actual values and actually within the page itself in my B+tree. Right. So I can take an intention-exclusive lock on this sort of range of values within the page.
Nhưng giờ tôi lấy lock trên các giá trị thực sự và ngay bên trong chính page của B+tree. Đúng không. Vậy tôi có thể lấy một intention-exclusive lock trên dải giá trị này bên trong page.
Right. And then inside that, now I can take an exclusive lock on the key range from 14 inclusive to 16 exclusive within the gap.
Đúng không. Và bên trong đó, giờ tôi có thể lấy một exclusive lock trên key range từ 14 bao gồm đến 16 không bao gồm, trong khoảng trống.
But then also, another transaction can take an exclusive lock on another key-value pair or key range by taking an intention-exclusive lock, which is compatible with the intention-exclusive lock that somebody else has maintained.
Nhưng bên cạnh đó, một giao dịch khác có thể lấy khóa độc quyền trên một cặp khóa-giá trị khác hoặc một khoảng khóa khác bằng cách lấy khóa ý định độc quyền (intention-exclusive), loại khóa này tương thích với khóa ý định độc quyền mà một giao dịch khác đang giữ.
Now I can lock 12. So two transactions can come in. Somebody could be updating 12 and somebody could be updating 14 up to the gap. And this will prevent phantoms for me.
Giờ tôi có thể khóa 12. Vậy là hai giao dịch có thể cùng vào. Một giao dịch có thể đang cập nhật 12 và một giao dịch khác đang cập nhật 14 cho đến hết khoảng trống. Và điều này sẽ giúp tôi ngăn chặn phantom.
Because again, I'm trying to avoid people inserting something that, you know, didn't exist before, because this allows me to take locks on things that I didn't know about before.
Bởi vì, một lần nữa, tôi đang cố tránh việc có người chèn vào thứ gì đó mà, bạn biết đấy, trước đó chưa tồn tại, vì cách này cho phép tôi khóa những thứ mà trước đó tôi không biết đến.
Okay. Yes.
Được rồi. Mời bạn.
Question is, what does a gap lock look like? What do you mean? Like, question is, how would you implement it? So you just keep track of, like, here.
Câu hỏi là gap lock trông như thế nào? Ý bạn là sao? Ý là, câu hỏi là bạn sẽ cài đặt nó như thế nào? Thì bạn chỉ cần theo dõi, kiểu như, ở đây.
You would keep track of, like, the range in which this is being locked. So 14 exclusive is 16 exclusive. So in the lock table you would keep track of, like, that interval.
Bạn sẽ theo dõi khoảng giá trị đang bị khóa. Tức là từ 14 đến 16, không bao gồm 16. Vậy trong bảng khóa, bạn sẽ lưu khoảng đó.
And so therefore, if anybody is trying to read something, they'd be scanning along the leaf nodes and they're, say they're finding values.
Và do đó, nếu ai đó muốn đọc thứ gì, họ sẽ quét dọc theo các nút lá và, giả sử, tìm thấy các giá trị.
Say you don't know the values that are, the keys that are in the range before they start.
Giả sử bạn không biết các giá trị, các khóa nằm trong khoảng đó trước khi bắt đầu.
Before you go read something, you have to go check to see whether you can acquire the lock to read something. So think of, like, the B+tree implemented in project 2.
Trước khi đọc bất cứ thứ gì, bạn phải kiểm tra xem mình có thể lấy được khóa để đọc hay không. Hãy nghĩ đến B+tree mà các bạn cài đặt trong project 2.
You got to go check the lock manager as you're scanning along the leaf nodes. Yes.
Bạn phải kiểm tra lock manager khi quét dọc theo các nút lá. Mời bạn.
So if you come in and you intend to run inside a gap, do you always lock everything until the end of the page before you read the file?
Vậy nếu bạn đến và định chèn vào bên trong một khoảng trống, bạn có luôn khóa mọi thứ đến cuối trang trước khi đọc tệp không?
The question is, if I intend to insert something into this gap, do I lock from the gap to the end of the page?
Câu hỏi là, nếu tôi định chèn một thứ gì đó vào khoảng trống này, tôi có khóa từ khoảng trống đến cuối trang không?
You would know, okay, at this point you're inside the page, so you know what the values are that are here.
Bạn sẽ biết, được rồi, đến thời điểm này bạn đang ở bên trong trang, nên bạn biết các giá trị ở đây là gì.
So you're, you know, you have it in some kind of read mode, you're reading things. That's okay. So then I'm going to go check the lock manager.
Tức là bạn đang ở một chế độ đọc nào đó, bạn đang đọc các thứ. Không sao. Sau đó tôi sẽ kiểm tra lock manager.
So I know what I'm trying to insert or delete, right? So you go check the lock manager, give me the lock for the thing I'm trying to modify.
Vì tôi biết mình đang định chèn hoặc xóa cái gì, đúng không? Vậy bạn kiểm tra lock manager, xin khóa cho thứ mà tôi đang định sửa đổi.
And it may be to the end, it may not be, depends on what you're trying to do.
Và nó có thể đến cuối trang, hoặc không, tùy vào việc bạn định làm gì.
But I'm saying you know the value, you'd have to know the value you're trying to modify in order to acquire the lock for it. Yes.
Nhưng ý tôi là bạn phải biết giá trị, bạn phải biết giá trị mà bạn định sửa đổi thì mới lấy được khóa cho nó. Mời bạn.
So his question is, if I insert 15 and then now I've got to split this node, how about that?
Vậy câu hỏi của bạn ấy là, nếu tôi chèn 15 và giờ tôi phải tách nút này thì sao?
You're talking about physically within the page? I still have to take a write latch on the page. These are logical locks.
Bạn đang nói về việc ở mức vật lý bên trong trang à? Tôi vẫn phải lấy khóa chốt ghi (write latch) trên trang. Đây là các khóa logic.
So I'm trying to lock the logical values that are stored inside the page. In order for me to modify the page, I have to take a physical latch.
Tức là tôi đang cố khóa các giá trị logic được lưu bên trong trang. Để sửa đổi trang, tôi phải lấy một latch vật lý.
Does that make sense? So again, in order for me to physically modify the bytes within a page, I have to have a write latch on that page.
Các bạn hiểu chứ? Vậy nên, một lần nữa, để tôi sửa đổi vật lý các byte bên trong một trang, thì tôi phải giữ một write latch trên trang đó.
There's another, this is why we were separating locks and latches. The locks are protecting the logical contents of the database. The logical contents are the keys that are stored within a range.
Còn một điểm nữa, đó là lý do chúng ta tách biệt lock và latch. Lock bảo vệ nội dung logic của cơ sở dữ liệu. Nội dung logic là các khóa được lưu trong một khoảng.
I'm using the index as the mechanism to efficiently keep track of that range. But I still have to maintain all the physical correctness using the latches. Lots of hands, yes.
Tôi dùng chỉ mục như cơ chế để theo dõi khoảng đó một cách hiệu quả. Nhưng tôi vẫn phải duy trì toàn bộ tính đúng đắn vật lý bằng các latch. Nhiều bạn giơ tay quá, em nói đi.
The question is, does that mean if I try to do, if I'm trying to run serializable transactions where I don't, and I don't have an index on the thing, on the ranges that I'm looking at, could that cause them to be expensive?
Câu hỏi là, nếu tôi cố chạy các giao dịch serializable mà tôi không có, tức là không có chỉ mục trên những khoảng mà tôi đang xét, thì điều đó có thể khiến chúng trở nên tốn kém không?
Yes. There's no free lunch, right? Yes.
Có. Không có bữa trưa nào miễn phí cả, đúng không? Vâng.
The question is, does everybody try to do syntactic, static analysis of the predicates and see whether you would have confidence in the other?
Câu hỏi là, liệu mọi hệ thống có cố phân tích tĩnh về mặt cú pháp các vị từ để xem có thể tin chắc về giao dịch kia hay không?
Maybe, but as soon as you have functions inside that thing, it becomes, and the statement is like, could you just, could you just do a quick fix?
Có thể, nhưng ngay khi bên trong có các hàm thì nó trở nên và ý của em là, liệu có thể làm một cách sửa nhanh không?
Could you quickly try to assess whether you can determine statically through the predicates whether you would have confidence in other transactions? If, If no, and it's provably correct, then you're good.
Liệu có thể nhanh chóng đánh giá xem có xác định được một cách tĩnh qua các vị từ rằng mình có thể yên tâm về các giao dịch khác không? Nếu không xung đột và chứng minh được là đúng, thì ổn.
If yes, then you fall back to the more heavyweight. Like, if you can't verify, if you can't verify that they're, like, the question is, is there any work in this space?
Nếu có, thì quay lại cách nặng nề hơn. Tức là, nếu không thể kiểm chứng được rằng chúng, câu hỏi là, có công trình nào trong mảng này không?
Maybe it's been 50 years since people are trying to do this, so maybe. I just don't know. Yeah. Questions in the back, sorry.
Có thể có, người ta đã thử làm việc này 50 năm rồi, nên có lẽ. Tôi không biết. Vâng. Câu hỏi ở cuối lớp, xin lỗi nhé.
Okay. I think we've covered all this. All right. So now here's the dirty secret.
Được rồi. Tôi nghĩ chúng ta đã bàn hết phần này. Được. Giờ đến bí mật đáng xấu hổ.
We spent the last three classes talking about how great serializability is, how it's important to, you know, keep track of what transactions are doing so you can generate schedules that are serializable.
Ba buổi vừa rồi chúng ta nói serializability tuyệt vời thế nào, việc theo dõi các giao dịch đang làm gì quan trọng ra sao, để có thể tạo ra các lịch biểu serializable.
The dirty secret is, most databases do not give you serializability by default. Right? And in some systems, they'll lie to you. Oracle famously does this.
Bí mật đáng xấu hổ là hầu hết cơ sở dữ liệu mặc định không cho bạn serializability. Và ở một số hệ thống, chúng còn nói dối bạn. Oracle nổi tiếng vì điều này.
If you say to Oracle, I want serializable transactions, it'll come back and say, yep, got it, no problem. It does not give you serializability. It gives you a lower form of isolation.
Nếu bạn nói với Oracle rằng tôi muốn các giao dịch serializable, nó sẽ trả lời: vâng, đã rõ, không vấn đề gì. Nó không cho bạn serializability. Nó cho bạn một mức cô lập thấp hơn.
Right?
Đúng không?
And so the reason why these systems are not going to do all this extra stuff we've been talking about in the last two classes, like, they're still going to do two-phase locking, they're still going to do OCC, but all these extra mechanisms I just talked about now to guarantee serializability, they're not going to do these things because they're expensive.
Và lý do các hệ thống này không làm tất cả những thứ bổ sung mà chúng ta đã nói trong hai buổi trước, tức là chúng vẫn dùng khóa hai pha, vẫn dùng OCC, nhưng tất cả các cơ chế bổ sung mà tôi vừa nói để đảm bảo serializability, chúng không làm vì chúng tốn kém.
You can't, you know, they kept asking the front row, what if you don't have indexes? How do I do this? You have to do the slow thing and just scan everything.
Các bạn hàng đầu cứ hỏi, nếu không có chỉ mục thì sao? Làm thế nào? Bạn phải làm cách chậm là quét toàn bộ.
And so by default, that's going to suck. If that's only by default, that's going to suck.
Và như vậy thì mặc định sẽ rất tệ. Nếu chỉ vì mặc định thôi cũng đã rất tệ.
People are like, yeah, this database sucks, it's so slow, and they're going to switch to something else and, you know, you lose out potential customers.
Người ta sẽ bảo cơ sở dữ liệu này tệ, chậm quá, rồi họ chuyển sang thứ khác, và bạn mất đi khách hàng tiềm năng.
So that's why by default most data systems are going to run with a lower isolation level. So now the question is, what is an isolation level?
Đó là lý do mặc định hầu hết hệ thống dữ liệu sẽ chạy với mức cô lập thấp hơn. Vậy câu hỏi bây giờ là: mức cô lập là gì?
So, an isolation level is going to control the, the sort of, how aggressive you want the data system to be to ensure your transactions don't incur any of the anomalies that we talked about before: dirty reads, unrepeatable reads, lost updates, and then the phantom reads we just mentioned here.
Một mức cô lập sẽ kiểm soát mức độ quyết liệt mà bạn muốn hệ thống dữ liệu phải đảm bảo để các giao dịch của bạn không gặp phải bất kỳ dị thường nào mà chúng ta đã nói trước đó: dirty read, unrepeatable read, lost update, và phantom read mà ta vừa nhắc đến ở đây.
So, by default, serializability makes sure that none of these things happen.
Theo mặc định, tính khả tuần tự hóa (serializability) đảm bảo không có hiện tượng nào trong số này xảy ra.
But if you run at a lower isolation level, so when your transaction starts, you can tell the system, "Run my new transaction, but run with a lower isolation level," you may incur some of these other anomalies.
Nhưng nếu bạn chạy ở mức cô lập thấp hơn, tức là khi giao dịch bắt đầu, bạn có thể bảo hệ thống: "Hãy chạy giao dịch mới của tôi, nhưng với mức cô lập thấp hơn", thì bạn có thể gặp một số dị thường khác này.
And so, what I'm showing here is the basic ones that were originally defined in the SQL standard from 1992, and this is assuming you're running in a system that uses two-phase locking, but the highest level is serializable.
Những gì tôi trình bày ở đây là các mức cơ bản được định nghĩa ban đầu trong chuẩn SQL năm 1992, và giả sử bạn đang chạy trên một hệ thống dùng khóa hai pha (two-phase locking), nhưng mức cao nhất là serializable.
So you say, I want my transaction on serializable, and you're guaranteed to have no phantoms, everything's repeatable reads, and then no dirty reads.
Khi bạn nói muốn giao dịch của mình chạy ở mức serializable, bạn được đảm bảo không có phantom, mọi lần đọc đều lặp lại được, và không có dirty read.
The next lowest isolation level is called repeatable reads, and this is where phantoms might happen, but the other three types of anomalies will not, definitely not happen.
Mức cô lập thấp kế tiếp gọi là repeatable reads, ở mức này phantom có thể xảy ra, nhưng ba loại dị thường còn lại chắc chắn không xảy ra.
Read committed is that you have phantoms, potentially unrepeatable reads, because you're reading data from transactions that have recently committed, but maybe you read an object at first before they committed, so you see the data one way, then they commit, and now you read it again, and because you're allowed to read committed data, you'll see different values, so you may have unrepeatable reads.
Với read committed, bạn có thể gặp phantom và có khả năng cả unrepeatable read, vì bạn đọc dữ liệu từ các giao dịch vừa mới commit, nhưng có thể lúc đầu bạn đọc một đối tượng trước khi chúng commit, nên bạn thấy dữ liệu theo một kiểu, rồi chúng commit, và bây giờ bạn đọc lại, và vì bạn được phép đọc dữ liệu đã commit, bạn sẽ thấy các giá trị khác nhau, nên có thể xảy ra unrepeatable read.
And the read uncommitted is just like you're driving without a seatbelt, all these anomalies may happen.
Còn read uncommitted thì giống như lái xe mà không thắt dây an toàn, tất cả các dị thường này đều có thể xảy ra.
Now I'm counting my language here, I'm not saying they will happen, I'm saying they might happen, because again, if I just execute one transaction by itself and no other transactions, that's serializable, right?
Tôi đang cân nhắc cách dùng từ ở đây, tôi không nói chúng sẽ xảy ra, mà là chúng có thể xảy ra, vì một lần nữa, nếu tôi chỉ chạy một giao dịch riêng lẻ và không có giao dịch nào khác, thì đó là serializable, đúng không?
One transaction in one schedule with no other transactions is by definition serial, because that's always going to be serializable.
Một giao dịch trong một lịch biểu mà không có giao dịch nào khác thì theo định nghĩa là tuần tự, vì nó luôn luôn khả tuần tự hóa.
So I'm putting a bunch of maybes here, just to say that, like, if you run these isolation levels, you may have these problems.
Nên tôi ghi hàng loạt chữ "có thể" ở đây, chỉ để nói rằng nếu bạn chạy các mức cô lập này, bạn có thể gặp những vấn đề này.
It depends on what are the other transactions running at the same time that your transaction is running, is reading and writing the data that you're reading and writing to.
Điều đó phụ thuộc vào việc những giao dịch nào khác đang chạy cùng lúc với giao dịch của bạn, đang đọc và ghi vào chính dữ liệu mà bạn đang đọc và ghi.
So now, if you do this in two-phase locking, how do you actually implement this?
Vậy nếu bạn làm điều này với khóa hai pha, thì thực sự triển khai nó như thế nào?
Well, again, you just turn off a bunch of the stuff I just spent the last half an hour telling you how to do.
Thì, bạn chỉ cần tắt bớt một loạt những thứ mà tôi vừa dành nửa tiếng qua để chỉ cách làm.
Again, OCC basically works the same way, but in the case of two-phase locking, if I run a strong strict 2PL with additional phantom protection, by either, like, re-executing scans, the index locks, or predicate locking, or whatever, then I'm guaranteed to not have any phantoms, and all the transactions will run in serial order, or the equivalent to a serial ordering.
OCC về cơ bản cũng hoạt động theo cách tương tự, nhưng với khóa hai pha, nếu tôi chạy strong strict 2PL cùng với cơ chế bảo vệ chống phantom bổ sung, bằng cách như thực thi lại các lần quét, khóa chỉ mục, hoặc khóa theo vị từ, hay bất cứ cách nào, thì tôi được đảm bảo không có phantom, và tất cả các giao dịch sẽ chạy theo thứ tự tuần tự, hoặc một thứ tự tương đương với thứ tự tuần tự.
Repeatable is, you just don't do the index locks or the stuff we talked about at the end.
Còn Repeatable thì bạn chỉ cần không dùng khóa chỉ mục hay những thứ chúng ta đã nói ở cuối bài.
Just do two-phase locking, strict two-phase locking, strong strict two-phase locking, and you're guaranteed to get everything without, everything but phantoms.
Chỉ cần dùng khóa hai pha, khóa hai pha chặt, khóa hai pha chặt mạnh, và bạn được đảm bảo có mọi thứ, trừ bóng ma (phantom).
Read committed, you, for this one, you basically just do 2PL, you don't do any index locks or gap locks, the things we talked about at the end, and then when a transaction reads an object, you acquire the shared lock on it, and then you immediately give back the shared lock.
Với Read committed, về cơ bản bạn chỉ làm 2PL, bạn không dùng khóa chỉ mục hay khóa khoảng trống, những thứ chúng ta đã nói ở cuối, và khi một giao dịch đọc một đối tượng, bạn lấy khóa chia sẻ trên nó, rồi trả lại ngay khóa chia sẻ đó.
You release the shared lock. Again, it violates the 2PL ordering, but, and you're going to get better parallelism because you can guarantee that other transactions can read data that you've read immediately.
Bạn giải phóng khóa chia sẻ. Một lần nữa, điều này vi phạm thứ tự của 2PL, nhưng bạn sẽ có tính song song tốt hơn vì bạn bảo đảm được rằng các giao dịch khác có thể đọc ngay dữ liệu mà bạn đã đọc.
You still hold the write locks until you commit. And then, and read uncommitted, you just, you, you, you just don't take any shared locks at all.
Bạn vẫn giữ khóa ghi cho đến khi commit. Còn với read uncommitted, bạn chỉ cần không lấy bất kỳ khóa chia sẻ nào cả.
If you modify something, again, it's about what you, Again, but what your transaction cares about.
Nếu bạn sửa đổi thứ gì đó, một lần nữa, vấn đề là bạn quan tâm điều gì ở giao dịch của mình.
So, I want to make sure that I don't have any lost updates, so I'll hold the write locks until I know I'm not going to write that transaction anymore.
Tôi muốn bảo đảm không có cập nhật bị mất, nên tôi sẽ giữ các khóa ghi cho đến khi tôi biết giao dịch đó sẽ không ghi nữa.
In the case of most systems, since you can't, what's it called, unlock on a, excuse me, lock on a 2PL, then it's, you just hold it to the very end until you commit.
Trong hầu hết các hệ thống, vì bạn không thể, gọi là gì nhỉ, mở khóa, xin lỗi, một khóa trong 2PL, nên bạn cứ giữ nó đến tận cùng cho đến khi commit.
Same as, you cannot have lost updates for read committed and below. You can. Yes.
Tương tự, bạn không thể có cập nhật bị mất ở read committed trở xuống. Có thể. Vâng.
Yes. Sorry, it's hard.
Vâng. Xin lỗi, phần này khó.
If I want to avoid lost updates, I don't want to write something and then not be able to read it.
Nếu tôi muốn tránh cập nhật bị mất, tôi không muốn ghi thứ gì đó rồi lại không đọc được nó.
So, yes, so, so you give up the exclusive locks, I think, on a read committed. Let me double check this. Yes.
Vậy nên, vâng, bạn nhả các khóa độc quyền, tôi nghĩ vậy, ở read committed. Để tôi kiểm tra lại. Vâng.
I, again, hopefully, it makes it clear this is hard. So, again, you define what isolation level you want.
Hy vọng điều này cho thấy phần này khó. Vậy nên, bạn xác định mức cô lập mình muốn.
If you want something other than the default, when the transaction starts, right, and different systems have different syntax on how to do this, right, and then the default is going to depend on what your system actually provides for you.
Nếu bạn muốn một mức khác với mặc định, thì khai báo khi giao dịch bắt đầu, và mỗi hệ thống có cú pháp khác nhau để làm việc này, còn mức mặc định sẽ phụ thuộc vào những gì hệ thống của bạn thực sự cung cấp.
So, this is just a quick survey of a bunch of, you know, various systems that are out there, and you see that there's this little part here, right here, from, you know, SQL Server, MySQL, Oracle, Postgres, those are the top four relational database systems in the world, right, and by default, none of them give you serializable by default, right.
Đây chỉ là một khảo sát nhanh về một loạt các hệ thống khác nhau hiện có, và bạn thấy có phần nhỏ này ở đây, ngay đây, gồm SQL Server, MySQL, Oracle, Postgres, đó là bốn hệ quản trị cơ sở dữ liệu quan hệ hàng đầu thế giới, và theo mặc định, không hệ nào cho bạn serializable cả.
In the case of MySQL, MySQL is actually better than the others because it's actually giving you repeatable reads, which is higher than, what's that?
Trong trường hợp của MySQL, MySQL thực ra tốt hơn những hệ khác vì nó cho bạn repeatable reads, cao hơn, gì vậy?
All right, the question is, what is snapshot isolation? That's the next class.
Được rồi, câu hỏi là: snapshot isolation là gì? Đó là nội dung của buổi học tới.
So, when they defined the SQL standard in 1992, they forgot about this multi-versioning stuff that's like the next class, and there's an anomaly that can occur with snapshot isolation that doesn't occur with two-phase locking, and the isolation level, therefore, is classified as different, So it's called snapshot isolation.
Vậy, khi họ định nghĩa chuẩn SQL vào năm 1992, họ đã quên mất chuyện đa phiên bản này, thứ sẽ có ở buổi học tới, và có một dị thường có thể xảy ra với snapshot isolation mà không xảy ra với khóa hai pha, nên mức cô lập này được xếp vào một loại khác, Vì vậy nó được gọi là snapshot isolation.
This means that I see a snapshot of the database that was created by any transaction that committed before I started. Yes?
Điều này có nghĩa là tôi thấy một snapshot của cơ sở dữ liệu được tạo ra bởi bất kỳ giao dịch nào đã commit trước khi tôi bắt đầu. Có câu hỏi không?
The question is, do all data systems have some version of OCC? No. Some systems will do 2PL, the two-phase locking. It's one or the other.
Câu hỏi là: hệ thống dữ liệu nào cũng có một dạng OCC nào đó phải không? Không. Một số hệ thống dùng 2PL, tức khóa hai pha. Là cái này hoặc cái kia.
Multi-versioning is going to be, you can do multi-versioning with, see, in this class. You can do it with two-phase locking, or you can do it with OCC.
Đa phiên bản sẽ là, bạn có thể làm đa phiên bản với, rồi bạn sẽ thấy, trong lớp này. Bạn có thể làm với khóa hai pha, hoặc làm với OCC.
But the way you also do multi-versioning is with timestamps. But like, the timestamps will just tell you in which, what version, when was a version created.
Nhưng cách để làm đa phiên bản cũng là dùng timestamp. Nhưng timestamp chỉ cho bạn biết là phiên bản nào, một phiên bản được tạo ra khi nào.
It doesn't tell you who's allowed to do what and when. OCC or 2PL defines that ordering. Question, which one's the most common? 2PL. Yeah. Alright, so. Right.
Nó không cho biết ai được phép làm gì và khi nào. OCC hay 2PL xác định thứ tự đó. Câu hỏi: cái nào phổ biến nhất? 2PL. Đúng vậy. Được rồi. Vâng.
We're jumping ahead. Alright, sorry. So, SAP, Satellite installation, we'll cover next class. There's a few systems that do serializable. Ingres was what Stonebraker built before.
Chúng ta đang đi trước rồi. Xin lỗi nhé. Vậy, SAP, Satellite installation, chúng ta sẽ học ở buổi tới. Có một vài hệ thống làm serializable. Ingres là hệ thống Stonebraker đã xây dựng trước đó.
Postgres, Cockroach DB was a distributed system out of New York City. VoltDB is a system I helped build when I was in grad school. By default, you get serializability. You can't run anything lower.
Postgres, Cockroach DB là một hệ thống phân tán đến từ thành phố New York. VoltDB là hệ thống mà tôi đã giúp xây dựng khi còn học cao học. Mặc định bạn có tính tuần tự hóa được. Bạn không thể chạy ở mức thấp hơn.
Google Spanner, and I guess DSQL also as well. Actually, I'm not sure about DSQL, but Google Spanner is one of the few systems that support strict serializability.
Google Spanner, và tôi đoán cả DSQL nữa. Thật ra tôi không chắc về DSQL, nhưng Google Spanner là một trong số ít hệ thống hỗ trợ strict serializability.
Also known as external consistency, meaning the order in which transactions are committed is the order in which they arrive in the system.
Còn được gọi là external consistency, nghĩa là thứ tự các giao dịch được commit chính là thứ tự chúng đến hệ thống.
So they're getting timestamps of when they show up, and that's the order that's going to be used to determine when they commit.
Vậy chúng nhận timestamp lúc chúng xuất hiện, và đó là thứ tự được dùng để xác định khi nào chúng commit.
Then he's like, what is cursor stability? So that's this other weird thing. Again, there's a whole bunch of different isolation levels beyond the four, basically, I told you.
Rồi bạn ấy hỏi: cursor stability là gì? Đó là một thứ kỳ lạ khác. Một lần nữa, có cả một loạt mức cô lập khác ngoài bốn mức mà về cơ bản tôi đã nói với các bạn.
And you can sort of think of the sort of chart here. At the bottom, you have read committed, read uncommitted. I think there's even one below this, but SQL doesn't support this.
Bạn có thể hình dung một dạng biểu đồ như thế này. Ở dưới cùng, bạn có read committed, read uncommitted. Tôi nghĩ còn có một mức thấp hơn nữa, nhưng SQL không hỗ trợ.
So now you have sort of two branches. You have above read committed, And think of, like, what, you're getting fewer anomalies. Cursor stability is something that IBM DB2 does.
Vậy bây giờ bạn có hai nhánh. Bạn có những mức phía trên read committed, Và hãy nghĩ là bạn gặp ít dị thường hơn. Cursor stability là thứ mà IBM DB2 làm.
Basically, you hold a read lock, a shared lock, on the cursor that's reading the data.
Về cơ bản, bạn giữ một khóa đọc, tức khóa chia sẻ, trên con trỏ đang đọc dữ liệu.
And that guarantees that within, like, as I'm, as the cursor is scanning the data, I'm holding implicitly a lock on that range. But then when I'm done scanning, I give it back up.
Và điều đó đảm bảo rằng trong khi tôi đang, khi con trỏ đang quét dữ liệu, tôi ngầm giữ một khóa trên phạm vi đó. Nhưng khi quét xong, tôi sẽ nhả khóa ra.
So as I'm reading, as I'm reading the table within my cursor, I'm guaranteed to see a consistent view. But then after that, if I read it again, it won't be repeatable.
Vậy nên khi tôi đang đọc bảng bằng con trỏ của mình, tôi được đảm bảo thấy một góc nhìn nhất quán. Nhưng sau đó, nếu tôi đọc lại thì kết quả sẽ không lặp lại được.
Yeah, there'll be no, no, no inserts or deletes while I'm scanning.
Đúng vậy, sẽ không có thao tác chèn hay xóa nào trong lúc tôi đang quét.
Yes, only in the range, yes. But then as soon as I'm done scanning, the cursor gives it up. Again, and then strict serializability, again, it's the order in which they arrive.
Vâng, chỉ trong phạm vi đó thôi. Nhưng ngay khi quét xong, con trỏ sẽ nhả khóa. Còn strict serializability thì, một lần nữa, là theo thứ tự mà các giao dịch đến.
So I'm kind of, I'm going fast here. We'll do demos and look at this more in the next class.
Tôi đang đi hơi nhanh ở đây. Chúng ta sẽ làm demo và xem kỹ hơn ở buổi sau.
But the main takeaway I want you to get is, like, most systems, most data systems that are out there today, most workloads are not running with serializable isolation, even though I made a big deal about it.
Nhưng điều chính tôi muốn các bạn rút ra là hầu hết các hệ thống, hầu hết các hệ thống dữ liệu hiện nay, hầu hết khối lượng công việc không chạy với mức cô lập serializable, dù tôi đã nhấn mạnh nó rất nhiều.
So this is a survey we did a few years ago where we asked DBAs where their databases are running in production, what's the most common isolation level they're using?
Đây là một khảo sát chúng tôi thực hiện vài năm trước, hỏi các DBA về cơ sở dữ liệu của họ chạy trong môi trường production, mức cô lập phổ biến nhất mà họ dùng là gì?
And you can see the most common one is read committed, because that's the default in most systems. Right? What's that? Is it a reasonable default? Nobody knows. Right?
Và các bạn thấy phổ biến nhất là read committed, vì đó là mặc định ở hầu hết các hệ thống. Đúng không? Thế nó có phải là mặc định hợp lý không? Không ai biết cả.
Because it depends, because, again, these problems might occur. So, like, if 99.99% of the time, you're going to have, you know, there's no issue.
Vì còn tùy, bởi những vấn đề này vẫn có thể xảy ra. Chẳng hạn 99,99% thời gian thì không có vấn đề gì.
But then there's one time maybe you read something you shouldn't have read. How would you know? Right?
Nhưng có một lần có thể bạn đọc phải thứ lẽ ra không nên đọc. Làm sao bạn biết được?
Or, like, you know, sometimes you see weird things, like, you know, anytime you maybe refresh a website and you don't see calendars look correctly, that's eventual consistency issues, not this.
Hoặc đôi khi bạn thấy những điều kỳ lạ, ví dụ khi bạn tải lại một trang web mà lịch hiển thị không đúng, đó là vấn đề nhất quán cuối cùng, không phải vấn đề này.
But, like, for other things, like, you wouldn't know. I'm blazing through all this, so I apologize for going fast.
Nhưng với những trường hợp khác thì bạn sẽ không biết. Tôi đang lướt qua tất cả những thứ này, xin lỗi vì đi nhanh.
But the main takeaway from all this is that there's basically two categories of concurrency control protocols: pessimistic, like two-phase locking, and optimistic, using timestamp ordering, that we talked about today.
Nhưng điều chính rút ra là về cơ bản có hai loại giao thức điều khiển đồng thời: bi quan, như khóa hai pha, và lạc quan, dùng sắp xếp theo timestamp, mà hôm nay chúng ta đã nói.
There's no one protocol better than another. And the next class, when we talk about multi-versioning, it's actually being a combination of all these techniques put together.
Không có giao thức nào tốt hơn hẳn giao thức khác. Và ở buổi sau, khi nói về đa phiên bản, thực ra đó là sự kết hợp của tất cả các kỹ thuật này.
And we're going to now, instead of maintaining a private workspace, we're going to have the new versions of the objects that we're modifying, they're going to show up in the global database, and we're going to use these timestamps to figure out what we're allowed to read or not read.
Và giờ đây, thay vì duy trì một không gian làm việc riêng, các phiên bản mới của những đối tượng mà chúng ta sửa đổi sẽ xuất hiện trong cơ sở dữ liệu toàn cục, và chúng ta sẽ dùng các timestamp này để xác định cái gì được phép đọc hoặc không được đọc.
Okay? Hit it.
Được chưa? Nhạc đi.
Hit it.
Nhạc đi.
Hit it.
Nhạc đi.
Đă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.