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ả.
DJ Cash, turns out if you make money, you got to pay taxes, he's learning the hard way. So he's there today with his accountant. I don't, that's his problem.
DJ Cash thì hóa ra là nếu kiếm được tiền, thì phải đóng thuế, và cậu ấy đang học điều đó một cách khó khăn. Nên hôm nay cậu ấy đang ở chỗ kế toán. Tôi thì không, đó là chuyện của cậu ấy.
All right, a lot to cover. And plus we have the guest speaker today, so I want to get through as much as I can.
Được rồi, hôm nay có rất nhiều nội dung. Hơn nữa hôm nay còn có khách mời, nên tôi muốn đi hết càng nhiều càng tốt.
All right, so last class we were talking about beginnings of concurrency control protocols in our database system.
Được rồi, buổi trước chúng ta đã nói về phần mở đầu của các giao thức điều khiển đồng thời trong hệ cơ sở dữ liệu.
And we talked about ACID, of course, but then we spent a lot of time on the isolation portion of ACID, where we were distinguishing between different levels of correctness or serializability within schedules of transactions.
Và tất nhiên chúng ta đã nói về ACID, nhưng sau đó dành nhiều thời gian cho phần isolation của ACID, trong đó chúng ta phân biệt các mức đúng đắn khác nhau hay tính khả tuần tự hóa trong các lịch của giao dịch.
We made the point that there's basically two that we care about in this class, although there's others we don't care about. There's two sort of main categories of serializability, conflict serializability and view serializability.
Chúng ta đã nêu rằng về cơ bản có hai loại mà ta quan tâm trong môn này, mặc dù còn những loại khác mà ta không quan tâm. Có hai nhóm chính của tính khả tuần tự hóa, conflict serializability và view serializability.
Conflict serializability is what you get in pretty much any system where they truly do support serializable transactions. This is what you get.
Conflict serializability là thứ bạn có được trong hầu như mọi hệ thống thực sự hỗ trợ các giao dịch khả tuần tự hóa. Đây là thứ bạn nhận được.
And we would verify that schedules were conflict serializable if we created a dependency graph and we didn't have any cycles.
Và ta kiểm tra một lịch có conflict serializable hay không bằng cách tạo đồ thị phụ thuộc và xem nó không có chu trình nào.
We'll see the notion of cycles corresponding to issues in transactions when we talk about deadlock detection in a second.
Ta sẽ thấy khái niệm chu trình tương ứng với các vấn đề trong giao dịch khi nói về phát hiện bế tắc ngay sau đây.
And then view serializability was this higher level notion of serializability where it was OK for certain conflicts to occur that would not be allowed under conflict serializability, but they are allowed in view serializability if we understand the semantics of what the application actually wants to do with data.
Còn view serializability là một khái niệm khả tuần tự hóa ở mức cao hơn, trong đó một số xung đột nhất định được phép xảy ra mà conflict serializability sẽ không cho phép, nhưng view serializability cho phép nếu ta hiểu được ngữ nghĩa của việc ứng dụng thực sự muốn làm với dữ liệu.
What does it mean to read something and write something? And that's not something that we can easily derive automatically from just looking at read and write requests to the data system.
Đọc một thứ gì đó và ghi một thứ gì đó có nghĩa là gì? Và điều đó không dễ suy ra một cách tự động chỉ từ việc nhìn các yêu cầu đọc và ghi gửi tới hệ thống dữ liệu.
You have to actually examine the application code or, again, worst case scenario, ask a human about what data means in their application. And therefore, no system is going to support this. All right.
Bạn phải thực sự xem xét mã ứng dụng, hoặc trong trường hợp xấu nhất, hỏi một người về dữ liệu có ý nghĩa gì trong ứng dụng của họ. Và vì vậy, không hệ thống nào hỗ trợ điều này. Được rồi.
All right, so the other point I think about last class is that I think I said this multiple times.
Được rồi, một điểm khác của buổi trước mà tôi nghĩ là tôi đã nói nhiều lần.
In all those examples, when we had those schedules, those were those sort of setups of the problem where I had all of the read and write operations that transactions were going to do ahead of time.
Trong tất cả các ví dụ đó, khi ta có những lịch ấy, đó là những bài toán được dựng sẵn, trong đó tôi có sẵn tất cả các thao tác đọc và ghi mà các giao dịch sẽ thực hiện, biết trước từ đầu.
Right? The schedule was static. There wasn't, like, when a transaction began, you knew everything it was going to do until it actually committed or rolled back.
Đúng không? Lịch là tĩnh. Không có chuyện, khi một giao dịch bắt đầu, bạn biết mọi thứ nó sẽ làm cho đến khi nó commit hoặc rollback.
And so we could look at the schedules in their totality and say, OK, yes, these are going to be serializable or not.
Và vì vậy ta có thể nhìn toàn bộ các lịch và nói, được, những lịch này khả tuần tự hóa hoặc không.
But now we need to build a real system where we can't assume, we cannot assume, we will have that schedule ahead of time. Some systems do. We can ignore that for now.
Nhưng giờ ta cần xây dựng một hệ thống thực, trong đó ta không thể giả định, không thể giả định, rằng ta có lịch đó từ trước. Một số hệ thống thì có. Tạm thời ta có thể bỏ qua điều đó.
And therefore, we need to be able to still provide complex serializability guarantees, even if transactions are starting and then sending query requests where we don't know what the additional queries and the later queries are going to be later on.
Và do đó, chúng ta vẫn cần cung cấp được các đảm bảo khả tuần tự hóa (serializability) phức tạp, ngay cả khi các giao dịch bắt đầu rồi mới gửi các yêu cầu truy vấn, trong khi chúng ta không biết các truy vấn bổ sung và các truy vấn về sau sẽ là gì.
And the mechanism we're going to use to make this work today is going to be using locks. Right? Hence the title of the lecture, two-phase locking.
Và cơ chế mà hôm nay chúng ta sẽ dùng để làm cho điều này hoạt động là sử dụng khóa (lock). Đúng không? Do đó mới có tên bài giảng là khóa hai pha (two-phase locking).
So I briefly mentioned locks earlier in the semester when we talked about index concurrency control protocols. And we made this distinction between locks and latches.
Tôi đã nhắc ngắn gọn về khóa ở phần đầu học kỳ khi chúng ta nói về các giao thức điều khiển đồng thời trên chỉ mục. Và chúng ta đã phân biệt giữa lock và latch.
This is the same table that I showed before, where on the left hand side, you had all the locks, but we only focused on the right hand side when we talked about indexes, to do latches.
Đây là bảng mà tôi đã cho các bạn xem trước đó, trong đó ở phía bên trái là tất cả các lock, nhưng chúng ta chỉ tập trung vào phía bên phải khi nói về chỉ mục, tức là các latch.
So now we're going to go back and look at all these things.
Còn bây giờ chúng ta sẽ quay lại và xem xét tất cả những thứ này.
So the way to understand locks is that they are going to be protecting database objects, higher level database objects in our system, like tables and tuples and databases themselves.
Cách để hiểu về lock là chúng bảo vệ các đối tượng của cơ sở dữ liệu, những đối tượng cơ sở dữ liệu ở mức cao hơn trong hệ thống của chúng ta, như bảng, tuple và bản thân cơ sở dữ liệu.
And we're going to allow multiple transactions to interleave their operations and operate on these objects as they go along.
Và chúng ta sẽ cho phép nhiều giao dịch đan xen các thao tác của chúng và thao tác trên những đối tượng này trong quá trình chạy.
The key thing that's going to be different about locks and transactions versus latches and indexes, even though the transactions take latches as they update the indexes, is that transactions will typically hold the locks for the entirety lifetime of the transaction.
Điểm mấu chốt khác biệt của lock và giao dịch so với latch và chỉ mục, dù các giao dịch có dùng latch khi cập nhật chỉ mục, là giao dịch thường giữ lock trong suốt toàn bộ vòng đời của giao dịch.
Whereas with latches, we were trying to do something in a single page and index or a single node.
Trong khi với latch, chúng ta chỉ cố làm một việc trong một trang đơn lẻ, một chỉ mục hay một nút đơn lẻ.
So we're trying to acquire the latch, do something, and then get out of it real quick and release the latch.
Tức là ta cố lấy latch, làm một việc gì đó, rồi thoát ra thật nhanh và nhả latch.
In this world, we're going to allow transactions to hold locks until they commit or finish.
Còn trong thế giới này, chúng ta sẽ cho phép giao dịch giữ lock cho đến khi commit hoặc kết thúc.
And the way we're going to have to handle deadlocks is through having these protocols that can assure that we don't have deadlocks, or having an overseer or a coordinator understand what transactions hold what locks at what time and what are they trying to do.
Và cách chúng ta xử lý bế tắc là thông qua các giao thức có thể đảm bảo rằng không xảy ra bế tắc, hoặc có một bộ giám sát hay bộ điều phối nắm được giao dịch nào đang giữ lock nào vào thời điểm nào và chúng đang cố làm gì.
And then we can arbitrate and decide how to break deadlocks. Whereas in the case of latches, we said there wasn't going to be any data detection.
Rồi chúng ta có thể phân xử và quyết định cách phá vỡ bế tắc. Trong khi với latch, chúng ta đã nói là sẽ không có việc phát hiện nào cả.
We had to make sure we wrote good code and didn't have these problems. In the locking world, we'll have to do this.
Chúng ta phải đảm bảo viết mã tốt để không gặp những vấn đề này. Trong thế giới khóa, chúng ta sẽ phải làm việc này.
We'll have to have the resolution stuff written by us, the database system developers.
Phần xử lý giải quyết này sẽ do chúng ta tự viết, những người phát triển hệ quản trị cơ sở dữ liệu.
Because we're dealing with the application sending random queries, making random requests, we can't assume they're going to know what they're doing and avoid deadlocks.
Bởi vì chúng ta phải đối phó với ứng dụng gửi các truy vấn ngẫu nhiên, đưa ra các yêu cầu ngẫu nhiên, chúng ta không thể giả định rằng họ biết mình đang làm gì và sẽ tránh được bế tắc.
We have to make sure they don't shoot themselves in the foot.
Chúng ta phải đảm bảo họ không tự gây rắc rối cho chính mình.
And the metadata we're going to maintain about what locks are being held by what transactions at what time, this is going to be kept in a centralized coordinator, a centralized data structure called the lock manager, where now we have a single location where we're keeping track of, here's all the locks transactions are holding.
Và siêu dữ liệu mà chúng ta sẽ duy trì về việc khóa nào đang được giữ bởi giao dịch nào tại thời điểm nào, sẽ được lưu trong một bộ điều phối tập trung, một cấu trúc dữ liệu tập trung gọi là lock manager, nghĩa là giờ đây chúng ta có một nơi duy nhất để theo dõi rằng, đây là tất cả các khóa mà các giao dịch đang nắm giữ.
Whereas in the case of latches, we were going to embed the latches directly in the data structure itself. Right? So again, we'll go through all this and make more sense as we go along.
Còn trong trường hợp của latch, chúng ta sẽ nhúng các latch trực tiếp vào chính cấu trúc dữ liệu. Đúng không? Nên một lần nữa, chúng ta sẽ đi qua tất cả những điều này và sẽ dễ hiểu hơn dần dần.
But the key thing to understand is, again, this is why I was saying there was a distinction between the OS world and our world.
Nhưng điều quan trọng cần hiểu, một lần nữa, là đây là lý do tôi nói có một sự phân biệt giữa thế giới hệ điều hành và thế giới của chúng ta.
In the OS world, a lock is really what they mean as a latch.
Trong thế giới hệ điều hành, khi nói lock thì thực chất họ muốn nói đến latch.
In the database world, locks are these higher level things that are actually managing the contents of a database itself within the database system. So let's look to see how this would work.
Trong thế giới cơ sở dữ liệu, khóa là những thứ ở mức cao hơn, thực sự quản lý nội dung của chính cơ sở dữ liệu bên trong hệ quản trị cơ sở dữ liệu. Vậy hãy xem điều này hoạt động như thế nào.
So now we have our schedules on the side here. We have T1, T2. T1 is going to read A, write A, and then read A again.
Bên cạnh đây chúng ta có các lịch biểu. Chúng ta có T1, T2. T1 sẽ đọc A, ghi A, rồi đọc A một lần nữa.
And then T2 is going to read A and write A.
Và sau đó T2 sẽ đọc A và ghi A.
And now I'm introducing explicit lock commands, like lock and unlock, and you're passing in what object you want to acquire or release the lock for.
Và bây giờ tôi đưa vào các lệnh khóa tường minh, như lock và unlock, và bạn truyền vào đối tượng mà bạn muốn lấy hoặc giải phóng khóa.
And we have now this centralized lock manager that everyone has to talk to when they want to get a lock or release a lock.
Và giờ chúng ta có lock manager tập trung này mà mọi người đều phải trao đổi với nó khi muốn lấy hoặc giải phóng một khóa.
So at the beginning, T1 starts and says, "I want to lock object A." So it goes to the lock manager and says, "Hey, can I have the lock on A?"
Vậy lúc đầu, T1 bắt đầu và nói: "Tôi muốn khóa đối tượng A." Nên nó đến lock manager và hỏi: "Này, tôi có thể có khóa trên A không?"
And assuming that nobody else holds that lock right now, the lock manager grants access to that and it's given a lock. And then now T1 can go and read A.
Và giả sử hiện giờ không ai khác giữ khóa đó, lock manager cấp quyền truy cập đó và nó được trao một khóa. Và giờ T1 có thể đọc A.
But then now when T2 starts running, it wants to acquire the lock on A. It goes to the lock manager. Lock manager says, "Oh, well, T1 already has this lock.
Nhưng khi T2 bắt đầu chạy, nó muốn lấy khóa trên A. Nó đến lock manager. Lock manager nói: "À, T1 đã giữ khóa này rồi.
You're not T1. You're T2. Therefore, I can't give you this request right now." And therefore, T2 is going to have to stall and wait until the lock that it's asking for is released.
Bạn không phải T1. Bạn là T2. Vì vậy tôi không thể đáp ứng yêu cầu này lúc này." Và do đó T2 sẽ phải dừng lại và chờ cho đến khi khóa mà nó yêu cầu được giải phóng.
Then T1 starts running again, does the write on A, read on A. Then it unlocks A here.
Sau đó T1 chạy tiếp, ghi A, đọc A. Rồi nó mở khóa A ở đây.
And now at this point, the lock manager knows, hey, there's also this transaction T2 that was waiting for this lock on A. But I told them they weren't allowed to have it.
Và đến lúc này, lock manager biết rằng, còn có giao dịch T2 này đang chờ khóa trên A. Nhưng tôi đã bảo họ là không được phép có nó.
So now I can grant the access to A to T2. And then it's allowed to do whatever it wants and then release the lock when it commits.
Vậy giờ tôi có thể cấp quyền truy cập A cho T2. Và sau đó nó được phép làm bất cứ điều gì nó muốn rồi giải phóng khóa khi nó commit.
So this is, roughly, the high level of what we're talking about today. And obviously, the devil's in the details. How do we make sure that we don't have problems while we're doing this?
Vậy đây, nói đại khái, là bức tranh tổng quan về những gì chúng ta bàn hôm nay. Và dĩ nhiên, vấn đề nằm ở các chi tiết. Làm sao để đảm bảo không có vấn đề gì khi chúng ta làm điều này?
And this is sort of a toy example. We'll see other problems that can come up as we go along.
Và đây chỉ là một ví dụ đơn giản. Chúng ta sẽ thấy những vấn đề khác có thể phát sinh dần dần.
So today, we're going to first talk about what kind of lock types you can have in our data system.
Vậy hôm nay, trước tiên chúng ta sẽ nói về những loại khóa nào mà bạn có thể có trong hệ quản trị dữ liệu của chúng ta.
And then we'll describe the two-phase locking protocol, which is the first provably correct, provably serializable concurrency control protocol, developed by Jim Gray in the 1970s, that you can use to execute transactions and generate serializable schedules.
Sau đó chúng ta sẽ mô tả giao thức khóa hai pha (two-phase locking), đây là giao thức kiểm soát đồng thời đầu tiên được chứng minh là đúng đắn, tức là khả tuần tự hóa, do Jim Gray phát triển vào những năm 1970, và bạn có thể dùng nó để thực thi các giao dịch và tạo ra các lịch biểu khả tuần tự hóa.
Then we'll talk about how to handle deadlocks, either through detection or prevention. Then we'll finish up talking about hierarchical locking, where now I can expand the scope of locks.
Tiếp theo chúng ta sẽ nói về cách xử lý bế tắc, bằng cách phát hiện hoặc phòng ngừa. Sau đó chúng ta sẽ kết thúc với khóa phân cấp, trong đó giờ đây tôi có thể mở rộng phạm vi của các khóa.
And then we'll finish up with the flash talk from German at Firebolt.
Và cuối cùng chúng ta sẽ kết thúc bằng bài nói nhanh (flash talk) của German tại Firebolt.
So when we talked about latches, there was basically two different latches. It was either in read mode or write mode.
Khi chúng ta nói về latch, về cơ bản có hai loại latch khác nhau. Hoặc là ở chế độ đọc, hoặc là ở chế độ ghi.
With locks now, instead of calling it read and writes, we're going to call them shared and exclusive. And the compatibility matrix looks very similar to what we had before with latches.
Với khóa (lock) thì thay vì gọi là đọc và ghi, chúng ta sẽ gọi là khóa chia sẻ (shared) và khóa độc quyền (exclusive). Và ma trận tương thích trông rất giống với những gì chúng ta đã có trước đây với latch.
If you have a shared lock, another shared lock can take the same lock at the same time.
Nếu bạn có một khóa chia sẻ, thì một khóa chia sẻ khác có thể giữ cùng khóa đó cùng một lúc.
But as soon as I have an exclusive lock, no other lock type can take that lock at the same time as I am.
Nhưng ngay khi tôi có một khóa độc quyền, thì không loại khóa nào khác có thể giữ khóa đó cùng lúc với tôi.
Now, this is a gross simplification of how real systems actually work.
Đây là một sự đơn giản hóa quá mức so với cách các hệ thống thực tế hoạt động.
If you go read the documentation for any data system that supports locking, you're going to see there's a lot more lock types that they have. Now, for the MySQL one, there's these intention locks.
Nếu bạn đọc tài liệu của bất kỳ hệ quản trị dữ liệu nào hỗ trợ khóa, bạn sẽ thấy họ có nhiều loại khóa hơn rất nhiều. Với MySQL, có các khóa ý định (intention lock).
We'll get to those at the end of this lecture. But now you see in the case of Oracle, you can have locks on tables. You can have different row exclusives or not.
Chúng ta sẽ nói về chúng ở cuối bài giảng này. Còn với Oracle, bạn có thể thấy là có thể đặt khóa trên các bảng. Bạn có thể có các khóa độc quyền trên dòng khác nhau hoặc không.
It gets way more complicated. And so I'm not going to go through other than the intention locks at the end of this class. We'll go through those.
Nó phức tạp hơn rất nhiều. Vì vậy tôi sẽ không đi qua những loại này, ngoại trừ các khóa ý định ở cuối buổi học. Chúng ta sẽ đi qua những khóa đó.
But all these other lock types that are maybe specific to a different database system, they're going to have their own nuances, their own characteristics.
Nhưng tất cả các loại khóa khác này có thể đặc thù cho một hệ quản trị cơ sở dữ liệu khác, chúng sẽ có những sắc thái và đặc điểm riêng.
But the two-phase locking protocol and the hierarchical locking technique I'll show you at the end, this all still works with these extra lock types.
Nhưng giao thức khóa hai pha và kỹ thuật khóa phân cấp mà tôi sẽ trình bày ở cuối, tất cả vẫn hoạt động với các loại khóa bổ sung này.
It just sort of complicates how you actually would implement this. But the basic two-phase protocol, two-phase locking protocol will be the same.
Chỉ là nó làm phức tạp hơn cách bạn thực sự cài đặt. Nhưng giao thức hai pha cơ bản, giao thức khóa hai pha thì vẫn như vậy.
All right, so now when transactions are going to execute, before we can do any read or write to an object in the database, we have to request that we want to lock from the lock manager on that object.
Được rồi, giờ khi các giao dịch được thực thi, trước khi có thể đọc hoặc ghi bất kỳ đối tượng nào trong cơ sở dữ liệu, chúng ta phải yêu cầu khóa trên đối tượng đó từ bộ quản lý khóa (lock manager).
We can support upgrades.
Chúng ta có thể hỗ trợ nâng cấp khóa.
If I have a shared lock on an object and I know I'm going to need to update it, I can say, go back to lock managers, I already have the shared lock.
Nếu tôi có một khóa chia sẻ trên một đối tượng và biết rằng mình sẽ cần cập nhật nó, tôi có thể nói với bộ quản lý khóa rằng tôi đã có khóa chia sẻ rồi.
Can I upgrade it to an exclusive lock? And it'll know whether any transaction already holds a shared lock and would have to deny or allow that upgrade request.
Tôi có thể nâng cấp nó thành khóa độc quyền không? Và nó sẽ biết liệu có giao dịch nào đang giữ khóa chia sẻ hay không và sẽ phải từ chối hoặc chấp nhận yêu cầu nâng cấp đó.
And then as transactions keep running, they can decide to release the locks, return them back to the lock manager, and then implicitly when they commit, all the locks are released, or when they abort, all the locks are released.
Và khi các giao dịch tiếp tục chạy, chúng có thể quyết định giải phóng các khóa, trả lại cho lock manager, và ngầm định là khi commit, tất cả các khóa được giải phóng, hoặc khi abort, tất cả các khóa cũng được giải phóng.
So the lock manager is going to be maintaining its own, basically, hash table that keeps track of what locks exist and who holds them and queues for who's waiting to acquire a lock that's being held by somebody else right now.
Vì vậy lock manager sẽ tự duy trì về cơ bản là một bảng băm theo dõi những khóa nào đang tồn tại, ai đang giữ chúng, và các hàng đợi cho những giao dịch đang chờ để lấy một khóa mà hiện đang bị người khác giữ.
But the key thing is it's going to have a global view of what all the transactions that are running in the system and what locks do they hold and what locks are they waiting for.
Nhưng điểm mấu chốt là nó sẽ có một cái nhìn toàn cục về tất cả các giao dịch đang chạy trong hệ thống, chúng đang giữ những khóa nào và đang chờ những khóa nào.
Again, in all my examples here, for anything I open up in a terminal, I can show maybe two or three transactions at a time.
Một lần nữa, trong tất cả các ví dụ ở đây, với những gì tôi mở trong terminal, tôi chỉ có thể cho các em xem hai hoặc ba giao dịch cùng lúc.
In real high-end transactional systems, you can imagine doing 100,000 or even a million transactions per second. So you've got to maintain all this metadata for them, which can get quite expensive.
Trong các hệ thống giao dịch cao cấp thực tế, các em có thể hình dung là xử lý 100.000 thậm chí một triệu giao dịch mỗi giây. Vì vậy phải duy trì toàn bộ siêu dữ liệu này cho chúng, và việc đó có thể khá tốn kém.
But when we crash and come back, we don't have to worry about reviving the state of the lock table, because every transaction that was running is dead anyway, so you just wipe everything.
Nhưng khi hệ thống gặp sự cố rồi khởi động lại, ta không cần lo khôi phục trạng thái của bảng khóa, vì dù sao mọi giao dịch đang chạy cũng đã chết, nên ta chỉ việc xóa sạch mọi thứ.
It's not like we need to persist anything in a page directory or the actual data itself.
Không phải là ta cần lưu bền vững thứ gì đó trong page directory hay trong chính dữ liệu thực tế.
All right, so let's look at an example here. Again, so now we're going to have, instead of just lock on a lock, we'll have the lock type. It's either exclusive lock or shared lock.
Được rồi, hãy xem một ví dụ ở đây. Một lần nữa, bây giờ ta sẽ có, thay vì chỉ khóa chung chung, ta sẽ có loại khóa. Đó là khóa độc quyền hoặc khóa chia sẻ.
So T1 starts, it gets exclusive lock on A. That's allowed, so the lock manager grants it. Then there's the read on A, the write on A. Then it unlocks A, right?
Vậy T1 bắt đầu, nó lấy khóa độc quyền trên A. Điều đó được phép, nên lock manager cấp khóa. Sau đó là đọc A, ghi A. Rồi nó mở khóa A, đúng không?
And then it says it's released and then keeps on running. But then now T2 is going to start.
Và nó báo là đã giải phóng rồi tiếp tục chạy. Nhưng bây giờ T2 bắt đầu.
It's going to acquire the exclusive lock on A, then do the write on A, and then return the locks back on A to the lock manager.
Nó sẽ lấy khóa độc quyền trên A, rồi ghi A, và sau đó trả khóa trên A lại cho lock manager.
But then now T1 starts running again at the bottom here, and it gets the shared lock on A, reads A, but what's it going to see when it reads A?
Nhưng bây giờ T1 chạy tiếp ở phần dưới này, và nó lấy khóa chia sẻ trên A, đọc A, nhưng nó sẽ thấy gì khi đọc A?
A different value than it saw before, right? So it's going to see the value that T2 wrote when it started running, right?
Một giá trị khác với giá trị nó thấy trước đó, đúng không? Nó sẽ thấy giá trị mà T2 đã ghi khi T2 chạy, đúng không?
And not the value that it wrote when it had the lock before, right? So what is this called? You did this last class.
Chứ không phải giá trị mà nó đã ghi lúc trước khi còn giữ khóa, đúng không? Vậy hiện tượng này gọi là gì? Các em đã học ở buổi trước.
Unrepeatable read, right? Like, I expected to read something again to see the same value, but I didn't get it, right?
Unrepeatable read, đúng không? Tức là tôi mong đợi đọc lại sẽ thấy cùng một giá trị, nhưng lại không được như vậy, đúng không?
So the point I'm trying to find out here is that just because we have locks doesn't mean we magically get serializability, right?
Điều tôi muốn chỉ ra ở đây là có khóa không có nghĩa là ta tự nhiên có tính khả tuần tự, đúng không?
We've got to be careful in how we give out the locks and when we actually release them.
Ta phải cẩn thận trong cách cấp khóa và thời điểm thực sự giải phóng chúng.
So this is what the two-phase locking protocol does for us.
Và đây chính là điều mà giao thức khóa hai pha làm cho ta.
It's the way in which it defines how we're going to determine when a transaction can acquire a lock, and what happens when they start releasing those locks, and what can they do during that period.
Đó là cách nó định nghĩa việc chúng ta sẽ xác định khi nào một giao dịch có thể lấy được một khóa, và chuyện gì xảy ra khi giao dịch bắt đầu nhả các khóa đó, và giao dịch được phép làm gì trong giai đoạn ấy.
And as you'd expect in the name, two-phase locking, it has two phases, right?
Và đúng như tên gọi, khóa hai pha, nó có hai pha, đúng không?
And this is the pessimistic protocol we would use if we don't know what the transactions are going to do ahead of time. We don't know what queries they're going to run.
Đây là giao thức bi quan mà chúng ta sẽ dùng khi chúng ta không biết trước các giao dịch sẽ làm gì. Chúng ta không biết chúng sẽ chạy những truy vấn nào.
We don't know what data they're going to read and write to. So with this locking protocol, we handle that dynamic environment. We don't have everything ahead of time.
Chúng ta không biết chúng sẽ đọc và ghi dữ liệu nào. Vì vậy với giao thức khóa này, chúng ta xử lý được môi trường động như thế. Chúng ta không có sẵn mọi thông tin từ trước.
So the first phase in two-phase locking is called the growing phase.
Pha đầu tiên trong khóa hai pha được gọi là pha mở rộng (growing phase).
And this is where a transaction is allowed to request to the lock manager all the locks that it wants in any mode that it wants.
Đây là lúc một giao dịch được phép yêu cầu bộ quản lý khóa cấp mọi khóa nó muốn, ở bất kỳ chế độ nào nó muốn.
And the lock manager can grant or deny the request.
Và bộ quản lý khóa có thể chấp thuận hoặc từ chối yêu cầu.
If it denies it, again, it'll just stall and wait until that lock is available, or it gets aborted because of a deadlock or something else.
Nếu bị từ chối, giao dịch sẽ chỉ bị treo và chờ đến khi khóa đó sẵn sàng, hoặc bị hủy vì bế tắc hay một lý do nào khác.
But then as soon as a transaction releases one lock, it now automatically enters the shrinking phase, where you're not allowed to acquire any more locks.
Nhưng ngay khi một giao dịch nhả một khóa, nó tự động chuyển sang pha thu hẹp (shrinking phase), trong đó bạn không được lấy thêm khóa nào nữa.
The only thing you can do is give back the locks you got during the growing phase, right?
Việc duy nhất bạn có thể làm là trả lại các khóa đã lấy trong pha mở rộng, đúng không?
Now, the spoiler is going to be, again, I'm showing all these schedules with lock and unlock as commands within the schedules.
Giờ, tôi nói trước một điều, là tôi đang trình bày các lịch biểu này với lock và unlock như các lệnh nằm trong lịch biểu.
In actuality, you don't, in SQL, you can't manually acquire locks and unlock them. I'll explain what the implications of this are in a second.
Thực tế, trong SQL bạn không thể tự tay lấy khóa và mở khóa. Tôi sẽ giải thích hệ quả của điều này ngay sau đây.
But, you know, you can, I mean, for certain things, you can, in some systems, call, like, lock database and things like that.
Nhưng với một số việc nhất định thì bạn có thể, ở một số hệ thống, gọi những lệnh như khóa cơ sở dữ liệu và tương tự.
But, like, typically when you run queries, you don't say, like, "lock, lock object foo," and then run a query on object foo. It implicitly happens for you automatically.
Nhưng thông thường khi chạy truy vấn, bạn không nói kiểu "khóa, khóa đối tượng foo" rồi mới chạy truy vấn trên đối tượng foo. Việc đó diễn ra ngầm định và tự động cho bạn.
When you run a select query or any query you want, the DBMS says, "I know what you're trying to do because it's SQL and I can, it's declarative.
Khi bạn chạy một truy vấn select hay bất kỳ truy vấn nào, DBMS nói: "Tôi biết bạn đang muốn làm gì vì đây là SQL và tôi có thể biết, nó mang tính khai báo.
I know exactly what command you want." So therefore, it acquires the locks for you automatically. Unlocking is tricky. We'll cover that in a second.
Tôi biết chính xác bạn muốn lệnh gì." Vì vậy, nó tự động lấy các khóa cho bạn. Còn mở khóa thì phức tạp. Chúng ta sẽ nói về điều đó ngay sau đây.
So, again, the way to think about it visually is, think of this as, like, the lifetime of a transaction, right, from beginning to end.
Vậy cách hình dung trực quan là, hãy coi đây như vòng đời của một giao dịch, từ đầu đến cuối.
And in the first phase, I'm allowed to grow and acquire new locks. And think of, like, the height in the chart here, the y-axis, is the number of locks being held by a transaction.
Và ở pha đầu, tôi được phép mở rộng và lấy thêm khóa mới. Hãy coi chiều cao trong biểu đồ này, tức trục y, là số khóa mà giao dịch đang nắm giữ.
So I can grow, grow, grow, acquire more locks. But then at some point, I release a lock and then I enter the shrinking phase.
Vậy tôi có thể tăng, tăng, tăng, lấy thêm khóa. Nhưng đến một lúc nào đó, tôi nhả một khóa và chuyển sang pha thu hẹp.
And the only thing I can do is give locks back to the lock manager. Right?
Và việc duy nhất tôi làm được là trả khóa lại cho bộ quản lý khóa. Đúng không?
I can't do something like this, where I release a bunch of locks and then go back and ask for more locks, because then that can cause problems.
Tôi không thể làm kiểu thế này, là nhả một loạt khóa rồi quay lại xin thêm khóa, vì như vậy có thể gây ra vấn đề.
And so the protocol would not allow this.
Và vì thế giao thức sẽ không cho phép điều này.
So if I go back to my example that I had before, right, now using proper two-phase locking, T1 starts, it gets an exclusive lock on A, that's allowed to happen.
Vậy nếu quay lại ví dụ lúc trước, giờ ta áp dụng khóa hai pha đúng chuẩn, T1 bắt đầu, nó lấy khóa độc quyền trên A, điều này được phép.
So then it can do the read on A and then write on A.
Rồi nó có thể đọc A và sau đó ghi A.
And then it doesn't give up the lock that it has on A, right, because it still has to be able to read it down below.
Và nó không nhả khóa đang giữ trên A, vì nó vẫn cần đọc A ở phía dưới.
So I can't, again, I don't want to have that problem where I unlock it and then try to relock the same object.
Nên một lần nữa, tôi không muốn gặp vấn đề là mở khóa rồi lại cố khóa lại cùng đối tượng đó.
So now when T2 tries to get the exclusive lock on A, that gets denied and has to stall and wait until T1 finishes whatever it wants to do.
Giờ khi T2 cố lấy khóa độc quyền trên A, yêu cầu đó bị từ chối và phải dừng lại và chờ đến khi T1 làm xong những gì nó muốn.
And then as soon as T1 unlocks A, that releases the lock to T2, and then T2 can do the write on A and commit.
Và ngay khi T1 mở khóa A, khóa được chuyển cho T2, rồi T2 có thể ghi A và commit.
The question is, when I say the worker is waiting, what does that mean? You're waiting. Stalled. Yeah, you can't do anything. I mean, for simplicity, yes.
Câu hỏi là: khi tôi nói worker đang chờ thì điều đó nghĩa là gì? Bạn đang chờ. Bị treo. Đúng, bạn không thể làm gì cả. Ý tôi là, để đơn giản thì đúng vậy.
There's tricks to get around that, yes. Yes.
Có những mẹo để vượt qua điều đó, đúng vậy.
Their statement is, and they are correct, if you can't explicitly say you want to unlock and you don't know everything you need ahead of time, how can you actually unlock?
Ý của bạn ấy là, và bạn ấy nói đúng, nếu bạn không thể nói rõ là muốn mở khóa và không biết trước mọi thứ mình cần, thì thực sự làm sao mở khóa được?
We'll cover this in a second, yes. In actuality, there isn't really going to be a locking phase as we know it, as we described before.
Chúng ta sẽ nói về việc này ngay sau đây. Trên thực tế, sẽ không có một pha khóa theo đúng nghĩa như ta biết, như đã mô tả trước đó.
They're going to use a more stricter form, and we'll cover that in a second. So when systems say they're using two-phase locking, like SQL Server, you're going to have something more.
Họ sẽ dùng một dạng chặt chẽ hơn, và chúng ta sẽ nói về nó ngay sau đây. Vì vậy khi các hệ thống như SQL Server nói rằng họ dùng khóa hai pha, thì thực tế sẽ có thêm một thứ gì đó.
So by itself, two-phase locking is enough to guarantee that the schedules of the transactions you will generate in real time or run time running the system will be conflict serializable, meaning if you define the precedence graph, the dependency graph, you'll have no cycles.
Bản thân khóa hai pha là đủ để đảm bảo rằng các lịch biểu của những giao dịch mà bạn tạo ra theo thời gian thực hay khi hệ thống đang chạy sẽ khả tuần tự hóa xung đột, nghĩa là nếu bạn xác định đồ thị thứ tự trước sau, đồ thị phụ thuộc, thì sẽ không có chu trình.
You can guarantee that it'll be conflict serializable. But it is going to be subject to another problem called cascading aborts that isn't a correctness issue.
Bạn có thể đảm bảo nó khả tuần tự hóa xung đột. Nhưng nó sẽ gặp một vấn đề khác gọi là hủy dây chuyền, và đây không phải vấn đề về tính đúng đắn.
So it's not one of the anomalies like unrepeatable read, dirty reads, and lost updates we talked about last time.
Nó không phải một trong các dị thường như đọc không lặp lại, đọc dữ liệu bẩn, và mất cập nhật mà ta đã nói lần trước.
It's more of a performance issue, where if you implement it as defined in two-phase locking, not talking about the release at the end, as he's talking about now, that they were talking about, if you allow transactions to unlock objects in the middle of the transactions and still do more stuff,
Đó chủ yếu là vấn đề hiệu năng, khi bạn triển khai đúng như định nghĩa của khóa hai pha, chưa nói đến việc nhả khóa ở cuối, như bạn ấy đang nói, điều mà họ đã đề cập, nếu bạn cho phép giao dịch mở khóa các đối tượng ở giữa giao dịch và vẫn làm thêm việc khác,
they can't acquire new locks, but they still can do more stuff, then we can have this problem of cascading aborts. So it looks like this.
chúng không thể lấy khóa mới, nhưng vẫn có thể làm thêm việc, thì ta có thể gặp vấn đề hủy dây chuyền này. Nó trông như thế này.
So say now T1 wants to do a lock on A, executes a lock on A, then executes a lock on B, read A, write A, unlock A, then go read B and write B.
Giả sử T1 muốn khóa A, thực hiện khóa A, rồi khóa B, đọc A, ghi A, mở khóa A, sau đó đọc B và ghi B.
And at the bottom here, it's going to abort and roll back all its changes. So the problem is going to be with T2.
Và ở phía dưới này, nó sẽ hủy bỏ và khôi phục lại tất cả các thay đổi của mình. Vậy vấn đề sẽ nằm ở T2.
As soon as T1 releases the lock on A, T2 can get the exclusive lock on A, then it can read it and it can write it, and it's going to read the change that was made by T1.
Ngay khi T1 nhả khóa trên A, T2 có thể lấy khóa độc quyền trên A, rồi nó có thể đọc và ghi A, và nó sẽ đọc thay đổi do T1 thực hiện.
But then later on, T1 aborts, and then now we have, again, a dirty read here, where we read something that we shouldn't have seen, technically, because the transaction has committed, but it's still allowed under two-phase locking, right?
Nhưng sau đó, T1 bị hủy, và bây giờ chúng ta lại có một lần đọc dữ liệu bẩn ở đây, tức là chúng ta đọc một thứ mà về mặt kỹ thuật lẽ ra không nên thấy, vì giao dịch chưa được commit, nhưng điều này vẫn được phép theo khóa hai pha, đúng không?
There's just additional metadata we would keep track of in our system to say, well, T2 read something from T1 that T1 modified, but T1 hasn't committed yet, so I can't let T2 commit until I know whether T1 commits.
Chỉ là hệ thống sẽ phải theo dõi thêm một số siêu dữ liệu để nói rằng, T2 đã đọc thứ mà T1 sửa đổi, nhưng T1 vẫn chưa commit, nên tôi không thể cho T2 commit cho đến khi biết T1 có commit hay không.
In this case here, T1 does not commit. T2, therefore, and then T1 aborts, therefore T2 has to abort.
Trong trường hợp này, T1 không commit. Do đó T2, và vì T1 bị hủy nên T2 cũng phải hủy.
So this is what I mean by a cascading rollback, where a rollback of one transaction may cause other transactions to have to abort and rollback as well, because they read something from that uncommitted transaction, right?
Đây là điều tôi muốn nói bằng khôi phục dây chuyền, tức là việc khôi phục một giao dịch có thể khiến các giao dịch khác cũng phải hủy bỏ và khôi phục theo, vì chúng đã đọc thứ gì đó từ giao dịch chưa commit đó, đúng không?
And the reason why we can't allow T2 to commit here, we'd have to actually wait and to see, find out what happens about T1, is, again, we can't leak any information to the outside world about an uncommitted transaction, right?
Và lý do chúng ta không thể cho T2 commit ở đây, mà thực sự phải chờ để xem T1 sẽ ra sao, là vì một lần nữa, chúng ta không thể làm rò rỉ bất kỳ thông tin nào ra thế giới bên ngoài về một giao dịch chưa commit, đúng không?
I can't tell the client, here's what your data actually looks like, and then have it do something based on that information.
Tôi không thể nói với client rằng đây là dữ liệu thực sự của bạn, rồi để nó làm gì đó dựa trên thông tin ấy.
In the back, yes.
Bạn ở phía sau, mời.
The question is, how is this two-phase locking example, what, how does that solve the problem we did in the earlier lecture? So let's go back to the first example.
Câu hỏi là, ví dụ về khóa hai pha này, nó giải quyết vấn đề mà chúng ta đã làm ở bài giảng trước như thế nào? Vậy hãy quay lại ví dụ đầu tiên.
In the first example, right, the problem was I was acquiring a lock on A and then releasing a lock on A in T1. Come back here, right?
Trong ví dụ đầu tiên, vấn đề là tôi lấy khóa trên A rồi nhả khóa trên A trong T1. Quay lại đây nhé.
And then T1 did whatever, like it prompted LLM and has to wait, whatever, right? And then now control switch over to the T2. T2 starts running.
Và sau đó T1 làm gì đó, chẳng hạn như gửi prompt cho LLM và phải chờ, đại loại vậy. Rồi quyền điều khiển chuyển sang T2. T2 bắt đầu chạy.
It gets an exclusive lock on A, which is allowed to do because nobody holds the lock on A right now. It does it right and unlocks A. Control goes back to T1.
Nó lấy khóa độc quyền trên A, điều này được phép vì hiện giờ không ai giữ khóa trên A. Nó thực hiện xong và mở khóa A. Quyền điều khiển quay lại T1.
Now T1 gets the shared lock on A, which is allowed to do because nobody holds that. And then now when it reads it, it reads something that it didn't expect to see.
Bây giờ T1 lấy khóa chia sẻ trên A, điều này được phép vì không ai giữ khóa đó. Và khi đọc, nó đọc được thứ mà nó không mong đợi.
If they were running in true serial order, it'd either be T1 followed by T2 or T2 followed by T1.
Nếu chúng chạy theo đúng thứ tự tuần tự, thì sẽ là T1 rồi đến T2, hoặc T2 rồi đến T1.
In this scenario here with my interleaving, I'm seeing something from an intermediate state that I shouldn't see, right?
Trong kịch bản này với cách đan xen của tôi, tôi đang thấy một thứ từ trạng thái trung gian mà lẽ ra không nên thấy, đúng không?
So with two-phase locking, we avoid this problem because T1 would not be allowed to unlock A up above and then acquire it again.
Với khóa hai pha, chúng ta tránh được vấn đề này vì T1 sẽ không được phép mở khóa A ở trên rồi lại lấy nó lần nữa.
As soon as you enter the shrinking phase, you can never acquire new locks.
Ngay khi bạn bước vào pha thu hẹp, bạn không bao giờ được lấy thêm khóa mới.
The statement is you cannot release locks in the growing phase. As soon as you release one lock, you're now in the growing phase automatically. Sorry, what did I say?
Phát biểu là bạn không thể nhả khóa trong pha mở rộng. Ngay khi bạn nhả một khóa, bạn tự động chuyển sang pha thu hẹp. Xin lỗi, tôi đã nói gì vậy?
As soon as you release a lock in the growing phase, you're now in the shrinking phase automatically. Yes.
Ngay khi bạn nhả một khóa trong pha mở rộng, bạn sẽ tự động chuyển sang pha thu hẹp. Vâng.
Yeah, to the point, yes. They're correct.
Đúng rồi, đúng ý đó. Bạn ấy nói đúng.
What it really should be is like, I just put it in the middle, but it really should be as soon as I release one thing, it goes down, yes.
Thực ra nó nên là thế này, tôi chỉ đặt nó ở giữa, nhưng đúng ra là ngay khi tôi nhả một thứ, nó đi xuống, đúng vậy.
You're the first person to point that out in five years, so yes, we should fix that. Think of it really like this.
Bạn là người đầu tiên chỉ ra điều đó trong năm năm qua, nên đúng, chúng ta nên sửa lại. Hãy hình dung nó thế này.
Again, without the hump going up, that can't happen, but as soon as I release one, the number of locks goes down and now I'm in the shrinking phase.
Một lần nữa, nếu không có đoạn đi lên thì điều đó không thể xảy ra, nhưng ngay khi tôi nhả một khóa, số lượng khóa giảm xuống và tôi đã ở trong pha thu hẹp.
This one's a violation. You can't do this.
Cái này là vi phạm. Bạn không thể làm thế này.
Okay, So again, this problem here where if we, under two-phase locking, you can read data from uncommitted transactions because maybe you assume that they're going to commit, but you get to maintain metadata and say, this transaction read something from a transaction that hasn't committed, therefore I can't commit until I find out whether they commit.
Được rồi, vậy vấn đề ở đây, nếu chúng ta, với khóa hai pha, bạn có thể đọc dữ liệu từ các giao dịch chưa commit vì có thể bạn giả định rằng chúng sẽ commit, nhưng bạn phải duy trì siêu dữ liệu và ghi rằng, giao dịch này đã đọc thứ gì đó từ một giao dịch chưa commit, do đó tôi không thể commit cho đến khi biết giao dịch kia có commit hay không.
And therefore, if the transaction that I read their uncommitted read from aborts, I have to abort as well. So this is the cascading rollback problem.
Và do đó, nếu giao dịch mà tôi đã đọc dữ liệu chưa commit của nó bị abort, thì tôi cũng phải abort. Đây là vấn đề rollback dây chuyền.
And so the challenge is going to be, again, for two transactions, no big deal, but in a real system, if I now have thousands of transactions that depend on this other transaction and that other transaction aborts, I have to abort all those other transactions and it's a bunch of wasted work.
Và thách thức ở đây, một lần nữa, với hai giao dịch thì không đáng kể, nhưng trong một hệ thống thực tế, nếu giờ tôi có hàng nghìn giao dịch phụ thuộc vào giao dịch kia và giao dịch đó bị abort, thì tôi phải abort tất cả các giao dịch còn lại và đó là một đống công việc bị lãng phí.
And you're basically burning cycles and doing IO for things that never actually commit and get any real work done. Yes.
Về cơ bản bạn đang đốt chu kỳ CPU và thực hiện IO cho những thứ không bao giờ được commit và không tạo ra công việc thực sự nào. Vâng.
The question is, in my example here, how does transaction T2 know that it needs to roll back because it read something from T1?
Câu hỏi là, trong ví dụ của tôi, làm sao giao dịch T2 biết rằng nó cần rollback vì đã đọc thứ gì đó từ T1?
There's extra metadata you're maintaining in the system for this, which is not showing in the PowerPoint. In the back.
Hệ thống duy trì thêm siêu dữ liệu cho việc này, cái này không hiển thị trong slide PowerPoint. Bạn ở phía sau.
So the question is, how did T1, T2 acquire the lock on A? Shouldn't T2 be shrinking?
Câu hỏi là, T1, T2 lấy khóa trên A bằng cách nào? T2 không phải đang ở pha thu hẹp sao?
Yes, but it released the lock on A, not the lock on B. It still has the lock on B. Right? So it can still do whatever it wants after that point.
Đúng, nhưng nó nhả khóa trên A, chứ không phải khóa trên B. Nó vẫn còn giữ khóa trên B. Đúng không? Nên sau thời điểm đó nó vẫn có thể làm bất cứ gì nó muốn.
It can still do reads and writes. Just because you're in the shrinking phase doesn't mean you can't do other things. You can do things on the locks you hold.
Nó vẫn có thể đọc và ghi. Việc bạn ở pha thu hẹp không có nghĩa là bạn không thể làm những việc khác. Bạn có thể thao tác trên các khóa mà bạn đang giữ.
You just can't acquire new locks.
Bạn chỉ không thể lấy thêm khóa mới.
Yeah. Yeah. So their statement is, the notion of what phase I'm in is in a per transaction basis, not globally in the system.
Vâng. Vâng. Vậy ý bạn ấy là, khái niệm tôi đang ở pha nào được xét theo từng giao dịch, chứ không phải trên toàn hệ thống.
Correct. Yes. So T1 has its own, am I in the growing phase or the shrinking phase? T2 and whatever transaction, they have their own phases. It isn't for the entire system. Okay.
Chính xác. Vâng. T1 có pha riêng của nó: tôi đang ở pha mở rộng hay pha thu hẹp? T2 và bất kỳ giao dịch nào khác đều có các pha riêng của chúng. Nó không áp dụng cho toàn bộ hệ thống. Được rồi.
So, the thing to point out here now though, this means that if we, what is this?
Vậy điều cần chỉ ra ở đây là, điều này có nghĩa là nếu chúng ta, cái này là gì nhỉ?
There are maybe scenarios where we could actually have schedules of transactions that are actually serializable, but because the two-phase locking protocol is pessimistic, meaning if they assume they're gonna have aborts, and so you assume you're gonna have conflicts and therefore you require everyone to acquire locks before they can do anything.
Có thể có những tình huống mà chúng ta thực sự có các lịch biểu giao dịch vốn dĩ khả tuần tự hóa (serializable), nhưng vì giao thức khóa hai pha (two-phase locking) mang tính bi quan, nghĩa là nó giả định rằng sẽ có các lần hủy bỏ (abort), và do đó giả định rằng sẽ có xung đột, nên nó yêu cầu mọi người phải lấy khóa trước khi làm bất cứ việc gì.
There may actually be scenarios where you could actually have better parallelism and better performance, but if you follow two-phase locking as defined, you end up giving that up.
Thực ra có thể có những tình huống mà ta có thể đạt được tính song song tốt hơn và hiệu năng tốt hơn, nhưng nếu tuân theo khóa hai pha đúng như định nghĩa thì ta phải từ bỏ điều đó.
Again, that's okay because if it's running anything that's super critical, like with money, like your bank account, you don't want to have, you don't really care that the database is faster if it ends up losing money, like your money.
Một lần nữa, điều đó vẫn ổn, vì nếu hệ thống xử lý những thứ cực kỳ quan trọng, như tiền bạc, chẳng hạn tài khoản ngân hàng của bạn, thì bạn không muốn, bạn thực sự không quan tâm cơ sở dữ liệu nhanh hơn nếu cuối cùng nó làm mất tiền, tiền của bạn.
So that's why transactional systems that are gonna be doing two-phase locking or the other protocol we'll talk about next class, they're gonna choose correctness, typically, over performance.
Đó là lý do các hệ thống giao dịch dùng khóa hai pha hoặc giao thức khác mà chúng ta sẽ nói ở buổi sau, thường sẽ chọn tính đúng đắn hơn là hiệu năng.
The default, though, when we talk about isolation levels, the default isn't actually gonna be serializable in most systems.
Tuy nhiên, khi nói về các mức cô lập (isolation level), mức mặc định ở hầu hết các hệ thống thực ra không phải là serializable.
It's gonna be a lower form where you can have some problems, and it turns out sometimes that's okay. And banks really don't do updates in place.
Nó là một mức thấp hơn, nơi có thể xảy ra một số vấn đề, và hóa ra đôi khi điều đó vẫn chấp nhận được. Và các ngân hàng thực ra không cập nhật tại chỗ.
They always have a ledger where you're writing all the transactions and then they do summations.
Họ luôn có một sổ cái, nơi ghi lại tất cả các giao dịch rồi sau đó họ tính tổng.
So banks are not the perfect example for this, but just think anything with money, you don't want to have incorrect issues.
Vì vậy ngân hàng không phải ví dụ hoàn hảo, nhưng cứ nghĩ đến bất cứ thứ gì liên quan đến tiền, bạn không muốn có sai sót.
All right, so with two-phase locking, again, we can still have dirty reads, but again, we have to maintain metadata about what transactions read from what data from what other transactions so that if one transaction aborts, we roll back, and that's the cascading abort problem.
Được rồi, với khóa hai pha, ta vẫn có thể có đọc bẩn (dirty read), nhưng một lần nữa, ta phải duy trì siêu dữ liệu về việc giao dịch nào đã đọc dữ liệu nào từ những giao dịch nào khác, để nếu một giao dịch bị hủy bỏ thì ta khôi phục lại (rollback), và đó là vấn đề hủy bỏ dây chuyền (cascading abort).
One solution to that will be the strong, strict two-phase locking, which is what they were asking about.
Một giải pháp cho vấn đề đó là khóa hai pha chặt chẽ mạnh (strong strict two-phase locking), chính là điều mà bạn ấy đã hỏi.
And then, of course, we can still have deadlocks because now we're allowing transactions to acquire locks for any object they want, And you may have dependencies between two of them, and we have to handle that.
Và tất nhiên, ta vẫn có thể có bế tắc, vì bây giờ ta cho phép các giao dịch lấy khóa trên bất kỳ đối tượng nào chúng muốn, và có thể có sự phụ thuộc giữa hai giao dịch, và ta phải xử lý điều đó.
So we'll tackle the first problem: how do we handle dirty reads and this cascading abort problem? And then we'll talk about how we want to handle deadlocks.
Vậy ta sẽ giải quyết vấn đề đầu tiên: làm thế nào xử lý đọc bẩn và vấn đề hủy bỏ dây chuyền này? Sau đó ta sẽ nói về cách xử lý bế tắc.
So again, bringing back up the point that they brought up, every system that I'm aware of that does two-phase locking, the way it's actually going to be implemented is not the protocol where you have this notion of a shrinking phase where you can incrementally unlock things as you go along.
Vậy, nhắc lại điểm mà bạn ấy đã nêu, mọi hệ thống mà tôi biết có dùng khóa hai pha, cách chúng thực sự được triển khai không phải là giao thức có khái niệm pha thu hẹp (shrinking phase) nơi bạn có thể mở khóa dần từng thứ trong quá trình chạy.
Instead, they're re-implementing what's called strong strict two-phase locking, where the shrinking phase basically just happens at the end, meaning at some point I say, "All right, I've acquired all the locks that I need," and then I hold all those locks until I go commit, and then all of them are released.
Thay vào đó, chúng triển khai cái gọi là khóa hai pha chặt chẽ mạnh, trong đó pha thu hẹp về cơ bản chỉ xảy ra ở cuối, nghĩa là đến một lúc nào đó tôi nói: "Được rồi, tôi đã có được tất cả các khóa mà mình cần," rồi tôi giữ tất cả các khóa đó cho đến khi commit, và sau đó tất cả chúng được giải phóng.
And this avoids the dirty read problem because I'm never going to release a lock on something that I've modified, and therefore someone else can go read it.
Cách này tránh được vấn đề dirty read vì tôi sẽ không bao giờ nhả khóa trên thứ mà tôi đã sửa đổi, để rồi người khác có thể đọc nó.
They can't read anything until I fully have committed. So at the end is when everything gets released.
Họ không thể đọc gì cho đến khi tôi commit xong hoàn toàn. Vì vậy, đến cuối cùng mọi thứ mới được giải phóng.
Like the shrinking phase is just like this little blip at the end, yes, but I'm just trying to visually show what it looks like.
Giai đoạn co lại chỉ như một khoảnh khắc nhỏ ở cuối, vâng, nhưng tôi chỉ đang cố minh họa trực quan xem nó trông như thế nào.
So there is a less restrictive form of this protocol called strict two-phase locking, so not strong strict, just strict. I'll explain what strict is in the next slide.
Vậy có một dạng ít hạn chế hơn của giao thức này gọi là strict two-phase locking, tức là không phải strong strict, mà chỉ là strict. Tôi sẽ giải thích strict là gì ở slide tiếp theo.
We are allowed to release the exclusive locks before a transaction commits, but you still hold all the shared locks.
Chúng ta được phép nhả các khóa độc quyền trước khi giao dịch commit, nhưng vẫn giữ tất cả các khóa chia sẻ.
And again, that allows you to release things and to maybe sort of free up more opportunities for other transactions to run, but it still has the dirty read problem.
Và một lần nữa, điều đó cho phép bạn nhả bớt mọi thứ và có thể giải phóng thêm cơ hội cho các giao dịch khác chạy, nhưng nó vẫn có vấn đề dirty read.
So strictest means that if a value is written by a transaction, then it's not going to be read or overwritten by any other transaction until the transaction that modified that object has committed.
Vậy strict nghĩa là nếu một giá trị được một giao dịch ghi, thì nó sẽ không bị đọc hay ghi đè bởi bất kỳ giao dịch nào khác cho đến khi giao dịch đã sửa đối tượng đó commit xong.
So again, this avoids the cascading abort problem, and it actually makes undoing changes of aborted transactions really easy, because you don't have to worry about this dependency chain of, like, undoing this, followed by undoing this, followed by undoing this.
Một lần nữa, điều này tránh được vấn đề cascading abort, và nó khiến việc hoàn tác thay đổi của các giao dịch bị hủy trở nên rất dễ, vì bạn không phải lo về chuỗi phụ thuộc kiểu hoàn tác cái này, rồi hoàn tác cái này, rồi lại hoàn tác cái này.
You just say, here's the last version of this value of this object that the transaction modified, and you just undo that one.
Bạn chỉ cần nói: đây là phiên bản cuối cùng của giá trị của đối tượng này mà giao dịch đã sửa, và bạn chỉ hoàn tác đúng phiên bản đó.
And so any data system that's doing two-phase locking and supports serializable transactions is going to be doing strong strict 2PL, because there's no explicit way to unlock things in SQL.
Và vì vậy, bất kỳ hệ thống dữ liệu nào dùng two-phase locking và hỗ trợ các giao dịch serializable đều sẽ dùng strong strict 2PL, vì trong SQL không có cách tường minh để mở khóa.
Strong means you hold everything, the right locks, sorry, the exclusive locks and the shared locks. If it's just strict, you can release the exclusive but keep the shared.
Strong nghĩa là bạn giữ mọi thứ, các khóa ghi, xin lỗi, các khóa độc quyền và các khóa chia sẻ. Nếu chỉ là strict, bạn có thể nhả khóa độc quyền nhưng giữ khóa chia sẻ.
I think for your rights, yes. So strong strict avoids cascading aborts.
Tôi nghĩ với quyền ghi của bạn, vâng. Vậy strong strict tránh được cascading abort.
Strict 2PL still can happen.
Strict 2PL thì vẫn có thể xảy ra.
Correct, yes. And I think a textbook might also call them rigorous, but it all means the same thing.
Đúng vậy, vâng. Và tôi nghĩ sách giáo khoa cũng có thể gọi chúng là rigorous, nhưng tất cả đều có cùng một ý nghĩa.
Strict 2PL by itself, you keep the shared locks to the end, but you can release the exclusive locks in the shrinking phase.
Với strict 2PL riêng lẻ, bạn giữ các khóa chia sẻ đến cuối, nhưng có thể nhả các khóa độc quyền trong giai đoạn co lại.
Yes. Let me follow up on Piazza. I might be flipping the order, right?
Vâng. Để tôi trả lời tiếp trên Piazza. Có thể tôi đang nói đảo thứ tự, đúng không?
The main thing I want you to understand is, like, with strong strict, you definitely hold everything to the end, and then in a lesser form of strong strict, strict 2PL, you're releasing one type of lock.
Điều chính tôi muốn các bạn hiểu là, với strong strict, chắc chắn bạn giữ mọi thứ đến cuối, và rồi ở một dạng nhẹ hơn của strong strict, là strict 2PL, bạn chỉ nhả một loại khóa.
And I might have that reversed, I apologize. Let me follow up on that. All right, so let's look at an example here of doing strong strict 2PL.
Có thể tôi nói ngược rồi, xin lỗi các bạn. Để tôi xác nhận lại sau. Được rồi, bây giờ hãy xem một ví dụ về strong strict 2PL.
So we want to take $100 out of DJ Cash's account and move it to his bookie's account or his tax accountant's account.
Giả sử ta muốn rút $100 từ tài khoản của DJ Cash và chuyển sang tài khoản của người cá cược hoặc kế toán thuế của anh ấy.
And then in another transaction, we're going to do that summation we had before. We're just going to read A, read B, and then just spit out the summation of the two.
Và trong một giao dịch khác, ta sẽ thực hiện phép tính tổng như lúc trước. Ta chỉ đọc A, đọc B, rồi in ra tổng của hai giá trị đó.
So I'm going to show an example: if you don't do this with 2PL, what happens? And then if we use regular 2PL, what happens? And then what happens when we use strong, strict 2PL?
Tôi sẽ minh họa: nếu không dùng 2PL thì chuyện gì xảy ra? Rồi nếu dùng 2PL thông thường thì sao? Và khi dùng strong strict 2PL thì sao?
So if we don't do any 2PL, we're going to have a schedule like this where we start T1, right?
Vậy nếu không dùng 2PL, ta sẽ có một lịch thực thi như thế này, bắt đầu với T1, đúng không?
It gets an exclusive lock on A, then it does a read on A, then T2 tries to get the share lock on A, but because T1 holds the exclusive lock on A, it's going to get blocked and wait.
Nó lấy khóa độc quyền trên A, rồi đọc A, sau đó T2 cố lấy khóa chia sẻ trên A, nhưng vì T1 đang giữ khóa độc quyền trên A nên T2 bị chặn và phải chờ.
And then control goes back to T1, it does the update on A and writes it to the database, and then it unlocks A, at which point this now releases the lock to T2.
Rồi quyền điều khiển quay lại T1, nó cập nhật A và ghi vào cơ sở dữ liệu, rồi mở khóa A, lúc này khóa được nhả cho T2.
So T2 can read A, right? And now it's going to read the change that T1 made.
Vậy T2 có thể đọc A, đúng không? Và giờ nó sẽ đọc thay đổi mà T1 đã thực hiện.
Then it unlocks A, takes a share lock on B, reads B, but then now when T1 tries to get the exclusive lock on B to update it to put the $100 back into B's account, it gets paused and blocked because it can't get the exclusive lock on B.
Sau đó nó mở khóa A, lấy khóa chia sẻ trên B, đọc B, nhưng lúc này khi T1 cố lấy khóa độc quyền trên B để cập nhật, đưa $100 vào tài khoản B, nó bị tạm dừng và chặn vì không lấy được khóa độc quyền trên B.
Control goes back to T2, T2 releases that lock, spits out the output of A plus B, and then now we do the update on B, unlock it, commit.
Quyền điều khiển quay lại T2, T2 nhả khóa đó, in ra kết quả A cộng B, rồi sau đó ta cập nhật B, mở khóa, commit.
But then again, just like before in our example, we were missing money, we're missing $100 in our summation from T2's output because we read A after we took the money out, and then we read B before the money was put in, right?
Nhưng một lần nữa, giống như ví dụ trước, ta bị thiếu tiền, tổng trong kết quả của T2 bị thiếu $100 vì ta đọc A sau khi tiền đã bị rút ra, và đọc B trước khi tiền được chuyển vào, đúng không?
So this again, this would not have happened if it was running T1 followed by T2 or T2 followed by T1 in a serial ordering.
Vậy nên một lần nữa, điều này sẽ không xảy ra nếu chạy T1 rồi đến T2 hoặc T2 rồi đến T1 theo thứ tự tuần tự.
So now if I do two-phase locking, same thing starts, I get the T2, sorry, T1 starts, gets exclusive lock on A, does a read on A, and then when T2 tries to get the share lock on A, it gets paused and waits.
Bây giờ nếu dùng khóa hai pha, bắt đầu giống như vậy, T1 bắt đầu, lấy khóa độc quyền trên A, đọc A, rồi khi T2 cố lấy khóa chia sẻ trên A, nó bị tạm dừng và chờ.
Now I get the exclusive lock, update A, do the write to A, get the exclusive lock on B, and now I can unlock A, which I'm allowed to do in two-phase locking because now I'm in the shrinking phase for T1.
Giờ tôi lấy khóa độc quyền, cập nhật A, ghi A, lấy khóa độc quyền trên B, và bây giờ tôi có thể mở khóa A, điều này được phép trong khóa hai pha vì lúc này T1 đang ở pha co lại.
So then T2 could start running, does the read on A, tries to get the share lock on B, that gets blocked because T1 has that.
Sau đó T2 có thể bắt đầu chạy, đọc A, cố lấy khóa chia sẻ trên B, nhưng bị chặn vì T1 đang giữ khóa đó.
So then control goes back to T1, does the read on A, adds the $100 to it, writes it out, unlocks B, and then T2 can run and produces the correct result, right?
Quyền điều khiển quay lại T1, nó đọc B, cộng thêm $100, ghi ra, mở khóa B, rồi T2 có thể chạy và cho ra kết quả đúng, phải không?
The key thing is, again, the T1 acquired all the locks that it needed, and as soon as it unlocked A, then it can't acquire a new one.
Điểm mấu chốt, một lần nữa, là T1 đã lấy tất cả các khóa mà nó cần, và ngay khi nó mở khóa A, thì nó không thể lấy thêm khóa mới nữa.
Now with strong, strict 2PL, this one is basically comes down to being serial ordering, at least for this example here, right?
Bây giờ với strong strict 2PL, về cơ bản trường hợp này quy về thứ tự tuần tự, ít nhất là với ví dụ này, đúng không?
Because T2 is going to try to get the share lock on A, but it's going to get denied because T1 got it first, and T1's not going to release that share lock until it commits, right?
Vì T2 sẽ cố lấy khóa chia sẻ trên A, nhưng sẽ bị từ chối vì T1 đã lấy trước, và T1 sẽ không nhả khóa chia sẻ đó cho đến khi commit, đúng không?
And then it does the read on A, then tries to get the share lock on B.
Rồi nó đọc A, sau đó cố lấy khóa chia sẻ trên B.
At this point, T1 has already released that lock, so it's allowed to get it and then finish its processing and then produce the correct result.
Lúc này, T1 đã nhả khóa đó rồi, nên nó được phép lấy khóa và sau đó hoàn tất quá trình xử lý và cho ra kết quả đúng.
Yes? The question is, shouldn't the unlock happen after the commit?
Vâng? Câu hỏi là: mở khóa chẳng phải nên xảy ra sau commit sao?
Like... How does this... I'm starting in PowerPoint, but yes. And again, this is why there's no explicit unlock command. When you call commit, then, like, unlocking happens as all part of it.
Kiểu như... Cái này... Tôi đang làm trong PowerPoint, nhưng đúng vậy. Và một lần nữa, đây là lý do không có lệnh unlock tường minh. Khi bạn gọi commit, việc mở khóa diễn ra như một phần của nó.
It's part of the commit.
Nó là một phần của commit.
So the way to go think about, again, what the 2PL stuff provides for us in the context of the universe of schedules we could possibly have.
Vậy cách để suy nghĩ về điều này, một lần nữa, là 2PL mang lại cho chúng ta những gì trong bối cảnh của toàn bộ các lịch biểu mà ta có thể có.
Remember, we had serial in the middle, and around that encompassing it is conflict serializable schedules, and around that are view serializable schedules.
Nhớ rằng, ở giữa là lịch tuần tự, bao quanh nó là các lịch khả tuần tự theo xung đột, và bao quanh đó là các lịch khả tuần tự theo view.
So then now, this region here are going to be schedules that do not allow for cascading aborts. And some of them will be, you know, view serializable, conflict serializable, or even serial.
Vậy bây giờ, vùng này sẽ là các lịch biểu không cho phép hủy dây chuyền (cascading abort). Và một số trong đó sẽ là, khả tuần tự theo view, theo xung đột, hoặc thậm chí tuần tự.
And some of them just aren't. Right? And then, more narrowly, inside of conflict serializable is going to be where strong strict 2PL exists.
Và một số thì không. Đúng không? Và hẹp hơn nữa, bên trong khả tuần tự theo xung đột là nơi strong strict 2PL tồn tại.
And around that, you can think of, like, even more broadly would be where 2PL exists. But in the case of strong strict 2PL, none of those schedules will have cascading aborts.
Và bao quanh đó, bạn có thể nghĩ, rộng hơn nữa sẽ là nơi 2PL tồn tại. Nhưng với strong strict 2PL, không lịch biểu nào trong đó có hủy dây chuyền.
Okay? All right. So now we go back to the second issue we talked about of, you know, we now know how to handle the dirty read problem with strong strict 2PL.
Được chứ? Được rồi. Giờ ta quay lại vấn đề thứ hai mà ta đã nói, ta đã biết cách xử lý vấn đề đọc dữ liệu bẩn bằng strong strict 2PL.
Now we have to handle deadlocks. Right? Again, this is the classic concurrent programming 101 stuff. Right? T1 starts because it's locked on A. That's allowed to happen.
Giờ ta phải xử lý bế tắc. Đúng không? Đây là kiến thức nhập môn lập trình đồng thời kinh điển. Đúng không? T1 bắt đầu vì nó khóa A. Điều đó được phép.
T2 wants to get a shared lock on B. That's allowed to happen. But now when T2 tries to get the shared lock on A, that gets denied because T1 already holds it.
T2 muốn lấy khóa chia sẻ trên B. Điều đó được phép. Nhưng giờ khi T2 cố lấy khóa chia sẻ trên A, nó bị từ chối vì T1 đang giữ khóa đó.
But then later on, T1 tries to get the shared lock on B, and that gets denied because T2 holds it. So of course, now we have, again, a classic deadlock.
Nhưng sau đó, T1 cố lấy khóa chia sẻ trên B, và bị từ chối vì T2 đang giữ. Vậy tất nhiên, giờ ta có một bế tắc kinh điển.
We have two transactions that both hold locks, and they're waiting for locks held by the other transaction. And therefore, they're never going to get released.
Ta có hai giao dịch đều đang giữ khóa, và chúng đang chờ các khóa do giao dịch kia giữ. Và do đó, chúng sẽ không bao giờ được nhả.
So deadlock, obviously, is just, again, a cycle and a dependencies between the locks that transactions hold and the locks that they want to acquire.
Vậy bế tắc, rõ ràng, chỉ là một chu trình phụ thuộc giữa các khóa mà các giao dịch đang giữ và các khóa mà chúng muốn lấy.
And they're just waiting for the other one to release it.
Và chúng chỉ đang chờ giao dịch kia nhả khóa ra.
So the two ways we're going to handle this is through either deadlock detection, where we have an active mechanism goes and says, I'm finding the deadlocks.
Vậy có hai cách chúng ta sẽ xử lý chuyện này: hoặc là phát hiện bế tắc (deadlock detection), trong đó ta có một cơ chế chủ động đi tìm và nói: tôi đang tìm các bế tắc.
Let me go kill something to go break it.
Để tôi đi "giết" một thứ gì đó để phá vỡ nó.
Or deadlock prevention, where when a transaction tries to acquire a lock, based on an ordering protocol, A priority protocol, we will determine who is allowed to wait for a lock and who has to give up a lock and abort and restart.
Hoặc là ngăn ngừa bế tắc (deadlock prevention), trong đó khi một giao dịch cố lấy một khóa, dựa trên một giao thức thứ tự, một giao thức ưu tiên, ta sẽ xác định ai được phép chờ một khóa và ai phải nhả khóa, hủy bỏ rồi khởi động lại.
And the thing I'll say is that this is where, again, another distinction between the high-end expensive systems, like the Oracles, like the DB2s.
Và điều tôi muốn nói là đây chính là chỗ lại có thêm một điểm khác biệt giữa các hệ thống cao cấp, đắt tiền, như Oracle, như DB2.
These systems are actually going to support both of these methods, versus, like, MySQL, I think, only has one of them.
Những hệ thống này thực ra hỗ trợ cả hai phương pháp, trong khi, chẳng hạn, MySQL thì tôi nghĩ chỉ có một trong hai.
And as a human operator or administrator of these systems, you can toggle the runtime knobs or parameters to determine which of these ones you want to use for your transactions.
Và với tư cách là người vận hành hay quản trị viên của các hệ thống này, bạn có thể bật tắt các tham số lúc chạy để quyết định bạn muốn dùng phương pháp nào cho các giao dịch của mình.
Because it's going to depend on what the workload is, what the hardware is, which one of these is actually going to be better.
Vì điều đó sẽ phụ thuộc vào khối lượng công việc, vào phần cứng, phương pháp nào thực sự sẽ tốt hơn.
So for deadlock detection, the way this is going to work is that the lock manager is going to maintain what's called a waits-for graph.
Với phát hiện bế tắc, cách hoạt động là trình quản lý khóa sẽ duy trì một thứ gọi là đồ thị chờ (waits-for graph).
It's basically equivalent to the dependency graph of what transactions are waiting for locks held by other transactions.
Về cơ bản nó tương đương với đồ thị phụ thuộc cho biết giao dịch nào đang chờ các khóa do giao dịch khác giữ.
And if now the system detects that there's a cycle in this graph, you know there's a deadlock.
Và nếu bây giờ hệ thống phát hiện có một chu trình trong đồ thị này, bạn biết là có bế tắc.
And therefore, it has to then deploy some mechanism to decide, or protocol to decide, which transaction does it want to abort and kill so that it breaks the deadlock and the transactions can keep on running.
Và do đó, nó phải dùng một cơ chế nào đó để quyết định, hay một giao thức để quyết định, giao dịch nào nó muốn hủy bỏ và "giết" để phá vỡ bế tắc và các giao dịch có thể tiếp tục chạy.
And so the challenge is going to be how aggressive you want the data system to be in looking for these deadlocks. Again, for two transactions, three transactions, no big deal.
Vì vậy thách thức là bạn muốn hệ thống dữ liệu tích cực đến mức nào trong việc tìm các bế tắc này. Một lần nữa, với hai hay ba giao dịch thì không có gì to tát.
But think of, like, tens of thousands of transactions with very complex dependency graphs, waits-for graphs. You can pick your favorite cycle detection algorithm, but sometimes those aren't cheap to run.
Nhưng hãy nghĩ đến hàng chục nghìn giao dịch với các đồ thị phụ thuộc, đồ thị chờ rất phức tạp. Bạn có thể chọn thuật toán phát hiện chu trình ưa thích, nhưng đôi khi chúng chạy không rẻ.
So if you're trying to check for a deadlock every millisecond, you're basically burning cycles looking for deadlocks where you could be using those resources to actually execute transactions.
Nếu bạn cố kiểm tra bế tắc mỗi mili giây, về cơ bản bạn đang đốt chu kỳ CPU để tìm bế tắc trong khi lẽ ra có thể dùng những tài nguyên đó để thực thi giao dịch.
But if I only run it every five minutes, Then I may have transactions sitting around for four minutes, 59 seconds because of a deadlock, and waiting for the next time the cycle detector goes through and it finds a deadlock.
Nhưng nếu tôi chỉ chạy nó mỗi năm phút, thì có thể các giao dịch nằm chờ suốt bốn phút, 59 giây vì một bế tắc, và chờ đến lần tiếp theo bộ phát hiện chu trình chạy qua và tìm ra bế tắc.
So how to balance how aggressive you want to be in breaking the deadlocks versus how quickly you want to release them and get transactions running again, there isn't one answer.
Vậy việc cân bằng giữa mức độ tích cực khi phá bế tắc với việc bạn muốn giải phóng chúng nhanh đến đâu và cho các giao dịch chạy lại, không có một đáp án duy nhất.
And this is what, again, the high-end systems allow you to do, these things. So the basic protocol is pretty straightforward.
Và đây chính là điều mà các hệ thống cao cấp cho phép bạn tinh chỉnh. Vậy giao thức cơ bản khá đơn giản.
Every time that there's a transaction that's waiting for a lock being held by another transaction, I just add an edge for my waits-for graph here.
Mỗi khi có một transaction đang chờ một khóa đang bị transaction khác giữ, thì tôi chỉ cần thêm một cạnh vào đồ thị waits-for ở đây.
And I know what locks transactions hold because it's in my transaction, it's my lock manager in that hash table.
Và tôi biết transaction nào đang giữ khóa nào vì nó nằm trong bảng băm của trình quản lý khóa (lock manager) của tôi.
And I know what transactions they're trying to, I know what locks transactions are requesting because, again, I have my queues and my lock manager keeps track of what they're waiting for.
Và tôi cũng biết các transaction đang cố lấy, tôi biết các transaction đang yêu cầu khóa nào, bởi vì như đã nói, tôi có các hàng đợi và lock manager theo dõi xem chúng đang chờ cái gì.
So, again, say here, T2 wants to lock on C, but T3 holds that, so you have an edge from 2 to 3, T2 to T3.
Vậy ví dụ ở đây, T2 muốn khóa C, nhưng T3 đang giữ nó, nên có một cạnh từ 2 sang 3, tức T2 sang T3.
And then now T3 wants to lock on A, but that's being held by T1. So, again, I have a deadlock.
Rồi giờ T3 muốn khóa A, nhưng A đang bị T1 giữ. Như vậy là tôi có một bế tắc.
So when we detect this, I'll say also, too, a simple way you would do this is the detection algorithm could do something real simple, like just look for two-transaction cycles, like T1 and T2 are deadlocked.
Vậy khi phát hiện ra điều này, tôi cũng xin nói thêm, một cách đơn giản là thuật toán phát hiện có thể làm một việc rất đơn giản, như chỉ tìm các chu trình gồm hai transaction, ví dụ T1 và T2 bị bế tắc với nhau.
Run that first because that's cheap to do. Find any deadlocks and maybe clean those up.
Chạy cái đó trước vì nó rẻ. Tìm các bế tắc và có thể dọn chúng đi.
But if you don't find anything, or if you did the two-transaction cycle check and breaking them, or killing transactions, that didn't release other transactions, didn't release the major bottleneck, then you run the more expensive cycle detection algorithm.
Nhưng nếu bạn không tìm thấy gì, hoặc nếu bạn đã kiểm tra chu trình hai transaction và phá chúng, hoặc giết các transaction, mà việc đó không giải phóng các transaction khác, không gỡ được nút thắt chính, thì bạn chạy thuật toán phát hiện chu trình tốn kém hơn.
So you sort of do a quick fix and see whether that solves problems, because most problems will be like that. But then you can run the more expensive one afterwards.
Tức là bạn sửa nhanh trước rồi xem nó có giải quyết được vấn đề không, vì hầu hết các vấn đề đều thuộc loại như vậy. Còn sau đó bạn mới chạy thuật toán tốn kém hơn.
All right, so when we detect a deadlock, now the data system has to decide which transaction to kill, to abort, and to break that deadlock.
Được rồi, khi chúng ta phát hiện một bế tắc, hệ thống dữ liệu giờ phải quyết định giết, hủy transaction nào để phá bế tắc đó.
Remember I said last class that, you know, every transaction starts with begin, and then they can either say commit or they can say abort to tell the data system that the transaction itself wants to abort.
Nhớ là buổi trước tôi đã nói mỗi transaction bắt đầu bằng begin, và sau đó có thể nói commit hoặc nói abort để báo cho hệ thống dữ liệu rằng chính transaction đó muốn hủy.
But the data system can also decide on its own that it has to abort as well. That's what this one is.
Nhưng hệ thống dữ liệu cũng có thể tự quyết định phải hủy. Trường hợp này là như vậy.
So when the data system says, all right, tell the transaction to abort, it releases all the locks, undoes all its changes to provide the atomicity guarantees, and then it can either restart itself, or we throw an exception back to the application
Khi hệ thống dữ liệu nói, được rồi, bảo transaction hủy đi, nó giải phóng mọi khóa, hoàn tác mọi thay đổi để đảm bảo tính nguyên tử (atomicity), và sau đó nó có thể tự khởi động lại, hoặc ta ném một ngoại lệ về cho ứng dụng
saying this transaction aborted and rely on the application to restart it for us. If it's a stored procedure, think of like an RPC call, you just invoke the RPC again inside our data system.
báo rằng transaction này đã bị hủy và trông cậy vào ứng dụng khởi động lại giúp ta. Nếu là stored procedure, hãy nghĩ như một lời gọi RPC, bạn chỉ cần gọi lại RPC đó bên trong hệ thống dữ liệu của ta.
But if we have to go back to the application code, they might not have exception handling to be able to restart things.
Nhưng nếu phải quay lại mã của ứng dụng, thì họ có thể không có xử lý ngoại lệ để khởi động lại mọi thứ.
So the decision of what, you know, what transaction should be the victim that you're going to kill off and release all their locks depends on a lot of different factors that the data systems can take into consideration that can have a pretty significant difference in performance.
Vậy quyết định về việc transaction nào sẽ là nạn nhân bị giết và giải phóng mọi khóa của nó phụ thuộc vào nhiều yếu tố khác nhau mà hệ thống dữ liệu có thể cân nhắc, và chúng có thể tạo ra sự khác biệt khá lớn về hiệu năng.
So a common thing would be, like, you just pick whatever transaction is either the oldest or the newest and you go ahead and kill them.
Vậy một cách phổ biến là, bạn chọn giao dịch cũ nhất hoặc mới nhất và cứ thế hủy nó đi.
Typically you pick the newest, because you would say maybe they haven't been around long enough, and I'm not starving them if I kill them.
Thông thường người ta chọn giao dịch mới nhất, vì có thể nó chưa chạy đủ lâu, và nếu hủy nó thì tôi không làm nó bị bỏ đói.
Of course, now when they come back, you make sure that they have maybe the same timestamp, so they have this, you know, a higher priority than they had before.
Tất nhiên, khi nó chạy lại, bạn phải đảm bảo là nó có thể vẫn giữ nguyên dấu thời gian cũ, để nó có độ ưu tiên cao hơn so với trước đó.
It could also be how much work the transactions have done so far, Right? Maybe they've updated a billion records. You have two transactions that are conflicted and they have a deadlock.
Cũng có thể dựa vào lượng công việc mà giao dịch đã làm cho đến giờ, đúng không? Có thể nó đã cập nhật một tỉ bản ghi. Bạn có hai giao dịch xung đột nhau và bị bế tắc.
One transaction updated a billion records. One transaction's updated one record.
Một giao dịch đã cập nhật một tỉ bản ghi. Giao dịch kia mới cập nhật một bản ghi.
I'm better off killing the one record transaction because I don't want to undo all the work that the other transaction did, because that was expensive to do and I don't want to waste the time of it.
Tốt hơn là tôi hủy giao dịch chỉ có một bản ghi, vì tôi không muốn hoàn tác toàn bộ công việc mà giao dịch kia đã làm, bởi việc đó tốn kém và tôi không muốn lãng phí thời gian đó.
You can also look at how many items the transaction has locked so far. It's sort of like the work. How much work have I ever done?
Bạn cũng có thể xem giao dịch đã khóa bao nhiêu mục cho đến giờ. Nó hơi giống lượng công việc. Tôi đã làm được bao nhiêu việc?
How much data has the transaction read or modified? Locks are kind of the same thing because, again, going to the lock manager and acquiring the locks is not free.
Giao dịch đã đọc hoặc sửa đổi bao nhiêu dữ liệu? Khóa cũng tương tự như vậy, vì một lần nữa, việc đến lock manager và lấy khóa không hề miễn phí.
We have to protect it with latches, like we did in the page table in the buffer pool manager.
Chúng ta phải bảo vệ nó bằng latch, như đã làm với page table trong buffer pool manager.
So that's an expensive operation, to go acquire locks, and so if someone has a billion locks held versus somebody has one lock held, they'd be better off killing off the one lock transaction.
Vì vậy việc lấy khóa là một thao tác tốn kém, và nếu một giao dịch giữ một tỉ khóa còn giao dịch khác chỉ giữ một khóa, thì tốt hơn là hủy giao dịch chỉ có một khóa.
If we allow for cascading aborts, we can also keep track of how many transactions are going to have to get rolled back if we kill one of those transactions.
Nếu cho phép hủy dây chuyền (cascading abort), chúng ta cũng có thể theo dõi xem có bao nhiêu giao dịch sẽ phải bị quay lui nếu hủy một trong các giao dịch đó.
Strong strict 2PL doesn't have this problem, but other protocols do. All right.
Strong strict 2PL không gặp vấn đề này, nhưng các giao thức khác thì có. Được rồi.
So again, there's a lot of different things we can consider when we want to decide which transaction to abort, and this is where, again, the high-end systems, where you're paying millions of dollars for them, they're going to maintain all these kind of statistics internally and try to figure out the best choice for you.
Vậy một lần nữa, có rất nhiều yếu tố khác nhau mà chúng ta có thể cân nhắc khi quyết định hủy giao dịch nào, và đây là chỗ mà các hệ thống cao cấp, loại bạn phải trả hàng triệu đô la, sẽ duy trì tất cả các loại thống kê này bên trong và cố tìm ra lựa chọn tốt nhất cho bạn.
Whereas, at least with MySQL, I think it's just like whatever transaction is the newest, they just kill that. So it's pretty basic, pretty simple.
Trong khi đó, ít nhất với MySQL, tôi nghĩ nó chỉ chọn giao dịch nào mới nhất và hủy giao dịch đó. Nên nó khá cơ bản, khá đơn giản.
All right. So now when a transaction rolls back, the question would be how far we'd roll it back.
Được rồi. Bây giờ khi một giao dịch bị quay lui, câu hỏi là ta sẽ quay lui nó đến đâu.
Now I'm sort of assuming so far when I say I'm going to kill a transaction, it gets completely aborted, but it doesn't have to be that.
Cho đến giờ tôi đang giả định rằng khi nói sẽ hủy một giao dịch, nó bị hủy hoàn toàn, nhưng không nhất thiết phải như vậy.
So we can show demos of this next class, but there's these things called save points, where while my transaction is running, I call BEGIN, but then I can also kind of establish a checkpoint, a save point, within that transaction, and I can potentially roll back to that save point to break a deadlock without having to roll the entire transaction back.
Chúng ta sẽ có demo về việc này ở buổi sau, nhưng có thứ gọi là save point, trong đó khi giao dịch đang chạy, tôi gọi BEGIN, nhưng sau đó tôi cũng có thể thiết lập một kiểu điểm kiểm tra, một save point, bên trong transaction đó, và có thể rollback về save point đó để phá bế tắc mà không phải rollback toàn bộ transaction.
So I can maybe update five records, take a save point, then try to update the sixth record, but then I can't acquire the lock for that.
Ví dụ tôi có thể cập nhật năm bản ghi, tạo một save point, rồi thử cập nhật bản ghi thứ sáu, nhưng lại không lấy được khóa cho bản ghi đó.
So rather than just killing, aborting a transaction entirely, I'll just roll it back for some amount of work up to the save point, and then that breaks the deadlock, but then I don't have to roll everything back.
Vì vậy, thay vì giết, hủy hoàn toàn một transaction, tôi chỉ rollback một phần công việc về đến save point, và như vậy là phá được bế tắc, mà không phải rollback mọi thứ.
Potentially, you don't even have to tell the application server that there's a deadlock for it as well. What's that? The question is, how do you decide where to take a save point?
Thậm chí có thể bạn không cần phải báo cho application server rằng đã có bế tắc xảy ra. Gì vậy? Câu hỏi là: làm sao quyết định chọn chỗ tạo save point?
It's application code. So the application code has to say, I want to take a save point. It's not something it does automatically.
Đó là mã của ứng dụng. Mã ứng dụng phải nói rằng: tôi muốn tạo một save point. Hệ thống không tự động làm việc đó.
For some things, like if the, say, a single update query, it updates two records, it gets the lock for the first record, tries to get the lock for the second record, that causes a deadlock.
Với một số trường hợp, chẳng hạn một câu truy vấn update đơn lẻ, cập nhật hai bản ghi, nó lấy được khóa của bản ghi thứ nhất, rồi cố lấy khóa của bản ghi thứ hai, và điều đó gây ra bế tắc.
For that one, you could break the deadlock by undoing the change of the first tuple that it updated.
Trường hợp này, bạn có thể phá bế tắc bằng cách hoàn tác thay đổi của tuple thứ nhất mà nó đã cập nhật.
That releases the deadlock, and then you can re-execute that query once things are dislodged without having to go back to the application server.
Việc đó giải phóng bế tắc, và sau đó bạn có thể thực thi lại câu truy vấn đó khi mọi thứ đã thông suốt, mà không phải quay lại application server.
So some things you do implicitly, other things require explicit commands in SQL to create save points.
Vậy có những việc hệ thống làm ngầm định, còn những việc khác cần lệnh tường minh trong SQL để tạo save point.
The question is, is the granularity of the lock at a row level, table level, or something else? At this point here, we're not defining. My example, I said tuples.
Câu hỏi là: độ chi tiết của khóa là ở mức hàng, mức bảng, hay một mức nào khác? Ở thời điểm này, chúng ta chưa định nghĩa điều đó. Trong ví dụ của tôi, tôi nói là các tuple.
When we talk about hierarchical locking, it could be anything. The question is, again, what am I locking when I say an object A?
Khi nói về khóa phân cấp, nó có thể là bất kỳ thứ gì. Câu hỏi, một lần nữa, là: tôi đang khóa cái gì khi nói đối tượng A?
Most of it is going to be a single record, a tuple. It doesn't have to be. Again, we'll see how we handle that in a second.
Phần lớn sẽ là một bản ghi đơn lẻ, một tuple. Nhưng không bắt buộc. Một lát nữa chúng ta sẽ xem cách xử lý chuyện đó.
Deadlock prevention is, rather than relying on a background worker to go look for deadlocks in the lock manager and break them up, instead what we're going to do is, when a transaction tries to acquire a lock that's being held by another transaction already, then the DBMS has to decide which one to kill at that moment to avoid having a deadlock.
Phòng tránh bế tắc là: thay vì dựa vào một worker chạy nền để đi tìm các bế tắc trong lock manager rồi phá chúng, thì thay vào đó chúng ta sẽ làm như sau: khi một transaction cố lấy một khóa đang được một transaction khác giữ, thì DBMS phải quyết định giết transaction nào ngay tại thời điểm đó để tránh xảy ra bế tắc.
And for this one, we don't need a waits-for graph, we just need to know who waits for what, and we need to know timestamps of when transactions started.
Với cách này, chúng ta không cần đồ thị waits-for, chỉ cần biết ai đang chờ cái gì, và cần biết timestamp lúc các transaction bắt đầu.
So there will be two methods of deadlock prevention. And again, the high-end systems can support both.
Có hai phương pháp phòng tránh bế tắc. Và một lần nữa, các hệ thống cao cấp có thể hỗ trợ cả hai.
So every transaction is going to be assigned a timestamp of when they started, and then that's going to be used to determine their priority over other transactions.
Mỗi transaction sẽ được gán một timestamp tại thời điểm nó bắt đầu, và timestamp đó sẽ được dùng để xác định mức ưu tiên của chúng so với các giao dịch khác.
And then the two protocols are going to say who's allowed to wait for what, whether a transaction is allowed to wait for another transaction to release a lock or not.
Và hai giao thức này sẽ quy định ai được phép chờ ai, tức là một giao dịch có được phép chờ hay không một giao dịch khác nhả khóa.
And if we guarantee that waiting only happens in sort of one direction of priorities, we can ensure that we don't have deadlocks.
Và nếu ta đảm bảo rằng việc chờ đợi chỉ diễn ra theo một chiều của mức ưu tiên, thì ta có thể đảm bảo không xảy ra bế tắc.
So the first is wait-die, which is the old waits for the young.
Giao thức đầu tiên là wait-die, tức là giao dịch già chờ giao dịch trẻ.
This means that if the transaction that's trying to acquire the lock has a higher priority than the holding transaction, meaning it's older, the timestamp is less, then the requesting transaction is allowed to wait for that other transaction to give up the lock.
Nghĩa là nếu giao dịch đang cố giành khóa có mức ưu tiên cao hơn giao dịch đang giữ khóa, tức là nó già hơn, có timestamp nhỏ hơn, thì giao dịch yêu cầu khóa được phép chờ giao dịch kia nhả khóa.
But if the transaction that's trying to acquire the lock is younger than the transaction that holds the lock, then that requesting transaction has to kill themselves.
Nhưng nếu giao dịch đang cố giành khóa trẻ hơn giao dịch đang giữ khóa, thì giao dịch yêu cầu đó phải tự hủy.
Wound-wait is the opposite, like the young waits for the old. So if the requesting transaction is younger than the transaction that holds the lock, then it's allowed to wait.
Wound-wait thì ngược lại, giao dịch trẻ chờ giao dịch già. Nếu giao dịch yêu cầu khóa trẻ hơn giao dịch đang giữ khóa, thì nó được phép chờ.
If it's older, then it has to kill itself. So let's look at explicit examples here. So we have two transactions, or two schedules, or two different transactions, T1 and T2.
Nếu nó già hơn, thì nó phải tự hủy. Hãy xem các ví dụ cụ thể. Ta có hai giao dịch, hay hai lịch biểu, hay hai giao dịch khác nhau, T1 và T2.
And the first one here at the top, T1 starts, so it has a timestamp that's going to be less than T2. Timestamps are 1 and 2. So T1 starts, it gets timestamp 1.
Ở ví dụ đầu tiên phía trên, T1 bắt đầu, nên nó có timestamp nhỏ hơn T2. Timestamp là 1 và 2. T1 bắt đầu, nhận timestamp 1.
T2 starts, it gets timestamp 2. T2 gets to use the lock on A, but then T1 tries to get that same lock on A.
T2 bắt đầu, nhận timestamp 2. T2 giữ khóa trên A, rồi T1 cố lấy chính khóa đó trên A.
And under wait-die, where the old waits for the young, because T1 is older than T2, it's allowed to wait for T2 to finish to acquire that lock.
Với wait-die, tức là già chờ trẻ, vì T1 già hơn T2, nó được phép chờ T2 xong để lấy khóa đó.
Under wound-wait, T2 will end up getting aborted because basically saying, I'm not waiting for you, I'm older than you, I'm going to go, you know, steal your lock and kill you, right?
Với wound-wait, T2 sẽ bị hủy vì về cơ bản T1 nói rằng: tôi không chờ anh đâu, tôi già hơn anh, tôi sẽ đi, cướp khóa của anh và giết anh, đúng không?
And now this other example here, again, T1 starts, gets exclusive lock on A. T2 then starts, tries to get the exclusive lock on A.
Còn ví dụ khác này, T1 bắt đầu, lấy khóa độc quyền trên A. Sau đó T2 bắt đầu, cố lấy khóa độc quyền trên A.
And under wait-die, T2 has to abort because in wait-die, the old waits for the young. Because T2 is younger than T1, it's not allowed to wait and it has to kill itself.
Với wait-die, T2 phải hủy vì trong wait-die, già chờ trẻ. Vì T2 trẻ hơn T1 nên không được chờ và phải tự hủy.
In the case of wound-wait, where the young waits for the old, T2 is allowed to wait for T1.
Với wound-wait, tức là trẻ chờ già, T2 được phép chờ T1.
All right, so why is this guaranteed that there's no deadlocks? Because all the waiting is going to happen in one direction. Again, you would implement just one, either wound-wait or wait-die.
Vậy tại sao điều này đảm bảo không có bế tắc? Vì mọi việc chờ đợi đều diễn ra theo một chiều. Một lần nữa, bạn chỉ cài đặt một trong hai, wound-wait hoặc wait-die.
You don't implement both of them. I mean, you can, but you can only run one at a time. So it's like when we talked about latching in the B+tree along the leaf nodes, right?
Bạn không cài đặt cả hai. Ý tôi là có thể, nhưng mỗi lúc chỉ chạy được một cái. Giống như khi ta nói về latching trong B+tree dọc theo các nút lá, đúng không?
Normally, in just the traversal itself, all our workers are starting from the top and going to the bottom. We didn't have anybody else going in the other direction.
Thông thường, chỉ riêng trong quá trình duyệt cây, tất cả các worker của chúng ta đều bắt đầu từ trên cùng và đi xuống dưới. Chúng ta không có ai đi theo chiều ngược lại.
So you can't have deadlocks. It's all, the waiting is sort of going in one direction.
Cho nên không thể có bế tắc. Tất cả đều như vậy, việc chờ đợi diễn ra theo một chiều.
So wait-die, wound-wait, basically the same thing, but in more nuance because now you're dealing with, you know, coming at different directions, but you only allow one of them to actually occur, and that guarantees that you don't have any deadlocks.
Vậy wait-die và wound-wait về cơ bản là giống nhau, nhưng có nhiều sắc thái hơn vì bây giờ bạn phải xử lý các luồng đi từ những hướng khác nhau, nhưng bạn chỉ cho phép một trong hai xảy ra thực sự, và điều đó đảm bảo rằng bạn không có bế tắc nào.
So when a transaction restarts, we have to give it a new priority, but we're just going to use the same timestamp of when they started before, the first time they were aborted.
Khi một transaction khởi động lại, ta phải cho nó một mức ưu tiên mới, nhưng ta sẽ dùng lại đúng timestamp lúc nó bắt đầu trước đó, tức là lần đầu tiên nó bị hủy.
So that guarantees that eventually there'll be like, you know, an old person that just gets whatever they want. All right? And it doesn't get starved.
Như vậy đảm bảo rằng cuối cùng sẽ có một transaction già nhất, muốn gì được nấy. Đúng không? Và nó không bị bỏ đói.
And like I said, in some workloads, wound-wait is better. Other workloads, wait-die is better. And then the high-end systems allow you to toggle on which one you want to use.
Và như tôi đã nói, với một số workload thì wound-wait tốt hơn. Với các workload khác thì wait-die tốt hơn. Và các hệ thống cao cấp cho phép bạn bật tắt để chọn cái mình muốn dùng.
All right, so now, coming up to their question earlier, all my examples here, we're just assuming that we have a one-to-one mapping of database objects, and I didn't define exactly what they were, to locks, right?
Được rồi, quay lại câu hỏi lúc nãy, tất cả các ví dụ của tôi ở đây đều giả định rằng ta có ánh xạ một-một giữa các đối tượng cơ sở dữ liệu, mà tôi chưa định nghĩa chính xác chúng là gì, với các lock, đúng không?
But the challenge with this one is it's not going to be scalable.
Nhưng thách thức của cách này là nó sẽ không có khả năng mở rộng.
So if I have a transaction that wants to update a billion tuples, and everything I've told you so far, I got to go to the lock manager and get a billion locks.
Nếu tôi có một transaction muốn cập nhật một tỉ tuple, và với mọi thứ tôi đã nói với các bạn cho đến giờ, tôi phải tới lock manager và lấy một tỉ lock.
And again, it's a page table, it's a hash table, like the page table, but I have to protect it with latches because it's a centralized data structure.
Và nó là một bảng băm, giống như page table, nhưng tôi phải bảo vệ nó bằng latch vì nó là cấu trúc dữ liệu tập trung.
And if I got to go in and get a billion locks, Chances are that the cost of going and acquiring the locks is going to be more expensive than just updating whatever the record is, whatever the records that I wanted to update, right?
Và nếu tôi phải vào đó lấy một tỉ lock, thì nhiều khả năng chi phí đi lấy các lock đó sẽ đắt hơn việc chỉ cập nhật bản ghi đó, những bản ghi mà tôi muốn cập nhật, đúng không?
It's not like a latch where I'm flipping a 64-bit integer and I can do that in a single instruction in the CPU.
Nó không như latch, nơi tôi chỉ đổi một số nguyên 64 bit và làm được việc đó chỉ bằng một lệnh của CPU.
I got to traverse the hash, whatever I'm looking for, do my search in the hash table, then acquire latches for whatever the things I want to modify.
Tôi phải duyệt bảng băm, tìm thứ tôi cần, thực hiện tìm kiếm trong bảng băm, rồi mới lấy latch cho những thứ tôi muốn sửa.
So we can get around this problem by introducing different kinds of lock granularities, and now we can define locks to have scope, or the thing that they're locking can encompass larger and larger logical parts of a database itself.
Vậy ta có thể vượt qua vấn đề này bằng cách đưa vào các mức độ hạt (granularity) khác nhau của lock, và giờ ta có thể định nghĩa lock có phạm vi, hay thứ mà chúng khóa có thể bao trùm những phần logic ngày càng lớn hơn của chính cơ sở dữ liệu.
So now when I say I'm going to acquire a lock, I can acquire a lock on a database, a table, a page in the table, a tuple, and then in the lowest case, I can own a single column or a single attribute within a tuple.
Vậy bây giờ khi tôi nói sẽ lấy một lock, tôi có thể lấy lock trên một cơ sở dữ liệu, một bảng, một page trong bảng, một tuple, và ở mức thấp nhất, tôi có thể sở hữu một cột đơn hay một thuộc tính đơn trong một tuple.
And in an ideal scenario, we want our DBMS to acquire the smallest number of locks that it actually needs to do whatever it is the transaction wants to do, because then we go into that lock manager fewer times.
Và trong kịch bản lý tưởng, ta muốn DBMS lấy số lượng lock ít nhất mà nó thực sự cần để làm bất cứ điều gì transaction muốn, vì như vậy ta phải vào lock manager ít lần hơn.
But the trade-off is going to be, if I'm only acquiring coarse-grained locks for the entire database, then that's going to block out other transactions from running at the same time and I get bad parallelism.
Nhưng đổi lại, nếu tôi chỉ lấy các khóa thô (coarse-grained) cho toàn bộ cơ sở dữ liệu, thì điều đó sẽ chặn các giao dịch khác chạy cùng lúc và tôi có tính song song kém.
So we can introduce this notion of a lock hierarchy, and what this means is that at the very top, you have a database, and within that, it has tables.
Vì vậy, chúng ta có thể đưa vào khái niệm phân cấp khóa (lock hierarchy), nghĩa là ở trên cùng, bạn có một cơ sở dữ liệu, và bên trong nó có các bảng.
So if I acquire a lock on the database, that implicitly acquires the lock on everything down below within that database.
Vậy nếu tôi lấy khóa trên cơ sở dữ liệu, thì điều đó ngầm định lấy khóa trên mọi thứ bên dưới nằm trong cơ sở dữ liệu đó.
And so now, if I want to do certain things, if I would update a billion tuples in a table, instead of acquiring a billion locks on individual tuples, I just acquire the lock on the table, And that guarantees that I'm protected from other transactions.
Và bây giờ, nếu tôi muốn làm một số việc nhất định, nếu tôi cập nhật một tỉ tuple trong một bảng, thay vì lấy một tỉ khóa trên từng tuple riêng lẻ, tôi chỉ lấy khóa trên bảng, và điều đó đảm bảo tôi được bảo vệ khỏi các giao dịch khác.
So all the transactions have to sort of enter this tree and acquire the locks in the same direction.
Vì vậy, mọi giao dịch đều phải đi vào cây này và lấy các khóa theo cùng một hướng.
So T1 shows up, and again, I want to update the entire table, so if I just get the lock on the table at the top, implicitly I have the locks for everything down below.
Giả sử T1 xuất hiện, và một lần nữa, tôi muốn cập nhật toàn bộ bảng, nên nếu tôi chỉ lấy khóa trên bảng ở trên cùng, thì ngầm định tôi có khóa cho mọi thứ bên dưới.
So MongoDB, the first version of MongoDB when it came out, they only had database locks. So anytime you had a writer, they would lock the entire database. Sort of how SQLite works now.
Với MongoDB, phiên bản đầu tiên của MongoDB khi mới ra mắt, chỉ có khóa cấp cơ sở dữ liệu. Nên bất cứ khi nào có một bên ghi, họ khóa toàn bộ cơ sở dữ liệu. Gần giống cách SQLite hoạt động hiện nay.
SQLite only allows for one writer thread.
SQLite chỉ cho phép một luồng ghi.
Now they allow for multiple readers and potentially read other parts of the database at the same time you're writing to it, but they sort of have this model where you only lock, you have a sort of single lock for the entire database for writers.
Giờ đây họ cho phép nhiều bên đọc và có thể đọc các phần khác của cơ sở dữ liệu cùng lúc bạn đang ghi vào nó, nhưng họ có mô hình mà bạn chỉ khóa, tức là có một khóa duy nhất cho toàn bộ cơ sở dữ liệu đối với bên ghi.
Readers can read different things. So the way to think about how different systems are applicable to this: the tuple-level locks are very, very common.
Các bên đọc có thể đọc những thứ khác nhau. Vậy cách nghĩ về việc các hệ thống khác nhau áp dụng điều này như sau: khóa cấp tuple là rất, rất phổ biến.
Pretty much anybody that's doing tuple-based locking is going to be doing this. The next one would be table locks, which are very common.
Hầu như bất kỳ ai khóa dựa trên tuple đều sẽ làm như vậy. Tiếp theo là khóa bảng, cũng rất phổ biến.
Page locks, they're more nuanced, we'll see that in two more lectures, but some systems can do that.
Khóa trang thì phức tạp hơn, chúng ta sẽ thấy điều đó trong hai bài giảng nữa, nhưng một số hệ thống có thể làm được.
You can do database locks in some systems, like Postgres, you can lock the entire table, I don't think you can lock the entire database.
Một số hệ thống cho phép khóa cơ sở dữ liệu, như Postgres, bạn có thể khóa toàn bộ bảng, tôi không nghĩ bạn có thể khóa toàn bộ cơ sở dữ liệu.
You can put the database in read-only mode and that's sort of like the same thing. I only know one system that does attribute-level locks and that's YugabyteDB, which is pretty impressive.
Bạn có thể đặt cơ sở dữ liệu ở chế độ chỉ đọc và điều đó gần như tương tự. Tôi chỉ biết một hệ thống có khóa cấp thuộc tính đó là YugabyteDB, khá ấn tượng.
And the challenge is going to be, when we talk about multiversioning, that in order to support this, I've got to put information in the header of every single attribute or every single tuple about what locks are being held by that tuple within its attributes.
Và thách thức là, khi chúng ta nói về đa phiên bản (multiversioning), để hỗ trợ điều này, tôi phải đặt thông tin vào phần header của từng thuộc tính hoặc từng tuple về những khóa nào đang được giữ bởi tuple đó trong các thuộc tính của nó.
And again, it opens up more parallelism, but it's a more complicated protocol to implement and there's more metadata you have to maintain.
Và một lần nữa, nó mở ra nhiều tính song song hơn, nhưng là một giao thức phức tạp hơn để triển khai và có nhiều siêu dữ liệu hơn bạn phải duy trì.
All right, so now the problem is if I just have only two lock modes, shared and exclusive, then it becomes kind of challenging to start doing anything more sophisticated using this hierarchy because, you know, someone could take an exclusive lock on the table and maybe only update a small number of tuples, and that would be good.
Được rồi, vấn đề bây giờ là nếu tôi chỉ có hai chế độ khóa, shared và exclusive, thì sẽ khá khó để bắt đầu làm bất cứ điều gì phức tạp hơn bằng cấu trúc phân cấp này, bởi vì, bạn biết đấy, ai đó có thể lấy một khóa exclusive trên bảng và có thể chỉ cập nhật một số ít tuple, và như thế là tốt.
And so I want a way to be able to hint to other transactions what's going on below me in the tree without having to go in the tree and traverse everything to find what I need.
Vì vậy tôi muốn có cách gợi ý cho các transaction khác biết điều gì đang diễn ra bên dưới tôi trong cây mà không phải đi vào cây và duyệt mọi thứ để tìm ra điều mình cần.
Because again, under two-phase locking, I have to acquire locks on objects before I'm allowed to do anything on those objects. So I have to check this thing first before I can do anything.
Bởi vì một lần nữa, theo two-phase locking, tôi phải lấy khóa trên các đối tượng trước khi được phép làm bất cứ điều gì trên các đối tượng đó. Nên tôi phải kiểm tra thứ này trước khi có thể làm bất cứ điều gì.
So this is where intention locks are going to help us.
Và đây là lúc intention lock giúp ích cho chúng ta.
Intention locks give me hints for us in this hierarchy tree of the lock granularities that convey information about what's going on below me in the tree without having to go down into the tree and look at everything.
Intention lock cho chúng ta những gợi ý trong cây phân cấp của các mức độ chi tiết của khóa, truyền đạt thông tin về những gì đang diễn ra bên dưới tôi trong cây mà không phải đi xuống cây và xem xét mọi thứ.
It's just a hint for other transactions. And the three basic types we're going to have are intention shared, intention exclusive, and shared intention exclusive.
Nó chỉ là một gợi ý cho các transaction khác. Và ba loại cơ bản mà chúng ta sẽ có là intention shared, intention exclusive, và shared intention exclusive.
So intention shared basically says a hint to say, hey, down below me in the tree, I'm going to be taking things, there's going to be some, some objects will be taken in shared mode.
Vậy intention shared về cơ bản là gợi ý rằng, này, bên dưới tôi trong cây, tôi sẽ lấy một số thứ, sẽ có một số đối tượng được lấy ở chế độ shared.
Intention exclusive says some things down below me are going to be in exclusive mode. And then shared intention exclusive means that I'm going to take that object and everything below it in shared mode.
Intention exclusive nói rằng một số thứ bên dưới tôi sẽ ở chế độ exclusive. Còn shared intention exclusive nghĩa là tôi sẽ lấy đối tượng đó và mọi thứ bên dưới nó ở chế độ shared.
But then down below within that, I'll upgrade my locks and take something in exclusive mode, but not at the level where this lock is being defined.
Nhưng sau đó bên dưới trong phạm vi đó, tôi sẽ nâng cấp khóa và lấy một số thứ ở chế độ exclusive, nhưng không phải ở mức mà khóa này đang được định nghĩa.
All right, so what does this look like for our compatibility matrix? Now it's getting more complicated, right? Because again, now we have these intention locks plus the original shared and exclusive locks.
Được rồi, vậy ma trận tương thích của chúng ta trông thế nào? Giờ nó phức tạp hơn rồi, đúng không? Bởi vì một lần nữa, giờ chúng ta có các intention lock này cộng với các khóa shared và exclusive ban đầu.
Again, exclusive locks block everything else. You can't do anything with that.
Một lần nữa, khóa exclusive chặn mọi thứ khác. Bạn không thể làm gì với nó.
But like with an intention shared, you can start sharing this, so it's compatible with everything but exclusive, because again, this is a hint to say, "Hey, down below me, I'm doing something, but not exactly at the level that I'm at, you're at right now."
Nhưng với intention shared, bạn có thể bắt đầu chia sẻ nó, nên nó tương thích với mọi thứ trừ exclusive, vì một lần nữa, đây là gợi ý rằng: "Này, bên dưới tôi, tôi đang làm gì đó, nhưng không đúng ở mức mà tôi, mà bạn đang ở lúc này."
So the locking protocol becomes a bit more complicated, where now before I go and do whatever read or write I want to do on the object in the database, I go into my hierarchy, figure out at the high level what intention locks I maybe need to hold, because I'm trying to reduce the total number of absolute locks I'm taking for my transaction.
Vì vậy giao thức khóa trở nên phức tạp hơn một chút, khi mà bây giờ trước khi tôi thực hiện bất kỳ thao tác đọc hay ghi nào tôi muốn trên đối tượng trong cơ sở dữ liệu, tôi đi vào cấu trúc phân cấp của mình, xác định ở mức cao những intention lock nào tôi có thể cần giữ, bởi vì tôi đang cố giảm tổng số khóa thực sự mà transaction của tôi phải lấy.
And then at the lowest level, then I'll either take things in either exclusive mode or shared mode, again depending on what my operation is actually going to be.
Và sau đó ở mức thấp nhất, tôi sẽ lấy khóa ở chế độ exclusive hoặc chế độ shared, một lần nữa tùy thuộc vào thao tác thực sự của tôi là gì.
And now me standing here waving my hands is probably not helping, so let's look at a bunch of examples. So it's the same one we had before.
Và việc tôi đứng đây khua tay múa chân có lẽ cũng chẳng giúp ích gì, nên chúng ta hãy xem một loạt ví dụ. Đây vẫn là ví dụ lúc trước.
We're going to check the balance of DJ Cash's bank account, and then we're going to increase his bookie's account balance by 1%.
Chúng ta sẽ kiểm tra số dư tài khoản ngân hàng của DJ Cash, rồi tăng số dư tài khoản của người cá cược của anh ta thêm 1%.
So for this, we're going to take explicit exclusive and shared locks for the leaf nodes in our lock tree hierarchy.
Với ví dụ này, chúng ta sẽ lấy các khóa exclusive và shared tường minh trên các nút lá trong cây phân cấp khóa.
But then we'll have the intention locks up above to tell the transaction what's going on down below. So to keep it simple, we only have two levels. We have table locks and tuple locks.
Nhưng phía trên sẽ có các khóa intention để cho giao dịch biết điều gì đang diễn ra ở phía dưới. Để cho đơn giản, chúng ta chỉ có hai tầng. Đó là khóa bảng và khóa tuple.
Again, you have page locks, you can have attribute locks, you can have database locks. It's all, you know, it all still works the same.
Tất nhiên, bạn cũng có thể có khóa trang, khóa thuộc tính, khóa cơ sở dữ liệu. Mọi thứ vẫn hoạt động theo cùng một cách.
So when T1 starts, it wants to read a single record in the table. So it only wants to get this lock in shared mode.
Khi T1 bắt đầu, nó muốn đọc một bản ghi duy nhất trong bảng. Vì vậy nó chỉ cần lấy khóa này ở chế độ shared.
So in my hierarchy, as I go down, I'm going to give a, take an intention shared lock at this, at the table level and then traverse now down and get the shared lock that I want, explicit shared lock on the, on the tuple I'm going to read.
Vậy trong cây phân cấp, khi đi xuống, tôi sẽ lấy một khóa intention shared ở mức bảng, rồi đi xuống tiếp và lấy khóa shared mà tôi cần, tức khóa shared tường minh trên tuple mà tôi sắp đọc.
And for T2, that's going to update a record in the table, we want to get a, we want to take this bottom lock in exclusive mode.
Còn với T2, giao dịch cập nhật một bản ghi trong bảng, chúng ta muốn lấy khóa ở dưới cùng này ở chế độ exclusive.
Again, in our compatibility matrix, intention shared is compatible with intention exclusive lock, right? But not exclusive lock.
Một lần nữa, trong ma trận tương thích, khóa intention shared tương thích với khóa intention exclusive, đúng không? Nhưng không tương thích với khóa exclusive.
So I don't want to take an exclusive lock on the table, because that's going to block everything, any reads and writes on the table, and it's going to get denied too because T1 already holds the intention shared lock.
Vì vậy tôi không muốn lấy khóa exclusive trên bảng, vì như thế sẽ chặn mọi thứ, mọi thao tác đọc và ghi trên bảng, và nó cũng sẽ bị từ chối vì T1 đã giữ khóa intention shared.
So instead, I'm going to take an intention exclusive lock on the table.
Thay vào đó, tôi sẽ lấy khóa intention exclusive trên bảng.
Again, giving a hint to other transactions, say, hey, down below me, I'm taking an exclusive lock, and I get the exclusive lock on the one tuple I want to modify.
Một lần nữa, đó là gợi ý cho các giao dịch khác rằng: này, ở phía dưới tôi, tôi đang giữ một khóa exclusive, và tôi lấy khóa exclusive trên một tuple mà tôi muốn sửa đổi.
And therefore, these two transactions can run in parallel and they don't interfere with each other.
Do đó, hai giao dịch này có thể chạy song song và không gây cản trở lẫn nhau.
For more complex examples, so now we'll do three transactions. T1 is going to scan all the tuples in R and update one of them. T2 is going to read a single tuple in R.
Với các ví dụ phức tạp hơn, giờ ta sẽ có ba giao dịch. T1 sẽ quét tất cả các tuple trong R và cập nhật một trong số đó. T2 sẽ đọc một tuple duy nhất trong R.
And then T3 is going to read all the tuples in R but not update any of them. And assume they're showing up in T1 followed by T2 followed by T3.
Và T3 sẽ đọc tất cả các tuple trong R nhưng không cập nhật tuple nào. Giả sử chúng đến theo thứ tự T1, rồi T2, rồi T3.
And I'm not defining whether I'm doing deadlock detection or deadlock prevention. It doesn't matter at this point, right? I'm just trying to explain how we're actually taking the locks in the hierarchy.
Và tôi không nói rõ là đang dùng phát hiện bế tắc hay ngăn ngừa bế tắc. Lúc này điều đó không quan trọng, đúng không? Tôi chỉ đang cố giải thích cách chúng ta thực sự lấy các khóa trong cây phân cấp.
So T1 wants to read all the tuples in R and update one of them. So I'm going to read a bunch of these and then write this last one here.
Vậy T1 muốn đọc tất cả các tuple trong R và cập nhật một tuple. Nên tôi sẽ đọc một loạt tuple rồi ghi tuple cuối cùng này.
So for this, I could take a shared intention exclusive lock At the table level. And then I only need to take an exclusive lock on the one tuple I need to modify.
Với việc này, tôi có thể lấy một khóa shared intention exclusive ở mức bảng. Và sau đó tôi chỉ cần lấy khóa exclusive trên một tuple duy nhất mà tôi cần sửa đổi.
Because it's shared intention exclusive, the shared part is explicit.
Vì đây là shared intention exclusive nên phần shared là tường minh.
So that means tuple one and tuple two and every other tuple below this table are going to be in shared mode, or locked in shared mode, for this transaction.
Nghĩa là tuple một và tuple hai cùng mọi tuple khác bên dưới bảng này sẽ ở chế độ shared, hay nói cách khác là bị khóa ở chế độ shared, đối với giao dịch này.
And then the one lock, the one tuple I want to modify, I take that in explicit exclusive mode.
Còn khóa trên tuple duy nhất mà tôi muốn sửa đổi, thì tôi lấy tường minh ở chế độ exclusive.
Then now when T2 wants to come along and it wants to read a single tuple in the table, say this one over here, I can look at my compatibility matrix and know that the shared intention exclusive is compatible with an intention shared, right?
Bây giờ khi T2 xuất hiện và muốn đọc một tuple đơn lẻ trong bảng, giả sử là tuple ở đằng này, tôi có thể nhìn vào ma trận tương thích và biết rằng shared intention exclusive tương thích với intention shared, đúng không?
Because then I'm just saying, like, hey, down below me, I'm going to read something. So I get intention shared on the table and then take the shared lock on the first tuple here.
Vì khi đó tôi chỉ đang nói rằng, ở bên dưới tôi, tôi sẽ đọc một thứ gì đó. Vậy tôi lấy intention shared trên bảng rồi lấy khóa shared trên tuple đầu tiên ở đây.
And again, that's compatible with shared intention exclusive because, again, implicitly, T1 has all the tuples in shared mode and only this one at the end in exclusive mode.
Và một lần nữa, điều đó tương thích với shared intention exclusive vì, như đã nói, ngầm định T1 giữ tất cả các tuple ở chế độ shared và chỉ tuple cuối cùng này ở chế độ exclusive.
And then now when T3 shows up, it wants to scan all the tuples in R.
Rồi bây giờ khi T3 xuất hiện, nó muốn quét tất cả các tuple trong R.
And for this, instead of going and getting every single tuple in shared mode, it wants to get a shared lock on the table.
Và với việc này, thay vì đi lấy từng tuple một ở chế độ shared, nó muốn lấy khóa shared trên bảng.
Because, again, I'm trying to minimize the number of times I'm going to the lock manager.
Bởi vì, một lần nữa, tôi đang cố giảm thiểu số lần phải gọi đến lock manager.
So I get the shared lock on R, then they implicitly get all the other tuples in R in shared mode.
Vậy tôi lấy khóa shared trên R, thì nó ngầm định có tất cả các tuple khác trong R ở chế độ shared.
But because that conflicts with the shared intention exclusive lock being held by T1, therefore T3 has to wait.
Nhưng vì điều đó xung đột với khóa shared intention exclusive mà T1 đang giữ, nên T3 phải chờ.
T2 then commits, releases the intention shared lock. That still doesn't unblock T3. Only when T1 commits, then we can get the shared lock on R and we can then read everything we want.
Sau đó T2 commit và giải phóng khóa intention shared. Điều đó vẫn chưa gỡ chặn cho T3. Chỉ khi T1 commit, thì chúng ta mới lấy được khóa shared trên R và đọc mọi thứ mình muốn.
So you can also go back too. You can say, like, say for T3, it's going to read all the tuples, but it doesn't know the number of tuples there are.
Bạn cũng có thể quay lại như vậy. Ví dụ với T3, nó sẽ đọc tất cả các tuple, nhưng nó không biết có bao nhiêu tuple.
Maybe the statistics are wrong. So it could say things like, well, I think there's a thousand tuples, so I'll just get a thousand tuple locks.
Có thể số liệu thống kê bị sai. Nên nó có thể nghĩ rằng, tôi nghĩ có một nghìn tuple, vậy tôi sẽ lấy một nghìn khóa tuple.
That's fine. But then it keeps going, and now it realizes there's a billion tuples.
Không sao. Nhưng rồi nó cứ tiếp tục, và bây giờ nó nhận ra có một tỉ tuple.
You can then go back in the hierarchy and say, upgrade my intention shared lock at the table level and put it into shared mode.
Khi đó bạn có thể quay lại trong hệ thống phân cấp và nói, hãy nâng cấp khóa intention shared của tôi ở mức bảng lên chế độ shared.
Again, this is just repeating what I said. You can switch to more coarse-grained locks when you realize you're acquiring too many low-level locks or explicit locks down below.
Một lần nữa, đây chỉ là lặp lại những gì tôi đã nói. Bạn có thể chuyển sang các khóa có độ mịn thô hơn khi nhận ra mình đang lấy quá nhiều khóa mức thấp hay các khóa tường minh ở bên dưới.
Yes.
Vâng.
The question is, why does T3 take a shared lock here instead of intention shared?
Câu hỏi là, tại sao T3 lấy khóa shared ở đây thay vì intention shared?
Because say that it knows there's a billion tuples down below that it doesn't want to acquire a billion locks for all those individual tuples.
Vì giả sử nó biết có một tỉ tuple ở bên dưới rằng nó không muốn lấy một tỉ khóa cho từng tuple riêng lẻ đó.
It's better off to take the shared lock at the table level.
Tốt hơn là lấy khóa chia sẻ ở cấp bảng.
Yes. The statement is, well, the question is, why did T1 take a shared intention exclusive?
Vâng. Ý bạn là, à, câu hỏi là, tại sao T1 lại lấy khóa shared intention exclusive?
Because it's going to do a mix, but it knows it needs to read everything, and it's going to only update one of them.
Vì nó sẽ làm một thao tác hỗn hợp, nhưng nó biết mình cần đọc toàn bộ, và chỉ cập nhật một trong số đó.
So the shared intention exclusive gets everybody in read mode down below implicitly, and then I take the one explicit exclusive lock on the two I'm going to modify.
Vậy shared intention exclusive sẽ cho mọi tuple ở bên dưới chế độ đọc một cách ngầm định, rồi tôi lấy một khóa exclusive tường minh trên hai tuple mà tôi sẽ sửa đổi.
The statement is, and they're correct, if it knew it was going to update everything down below, it would just take an exclusive lock on the entire table. Yes.
Ý bạn là, và bạn nói đúng, nếu nó biết mình sẽ cập nhật mọi thứ bên dưới, thì nó chỉ cần lấy khóa exclusive trên toàn bộ bảng. Vâng.
You see that in things like when you modify the schema of a table, they're going to add a column or drop a column, I'll take an exclusive lock on the table so I can make that change and prevents anybody else from reading and writing while making that change.
Bạn sẽ thấy điều đó khi sửa đổi schema của một bảng, chẳng hạn thêm một cột hoặc xóa một cột, tôi sẽ lấy khóa exclusive trên bảng để có thể thực hiện thay đổi đó và ngăn không cho ai khác đọc và ghi trong lúc thực hiện thay đổi.
That's an easy way to do schema changes. All right. So, as I said before, you typically don't manually acquire locks in SQL in your application code.
Đó là cách dễ dàng để thay đổi schema. Được rồi. Như tôi đã nói trước đó, thông thường bạn không tự lấy khóa thủ công bằng SQL trong mã ứng dụng.
It's only when you go try to run a SQL query, the data system figures out for you which level of the hierarchy you want to acquire and what locks you're actually going to need.
Chỉ khi bạn chạy một truy vấn SQL, hệ quản trị dữ liệu sẽ tự xác định giúp bạn nên lấy khóa ở cấp nào của phân cấp và thực sự cần những khóa nào.
But there's sometimes in SQL you can actually give hints to the database server that what you actually want, what locks you want to acquire and in what mode as part of the SQL command itself.
Nhưng đôi khi trong SQL bạn có thể đưa gợi ý cho máy chủ cơ sở dữ liệu về việc bạn thực sự muốn lấy những khóa nào và ở chế độ nào, ngay trong chính câu lệnh SQL.
Right.
Đúng vậy.
An example I said before, you can take a explicit lock on a database or a table and you're going to make major changes and update all the tuples rather than, you know, having the lock manager figure this out.
Như ví dụ tôi nói trước đó, bạn có thể lấy khóa tường minh trên một cơ sở dữ liệu hoặc một bảng khi bạn sắp thực hiện thay đổi lớn và cập nhật tất cả các tuple, thay vì để trình quản lý khóa tự tìm ra điều này.
You just lock the entire table and make your change. That's very common. One of the most common techniques you can use are what's called FOR UPDATE hints.
Bạn chỉ cần khóa toàn bộ bảng và thực hiện thay đổi. Cách này rất phổ biến. Một trong những kỹ thuật phổ biến nhất là cái gọi là gợi ý FOR UPDATE.
And so, in my SQL query, I have, you know, SELECT star FROM whatever table with a WHERE clause, and if I don't have this FOR UPDATE piece, when I run this query, the data system is going to take your locks in shared mode.
Vậy, trong truy vấn SQL của tôi, tôi có SELECT * FROM một bảng nào đó với mệnh đề WHERE, và nếu tôi không có phần FOR UPDATE này, khi chạy truy vấn, hệ quản trị dữ liệu sẽ lấy khóa ở chế độ chia sẻ.
Right. But I'm going to put this FOR UPDATE thing at the end.
Đúng. Nhưng tôi sẽ đặt FOR UPDATE này ở cuối.
It says, it's basically saying, hey, I'm going to read this and the very next thing I'm going to do is write to it. So, don't acquire it in shared mode.
Về cơ bản nó nói rằng, này, tôi sẽ đọc dữ liệu này và việc tiếp theo tôi làm là ghi vào nó. Vì vậy, đừng lấy khóa ở chế độ chia sẻ.
Just immediately acquire it in exclusive mode because the next query that's coming at you is going to be an update query or a delete or something like that.
Hãy lấy ngay khóa ở chế độ exclusive vì truy vấn tiếp theo đến sẽ là một truy vấn update hoặc delete hay gì đó tương tự.
And in, I don't, I don't, I'm scared when this is in the SQL standard, but the FOR UPDATE one is very common.
Và tôi không chắc, tôi e là cái này có nằm trong chuẩn SQL hay không, nhưng FOR UPDATE thì rất phổ biến.
MySQL has different syntax, LOCK IN SHARE MODE or lock in whatever mode you want. Right. For SELECT statements. We can see here from the Postgres application, There's a bunch of variations of it.
MySQL có cú pháp khác, LOCK IN SHARE MODE hoặc khóa ở bất kỳ chế độ nào bạn muốn. Đúng vậy. Đối với các câu lệnh SELECT. Chúng ta có thể thấy ở đây, từ ứng dụng Postgres, Có khá nhiều biến thể của nó.
Like FOR KEY SHARE, FOR SHARE, or FOR NO KEY UPDATE or FOR UPDATE. And it shows you the compatibility matrix with a bunch of them.
Như FOR KEY SHARE, FOR SHARE, FOR NO KEY UPDATE hoặc FOR UPDATE. Và nó cho bạn thấy ma trận tương thích của rất nhiều biến thể này.
So, this is super common when you have, like, read, modify, write workloads. Like, read someone's bank account and then take money out of it. You would run queries using FOR UPDATE.
Cái này cực kỳ phổ biến khi bạn có các khối lượng công việc kiểu đọc, sửa đổi, ghi. Ví dụ, đọc tài khoản ngân hàng của ai đó rồi rút tiền ra khỏi đó. Bạn sẽ chạy các truy vấn bằng FOR UPDATE.
And that avoids the problem of, like, I read something, get the shared lock in the lock manager, so I have to go to the lock manager for that.
Và như vậy tránh được vấn đề là tôi đọc một thứ gì đó, lấy khóa chia sẻ trong bộ quản lý khóa, nên tôi phải đến bộ quản lý khóa để làm việc đó.
Then the next query is going to try to update it and I'm going to go back in the lock manager and try to upgrade that.
Sau đó truy vấn tiếp theo sẽ cố cập nhật nó và tôi sẽ phải quay lại bộ quản lý khóa để cố nâng cấp khóa đó.
So, rather than doing the read and then later on realizing you can't get the exclusive mode lock, just read it and get the exclusive mode lock while you're reading it.
Vì vậy, thay vì đọc xong rồi sau đó mới nhận ra là không thể lấy được khóa chế độ độc quyền, thì cứ đọc và lấy luôn khóa chế độ độc quyền trong lúc đọc.
And that way, if it fails, you're not, you know, you didn't read data, you didn't run the read query that you end up rolling back unnecessarily. Yes?
Và như vậy, nếu thất bại, bạn không, bạn biết đấy, bạn chưa đọc dữ liệu, bạn chưa chạy truy vấn đọc mà rốt cuộc phải rollback một cách không cần thiết. Bạn hỏi?
The question is, if you're running your transaction at a lower isolation level, which we will cover next class, does this change the semantics? No. No. Well, hold on. Let me think about that.
Câu hỏi là nếu bạn chạy giao dịch ở mức cô lập thấp hơn, mà chúng ta sẽ học ở buổi sau, thì điều này có thay đổi ngữ nghĩa không? Không. Không. À khoan. Để tôi nghĩ đã.
Excuse me. Yeah, for the transaction, if you take something, if you take it in exclusive lock mode, you're basically, you're putting things in serial order potentially.
Xin lỗi nhé. Ừ, với giao dịch, nếu bạn lấy một thứ gì đó, nếu bạn lấy nó ở chế độ khóa độc quyền, về cơ bản bạn có thể đang đưa mọi thứ vào thứ tự tuần tự.
We'll cover that next class. Yeah. We haven't talked about isolation levels yet.
Chúng ta sẽ học buổi sau. Ừ. Chúng ta chưa nói về các mức cô lập.
Another cool trick you can do is this little hint, which I know works in Postgres, I don't think, I forget what's in the SQL standard, but a bunch of systems support this.
Một mẹo hay khác bạn có thể dùng là gợi ý nhỏ này, mà tôi biết chạy được trong Postgres, tôi không nghĩ là, tôi quên mất chuẩn SQL có gì, nhưng nhiều hệ thống hỗ trợ cái này.
It's called SKIP LOCKED. Basically, you say, run my select query and anytime that you come across a tuple that you can't get the share lock for, just skip it.
Nó gọi là SKIP LOCKED. Về cơ bản, bạn nói: hãy chạy truy vấn select của tôi và bất cứ khi nào gặp một tuple mà bạn không lấy được khóa chia sẻ, thì cứ bỏ qua nó.
Ignore it. Don't have it be part of its output.
Lờ nó đi. Đừng đưa nó vào kết quả đầu ra.
And this is kind of weird because you say, "Oh, well, that means I could potentially run the same query on the same data multiple times and actually get different results."
Điều này hơi kỳ lạ vì bạn sẽ nói: "Ồ, vậy nghĩa là tôi có thể chạy cùng một truy vấn trên cùng dữ liệu nhiều lần mà lại nhận được các kết quả khác nhau."
Yeah, you can. And for some applications, some scenarios, that's okay. So this is common when you use databases for queues. Like work queues.
Đúng, có thể. Và với một số ứng dụng, một số tình huống, điều đó vẫn ổn. Nên cái này phổ biến khi bạn dùng cơ sở dữ liệu làm hàng đợi. Như hàng đợi công việc.
So you say you have a single queue, or here's all the tasks I want, the jobs I want to run in my system, and you have a bunch of workers outside the system, like application code, polling the queue and saying, "What's the next task I should run?"
Giả sử bạn có một hàng đợi duy nhất, hay đây là tất cả các tác vụ, các công việc tôi muốn chạy trong hệ thống, và bạn có nhiều worker bên ngoài hệ thống, như mã ứng dụng, thăm dò hàng đợi và hỏi: "Tác vụ tiếp theo tôi nên chạy là gì?"
And so when you poll the queue, you don't want to wait for a lock to be released by another worker who's polling the queue.
Và khi bạn thăm dò hàng đợi, bạn không muốn phải chờ một khóa được nhả ra bởi một worker khác đang thăm dò hàng đợi.
If they're pulling something out, I'm going to start running it. They're going to update the status, say, "Job is taken."
Nếu họ đang lấy một thứ ra, tôi sẽ bắt đầu chạy nó. Họ sẽ cập nhật trạng thái, kiểu như "Công việc đã được nhận."
So you just now, with skip lock, you just skip whatever you can't acquire the locks for, and that way you can get the next thing in the queue, which is pretty cool.
Vậy là với skip lock, bạn chỉ bỏ qua bất cứ thứ gì mình không lấy được khóa, và như vậy bạn có thể lấy mục tiếp theo trong hàng đợi, khá hay đấy.
It's a weaker form of FOR UPDATE. It just prevents you from seeing things that, like, it's preventing things you just can't acquire the lock for.
Đây là một dạng yếu hơn của FOR UPDATE. Nó chỉ ngăn bạn nhìn thấy những thứ mà, tức là nó loại bỏ những thứ bạn không thể lấy được khóa.
Whereas FOR UPDATE is trying to force you to acquire the lock when you try to read it.
Trong khi FOR UPDATE cố buộc bạn phải lấy được khóa khi bạn cố đọc dữ liệu đó.
All right, before we flip over to the Firebolt talk, again, two-phase locking, or some variant of two-phase locking, you use in pretty much every single data system around, even for the multi-versioning ones we'll cover next week.
Được rồi, trước khi chuyển sang bài nói của Firebolt, nhắc lại về khóa hai pha, hoặc một biến thể nào đó của khóa hai pha, được dùng trong hầu như mọi hệ thống dữ liệu hiện nay, kể cả những hệ thống đa phiên bản mà chúng ta sẽ học vào tuần sau.
And we talked about how there's different variations of two-phase locking, strong two-phase locking. I'll follow up on Piazza about the distinction between strict versus strong and rigorous. But we'll follow whatever's in the textbook.
Và chúng ta đã nói về các biến thể khác nhau của khóa hai pha, khóa hai pha mạnh. Tôi sẽ trả lời thêm trên Piazza về sự khác biệt giữa strict với strong và rigorous. Nhưng chúng ta sẽ theo những gì có trong giáo trình.
And we showed how to deal with deadlocks, either through detection or prevention. And then we showed how to acquire different locks at different levels in the hierarchy. We didn't talk about nested transactions.
Và chúng ta đã xem cách xử lý bế tắc, bằng phát hiện hoặc phòng ngừa. Rồi chúng ta cũng đã xem cách lấy các khóa khác nhau ở các mức khác nhau trong hệ thống phân cấp. Chúng ta chưa nói về các giao dịch lồng nhau.
We didn't talk about save points in more detail. We can go over that for our next class.
Chúng ta cũng chưa nói chi tiết hơn về save point. Chúng ta có thể xem phần đó trong buổi học sau.
Next class, we'll spend more time talking about the, sorry, we'll spend time talking about optimistic concurrency protocols, whereas two-phase locking is a pessimistic one.
Buổi sau, chúng ta sẽ dành thêm thời gian nói về, xin lỗi, chúng ta sẽ dành thời gian nói về các giao thức điều khiển đồng thời lạc quan, trong khi khóa hai pha là giao thức bi quan.
And we'll see variations of that, and then that'll lead us into multi-versioning.
Và chúng ta sẽ thấy các biến thể của nó, rồi từ đó dẫn sang đa phiên bản.
And then we'll bring up the thing that they mentioned about different isolation levels, where you can actually run, sort of, you run at lower, you run the transactions with lower guarantees about the anomalies that we're trying to avoid with serializability.
Và sau đó chúng ta sẽ nhắc đến điều mà họ đã đề cập về các mức cô lập khác nhau, trong đó bạn thực sự có thể chạy, bạn chạy các giao dịch ở mức thấp hơn, với ít đảm bảo hơn về các dị thường mà chúng ta đang cố tránh bằng tính khả tuần tự.
Okay? Question, yes.
Được chứ? Câu hỏi, mời bạn.
Question is, can this produce incomplete results? Yes. So you wouldn't want to do it for your regular application.
Câu hỏi là liệu cách này có thể cho kết quả không đầy đủ không? Có. Vì vậy bạn sẽ không muốn dùng nó cho ứng dụng thông thường.
It's like for certain scenarios, like pulling a queue, where I don't care about the things I can't get access to. I only care about the, you know, fresh things. This does that.
Nó dành cho một số tình huống, như lấy việc từ hàng đợi, nơi tôi không quan tâm đến những thứ mình không truy cập được. Tôi chỉ quan tâm đến những thứ mới. Cách này làm được điều đó.
All right, this is Ben. As I said, he's German, and the good kind. He's from TU Munich.
Được rồi, đây là Ben. Như tôi đã nói, anh ấy là người Đức, và thuộc loại tốt. Anh ấy đến từ TU Munich.
He was a protege of Thomas Neumann, which is one of the best database researchers in the world. And now he, you started, you did EP engineering at age like 24, right?
Anh ấy là học trò cưng của Thomas Neumann, một trong những nhà nghiên cứu cơ sở dữ liệu giỏi nhất thế giới. Và giờ anh, anh bắt đầu làm kỹ sư ở tuổi khoảng 24, đúng không?
No, I'm 26 now. No, when you started at Firewall. When I started at Firewall, I was like 22, I think. Even you're very impressive.
Không, giờ tôi 26. Không, ý tôi là khi anh bắt đầu ở Firewall. Khi bắt đầu ở Firewall, tôi khoảng 22, tôi nghĩ vậy. Thế thì anh càng ấn tượng.
The Germans are very good at this. This is Ben. He's very smart. Go for it, man. Thank you for the kind introduction, and you're being too nice. Cool.
Người Đức rất giỏi chuyện này. Đây là Ben. Anh ấy rất thông minh. Mời anh bắt đầu. Cảm ơn vì lời giới thiệu tốt đẹp, anh quá khen. Tuyệt.
So I know all of you learned about kind of query planners over the last couple of weeks, and we thought maybe it's interesting to you to get our industry perspective on query planners, and very specifically cardinality estimates.
Tôi biết các bạn đều đã học về bộ lập kế hoạch truy vấn trong vài tuần qua, và chúng tôi nghĩ có lẽ các bạn sẽ thấy thú vị khi biết góc nhìn từ ngành về bộ lập kế hoạch truy vấn, và cụ thể là các ước lượng lực lượng.
So we decided to talk, title the talk Be Weary of Cardinality Estimates. And one thing that I think is important context, wait a second, I can't skip slides right now.
Vì vậy chúng tôi quyết định đặt tên bài nói là Hãy thận trọng với các ước lượng lực lượng. Và có một điều tôi nghĩ là bối cảnh quan trọng, khoan đã, bây giờ tôi không chuyển slide được.
Oh, something broke on my end. Perfect. Is that whenever you build a query optimizer, it's really important to put it in the context of the workload you're going to run in the system, right?
Ồ, máy của tôi bị trục trặc rồi. Tuyệt thật. Đó là bất cứ khi nào bạn xây dựng một bộ tối ưu hóa truy vấn, điều rất quan trọng là đặt nó trong bối cảnh của khối lượng công việc mà bạn sẽ chạy trên hệ thống, đúng không?
Like different types of database systems will require different types of optimizers. And so I wanted to tell you a bit about the workloads we care most about running at Firebolt.
Chẳng hạn, các loại hệ quản trị cơ sở dữ liệu khác nhau sẽ đòi hỏi các loại bộ tối ưu hóa khác nhau. Vì vậy tôi muốn nói với các bạn một chút về những khối lượng công việc mà chúng tôi quan tâm nhất khi chạy tại Firebolt.
First of all, it's an analytical database and it's scale out. So it's Postgres compliant, but we usually run on terabytes of data, petabytes of data.
Trước hết, đây là một cơ sở dữ liệu phân tích và có khả năng mở rộng theo chiều ngang. Nó tuân thủ Postgres, nhưng thường chúng tôi chạy trên hàng terabyte, hàng petabyte dữ liệu.
And in many cases, customers build basically mission critical real-time applications on top of Firebolt. So what that means is that individual queries need to run really, really quickly.
Và trong nhiều trường hợp, khách hàng xây dựng các ứng dụng thời gian thực mang tính sống còn ngay trên nền Firebolt. Điều đó có nghĩa là từng truy vấn riêng lẻ cần chạy thật, thật nhanh.
We're talking about tens of milliseconds, maybe hundreds of milliseconds if they touch more data. And there's very high concurrency. So we have cases where you have maybe thousands of QPS, hundreds of QPS.
Chúng tôi nói đến hàng chục mili giây, có thể là hàng trăm mili giây nếu chúng đụng đến nhiều dữ liệu hơn. Và mức độ đồng thời rất cao. Có những trường hợp bạn có thể có hàng nghìn QPS, hàng trăm QPS.
And usually, as I said, these workloads are mission critical. Now, the other thing which is quite interesting about these workloads is you usually have pretty predictable and repetitive query patterns.
Và thường thì, như tôi đã nói, những khối lượng công việc này mang tính sống còn. Còn một điều khá thú vị khác về các khối lượng công việc này là thường có các mẫu truy vấn khá dễ đoán và lặp đi lặp lại.
Think about someone, for example, I don't know, building out like a customer-facing observability solution that gives metrics into their application. You will see the same types of dashboards over and over again.
Ví dụ hãy nghĩ đến một người nào đó, tôi không biết nữa, đang xây dựng một giải pháp quan sát hệ thống hướng đến khách hàng cung cấp các chỉ số về ứng dụng của họ. Bạn sẽ thấy cùng những loại dashboard xuất hiện lặp đi lặp lại.
Maybe our customer has 10,000 customers or 100,000 customers looking at that application, but fundamentally, it's the same dashboards being run over and over again.
Có thể khách hàng của chúng tôi có 10.000 khách hàng hoặc 100.000 khách hàng xem ứng dụng đó, nhưng về căn bản, vẫn là những dashboard đó được chạy đi chạy lại.
If we run these workloads and we have predictable and repetitive query patterns, we must have predictable query performance. This is the most important thing for us.
Nếu chúng tôi chạy các khối lượng công việc này và có các mẫu truy vấn dễ đoán và lặp lại, thì chúng tôi phải có hiệu năng truy vấn dễ dự đoán. Đây là điều quan trọng nhất đối với chúng tôi.
And this is ultimately what our customers pay us for and what they expect from our service given that, for them, Firebolt is a mission critical piece of infrastructure.
Và đây cuối cùng chính là thứ khách hàng trả tiền cho chúng tôi, và là điều họ mong đợi từ dịch vụ của chúng tôi, vì đối với họ, Firebolt là một phần hạ tầng mang tính sống còn.
And so now the question becomes when you're building a database in industry or also in academia, what can actually make SQL performance unpredictable? And there's a few things you might think about right away.
Và như vậy câu hỏi bây giờ là, khi bạn xây dựng một cơ sở dữ liệu trong ngành hay cả trong giới học thuật, điều gì thực sự có thể làm hiệu năng SQL trở nên khó dự đoán? Và có vài điều bạn có thể nghĩ đến ngay.
So maybe the ingestion pattern changed, right? Like they're ingesting three times as much data now, four times as much data, and queries are just becoming heavier. The reality is this doesn't usually happen.
Có thể mẫu nạp dữ liệu đã thay đổi, đúng không? Chẳng hạn bây giờ họ nạp nhiều gấp ba lần dữ liệu, gấp bốn lần dữ liệu, và các truy vấn cứ nặng dần lên. Thực tế là điều này thường không xảy ra.
Especially when customers of ours are building out their mission critical production workloads, they take great care to make sure that things are very predictable, right?
Đặc biệt khi khách hàng của chúng tôi đang xây dựng các khối lượng công việc production mang tính sống còn của họ, họ rất cẩn thận để đảm bảo mọi thứ luôn rất dễ dự đoán, đúng không?
Because we're usually working with platform engineering teams, infrastructure engineering teams. They are experts on running data infrastructure, and they are making sure that their ingestion patterns are very predictable.
Vì chúng tôi thường làm việc với các nhóm platform engineering, các nhóm kỹ sư hạ tầng. Họ là chuyên gia vận hành hạ tầng dữ liệu, và họ đảm bảo rằng các mẫu nạp dữ liệu của mình rất dễ dự đoán.
Now, the other thing you might say is maybe query patterns are changing. Here as well, this doesn't usually happen.
Còn một điều khác bạn có thể nói là có lẽ các mẫu truy vấn đang thay đổi. Ở đây cũng vậy, điều này thường không xảy ra.
So with agents running SQL queries, it's actually a bit different, and there's a lot of interesting things happening there right now.
Với các agent chạy truy vấn SQL thì thực ra có hơi khác, và hiện nay có rất nhiều điều thú vị đang diễn ra ở mảng đó.
At least for this talk, kind of let's skip that part and focus on more maybe traditional workloads, which in our case often have predictable query patterns.
Ít nhất trong buổi nói chuyện này, ta hãy bỏ qua phần đó và tập trung vào các khối lượng công việc truyền thống hơn, mà trong trường hợp của chúng tôi thường có các mẫu truy vấn dễ dự đoán.
You're not, you're just never in a situation where you see a query pattern that you haven't seen before. It doesn't happen. The other thing that might happen is a load spike, right?
Bạn gần như không bao giờ rơi vào tình huống phải thấy một mẫu truy vấn mà bạn chưa từng thấy trước đây. Điều đó không xảy ra. Một điều khác có thể xảy ra là tải tăng đột biến, đúng không?
Okay, there's now 10,000 users signing into the application. Everyone wants to look at their customer-facing data app. Now, this does happen.
Giả sử bây giờ có 10.000 người dùng đăng nhập vào ứng dụng. Ai cũng muốn xem ứng dụng dữ liệu dành cho khách hàng của mình. Điều này thì có xảy ra.
It doesn't happen that often, but when it happens, there are safeguards you should just build into your system. It's not rocket science.
Nó không xảy ra thường xuyên, nhưng khi xảy ra, có những cơ chế bảo vệ mà bạn nên xây dựng sẵn vào hệ thống. Việc này không phải là khoa học tên lửa.
First of all, you should have a robust queuing system, and you should also have auto-scaling, right?
Trước hết, bạn nên có một hệ thống hàng đợi vững chắc, và bạn cũng nên có auto-scaling, đúng không?
You should be able to basically handle that load spike by provisioning more compute and just getting through that backlog that may be built up.
Về cơ bản bạn phải có khả năng xử lý đợt tải tăng đột biến đó bằng cách cấp phát thêm tài nguyên tính toán và xử lý hết lượng công việc tồn đọng có thể đã tích tụ.
Now, the last thing is maybe you over-engineered your system and you thought you were really making it better. And in our experience, that's actually usually what's happening.
Điều cuối cùng là có thể bạn đã thiết kế hệ thống quá phức tạp và nghĩ rằng mình đang làm nó tốt hơn. Và theo kinh nghiệm của chúng tôi, thực ra đó thường là điều đang xảy ra.
And so you're kind of taking a component, kind of you think you're building this amazing algorithm, kind of making it super smart, but ultimately, you're maybe making it very smart and it's helping in 90% of cases, but you're also making things very unpredictable.
Tức là bạn lấy một thành phần, nghĩ rằng mình đang xây dựng một thuật toán tuyệt vời, làm cho nó cực kỳ thông minh, nhưng rốt cuộc bạn làm nó rất thông minh và nó giúp ích trong 90% trường hợp, nhưng đồng thời cũng khiến mọi thứ rất khó dự đoán.
And this is especially important for query planners, because fundamentally, your query planner can do the most good in your database systems.
Và điều này đặc biệt quan trọng với trình lập kế hoạch truy vấn, vì về cơ bản, trình lập kế hoạch truy vấn có thể mang lại nhiều lợi ích nhất trong hệ cơ sở dữ liệu của bạn.
Having a good planner maybe gives you 100x, 1,000x query performance improvements in many cases. That's very hard to do with just having a faster database runtime, for example.
Có một trình lập kế hoạch tốt có thể giúp bạn cải thiện hiệu năng truy vấn 100 lần, thậm chí 1.000 lần trong nhiều trường hợp. Ví dụ, chỉ dùng một runtime cơ sở dữ liệu nhanh hơn thì rất khó đạt được như vậy.
However, if you have all of that power and you can do the most good, usually you can also do the most hard.
Tuy nhiên, nếu bạn có tất cả sức mạnh đó và có thể mang lại nhiều lợi ích nhất, thì thường bạn cũng có thể gây ra nhiều tác hại nhất.
And now, for the remainder of the talk, let's actually touch through what that means for the way we're building our query planner at Firebolt.
Và bây giờ, trong phần còn lại của buổi nói chuyện, ta hãy cùng xem điều đó có ý nghĩa gì với cách chúng tôi xây dựng trình lập kế hoạch truy vấn tại Firebolt.
Now, by the way, one thing I wanted to mention is just now, at VLDB 2025, there was the Test of Time Award given to the paper "How Good Are Query Optimizers, Really?"
Nhân tiện, một điều tôi muốn nhắc là vừa mới đây, tại VLDB 2025, giải Test of Time đã được trao cho bài báo "How Good Are Query Optimizers, Really?"
And you can already see in the abstract basically that they're saying cardinality estimates can be wildly off, and that makes query plans a lot worse for many systems.
Và bạn có thể thấy ngay trong phần tóm tắt rằng họ nói các ước lượng cardinality có thể lệch rất nhiều, và điều đó làm các kế hoạch truy vấn tệ đi nhiều ở nhiều hệ thống.
This is a great paper to read. Again, just got this great award at VLDB. So, take a look at it. All right. Moving back to Firebolt's world. So, our planner is Postgres compliant.
Đây là một bài báo rất đáng đọc. Một lần nữa, nó vừa nhận giải thưởng danh giá này tại VLDB. Các bạn hãy xem qua bài báo đó nhé. Được rồi. Quay lại với thế giới của Firebolt. Bộ lập kế hoạch của chúng tôi tương thích với Postgres.
However, we actually don't have Postgres code inside of it. So, that's an important distinction. Even though dialect-wise we're compliant with Postgres, it's basically built from scratch, all in C++.
Tuy nhiên, bên trong thực ra chúng tôi không có mã nguồn của Postgres. Đây là một điểm khác biệt quan trọng. Dù về mặt phương ngữ thì chúng tôi tương thích với Postgres, nhưng về cơ bản nó được xây dựng từ đầu, hoàn toàn bằng C++.
We modeled a lot of things after Calcite.
Chúng tôi mô phỏng nhiều thứ theo Calcite.
And if you look at the core optimization stack, there's at this point I think more than 170 rules that do rule-based optimization, right, filter pushdown, kind of expression optimization, removing redundant aggregates, removing redundant joins, all of the things you learned about in the last couple of classes.
Và nếu nhìn vào phần lõi của hệ thống tối ưu hóa, hiện nay tôi nghĩ có hơn 170 luật dùng cho tối ưu hóa dựa trên luật, chẳng hạn đẩy bộ lọc xuống, tối ưu hóa biểu thức, loại bỏ các phép tổng hợp dư thừa, loại bỏ các phép nối dư thừa, tất cả những thứ các bạn đã học trong vài buổi học vừa qua.
And one set of rules we're especially proud of is, I think we did a great job building rules that eliminate redundancy in machine-generated queries.
Và có một nhóm luật mà chúng tôi đặc biệt tự hào, tôi nghĩ chúng tôi đã làm rất tốt khi xây dựng các luật loại bỏ sự dư thừa trong các truy vấn do máy sinh ra.
And we, for example, just published a paper at BTW this year, if you want to read more about that and learn about some maybe interesting industry rules and industry systems.
Chẳng hạn, năm nay chúng tôi vừa công bố một bài báo tại BTW, nếu các bạn muốn đọc thêm về nội dung đó và tìm hiểu về một số luật và hệ thống trong thực tế công nghiệp khá thú vị.
The other thing we're doing is cost-based join reordering. So this is bottom-up, using a join graph, using dynamic programming. I think you learned about that at the end of last week.
Một việc khác chúng tôi làm là sắp xếp lại thứ tự phép nối dựa trên chi phí. Cách này đi từ dưới lên, dùng đồ thị phép nối và quy hoạch động. Tôi nghĩ các bạn đã học về nó vào cuối tuần trước.
And all of this works on Iceberg tables as well, which is just an important thing to point out.
Và tất cả những điều này cũng hoạt động trên các bảng Iceberg, đây là điều quan trọng cần nhấn mạnh.
Iceberg is becoming mainstream, kind of every good modern analytical database system should have great Iceberg support, and we've done a lot of work wiring Iceberg throughout our query planner.
Iceberg đang trở nên phổ biến, mọi hệ cơ sở dữ liệu phân tích hiện đại tốt đều nên hỗ trợ Iceberg thật tốt, và chúng tôi đã bỏ nhiều công sức tích hợp Iceberg xuyên suốt bộ lập kế hoạch truy vấn.
Now, what does this mean in terms of kind of being wary of cardinality estimates?
Vậy điều này có ý nghĩa gì khi cần thận trọng với các ước lượng cardinality?
And usually when we onboard an engineer into the planner team, kind of this is the slide I would show them and this is the thing I would talk them through.
Thông thường khi đưa một kỹ sư mới vào nhóm lập kế hoạch, đây là slide tôi sẽ cho họ xem và là điều tôi sẽ giải thích cho họ.
First of all, for us, predictable query plans are more important than finding the perfect plan.
Trước hết, với chúng tôi, kế hoạch truy vấn dự đoán được quan trọng hơn việc tìm ra kế hoạch hoàn hảo.
I would rather have a plan that is not perfect but very predictable, and where a user can really rely on very consistent performance for their production workload.
Tôi thà có một kế hoạch không hoàn hảo nhưng rất dễ dự đoán, để người dùng thực sự có thể tin cậy vào hiệu năng rất ổn định cho khối lượng công việc production của họ.
Now, if we don't always find the perfect plan, we want to give users control, and this is something we've been actually working a lot on over the course of this year.
Nếu không phải lúc nào cũng tìm được kế hoạch hoàn hảo, chúng tôi muốn trao quyền kiểm soát cho người dùng, và đây là điều chúng tôi thực sự đã làm rất nhiều trong suốt năm nay.
At this point, we allow users to fix a specific join order, we allow them to fix their distributed aggregation strategy, whether there should be a pre-aggregation or not, and we have a few other levers as well that we give to our customers if they really want to force a specific query plan.
Hiện nay, chúng tôi cho phép người dùng cố định một thứ tự nối cụ thể, cho phép họ cố định chiến lược tổng hợp phân tán, tức là có nên tổng hợp trước hay không, và chúng tôi còn cung cấp cho khách hàng một vài công cụ điều khiển khác nếu họ thực sự muốn ép dùng một kế hoạch truy vấn cụ thể.
The other rule is: avoid using cardinality estimates at all costs. Our rule is basically we only use cardinality estimates for join ordering because the payoff can be that big, right?
Quy tắc còn lại là: tránh dùng ước lượng cardinality bằng mọi giá. Quy tắc của chúng tôi về cơ bản là chỉ dùng ước lượng cardinality cho việc sắp xếp thứ tự nối vì lợi ích thu được có thể rất lớn, đúng không?
This is what I meant earlier with if you get your join ordering right.
Đây chính là điều tôi đã nói lúc trước, nếu các bạn chọn đúng thứ tự nối.
It can easily be 100x or 1,000x, but we think in most other places using cardinality estimates is not worth it and does more harm than good.
Nó có thể dễ dàng lên tới 100 lần hoặc 1.000 lần, nhưng chúng tôi nghĩ ở hầu hết những chỗ khác, việc dùng ước lượng cardinality là không đáng và gây hại nhiều hơn có lợi.
And one last thing, and this is actually important to think through: you'll probably have to solve the same problem in Iceberg one day.
Và một điều cuối cùng, điều này thực sự quan trọng, các bạn nên suy nghĩ kỹ: một ngày nào đó có lẽ bạn sẽ phải giải quyết cùng vấn đề này trong Iceberg.
And the reality is you actually have to have a lot of control on your managed formats over what statistics you collect. With Iceberg, things are becoming a lot harder.
Và thực tế là bạn thực sự cần có nhiều quyền kiểm soát trên các định dạng được quản lý đối với việc thu thập thống kê nào. Với Iceberg, mọi thứ đang trở nên khó hơn nhiều.
In many cases you really only have the table row count.
Trong nhiều trường hợp, bạn thực sự chỉ có số dòng của bảng.
If we look under the hood of Firebolt, I wanted to share one really simple example with you that actually shows how hard all of this gets.
Nếu nhìn vào bên trong Firebolt, tôi muốn chia sẻ với các bạn một ví dụ thực sự đơn giản cho thấy tất cả những chuyện này khó đến mức nào.
So here we're doing a join between two Iceberg tables. One Iceberg table is 70,000 rows. That's the one on the right side, the build side of the join.
Ở đây chúng ta đang thực hiện phép join giữa hai bảng Iceberg. Một bảng Iceberg có 70.000 dòng. Đó là bảng ở bên phải, phía build của phép join.
And one Iceberg table has five billion rows. That's the events table to the left, and that's on the probe side. Now, the Iceberg scan to the left on the large table is filtered.
Còn bảng Iceberg kia có năm tỉ dòng. Đó là bảng events ở bên trái, và nằm ở phía probe. Bây giờ, phép quét Iceberg bên trái trên bảng lớn có áp dụng bộ lọc.
And we have this filter called tracker equals RB080.
Và chúng ta có bộ lọc tracker equals RB080.
Now, the question is what cardinality estimate do we actually put above this filter if we only have the base table row counts from that Iceberg table?
Câu hỏi bây giờ là chúng ta thực sự đặt ước lượng cardinality nào phía trên bộ lọc này nếu chúng ta chỉ có số dòng của bảng gốc từ bảng Iceberg đó?
And to give a concrete example, basically we want to estimate the selectivity of this tracker filter, and the intuition here often is if you have a lot of rows, you probably have more distinct values.
Và để đưa ra một ví dụ cụ thể, về cơ bản chúng ta muốn ước lượng độ chọn lọc của bộ lọc tracker này, và trực giác ở đây thường là nếu bạn có nhiều dòng, thì có lẽ bạn có nhiều giá trị phân biệt hơn.
And there's this well-known SQL Server formula, which is basically a magic number or kind of a formula someone came up with, that gives you the selectivity.
Và có một công thức nổi tiếng của SQL Server, về cơ bản là một con số kỳ diệu, hay một công thức mà ai đó nghĩ ra, để cho bạn độ chọn lọc.
And if you apply this formula, you get 70,000 rows as your cardinality estimate.
Và nếu áp dụng công thức này, bạn được 70.000 dòng làm ước lượng cardinality.
Now, this is terrible, because this is exactly the same estimate as you have on the other table, which basically means that if the tables change a bit and you have some inserts happening, your plans will start flapping like crazy.
Điều này thật tệ, vì đây chính xác là ước lượng giống hệt bảng còn lại, nghĩa là nếu các bảng thay đổi đôi chút và có một vài thao tác insert xảy ra, các kế hoạch của bạn sẽ bắt đầu đổi qua đổi lại liên tục.
You insert a few rows to the right, put that on the build side, insert a few rows to the left, put that on the build side.
Bạn insert vài dòng vào bên phải, thì đưa bảng đó sang phía build, insert vài dòng vào bên trái, lại đưa bảng đó sang phía build.
And one thing we've been working on over the past couple of months, and that's kind of making its way into production right now, is actually we're carrying estimation bounds through our plans.
Và một việc chúng tôi đã làm trong vài tháng qua, và hiện đang dần được đưa vào production, là mang các cận ước lượng xuyên suốt các kế hoạch của chúng tôi.
And this is also the last slide I want to end with. And I think this is pretty cool and just something you maybe haven't seen so far.
Và đây cũng là slide cuối cùng tôi muốn kết thúc. Tôi nghĩ nó khá hay và có thể là điều các bạn chưa thấy trước đây.
We propagate through our entire query plan basically guaranteed lower and upper bounds. What this means is, for your base table, we know the exact number from Iceberg metadata.
Chúng tôi lan truyền qua toàn bộ kế hoạch truy vấn các cận dưới và cận trên được đảm bảo. Điều này có nghĩa là, với bảng gốc, chúng tôi biết con số chính xác từ siêu dữ liệu của Iceberg.
We know left side is 5 billion to 5 billion rows, right side is 70K to 70K rows.
Chúng tôi biết bên trái là từ 5 tỉ đến 5 tỉ dòng, bên phải là từ 70K đến 70K dòng.
And then on the filter on top on the left side, we do our basically expected value estimation, let's say, based on the SQL Server formula, but we also carry that it could actually be between zero and 5 billion rows.
Và sau đó với bộ lọc phía trên ở bên trái, chúng tôi thực hiện ước lượng theo giá trị kỳ vọng, giả sử, dựa trên công thức của SQL Server, nhưng chúng tôi cũng giữ lại thông tin rằng thực tế số dòng có thể nằm trong khoảng từ 0 đến 5 tỉ.
And that's what we do. And then here in join ordering, we do traditional cost-based bottom-up join reordering, but we also do a risk minimization pass.
Và đó là những gì chúng tôi làm. Sau đó, ở phần sắp xếp lại thứ tự join, chúng tôi thực hiện sắp xếp lại join từ dưới lên theo chi phí như truyền thống, nhưng chúng tôi cũng có thêm một bước giảm thiểu rủi ro.
And we basically take a look at the join order we chose cost-based.
Về cơ bản, chúng tôi xem xét thứ tự join đã được chọn dựa trên chi phí.
And if we can guarantee with the bounds that certain tables are going to be small or certain sub plans are going to be small, we put those on the build side.
Và nếu nhờ các cận mà chúng tôi đảm bảo được một số bảng sẽ nhỏ, hoặc một số kế hoạch con sẽ nhỏ, thì chúng tôi đặt chúng ở phía build.
And so what this means in our planner, even though we might not be able to estimate the filter, we will always put the small side on the build side, the smaller table on the build side, just to minimize risk for our customers.
Vì vậy, điều này có nghĩa là trong bộ lập kế hoạch của chúng tôi, dù có thể không ước lượng được bộ lọc, chúng tôi sẽ luôn đặt phía nhỏ ở phía build, tức là bảng nhỏ hơn ở phía build, chỉ để giảm thiểu rủi ro cho khách hàng của chúng tôi.
And so, yeah, if that's one concrete example, we're doing a lot more under the hood. Feel free to shoot me an email or whatever.
Và đó là một ví dụ cụ thể, chúng tôi còn làm nhiều việc khác ở bên dưới nữa. Cứ thoải mái gửi email cho tôi nhé.
I'm excited to talk about these things. Thanks for your attention. Bye.
Tôi rất hào hứng được trao đổi về những chủ đề này. Cảm ơn mọi người đã chú ý. Tạm biệt.
Bye. Bye.
Tạm biệt. Tạm biệt.
Bye. Bye. Bye. Bye. Bye. Bye. Bye. Bye. Bye. Bye.
Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt.
Bye. Bye. Bye. Bye.
Tạm biệt. Tạm biệt. Tạm biệt. Tạm biệt.
Đă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.