Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Alright, give it up for DJ Kash. You look swell. Thank you, thank you. Why? I'm just coming back from court.
Được rồi, hãy dành một tràng pháo tay cho DJ Kash nào. Trông bạn bảnh đấy. Cảm ơn, cảm ơn. Sao vậy? Tôi vừa từ sân về.
I played a basketball game and saw my relatives. Did you win or you don't know yet? I'm not too sure. I'll let you know next week. Okay. There's a lot of announcements.
Tôi chơi một trận bóng rổ và gặp họ hàng. Bạn thắng hay chưa biết kết quả? Tôi cũng không chắc lắm. Tuần sau tôi sẽ báo cho mọi người. Được rồi. Có rất nhiều thông báo.
Actually, announcing for you as well. You have a radio show starting this week. I do, I do, on Sunday. This Sunday.
Thực ra là tôi cũng đang thông báo giúp bạn luôn. Bạn có một chương trình radio bắt đầu từ tuần này. Đúng vậy, vào Chủ nhật. Chủ nhật này.
From 1 to 2 p.m. I have a show starting from WRCT. You guys should all walk in. Alright. This Sunday, DJ Kash is on the radio. Are they paying you or no? No.
Từ 1 đến 2 giờ chiều. Tôi có một chương trình bắt đầu trên WRCT. Mọi người nên ghé vào nhé. Được rồi. Chủ nhật này, DJ Kash lên sóng radio. Họ có trả tiền cho bạn không? Không.
Alright, you gotta work on that. Okay. For you guys in the class, Homework 2 is gonna go out today. That'll be on the 21st. Project 1 got released yesterday.
Được rồi, bạn phải xử lý chuyện đó đi. Được thôi. Với các bạn trong lớp, Homework 2 sẽ được phát hôm nay. Hạn nộp là ngày 21. Project 1 đã được công bố hôm qua.
And that's gonna be due on September 29th. Has anybody looked at Project 1 yet? Are there any questions about Project 1?
Và hạn nộp là ngày 29 tháng 9. Đã ai xem Project 1 chưa? Có câu hỏi nào về Project 1 không?
So we'll announce the recitation. That'll be next week. But all the files and everything should be on GitHub. So pull down the latest version and make sure you're working off that code base.
Chúng tôi sẽ thông báo về buổi thảo luận. Đó sẽ là tuần sau. Nhưng tất cả các tệp và mọi thứ đều có trên GitHub. Vì vậy hãy kéo phiên bản mới nhất về và đảm bảo các bạn làm việc trên mã nguồn đó.
And then as I said last class, next Monday and Tuesday on the 16th and 17th, we are having our Industry Affiliates Visit Day.
Và như tôi đã nói ở buổi trước, thứ Hai và thứ Ba tuần sau, ngày 16 và 17, chúng ta có Ngày thăm của các đối tác doanh nghiệp (Industry Affiliates Visit Day).
So a bunch of database friends from various companies are coming to campus to give talks and meet with you guys.
Rất nhiều người bạn làm về cơ sở dữ liệu từ nhiều công ty sẽ đến trường để thuyết trình và gặp gỡ các bạn.
So 15th will be research talks and poster sessions with students and other researchers at CMU.
Ngày 15 sẽ là các buổi báo cáo nghiên cứu và các buổi trưng bày poster với sinh viên và các nhà nghiên cứu khác ở CMU.
And then on the 16th, in the morning before like 12:30, there'll be three sessions of different talks from the companies. You can talk to them about internships and full-time positions.
Còn ngày 16, vào buổi sáng, trước khoảng 12:30, sẽ có ba phiên với các bài nói khác nhau từ các công ty. Các bạn có thể trao đổi với họ về thực tập và các vị trí toàn thời gian.
And like I said, we'll send them your resumes if you fill out the spreadsheet that I posted on Piazza. Okay? Yes, question. The question is, is there a list of research talks and times?
Và như tôi đã nói, chúng tôi sẽ gửi hồ sơ của các bạn cho họ nếu các bạn điền vào bảng tính mà tôi đã đăng trên Piazza. Được chứ? Vâng, mời bạn hỏi. Câu hỏi là có danh sách các buổi báo cáo nghiên cứu và giờ giấc không?
Yes. So that link, In the slides, that link will take you to the page. We don't have, the finalized schedule is not ready yet, but that'll be posted probably tomorrow.
Có. Trong slide, đường liên kết đó sẽ dẫn các bạn đến trang. Hiện chưa có, lịch trình cuối cùng vẫn chưa xong, nhưng có lẽ ngày mai sẽ được đăng.
And then for the company sessions, once everyone fills out the form tomorrow, we'll figure out what the actual optimal ordering will be.
Còn với các phiên của công ty, khi mọi người điền xong biểu mẫu vào ngày mai, chúng tôi sẽ tìm ra thứ tự tối ưu thực sự.
Okay? Any other questions? All right. So this is very unusual, but there was very, very huge news today in databases, like two hours ago.
Được chứ? Còn câu hỏi nào khác không? Được rồi. Chuyện này rất hiếm, nhưng hôm nay có một tin rất, rất lớn trong giới cơ sở dữ liệu, cách đây khoảng hai tiếng.
Anybody know what it is? Like groundbreaking news, like the biggest news story in your lifetime. Nobody.
Có ai biết đó là gì không? Một tin mang tính đột phá, như tin lớn nhất trong đời các bạn vậy. Không ai biết sao.
Larry Ellison, the founder of Oracle, is now officially the richest person in the world. He dethroned Elon Musk. What's that?
Larry Ellison, người sáng lập Oracle, giờ chính thức là người giàu nhất thế giới. Ông ấy đã hạ bệ Elon Musk. Gì vậy?
Who? I don't know. He doesn't do databases, right? This guy does, right? All right. Larry Ellison is like the OG of database money, right?
Ai cơ? Tôi không biết. Ông ấy đâu có làm cơ sở dữ liệu, đúng không? Còn người này thì có, đúng không? Được rồi. Larry Ellison giống như huyền thoại kiếm tiền từ cơ sở dữ liệu vậy.
He's, again, now he's the richest person in the world. It's all paid for by databases. He owns a Hawaiian island, paid for by databases, and like a big one, right?
Một lần nữa, giờ ông ấy là người giàu nhất thế giới. Tất cả là nhờ cơ sở dữ liệu. Ông ấy sở hữu một hòn đảo ở Hawaii, mua bằng tiền từ cơ sở dữ liệu, mà còn là một đảo lớn nữa, đúng không?
Not the one with the head of all the lepers, right? One you could actually see from like Maui. He bought his son from his fourth marriage a movie studio, right?
Không phải hòn đảo có khu người bệnh phong ấy, đúng không? Mà là hòn đảo mà bạn thực sự có thể nhìn thấy từ Maui. Ông ấy đã mua cho con trai với người vợ thứ tư một hãng phim, đúng không?
He got married last year. The woman, she's 36, he's 80, whatever. Like that's his thing, right? This is a big deal.
Năm ngoái ông ấy cưới vợ. Cô ấy 36 tuổi, ông ấy 80, kệ đi. Đó là sở thích của ông ấy mà, đúng không? Đây là chuyện lớn.
Like, I know he's worked so hard for it and it really means a lot to him, and I sent an email congratulating him.
Tôi biết ông ấy đã làm việc rất vất vả vì điều này và nó có ý nghĩa rất lớn với ông ấy, và tôi đã gửi email chúc mừng ông ấy.
But this is it. This is why we do databases. This right here, right?
Nhưng chính là thế này. Đây là lý do chúng ta làm cơ sở dữ liệu. Chính điều này đây, đúng không?
So, I mean, I would do a round of applause for him, but he's not here, so that'd be kind of weird.
Nên, tôi muốn vỗ tay chúc mừng ông ấy, nhưng ông ấy không có ở đây, nên làm thế sẽ hơi kỳ.
But this, again, he's been bumping back and forth between fifth and seventh, and then earlier in the year, he went to third to second. So this is a big deal.
Nhưng một lần nữa, ông ấy cứ lên xuống giữa vị trí thứ năm và thứ bảy, rồi đầu năm nay, ông ấy đã nhảy từ thứ ba lên thứ hai. Nên đây là chuyện lớn.
And I mean, I get emotional, but this means a lot. Okay. All right, so we're not there yet. We're not at Larry's level. But we'll get there.
Và tôi xúc động, nhưng điều này có ý nghĩa rất lớn. Được rồi. Được rồi, chúng ta chưa tới đó. Chúng ta chưa ở đẳng cấp của Larry. Nhưng sẽ tới thôi.
All right, so last class, we spent time talking about the Buffer Pool Manager, right? We said that this was this component inside of every database system. If you're not using mmap, you shouldn't be.
Được rồi, buổi trước, chúng ta đã dành thời gian nói về Buffer Pool Manager, đúng không? Chúng ta nói rằng đây là thành phần nằm bên trong mọi hệ quản trị cơ sở dữ liệu. Nếu bạn không dùng mmap, thì bạn không nên dùng nó.
If you're going to manage your own memory in your database system, it's the component that is responsible for storing pages, disk database pages, from disk into memory, handing off pointers out to other parts of the system, keeping track of the reference count, or whether they're dirty or not, right?
Nếu bạn định tự quản lý bộ nhớ trong hệ cơ sở dữ liệu của mình, thì đó là thành phần chịu trách nhiệm lưu các trang, các trang cơ sở dữ liệu trên đĩa, từ đĩa vào bộ nhớ, trao con trỏ cho các phần khác của hệ thống, theo dõi bộ đếm tham chiếu, hoặc xem chúng có bị dirty hay không, đúng không?
Seeing all the machinery allows us to have the illusion that our databases actually can fit in memory, even though it may not, right?
Toàn bộ cơ chế này tạo ra ảo giác rằng cơ sở dữ liệu của chúng ta có thể nằm vừa trong bộ nhớ, dù thực tế có thể không, đúng không?
So today's class, I want to quickly go over some three optimizations we missed at the end of the last class.
Vậy buổi hôm nay, tôi muốn điểm nhanh qua ba tối ưu hóa mà chúng ta đã bỏ lỡ ở cuối buổi trước.
Then we're going to jump back now to the disk level and refresh your memory about what tuple-oriented storage looks like.
Sau đó chúng ta sẽ quay lại mức đĩa và nhắc lại để các bạn nhớ lưu trữ hướng tuple trông như thế nào.
And then we're going to look at two alternative methods, index-oriented storage and log-structured storage.
Rồi chúng ta sẽ xem hai phương pháp thay thế, lưu trữ hướng chỉ mục và lưu trữ log-structured.
And then at the end of class today, we'll finish up with a talk from the SingleStore guys, which actually is not a disk... These started off not as a disk-oriented database.
Và cuối buổi hôm nay, chúng ta sẽ kết thúc với bài nói chuyện của các bạn ở SingleStore, hệ này thực ra không phải là hướng đĩa... Ban đầu họ không bắt đầu với một cơ sở dữ liệu hướng đĩa.
It was an in-memory database where the primary storage location of the database was in memory. They switched to that, but it's a pretty state-of-the-art system.
Đó là một cơ sở dữ liệu trong bộ nhớ nơi vị trí lưu trữ chính của cơ sở dữ liệu là trong bộ nhớ. Họ đã chuyển sang hướng đĩa, nhưng đây là một hệ thống rất hiện đại.
And the founder of SingleStore was actually the founder of Neon as well, who got bought by Databricks for a billion dollars last year.
Và người sáng lập SingleStore cũng chính là người sáng lập Neon, công ty đã được Databricks mua với giá một tỉ đô la năm ngoái.
So again, Larry Ellison is not the only one who makes a lot of money in databases. Okay.
Vậy nên, Larry Ellison không phải là người duy nhất kiếm được nhiều tiền từ cơ sở dữ liệu. Được rồi.
So last class, again, we were trying to quickly go over the buffer pool stuff at the end or the disk scheduling stuff, and I want to come back and talk about buffer pool optimizations.
Vậy buổi trước, chúng ta đã cố điểm nhanh phần buffer pool ở cuối buổi hay phần lập lịch đĩa, và tôi muốn quay lại nói về các tối ưu hóa buffer pool.
Again, these are going to be examples of things your database system can do Because it has full control of the memory and what's being read and written from disk.
Đây sẽ là những ví dụ về điều mà hệ cơ sở dữ liệu của bạn có thể làm vì nó kiểm soát hoàn toàn bộ nhớ và những gì được đọc và ghi từ đĩa.
Again, these are things that the operating system is not going to be able to do very easily because it doesn't know what queries are running and what queries want to do, but we, as the data system, we know.
Một lần nữa, đây là những việc mà hệ điều hành sẽ không thể làm dễ dàng được vì nó không biết những truy vấn nào đang chạy và các truy vấn muốn làm gì, nhưng chúng ta, với tư cách là hệ quản trị dữ liệu, thì chúng ta biết.
Because SQL is declarative, we know what the query plan is going to look like. Therefore, there's a bunch of tricks we can do to make things better.
Vì SQL là ngôn ngữ khai báo, chúng ta biết kế hoạch truy vấn sẽ trông như thế nào. Do đó, có một loạt mẹo chúng ta có thể dùng để làm mọi thứ tốt hơn.
So the first one is: maintain multiple buffer pools. So I talked about this buffer pool being like this region of memory, and we're going to put our database pages in there.
Mẹo đầu tiên là: duy trì nhiều buffer pool. Tôi đã nói về buffer pool như một vùng bộ nhớ, và chúng ta sẽ đặt các trang cơ sở dữ liệu vào đó.
It doesn't have to be logically organized as a single block of memory.
Nó không nhất thiết phải được tổ chức một cách logic thành một khối bộ nhớ duy nhất.
We actually could break it up into sort of sub-arrays and have a page table per sub-array and have different policies and algorithms used to optimize those different buffer pools.
Thực ra chúng ta có thể chia nó thành các mảng con, mỗi mảng con có một page table riêng và có các chính sách khác nhau cùng các thuật toán khác nhau để tối ưu cho từng buffer pool đó.
So you can have one per database, one per table, you can have one per page type. If it's going to be indexes versus table pages, you split those up.
Vậy bạn có thể có một buffer pool cho mỗi cơ sở dữ liệu, mỗi bảng, hoặc mỗi loại trang. Nếu là chỉ mục so với các trang của bảng, bạn tách chúng ra.
And so the benefit that I'm going to get is that because now we can tailor the buffer pool's internal algorithms based on how we know the rest of the system wants to use the data that's going to be put in that buffer pool, we can make better decisions about what to evict and when to evict.
Lợi ích tôi nhận được là vì giờ đây chúng ta có thể điều chỉnh các thuật toán bên trong của buffer pool dựa trên việc chúng ta biết phần còn lại của hệ thống muốn dùng dữ liệu được đưa vào buffer pool đó như thế nào, chúng ta có thể quyết định tốt hơn về việc loại bỏ cái gì và khi nào.
And we're actually going to reduce latch contention when we have multiple workers trying to access the same data structures at the same time, because now things are split across.
Và chúng ta thực sự sẽ giảm tranh chấp latch khi có nhiều worker cùng cố truy cập vào cùng các cấu trúc dữ liệu tại cùng một thời điểm, vì giờ mọi thứ đã được chia ra.
So this is something you'll see in the high-end systems, the enterprise systems. Like in DB2, you can go crazy.
Đây là thứ bạn sẽ thấy trong các hệ thống cao cấp, các hệ thống doanh nghiệp. Như trong DB2, bạn có thể làm đủ kiểu.
Like from IBM's system, you can declare a buffer pool per table, per index, per block type. Like, you can do a lot of very sophisticated things.
Với hệ thống của IBM, bạn có thể khai báo một buffer pool cho mỗi bảng, mỗi chỉ mục, mỗi loại block. Tức là bạn có thể làm rất nhiều việc rất tinh vi.
MySQL has a pretty simple one. We'll see that in a second.
MySQL thì khá đơn giản. Lát nữa chúng ta sẽ thấy.
So there's basically two ways to do this. You can just say, "All right, well, if I have a...
Về cơ bản có hai cách để làm việc này. Bạn có thể nói: "Được rồi, nếu tôi có một...
Since I know I've got to do lookups on record IDs or object IDs," like the object could be like a table or index, then when I do my lookup to try to get that page that this object belongs to, I'm showing some arbitrary command, get record, whatever.
Vì tôi biết mình phải tra cứu theo record ID hoặc object ID," đối tượng ở đây có thể là một bảng hoặc một chỉ mục, thì khi tôi tra cứu để lấy trang mà đối tượng này thuộc về, tôi đang minh họa một lệnh tùy ý, kiểu get record gì đó.
It's not really SQL, obviously.
Rõ ràng nó không thực sự là SQL.
But you could pick apart this record ID, look at maybe the first portion of it, that's the object ID, and use that to decide which of these different buffer pools are going to have the data that you want.
Nhưng bạn có thể tách record ID này ra, nhìn vào phần đầu của nó, đó là object ID, và dùng nó để quyết định buffer pool nào trong số các buffer pool khác nhau này sẽ chứa dữ liệu bạn muốn.
The thing about the guarantee if you have multiple buffer pools is that any page that we want, any physical page, can only exist in one and only one buffer pool at a time.
Điều đảm bảo nếu bạn có nhiều buffer pool là bất kỳ trang nào chúng ta muốn, bất kỳ trang vật lý nào, tại một thời điểm chỉ có thể tồn tại trong một và chỉ một buffer pool.
You don't want to have two copies, because then if you do two writes, how do you keep them in sync? We don't want to do that.
Bạn không muốn có hai bản sao, vì nếu ghi hai lần thì làm sao giữ chúng đồng bộ? Chúng ta không muốn làm vậy.
So again, with the simple mapping, we can just say, okay, this is what we want for this object ID. We know it's in buffer pool one, and go get it over there.
Vậy với ánh xạ đơn giản, chúng ta chỉ cần nói, được rồi, đây là thứ chúng ta muốn cho object ID này. Chúng ta biết nó nằm trong buffer pool một, và đến đó lấy.
Another simple trick, and this is what MySQL does, is that you can just take whatever the record ID is it's trying to find, like I want page one, two, three, or record one, two, three, just hash it and mod it by the number of buffer pools that you allocate at the beginning, and it just tells you where to go find it.
Một mẹo đơn giản khác, và đây là cách MySQL làm, là bạn chỉ cần lấy bất kỳ record ID nào mà nó đang muốn tìm, ví dụ tôi muốn trang một, hai, ba, hoặc bản ghi một, hai, ba, rồi băm nó và lấy phần dư theo số lượng buffer pool mà bạn cấp phát ngay từ đầu, và kết quả cho bạn biết cần tìm nó ở đâu.
Again, this has the same property guarantee that any page that we're looking for can only be in one of these buffer pools at a time.
Một lần nữa, cách này cũng đảm bảo cùng một tính chất: bất kỳ trang nào mà chúng ta tìm thì tại một thời điểm chỉ có thể nằm trong một buffer pool.
Right? I'm showing two buffer pools. You could have hundreds. Right?
Đúng không? Tôi đang vẽ hai buffer pool. Bạn có thể có hàng trăm. Đúng không?
And then there's a disk scheduler underneath to make sure that if you're trying to, all these buffer pool instances are trying to write data, read and write data at the same time.
Và bên dưới có một bộ lập lịch đĩa để đảm bảo rằng nếu tất cả các buffer pool instance này cùng cố ghi dữ liệu, đọc và ghi dữ liệu cùng một lúc.
You don't want to do random, have a bunch of random IO. The disk scheduler can see all the requests and then sort things and try to do it in a more efficient manner.
Bạn không muốn có hàng loạt thao tác IO ngẫu nhiên. Bộ lập lịch đĩa có thể thấy tất cả các yêu cầu rồi sắp xếp chúng và cố gắng thực hiện theo cách hiệu quả hơn.
Another trick we can do is prefetching. So again, we haven't really talked about what query plans look like.
Một mẹo khác chúng ta có thể làm là prefetching. Một lần nữa, chúng ta chưa thực sự nói về việc query plan trông như thế nào.
Just assume that it's the program that we know we're going to execute in order to run some query. Right? So we know everything ahead of time, what's going to happen.
Cứ giả sử nó là chương trình mà chúng ta biết sẽ thực thi để chạy một truy vấn nào đó. Đúng không? Vậy chúng ta biết trước mọi thứ sẽ xảy ra.
So if we see a scan occurring on data, so query one is going to start. First thing it needs is page zero, and then it starts reading page one and go read that.
Nên nếu ta thấy một phép quét dữ liệu đang diễn ra, giả sử truy vấn một bắt đầu. Việc đầu tiên nó cần là trang 0, rồi nó bắt đầu đọc trang 1 và đi đọc trang đó.
But if we recognize that we had this sequential access pattern, then the database system can say, okay, well, you just read page zero and you read page one.
Nhưng nếu ta nhận ra có mẫu truy cập tuần tự này, thì hệ quản trị cơ sở dữ liệu có thể nói: được rồi, bạn vừa đọc trang 0 và trang 1.
I know your query is also going to need page two and page three. So let me go ahead and prefetch that for you.
Tôi biết truy vấn của bạn cũng sẽ cần trang 2 và trang 3. Vậy để tôi prefetch sẵn cho bạn.
Put that in the buffer pool while you're crunching on page one. Right? Run whatever eviction policy that we want to run. Put those pages in there.
Đưa chúng vào buffer pool trong lúc bạn đang xử lý trang 1. Đúng không? Chạy bất kỳ chính sách loại bỏ nào mà ta muốn chạy. Đưa các trang đó vào đó.
So then now when the query says, all right, I'm done on page one and now I'm going to go look at page two, it doesn't stall and wait while you're going to fetch it from disk.
Như vậy bây giờ khi truy vấn nói, được rồi, tôi xong trang 1 và giờ tôi sẽ xem trang 2, nó không bị dừng lại chờ trong lúc bạn lấy trang đó từ đĩa.
The data you need is already there. Right? And you can do that for the rest of pages all the way down. Now, mmap can do that, actually. The OS can do this.
Dữ liệu bạn cần đã có sẵn ở đó. Đúng không? Và bạn có thể làm vậy với các trang còn lại cho đến hết. Thật ra mmap cũng làm được điều này. Hệ điều hành có thể làm.
The OS has a way to do, you can pass hints to say I want to prefetch as I'm reading a file. But again, it can only prefetch sequentially. Right?
Hệ điều hành có cách để làm, bạn có thể truyền gợi ý rằng tôi muốn prefetch khi đang đọc một tệp. Nhưng một lần nữa, nó chỉ có thể prefetch tuần tự. Đúng không?
It can't do anything more sophisticated because it doesn't know what's in these pages. It doesn't know how they're related to each other.
Nó không thể làm gì phức tạp hơn vì nó không biết trong các trang này có gì. Nó không biết chúng liên quan với nhau như thế nào.
So you can do tricks like this. Let's say I have a query. I want to get data within a range. And the database system decides, okay, well, I have an index for this.
Vậy bạn có thể dùng những mẹo như thế này. Giả sử tôi có một truy vấn. Tôi muốn lấy dữ liệu trong một khoảng. Và hệ quản trị cơ sở dữ liệu quyết định: được rồi, tôi có một chỉ mục cho việc này.
I can use that to find the data that I want, assuming some tree data structure. It's most likely going to be a B+tree.
Tôi có thể dùng nó để tìm dữ liệu mình muốn, giả sử là một cấu trúc dữ liệu cây nào đó. Rất có thể nó sẽ là một B+tree.
We'll cover that in a few weeks, but it doesn't have to be. Right? And along the leaf nodes, the data is going to be sorted in that key order we want.
Chúng ta sẽ học về nó trong vài tuần nữa, nhưng không nhất thiết phải vậy. Đúng không? Và dọc theo các nút lá, dữ liệu sẽ được sắp xếp theo đúng thứ tự khóa mà chúng ta muốn.
So now as my query starts running, I read in this page zero, that's the root. That's going to tell me whether I want to go left or right. Now I go down here.
Giờ khi truy vấn bắt đầu chạy, tôi đọc trang số 0 này, đó là nút gốc. Nó sẽ cho tôi biết nên đi sang trái hay sang phải. Giờ tôi đi xuống đây.
I go to page one. I fetch that in. And that just happened to be sequential in my database file. So yeah, you can potentially prefetch that.
Tôi đến trang một. Tôi nạp nó vào. Và trang đó tình cờ nằm liên tiếp trong tệp cơ sở dữ liệu của tôi. Vậy nên đúng, có thể prefetch trang đó.
But when I get down here to the bottom, I can see that I'm going to scan across the leaf nodes, and I know I'm going to need page three and page five.
Nhưng khi tôi xuống tới tận đây, ở dưới cùng, tôi thấy rằng mình sẽ quét dọc theo các nút lá, và tôi biết mình sẽ cần trang ba và trang năm.
And they're not sequential. So if the OS was doing this for us, it would blindly say, okay, well, you just read page one, page two.
Và chúng không liên tiếp nhau. Vậy nếu hệ điều hành làm việc này cho chúng ta, nó sẽ mù quáng nói rằng, được rồi, bạn vừa đọc trang một, trang hai.
Let me go get page three for you, and three and four. We actually want three and five. But because we know the contents of these pages, we can peek ahead.
Để tôi lấy trang ba cho bạn, rồi cả trang ba và bốn. Thực ra chúng ta muốn trang ba và trang năm. Nhưng vì chúng ta biết nội dung của các trang này, chúng ta có thể nhìn trước.
And we'll talk about in a few weeks how we do that. Say, oh, we don't actually want four. We actually want five, because we're scanning along the leaf nodes.
Và vài tuần nữa chúng ta sẽ nói về cách làm điều đó. Chẳng hạn, ồ, thực ra chúng ta không cần trang bốn. Chúng ta thực sự cần trang năm, vì chúng ta đang quét dọc theo các nút lá.
And we go ahead and prefetch those guys. So again, this is an example.
Và chúng ta tiến hành prefetch những trang đó. Vậy đây là một ví dụ.
Because the database system knows what you're trying to do, the queries, it's in a better position to make decisions about how to optimize things.
Vì hệ quản trị cơ sở dữ liệu biết bạn đang cố làm gì, tức là biết các truy vấn, nó ở vị thế tốt hơn để đưa ra quyết định về cách tối ưu mọi thứ.
All right, the last one I want to talk about is scan sharing.
Được rồi, điều cuối cùng tôi muốn nói là scan sharing.
And the idea here is that if we have a query that's running and it's scanning some table, and then some other query comes along and wants to scan the same table, Rather than just having that second query start from the beginning and read all the same pages that the first guy just read, we actually can piggyback and ride along the first query,
Và ý tưởng ở đây là nếu chúng ta có một truy vấn đang chạy và đang quét một bảng nào đó, rồi có một truy vấn khác xuất hiện và cũng muốn quét chính bảng đó, thay vì để truy vấn thứ hai bắt đầu từ đầu và đọc lại tất cả các trang mà truy vấn đầu tiên vừa đọc, thực ra chúng ta có thể bám theo và đi cùng truy vấn thứ nhất,
see all the pages that it sees, and then make a determination whether we want to quit or not, or come back around and find the data that we're looking for.
thấy tất cả các trang mà nó thấy, rồi quyết định xem mình có muốn dừng lại hay không, hay quay lại vòng đầu để tìm dữ liệu mà chúng ta đang cần.
These are sometimes called synchronized scans. And again, this is done at the lowest level of the system. There's some cursor reading pages from the page directory or scanning along a table.
Đôi khi cách này được gọi là synchronized scan. Và một lần nữa, việc này được thực hiện ở tầng thấp nhất của hệ thống. Có một con trỏ nào đó đọc các trang từ page directory hoặc quét dọc theo một bảng.
This is not the same as result caching. Result caching is like, I take a query, I run a query, I produce some output.
Điều này không giống với result caching. Result caching là: tôi nhận một truy vấn, chạy nó, và tạo ra một kết quả đầu ra nào đó.
If that same query shows up, I just reuse the same output. This is actually done at the lowest level while we're running queries. So this is actually rare. Few systems support this.
Nếu chính truy vấn đó xuất hiện lại, tôi chỉ việc dùng lại kết quả đầu ra ấy. Còn cái này thực sự được thực hiện ở tầng thấp nhất trong lúc chúng ta đang chạy truy vấn. Vì vậy nó khá hiếm. Rất ít hệ thống hỗ trợ.
Again, the high-end ones like DB2, SQL Server, Teradata, and Postgres do this. Postgres is the exception. Oracle, again, despite him now being the richest person in the world, doesn't have this feature.
Một lần nữa, các hệ thống cao cấp như DB2, SQL Server, Teradata và Postgres có làm việc này. Postgres là ngoại lệ. Còn Oracle, một lần nữa, dù ông ấy giờ là người giàu nhất thế giới, lại không có tính năng này.
They have something that almost looks like this, but has this limitation where the queries have to be exactly the same in order to do this piggyback mechanism. Meaning, this is from the documentation.
Họ có một thứ trông gần giống như vậy, nhưng có hạn chế là các truy vấn phải giống hệt nhau thì mới dùng được cơ chế bám theo này. Nghĩa là, đây là lấy từ tài liệu.
If you have a query like SELECT * FROM employees, if the next query comes along, it says SELECT * FROM employees with a capital E, or there's an extra space in there, it doesn't match it.
Nếu bạn có một truy vấn như SELECT * FROM employees, và truy vấn tiếp theo xuất hiện, viết SELECT * FROM employees với chữ E viết hoa, hoặc có thêm một khoảng trắng trong đó, thì nó sẽ không khớp.
Even though semantically they're the same, the way they're doing this matching is basically hashing the string and seeing whether it's identical. But the high-level idea is still the same.
Dù về mặt ngữ nghĩa thì chúng giống nhau, cách họ so khớp về cơ bản là băm chuỗi ký tự rồi xem chúng có giống hệt nhau hay không. Nhưng ý tưởng ở mức tổng quát vẫn như vậy.
So say we have this query, select the sum from A. It starts at the beginning. It's going to scan through and read all the pages that it needs.
Giả sử ta có truy vấn này, select tổng từ A. Nó bắt đầu từ đầu. Nó sẽ quét qua và đọc tất cả các trang cần thiết.
And then say at this point we get here, we need to read page three. We only have three frames in our buffer pool, so we're going to throw out page zero.
Rồi giả sử đến điểm này, ta cần đọc trang ba. Buffer pool của ta chỉ có ba frame, nên ta sẽ loại trang không ra.
And then, while we're doing this, now another query shows up that basically wants to do another sequential scan on the entire table, but now it could be a different aggregation.
Và trong lúc đang làm vậy, giờ có một truy vấn khác xuất hiện, về cơ bản muốn thực hiện một lần quét tuần tự khác trên toàn bộ bảng, nhưng lần này có thể là một phép tổng hợp khác.
So the computation is different, but the data it needs to access is the same.
Vậy phép tính khác nhau, nhưng dữ liệu cần truy cập thì giống nhau.
So we could do the stupid thing and just start this second query from the very beginning of the table, but it's going to read page zero, and that's actually the last page we just evicted.
Ta có thể làm theo cách ngớ ngẩn là cho truy vấn thứ hai bắt đầu từ tận đầu bảng, nhưng nó sẽ đọc trang không, mà đó lại chính là trang ta vừa loại ra.
So we just go back and now fetch it back in in our buffer pool.
Thế là ta phải quay lại và nạp nó vào buffer pool lần nữa.
But if we're smart about it, we can say, okay, well, these are both doing a sequential scan on A, so I'll just have Q2 tag along Q1.
Nhưng nếu khôn ngoan hơn, ta có thể nói: được rồi, cả hai đều đang quét tuần tự trên A, nên tôi sẽ cho Q2 đi theo Q1.
As the cursor reads the table and gets all of these pages, it can do whatever computation it wants. Then at the bottom, Q1 says, oh, I scanned the entire table.
Khi con trỏ đọc bảng và lấy tất cả các trang này, nó có thể thực hiện bất kỳ phép tính nào nó muốn. Rồi ở cuối, Q1 nói: à, tôi đã quét hết toàn bộ bảng.
It goes away, but Q2 says, well, I know I started at the beginning, the sort of halfway point of this table, and there's a bunch more pages I need to go back and read, so let me start scanning through those all over again.
Nó kết thúc, còn Q2 nói: tôi biết mình đã bắt đầu từ đầu, tức là khoảng giữa bảng này, và còn một loạt trang nữa tôi cần quay lại đọc, nên để tôi quét lại những trang đó từ đầu.
All right? Again, we talked about this in the last class. We want to maximize the amount of computational work we can do on data pages when we bring them from disk into memory.
Được chứ? Ta đã nói về điều này ở buổi học trước. Ta muốn tối đa hóa lượng công việc tính toán thực hiện trên các trang dữ liệu khi đưa chúng từ đĩa vào bộ nhớ.
So if I can run two queries, or satisfy two queries' operations, for one single page fetch, that's a huge win for us. Yes?
Nên nếu tôi chạy được hai truy vấn, hay đáp ứng thao tác của hai truy vấn, chỉ với một lần nạp trang, thì đó là lợi ích rất lớn cho ta. Em hỏi ạ?
Like here.
Như ở đây.
The question is, sorry, the question is, at this point here, query one has not seen page one or two. Yes? Yes. Yes.
Câu hỏi là, xin lỗi, câu hỏi là, tại điểm này, truy vấn một chưa thấy trang một hay hai. Đúng không? Vâng. Đúng.
So his statement here is, could we be more sophisticated and have Q2 recognize I need page one and two, that's already in memory by going and peeking in the buffer pool, and then say, okay, let me read those and then piggyback?
Ý của bạn ấy là, liệu ta có thể tinh vi hơn, để Q2 nhận ra nó cần trang một và hai, những trang đã nằm trong bộ nhớ, bằng cách xem thử trong buffer pool, rồi nói: được, để tôi đọc những trang đó rồi mới đi theo?
Yes. In this PowerPoint example, I'm not showing that. Yes, you could do that. Now, who does that? I don't think Postgres does.
Vâng. Trong ví dụ PowerPoint này, tôi không trình bày điều đó. Có, bạn có thể làm vậy. Vậy ai làm thế? Tôi nghĩ Postgres không làm.
I don't know, the Enterprise guys are closed source, so I don't know what they do. Yes? The question is, how do you know what pages correspond to what table?
Tôi không biết, các hệ thống Enterprise là mã nguồn đóng, nên tôi không biết họ làm gì. Em hỏi ạ? Câu hỏi là, làm sao biết những trang nào thuộc về bảng nào?
The page directory tells us.
Page directory cho ta biết điều đó.
Yeah, page directory is basically a catalog that says, okay, if I want to read table A, here's the directory, or here's the pages, here's the directory with the files that have the pages that you want to read for this.
Vâng, page directory về cơ bản là một danh mục (catalog) cho biết, được rồi, nếu tôi muốn đọc bảng A, thì đây là directory, hoặc đây là các trang, đây là directory chứa các tệp có những trang mà bạn muốn đọc cho bảng này.
Yeah, we have to know that.
Vâng, chúng ta phải biết điều đó.
The statement is, this is a sequential scan. If it was an index scan, it might not do the same, read the same pages. Yes.
Ở đây câu lệnh là một sequential scan. Nếu là index scan, nó có thể không làm giống vậy, không đọc cùng những trang đó. Vâng, mời bạn.
If there's a predicate there, from A, from A where something, you might not want to read everything. If there's an index, sure. Keep it simple, sequential scan. Right?
Nếu có một predicate ở đó, kiểu from A, from A where một điều kiện nào đó, thì bạn có thể không muốn đọc hết mọi thứ. Nếu có chỉ mục thì đúng vậy. Cứ giữ cho đơn giản, sequential scan. Đúng không?
All right. All right, so again, that's the, again, the three optimizations I wanted to cover in the buffer pool.
Được rồi. Được rồi, vậy đó là, ba tối ưu hóa mà tôi muốn trình bày về buffer pool.
So let's jump back now and talk about the disk storage, the database storage on disk.
Bây giờ chúng ta quay lại và nói về lưu trữ trên đĩa, tức là lưu trữ cơ sở dữ liệu trên đĩa.
So, we said at the beginning of the semester that we're going to focus on what I'll call a disk-oriented architecture.
Vậy, đầu học kỳ chúng ta đã nói rằng chúng ta sẽ tập trung vào cái mà tôi gọi là kiến trúc hướng đĩa (disk-oriented).
Again, we assume that the primary location of the database when it is at rest is its own non-volatile storage, like a disk.
Một lần nữa, chúng ta giả định rằng nơi chứa chính của cơ sở dữ liệu khi nó ở trạng thái nghỉ là bộ nhớ không bay hơi của chính nó, như một chiếc đĩa.
And then we talked about a way to break up a database, the entire database, and work with these database pages and represent them in a slotted page where we could stick in tuples and then do lookups later on.
Và sau đó chúng ta nói về cách chia nhỏ một cơ sở dữ liệu, toàn bộ cơ sở dữ liệu, và làm việc với các trang cơ sở dữ liệu này và biểu diễn chúng trong một slotted page nơi chúng ta có thể nhét các tuple vào rồi tra cứu sau đó.
All right, so we discussed the page layout. So that page layout would be, again, what are actually in the pages? So, what's in the pages that we're storing in our database files?
Được rồi, vậy chúng ta đã thảo luận về bố cục trang. Bố cục trang đó là, một lần nữa, thực sự có gì bên trong các trang? Vậy, có gì trong các trang mà chúng ta lưu trong các tệp cơ sở dữ liệu?
And we talk, again, tuple-oriented storage, that was the slotted page architecture where the pages are really all about storing tuples, and we have this indirection layer within each page that allows us to move data or tuples around within that single page itself.
Và chúng ta đã nói về lưu trữ hướng tuple, đó là kiến trúc slotted page nơi các trang thực chất chỉ để lưu các tuple, và chúng ta có một tầng gián tiếp trong mỗi trang cho phép di chuyển dữ liệu hay các tuple ngay trong chính trang đơn lẻ đó.
So today, I want to now look at two alternatives. Again, we'll refresh what a tuple-oriented storage looks like, but then we'll jump into the new stuff for today.
Hôm nay, tôi muốn xem xét hai phương án thay thế. Chúng ta sẽ ôn lại lưu trữ hướng tuple trông như thế nào, rồi sau đó đi vào phần mới của hôm nay.
All right, these are going to be alternative ways to store data for tables in a database. So again, slotted page, I said this is the most common layout for databases that are row-oriented.
Được rồi, đây sẽ là những cách thay thế để lưu dữ liệu cho các bảng trong cơ sở dữ liệu. Vậy, nhắc lại slotted page, tôi đã nói đây là bố cục phổ biến nhất cho các cơ sở dữ liệu hướng hàng.
Next class, we'll discuss what that means in more detail.
Buổi sau, chúng ta sẽ thảo luận chi tiết hơn điều đó nghĩa là gì.
Basically, we're going to take any tuple and, assuming we can fit it to this page, we're going to store it from beginning to end inside that page.
Về cơ bản, chúng ta lấy một tuple bất kỳ và, giả sử nó vừa với trang này, chúng ta sẽ lưu nó từ đầu đến cuối bên trong trang đó.
And then, inside that page, we have this header that tells us some metadata about what's in the page, like a checksum, a version number, so forth.
Rồi bên trong trang đó, chúng ta có phần header cho biết một số siêu dữ liệu về những gì có trong trang, như checksum, số phiên bản, v.v.
Then there'll be a slot array at the beginning and all the tuple data at the bottom.
Sau đó sẽ có một slot array ở đầu và toàn bộ dữ liệu tuple ở phía dưới.
And the slot array is going to have basically just record offsets inside the page that tells us where to jump to to find the beginning point for every single tuple.
Và slot array về cơ bản chỉ chứa các offset bản ghi bên trong trang cho biết cần nhảy tới đâu để tìm điểm bắt đầu của từng tuple.
And we said the slot array is allowed to grow from the beginning to the end and the tuple data is going to grow from the end to the beginning.
Và chúng ta đã nói slot array được phép phát triển từ đầu đến cuối còn dữ liệu tuple sẽ phát triển từ cuối về đầu.
This is the way Postgres does this. This is the way I think the textbook might describe this. Other textbooks might reverse it.
Postgres làm theo cách này. Tôi nghĩ giáo trình cũng có thể mô tả theo cách này. Các giáo trình khác có thể làm ngược lại.
In the end, it doesn't matter whether the slot array or the tuple data is on the top or the bottom. The high-level idea is the same.
Rốt cuộc, việc mảng slot hay dữ liệu tuple nằm ở trên hay ở dưới không quan trọng. Ý tưởng ở mức tổng quát là như nhau.
And again, the slot array is providing us an indirection that allows us to change the position of tuples within the page itself. You don't want to move it to another page.
Và một lần nữa, mảng slot cho chúng ta một tầng gián tiếp cho phép thay đổi vị trí của các tuple ngay bên trong trang. Bạn không muốn chuyển nó sang trang khác.
We may have to, but we're not focusing on that yet.
Có thể ta sẽ phải làm vậy, nhưng hiện giờ chưa tập trung vào điều đó.
And this allows us to then be able to do things like, oh, I'll delete this tuple here and then I can do compaction and slide this tuple over here to fill in the space.
Và điều này cho phép chúng ta làm những việc như, ồ, tôi sẽ xóa tuple này ở đây rồi tôi có thể thực hiện compaction, dịch tuple này sang đây để lấp chỗ trống.
And all I have to do now is update the slot array to tell me where the offset is for that tuple I just moved, and I don't have to update anything else outside the system or outside this page itself.
Và giờ tôi chỉ cần cập nhật mảng slot để cho biết offset của tuple vừa được di chuyển nằm ở đâu, và tôi không cần cập nhật bất cứ thứ gì khác bên ngoài hệ thống hay bên ngoài chính trang này.
Then we talked about record IDs. And this was the way that we were going to physically find a tuple within our database.
Sau đó chúng ta nói về record ID. Và đây là cách để chúng ta tìm tuple một cách vật lý trong cơ sở dữ liệu.
It's going to be some combination of a file name or a file ID, a page ID, and then a slot number within that page. Right?
Nó sẽ là sự kết hợp của tên tệp hoặc ID tệp, ID trang, rồi đến số slot trong trang đó. Đúng không?
So the page directory thing he was asking about before, they were asking about before, that'll store the file ID for some object.
Còn page directory mà bạn ấy hỏi lúc nãy, họ hỏi lúc nãy, nó sẽ lưu ID tệp của một đối tượng nào đó.
Like, I want table foo, here's the file, where to go find it.
Kiểu như, tôi muốn bảng foo, thì đây là tệp, hãy đến đó mà tìm.
And then if I want page 1, 2, 3, depending on the addressing scheme the data system uses, it could just be an offset within the file, or it could just be the file name itself might have the page number.
Và nếu tôi muốn trang 1, 2, 3, tùy theo sơ đồ định địa chỉ mà hệ quản trị dữ liệu sử dụng, nó có thể chỉ là một offset trong tệp, hoặc chính tên tệp có thể chứa số trang.
Right? All that's within the page directory. Yes.
Đúng không? Tất cả những thứ đó nằm trong page directory. Vâng, mời bạn.
The question is, what if you have more rows than the size of the ID? I mean, it's a 64-bit number. Well, hold up. In Oracle, it's a 10-byte number. Right? That's pretty big.
Câu hỏi là, nếu có nhiều hàng hơn kích thước của ID thì sao? Ý tôi là, đó là số 64 bit. Khoan đã. Trong Oracle, đó là số 10 byte. Đúng không? Khá lớn đấy.
So Ingres is the first relational system from, like, 1974. Postgres is, yeah, so six bytes.
Ingres là hệ quan hệ đầu tiên, khoảng năm 1974. Postgres thì, vâng, là sáu byte.
Sybase is, would you run out of six bytes? I mean, it's a pretty big, that'd be a pretty big table. But in theory, yes, you could. There's other limitations too, right?
Sybase thì, liệu bạn có dùng hết sáu byte không? Ý tôi là, đó sẽ là một bảng rất lớn. Nhưng về lý thuyết thì có thể. Cũng còn những giới hạn khác nữa, đúng không?
So, like, Sybase is, it's not just for one table, it's for the whole database.
Chẳng hạn Sybase, nó không chỉ dành cho một bảng mà cho cả cơ sở dữ liệu.
Yeah, this would be for, depending on the scheme you're using, this could be the, for the entire database, it could be for a single table. Right?
Vâng, tùy vào sơ đồ bạn dùng, nó có thể áp dụng cho toàn bộ cơ sở dữ liệu, hoặc cho một bảng riêng lẻ. Đúng không?
I know I want table foo, and here's the page ID for it, therefore, I know how to find that. Right?
Tôi biết mình muốn bảng foo, và đây là ID trang của nó, vì vậy tôi biết cách tìm ra nó. Đúng không?
There's other limitations I'm not going to talk about, like, in Postgres, you can only have 2 to the 16 columns in a table.
Còn những giới hạn khác mà tôi sẽ không nói đến, chẳng hạn trong Postgres, một bảng chỉ có thể có tối đa 2^16 cột.
Oracle famously only lets you have 1,000 because somebody hard-coded it. Right? It used to be, like, 200, and then they spent a year trying to fix it to go to 1,000.
Oracle nổi tiếng chỉ cho phép 1.000 vì có ai đó đã mã hóa cứng giá trị đó. Đúng không? Ngày xưa nó chỉ khoảng 200, rồi họ mất một năm cố sửa để nâng lên 1.000.
But that was 10 years ago and no one's going to change it again. Like, it's, like, stupid things like that. But yeah, you're very unlikely to run out of space for this.
Nhưng đó là chuyện 10 năm trước và sẽ không ai thay đổi nó nữa. Kiểu như, toàn những chuyện ngớ ngẩn như vậy. Nhưng đúng vậy, bạn rất khó bị hết chỗ vì chuyện này.
There's other tricks to do if you get around this. Like, in the case of Postgres, you can have a... You can partition a table. It's, like, make...
Còn có những mẹo khác để lách giới hạn này. Ví dụ với Postgres, bạn có thể phân vùng một bảng. Kiểu như, tạo...
Here's, like, here's our parent table, and then within that I have, like, sub-tables. So, logically, it looks like a single table, but each one has their own...
Đây là bảng cha của chúng ta, và bên trong nó tôi có các bảng con. Về mặt logic, nó trông như một bảng duy nhất, nhưng mỗi bảng con có riêng...
Right? There's ways to get around it. Say it again?
Đúng không? Có nhiều cách để lách. Bạn nói lại được không?
The question is, for a row-stored database system, would it make sense to have 1,000 columns? People do it. Sure, why not? Right? There's easily applications that have 1,000 columns. Yeah.
Câu hỏi là, với một hệ cơ sở dữ liệu lưu trữ theo hàng, liệu có hợp lý khi có 1.000 cột không? Người ta vẫn làm vậy. Chắc chắn rồi, tại sao không? Đúng không? Có rất nhiều ứng dụng có 1.000 cột. Vâng.
Enterprise stuff is nasty. Like, anything from, like, the SAP Enterprise Resource... ERP thing, the thing they make a lot of money on, that thing is insane. Right?
Phần mềm doanh nghiệp rất khủng khiếp. Ví dụ như SAP Enterprise Resource... Hệ thống ERP, thứ họ kiếm rất nhiều tiền, nó điên rồ lắm. Đúng không?
Because think of, like, an application running for, like, 30 years.
Hãy nghĩ đến một ứng dụng chạy suốt khoảng 30 năm.
Every two years, someone's got to add, like, 10 columns because something gets else added, and then before you know it, you're out of 1,000 easily.
Cứ hai năm lại có người phải thêm khoảng 10 cột vì có thêm thứ gì đó mới, và chẳng mấy chốc bạn vượt quá 1.000 một cách dễ dàng.
To your point, I mean, like, it's a long tail. Right? There's going to be most... Most tables are going to have, maybe, I don't know, 20, 30 columns.
Như bạn nói, đây là một đuôi dài. Đúng không? Phần lớn... Hầu hết các bảng có lẽ chỉ khoảng 20, 30 cột.
But there's easily stuff out there that don't have that many.
Nhưng chắc chắn có những hệ thống ngoài kia có nhiều cột hơn thế.
The thing is, at that point, you would have a single row across multiple pages. Depends on what the columns are.
Vấn đề là, lúc đó một hàng sẽ nằm trải trên nhiều trang. Còn tùy các cột là gì.
Is that assuming that there are multiple pages?
Điều đó có giả định là có nhiều trang không?
Sure, like, but the data doesn't handle that. Yeah. For our discussion here, we've simplified it and say, like, we assume it's all going to sit in a single page.
Đúng, nhưng dữ liệu không xử lý điều đó. Vâng. Trong phần thảo luận này, chúng ta đã đơn giản hóa và nói rằng ta giả định mọi thứ đều nằm trong một trang duy nhất.
But actually, now we talked about large data records, or large attributes. Now you just have a pointer to something else, to another page.
Nhưng thực ra, chúng ta đã nói về bản ghi dữ liệu lớn, hay thuộc tính lớn. Lúc đó bạn chỉ có một con trỏ tới thứ khác, tới một trang khác.
And then, at run time, the data system knows how to stitch it back together. All right. So, in this tuple-oriented storage, reads are pretty simple. All right?
Và khi chạy, hệ cơ sở dữ liệu biết cách ghép chúng lại với nhau. Được rồi. Vậy trong lưu trữ hướng tuple này, việc đọc khá đơn giản. Đúng không?
If I want to get an existing tuple, then I'm going to get its record ID. I'm not saying how to get that just yet.
Nếu muốn lấy một tuple đã có, tôi sẽ lấy record ID của nó. Tôi chưa nói cách lấy nó vội.
But assume there's some index, there's something that's going to tell me, for, you know, I want your email, for your email address, here's the record ID that has your student record.
Nhưng giả sử có một index, một thứ sẽ cho tôi biết, chẳng hạn tôi muốn email của bạn, với địa chỉ email của bạn, thì đây là record ID chứa hồ sơ sinh viên của bạn.
There's something there, it's the index, that's going to tell us how to find that. But for app purposes, right here, we don't care. So again, how do we find this?
Có một thứ ở đó, là index, sẽ cho ta biết cách tìm nó. Nhưng ở đây ta không quan tâm. Vậy, làm sao tìm được nó?
We go look in the page directory, go get the, find the location of the page we want, retrieve that page we want from that location on disk, if it's not already in memory, and then, now we use the record ID's offset that's embedded inside it to jump inside the page within the slot array to find the data we're looking for.
Ta tra trong page directory, tìm vị trí của trang ta muốn, lấy trang đó từ vị trí của nó trên đĩa, nếu nó chưa có trong bộ nhớ, và sau đó, ta dùng offset của record ID được nhúng bên trong nó để nhảy vào trong trang, trong slot array, để tìm dữ liệu ta cần.
All right? Reads are pretty simple.
Được chứ? Các thao tác đọc khá đơn giản.
The, in this case here, we have to do the lookup in the index to find the data that we're looking for.
Trong trường hợp này, chúng ta phải tra cứu trong chỉ mục để tìm dữ liệu mình cần.
So we kind of do a lookup in this index, that's going to tell us the, for a given logical key, like your email address, when we, when we look at the index, it's going to come back and say here's the record ID.
Vậy ta tra cứu trong chỉ mục này, và nó sẽ cho ta biết, với một khóa logic cho trước, như địa chỉ email của bạn, khi ta tra cứu trong chỉ mục, nó sẽ trả về và nói: đây là record ID.
Then we do a lookup to go find the data that we want given that record ID within the, within the page. But what if we didn't have to do that?
Sau đó ta tra cứu để tìm dữ liệu mình muốn dựa trên record ID đó, bên trong trang. Nhưng nếu ta không cần phải làm vậy thì sao?
What if we didn't have to do a separate lookup in the index and a separate lookup in the table here? So this is called index organized storage.
Nếu ta không cần tra cứu riêng trong chỉ mục rồi lại tra cứu riêng trong bảng ở đây thì sao? Đây gọi là lưu trữ tổ chức theo chỉ mục (index organized storage).
The basic idea is that we're going to use the index as the storage for the table itself. So again, what is, what is the index doing for us?
Ý tưởng cơ bản là ta sẽ dùng chính chỉ mục làm nơi lưu trữ cho bảng. Nhắc lại, chỉ mục làm gì cho chúng ta?
It's a mapping from a key to a value. In this case here, it would be a logical key, like your email address, like the primary key or something.
Nó là ánh xạ từ một khóa sang một giá trị. Trong trường hợp này, đó sẽ là một khóa logic, như địa chỉ email của bạn, chẳng hạn khóa chính.
And then the value is going to be the record ID if it was a tuple in the storage.
Còn giá trị sẽ là record ID của một tuple trong kho lưu trữ.
With index organized storage, in the leaf nodes, instead of storing a record ID, we're just going to store the tuple itself.
Với lưu trữ tổ chức theo chỉ mục, ở các nút lá, thay vì lưu record ID, ta sẽ lưu luôn chính tuple.
So again, I'm not telling you what data structure this is going to be, but typically it's going to be a B+tree, could be a skip list, could be a trie, could be, you know, whatever your favorite tree data structure you want.
Một lần nữa, tôi không nói đây là cấu trúc dữ liệu nào, nhưng thường đó sẽ là B+tree, cũng có thể là skip list, trie, hay là, bất kỳ cấu trúc cây nào mà bạn thích.
So then now within, again within the pages, sorry, the leaf nodes, it's going to look a lot like the slot array from the tuple oriented storage.
Vậy bên trong các trang, xin lỗi, các nút lá, nó sẽ trông khá giống slot array của lưu trữ hướng tuple.
But in the beginning, the header, we're going to have this key to offset array mapping that we have to keep in sorted order based on the key, and these are just going to, again, be offsets within the page that gives us the tuple that we want.
Nhưng ở phần đầu, tức header, ta sẽ có mảng ánh xạ khóa sang offset này, mà ta phải giữ được sắp xếp theo khóa, và các giá trị này, một lần nữa, chỉ là các offset trong trang cho ta biết tuple mà ta cần.
So now when I do that lookup, based on your email address, I would scan down through the inner nodes in the data structure, land on the leaf node, then do a binary search inside this key offset array, and then that'll find the record that you're looking for.
Vậy khi tôi tra cứu dựa trên địa chỉ email của bạn, tôi sẽ duyệt xuống qua các nút trong của cấu trúc dữ liệu, đến nút lá, rồi tìm kiếm nhị phân trong mảng key offset này, và thế là tìm ra bản ghi bạn cần.
And I don't have to do that separate lookup in like the page directory to go find your tuple if we're given a record ID. Everything is right there in the leaf node.
Và tôi không phải tra cứu riêng trong page directory để tìm tuple của bạn khi được cho một record ID. Mọi thứ đều nằm ngay trong nút lá.
So SQLite famously, or SQLite, MySQL with InnoDB famously give you this view. That's basically how they organize, it is how they organize the data in their system.
SQLite nổi tiếng là vậy, hay MySQL với InnoDB cũng nổi tiếng cho bạn cách nhìn này. Về cơ bản đó là cách họ tổ chức, chính là cách họ tổ chức dữ liệu trong hệ thống của mình.
With Oracle and SQL Server, by default you get the slotted page architecture as I said before, but when you create a table, you can tell it, "I want to do index-organized storage."
Với Oracle và SQL Server, mặc định bạn có kiến trúc slotted page như tôi đã nói trước đó, nhưng khi tạo bảng, bạn có thể yêu cầu nó: "Tôi muốn dùng lưu trữ tổ chức theo chỉ mục."
So they'll support this as well.
Vậy nên họ cũng hỗ trợ cách này.
And just like before, the key offset grows one way, and the tuple grows another way.
Và cũng như trước, phần offset của khóa mở rộng theo một hướng, còn tuple mở rộng theo hướng ngược lại.
Okay, well, so that solves the problem we had in reads before, where I wanted to do a, I want to find a record, or a tuple, based on the record ID.
Được rồi, như vậy là giải quyết được vấn đề ở phần đọc lúc nãy, khi mà tôi muốn, tôi muốn tìm một bản ghi, hay một tuple, dựa trên record ID.
I have to go look in the index, and I then have to find the, for a given key, look up the index, and the index tells me the record ID, and from the record ID I can go to the page that has the tuple data.
Tôi phải đi tra trong chỉ mục, rồi với một khóa cho trước, tôi phải tra chỉ mục, và chỉ mục cho tôi biết record ID, và từ record ID tôi có thể đến trang chứa dữ liệu của tuple.
But we still have to worry about writes. So to do an insert, it's pretty straightforward, right?
Nhưng chúng ta vẫn phải lo đến các thao tác ghi. Với thao tác insert thì khá đơn giản, đúng không?
We just go check the page directory to see whether there's a free page for us that has enough space, or if there's a page that has enough free space for the tuple we want to store.
Ta chỉ cần kiểm tra page directory để xem có trang trống nào đủ chỗ cho mình không, hoặc có trang nào còn đủ chỗ trống cho tuple mà ta muốn lưu.
Again, we know the size of the data we're storing because SQL is declarative, we know exactly what you're telling us to store, so we can figure out at the moment you try to insert it how much space we need.
Một lần nữa, ta biết kích thước dữ liệu cần lưu vì SQL là khai báo, ta biết chính xác bạn yêu cầu lưu cái gì, nên ngay lúc bạn insert, ta có thể tính được cần bao nhiêu dung lượng.
Then we go retrieve that page from disk, if it's not already in memory, and go check the slot array to find a free slot and insert into it.
Sau đó ta lấy trang đó từ đĩa, nếu nó chưa nằm trong bộ nhớ, rồi kiểm tra slot array để tìm một slot trống và chèn vào đó.
Ignoring the index-organized storage, rebalancing the tree, we'll worry about that later. So inserting is pretty straightforward.
Tạm bỏ qua lưu trữ tổ chức theo chỉ mục, việc cân bằng lại cây thì lát nữa ta sẽ lo. Vậy nên insert khá đơn giản.
And say we run out of pages, there's no free space in the current pages we have, we just allocate a new page, and then insert our record in there.
Và giả sử ta hết trang, không còn chỗ trống trong các trang hiện có, thì ta chỉ cần cấp phát một trang mới, rồi chèn bản ghi vào đó.
No problem. But now if we want to update a tuple, we go through the same process as before: go find its page, find its record ID, go see whether the page exists.
Không vấn đề gì. Nhưng bây giờ nếu muốn cập nhật một tuple, ta làm theo quy trình như trước: tìm trang của nó, tìm record ID của nó, xem trang đó có tồn tại không.
Then, assuming we're going to overwrite the data, which is not always the case in most systems, but assuming we are, then I'm going to check to see whether the size of the tuple, the new value of the tuple that I'm trying to insert or update, is larger than the original value.
Sau đó, giả sử ta sẽ ghi đè dữ liệu, điều này không phải lúc nào cũng đúng ở hầu hết các hệ thống, nhưng cứ giả sử là vậy, thì tôi sẽ kiểm tra xem kích thước của tuple, tức giá trị mới của tuple mà tôi định chèn hoặc cập nhật, có lớn hơn giá trị ban đầu không.
Do I have any space in my page? Now, because of the slot array, I can reorganize things or try to free up space within the page.
Trang của tôi còn chỗ không? Nhờ có slot array, tôi có thể sắp xếp lại mọi thứ hoặc cố giải phóng bớt chỗ trong trang.
And if I can do that, and I can get it in the same page, great, I'm done.
Nếu làm được và nhét vừa vào cùng trang đó thì tốt, xong việc.
But if there's no space in the current page, where the tuple currently exists, then I basically have to treat that as a delete, removing the original tuple, followed by an insert with the new tuple.
Nhưng nếu trang hiện tại, nơi tuple đang nằm, không còn chỗ, thì về cơ bản tôi phải coi đó là một thao tác delete, xóa tuple ban đầu, rồi sau đó insert tuple mới.
And that's expensive, right?
Và việc đó tốn kém, đúng không?
So tuple-oriented storage is really great for reads because, again, it's really easy to go find the thing that I'm looking for. For inserts, not so bad either, right?
Vậy lưu trữ hướng tuple rất tốt cho việc đọc vì, như đã nói, rất dễ tìm thứ mà tôi cần. Với insert thì cũng không tệ, đúng không?
Because I can just insert a page, a page, a page over and over again. But for updates, they can actually be quite expensive.
Vì tôi chỉ cần chèn hết trang này đến trang khác liên tục. Nhưng với cập nhật thì chi phí có thể khá cao.
Right? So part of the problem we're going to have is that there's going to be fragmentation, right? Because we can't guarantee that we're going to be able to fully utilize every single page.
Đúng không? Một phần vấn đề ta sẽ gặp là sẽ có hiện tượng phân mảnh, đúng không? Bởi vì ta không thể đảm bảo rằng chúng ta có thể tận dụng hoàn toàn từng trang một.
There's that little space in the middle where the slot array goes one way and the tuple data goes the other way.
Có một khoảng trống nhỏ ở giữa, nơi slot array đi theo một hướng còn dữ liệu tuple đi theo hướng ngược lại.
And if I don't line up exactly perfectly, which you almost never do, then you're going to have a little space in the middle that's just wasted.
Và nếu tôi không căn khớp hoàn hảo, mà hầu như không bao giờ được như vậy, thì sẽ có một khoảng trống nhỏ ở giữa bị lãng phí.
Then now, anytime I want to go update a tuple, I've got to go fetch that page into memory In order just to update one tuple inside of it.
Rồi giờ đây, mỗi khi tôi muốn cập nhật một tuple, tôi phải lấy trang đó vào bộ nhớ chỉ để cập nhật một tuple bên trong nó.
Depending on the page size, if my pages are really large, then I might be reading 16 kilobytes to go update a five-byte value or eight-byte value, like something really small.
Tùy vào kích thước trang, nếu các trang của tôi rất lớn, thì tôi có thể phải đọc 16 kilobyte để cập nhật một giá trị năm byte hoặc tám byte, một thứ thật nhỏ.
So there's a lot of ways to I/O potentially, depending on what my workload is, what my data looks like.
Vì vậy có rất nhiều khả năng phát sinh I/O, tùy vào khối lượng công việc và dữ liệu của tôi trông như thế nào.
The other problem is going to be is that because now tuples can be stored across multiple pages, that means if I want to update a batch of tuples at the same time, I may have to go fetch all those individual pages, bring them into memory, and then update them.
Vấn đề khác là vì giờ các tuple có thể được lưu trên nhiều trang, nên nếu tôi muốn cập nhật một loạt tuple cùng lúc, tôi có thể phải lấy từng trang riêng lẻ đó, đưa chúng vào bộ nhớ, rồi mới cập nhật.
If I had 10 tuples that cross 10 different pages, I have to bring in those 10 pages into memory before I can update anything.
Nếu tôi có 10 tuple nằm trên 10 trang khác nhau, tôi phải đưa 10 trang đó vào bộ nhớ trước khi có thể cập nhật bất cứ thứ gì.
And then lastly, this is not so much an issue with tuple-oriented storage, but it's a way to think about how to design systems.
Và cuối cùng, điều này không hẳn là vấn đề của lưu trữ hướng tuple, nhưng đó là một cách để nghĩ về việc thiết kế hệ thống.
Well, what if we actually can't do any in-place updates in our nonvolatile storage?
Chà, nếu thực ra chúng ta không thể cập nhật tại chỗ trên bộ lưu trữ không bay hơi thì sao?
I can't bring a page into memory, jump to some offset within it, and then write out new values to that offset. There's some storage systems that actually don't let you do this.
Tôi không thể đưa một trang vào bộ nhớ, nhảy đến một offset nào đó trong nó, rồi ghi các giá trị mới vào offset đó. Có một số hệ thống lưu trữ thực sự không cho phép làm điều này.
The Hadoop file system is one, probably one of the earliest ones that did this. Google has their own internal file system called Colossus.
Hadoop file system là một ví dụ, có lẽ là một trong những hệ thống đầu tiên làm vậy. Google có hệ thống tệp nội bộ riêng gọi là Colossus.
If you ever use Amazon S3 or other object stores, some of them provide these semantics. You can't do in-place updates. You can only do appends.
Nếu bạn từng dùng Amazon S3 hay các kho đối tượng khác, một số trong đó cung cấp ngữ nghĩa này. Bạn không thể cập nhật tại chỗ. Bạn chỉ có thể append.
You can only create new data. You can't overwrite existing ones. If you want to get rid of the old stuff, you got to actually, it's a delete, and then you do more appends.
Bạn chỉ có thể tạo dữ liệu mới. Bạn không thể ghi đè dữ liệu hiện có. Nếu muốn loại bỏ dữ liệu cũ, thì thực chất đó là một thao tác xóa, rồi bạn lại append thêm.
So because of these issues, there's a different way to store data called log-structured storage. Sometimes these are called log-structured merge trees or LSMs.
Vì những vấn đề này, có một cách lưu trữ dữ liệu khác gọi là log-structured storage. Đôi khi chúng được gọi là log-structured merge tree hay LSM.
And the idea here is that instead of storing tuples and pages and then updating them in place, Multiversioning we'll cover later.
Ý tưởng ở đây là thay vì lưu các tuple trong các trang rồi cập nhật tại chỗ, Multiversioning thì chúng ta sẽ học sau.
What I'm saying is not exactly true for multiversioning, but what we're talking about today is going to look like multiversioning, but not in the way that we'll talk about later for concurrency control.
Điều tôi đang nói không hoàn toàn đúng với multiversioning, nhưng những gì chúng ta bàn hôm nay sẽ trông giống multiversioning, chứ không phải theo cách chúng ta sẽ nói sau này cho concurrency control.
But the high-level idea is still the same: that instead of diving in to do in-place updates, the only thing we can do is append new records to data pages.
Nhưng ý tưởng ở mức cao vẫn như nhau: thay vì lao vào cập nhật tại chỗ, điều duy nhất chúng ta có thể làm là append các bản ghi mới vào các trang dữ liệu.
And the idea is, because now we're going to only do appends, because we have to handle deletes to remove things, then that makes some of the algorithms to go read and write data more efficient or less efficient, but it's going to make our updates go really, really fast.
Và ý tưởng là, vì giờ chúng ta chỉ thực hiện append, và vì chúng ta phải xử lý việc xóa để loại bỏ dữ liệu, nên điều đó khiến một số thuật toán để đọc và ghi dữ liệu hiệu quả hơn hoặc kém hiệu quả hơn, nhưng nó sẽ làm cho các thao tác cập nhật của chúng ta chạy cực kỳ nhanh.
Inserts go really fast as well because you're just appending new records, and then that's that thing we talked about before, where we want to be able to minimize the amount of random I/O in exchange for more sequential I/O.
Các thao tác chèn cũng chạy rất nhanh vì ta chỉ nối thêm các bản ghi mới, và đó chính là điều chúng ta đã nói trước đây, là ta muốn giảm thiểu lượng I/O ngẫu nhiên để đổi lấy nhiều I/O tuần tự hơn.
So now if we only do appends, that's all sequential I/O, and that's going to be much faster for us. So the LSMs are an old idea that goes back to 1996.
Vì vậy, nếu bây giờ ta chỉ nối thêm, thì tất cả đều là I/O tuần tự, và điều đó sẽ nhanh hơn nhiều đối với chúng ta. LSM là một ý tưởng cũ có từ năm 1996.
Actually, the guy that invented the LRU-K stuff we talked about in the last class also was the inventor of the LSMs. The paper came out in 1996.
Thực ra, người đã phát minh ra LRU-K mà chúng ta nói đến ở buổi học trước cũng là người phát minh ra LSM. Bài báo ra đời năm 1996.
There was earlier work done on log-structured file systems in the late 80s, early 90s, and so this is a successor to that in the file system world but applying to databases.
Trước đó đã có những công trình về hệ thống tệp có cấu trúc nhật ký vào cuối những năm 80, đầu những năm 90, và đây là sự kế thừa của những công trình đó trong thế giới hệ thống tệp, nhưng áp dụng cho cơ sở dữ liệu.
So there's essentially going to be two main data structures in a log-structured storage system.
Về cơ bản sẽ có hai cấu trúc dữ liệu chính trong một hệ thống lưu trữ có cấu trúc nhật ký.
There'll be a memtable, or in-memory data structure, where we do all our writes and make all our changes, and that one, because it's in memory, we can make in-place updates.
Có một memtable, tức là một cấu trúc dữ liệu trong bộ nhớ, nơi ta thực hiện mọi thao tác ghi và mọi thay đổi, và vì nó nằm trong bộ nhớ, nên ta có thể cập nhật tại chỗ.
And then as this memtable gets too big, then we're going to write it out to this immutable file called an SSTable.
Rồi khi memtable này trở nên quá lớn, ta sẽ ghi nó ra một tệp bất biến gọi là SSTable.
I think it's called, it stands for sorted string table or sometimes sorted static table.
Tôi nghĩ tên đó là viết tắt của sorted string table, hoặc đôi khi là sorted static table.
Whatever, it's the same idea, but it's going to be a sort of compact form of what the mem table is that's going to have the changes that are made to the database.
Sao cũng được, ý tưởng vẫn như nhau, nhưng nó sẽ là một dạng nén gọn của memtable, chứa các thay đổi đã được thực hiện đối với cơ sở dữ liệu.
So there's only two operations to modify a log-structured system. We put, we add a new entry, and delete. There's no overwrite.
Vậy chỉ có hai thao tác để sửa đổi một hệ thống có cấu trúc nhật ký. Đó là put, tức thêm một mục mới, và delete. Không có ghi đè.
There's no update. There's no upserts.
Không có cập nhật. Không có upsert.
It puts basically the same as insert, but it may not be, you may be physically putting a new record in, but logically it might be updating an existing one.
Put về cơ bản giống insert, nhưng có thể không hẳn, về mặt vật lý bạn có thể đang đưa vào một bản ghi mới, nhưng về mặt logic nó có thể đang cập nhật một bản ghi có sẵn.
We'll see what that looks like in a second. So again, now we bring in the demarcation line between disk and memory.
Chúng ta sẽ thấy nó trông thế nào ngay sau đây. Vậy bây giờ ta vẽ đường phân ranh giữa đĩa và bộ nhớ.
Again, we have our mem table up above and some tree data structure that's going to record changes that we're going to make to the database.
Ta có memtable ở phía trên và một cấu trúc dữ liệu dạng cây sẽ ghi lại các thay đổi mà ta sắp thực hiện đối với cơ sở dữ liệu.
I'm not saying what the data structure is. Again, it could be a B+tree. Skip lists are pretty common. It could be a trie. It doesn't matter.
Tôi không nói đó là cấu trúc dữ liệu nào. Nó có thể là B+tree. Skip list khá phổ biến. Có thể là trie. Không quan trọng.
So say now my operation is I want to put a new value in for key 101. I'm not defining how, I'm determining what key 101 is.
Giả sử thao tác của tôi là put một giá trị mới cho khóa 101. Tôi không định nghĩa cách làm, tôi đang xác định khóa 101 là gì.
You can think of it the same way we did that, like the row ID in SQLite, like a sequential counter where the system is maintaining for every new record, you just add a new key.
Bạn có thể hình dung giống như cách chúng ta đã làm, như row ID trong SQLite, một bộ đếm tuần tự mà hệ thống duy trì, với mỗi bản ghi mới thì bạn thêm một khóa mới.
You increment a counter by one. So I'm going to put this put into my mem table and I'm going to basically add a new entry for it.
Bạn tăng bộ đếm lên một. Vậy tôi sẽ đưa put này vào memtable và về cơ bản thêm một mục mới cho nó.
Same thing now, I want to do a put for key 102 with a new value of B1. I'll put that in my mem table as well.
Tương tự, bây giờ tôi muốn put cho khóa 102 với giá trị mới là B1. Tôi cũng sẽ đưa nó vào memtable.
And then now, if I want to go back and modify key 101 again, now with a value A2, Again, because the mem table is in memory by its name, I can do an in-place update inside of that.
Và bây giờ, nếu tôi muốn quay lại sửa khóa 101 một lần nữa, lần này với giá trị A2, Một lần nữa, vì mem table nằm trong bộ nhớ, tôi có thể cập nhật tại chỗ ngay bên trong nó.
I actually don't need to record the history of the previous changes that were made.
Thực ra tôi không cần ghi lại lịch sử của các thay đổi trước đó.
There's a separate log file we're not going to talk about in today's class, but basically, because this is in memory, if you crash, you could lose data.
Có một tệp log riêng mà hôm nay chúng ta sẽ không nói tới, nhưng về cơ bản, vì dữ liệu này nằm trong bộ nhớ, nếu hệ thống sập thì bạn có thể mất dữ liệu.
But basically, we are appending the puts to a separate file and that'll get flushed before we say the transaction is committed. But for now, we can ignore that.
Nhưng về cơ bản, chúng ta nối thêm các thao tác put vào một tệp riêng và tệp đó sẽ được flush trước khi ta báo rằng giao dịch đã commit. Nhưng bây giờ, chúng ta có thể bỏ qua phần đó.
Just be aware that we have a way to keep the mem table durable. Same thing if I do another put on key 103, I'll update my mem table and stuff like that.
Chỉ cần biết rằng chúng ta có cách để giữ cho mem table bền vững. Tương tự nếu tôi thực hiện một put khác trên khóa 103, tôi sẽ cập nhật mem table và các thứ tương tự.
So at some point, the mem table is going to get full. We're going to run out of space. Think a couple hundred megabytes or something like that.
Rồi đến một lúc nào đó, mem table sẽ đầy. Chúng ta sẽ hết chỗ. Hãy nghĩ đến vài trăm megabyte hoặc đại loại như vậy.
So at which point, we're going to take a scan on the leaf nodes of the mem table. That's because that's all the entries of the actual values for the different keys that we have.
Khi đó, chúng ta sẽ quét các nút lá của mem table. Vì đó chính là nơi chứa toàn bộ các mục giá trị thực của các khóa khác nhau mà chúng ta có.
And we're going to store that now into a different form, the SSTable. Again, this is almost like the write-ahead log of the log.
Và giờ chúng ta sẽ lưu chúng sang một dạng khác, đó là SSTable. Một lần nữa, nó gần giống như write-ahead log của log.
Here's all the changes that were made that this mem table recorded.
Đây là tất cả các thay đổi mà mem table này đã ghi lại.
So again, if I made multiple changes to a key, like I changed key 101 multiple times, because I'm doing in-place updates in the mem table, when I write out the SSTable, I only see whatever the latest version of that was.
Vậy nên, nếu tôi thay đổi một khóa nhiều lần, chẳng hạn tôi đổi khóa 101 nhiều lần, vì tôi cập nhật tại chỗ trong mem table, khi ghi SSTable ra, tôi chỉ thấy phiên bản mới nhất của nó.
So at this point, once my SSTable has been initialized with the data of the mem table, I'm storing the data within the lowest key to the highest key.
Vậy tại thời điểm này, khi SSTable đã được khởi tạo bằng dữ liệu của mem table, tôi lưu dữ liệu từ khóa thấp nhất đến khóa cao nhất.
So this is in a sorted order based on whatever key that we want. I'm going to go ahead and write this out to disk, to non-volatile storage. Do a flush, make sure it's there.
Tức là nó được sắp xếp theo thứ tự của khóa mà chúng ta chọn. Tôi sẽ ghi nó xuống đĩa, xuống bộ nhớ không bay hơi. Thực hiện flush, đảm bảo dữ liệu đã nằm ở đó.
And then I'll just populate a new mem table, just keep doing this over and over again, making new SS tables.
Rồi tôi sẽ tạo một mem table mới, cứ lặp đi lặp lại như vậy, tạo ra các SSTable mới.
And these are now going to be basically sorted now in timestamp order from newest to oldest. Within one file, it's sorted from key low to high.
Và những SSTable này về cơ bản sẽ được sắp xếp theo thứ tự dấu thời gian, từ mới nhất đến cũ nhất. Trong một tệp, dữ liệu được sắp xếp theo khóa từ thấp đến cao.
With cross -multiple files, I'm going to sort them, keep track of them in newest to oldest order.
Còn giữa nhiều tệp, tôi sẽ sắp xếp chúng, theo dõi chúng theo thứ tự từ mới nhất đến cũ nhất.
You put the file name, have a timestamp, and the timestamp is always incrementing as things go forward. So I'm going to show one type of compaction.
Bạn đặt tên tệp, kèm một dấu thời gian, và dấu thời gian luôn tăng dần theo thời gian. Tôi sẽ trình bày một kiểu compaction.
It's probably the most common one, but I'll show another one, and I'll go into more detail what this compaction scheme looks like.
Có lẽ đây là kiểu phổ biến nhất, nhưng tôi cũng sẽ trình bày một kiểu khác, và tôi sẽ đi vào chi tiết hơn về cách hoạt động của sơ đồ compaction này.
But at some point, this level is going to get full, so then I actually want to combine SS tables that are in disk, the first level zero, and I'll combine them into a new SS table.
Nhưng đến một lúc nào đó, tầng này sẽ đầy, khi đó tôi muốn gộp các SS table đang nằm trên đĩa, ở tầng đầu tiên là tầng 0, và gộp chúng thành một SSTable mới.
And then I can blow away the old ones. The idea is that as you keep going down, these things get bigger and bigger.
Sau đó tôi có thể xóa bỏ những cái cũ. Ý tưởng là càng đi xuống các tầng dưới, chúng càng lớn dần.
And the idea is that I'm throwing away things that I don't need anymore, and I always try to have whatever the latest version is at each level for a given key.
Ý tưởng là tôi vứt bỏ những thứ mình không còn cần nữa, và tôi luôn cố gắng giữ phiên bản mới nhất của một khóa nhất định ở mỗi tầng.
Yes? This question is, why do we want multiple levels? Why not just merge levels there within itself? Give me two slides, we'll come to that.
Bạn hỏi gì? Câu hỏi là, tại sao chúng ta muốn có nhiều tầng? Sao không chỉ trộn ngay trong chính tầng đó? Cho tôi hai slide nữa, chúng ta sẽ nói tới.
So one would be better for reads, one would be better for writes. I'm not showing key ranges here, and that's why it's maybe confusing. Give me a few slides. Yes?
Một cách sẽ tốt hơn cho việc đọc, một cách tốt hơn cho việc ghi. Tôi chưa cho thấy các khoảng khóa ở đây, nên có thể hơi khó hiểu. Cho tôi vài slide nữa. Bạn hỏi gì?
I assume you're talking about operations. Do you just throw out other operations at the same key value that we're expecting from? Yes. Two slides.
Tôi đoán bạn đang nói về các thao tác. Có phải ta chỉ bỏ các thao tác khác trên cùng một giá trị khóa mà ta đang cần không? Đúng. Hai slide nữa.
His question is, and he's correct, is this compaction, are we throwing out operations that we don't need anymore?
Câu hỏi của bạn ấy là, và bạn ấy nói đúng, trong compaction này, chúng ta có bỏ đi những thao tác không còn cần nữa không?
Yes. So if I do a bunch of puts on a key, then I delete that key. I don't need to keep the puts, I just need to know that I deleted it.
Có. Nếu tôi thực hiện một loạt put trên một khóa, rồi xóa khóa đó. Tôi không cần giữ các put, chỉ cần biết là tôi đã xóa nó.
So you basically end up with sort of this tier structure like this, where you have big, longer SS tables at the bottom, and progressively smaller ones as you go up.
Như vậy rốt cuộc bạn có một cấu trúc phân tầng như thế này, với các SS table lớn hơn, dài hơn ở dưới cùng, và nhỏ dần khi đi lên.
All right, so that's how we do puts and deletes. We need to handle reads now.
Được rồi, đó là cách ta xử lý put và delete. Giờ ta cần xử lý việc đọc.
So if I want to do a read, the T101, the first thing I'm going to do is go check my mem table to see if I have any entries inside that, because the mem table is always going to have the latest version or latest changes that were made to a key.
Nếu tôi muốn đọc khóa 101, việc đầu tiên tôi làm là kiểm tra mem table xem bên trong có mục nào không, vì mem table luôn có phiên bản mới nhất hoặc những thay đổi mới nhất đã thực hiện trên một khóa.
So I go check my mem table. If it's in there, great. Take whatever the value is and return that back.
Vậy tôi kiểm tra mem table. Nếu có ở đó thì tốt. Lấy giá trị đó và trả về.
I'm also not saying what the value is, I'm kind of being vague here, but it's typically going to be the tuple itself, right, in sort of serialized form.
Tôi cũng chưa nói giá trị là gì, tôi đang nói hơi mơ hồ, nhưng thường nó sẽ là chính tuple, ở dạng đã tuần tự hóa.
But if the key that I want is not in the mem table, then I now got to go check all these different SS tables at different levels.
Nhưng nếu khóa tôi cần không có trong mem table, thì giờ tôi phải kiểm tra tất cả các SS table ở các tầng khác nhau.
And that's going to suck now because I got to go through a bunch of reads to go find some, basically a needle in a haystack. Right?
Và điều đó sẽ rất tệ vì tôi phải thực hiện hàng loạt lần đọc để tìm ra, về cơ bản là mò kim đáy bể. Đúng không?
So the way to deal with this is that you basically maintain what's called a summary table in memory that provides some additional metadata about what's actually in these files.
Cách giải quyết là về cơ bản bạn duy trì trong bộ nhớ cái gọi là summary table cung cấp thêm một số siêu dữ liệu về những gì thực sự có trong các tệp này.
Right? So I could say, for a given key 101, I could check, does this key even exist at the different levels?
Đúng không? Vậy với khóa 101, tôi có thể kiểm tra xem khóa này có tồn tại ở các tầng khác nhau hay không?
So I start at level zero because, again, the levels are going, depending on my connection scheme, could be going four at a time. It could be also going across keys.
Tôi bắt đầu từ tầng 0 vì, một lần nữa, các tầng đang đi, tùy theo sơ đồ kết hợp của tôi, có thể đi bốn cái một lần. Cũng có thể đi xuyên qua các khóa.
But I want to see what level has my key.
Nhưng tôi muốn biết tầng nào có khóa của mình.
And then if I know that the key exists maybe at this bottom level here, but it also exists in a higher level there, I always want to choose the higher one because I know that one's more recent.
Và nếu tôi biết khóa có thể nằm ở tầng dưới cùng này, nhưng nó cũng tồn tại ở một level cao hơn ở đó, thì tôi luôn muốn chọn cái ở level cao hơn vì tôi biết cái đó mới hơn.
So again, we're making this tradeoff to make our writes go faster in exchange for slower reads, but we can add some additional data structures to make sure the reads aren't as bad.
Vậy nên một lần nữa, chúng ta đang đánh đổi để các thao tác ghi nhanh hơn, đổi lại việc đọc chậm hơn, nhưng chúng ta có thể thêm một số cấu trúc dữ liệu bổ sung để đảm bảo việc đọc không quá tệ.
Say that again? The question, is the key filter a Bloom filter? What was the question? The question, what is the filter?
Em nói lại được không? Câu hỏi là key filter có phải là Bloom filter không? Câu hỏi là gì nhỉ? Câu hỏi là filter đó là gì?
It could be a range filter to say, within this range, this key doesn't exist or not, because that would handle range scans.
Nó có thể là một range filter, cho biết trong khoảng này key này có tồn tại hay không, vì như vậy sẽ xử lý được các range scan.
It could be a single key. Does this key exist in this level or not? And that would be a Bloom filter lookup.
Nó cũng có thể là một key đơn lẻ. Key này có tồn tại ở level này hay không? Và đó sẽ là một lần tra cứu Bloom filter.
So that could give you a, we'll talk about Bloom filters in a few weeks, but that could give you a false positive. It might tell you the key exists in this lower level.
Vậy nó có thể cho bạn, chúng ta sẽ nói về Bloom filter trong vài tuần nữa, nhưng nó có thể cho bạn một kết quả dương tính giả. Nó có thể báo rằng key tồn tại ở level thấp hơn này.
Then you've got to go actually look and check to see whether it's there or not. Yes? The way I imagine it, the key has to be down to the key filter.
Khi đó bạn phải thực sự đi tìm và kiểm tra xem nó có ở đó hay không. Vâng, em hỏi? Theo em hình dung thì key phải được đưa xuống key filter.
Like, suppose, and which field you're in. Like, let's say I say, I want to update this field for ID 1.
Ví dụ, giả sử, và còn tùy bạn đang ở trường nào. Ví dụ, giả sử tôi muốn cập nhật trường này cho ID 1.
Then, in my main table, I only have, we've only talked about this field I'm saying. But let's say there are many other fields that I've dated.
Khi đó, trong bảng chính của tôi, chúng ta mới chỉ nói về trường này thôi. Nhưng giả sử còn nhiều trường khác mà tôi đã cập nhật.
The statement is, again, this is why I'm trying to be vague about what the value is.
Phát biểu là, một lần nữa, đây là lý do tôi cố tình nói mơ hồ về giá trị là gì.
The statement is, is the, if I update a record, if it's a blind write, I don't need to look to see what it actually was.
Phát biểu là, nếu tôi cập nhật một bản ghi, nếu đó là blind write thì tôi không cần xem giá trị thực sự trước đó là gì.
I just put a put, and I'm done. If it's like, update Andy's salary, or Andy's age, where age equals current age plus one, I've got to go read whatever the original value was.
Tôi chỉ việc put một cái, và xong. Còn nếu là kiểu cập nhật lương của Andy, hoặc tuổi của Andy, trong đó tuổi bằng tuổi hiện tại cộng một, thì tôi phải đọc giá trị ban đầu là gì.
Then I've got to do an update. And then what do I, I'm actually putting in the mem table.
Rồi tôi phải thực hiện cập nhật. Và rồi cái tôi thực sự đưa vào mem table là gì.
In the case of RocksDB, I think it's, or most systems, it's going to be the full tuple all over again. But my point is, let's say it's just a write.
Với RocksDB, tôi nghĩ là, hoặc hầu hết các hệ thống, nó sẽ là toàn bộ tuple một lần nữa. Nhưng ý tôi là, giả sử nó chỉ là một thao tác ghi.
I don't care what people are saying, like Andy's age. A blind write. Yes.
Tôi không quan tâm người ta nói gì, như tuổi của Andy. Một blind write. Vâng, mời em.
So if I do that, and later on I want to read your record, it's not enough to, like, find your age.
Vậy nếu làm thế, và sau này tôi muốn đọc bản ghi của bạn, thì chỉ tìm tuổi của bạn là chưa đủ.
I need to find everything. Like, your record here is in multiple SS tables.
Tôi cần tìm mọi thứ. Như bản ghi của bạn ở đây nằm trong nhiều SS table.
Yes, so his statement is, you're basically asking, is a given record that has multiple attributes, is that, those attributes broken across multiple SS tables?
Vâng, ý em là, về cơ bản em đang hỏi, một bản ghi có nhiều thuộc tính, thì các thuộc tính đó có bị tách ra nhiều SS table không?
No, you would always have the full tuple with all its attributes in the record that you're storing as part of the value in the mem table or an SS table.
Không, bạn luôn có đầy đủ tuple với tất cả thuộc tính của nó trong bản ghi mà bạn lưu như một phần của giá trị trong mem table hoặc một SS table.
A blind write would be like an insert. But to your point, yeah, so his point is, like, you'd have to do a read-modify-write. You'd have to go fetch the tuple, then update.
Một blind write sẽ giống như một lệnh insert. Nhưng theo ý em thì đúng, ý em là bạn sẽ phải thực hiện read-modify-write. Bạn phải lấy tuple về, rồi mới cập nhật.
Depends on, like, what the query is.
Còn tùy câu truy vấn là gì.
If it's an update, where you're, if it's an update where you're, like, you're changing all the attributes, then yeah, you don't need to see what the original ones were.
Nếu là một lệnh update, mà trong đó, nếu là update mà bạn, thay đổi tất cả các thuộc tính, thì đúng rồi, bạn không cần xem giá trị ban đầu là gì.
Just do an update in place. Or not update in place, you can do an update without actually reading it. Other questions? All right, so again, what are we doing?
Cứ update tại chỗ. Hoặc không update tại chỗ, bạn có thể update mà không cần đọc nó. Còn câu hỏi nào khác không? Được rồi, vậy một lần nữa, chúng ta đang làm gì?
It's a basic key-value storage architecture where, again, the value is going to represent the contents of the tuple.
Đó là một kiến trúc lưu trữ key-value cơ bản, trong đó, một lần nữa, value sẽ biểu diễn nội dung của tuple.
The, if we do a delete, we don't actually need to go find the data that we want and actually delete it, which is kind of nice.
Còn nếu chúng ta thực hiện delete, thì thực ra không cần đi tìm dữ liệu muốn xóa rồi xóa nó thật, điều này khá hay.
Again, in a tuple-oriented architecture, and it's a lot of pages, I gotta go fetch the page, then mark, go, mark it as deleted.
Trong kiến trúc hướng tuple, vốn có rất nhiều page, tôi phải đi lấy page đó, rồi đánh dấu nó là đã xóa.
In this case here, if I have the key of the thing I want to delete, I just put a delete key record in my, my log, in the mem table, and then I'm done with it.
Còn ở đây, nếu tôi có key của thứ muốn xóa, tôi chỉ cần ghi một bản ghi delete key vào log của mình, trong mem table, và thế là xong.
Then anybody else that comes along wants to read that tuple, you gotta, you know, has to make sure that it sees that delete record Notifying it that the record no longer logically exists, even though physically it might be, and it's still in a bunch of SSTables, so we know we should ignore it if we try to do a lookup on it.
Sau đó bất kỳ ai khác đến và muốn đọc tuple đó, thì phải đảm bảo là nhìn thấy bản ghi delete đó, báo rằng về mặt logic bản ghi không còn tồn tại nữa, dù về mặt vật lý nó có thể vẫn còn, vẫn nằm trong một loạt SSTable, nên chúng ta biết là phải bỏ qua nó nếu thử tra cứu nó.
Yeah, sorry, yes.
Vâng, xin lỗi, mời bạn.
Question: the question is, when do SSTables get merged? Next slide. Okay.
Câu hỏi là: khi nào các SSTable được gộp? Ở slide tiếp theo. Được rồi.
So, at some point, I'm making all these SSTables running out to the disk, and, you know, if I delete a tuple, if I update a tuple a thousand times, then I delete it, I'm gonna have a thousand and one records corresponding to that one tuple, but I only really need the latest one.
Vậy, đến một lúc nào đó, tôi tạo ra tất cả các SSTable này và ghi xuống đĩa, và nếu tôi xóa một tuple, nếu tôi update một tuple một nghìn lần rồi xóa nó, tôi sẽ có một nghìn lẻ một bản ghi tương ứng với tuple đó, nhưng thực sự tôi chỉ cần bản ghi mới nhất.
So there'll be this background process that gets triggered based on the size of the SSTables, based on the number of overlapping key ranges, we'll see that in the next slide.
Vì vậy sẽ có một tiến trình nền được kích hoạt dựa trên kích thước của các SSTable, dựa trên số lượng khoảng key chồng lấn, chúng ta sẽ thấy ở slide tiếp theo.
There's a bunch of ways, a bunch of mechanisms to trigger when compaction should kick in. And again, there's this trade-off between doing background maintenance and actually just running queries.
Có nhiều cách, nhiều cơ chế để kích hoạt thời điểm compaction bắt đầu. Và một lần nữa, có sự đánh đổi giữa việc bảo trì nền và việc thực sự chạy các truy vấn.
Remember we talked about the background writer, or the page cleaner, in the buffer pool?
Nhớ là chúng ta đã nói về background writer, hay page cleaner, trong buffer pool chứ?
We could have a thread run through our buffer pool manager, find our dirty pages and start proactively writing them out so that they get marked clean and they can get evicted.
Chúng ta có thể cho một thread chạy qua buffer pool manager, tìm các dirty page và chủ động ghi chúng ra để chúng được đánh dấu là sạch và có thể bị đuổi ra.
But if I'm spending all my time doing that, then I'm gonna slow down queries actually trying to do real work.
Nhưng nếu tôi dành toàn bộ thời gian để làm việc đó, thì tôi sẽ làm chậm các truy vấn đang thực sự làm việc chính.
So I could spend all my time doing compaction to clean up all these SSTables, but that's gonna make query execution run slower.
Vậy tôi có thể dành hết thời gian để compaction nhằm dọn dẹp các SSTable này, nhưng điều đó sẽ làm việc thực thi truy vấn chạy chậm hơn.
So there really isn't a good way to, there's not a sort of one-size-fits-all solution to determine when you should trigger a compaction. But things like RocksDB have a bunch of different policies.
Vì vậy thực sự không có cách nào tốt để, không có một giải pháp chung cho mọi trường hợp để xác định khi nào nên kích hoạt compaction. Nhưng những hệ thống như RocksDB có nhiều chính sách khác nhau.
So say, in the most simple form, say I have two SSTables, I wanna merge them.
Giả sử, ở dạng đơn giản nhất, tôi có hai SSTable và muốn gộp chúng.
And in this case here, I'm assuming that the order of the two SS tables is from newest to oldest.
Và trong trường hợp này, Tôi giả định thứ tự của hai SS table là từ mới nhất đến cũ nhất.
So the one on, all the way over here, is the newest one, the one after that is older than that.
Vậy cái ở tận đây là cái mới nhất, cái tiếp theo thì cũ hơn cái đó.
So the way I'm gonna do, basically, merge is the same way you're gonna do sort merge. If you know that algorithm, we'll talk about that in two weeks.
Cách tôi sẽ làm, về cơ bản, việc gộp (merge) cũng giống cách bạn làm sort merge. Nếu bạn biết thuật toán đó, chúng ta sẽ nói về nó trong hai tuần nữa.
There's a join algorithm on sort merge as well. You basically just have two cursors that start at the beginning of both these files. Again, I'm showing two SS tables. You can have multiple ones.
Sort merge cũng là một thuật toán join. Về cơ bản bạn chỉ có hai con trỏ (cursor) bắt đầu ở đầu của cả hai tệp này. Một lần nữa, tôi đang minh họa hai SS table. Bạn có thể có nhiều hơn.
Typically, you wanna merge multiple ones at the same time. But for our illustration, it's just two.
Thông thường, bạn muốn gộp nhiều SS table cùng một lúc. Nhưng để minh họa, ở đây chỉ có hai.
So now what's gonna happen is, I'm gonna look at whatever the key is being referenced at wherever my cursor's pointing at.
Bây giờ điều sẽ xảy ra là, tôi sẽ xem khóa nào đang được tham chiếu ở vị trí mà con trỏ của tôi đang trỏ tới.
In this case here, the first cursor is looking at a delete on key 100. This guy has a put on key 101. This is 100 is less than 101.
Trong trường hợp này, con trỏ đầu tiên đang nhìn vào một delete trên khóa 100. Cái này có một put trên khóa 101. Vậy 100 nhỏ hơn 101.
I know that there isn't gonna be a reference to key 100 in this SS table. So therefore, I can just take whatever that record is and put it in my new SS table.
Tôi biết sẽ không có tham chiếu nào tới khóa 100 trong SS table này. Do đó, tôi có thể lấy bất kể bản ghi đó và đưa vào SS table mới của tôi.
And then I move that cursor down, but I keep the other cursor at the same location that it was pointing at before.
Sau đó tôi di chuyển con trỏ đó xuống, nhưng giữ con trỏ còn lại ở đúng vị trí mà nó trỏ tới trước đó.
So now at this point here, we have a put on key 101 in the first one, and then a put on key 101 as well in the second one.
Bây giờ ở đây, chúng ta có một put trên khóa 101 ở cái đầu tiên, và cũng một put trên khóa 101 ở cái thứ hai.
But since this SS table is newer than this one, we know we don't care about whatever that put was. We only care about the latest one.
Nhưng vì SS table này mới hơn cái kia, nên ta biết ta không quan tâm put đó là gì. Ta chỉ quan tâm cái mới nhất.
So we go ahead and remove, ignore that put and put the first SS tables into the new one. Then same thing, both of their cursors move down.
Vì vậy ta bỏ đi, bỏ qua put đó và đưa bản ghi của SS table thứ nhất vào cái mới. Tương tự, cả hai con trỏ cùng di chuyển xuống.
They have a put on key 102, another put on key 102 in both of them. I don't care about the second one. I only put the first one. Keep moving down.
Chúng có một put trên khóa 102, và một put khác trên khóa 102 ở cả hai. Tôi không quan tâm cái thứ hai. Tôi chỉ đưa cái đầu tiên vào. Tiếp tục đi xuống.
Now I have a put in key 103, but I also have a delete on key 103. Same thing.
Giờ tôi có một put trên khóa 103, nhưng cũng có một delete trên khóa 103. Cũng tương tự.
They're operating on the same, doing some modification to the same key, but I only care about the latest one. So I go ahead and ignore the second one, put in the first one.
Chúng đang thao tác trên cùng một khóa, thực hiện một sửa đổi trên cùng khóa đó, nhưng tôi chỉ quan tâm cái mới nhất. Vì vậy tôi bỏ qua cái thứ hai, đưa cái đầu tiên vào.
The first cursor is done. So now I keep scanning along, and whatever comes after that, I know I want to copy into my new SS table. So I put the put for 104 there.
Con trỏ đầu tiên đã xong. Giờ tôi tiếp tục quét xuống, và bất kể thứ gì đến sau đó, tôi biết mình muốn sao chép vào SS table mới. Vậy tôi đưa put của khóa 104 vào đó.
That's basically what compaction is doing.
Về cơ bản đó là những gì compaction đang làm.
Now the tricky thing is going to be, how do I organize multiple SS tables and what am I, what's the, how am I deciding what SS tables to merge?
Giờ điều khó là, làm thế nào để tổ chức nhiều SS table và tôi sẽ, làm sao tôi quyết định nên gộp những SS table nào?
And we said, when it gets triggered based on a bunch of different policies.
Và ta đã nói, nó được kích hoạt dựa trên nhiều chính sách khác nhau.
So what I showed before was an example I'll call level compaction, where I'm going to maintain different levels of SS tables of different sizes, and the goal here is actually to have non-overlapping key ranges within our levels, except for level zero, because that's the special one where as mem tables get full,
Vậy cái tôi cho xem trước đó là ví dụ mà tôi gọi là level compaction, trong đó tôi duy trì các tầng (level) SS table khác nhau với kích thước khác nhau, và mục tiêu ở đây thực ra là có các khoảng khóa không chồng lấn nhau trong mỗi tầng của chúng ta, ngoại trừ tầng không (level 0), vì đây là tầng đặc biệt, nơi khi các mem table đầy,
we record them as SS tables, we just append them to disk. So in that case, they will have overlapping key ranges, but everything below that will not.
ta ghi chúng thành các SS table, chỉ việc nối thêm vào đĩa. Vì vậy trong trường hợp đó, chúng sẽ có các khoảng khóa chồng lấn nhau, nhưng mọi thứ bên dưới tầng đó thì không.
So again, so assuming that the SS tables are growing from newest to oldest, our first SS table we're going to get right now is going to have key range from A to R, right, arbitrary letters.
Một lần nữa, giả sử các SS table lớn dần từ mới nhất đến cũ nhất, thì SS table đầu tiên mà ta có ngay lúc này có khoảng khóa từ A đến R, các chữ cái này chỉ là tùy ý.
Next one is going to have key ranges from E to T, and then the third one here will have key ranges from B to Q.
Cái tiếp theo sẽ có khoảng khóa từ E đến T, và cái thứ ba ở đây sẽ có khoảng khóa từ B đến Q.
So at some point, I'm going to run out of space, or something gets trickier, since I want to now do compaction on level zero.
Đến một lúc nào đó, tôi sẽ hết chỗ, hoặc mọi thứ trở nên phức tạp hơn, vì giờ tôi muốn thực hiện compaction trên tầng 0.
So I'm now going to make a new level, level one, and I'm going to take these three SS tables, and I'm going to combine them into two larger SS tables, And I'll do the compaction I just showed in the previous slide, where I'll have a cursor go through each one and remove whatever the oldest entry is for a given key, and it'll only keep the latest one.
Vậy bây giờ tôi sẽ tạo một tầng mới, tầng 1, và tôi sẽ lấy ba SS table này, rồi gộp chúng thành hai SS table lớn hơn, Và tôi sẽ thực hiện compaction như tôi vừa trình bày ở slide trước, trong đó tôi cho một con trỏ duyệt qua từng cái và loại bỏ mục cũ nhất với mỗi khóa cho trước, và chỉ giữ lại mục mới nhất.
But then my new SS tables I'm going to generate now have non-overlapping keys within this level.
Nhưng các SS table mới mà tôi tạo ra bây giờ có các khóa không chồng lấn nhau trong tầng này.
So if I'm looking for key X, for example, if I have to look at level zero, I have to potentially look at all the SS tables to find key X.
Vậy nếu tôi tìm khóa X, chẳng hạn, nếu tôi phải xem tầng 0, thì có thể tôi phải xem tất cả các SS table để tìm khóa X.
Well, actually, I wouldn't need any of them, but say I'm looking for key Q.
À, thực ra thì tôi sẽ không cần cái nào cả, nhưng giả sử tôi tìm khóa Q.
I would actually have to look at all three SS tables to find that given key, because each of them have, that key could fit each of their ranges.
Thì thực sự tôi phải xem cả ba SS table để tìm khóa đó, vì khóa đó có thể nằm trong khoảng khóa của mỗi cái.
But now when I do a compaction down to the second level, or level one, since now they're non-overlapping key ranges, if I need key Q, I know I only have to go look in the second SS table.
Nhưng bây giờ khi tôi compaction xuống tầng thứ hai, tức tầng 1, vì các khoảng khóa giờ không chồng lấn, nếu tôi cần khóa Q, tôi biết mình chỉ phải tìm trong SS table thứ hai.
It may not exist, and again, I can use a filter to tell me whether it's going to exist or not, but if it could exist, then I know, so I only need to look at one SS table.
Có thể nó không tồn tại, và một lần nữa, tôi có thể dùng bộ lọc để biết nó có tồn tại hay không, nhưng nếu nó có thể tồn tại, thì tôi biết là mình chỉ cần xem một SS table.
Yes? AUDIENCE MEMBER: Can you just wipe it up?
Vâng, bạn? KHÁN GIẢ: Thầy có thể xóa nó đi được không?
It's a question, why do we end up with multiple SS tables in level two? It could be just one giant one.
Câu hỏi là, tại sao ta lại có nhiều SS table ở tầng hai? Có thể chỉ là một cái khổng lồ.
Basically, the size of the SS table is growing, sorry, size of the SS table grows per level, and so the cumulative size of the SS tables above that I'm merging down may be larger than what I could fit into a single SS table, so I drew a two, but it could just be one.
Về cơ bản, kích thước của SS table tăng lên, xin lỗi, kích thước của SS table tăng theo từng tầng, nên tổng kích thước các SS table ở tầng trên mà tôi gộp xuống có thể lớn hơn mức một SS table đơn lẻ chứa được, nên tôi vẽ hai cái, nhưng cũng có thể chỉ là một.
I just wanted to show two, that you would have these non-overlapping ranges.
Tôi chỉ muốn vẽ hai để cho thấy các khoảng khóa không chồng lấn này.
So once this is done, again, I can blow away all the SS tables at level zero and keep doing the same thing, just keep adding more and more, right, doing depends, and now I have different ranges, And at some point I want to do a merge.
Vậy khi việc này xong, tôi có thể xóa bỏ tất cả SS table ở tầng 0 và tiếp tục làm điều tương tự, cứ thêm ngày càng nhiều, đúng rồi, cứ nối thêm, và giờ tôi có các khoảng khóa khác nhau, Và đến một lúc nào đó tôi muốn thực hiện một lần gộp.
And again, these are going to be overlapping ranges in level zero, but when I create SS tables in level one, they have to be non-overlapping.
Và một lần nữa, các khoảng ở tầng 0 sẽ chồng lấn nhau, nhưng khi tạo các SS table ở tầng 1, chúng phải không chồng lấn.
So I may actually end up recreating all the files again.
Vì vậy thực tế tôi có thể phải tạo lại toàn bộ các tệp một lần nữa.
So read them all into memory using my buffer pool manager, and then write them all back out, because the keys that are in level zero might be in any of the files, might go in any of the files.
Nên đọc hết chúng vào bộ nhớ bằng buffer pool manager của tôi, rồi ghi tất cả ra lại, vì các khóa ở level zero có thể nằm trong bất kỳ tệp nào, có thể thuộc về bất kỳ tệp nào.
I may have to generate a bunch more files.
Tôi có thể phải tạo thêm một loạt tệp nữa.
So if I have, like, 10 gigabytes of data on level one, I run compaction, I'm going to have to read 10 gigabytes in, and I might be writing out another 10 gigabytes.
Vậy nếu tôi có khoảng 10 gigabyte dữ liệu ở level một, tôi chạy compaction, tôi sẽ phải đọc vào 10 gigabyte, và có thể phải ghi ra thêm 10 gigabyte nữa.
Yes? The question is, is the number of levels fixed? No, it can go forever.
Vâng? Câu hỏi là số lượng level có cố định không? Không, nó có thể tăng mãi.
In practice though, I forget what the default is in RocksDB, you just end up with really big files at the bottom.
Nhưng trong thực tế, tôi quên mất mặc định trong RocksDB là bao nhiêu, bạn sẽ chỉ có những tệp rất lớn ở tầng dưới cùng.
The question is, for any set of what, sorry? For, like...
Câu hỏi là với một tập nào, xin lỗi? Với, kiểu như...
The question is, would you have a setting for a database system to say, I'm going to have 10 levels in my compaction scheme, and then you always have 10 levels?
Câu hỏi là hệ cơ sở dữ liệu có thể có một thiết lập để nói rằng, tôi sẽ có 10 level trong lược đồ compaction, và lúc nào cũng có đúng 10 level không?
No. At the very beginning, I could set this thing to have 10 levels, but right here at this point, you only have two. It grows.
Không. Ngay từ đầu, tôi có thể đặt tối đa 10 level, nhưng ngay tại thời điểm này, bạn mới chỉ có hai. Nó tăng dần.
Yeah, so never exceed that, you just end up with really large SS tables, a lot of them at the lowest level.
Vâng, nên không bao giờ vượt quá mức đó, bạn chỉ có những SS table rất lớn, với rất nhiều SS table ở level thấp nhất.
The question is, why is this better for read-heavy workloads?
Câu hỏi là tại sao cách này tốt hơn cho các tải công việc nặng về đọc?
Because when we see universal compaction next slide, if I want to go find a key at a lower level, I only have to look at the SS tables where my key fits in that range.
Vì khi xem universal compaction ở slide sau, nếu tôi muốn tìm một khóa ở level thấp hơn, tôi chỉ cần xem các SS table có khoảng chứa khóa của tôi.
If you go back just to when we only had level zero, and this is fresh from memory into disk, These are overlapping ranges.
Nếu quay lại lúc chỉ có level zero, và dữ liệu vừa được đẩy từ bộ nhớ xuống đĩa, các khoảng này chồng lấn nhau.
So if I want key Q, it can exist in the first one, the second one, or the third one. So I have to check all of them.
Vậy nếu tôi muốn khóa Q, nó có thể nằm ở cái thứ nhất, thứ hai hoặc thứ ba. Nên tôi phải kiểm tra tất cả.
Now in this case here, it would be, since they're ordered based on time, if I see it in the first one, I know I don't care about the other two.
Trong trường hợp này, vì chúng được sắp xếp theo thời gian, nếu thấy nó ở cái đầu tiên, tôi biết không cần quan tâm hai cái còn lại.
But in the worst case, I have to scan all three. Yep.
Nhưng trong trường hợp xấu nhất, tôi phải quét cả ba. Vâng.
Other questions?
Còn câu hỏi nào khác không?
The question is, can the same key exist in level zero and level one? Yes.
Câu hỏi là cùng một khóa có thể tồn tại ở cả level zero và level một không? Có.
The question is, because at level zero it's sorted by newest to oldest, it does not impact the search speed?
Câu hỏi là vì ở level zero được sắp xếp từ mới nhất đến cũ nhất, nên nó không ảnh hưởng đến tốc độ tìm kiếm phải không?
Meaning like, well, no, no. So if I want Q, if I'm only at level zero and I want key Q, if it's not in the first one, I've got to check the second one.
Ý là kiểu như, à không, không. Nếu tôi muốn Q, và chỉ có level zero, tôi muốn khóa Q, nếu nó không có ở cái đầu tiên, tôi phải kiểm tra cái thứ hai.
So that's slow. If it's not in the second one, I've got to check the third one. That's slow. So in the worst case scenario, I have to check everything at level zero.
Vậy là chậm. Nếu không có ở cái thứ hai, tôi phải kiểm tra cái thứ ba. Cũng chậm. Vậy trong trường hợp xấu nhất, tôi phải kiểm tra mọi thứ ở level zero.
The summary table helps me to, helps to maybe not do, look up some tables that, or SST tables that aren't going to have the data that I want.
Bảng tóm tắt giúp có thể không phải tra cứu một số bảng hoặc SST table không chứa dữ liệu tôi cần.
But in the worst case, I may have to check. So reads will get slower.
Nhưng trong trường hợp xấu nhất, tôi vẫn có thể phải kiểm tra. Vậy việc đọc sẽ chậm đi.
But that's why they have the additional levels, because now when I start compacting, going down the levels, I can guarantee that, again, for key Q, it's only going to exist in one SST table at level one.
Nhưng đó là lý do họ có thêm các level, vì giờ khi tôi bắt đầu compaction, đi xuống các level, Tôi có thể đảm bảo rằng, một lần nữa, với khóa Q, nó chỉ tồn tại trong một SST table duy nhất ở level một.
Likewise, if I keep adding more, same thing. Q can only exist in one SST table.
Tương tự, nếu tôi tiếp tục thêm nữa thì vẫn vậy. Q chỉ có thể tồn tại trong một SST table.
Whereas if it's just me just writing SST tables straight from memory, like I do in level zero, it could be in any of them.
Trong khi nếu tôi chỉ ghi thẳng các SST table từ bộ nhớ, như tôi làm ở level zero, thì nó có thể nằm trong bất kỳ bảng nào.
And I just do the same thing. I do compaction down to this level, and I can blow away things there.
Và tôi cứ làm điều tương tự. Tôi thực hiện compaction xuống level này, và tôi có thể xóa bỏ những thứ ở đó.
And now I have, again, non-overlapping ranges within, as they exist now, but again, as I add more things, it may be overlapping.
Và bây giờ tôi lại có các khoảng khóa không chồng lấn bên trong, như hiện tại, nhưng một lần nữa, khi tôi thêm nhiều thứ hơn, chúng có thể chồng lấn.
The question is similar to the one they asked before. What triggers compaction? Depends on the system. Depends how you set it up.
Câu hỏi này giống câu hỏi họ vừa hỏi trước đó. Điều gì kích hoạt compaction? Tùy hệ thống. Tùy cách bạn thiết lập.
So it could be that if I have a max number of, max size of all the files within a level, when that exceeds something, then that triggers compaction.
Có thể là nếu tôi đặt một số lượng tối đa, kích thước tối đa của tất cả các tệp trong một level, khi con số đó vượt quá ngưỡng nào đó thì sẽ kích hoạt compaction.
Can you say it again?
Bạn có thể nói lại không?
The question is, why did I do for this one here? Why did I merge it?
Câu hỏi là, tại sao ở ví dụ này tôi lại làm vậy? Tại sao tôi lại gộp nó?
The question is, why did I merge, in this case here, why did I merge only two SST tables from level one down to level two? It's just the example. What's that?
Câu hỏi là, trong trường hợp này, tại sao tôi lại gộp chỉ hai SST table từ level một xuống level hai? Đó chỉ là ví dụ thôi. Sao cơ?
Yeah, it's like, you would merge more than two. I'm trying to make this work on PowerPoint, so for simplicity, yeah.
Vâng, đúng rồi, bạn có thể gộp nhiều hơn hai. Tôi đang cố làm cho nó chạy được trên PowerPoint, nên cho đơn giản thôi.
You can be very, going back and forth, you can be very aggressive and try to merge everything, but that's going to be, you're just spending your time doing compaction, not running queries.
Bạn có thể, qua lại, bạn có thể rất quyết liệt và cố gộp mọi thứ, nhưng như vậy bạn chỉ tốn thời gian làm compaction, chứ không chạy truy vấn.
All right, so let me show universal compaction real quickly. Universal compaction only has one level.
Được rồi, giờ tôi sẽ trình bày nhanh universal compaction. Universal compaction chỉ có một level.
And again, it's the SST tables as they exist, as they're being written out, from the mem table in memory to disk.
Và một lần nữa, đó là các SST table như hiện có, khi chúng được ghi ra, từ mem table trong bộ nhớ xuống đĩa.
So we want to do compaction on them, but again, we don't want to maintain multiple levels, because we don't want to have this write amplification problem, where every single time we want to do compaction, we've got to read a bunch of things in, and then write it all back out.
Vậy chúng ta muốn thực hiện compaction trên chúng, nhưng một lần nữa, chúng ta không muốn duy trì nhiều level, vì chúng ta không muốn gặp vấn đề write amplification, trong đó mỗi lần chúng ta muốn làm compaction, chúng ta phải đọc cả loạt dữ liệu vào rồi ghi tất cả ra lại.
So instead, we're going to be more targeted compactions.
Vì vậy, thay vào đó, chúng ta sẽ thực hiện các compaction có chọn lọc hơn.
So in this case here, like I said, I'm going to take these three SST tables, again, they all have sort of non-overlapping key ranges, but they're ordered through time, and then now, I'm going to take these three and merge them into a single SST table, compact them, and reclaim the space.
Trong trường hợp này, như tôi đã nói, tôi sẽ lấy ba SST table này, một lần nữa, chúng đều có các khoảng khóa gần như không chồng lấn, nhưng được sắp xếp theo thời gian, và bây giờ, tôi sẽ lấy ba bảng này và gộp chúng thành một SST table duy nhất, compact chúng và thu hồi không gian.
And I can do this again for the next two here, compact them, and put them into a larger one.
Và tôi có thể làm lại với hai bảng tiếp theo ở đây, compact chúng và đưa vào một bảng lớn hơn.
So this is great for workloads where you're inserting data very quickly, do a lot of updates. It's great for workloads where I typically only want the latest data that I just inserted.
Vì vậy cách này rất phù hợp với các workload mà bạn chèn dữ liệu rất nhanh và cập nhật nhiều. Nó rất phù hợp với các workload mà thường tôi chỉ cần dữ liệu mới nhất vừa chèn vào.
Like if I'm inserting time series information, like the temperature of this room, I only care about the last five minutes, ten minutes. I don't care about what the temperature was a year ago.
Chẳng hạn nếu tôi chèn dữ liệu chuỗi thời gian, như nhiệt độ của căn phòng này, tôi chỉ quan tâm đến năm phút, mười phút gần nhất. Tôi không quan tâm nhiệt độ một năm trước là bao nhiêu.
And so in that case, I'll be able to look up very quickly and find the data that I want in the newest SST tables that are on disk.
Và trong trường hợp đó, tôi có thể tra cứu rất nhanh và tìm thấy dữ liệu mình cần trong các SST table mới nhất nằm trên đĩa.
Right?
Đúng không?
Classic trade-off in computer science of like, I'm spending more time, more energy to make the, when I write things, to make the writes more expensive, but my reads will be faster in exchange for, or as opposed to making my writes go really fast, but my reads a little bit slower.
Đây là một sự đánh đổi kinh điển trong khoa học máy tính: tôi tốn nhiều thời gian, nhiều năng lượng hơn để làm cho, khi ghi dữ liệu, thao tác ghi đắt hơn, nhưng đổi lại thao tác đọc sẽ nhanh hơn, hoặc ngược lại, làm cho thao tác ghi cực nhanh, nhưng thao tác đọc chậm hơn một chút.
Right? So this is making the writes go faster, but the reads can potentially be slower based on what you're looking up. Okay.
Đúng không? Vậy ở đây là làm cho việc ghi nhanh hơn, nhưng việc đọc có thể chậm hơn tùy vào thứ bạn tra cứu. Được rồi.
So to finish up, log-structured storage in the last 15 years has become super common. And part of this, this is because of RocksDB.
Để kết thúc, lưu trữ có cấu trúc log trong 15 năm qua đã trở nên cực kỳ phổ biến. Một phần là nhờ RocksDB.
RocksDB is a log-structured merge tree key-value store that actually supports both these compaction schemes. You can set whatever you want. I think default is level compaction.
RocksDB là một kho key-value dạng log-structured merge tree hỗ trợ cả hai cơ chế compaction này. Bạn muốn đặt cái nào cũng được. Tôi nghĩ mặc định là level compaction.
But that has been used as the starting point for, or the built-in storage manager for many, many new systems.
Nhưng nó đã được dùng làm điểm khởi đầu cho, hoặc làm storage manager tích hợp sẵn của rất nhiều hệ thống mới.
RocksDB was not, was created by Facebook or Meta, whatever it is now. But they weren't the original authors of it. It's actually a fork of something called LevelDB that came out of Google.
RocksDB được tạo ra bởi Facebook, hay Meta, bây giờ gọi là gì cũng được. Nhưng họ không phải tác giả gốc của nó. Thực ra nó là một bản fork của thứ gọi là LevelDB đến từ Google.
This was built by Jeff Dean and the people working on Bigtable. They built this log-structured storage embedded key-value store called LevelDB. Facebook forked that and made RocksDB.
Nó được xây dựng bởi Jeff Dean và những người làm việc trên Bigtable. Họ xây dựng kho key-value nhúng dạng log-structured tên là LevelDB. Facebook fork nó và tạo ra RocksDB.
What's the first thing Facebook did when they forked LevelDB to RocksDB? What was that? No, not copyrighted. No, no. They would think it was Apache license maybe, so it wasn't an issue.
Việc đầu tiên Facebook làm khi fork LevelDB thành RocksDB là gì? Gì cơ? Không, không phải bản quyền. Không, không. Có lẽ họ nghĩ đó là giấy phép Apache nên không thành vấn đề.
Non-legal thing. What's the first technical thing they did? No, that's a legal thing. He said change license. No, technical.
Không phải chuyện pháp lý. Việc kỹ thuật đầu tiên họ làm là gì? Không, đó là chuyện pháp lý. Bạn nói đổi giấy phép. Không, phải là kỹ thuật.
They changed the code in what way? What did they do? Remove the mmap. Right?
Họ thay đổi mã theo cách nào? Họ đã làm gì? Loại bỏ mmap. Đúng không?
That was the very first thing they did, was get rid of mmap, because it's garbage, and switch to a buffer pool manager, the same way that we talked about last class.
Đó là việc đầu tiên họ làm: bỏ mmap, vì nó tệ hại, và chuyển sang buffer pool manager, giống như chúng ta đã nói ở buổi trước.
Right? Like I said, a bunch of the different systems, you start off using RocksDB as their own internal storage manager. Cockroach did this, and then over time they rewrite it.
Đúng không? Như tôi đã nói, nhiều hệ thống khác nhau bắt đầu bằng việc dùng RocksDB làm storage manager nội bộ của mình. Cockroach đã làm vậy, rồi theo thời gian họ viết lại nó.
This is, again, a small smattering of log-structured storage systems. There's a lot more.
Đây, một lần nữa, chỉ là một vài ví dụ về các hệ thống lưu trữ log-structured. Còn nhiều hệ thống khác nữa.
And as we said, the challenge of this approach is it's going to be really great for doing writes, but the compaction is expensive, and we may have this write amplification issue where we do one update to a single tuple, and even though we never update it ever again, we're going to read it in, write it out, read it in, write it out, over and over again, multiple times,
Và như chúng ta đã nói, thách thức của cách tiếp cận này là nó rất tuyệt cho việc ghi, nhưng compaction thì tốn kém, và chúng ta có thể gặp vấn đề write amplification khi ta cập nhật một lần cho một tuple, và dù không bao giờ cập nhật lại nữa, ta vẫn sẽ đọc nó vào, ghi nó ra, đọc vào, ghi ra, lặp đi lặp lại nhiều lần,
because of the compaction process.
do quá trình compaction.
Whereas in a tuple-oriented architecture, if I write something to a page, it gets written out to disk, I never read it again, I never write it out over and over again.
Trong khi đó, với kiến trúc hướng tuple, nếu tôi ghi một thứ gì đó vào một trang, nó được ghi xuống đĩa, tôi không bao giờ đọc lại nó nữa, và cũng không phải ghi nó ra hết lần này đến lần khác.
Yes? The question is, are all these systems as bad for read-heavy workloads? No. Things like ClickHouse are really, really good for it.
Em hỏi đi? Câu hỏi là, liệu tất cả các hệ thống này có tệ như vậy với khối lượng công việc nặng về đọc không? Không. Những hệ thống như ClickHouse xử lý việc đó rất, rất tốt.
Because there's a bunch of stuff you can do to mitigate the issues. And that'll be next class. Okay.
Bởi vì có rất nhiều việc bạn có thể làm để giảm thiểu các vấn đề đó. Và đó sẽ là nội dung của buổi sau. Được rồi.
So next class we're actually going to break your preconceived notion of what a database looks like. For now we've been talking about these rows that are contiguously in disk or memory.
Vậy buổi sau chúng ta sẽ phá vỡ quan niệm có sẵn của các bạn về hình dạng của một cơ sở dữ liệu. Cho đến giờ chúng ta đã nói về các hàng được lưu liên tiếp trên đĩa hoặc trong bộ nhớ.
We're going to flip that and talk about column stores. We actually store data as columns, not rows. That'll be next class.
Chúng ta sẽ đảo ngược điều đó và nói về column store. Chúng ta sẽ lưu dữ liệu theo cột, không phải theo hàng. Đó sẽ là buổi sau.
For project one, I'm going to quickly go over this before we jump to the speaker. So this has been posted on Piazza and the code is on GitHub.
Về dự án một, tôi sẽ điểm qua nhanh trước khi chuyển sang diễn giả. Dự án này đã được đăng trên Piazza và mã nguồn nằm trên GitHub.
You're going to build your own BufferPool manager in the BusTub system. So you're going to build a replacement policy algorithm based on ARC.
Các bạn sẽ xây dựng BufferPool manager của riêng mình trong hệ thống BusTub. Các bạn sẽ xây dựng một thuật toán chính sách thay thế dựa trên ARC.
Again, we'll have a recitation next week that goes over the algorithm in more detail, but it's pretty straightforward. Then you build a disk scheduler and then a BufferPool instance.
Một lần nữa, tuần sau sẽ có buổi thảo luận đi qua thuật toán chi tiết hơn, nhưng nó khá đơn giản. Sau đó các bạn xây dựng một disk scheduler rồi một BufferPool instance.
And that'll be due on September 29th. So the replacement policy is just the algorithm itself that actually decides what to evict when you need a page.
Hạn nộp là ngày 29 tháng 9. Chính sách thay thế chỉ là thuật toán quyết định thực sự sẽ loại bỏ trang nào khi bạn cần một trang.
You're allowed to use the built-in STL containers for the ghost lists and the most frequently used, most recently used lists.
Các bạn được phép dùng các container STL có sẵn cho các ghost list và các danh sách được dùng thường xuyên nhất, được dùng gần đây nhất.
So you don't need to build your own separate vector indexes and things like that inside your, not vector indexes, the vectors or lists inside of C++, just use the STL ones.
Vì vậy các bạn không cần tự xây dựng vectơ riêng hay chỉ mục và những thứ tương tự bên trong, không phải chỉ mục vectơ, mà là các vector hay list trong C++, cứ dùng loại của STL.
Because it's in memory, the BufferPool is in memory, we don't care if we lose the data or what's in these lists if we crash. It's okay to use the built-in data structures.
Vì nó nằm trong bộ nhớ, BufferPool nằm trong bộ nhớ, nên ta không quan tâm nếu mất dữ liệu hay nội dung các danh sách này khi hệ thống bị sập. Dùng các cấu trúc dữ liệu có sẵn là được.
For the disk scheduler, you're basically going to support asynchronous I.O. through STL or STD promise callbacks.
Với disk scheduler, về cơ bản các bạn sẽ hỗ trợ I/O bất đồng bộ thông qua các callback promise của STL hay STD.
And the basic idea is that other parts of the system are going to ask the disk scheduler, hey, I want this page.
Ý tưởng cơ bản là các phần khác của hệ thống sẽ hỏi disk scheduler rằng, này, tôi muốn trang này.
And then it's going to be, you're going to build the piece of the system that's responsible for scheduling the reads, fetching those into memory, and then handing them off to the BufferPool manager.
Và các bạn sẽ xây dựng phần của hệ thống chịu trách nhiệm lên lịch các thao tác đọc, nạp chúng vào bộ nhớ, rồi chuyển giao chúng cho BufferPool manager.
Alright.
Được rồi.
You're going to put this all together and now actually build the frame storage and the BufferPool manager and the page table that actually takes the request for the pages from other parts of the system, goes to the disk scheduler, tries to find the pages you want, brings it into memory, and if you don't have any space, it runs your ARC replacement algorithm to decide how to remove things.
Các bạn sẽ ghép tất cả lại và xây dựng phần lưu trữ frame cùng BufferPool manager và bảng trang nhận yêu cầu về các trang từ các phần khác của hệ thống, đi đến disk scheduler, cố gắng tìm các trang bạn muốn, đưa vào bộ nhớ, và nếu bạn không còn chỗ trống, nó sẽ chạy thuật toán thay thế ARC của các em để quyết định loại bỏ những gì.
Okay?
Rõ chưa?
So, super important: don't change any file other than the ones we tell you to change, because when it runs on Gradescope it wipes away whatever you give us, anything else but those files, and if you make any changes in there it won't run.
Điều này cực kỳ quan trọng: đừng thay đổi bất kỳ tệp nào ngoài những tệp chúng tôi yêu cầu, vì khi chạy trên Gradescope, hệ thống sẽ xóa sạch những gì các em nộp, mọi thứ ngoài các tệp đó, và nếu các em sửa gì trong đó thì nó sẽ không chạy.
And then the projects are all cumulative. So project one is the first start of this, but two, three, and four are based on your BufferPool implementation for this project.
Và các project đều mang tính tích lũy. Project một là bước khởi đầu, còn project hai, ba và bốn đều dựa trên phần cài đặt BufferPool của các em ở project này.
So we want to make sure that we want to test to make sure you don't screw things up, but you don't want to fall behind, because if you're trying to fix your BufferPool manager two months from now, it's going to make all the other projects a lot harder.
Vì vậy chúng tôi muốn đảm bảo rằng chúng tôi muốn kiểm tra để chắc là các em không làm hỏng mọi thứ, nhưng các em cũng không nên bị tụt lại phía sau, vì nếu hai tháng nữa các em mới phải sửa BufferPool manager, thì tất cả các project còn lại sẽ khó hơn rất nhiều.
If you have questions, please come post in Piazza or come to office hours, but we won't sit there with the GDB and tell you how to debug things.
Nếu có câu hỏi, hãy đăng lên Piazza hoặc đến giờ tiếp sinh viên, nhưng chúng tôi sẽ không ngồi cùng GDB để chỉ các em cách gỡ lỗi.
We assume you know how to do that in C++ because of project zero. Just like in project zero, do a bunch of checks to make sure that your code looks good.
Chúng tôi cho rằng các em biết cách làm việc đó bằng C++ nhờ project zero. Giống như ở project zero, hãy chạy nhiều bước kiểm tra để đảm bảo mã của các em tốt.
And then for extra credit this year we will have a leaderboard, so we have a version of BusTub that runs on Gradescope, and whoever has the fastest BufferPool implementation, actually for all the projects going forward, will have a ranked order on the leaderboard, and the top 20 gets extra credit.
Và về điểm cộng, năm nay chúng ta sẽ có một bảng xếp hạng, chúng tôi có một phiên bản BusTub chạy trên Gradescope, và ai có phần cài đặt BufferPool nhanh nhất, thực ra là cho tất cả các project sắp tới, sẽ được xếp thứ hạng trên bảng xếp hạng, và 20 người đứng đầu sẽ được điểm cộng.
And then this year we're actually going to try to get a trophy made, like the Stanley Cup, not that big, but like whoever has the highest leaderboard scores at the end of the semester, we'll put your name and year at the bottom of it, and that way over the years we can get this thing and start growing it.
Năm nay chúng tôi còn định làm một chiếc cúp, giống Stanley Cup, nhưng không to như vậy, ai có điểm cao nhất trên bảng xếp hạng vào cuối học kỳ, chúng tôi sẽ khắc tên và năm học của các em ở phía dưới, và như vậy qua các năm chúng ta sẽ có chiếc cúp này và làm nó dày thêm.
Okay? Don't plagiarize, because you'll get it messed up, and then ask questions. All right, so let me jump to the speaker. All right, this is Joseph.
Được chứ? Đừng đạo văn, vì các em sẽ làm hỏng bài, và hãy đặt câu hỏi. Được rồi, giờ tôi chuyển sang diễn giả. Đây là Joseph.
He's been at SingleStore for a while. He's going to get... You're coming next week as well, right? Right, he's awesome. He's super smart.
Anh ấy làm ở SingleStore đã lâu. Anh ấy sẽ... Tuần sau anh cũng đến nữa, đúng không? Đúng, anh ấy tuyệt lắm. Anh ấy rất thông minh.
He's going to come next week. The floor is yours, man. Go for it. All right, cool. So yeah, I'm going to tell you guys a little bit about SingleStore.
Tuần sau anh ấy sẽ đến. Xin mời anh, sân khấu là của anh. Nào. Được rồi, tuyệt. Vâng, tôi sẽ kể cho các bạn đôi chút về SingleStore.
SingleStore is kind of a unique database in the industry. I think it's probably one of the most unique databases in the industry.
SingleStore là một cơ sở dữ liệu khá độc đáo trong ngành. Tôi nghĩ có lẽ nó là một trong những cơ sở dữ liệu độc đáo nhất trong ngành.
And so let's just dive right in. This is going to be kind of a rapid-fire talk.
Vậy ta đi thẳng vào vấn đề. Đây sẽ là một bài nói khá nhanh.
So I'm going to talk a little bit about the two types of database workloads and how SingleStore presents itself as a sort of hybrid option.
Tôi sẽ nói đôi chút về hai loại tải công việc của cơ sở dữ liệu và cách SingleStore thể hiện mình như một lựa chọn lai.
And I'm going to switch gears completely and talk about modern cloud systems and the kind of benefits SingleStore gets from running in the cloud.
Sau đó tôi sẽ chuyển hẳn chủ đề sang các hệ thống đám mây hiện đại và những lợi ích SingleStore có được khi chạy trên đám mây.
So let's get started. So the two types of database workloads. So you've maybe seen this in your class so far or you will later in the semester.
Bắt đầu nhé. Hai loại tải công việc của cơ sở dữ liệu. Có thể các bạn đã thấy điều này trong lớp, hoặc sẽ thấy sau trong học kỳ.
But there's basically two broad categories of database workloads. The first is OLTP, Online Transaction Processing.
Về cơ bản có hai nhóm tải công việc lớn của cơ sở dữ liệu. Nhóm đầu là OLTP, Online Transaction Processing (xử lý giao dịch trực tuyến).
So it's characterized by a large number of transactions, super high concurrency, small reads and writes, stuff like that.
Nó được đặc trưng bởi một số lượng lớn các giao dịch, đồng thời cực cao, các thao tác đọc và ghi nhỏ, đại loại như vậy.
And so it's like, you know, any row you need to be able to fetch at any given moment. And you might need to be able to update it at any given moment.
Nghĩa là, bạn biết đấy, hàng nào bạn cũng phải truy xuất được vào bất kỳ lúc nào. Và bạn cũng có thể cần cập nhật nó vào bất kỳ lúc nào.
So everything is kind of optimized to be able to find stuff, index stuff, do transactions, change things around.
Vì vậy mọi thứ đều được tối ưu để tìm dữ liệu, lập chỉ mục, thực hiện giao dịch, thay đổi dữ liệu.
And so you typically will have very high concurrency, lots of queries that are small, hitting the database all at once, very short SLAs.
Và thường thì bạn sẽ có mức đồng thời rất cao, rất nhiều truy vấn nhỏ cùng lúc đổ vào cơ sở dữ liệu, với SLA rất ngắn.
You expect things to return in milliseconds and you really care about ACID.
Bạn mong kết quả trả về trong vài mili giây và bạn thực sự quan tâm đến ACID.
You really care about your transactions being atomic and not seeing any weird side effects of, you know, isolation and you don't want your writes to be lost.
Bạn thực sự quan tâm đến việc giao dịch có tính nguyên tử và không gặp các tác dụng phụ kỳ lạ của tính cô lập, và bạn không muốn các thao tác ghi bị mất.
So you care about these kinds of things with that kind of workload. So you can think about running applications.
Vậy nên với kiểu khối lượng công việc này, bạn quan tâm đến những điều đó. Hãy nghĩ đến các ứng dụng đang chạy.
You know, you can think about Like running literal transactions at a bank, or, you know, if I click on something on my website and it says you pay me and I'm going to send you this, you know, thing that you just bought.
Chẳng hạn các giao dịch thực sự tại một ngân hàng, hoặc khi tôi bấm vào một thứ gì đó trên website của mình và nó báo bạn trả tiền cho tôi, rồi tôi sẽ gửi cho bạn món hàng mà bạn vừa mua.
And so typically these kinds of databases will use row-oriented data structure, right? Because every row has to be findable and updatable very fast.
Và thường thì các cơ sở dữ liệu kiểu này dùng cấu trúc dữ liệu hướng hàng, đúng không? Vì mỗi hàng phải được tìm và cập nhật rất nhanh.
So they'll typically use B-trees and skip lists, which allow you to find one row very fast. And you've probably learned about that in this class.
Nên chúng thường dùng B-tree và skip list, cho phép tìm một hàng rất nhanh. Và có lẽ bạn đã học về điều đó trong lớp này.
So examples of this: Postgres is, Postgres is basically synonymous with OLTP these days. Older databases, Oracle and SQL Server, are of course there, Cockroach, Spanner.
Ví dụ cho loại này: Postgres, ngày nay Postgres gần như đồng nghĩa với OLTP. Các cơ sở dữ liệu cũ hơn như Oracle và SQL Server tất nhiên cũng có, rồi Cockroach, Spanner.
These things being the kind of modern large-scale transactional databases.
Đây là những cơ sở dữ liệu giao dịch quy mô lớn hiện đại.
The other type of database, broad category, is analytical databases, OLAP databases. So these are characterized by large bulk processing queries.
Loại cơ sở dữ liệu còn lại, hay nhóm lớn còn lại, là cơ sở dữ liệu phân tích, tức cơ sở dữ liệu OLAP. Chúng được đặc trưng bởi các truy vấn xử lý hàng loạt lớn.
And sometimes the queries will take minutes, hours, or even days to run. Maybe these days that's not considered acceptable, but these large reporting queries can take a long time.
Và đôi khi các truy vấn chạy mất hàng phút, hàng giờ, thậm chí hàng ngày. Có lẽ ngày nay điều đó bị coi là không chấp nhận được, nhưng các truy vấn báo cáo lớn này có thể chạy rất lâu.
And you will often run on huge scales of data. Terabytes or petabytes are not uncommon. So you should think large reporting queries, analytics, dashboards.
Và bạn thường chạy trên lượng dữ liệu khổng lồ. Hàng terabyte hay petabyte là chuyện không hiếm. Vậy hãy nghĩ đến các truy vấn báo cáo lớn, phân tích, bảng điều khiển.
Your loads are big bulk loads that you do periodically. You're not updating one row. And so the data structures used to build these kinds of things are very different.
Việc nạp dữ liệu là các đợt nạp hàng loạt lớn mà bạn làm định kỳ. Bạn không cập nhật từng hàng một. Vì thế các cấu trúc dữ liệu dùng để xây dựng những hệ này rất khác.
You do these column-oriented data structures. And you're going to learn about that in this class, I assume, I hope. I love column stores. I think they're so cool.
Bạn dùng các cấu trúc dữ liệu hướng cột. Và bạn sẽ được học về điều đó trong lớp này, tôi đoán vậy, tôi hy vọng thế. Tôi yêu column store. Tôi thấy chúng tuyệt lắm.
And they're one of these data structures that just makes me so happy. So it's going to be fun to learn about those.
Chúng là một trong những cấu trúc dữ liệu khiến tôi rất vui. Nên học về chúng sẽ rất thú vị.
But yeah, so they use these column-oriented data structures that are really, really good at scanning really fast, really, really fast.
Nhưng vâng, chúng dùng các cấu trúc dữ liệu hướng cột, rất, rất giỏi quét dữ liệu thật nhanh, cực kỳ nhanh.
And so examples of this kind of database are Snowflake, ClickHouse, Redshift, BigQuery, Vertica. There's different flavors within this thing, but they're all pretty much distributed column store systems.
Và các ví dụ của loại cơ sở dữ liệu này là Snowflake, ClickHouse, Redshift, BigQuery, Vertica. Trong nhóm này có nhiều biến thể khác nhau, nhưng về cơ bản tất cả đều là hệ thống column store phân tán.
And they're good at big data analytics. So the question is, why are they hard to do both?
Và chúng giỏi phân tích dữ liệu lớn. Vậy câu hỏi là: tại sao khó làm tốt cả hai?
And why are there these two different data structures and I can't just have one data structure that does both?
Và tại sao lại có hai cấu trúc dữ liệu khác nhau này, mà không thể chỉ dùng một cấu trúc dữ liệu làm được cả hai?
And so you could talk about, like, oh, row stores will cause write amplification and you're doing a bunch of random IO and so their scan speed is limited.
Bạn có thể nói rằng, ồ, row store gây ra khuếch đại ghi và bạn phải thực hiện nhiều IO ngẫu nhiên, nên tốc độ quét của chúng bị giới hạn.
And that's kind of true. But really the reason is that column stores are really, really, really fast. So when column stores do scans, they just blow through your data.
Điều đó cũng đúng phần nào. Nhưng lý do thực sự là column store cực kỳ, cực kỳ nhanh. Khi column store quét, chúng lướt qua dữ liệu của bạn rất nhanh.
And it's really impressive and it's a really cool technology. But column stores, the updates are generally not fast.
Điều đó rất ấn tượng và là một công nghệ rất tuyệt. Nhưng với column store, việc cập nhật nói chung không nhanh.
So if you want to scan huge amounts of data, you're kind of forced into this column store world and your updates will suck because of it.
Vì vậy, nếu bạn muốn quét một lượng dữ liệu khổng lồ, bạn gần như bị buộc vào thế giới column store và việc cập nhật của bạn sẽ tệ vì điều đó.
The questions of what other data structures do are almost irrelevant. The column store is just so good.
Các cấu trúc dữ liệu khác làm gì gần như không còn quan trọng. Column store đơn giản là quá tốt.
So there's a fundamental fact of the universe: no column store will ever be as fast as row store on point queries.
Có một sự thật cơ bản của vũ trụ: không column store nào có thể nhanh bằng row store trên các truy vấn điểm.
And so if you have a database, it's either a column store for analytics or a row store for transactional workloads, and typically it's not both. But that's what SingleStore is.
Vì vậy, nếu bạn có một cơ sở dữ liệu, nó hoặc là column store cho phân tích hoặc là row store cho khối lượng công việc giao dịch, và thường thì không phải cả hai. Nhưng SingleStore chính là như vậy.
It's a hybrid row store, column store thingy. So what is SingleStore? What is SingleStore as a hybrid option? Why do we exist? We're not really a hybrid option.
Nó là thứ lai giữa row store và column store. Vậy SingleStore là gì? SingleStore là gì với tư cách một lựa chọn lai? Tại sao chúng tôi tồn tại? Thực ra chúng tôi không hẳn là một lựa chọn lai.
It would not be fair to say that we're some kind of Franken thing. We're a column store with tricks, is what we are.
Nói chúng tôi là một thứ kiểu Frankenstein thì không công bằng. Chúng tôi là một column store có thêm vài mẹo.
We're a column store with a row store bolted onto it that is kind of considered the first segment of that column store. And it's used to store the hot rows.
Chúng tôi là column store được gắn thêm một row store vào, và nó được coi như đoạn đầu tiên của column store đó. Nó được dùng để lưu các hàng nóng.
And then we optimize our column stores in a way that don't negatively affect the scan performance, but make it so that they're decent.
Sau đó chúng tôi tối ưu column store theo cách không ảnh hưởng xấu đến hiệu năng quét, nhưng giúp chúng hoạt động ở mức khá.
Not as good as row store, but decent at transactional workloads.
Không bằng row store, nhưng khá tốt với khối lượng công việc giao dịch.
And the way we do that is, first of all, you change the column store encoding so that they're seekable, which by itself doesn't give you much, but you add these secondary hash indexes that tell you the offsets.
Và cách chúng tôi làm là, trước hết, bạn thay đổi cách mã hóa của column store để có thể seek, chỉ riêng điều đó thì chưa được bao nhiêu, nhưng bạn thêm các chỉ mục băm phụ cho biết các offset.
And so it's like, "Oh, I know all the offsets. I can seek in real fast."
Và như vậy là, "Ồ, tôi biết mọi offset. Tôi có thể seek rất nhanh."
And you kind of use that row store to kind of manage the locking, virtual locks for the stuff in the column store. And I don't have a ton of time.
Và bạn dùng row store đó để quản lý việc khóa, các khóa ảo cho dữ liệu trong column store. Tôi không có nhiều thời gian.
I could give an hour presentation on each of these things, but somehow it's a column store that doesn't fall over when you try to do transactional stuff.
Tôi có thể thuyết trình một tiếng về từng thứ này, nhưng bằng cách nào đó nó là một column store mà không sụp đổ khi bạn thử làm các việc giao dịch.
And that is very unique in the industry. And yeah, so the column stores are not generally good at concurrent writes, but this one is.
Và điều đó rất độc đáo trong ngành. Vâng, nhìn chung các column store không giỏi xử lý ghi đồng thời, nhưng hệ thống này thì có.
And for those things that really need transactional workloads, we do offer dedicated in-memory row store tables as well. We used to be called MemSQL.
Còn với những khối lượng công việc thực sự cần giao dịch, chúng tôi cũng cung cấp các bảng row store chuyên dụng nằm trong bộ nhớ. Trước đây chúng tôi có tên là MemSQL.
We used to be mostly focused on that in-memory row store thing. We changed our name because we're not really mostly focused on that anymore, but we do still have those.
Trước đây chúng tôi chủ yếu tập trung vào row store trong bộ nhớ đó. Chúng tôi đổi tên vì giờ không còn chủ yếu tập trung vào nó nữa, nhưng chúng tôi vẫn có các bảng đó.
What is this bias? What kind of workloads can we do that other competitors can't?
Thế thiên hướng này là gì? Chúng tôi làm được những khối lượng công việc nào mà đối thủ không làm được?
Well, analytical databases love these analytical benchmarks, TPC-H, TPC-DS, there's a ton of them.
Các cơ sở dữ liệu phân tích rất thích những benchmark phân tích, như TPC-H, TPC-DS, có rất nhiều loại.
And these analytical benchmarks, they kind of have the flavor of, they'll give you a hundred queries or whatever, and Snowflake's better on one, BigQuery is better on a different one, ClickHouse is better on another one, SingleStore is better on one.
Và các benchmark phân tích này có kiểu như là, họ đưa cho bạn khoảng một trăm truy vấn, Snowflake tốt hơn ở một truy vấn, BigQuery tốt hơn ở một truy vấn khác, ClickHouse tốt hơn ở một truy vấn khác nữa, SingleStore tốt hơn ở một truy vấn.
And it's just like, it's a bag of tricks. It depends on, does your optimizer have this thing? Does your query execution have this thing? Does your column store execution have this thing?
Nó giống như một túi mánh khóe vậy. Nó phụ thuộc vào việc trình tối ưu hóa của bạn có tính năng này không? Thực thi truy vấn của bạn có tính năng này không? Thực thi column store của bạn có tính năng này không?
And so SingleStore is competitive with the best data warehouses on these analytical benchmarks. OLTP databases do not finish these. If you're not column store, you don't stand a chance, don't even bother.
Vì vậy SingleStore cạnh tranh ngang ngửa với các kho dữ liệu tốt nhất trên những benchmark phân tích này. Các cơ sở dữ liệu OLTP không chạy xong được những benchmark này. Nếu bạn không phải column store thì không có cơ hội, đừng mất công.
So SingleStore can do these things and we're just as good as anyone else. But we can also do the transactional benchmarks.
Vậy SingleStore làm được những việc này và chúng tôi giỏi không kém ai. Nhưng chúng tôi cũng chạy được các benchmark giao dịch.
We can do TPCC and we can do other sorts of point write workloads and Snowflake just, it doesn't work. It just doesn't work.
Chúng tôi chạy được TPCC và các loại khối lượng công việc ghi điểm khác còn Snowflake thì đơn giản là không chạy được. Nó chỉ là không chạy được.
It's not about being better than anyone else. It's like, we're the only one that can actually finish all of these and that's very cool.
Vấn đề không phải là tốt hơn ai đó. Mà là chúng tôi là hệ thống duy nhất thực sự chạy xong tất cả những thứ này, và điều đó rất tuyệt.
So we're the only system that I'm aware of that can finish all three, at least the only commercially available one.
Vậy nên chúng tôi là hệ thống duy nhất mà tôi biết có thể chạy xong cả ba loại, ít nhất là hệ thống thương mại duy nhất.
I think that there's some academic ones that can do it as well and that's pretty cool.
Tôi nghĩ có một vài hệ thống học thuật cũng làm được và điều đó khá hay.
So are we a hybrid database? Maybe our marketing will tell you we're HTAP or something, but I think of us as an analytical database that doesn't fall over under high concurrency or point workloads.
Vậy chúng tôi có phải là cơ sở dữ liệu lai không? Có thể bên tiếp thị sẽ nói với bạn chúng tôi là HTAP hay gì đó, nhưng tôi coi chúng tôi là một cơ sở dữ liệu phân tích không gục ngã khi tính đồng thời cao hay với khối lượng công việc ghi điểm.
We can do a wide variety of mixed workloads like dashboards, logistics, manufacturing, streaming AI, that kind of stuff. And it's mostly analytical with enough transaction processing that other systems can't keep up.
Chúng tôi xử lý được nhiều loại khối lượng công việc hỗn hợp như bảng điều khiển, hậu cần, sản xuất, AI streaming, đại loại vậy. Phần lớn là phân tích, kèm đủ xử lý giao dịch để các hệ thống khác không theo kịp.
Cool, so I'm flying through this. I got a couple more slides that are on a completely different topic of modern cloud systems, but maybe I'm also over time already.
Tuyệt, tôi đang lướt qua khá nhanh. Tôi còn vài slide nữa về một chủ đề hoàn toàn khác, là các hệ thống đám mây hiện đại, nhưng có lẽ tôi cũng đã quá giờ rồi.
So maybe I should stop for questions and just let that be the presentation. Yes, any questions for Joe? Yes.
Nên có lẽ tôi nên dừng lại để nhận câu hỏi và coi đó là bài thuyết trình. Vâng, có câu hỏi nào cho Joe không? Mời bạn.
His question is, worse encoding means higher storage requirements? Yes.
Câu hỏi của bạn ấy là: mã hóa kém hơn thì có nghĩa là yêu cầu dung lượng lưu trữ cao hơn phải không? Đúng vậy.
The question is, he's asking about encodings. Let's hold your question for next class. His setup is basically the intro for next lecture. This is fantastic.
Câu hỏi là bạn ấy đang hỏi về các phương pháp mã hóa. Hãy để dành câu hỏi của bạn cho buổi học sau. Phần trình bày của anh ấy về cơ bản là phần mở đầu cho bài giảng sau. Thật tuyệt vời.
So a bunch of stuff may not make sense now. It'll make sense on Monday and plus he's coming to campus and we'll talk to him again about it.
Nên có nhiều thứ bây giờ có thể chưa hiểu ngay. Đến thứ Hai sẽ rõ hơn, hơn nữa anh ấy sẽ đến trường và chúng ta sẽ lại trao đổi với anh ấy về vấn đề này.
Okay. All right, guys. Let's thank Joe.
Được rồi, các bạn. Hãy cảm ơn Joe.
And like I said, DJ Cash's radio show is this Sunday at one o'clock and then see everyone at the visit day on Monday. Hit it.
Và như tôi đã nói, chương trình radio của DJ Cash sẽ phát vào Chủ nhật này lúc một giờ và sau đó hẹn gặp mọi người tại ngày tham quan vào thứ Hai. Bắt đầu nhé.
Thank you. Thank you.
Cảm ơn mọi người. Cảm ơn.
Đă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.