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ả.
So we're in class this week. I can't be on campus this week, I'm in London. And actually right now we are actually in the emergency room here in London.
Tuần này chúng ta vẫn học như bình thường. Tuần này tôi không thể có mặt ở trường, tôi đang ở London. Và thực ra ngay lúc này chúng tôi đang ở phòng cấp cứu tại London.
So fat-faced Rick did a microdose of LSD last night. Went walking around and then he got beat up by a bunch of, like, 12-year-olds. They basically beat the shit out of him.
Chuyện là anh chàng mặt béo Rick đã dùng một liều nhỏ LSD tối qua. Cậu ấy đi lang thang rồi bị một đám trẻ khoảng 12 tuổi đánh cho một trận. Về cơ bản chúng đánh cậu ấy nhừ tử.
So we had to bring him to the hospital and I'm out here in the waiting room, waiting for him to get cleaned up, stitched up. And then we can go back.
Nên chúng tôi phải đưa cậu ấy vào bệnh viện, còn tôi đang ngồi ở phòng chờ, đợi cậu ấy được làm sạch vết thương và khâu lại. Rồi chúng tôi có thể quay về.
So I figured while I'm sitting here, we have to teach about databases because that's a super important life. So let's jump into this. So last class we were talking about SQL.
Nên tôi nghĩ trong lúc ngồi đây, thì mình vẫn phải dạy về cơ sở dữ liệu, vì đó là một điều cực kỳ quan trọng trong cuộc sống. Vậy bắt đầu thôi. Buổi trước chúng ta đã nói về SQL.
And then today we're going to talk about how to actually build a system. So as a reminder, Project Zero is due this coming Sunday coming up.
Và hôm nay chúng ta sẽ nói về cách thực sự xây dựng một hệ thống. Xin nhắc lại, Project Zero hạn nộp vào Chủ nhật tuần này.
And you're required to pass that if you want to get into the class. And Homework 1 is also due this coming Sunday at the same time.
Và các bạn bắt buộc phải qua bài này nếu muốn học lớp này. Homework 1 cũng hạn nộp vào Chủ nhật tuần này, cùng thời điểm.
So now that we understand what SQL looks like at the sort of logical level, like how to define tables, how to run queries on it, and what are the properties of relational algebra and how that fits into the relational model, that's sort of the last time we'll be looking at the application level of a database for most of the semester.
Giờ chúng ta đã hiểu SQL trông như thế nào ở mức logic, như cách định nghĩa bảng, cách chạy truy vấn trên đó, các tính chất của đại số quan hệ là gì và nó khớp với mô hình quan hệ ra sao, thì đây gần như là lần cuối chúng ta xem xét tầng ứng dụng của cơ sở dữ liệu trong phần lớn thời gian còn lại của học kỳ.
Now we're going to really start talking about how to build the software to run the queries that we saw, or store the data that we want from the database.
Giờ chúng ta sẽ thực sự bắt đầu nói về cách xây dựng phần mềm để chạy các truy vấn mà chúng ta đã thấy, hoặc lưu trữ dữ liệu mà ta muốn có trong cơ sở dữ liệu.
So that's really what's going forward at this point in the semester, or how do we actually build that system. And so the outline of the course roughly looks like this.
Đó chính là nội dung từ đây trở đi trong học kỳ, tức là làm thế nào để thực sự xây dựng hệ thống đó. Đại cương của khóa học đại khái như thế này.
So we've already sort of covered what the first week of relational database looks like.
Chúng ta đã đề cập qua nội dung của tuần đầu về cơ sở dữ liệu quan hệ.
And we're now going to go sort of at a level-by-level basis, and start looking at, like, okay, here's how you build the different layers that you need to put together, and interact with them to actually build a full-fledged database system.
Và giờ chúng ta sẽ đi lần lượt từng tầng một, và bắt đầu xem xét, đây là cách xây dựng các tầng khác nhau mà bạn cần ghép lại với nhau, và tương tác với chúng để xây dựng một hệ cơ sở dữ liệu hoàn chỉnh.
And so this is sort of the rough outline of where the course is going for this semester.
Đây là đại cương sơ lược về hướng đi của khóa học trong học kỳ này.
A lot of the things we'll be getting to at the very beginning will be like how to build a single node system.
Nhiều nội dung chúng ta sẽ học ngay từ đầu là cách xây dựng một hệ thống đơn nút.
And then once we understand that, then we'll finish up and talk about how can you scale it out and run across multiple nodes.
Và khi đã hiểu điều đó, chúng ta sẽ kết thúc bằng việc nói về cách mở rộng quy mô và chạy trên nhiều nút.
And so the way to think about this is a database system is essentially a bunch of layers, where there's a well defined API that one layer exposes to the next layer, in order to provide certain guarantees or certain operations on data, or whatever the level that they're trying to interact with.
Cách nghĩ về điều này là một hệ cơ sở dữ liệu về bản chất là một loạt các tầng, trong đó mỗi tầng cung cấp cho tầng kế tiếp một API được định nghĩa rõ ràng, nhằm đảm bảo một số tính chất hoặc cung cấp một số thao tác trên dữ liệu, hay bất kỳ mức nào mà chúng muốn tương tác.
So you can think at the very bottom you have this disk manager, the thing that actually reads and writes data from disk. It's essentially a database that's just files on disk.
Ở dưới cùng, bạn có thể hình dung là disk manager, thành phần thực sự đọc và ghi dữ liệu từ đĩa. Về cơ bản, cơ sở dữ liệu chỉ là các tệp trên đĩa.
And then above that you have the buffer manager.
Và phía trên đó là buffer manager.
That's going to be responsible for bringing in pages from disk, bringing in memory, and then handing them out correctly to the other components, such as access methods, accessing data on behalf of operators, executing queries.
Nó sẽ chịu trách nhiệm đưa các trang từ đĩa vào bộ nhớ, rồi trao chúng một cách chính xác cho các thành phần khác, chẳng hạn như các access method, truy cập dữ liệu thay mặt cho các toán tử đang thực thi truy vấn.
And above that we have a query planner optimizer, to try to then take SQL queries and convert them to physical plans that we can then execute on our system.
Và phía trên nữa là bộ lập kế hoạch và tối ưu hóa truy vấn, để lấy các truy vấn SQL rồi chuyển chúng thành các kế hoạch vật lý mà sau đó chúng ta có thể thực thi trên hệ thống của mình.
So again, you just think of the database system as a bunch of layers.
Như vậy, một lần nữa, bạn cứ hình dung hệ cơ sở dữ liệu như một loạt các tầng.
And what we're going to be going through this semester is actually we're going to start at the bottom and work our way back up the stack. So the application is up here.
Và những gì chúng ta sẽ đi qua trong học kỳ này thực ra là chúng ta sẽ bắt đầu từ dưới cùng và đi ngược dần lên trên của ngăn xếp. Ứng dụng nằm ở trên này.
This is what we talked about before, like the relational database in SQL. And it interacts with the front end. That's going to be the query planning.
Đây là những gì chúng ta đã nói trước đó, như cơ sở dữ liệu quan hệ và SQL. Và nó tương tác với phần front end. Đó chính là phần lập kế hoạch truy vấn.
And then we're just going to talk about how to go up the stack now and be able to execute those queries. So today's class, we're going to actually start at the very bottom.
Và sau đó chúng ta sẽ nói về cách đi lên trên ngăn xếp và có thể thực thi các truy vấn đó. Vậy buổi học hôm nay, chúng ta sẽ bắt đầu từ tầng thấp nhất.
We're going to talk about storage. Next class, next week when I come back in town, we'll actually go back up to the buffer manager. Talk about how to bring some pages into memory.
Chúng ta sẽ nói về lưu trữ. Buổi sau, tuần tới khi tôi quay lại thành phố, chúng ta sẽ đi ngược lên buffer manager. Nói về cách đưa một số trang vào bộ nhớ.
But then we actually need to go back down and talk about different alternatives for storing things on disk. So that'll be where we're at for the next two weeks.
Nhưng sau đó chúng ta lại cần đi xuống và nói về các phương án khác nhau để lưu trữ dữ liệu trên đĩa. Đó sẽ là nội dung của hai tuần tới.
So today again, we're going to start talking about what the background is, what the database is going to see and interact with in terms of hardware.
Vậy hôm nay, một lần nữa, chúng ta sẽ bắt đầu bằng phần nền tảng, tức là hệ cơ sở dữ liệu sẽ thấy và tương tác với những gì về phần cứng.
Then we'll talk about the lowest level: actually how to store things in files, how to then divide those files into pages, and how to then divide those pages into tuples.
Sau đó chúng ta sẽ nói về tầng thấp nhất: cách lưu dữ liệu trong các tệp, cách chia các tệp đó thành các trang, và cách chia các trang đó thành các tuple.
So today's class is going to be a row-oriented, centric view, meaning we're going to organize the data in tuples and rows.
Buổi học hôm nay sẽ là góc nhìn lấy hàng làm trung tâm, nghĩa là chúng ta sẽ tổ chức dữ liệu theo tuple và hàng.
We'll see in two weeks how we actually put that on its head and actually store things in an alternative way.
Hai tuần nữa chúng ta sẽ thấy cách đảo ngược cách nhìn đó và lưu dữ liệu theo một cách khác.
So today's going to be a classical database system architecture, how the original ones were built in the 1970s.
Vì vậy hôm nay sẽ là kiến trúc hệ cơ sở dữ liệu cổ điển, cách những hệ đầu tiên được xây dựng vào thập niên 1970.
And then we'll go from there and talk about alternative methods, the more modern methods, in a few weeks, to kind of understand the basics first before we get to the other ones.
Rồi từ đó chúng ta sẽ nói về các phương pháp thay thế, các phương pháp hiện đại hơn, trong vài tuần nữa, để hiểu những điều cơ bản trước khi đến với những phương pháp kia.
So the other thing about this class that I want to bring up is that we'll be focusing on what I call a disk-based or disk-oriented system architecture.
Một điều nữa về môn học này mà tôi muốn nêu ra là chúng ta sẽ tập trung vào cái mà tôi gọi là kiến trúc hệ thống dựa trên đĩa hay hướng đĩa.
And what I mean by that is that the software system, the data system, is going to assume that the primary source location of a database will be on non-volatile disks, like an SSD, network storage.
Ý tôi là phần mềm hệ thống, tức hệ thống dữ liệu, sẽ giả định rằng nơi chứa chính của cơ sở dữ liệu nằm trên các đĩa không bay hơi, như SSD hay lưu trữ qua mạng.
It doesn't matter, but it's considered volatile. And then it's a classic Von Neumann architecture where you can't operate on anything that will exist in disk.
Không quan trọng loại nào, nhưng nó được coi là bay hơi. Và đó là kiến trúc Von Neumann cổ điển trong đó bạn không thể thao tác trực tiếp trên bất cứ thứ gì nằm trên đĩa.
Instead, you have to bring pages from disk, or the files from disk, into memory, into volatile storage, something like DRAM. And then that's where you read and write to the data that you want.
Thay vào đó, bạn phải đưa các trang, hay các tệp, từ đĩa vào bộ nhớ, vào bộ lưu trữ bay hơi, chẳng hạn như DRAM. Và đó là nơi bạn đọc và ghi dữ liệu mà bạn muốn.
And the data system is then responsible for writing up those changes to the non-volatile disk at some later point. So this is what we'll be focusing on.
Và hệ thống dữ liệu khi đó chịu trách nhiệm ghi những thay đổi đó xuống đĩa không biến động vào một thời điểm nào đó sau này. Đây là điều chúng ta sẽ tập trung vào.
And then all of the components that we're going to talk about, the algorithms that we're going to talk about, is going to be predicated on this architecture assumption.
Và tất cả các thành phần mà chúng ta sẽ nói tới, các thuật toán mà chúng ta sẽ nói tới, đều dựa trên giả định về kiến trúc này.
So the way to think about how we're going to interact with non-volatile and volatile storage, so this is a classic hierarchy like this.
Vậy cách để hình dung việc chúng ta tương tác với bộ nhớ không biến động và biến động, là một hệ phân cấp kinh điển như thế này.
You've probably seen this in other classes. This should not be anything new.
Các em có lẽ đã thấy nó ở các lớp khác. Điều này không có gì mới.
But you sort of think of the bottom layer, you have the very large but slower storage, and the very top you have the very fast and cheaper one.
Nhưng hãy hình dung tầng dưới cùng, là bộ nhớ rất lớn nhưng chậm hơn, còn trên cùng là loại rất nhanh và đắt hơn.
So the top would be things like CPU registers, because it's the smallest amount of data you can store or access on a CPU.
Vậy trên cùng là những thứ như thanh ghi CPU, vì đó là lượng dữ liệu nhỏ nhất mà bạn có thể lưu hoặc truy cập trên CPU.
And obviously it's going to be really, really fast, but it's also going to be really expensive. It's going to be very limited. Then as you go down the stack, things get bigger.
Và hiển nhiên nó sẽ cực kỳ nhanh, nhưng cũng sẽ cực kỳ đắt. Nó sẽ rất hạn chế. Rồi đi xuống các tầng dưới thì mọi thứ lớn dần.
Capacity is larger. They're going to get slower, and they're going to be actually much cheaper to store per byte or per gigabyte.
Dung lượng lớn hơn. Chúng sẽ chậm hơn, và thực tế sẽ rẻ hơn nhiều tính theo mỗi byte hay mỗi gigabyte.
So this is the sort of way we want to think about how these different storage layers are going to work with each other.
Đây là cách chúng ta muốn suy nghĩ về việc các tầng lưu trữ khác nhau này phối hợp với nhau như thế nào.
But there's also this division line that I'll draw here between DRAM and SSDs.
Nhưng cũng có một đường phân chia mà tôi sẽ vẽ ở đây giữa DRAM và SSD.
And basically say at the top you have what I call volatile storage, where, again, if you lose the power on whatever the computing device you're using to store this, everything gets blown away.
Về cơ bản, phía trên là cái tôi gọi là bộ nhớ biến động, nghĩa là, nếu mất điện trên thiết bị tính toán mà bạn dùng để lưu trữ nó, thì mọi thứ đều bị xóa sạch.
But they're going to support what I'll call random access or byte-addressable access.
Nhưng chúng hỗ trợ cái mà tôi gọi là truy cập ngẫu nhiên hay truy cập theo địa chỉ byte.
Meaning we can jump to individual byte offsets without worrying about bringing in a bunch of other data that maybe we don't actually need.
Nghĩa là ta có thể nhảy tới từng vị trí byte riêng lẻ mà không phải lo kéo vào một loạt dữ liệu khác mà có thể ta thật ra không cần.
Now, with cache lines on the CPU, that's not entirely true, but for our purposes in this semester, we can ignore that. And then below this demarcation line, we have non-volatile storage.
Với cache line trên CPU thì điều đó không hoàn toàn đúng, nhưng với mục đích của chúng ta trong học kỳ này, có thể bỏ qua. Và bên dưới đường phân chia này là bộ nhớ không biến động.
So this will be things like, again, spinning disk hard drives or SSDs, or network storage like S3 on Amazon or Google Cloud Storage and so forth.
Đó sẽ là những thứ như ổ cứng quay, hoặc SSD, hoặc lưu trữ qua mạng như S3 của Amazon hay Google Cloud Storage, v.v.
So these devices will be non-volatile, meaning we can write to them and we can send a command to say flush the data to this storage device, and then we'd be guaranteed that if the power is lost, we come back and the data will be there.
Các thiết bị này không biến động, nghĩa là ta có thể ghi vào chúng và gửi một lệnh yêu cầu flush dữ liệu xuống thiết bị lưu trữ này, và khi đó ta được đảm bảo rằng nếu mất điện, khi quay lại thì dữ liệu vẫn còn đó.
Again, if obviously the machine catches on fire and the disk melts, we can't do that, but there's ways to get around that we'll cover later in the semester.
Tất nhiên, nếu máy bốc cháy và đĩa bị chảy ra thì không được, nhưng có những cách khắc phục mà ta sẽ học sau trong học kỳ.
These devices are also going to be block-addressable, and that means that the smallest granularity in which we can access data is going to be through a block.
Các thiết bị này cũng được địa chỉ hóa theo khối, nghĩa là đơn vị nhỏ nhất mà ta có thể truy cập dữ liệu là một khối.
And typically this can be four kilobytes, sometimes larger, sometimes smaller.
Thường là bốn kilobyte, đôi khi lớn hơn, đôi khi nhỏ hơn.
We can't do the byte-addressable access that we can do in DRAM or CPU caches, meaning if we want to access a single byte, we have to bring in the whole page, the block where that byte resides, even if you don't need that other data.
Ta không thể truy cập theo từng byte như trên DRAM hay cache CPU, nghĩa là nếu muốn truy cập một byte duy nhất, chúng ta phải đưa cả trang, tức khối chứa byte đó, vào bộ nhớ, kể cả khi không cần đến phần dữ liệu còn lại.
And that's sort of the trade-off that we have to make in our system design when we actually want to start storing things on non-volatile storage.
Và đó là sự đánh đổi mà chúng ta phải chấp nhận khi thiết kế hệ thống mỗi khi muốn bắt đầu lưu trữ dữ liệu trên bộ lưu trữ không bay hơi.
So for the purposes of this semester, what we're going to say is that anything below this demarcation line here between non-volatile and volatile storage, we're just going to say that's called disk.
Vậy nên trong phạm vi học kỳ này, bất cứ thứ gì nằm dưới ranh giới này, đường phân chia giữa lưu trữ không bay hơi và bay hơi ở đây, chúng ta sẽ gọi chung là đĩa.
Well, it doesn't matter whether it's an SSD, a spinning disk hard drive, or network storage.
Dù đó là SSD hay không thì cũng không quan trọng, là ổ cứng quay hay bộ lưu trữ qua mạng cũng vậy.
Even below network storage, you can have things like tape drives, but people really only use that for archival stuff, like Amazon Glacier. So everything down below is block addressable and non-volatile.
Thậm chí dưới lưu trữ qua mạng còn có những thứ như ổ băng từ, nhưng thực tế người ta chỉ dùng chúng để lưu trữ lâu dài, như Amazon Glacier. Vậy mọi thứ ở bên dưới đều được địa chỉ hóa theo khối và không bay hơi.
We'll just call that disk. And then above that line, we're just going to call whatever's in DRAM, we're just going to call that memory.
Chúng ta sẽ gọi đó là đĩa. Còn phía trên ranh giới đó, bất cứ thứ gì nằm trong DRAM, chúng ta sẽ gọi là bộ nhớ.
And then above that will be anything that's directly on the CPU, like on the actual die or the socket itself, like CPU caches and CPU registers. We're just going to say that's CPU storage.
Và phía trên nữa là mọi thứ nằm trực tiếp trên CPU, như ngay trên die hoặc socket, chẳng hạn bộ nhớ đệm CPU và thanh ghi CPU. Chúng ta sẽ gọi đó là lưu trữ của CPU.
And so for the purposes of this semester, we're actually going to ignore CPU-related stuff.
Và trong phạm vi học kỳ này, chúng ta sẽ bỏ qua những thứ liên quan đến CPU.
We can talk a little bit about more efficient ways to store the stuff, but for our purposes here, we can just ignore all that.
Chúng ta có thể nói đôi chút về những cách hiệu quả hơn để lưu trữ dữ liệu, nhưng với mục đích của mình ở đây, ta có thể bỏ qua tất cả những điều đó.
We'll cover these things in the advanced class because that's where we really care about cache locality and other things.
Chúng ta sẽ học những phần này trong lớp nâng cao vì ở đó chúng ta thực sự quan tâm đến tính cục bộ của bộ nhớ đệm và những vấn đề khác.
But for this semester, it's really about: is it in memory or is it on disk, and then how do we move back and forth?
Còn học kỳ này, vấn đề chủ yếu là: dữ liệu nằm trong bộ nhớ hay trên đĩa, và làm sao để chuyển qua lại giữa hai nơi?
Now, the other thing we have to be mindful of too, and this is going to be where we're going to deviate from maybe traditional algorithm classes we've taken in computer science classes before, where we actually need to be aware of how long it's going to take for us to access data at these different levels.
Bây giờ, một điều nữa chúng ta cũng cần lưu ý, và đây là chỗ chúng ta có thể khác với các lớp thuật toán truyền thống mà các bạn đã học trong các lớp khoa học máy tính trước đây, đó là chúng ta thực sự cần biết mất bao lâu để truy cập dữ liệu ở các tầng khác nhau này.
And so there's this great table here that comes from this website. You see in the corner, Jeff Dean has a version of this. It actually predates him.
Có một bảng rất hay ở đây, lấy từ trang web này. Các bạn thấy ở góc, Jeff Dean có một phiên bản của bảng này. Thật ra nó có từ trước ông ấy.
It goes back to Jim Gray from the early 1990s. But basically, it's a table.
Nó bắt nguồn từ Jim Gray vào đầu những năm 1990. Nhưng về cơ bản, đây là một cái bảng.
Here's all the time it takes to access different levels of storage, from the volatile ones down to the non-volatile ones. And here I'm showing these numbers measured in nanoseconds.
Đây là toàn bộ thời gian cần để truy cập các tầng lưu trữ khác nhau, từ loại bay hơi xuống đến loại không bay hơi. Và ở đây tôi trình bày các con số này tính bằng nano giây.
So basically, it just shows if I'm going to read something from DRAM, it's going to take 100 nanoseconds.
Về cơ bản, nó cho thấy nếu tôi đọc một thứ từ DRAM, sẽ mất 100 nano giây.
But if I'm going to read from SSD, Now it's going to take me maybe 50,000 nanoseconds. So it's like two orders of magnitude slower than reading from DRAM.
Nhưng nếu tôi đọc từ SSD, thì giờ có thể mất khoảng 50.000 nano giây. Tức là chậm hơn đọc từ DRAM khoảng hai bậc độ lớn.
So you really want to be mindful of when we're going to read things from disk and try to minimize the amount of time you have to do that.
Vì vậy bạn thực sự cần lưu ý mỗi khi chúng ta đọc dữ liệu từ đĩa và cố gắng giảm tối đa số lần phải làm như vậy.
Then once you get below an SSD, that's when things just get super, super slow. So really, as humans, it's hard for us to wrap our heads around times in terms of nanoseconds.
Còn khi xuống dưới SSD thì mọi thứ trở nên cực kỳ chậm. Thực sự thì con người chúng ta rất khó hình dung các khoảng thời gian tính bằng nanosecond.
So there's a really easy trick that Jim Gray came up with, where if you just replace nanosecond with second, then you really start to see how expensive these things are going to be relative to reading data that could be in memory.
Có một mẹo rất đơn giản do Jim Gray nghĩ ra, đó là nếu bạn thay nanosecond bằng second, thì bạn sẽ bắt đầu thấy những thao tác này tốn kém đến mức nào so với việc đọc dữ liệu có thể đang nằm trong bộ nhớ.
So if you read something in L1 cache, that would take a second.
Nếu bạn đọc một thứ trong L1 cache, việc đó mất một giây.
So that's like if I want to read a book, I just go over to that chair there and read a page in the book, and it would take me a second or four seconds.
Giống như việc tôi muốn đọc một cuốn sách, tôi chỉ cần đi tới chiếc ghế kia và đọc một trang sách, và mất khoảng một đến bốn giây.
But then if I want to read something in a tape drive, it's going to take 31 years.
Nhưng nếu tôi muốn đọc thứ gì đó trong ổ băng từ, sẽ mất 31 năm.
That's the equivalent of me flying to Pluto and back to read a single page in a book. It'd be ridiculously long.
Tương đương với việc tôi bay tới Sao Diêm Vương và quay về chỉ để đọc một trang trong cuốn sách. Lâu một cách vô lý.
You want to try to avoid that, because most systems are not going to be stored in tape drives, so that's not why they worry about that level of latency.
Bạn nên cố tránh điều đó, vì hầu hết các hệ thống không lưu trữ trên ổ băng từ, nên họ không lo về mức độ độ trễ đó.
But certainly there's a lot of systems, and real systems today, that are stored in SSDs, spinning disk hard drives, and network storage has three.
Nhưng chắc chắn có rất nhiều hệ thống, các hệ thống thực tế ngày nay, lưu trữ trên SSD, ổ cứng đĩa quay, và lưu trữ qua mạng cũng vậy.
And so we've got to be mindful of when are we going to read data from disk, and try to avoid having to block the system while we're waiting for those things.
Vì vậy chúng ta phải chú ý đến lúc nào mình đọc dữ liệu từ đĩa, và cố tránh việc phải chặn hệ thống trong khi chờ những thao tác đó.
The other thing we need to be mindful of in our implementation is random access, or random I/O.
Một điều nữa cần lưu ý khi triển khai là truy cập ngẫu nhiên, hay random I/O.
So again, when you assume you're Talking about quicksort algorithms in intro classes and so forth, you just assume, again, read and write everything in memory, and the time it takes to read any object or entity takes the same amount of time.
Như vậy, khi bạn giả định, ví dụ khi nói về các thuật toán quicksort trong các lớp nhập môn chẳng hạn, bạn chỉ giả định là đọc và ghi mọi thứ trong bộ nhớ, và thời gian đọc bất kỳ đối tượng hay thực thể nào đều như nhau.
But in reality, on real hardware, the latencies between random access and sequential access can be quite significant.
Nhưng trên thực tế, với phần cứng thật, độ trễ giữa truy cập ngẫu nhiên và truy cập tuần tự có thể chênh lệch khá lớn.
So random access would be like jumping around to different locations and reading different bits as I need it, whereas sequential access would be reading a stride of data that is contiguous to each other.
Truy cập ngẫu nhiên giống như nhảy tới các vị trí khác nhau và đọc các phần khác nhau khi tôi cần, còn truy cập tuần tự là đọc một dải dữ liệu nằm liền kề nhau.
And so I can just do one lookup and get multiple bytes or kilobytes that are all close to each other.
Nhờ vậy tôi chỉ cần một lần tra cứu là lấy được nhiều byte hoặc kilobyte nằm gần nhau.
So just to give you some ballpark numbers here: random I/O would be, on a fast SSD, maybe 80 to 100 microseconds.
Để cho bạn vài con số ước chừng: random I/O sẽ mất, trên một SSD nhanh, khoảng 80 đến 100 microsecond.
So let's be on the high end, for like a consumer-grade drive, whereas sequential I/O, you can read a bunch of data in terms of 10 to 100 microseconds.
Cứ lấy mức cao, cho ổ loại phổ thông, còn sequential I/O, bạn có thể đọc một lượng lớn dữ liệu trong khoảng 10 đến 100 microsecond.
And again, it depends on how much data you're reading, how many threads you're reading.
Và một lần nữa, điều đó phụ thuộc vào lượng dữ liệu bạn đọc, số luồng bạn dùng để đọc.
This is all a bunch of complicated stuff that we're not going to cover in this class, but the main thing to be mindful of is that there is a huge difference between sequential and random I/O, especially on spinning disk hard drives.
Đây đều là những vấn đề phức tạp mà chúng ta sẽ không đề cập trong lớp này, nhưng điều chính cần lưu ý là có một sự khác biệt rất lớn giữa I/O tuần tự và I/O ngẫu nhiên, đặc biệt trên ổ cứng đĩa quay.
And we want to try to maximize the amount of sequential access we can do whenever you have to read and write.
Và chúng ta muốn tối đa hóa lượng truy cập tuần tự mà chúng ta có thể thực hiện mỗi khi phải đọc và ghi.
And that means that we'll make certain choices in our algorithms that try to reduce the number of writes to random pages, so that we store data in continuous blocks.
Điều đó có nghĩa là chúng ta sẽ đưa ra một số lựa chọn nhất định trong các thuật toán nhằm giảm số lần ghi vào các trang ngẫu nhiên, để dữ liệu được lưu trong các khối liên tục.
And that means there'll be certain systems that will do certain things that seem like crazy things to do.
Và điều đó cũng có nghĩa là sẽ có một số hệ thống làm những việc nghe có vẻ điên rồ.
But again, if you're aware that sequential access is much faster than random access, that would sort of make sense.
Nhưng một lần nữa, nếu bạn biết rằng truy cập tuần tự nhanh hơn nhiều so với truy cập ngẫu nhiên, thì điều đó sẽ có lý.
So like MySQL, for example, when they write dirty pages to disk, They'll first write it to this double write buffer, and that's a sequential write where they put all the dirty pages they want to flush out, they write those sequentially.
Ví dụ như MySQL, khi họ ghi các trang bẩn xuống đĩa, trước hết họ sẽ ghi vào double write buffer này, và đó là một lần ghi tuần tự, trong đó họ đưa tất cả các trang bẩn muốn đẩy ra ngoài và ghi chúng một cách tuần tự.
Then in the background, they'll do the random writes at a later point, but at that point, you're not waiting for that dirty page to be written because you've written that sequentially the first time.
Sau đó, ở chế độ nền, họ sẽ thực hiện các lần ghi ngẫu nhiên vào một thời điểm muộn hơn, nhưng lúc đó bạn không phải chờ trang bẩn ấy được ghi xong vì bạn đã ghi nó tuần tự ngay lần đầu.
So what we're going to try to build this semester is a system that can manage a database system that's larger than the amount of memory that's available to the system.
Vậy điều chúng ta sẽ cố gắng xây dựng trong học kỳ này là một hệ thống có thể quản lý một hệ cơ sở dữ liệu lớn hơn dung lượng bộ nhớ mà hệ thống có sẵn.
So if you only have 8 gigs of RAM, you can run a database, handle a database that's 16 kilobytes or 32 gigabytes or gigabytes or larger.
Nên nếu bạn chỉ có 8 GB RAM, bạn vẫn có thể chạy một cơ sở dữ liệu, xử lý một cơ sở dữ liệu có dung lượng 16 kilobyte hoặc 32 gigabyte hoặc lớn hơn.
So the challenge, of course, is going to be to provide this illusion. We have to move data back and forth between disk and the memory, sort of a binomial architecture.
Vì vậy, thách thức tất nhiên là tạo ra ảo giác này. Chúng ta phải di chuyển dữ liệu qua lại giữa đĩa và bộ nhớ, một kiểu kiến trúc hai tầng.
So we want to do this in a clever way and take advantage of as many optimizations as we can, where we want to avoid large stalls while we're fetching things in disk and have the system grind to a halt just because we're waiting to go fetch I/O.
Vì vậy chúng ta muốn làm điều này một cách khéo léo và tận dụng càng nhiều tối ưu hóa càng tốt, trong đó chúng ta muốn tránh những lần đình trệ lớn khi đang lấy dữ liệu từ đĩa và để hệ thống chậm đến mức dừng hẳn chỉ vì phải chờ lấy dữ liệu I/O.
So there'll be a bunch of things we'll do as we go along about allowing multiple queries to run at the same time.
Vì vậy sẽ có một loạt việc chúng ta làm trong quá trình học nhằm cho phép nhiều truy vấn chạy cùng lúc.
So we're going to have a bunch of data that we bring into memory, being clever about what we write up from memory to disk.
Chúng ta sẽ có một lượng dữ liệu được đưa vào bộ nhớ, và phải khéo léo trong việc quyết định ghi gì từ bộ nhớ xuống đĩa.
So there's a bunch of things we're going to want to do, and we'll design certain algorithms in such a way that we can reduce that burden, reduce that cost of having to read my data from disk and make it look like we have enough memory to handle everything.
Như vậy có rất nhiều việc chúng ta muốn làm, và chúng ta sẽ thiết kế một số thuật toán sao cho có thể giảm gánh nặng đó, giảm chi phí phải đọc dữ liệu từ đĩa và làm cho hệ thống trông như có đủ bộ nhớ để xử lý mọi thứ.
Because at some point, if the working set size of the data of all the queries that are running, There's no way to get around that.
Bởi vì đến một lúc nào đó, nếu kích thước working set của dữ liệu của tất cả các truy vấn đang chạy thì không có cách nào tránh được điều đó.
But for other, in the general case, we'll be okay.
Nhưng trong trường hợp thông thường khác, chúng ta sẽ ổn.
All right, so everything I've said here is kind of handy and vague.
Được rồi, mọi thứ tôi vừa nói ở đây còn khá chung chung và mơ hồ.
So let's actually go into more details and look at a high-level picture of what a disk-oriented database system is going to look like.
Vì vậy hãy đi vào chi tiết hơn và xem bức tranh tổng quan về một hệ cơ sở dữ liệu hướng đĩa sẽ trông như thế nào.
And then we'll see what we're trying to then design and build as we go along for the rest of the semester.
Và sau đó chúng ta sẽ thấy mình cần thiết kế và xây dựng gì trong suốt phần còn lại của học kỳ.
So as I said before, a disk-oriented system, it's just about files on disk.
Như tôi đã nói trước đó, một hệ hướng đĩa thực chất chỉ là các tệp trên đĩa.
Sometimes it's one file, like some systems like DuckDB and SQLite, they pride themselves on storing the entire database as a single file.
Đôi khi chỉ là một tệp, như một số hệ thống như DuckDB và SQLite, họ tự hào vì lưu toàn bộ cơ sở dữ liệu trong một tệp duy nhất.
But most systems are going to store the database across multiple files on disk.
Nhưng hầu hết các hệ thống sẽ lưu cơ sở dữ liệu trên nhiều tệp trên đĩa.
These files aren't special in terms of the operating system, meaning it's like the operating system just uses a bunch of files that it's created with, you know, fwrite or fopen.
Về phía hệ điều hành, những tệp này không có gì đặc biệt, nghĩa là hệ điều hành chỉ dùng một loạt tệp được tạo ra bằng, bạn biết đấy, fwrite hoặc fopen.
It's really the database where all the important stuff or the magic happens in the system. So we have one on our Basel disk. We have some metadata in this file.
Chính cơ sở dữ liệu mới là nơi mọi thứ quan trọng, hay phép màu, diễn ra trong hệ thống. Vậy trên đĩa của chúng ta có một tệp. Trong tệp này có một ít metadata.
And we'll break this up into a bunch of pages. These will be sort of fixed-length, size segments or divisions of the file.
Và chúng ta sẽ chia nó thành một loạt trang. Đây là các đoạn hay phần của tệp có kích thước cố định.
And at the header, or at some special location, usually it's usually the header, will be what we call a page directory.
Và ở phần đầu, hoặc ở một vị trí đặc biệt nào đó, thường là phần đầu, sẽ có thứ mà ta gọi là page directory.
And that's just a kind of internal database of keeping track of like, here's all the pages that I have on the disk.
Đó chỉ là một dạng cơ sở dữ liệu nội bộ dùng để theo dõi xem tôi có những trang nào trên đĩa.
And then now I have in memory for my data system, I have what I call a buffer pool, sometimes called the buffer cache or the memory cache or something.
Còn trong bộ nhớ của hệ quản trị dữ liệu, tôi có thứ gọi là buffer pool, đôi khi được gọi là buffer cache hay memory cache hoặc tên nào đó tương tự.
They're all different systems called different things, but it's basically the same thing.
Mỗi hệ thống gọi nó một tên khác nhau, nhưng về cơ bản đều là một thứ.
And this is going to have a bunch of frames, we'll call them, where I can store pages and I'm going to bring them to memory.
Và nó sẽ có một loạt frame, ta sẽ gọi như vậy, nơi tôi có thể lưu các trang mà tôi đưa vào bộ nhớ.
So again, the database system's job is really about managing the movement of disk pages back and forth between disk and memory in order to service whatever the queries are that I'm executing.
Như vậy, một lần nữa, công việc của hệ quản trị cơ sở dữ liệu thực chất là quản lý việc di chuyển các trang đĩa qua lại giữa đĩa và bộ nhớ để phục vụ bất kỳ truy vấn nào mà tôi đang thực thi.
So I have my execution engine. I'm not defining what this is for now. We'll just assume that it's something above the ones from the queries.
Vậy tôi có execution engine. Hiện giờ tôi chưa định nghĩa nó là gì. Ta cứ giả định nó là thứ nằm phía trên, nhận các truy vấn.
This is something, this is I want to get page number two.
Giả sử nó yêu cầu: tôi muốn lấy trang số hai.
So at the very beginning, assuming that nothing's in memory, the very first thing we need to do is to bring up the directory to memory, because the directory is going to tell us what pages we have and where to go find them.
Vậy ngay từ đầu, giả sử chưa có gì trong bộ nhớ, việc đầu tiên cần làm là đưa directory vào bộ nhớ, vì directory sẽ cho ta biết ta có những trang nào và tìm chúng ở đâu.
And again, for us right now, in this example here, we assume it's a single file, but it could be spread across multiple files and multiple directories or even across multiple machines.
Và một lần nữa, hiện giờ, trong ví dụ này, ta giả định chỉ có một tệp, nhưng nó có thể được trải trên nhiều tệp và nhiều thư mục, thậm chí trên nhiều máy.
But at this point, right, for simplicity, assume we can just compute where the offset is in this file and then it finds it for us.
Nhưng ở thời điểm này, để đơn giản, giả sử ta chỉ cần tính ra vị trí offset trong tệp này và từ đó tìm được trang.
Then we go fetch that page into memory. And then now we then hand back to the execution engine a pointer to that page in memory.
Rồi ta lấy trang đó vào bộ nhớ. Sau đó ta trả lại cho execution engine một con trỏ tới trang đó trong bộ nhớ.
And the buffer pool is going to guarantee that that pointer is not going to get replaced or swapped out with another page until the execution engine says they're done with it.
Và buffer pool sẽ đảm bảo rằng con trỏ đó sẽ không bị thay thế hay hoán đổi bằng một trang khác cho đến khi execution engine báo rằng nó đã dùng xong.
So now, also notice here that we didn't say anything about what's inside these pages.
Bây giờ, cũng lưu ý rằng ta chưa nói gì về nội dung bên trong các trang này.
We said that the only way to go up above in the system to then interpret what's in these pages is to decide what the bytes actually mean.
Ta đã nói rằng cách duy nhất để các tầng phía trên trong hệ thống diễn giải nội dung của các trang này là quyết định xem các byte thực sự có ý nghĩa gì.
But this lowest level here, we don't know, we don't actually care right now. So then the execution engine does whatever it does, interprets the page layout, and let's say that it's doing an update.
Nhưng ở tầng thấp nhất này, ta không biết, và hiện giờ cũng không thực sự quan tâm. Rồi execution engine làm những gì nó cần làm, diễn giải cách bố trí của trang, và giả sử nó đang thực hiện một thao tác cập nhật.
So it wants to update the contents of page number two.
Nó muốn cập nhật nội dung của trang số hai.
So then it writes back the change to the page, and then it can then say, In a way that's safe, so that if we crash and come back, we don't lose any of those changes that the execution engine made to that page.
Vậy là nó ghi lại thay đổi đó vào trang, rồi sau đó nó có thể nói rằng, Theo cách an toàn, để nếu hệ thống bị sập rồi khởi động lại, chúng ta không mất bất kỳ thay đổi nào mà execution engine đã thực hiện trên trang đó.
So we're not going to go into the details of all these things in this lecture.
Chúng ta sẽ không đi vào chi tiết tất cả những thứ này trong bài giảng hôm nay.
We'll discuss things in other lectures, but we'll discuss some of what these pages actually look like at the files in this lecture, and then we'll come back to this in five and six.
Chúng ta sẽ bàn về chúng trong các bài giảng khác, nhưng chúng ta sẽ bàn một phần về việc các trang này thực sự trông như thế nào trong các tệp ở bài giảng này, rồi sau đó sẽ quay lại phần này ở bài giảng năm và sáu.
And then we're going to spend, in lecture four, we're going to spend time discussing how to do this. We won't discuss everything, how to do this in a transactionally safe manner.
Và sau đó, ở bài giảng bốn, chúng ta sẽ dành thời gian thảo luận về cách làm điều này. Chúng ta sẽ không bàn hết mọi thứ, tức là cách làm điều này theo cách an toàn về mặt giao dịch.
That'll be later in the semester, at the midterm. We'll just have a general idea of how the mechanism is actually going to work. So we'll cover that next week in lecture four.
Phần đó sẽ để sau trong học kỳ, vào khoảng giữa kỳ. Chúng ta chỉ cần có ý tưởng chung về cơ chế này thực sự sẽ hoạt động ra sao. Vì vậy chúng ta sẽ học phần đó vào tuần sau, ở bài giảng bốn.
It's also, too, what you'll need in the first project. And then for what the execution engine is going to look like, we'll cover that in lectures 13 and 14 in a few weeks.
Đó cũng là thứ các bạn sẽ cần cho dự án đầu tiên. Còn về việc execution engine sẽ trông như thế nào, chúng ta sẽ học ở các bài giảng 13 và 14 trong vài tuần nữa.
We'll cover the databases, which are files on disk.
Chúng ta sẽ bàn về các cơ sở dữ liệu, vốn là các tệp trên đĩa.
And then the second question we have to deal with is how we're going to move those pages back and forth from disk into memory and then hand them off to other parts of the system in order to interpret their bytes.
Và câu hỏi thứ hai chúng ta phải giải quyết là làm thế nào để chuyển các trang đó qua lại giữa đĩa và bộ nhớ, rồi giao chúng cho các thành phần khác của hệ thống để diễn giải các byte của chúng.
So for today's class, we're going to focus on this. And as I said, next class we'll then come back to problem number two and understand what the buffer pool manager is all about.
Vì vậy, trong buổi học hôm nay, chúng ta sẽ tập trung vào phần này. Và như tôi đã nói, buổi sau chúng ta sẽ quay lại vấn đề số hai và tìm hiểu buffer pool manager là gì.
Files on disk. And there's nothing special about them in terms, again, what the operating system sees.
Các tệp trên đĩa. Và chúng không có gì đặc biệt xét về những gì hệ điều hành nhìn thấy.
It's just as if I create a bunch of files in any application and then the database system is up to interpret what's in them.
Nó giống như khi tôi tạo một loạt tệp trong bất kỳ ứng dụng nào và hệ quản trị cơ sở dữ liệu phải tự diễn giải nội dung bên trong.
Now, historically, these file formats, what's in the files has always been proprietary, meaning they are specific to whatever the database system is up to.
Về mặt lịch sử, các định dạng tệp này, tức là nội dung trong các tệp, luôn là độc quyền, nghĩa là chúng đặc thù cho từng hệ quản trị cơ sở dữ liệu.
You can't take a Postgres file, its file format, and then open it up in MySQL or Oracle.
Bạn không thể lấy một tệp Postgres, với định dạng tệp của nó, rồi mở trong MySQL hay Oracle.
It's not going to know how to interpret these bytes because it doesn't mean anything to the other system.
Nó sẽ không biết cách diễn giải các byte này vì chúng không có ý nghĩa gì với hệ thống kia.
There's a newer trend in building what are called portable file formats, things like Parquet, where it's a file format that is open, with an open spec, and the system can read and write to them.
Có một xu hướng mới hơn là xây dựng cái gọi là các định dạng tệp di động, như Parquet, là một định dạng tệp mở, có đặc tả mở, và hệ thống có thể đọc và ghi vào chúng.
But we're not going to discuss that in this class.
Nhưng chúng ta sẽ không bàn về điều đó trong lớp này.
The other thing I'll also point out, too, is that the database system is typically going to be run on off-the-shelf file systems, like ext4, WinFS, whatever the operating system installs, and that's going to be typically good enough for what we need.
Một điều nữa tôi cũng muốn chỉ ra là hệ quản trị cơ sở dữ liệu thường sẽ chạy trên các hệ thống tệp có sẵn, như ext4, WinFS, bất kể hệ điều hành cài đặt loại nào. và thường thì như vậy là đủ tốt cho những gì chúng ta cần.
There was some systems in the 1980s that would actually build custom file systems on top of raw block storage.
Có một số hệ thống vào những năm 1980 thực sự xây dựng hệ thống tệp tùy chỉnh trên nền lưu trữ khối thô.
So you'd buy a storage device and the database system would install its own custom file system inside of that. You typically don't see that, especially in non-open-source systems.
Tức là bạn mua một thiết bị lưu trữ và hệ quản trị cơ sở dữ liệu sẽ cài hệ thống tệp tùy chỉnh của riêng nó vào bên trong đó. Bạn thường không thấy điều này, đặc biệt là ở các hệ thống không phải mã nguồn mở.
And you only really see this in really high-end enterprise systems, like Oracle and Teradata. Most people aren't going to do this.
Và bạn chỉ thực sự thấy nó ở các hệ thống doanh nghiệp cao cấp, như Oracle và Teradata. Hầu hết mọi người sẽ không làm như vậy.
If you look at Oracle's documentation, you could have this thing called the Oracle ASM.
Nếu bạn xem tài liệu của Oracle, bạn có thể có thứ gọi là Oracle ASM.
It basically says instead of having the operating system manage the file system for you to manage or whatever, instead the database system is going to do that for you.
Về cơ bản nó nói rằng thay vì để hệ điều hành quản lý hệ thống tệp cho bạn, hay bạn tự quản lý gì đó, thì hệ quản trị cơ sở dữ liệu sẽ làm việc đó thay bạn.
It's basically injecting a custom file system to the operating system.
Về cơ bản là chèn một hệ thống tệp tùy chỉnh vào hệ điều hành.
That still exposes the standard POSIX API that the operating system expects, but it lays out data in such a way that it's very specific to what the database system wants.
Nó vẫn cung cấp API POSIX chuẩn mà hệ điều hành mong đợi, nhưng nó sắp xếp dữ liệu theo cách rất riêng cho những gì hệ quản trị cơ sở dữ liệu muốn.
There hasn't been a study on this for a while, but you get roughly about a 15 improvement in performance for this.
Đã lâu rồi không có nghiên cứu nào về điều này, nhưng bạn được cải thiện hiệu năng khoảng 15 nhờ cách này.
All right, so then the database system at the lowest level is going to have this thing called the Storage Manager. Again, sometimes it's called the Disk Manager, but it's usually the same thing.
Được rồi, vậy hệ quản trị cơ sở dữ liệu ở tầng thấp nhất sẽ có thành phần gọi là Storage Manager. Một lần nữa, đôi khi nó được gọi là Disk Manager, nhưng thường là một thứ.
It's the component of the system that's responsible for reading data out the disk. Again, you could rely on the OS to do some things, but you don't have to do everything.
Đó là thành phần của hệ thống chịu trách nhiệm đọc dữ liệu từ đĩa. Một lần nữa, bạn có thể dựa vào hệ điều hành cho một số việc, nhưng bạn không phải làm mọi thứ như vậy.
Most of the higher-end systems, like if you do, their own scheduling for reads and writes and figure out where they're actually going to put data on their own.
Hầu hết các hệ thống cao cấp hơn, nếu làm vậy, sẽ tự lập lịch cho việc đọc và ghi và tự quyết định sẽ đặt dữ liệu ở đâu.
Don't let the OS just figure crap out for you, because it's always going to do a bad job.
Đừng để hệ điều hành tự xử lý mớ đó cho bạn, vì nó luôn làm rất tệ.
All right, and then those files that we're storing, as I said, they're cut up into pages, usually fixed length, within the file.
Được rồi, và những tệp mà chúng ta lưu trữ, như tôi đã nói, được chia thành các trang, thường có độ dài cố định, bên trong tệp.
Some systems will allow you to define a different page size per table. IBM DB2 can do this, but the collection of files for a table, they'll be all the same size.
Một số hệ thống cho phép bạn định nghĩa kích thước trang khác nhau cho mỗi bảng. IBM DB2 có thể làm điều này, nhưng tập hợp các tệp của một bảng thì sẽ có cùng kích thước.
And then the Storage Manager is going to be responsible for keeping track of these pages, reading and writing to them, and it keeps track of available space.
Và Storage Manager sẽ chịu trách nhiệm theo dõi các trang này, đọc và ghi chúng, và theo dõi không gian còn trống.
And then when there's a request from above that says, hey, I need to store somebody's bytes, you can then figure out where's the free space to actually store this.
Và khi có yêu cầu từ tầng trên nói rằng, này, tôi cần lưu các byte của ai đó, thì nó có thể tìm ra chỗ trống nào để lưu thực sự.
Now, the other thing to be mindful of is that within a single file on disk, where it's like a single instance running on the box by itself, we're not going to maintain multiple copies of a single page on disk at a physical level.
Bây giờ, một điều khác cần lưu ý là bên trong một tệp đơn trên đĩa, tức là chỉ có một thực thể chạy riêng trên máy, chúng ta sẽ không duy trì nhiều bản sao của một trang trên đĩa ở mức vật lý.
At a logical level, we may have multiple copies of data within a tuple, because we might store them in heap files, talk about in a second, and then store it again in the log file.
Ở mức logic, chúng ta có thể có nhiều bản sao dữ liệu trong một tuple, vì chúng ta có thể lưu chúng trong các heap file, lát nữa sẽ nói, rồi lưu nó lần nữa trong file log.
But it's not the Storage Manager's responsibility to, like, oh, I've got to write this page out, I'm going to make multiple copies of it.
Nhưng không phải trách nhiệm của Storage Manager là kiểu như ồ, mình phải ghi page này ra, vậy mình sẽ tạo nhiều bản sao của nó.
It's either going to happen at the level below it, like in the file system, Like with something like RAID or like a storage appliance that can make multiple copies or have replicas like an S3, or it's going to happen above the Storage Manager and I've got to write the data across multiple nodes.
Việc đó hoặc sẽ diễn ra ở tầng bên dưới nó, như trong hệ thống file, chẳng hạn với RAID, hoặc một thiết bị lưu trữ (storage appliance) có thể tạo nhiều bản sao, hoặc có các bản sao dự phòng (replica) như S3, hoặc nó sẽ diễn ra ở tầng phía trên Storage Manager, khi mình phải ghi dữ liệu trên nhiều node.
At the level of the Storage Manager, it's not going to do that. It's really about, I've got to write the data to a single instance, a single location for a single page.
Ở tầng của Storage Manager thì nó sẽ không làm việc đó. Vấn đề thực sự là mình phải ghi dữ liệu vào một instance duy nhất, một vị trí duy nhất cho một page.
Then, as I said, the page is going to be a fixed-size block of data, and that's going to basically contain everything that's in our database system.
Tiếp theo, như tôi đã nói, page là một khối dữ liệu có kích thước cố định, và về cơ bản nó sẽ chứa mọi thứ có trong hệ quản trị cơ sở dữ liệu của chúng ta.
It's going to contain the tuples that are in the data, the information I have, the page directories, basically stored as pages as well, indexes, log records.
Nó sẽ chứa các tuple của dữ liệu, những thông tin mà mình có, các page directory, về cơ bản cũng được lưu dưới dạng page, rồi index, các bản ghi log.
All this is going to be stored and broken up internally as pages.
Tất cả những thứ này đều được lưu và chia nhỏ bên trong thành các page.
Now, most systems are not going to mix the page types, meaning you're not going to have within a single file pages for table X and table Y or index X and table together.
Giờ, hầu hết các hệ thống sẽ không trộn lẫn các loại page, nghĩa là trong một file sẽ không có lẫn các page của bảng X và bảng Y, hay index X và bảng cùng nhau.
It's typically going to be like, here's one file, this table has data just for this one page.
Thông thường sẽ là kiểu: đây là một file, bảng này chỉ có dữ liệu cho đúng page này.
Some systems are also going to require the pages to be self-contained, meaning everything you need to know about what's inside the page has to be stored in the page itself.
Một số hệ thống cũng yêu cầu các page phải tự chứa đầy đủ (self-contained), nghĩa là mọi thứ bạn cần biết về nội dung bên trong page đều phải được lưu ngay trong chính page đó.
You can imagine things like if it's a data page for a table, you would say, here's all the metadata I need to have to know that this page is for this table.
Bạn có thể hình dung, ví dụ nếu đó là một data page của một bảng, bạn sẽ nói: đây là toàn bộ metadata mình cần có để biết rằng page này thuộc về bảng này.
You would do that for crash recovery, but you only see that if you're not losing people's data, and rightfully so.
Bạn làm vậy để phục hồi sau sự cố, nhưng bạn chỉ thấy điều đó khi không làm mất dữ liệu của người dùng, và điều đó là hoàn toàn đúng.
The other important thing to know is also that each page is given a unique identifier called the page ID.
Một điều quan trọng khác cần biết là mỗi page được gán một định danh duy nhất gọi là page ID.
A page ID is going to be this unique number that the database system is going to maintain to keep track of, here's how to address and find this particular page I'm looking for.
Page ID là một con số duy nhất mà hệ quản trị cơ sở dữ liệu duy trì để theo dõi, kiểu như: đây là cách định vị và tìm page cụ thể mà mình đang cần.
It can be unique to a single page.
Nó có thể là duy nhất cho một page.
It could be an offset in the file as well, but it could also be a logical location that would then use the page record to find out where that thing is actually being located.
Nó cũng có thể là một offset trong file, nhưng cũng có thể là một vị trí logic mà sau đó dùng bản ghi của page để tìm ra thực tế nó nằm ở đâu.
The important thing to understand is there are three notions of pages in a system. At the lowest level, you have what's called a Harvard page. This is typically four kilobytes.
Điều quan trọng cần hiểu là trong một hệ thống có ba khái niệm về page. Ở mức thấp nhất, có cái gọi là Harvard page. Thường là bốn kilobyte.
It's the smallest atomic unit of data that the hardware can guarantee that it can write out to the storage device, the actual physical medium of the storage, that's done atomically.
Đó là đơn vị dữ liệu nguyên tử nhỏ nhất mà phần cứng có thể đảm bảo ghi ra thiết bị lưu trữ, tức là môi trường vật lý thực sự của việc lưu trữ, được thực hiện một cách nguyên tử.
If I have to write out, say, two four kilobyte pages or eight kilobytes, the hardware can only guarantee that it can write one four kilobyte atomically.
Nếu tôi phải ghi ra, giả sử, hai page bốn kilobyte tức tám kilobyte, thì phần cứng chỉ đảm bảo được rằng nó ghi nguyên tử một khối bốn kilobyte.
None of them has the guarantee that it can write one of them.
Không thiết bị nào đảm bảo được việc ghi trọn vẹn cả hai.
Then now, above that, you have the OS page. By default in Linux, this is four kilobytes.
Rồi bây giờ, phía trên đó, bạn có trang của hệ điều hành. Mặc định trong Linux, kích thước này là bốn kilobyte.
In new versions of Linux, you get what are called huge pages and then you get two megabytes and one gigabyte.
Trong các phiên bản Linux mới, bạn có cái gọi là huge page và khi đó kích thước là hai megabyte và một gigabyte.
This is basically the mapping of a Harvard page to a logical page that the OS is going to keep track of in its own internal page directory.
Về cơ bản đây là việc ánh xạ một trang phần cứng sang một trang logic mà hệ điều hành sẽ theo dõi trong page directory nội bộ của nó.
Then now, above that, we have the database page and this is going to be what the database is going to organize, its own pages.
Rồi bây giờ, phía trên nữa, chúng ta có trang cơ sở dữ liệu và đây sẽ là thứ mà cơ sở dữ liệu dùng để tổ chức các trang của chính nó.
Again, the Harvard page is always going to be four kilobytes and that's the largest block that we can guarantee that it can write atomically, but then the OS can have its own page sizes and the database can have its own page sizes as well, and we just have to be mindful how we're going to do this mapping from a database page to a Harvard page and be aware of that if we have to write more data
Một lần nữa, trang phần cứng luôn là bốn kilobyte và đó là khối lớn nhất mà ta có thể đảm bảo ghi một cách nguyên tử, nhưng hệ điều hành có thể có kích thước trang riêng và cơ sở dữ liệu cũng có thể có kích thước trang riêng, và ta chỉ cần lưu ý cách ta thực hiện việc ánh xạ từ trang cơ sở dữ liệu sang trang phần cứng và biết rằng nếu ta phải ghi nhiều dữ liệu hơn
that we can do atomically in a four kilobyte page, we have to do a bunch of extra steps to make sure that things are written safely before we tell the outside world That this is going to vary per system.
mức có thể ghi nguyên tử trong một trang bốn kilobyte, thì ta phải làm thêm một loạt bước để đảm bảo dữ liệu được ghi an toàn trước khi ta báo cho thế giới bên ngoài. Điều này sẽ khác nhau tùy từng hệ thống.
On the smallest, something like SQLite, I know for its own embedded devices, it can go down to 512 bytes. By default, it's four kilobytes.
Nhỏ nhất là những hệ như SQLite, tôi biết với các thiết bị nhúng của nó, kích thước có thể xuống tới 512 byte. Mặc định là bốn kilobyte.
Oracle, by default, is four kilobytes. The DBT is four kilobytes. RocksDB, which is an embedded storage engine that's used in a lot of systems, that's four kilobytes.
Oracle mặc định là bốn kilobyte. DB2 là bốn kilobyte. RocksDB, một storage engine nhúng được dùng trong rất nhiều hệ thống, là bốn kilobyte.
WiredTiger is the storage engine for MongoDB, that's four kilobytes.
WiredTiger là storage engine của MongoDB, là bốn kilobyte.
And Postgres, they're eight kilobytes. And then MySQL famously can go up to 16 kilobytes.
Còn Postgres thì là tám kilobyte. Và MySQL nổi tiếng là có thể lên tới 16 kilobyte.
So the size of a database page, what you actually want to use in your system, depends on many different factors, like the environment, the hardware environment that the system is running in, what the data it is you're actually storing.
Vì vậy kích thước của một trang cơ sở dữ liệu, tức là cái bạn thực sự muốn dùng trong hệ thống, phụ thuộc vào nhiều yếu tố khác nhau, như môi trường, môi trường phần cứng mà hệ thống đang chạy, và dữ liệu mà bạn thực sự lưu trữ là gì.
Are they really wide tables that have a lot of columns or a small number of columns? Are they big blobs of data or are they just small integers?
Đó là những bảng rất rộng với nhiều cột hay chỉ có ít cột? Đó là những blob dữ liệu lớn hay chỉ là những số nguyên nhỏ?
And it actually depends on the workload you expect to run in your database system.
Và nó còn phụ thuộc vào khối lượng công việc bạn dự kiến chạy trên hệ quản trị cơ sở dữ liệu.
So in general, for databases that are doing read-heavy workloads, and we'll see more about this in a week or two, with these ones, you actually want to store things as larger page sizes, because you know you can do a lot of sequential scans, and I'm storing in tuples that I know I'm going to want, that I need for my queries.
Nên nhìn chung, với các cơ sở dữ liệu có khối lượng công việc nặng về đọc, và chúng ta sẽ thấy rõ hơn về điều này sau một hai tuần nữa, với loại này, bạn thực sự muốn lưu dữ liệu với kích thước trang lớn hơn, vì bạn biết mình có thể quét tuần tự rất nhiều, và tôi lưu các tuple mà tôi biết mình sẽ cần cho các truy vấn.
So every fetch for a page, in a database page, brings in useful data for me. We'll see how we handle that when we switch from a row store to a column store.
Nên mỗi lần lấy một trang, trong một trang cơ sở dữ liệu, đều đem về dữ liệu hữu ích cho tôi. Chúng ta sẽ xem cách xử lý điều đó khi chuyển từ row store sang column store.
That's one of the big things they're going to do.
Đó là một trong những điều lớn mà họ sẽ làm.
And then for systems that are more write-heavy, meaning I'm doing a lot of updates to tuples, I don't want 16 kilobytes because, again, the non-volatile storage is block-addressable.
Còn với các hệ thống nặng về ghi hơn, nghĩa là tôi cập nhật tuple rất nhiều, thì tôi không muốn 16 kilobyte vì, một lần nữa, bộ lưu trữ không bay hơi được đánh địa chỉ theo khối.
So that means I only have to write, if I'm only updating a single byte within a page, I have to write that whole page out.
Nghĩa là tôi chỉ phải ghi, nếu tôi chỉ cập nhật một byte duy nhất trong một trang, thì tôi vẫn phải ghi toàn bộ trang đó ra.
So if it's a 4 kilobyte page and I don't update a single byte, I still have to write 4 kilobytes out the disk.
Nên nếu là trang 4 kilobyte và tôi chỉ cập nhật một byte, tôi vẫn phải ghi 4 kilobyte ra đĩa.
So I don't want really massively large database pages because I would have to write 416 kilobytes pages.
Vì vậy tôi không muốn các trang cơ sở dữ liệu quá lớn, vì tôi sẽ phải ghi các trang 416 kilobyte.
We'll talk about that in Lecture 6. We'll see then how high-logged a page is going to be when we do read-heavy reports.
Chúng ta sẽ nói về điều đó ở Bài giảng 6. Khi đó chúng ta sẽ thấy một trang bị khóa nặng đến mức nào khi chạy các báo cáo thiên về đọc.
So now, there's a bunch of different ways we can manage these pages that are on disk. And again, they're all going to have different trade-offs on how to do certain things.
Còn bây giờ, có nhiều cách khác nhau để quản lý các trang nằm trên đĩa. Và một lần nữa, mỗi cách đều có những đánh đổi khác nhau cho từng việc.
So assume we're doing that for this lecture or next lecture. You just assume you have a bunch of pages and address them and bring them in and they're not ordered anyway.
Vậy hãy giả định như thế cho bài giảng này hoặc bài giảng sau. Cứ giả sử bạn có một loạt trang, đánh địa chỉ cho chúng và nạp vào, và chúng dù sao cũng không có thứ tự.
Another approach would be a tree-file organization where we're actually storing the pages in a tree data structure. And as I traverse the tree, I'm bringing in pages as I would need them.
Một cách khác là tổ chức tệp dạng cây trong đó chúng ta lưu các trang trong một cấu trúc dữ liệu cây. Và khi duyệt cây, tôi nạp các trang vào khi cần.
We'll talk a little bit about that later on. Again, for this class, we don't need this.
Chúng ta sẽ nói đôi chút về nó sau. Một lần nữa, với môn này, chúng ta không cần đến nó.
This is an older architecture from the 1970s that people really don't do anymore. But it's sort of similar to the tree one. We don't have to worry about this.
Đây là kiến trúc cũ từ thập niên 1970 mà người ta thực sự không còn dùng nữa. Nhưng nó hơi giống kiểu cây. Chúng ta không cần bận tâm.
And then hashing is another variation similar to a heap file where things aren't ordered and you can jump around them. So for this lecture, we're going to assume we're doing heap files.
Và băm là một biến thể khác tương tự heap file trong đó các thứ không có thứ tự và bạn có thể nhảy tới lui giữa chúng. Vì vậy trong bài giảng này, chúng ta sẽ giả định dùng heap file.
And then for the most part, right now for the next few more slides, we don't have to care about what's inside the pages.
Và phần lớn, ngay bây giờ, trong vài slide tiếp theo, chúng ta không cần quan tâm bên trong các trang có gì.
And then we'll go into more detail about what they look like. But as soon as we understand what the page structure looks like, it doesn't matter what's inside them.
Sau đó chúng ta sẽ đi vào chi tiết hơn về hình dạng của chúng. Nhưng một khi đã hiểu cấu trúc trang trông như thế nào, thì bên trong chúng có gì không quan trọng.
So a heap file is going to be an unordered collection of pages. Because SQL is unordered, we can store tuples anywhere we want in random order. It's wherever we have free space.
Vậy heap file là một tập hợp các trang không có thứ tự. Vì SQL không có thứ tự, chúng ta có thể lưu các tuple ở bất cứ đâu theo thứ tự ngẫu nhiên. Chỗ nào còn trống thì lưu ở đó.
And then it exposes a basic API to create that right into the pages, because that's the basic operations of a storage manager.
Và nó cung cấp một API cơ bản để tạo và ghi trực tiếp vào các trang, vì đó là các thao tác cơ bản của một trình quản lý lưu trữ.
We also need this to be able to iterate over all the pages, meaning give me the page IDs for all the pages in a given table or given index.
Chúng ta cũng cần có khả năng lặp qua tất cả các trang, nghĩa là cho tôi các page ID của mọi trang trong một bảng hoặc một chỉ mục nào đó.
Because we'll need that to be able to do a sequential scan.
Vì chúng ta cần điều đó để thực hiện quét tuần tự.
But when we do looking up things in indexes, we'll see how we get the page ID from an index lookup and then we'll get that single page.
Nhưng khi tra cứu trong các chỉ mục, chúng ta sẽ thấy cách lấy page ID từ một lần tra cứu chỉ mục rồi lấy đúng trang đơn lẻ đó.
We'll also need to be able to scan across all the pages as well.
Chúng ta cũng cần có khả năng quét qua tất cả các trang.
So for this, this means that essentially what we had in the page directory to keep track of the location of these files and also keep track of where we have free space.
Vì vậy, điều này về cơ bản có nghĩa là những gì chúng ta có trong page directory để theo dõi vị trí của các tệp này và cũng theo dõi chỗ nào còn trống.
Because any time we need to store something, we've got to say, where can we put it?
Vì bất cứ khi nào cần lưu thứ gì, ta phải xác định: ta có thể đặt nó ở đâu?
And since we're going to assume that we're storing things like 8 kilobyte pages, most tuples aren't 8 kilobytes, so we need to make sure that we can fill in free space that we have.
Và vì ta sẽ giả định rằng mình lưu trữ các trang có kích thước 8 kilobyte, mà hầu hết các tuple không có kích thước 8 kilobyte, nên ta cần đảm bảo có thể lấp đầy phần dung lượng trống mà mình có.
And we want to do this as a single file. So assume something says, hey, I want to do page number 2. I'm not defining how I'm doing that just yet.
Và ta muốn làm điều này trên một tệp duy nhất. Giả sử có thành phần nào đó yêu cầu: này, tôi muốn lấy trang số 2. Tôi chưa định nghĩa cách thực hiện việc đó.
There's some part of the system that says give me page 2.
Có một phần nào đó của hệ thống nói: hãy đưa tôi trang 2.
I can just do simple arithmetic to say, I know the starting location of my file, I know my page number, I know my page size because I'm assuming all the page sizes are the same on disk.
Tôi chỉ cần làm một phép tính số học đơn giản, vì tôi biết vị trí bắt đầu của tệp, tôi biết số trang, và tôi biết kích thước trang vì tôi giả định mọi trang trên đĩa có cùng kích thước.
So this is broken up across multiple files on disk. Now we want to get something like page number 23.
Còn ở đây thì dữ liệu được chia ra nhiều tệp trên đĩa. Giờ ta muốn lấy một trang như trang số 23.
Again, there's this page directory thing we haven't really defined that's going to have the metadata we need to go find the file that contains the page.
Một lần nữa, có cái gọi là page directory mà ta chưa thực sự định nghĩa, nó sẽ chứa siêu dữ liệu mà ta cần để tìm tệp chứa trang đó.
And then once we get in there, we can then do simple math to say, for a given page number and a given page size, what's the offset I should jump to to find the bytes that I need.
Và khi đã vào được bên trong, ta có thể làm phép toán đơn giản: với một số trang cho trước và một kích thước trang cho trước, thì độ lệch cần nhảy tới là bao nhiêu để tìm các byte mình cần.
So this is a different thing, how they implement the page directory. But at a high level, all these systems basically work this way.
Cách các hệ thống triển khai page directory thì mỗi nơi một khác. Nhưng ở mức tổng quát, tất cả các hệ thống này về cơ bản đều hoạt động như vậy.
So a common architecture is to use what's called a page directory, as I started to talk about before.
Một kiến trúc phổ biến là dùng cái gọi là page directory, như tôi đã bắt đầu nói ở trên.
And this is just like a database within the database that keeps track of, here's all my pages that I have for logical database objects. You could break it up across different ways.
Nó giống như một cơ sở dữ liệu nằm trong cơ sở dữ liệu, dùng để theo dõi: đây là tất cả các trang tôi có cho các đối tượng cơ sở dữ liệu logic. Bạn có thể chia nhỏ theo nhiều cách khác nhau.
You could have a database system with a table or index or whatever. Different systems will do different things.
Bạn có thể có một hệ cơ sở dữ liệu với bảng, chỉ mục hay bất cứ thứ gì. Mỗi hệ thống sẽ làm khác nhau.
But the basic idea is that I have a way to say, I want to get data from table X or table Y. Here's the file. Here's the directory.
Nhưng ý tưởng cơ bản là tôi có cách để nói: tôi muốn lấy dữ liệu từ bảng X hoặc bảng Y. Đây là tệp. Đây là thư mục.
Here's the location on the network that has this data.
Đây là vị trí trên mạng chứa dữ liệu này.
And then within that, I can then jump to the offset that I need based on the page directory information about where to find the pages that I'm looking for.
Rồi bên trong đó, tôi có thể nhảy tới độ lệch cần thiết dựa trên thông tin của page directory về nơi tìm các trang mà tôi cần.
Now the tricky thing is going to be making sure that this page directory is synchronized on disk with the data pages.
Điều khó là phải đảm bảo page directory này được đồng bộ trên đĩa với các trang dữ liệu.
Because if we crash and lose this thing, we're kind of screwed, because now we don't know where to find anything else.
Vì nếu hệ thống sập và mất nó thì coi như ta gặp rắc rối, bởi lúc đó ta không biết tìm bất cứ thứ gì khác ở đâu nữa.
And then if we start allocating new pages for our files, we want our page directory to sort of reflect that.
Và nếu ta bắt đầu cấp phát các trang mới cho các tệp, ta muốn page directory phản ánh điều đó.
Now the truth is it doesn't actually have to be 100% always synchronized, because if you crash and come back and this thing gets trashed, if you have enough metadata in your files, you could actually recreate this.
Thực ra nó không nhất thiết lúc nào cũng phải được đồng bộ 100%, vì nếu hệ thống sập rồi khởi động lại và nó bị hỏng, nếu các tệp có đủ siêu dữ liệu thì bạn thực sự có thể tái tạo lại nó.
It just makes recovery a lot slower. And a bunch of systems are going to have different ways to do this more efficiently.
Chỉ là việc khôi phục sẽ chậm hơn nhiều. Và nhiều hệ thống sẽ có những cách khác nhau để làm việc này hiệu quả hơn.
But in general, This is something you want to keep synchronized if you can, at least in memory, certainly in memory.
Nhưng nói chung, đây là thứ bạn nên giữ đồng bộ nếu có thể, ít nhất là trong bộ nhớ, chắc chắn là trong bộ nhớ.
But on disk we can kind of be like, it's a trade-off between how fast you want to run at runtime versus how long it takes to recover if there's a crash.
Nhưng trên đĩa thì chúng ta có thể nói đây là một sự đánh đổi, giữa việc bạn muốn hệ thống chạy nhanh đến mức nào lúc runtime với việc mất bao lâu để khôi phục nếu xảy ra sự cố.
So this, we can keep track of additional metadata about, for every file, how much free space we have on a page or a file, what are pages that we have that are completely empty that we can jump to them really quickly.
Vì vậy, chúng ta có thể theo dõi thêm siêu dữ liệu về mỗi tệp: còn bao nhiêu dung lượng trống trong một page hay một tệp, những page nào hoàn toàn trống để ta có thể nhảy đến chúng thật nhanh.
And then keep track of, are these pages keeping track of metadata, or are they keeping track of what's inside the page?
Rồi theo dõi xem các page này là đang lưu siêu dữ liệu, hay là đang lưu nội dung bên trong page?
So a directory can maintain all this information for us. All right. So that's what things look like on disk.
Vậy một directory có thể duy trì toàn bộ thông tin này cho chúng ta. Được rồi. Đó là hình dạng của mọi thứ trên đĩa.
You can assume that a DBMS is a bunch of files and a bunch of pages. So now let's talk about what the pages actually look like on the inside.
Bạn có thể coi một DBMS là một tập hợp các tệp và các page. Bây giờ hãy nói về bên trong các page thực sự trông như thế nào.
So in general, at a high level, every page is going to have what we'll call the header, where we keep track of metadata about what's inside the page.
Nhìn chung, ở mức tổng quát, mỗi page sẽ có cái mà ta gọi là header, nơi ta lưu siêu dữ liệu về những gì có bên trong page.
So obviously you keep track of things like the page size, a checksum about the contents of the page, the version of the software that wrote that information.
Hiển nhiên là bạn lưu những thứ như kích thước page, một checksum của nội dung page, phiên bản phần mềm đã ghi thông tin đó.
So that way if you upgrade the version and change the layout of pages, you know whether this page reflects that new layout or not.
Nhờ vậy nếu bạn nâng cấp phiên bản và thay đổi bố cục của các page, bạn biết được page này có theo bố cục mới hay không.
There's much information we can maintain about transaction visibility, like what data should be visible or not visible. For that one, we don't have to worry about this class.
Còn nhiều thông tin khác ta có thể lưu về khả năng hiển thị của giao dịch, chẳng hạn dữ liệu nào nên hiển thị hoặc không hiển thị. Phần đó thì chúng ta không cần lo trong lớp này.
We'll cover that again after the midterm. It could have additional information about how the data is actually being compressed, what coding they're using to store things.
Chúng ta sẽ học lại sau kỳ thi giữa kỳ. Nó cũng có thể chứa thêm thông tin về dữ liệu thực sự được nén như thế nào, họ dùng phương pháp mã hóa nào để lưu dữ liệu.
In some cases, like in Oracle, we had said they had to be self-contained. We're actually maintaining the table schema in the header of the page as well.
Trong một số trường hợp, như ở Oracle, ta đã nói rằng các page phải tự chứa đầy đủ. Họ còn lưu cả lược đồ của bảng ngay trong header của page.
So if there's a crash, you can come back and actually just look at the page and say, Here's the values that I have in my page.
Nên nếu có sự cố, bạn có thể quay lại và chỉ cần nhìn vào page rồi nói: đây là các giá trị tôi có trong page của mình.
I don't need to scan the entire page and look for certain pieces of data. I'm looking for all records that have the name Andy in it.
Tôi không cần quét toàn bộ page để tìm một số mảnh dữ liệu nhất định. Tôi đang tìm tất cả các bản ghi có tên Andy.
If I have a summary in my page that keeps track of the number of Andy tuples inside of it, I can just read that and it's zero.
Nếu trong page có một bản tóm tắt theo dõi số tuple Andy bên trong nó, tôi chỉ cần đọc nó và thấy là không.
I know I don't have to read the rest of the tuples. It's a high-level idea of how this summary stuff works. You only see that in the read-heavy stuff we'll cover later.
Tôi biết mình không phải đọc phần còn lại của các tuple. Đó là ý tưởng ở mức cao về cách phần tóm tắt này hoạt động. Bạn chỉ thấy điều đó ở các hệ thống thiên về đọc mà ta sẽ học sau.
The checksum is so important because if you crash, you come back and read the page back in. Actually, not even crash. You just go read a page in.
Checksum rất quan trọng vì nếu bạn gặp sự cố, rồi quay lại và đọc page vào. Thực ra không cần đến sự cố. Chỉ cần bạn đọc một page vào.
You want to know whether I got corrupted on disk and you can trust the bytes you're reading. The checksum will tell you that. Different systems will do different things.
Bạn muốn biết nó có bị hỏng trên đĩa hay không và liệu bạn có thể tin các byte mình đang đọc. Checksum sẽ cho bạn biết điều đó. Mỗi hệ thống làm một kiểu khác nhau.
It's the enterprise ones that will have the more safety controls in place to make sure that you're not losing data or corrupting data.
Các hệ thống doanh nghiệp là những hệ thống có nhiều cơ chế an toàn hơn để đảm bảo bạn không mất hay làm hỏng dữ liệu.
Within the page, we want to figure out what's going to be a header. Now we want to talk about how we put tuples inside the page, or put data inside the pages.
Bên trong trang, ta cần xác định phần header sẽ như thế nào. Bây giờ ta sẽ nói về cách đặt các tuple vào trong trang, hay đặt dữ liệu vào trong các trang.
Assume we're doing tuples. We won't worry about indexes for now. That'll come later.
Giả sử ta đang làm việc với các tuple. Tạm thời ta chưa bàn đến index. Phần đó sẽ đến sau.
We're also going to assume that we're doing what's called a row-oriented storage model, meaning we're going to organize each record or each tuple as a row where all the data is being stored continuously inside the page.
Ta cũng sẽ giả định rằng ta đang dùng cái gọi là mô hình lưu trữ hướng hàng (row-oriented), nghĩa là ta sẽ tổ chức mỗi bản ghi hay mỗi tuple thành một hàng trong đó toàn bộ dữ liệu được lưu liên tục bên trong trang.
We're also going to assume that every tuple is stored inside a single page. We'll see how we handle larger values in a second.
Ta cũng giả định rằng mỗi tuple được lưu trọn trong một trang duy nhất. Lát nữa ta sẽ xem cách xử lý các giá trị lớn hơn.
For that purpose, we're going to assume that every tuple is continuously stored within a single page.
Vì mục đích đó, ta sẽ giả định rằng mỗi tuple được lưu liên tục trong một trang duy nhất.
There's actually three ways to do this, to organize data into pages. For this class here today, we're going to assume we're doing tuple-oriented storage.
Thực ra có ba cách để làm việc này, tức là tổ chức dữ liệu vào các trang. Trong buổi học hôm nay, ta sẽ giả định rằng ta dùng lưu trữ hướng tuple (tuple-oriented).
The entire tuple is stored Inside a single page.
Toàn bộ tuple được lưu bên trong một trang duy nhất.
There's actually two of the methods we'll cover next week, next Wednesday, called log-structured storage, where we're actually going to store not the tuple, but we're actually going to store basically the delta of a tuple when things get changed.
Có hai phương pháp khác mà ta sẽ học vào tuần sau, thứ Tư tới, gọi là lưu trữ có cấu trúc log (log-structured), trong đó ta sẽ không lưu tuple, mà thực ra ta sẽ lưu về cơ bản là phần delta của tuple mỗi khi có thay đổi.
We'll end up having multiple copies of a tuple if it gets updated multiple times. That'll make more sense when we talk about it later on.
Ta sẽ có nhiều bản sao của một tuple nếu nó được cập nhật nhiều lần. Điều này sẽ dễ hiểu hơn khi ta nói về nó sau.
The data is a tree structure. We'll come to that later.
Dữ liệu có cấu trúc cây. Ta sẽ quay lại phần đó sau.
For our purposes here, we're assuming there's only one copy of a single tuple and it's going to be stored in the page in its entirety continuously.
Ở đây, ta giả định chỉ có một bản sao của mỗi tuple và nó sẽ được lưu liên tục, trọn vẹn trong trang.
If you wanted to start doing this, how should we keep track of the tuples in a page? We could just do something really simple. I'm assuming that the tuples are all the same length.
Nếu bạn muốn bắt đầu làm việc này, ta nên theo dõi các tuple trong một trang bằng cách nào? Ta có thể làm một cách thật đơn giản. Giả sử các tuple đều có cùng độ dài.
The first allocation that I have is the page. I just have my header and keep track of the number of tuples that I have.
Thứ đầu tiên tôi cấp phát là trang. Tôi chỉ có header và theo dõi số lượng tuple đang có.
I can do simple math to say at what offset do I jump to in the page to find the data that I want.
Tôi có thể tính toán đơn giản để biết cần nhảy tới offset nào trong trang để tìm dữ liệu mình muốn.
Every time I start a new tuple, it's depending on one after another in the page like this. If I delete a tuple, that becomes more tricky.
Mỗi lần tôi bắt đầu một tuple mới, nó được xếp nối tiếp nhau trong trang như thế này. Nếu xóa một tuple thì mọi việc phức tạp hơn.
If I delete tuple 2, now I have the number of tuples for tuple 3.
Nếu tôi xóa tuple 2, thì giờ tôi có số thứ tự tuple cho tuple 3.
Maybe I can just do a quick scan and try to find the first free slot and then put my tuple that way.
Có lẽ tôi có thể quét nhanh để tìm slot trống đầu tiên rồi đặt tuple của mình vào đó.
This starts to get expensive if I have to scan every single time.
Cách này bắt đầu tốn kém nếu lần nào tôi cũng phải quét.
Furthermore, I can't do any compaction now because if I move tuple 3 back to where tuple 2's slot was or location was in the page, then I have to update a bunch of other metadata or index data structures so that the number of tuple 3 would have changed in my page.
Hơn nữa, giờ tôi không thể nén lại (compaction), vì nếu tôi dời tuple 3 về chỗ slot hay vị trí của tuple 2 trong trang, thì tôi phải cập nhật hàng loạt metadata hay cấu trúc dữ liệu index khác vì số thứ tự của tuple 3 trong trang của tôi đã thay đổi.
But then, also, this doesn't work either if I have variable length data, because now I may have a free space that I can't actually use to insert the new tuple that I need, or I'd have to start moving things around and again pay that penalty of updating indexes or updating other parts of the data system.
Nhưng cách này cũng không hiệu quả nếu dữ liệu có độ dài thay đổi, vì lúc này có thể tôi có một vùng trống mà thực tế không dùng được để chèn tuple mới cần thiết, hoặc tôi phải bắt đầu di chuyển các thứ và lại phải trả cái giá của việc cập nhật index hay các phần khác của hệ thống dữ liệu.
To overcome this problem, I'm going to use a technique called slotted pages.
Để khắc phục vấn đề này, tôi sẽ dùng một kỹ thuật gọi là slotted pages.
What I'm describing here is basically, at a high level, how any row-oriented or row storage or tuple-oriented system is going to do this.
Những gì tôi đang mô tả ở đây về cơ bản, ở mức tổng quát, là cách mà bất kỳ hệ thống lưu trữ theo hàng hay theo tuple nào cũng sẽ làm.
The exact details of what the metadata is storing, or whether the slot is in the beginning or the end, it varies per system. But at a high level, this is basically how they work.
Các chi tiết cụ thể về việc metadata lưu những gì, hay slot nằm ở đầu hay ở cuối, thì tùy từng hệ thống. Nhưng ở mức tổng quát, về cơ bản chúng hoạt động như thế này.
What's going to happen is that we're going to have, at the beginning of the page, a fixed length array. Then I'm going to have this slot array.
Điều sẽ xảy ra là ở đầu trang, chúng ta sẽ có một mảng có độ dài cố định. Tức là tôi sẽ có slot array này.
It's going to be a fixed length array that keeps track of an offset within the page for a tuple at a given slot.
Nó là một mảng có độ dài cố định, theo dõi một offset bên trong trang cho một tuple ở một slot nhất định.
At the bottom of the page, that's where I'm going to actually store all my data. This is going to be any fixed length or variable length data of the tuple or my tuples.
Ở cuối trang, đó là nơi tôi thực sự lưu toàn bộ dữ liệu. Đó sẽ là bất kỳ dữ liệu có độ dài cố định hoặc độ dài thay đổi nào của tuple hay các tuple của tôi.
They're going to be at the bottom. The slot array basically tells me which locations are offsets within the page. If it's 4 kilobyte pages, the offsets aren't going to be that big.
Chúng sẽ nằm ở phía dưới. Về cơ bản, slot array cho tôi biết các vị trí là những offset bên trong trang. Nếu trang có kích thước 4 kilobyte thì các offset sẽ không lớn lắm.
It can tell me, for a given tuple defined by a slot, here's the offset within that page to go find it.
Với một tuple được xác định bởi một slot, nó có thể cho tôi biết offset trong trang đó để đi tìm tuple này.
As I want to add more tuples, the slot array is going to grow this way, and then the tuple data is going to grow the other way.
Khi tôi muốn thêm nhiều tuple hơn, slot array sẽ phát triển theo hướng này, còn dữ liệu tuple sẽ phát triển theo hướng ngược lại.
At some point, you reach in the middle where there's no more free space, and then the page is considered full.
Đến một lúc nào đó, hai phía gặp nhau ở giữa và không còn chỗ trống nữa, và khi đó trang được coi là đầy.
Do I have full occupancy of data? No, because the variable-length data down below might not fit exactly, align exactly within the page and use all the data. In general, this works good enough.
Liệu dữ liệu có lấp đầy hoàn toàn không? Không, vì dữ liệu có độ dài thay đổi ở phía dưới có thể không vừa khít, không khớp chính xác trong trang để dùng hết toàn bộ không gian. Nói chung, cách này đủ tốt.
The advantage of this approach is that now if I delete a tuple, like say tuple 3 here, I can either leave tuple 4 where it is by itself, and then hopefully another tuple that comes along gets inserted to fill in that space, or actually I can then move tuple 4 to be the end of this page,
Ưu điểm của cách tiếp cận này là bây giờ nếu tôi xóa một tuple, chẳng hạn tuple 3 ở đây, tôi có thể để nguyên tuple 4 tại chỗ, và hy vọng một tuple khác được chèn vào sau đó sẽ lấp đầy khoảng trống ấy, hoặc tôi cũng có thể dời tuple 4 xuống cuối trang này,
or the end where tuple 2 ends, and then all I need to do is update the slot array to say the location of tuple 4 within the slot array is now at this offset.
hay đến chỗ tuple 2 kết thúc, rồi tất cả những gì cần làm là cập nhật slot array để cho biết vị trí của tuple 4 trong slot array bây giờ là ở offset này.
What I get is indirection that allows me to change the location of a tuple within the page without having to go update other parts of the system. I don't have to update indexes.
Cái tôi có được là một tầng gián tiếp (indirection) cho phép tôi thay đổi vị trí của một tuple trong trang mà không phải cập nhật các phần khác của hệ thống. Tôi không phải cập nhật các chỉ mục.
I don't have to tell them, here's the location of tuple 4, it's changed. The blast radius of the modification I do from this compaction is just limited to this single page.
Tôi không phải báo cho chúng rằng đây là vị trí của tuple 4, nó đã thay đổi. Phạm vi ảnh hưởng của thay đổi mà tôi thực hiện khi nén dữ liệu này chỉ giới hạn trong đúng một trang này.
As I said before, the cost of bringing things into disk is very expensive versus the cost of moving things and bringing the page into memory.
Như tôi đã nói trước đó, chi phí đưa dữ liệu từ đĩa lên là rất đắt so với chi phí di chuyển dữ liệu và đưa trang vào bộ nhớ.
I can change around the contents of this page, doing the compaction or not doing the compaction, and that's cheap relative to having to read my data from disk all over again.
Tôi có thể thay đổi nội dung của trang này, dù có nén hay không nén, và điều đó rẻ so với việc phải đọc lại dữ liệu từ đĩa một lần nữa.
Once it's in memory, I'm pretty much free to do whatever I want to reorganize this page. Some systems like Postgres won't do it.
Một khi nó đã nằm trong bộ nhớ, Tôi gần như được tự do làm bất cứ điều gì mình muốn để sắp xếp lại trang này. Một số hệ thống như Postgres sẽ không làm vậy.
Some systems like SQL Server will do it every time you update a tuple.
Một số hệ thống như SQL Server sẽ làm điều đó mỗi lần bạn cập nhật một tuple.
Having this indirection layer means we can change the location of tuples in the page and not worry about updating indexes and other things.
Có lớp gián tiếp này nghĩa là chúng ta có thể thay đổi vị trí của các tuple trong trang mà không phải lo cập nhật các chỉ mục và những thứ khác.
The other cool thing is that It's all cool, it's databases.
Điều thú vị khác là... Ổn cả thôi, đây là cơ sở dữ liệu mà.
Another thing we want to talk about is how we're going to identify each logical tuple with a physical location. For this, we're going to use what we call record IDs.
Một việc khác chúng ta muốn bàn là cách chúng ta xác định từng tuple logic với một vị trí vật lý. Với việc này, chúng ta sẽ dùng thứ gọi là record ID.
Some systems will call them tuple IDs or page IDs. Sorry, not page IDs. Tuple IDs, record IDs, or row IDs.
Một số hệ thống gọi chúng là tuple ID hoặc page ID. Xin lỗi, không phải page ID. Tuple ID, record ID hoặc row ID.
Essentially, the ID is all the same thing, but it's a unique identifier for a logical tuple that stores its physical location, or represents its physical location, within the database.
Về cơ bản, các ID này đều là một thứ, đó là một định danh duy nhất cho một tuple logic lưu vị trí vật lý của nó, hoặc biểu diễn vị trí vật lý của nó, trong cơ sở dữ liệu.
An example would be: a record ID could say, here's the file ID and the page ID and then the slot number within that page.
Ví dụ, một record ID có thể cho biết: đây là file ID, page ID, rồi đến số slot trong trang đó.
In other parts of the system, if I want to be unique, I want to be able to say what's the index pointing to, what's the record ID or the address I'm pointing to, you would represent that through this record ID.
Ở những phần khác của hệ thống, nếu tôi muốn xác định duy nhất, muốn nói chỉ mục đang trỏ tới đâu, record ID nào hay địa chỉ nào mà tôi đang trỏ tới, thì bạn sẽ biểu diễn điều đó bằng record ID này.
Most systems don't store this.
Hầu hết các hệ thống không lưu nó.
Instead, it's derived at runtime based on, as you read the data. Looking at a bunch of different implementations, Ingres has a tuple ID that's four bytes.
Thay vào đó, nó được suy ra lúc chạy, khi bạn đọc dữ liệu. Xem qua một loạt cách triển khai khác nhau, Ingres có tuple ID dài bốn byte.
Postgres has a CTID that's six bytes. That's going to be page ID and slot number. For these systems, they don't actually store this, but you can uniquely address tuples based on it.
Postgres có CTID dài sáu byte. Đó sẽ là page ID và số slot. Với các hệ thống này, chúng thực ra không lưu nó, nhưng bạn có thể định địa chỉ duy nhất cho các tuple dựa vào nó.
SQLite is an interesting one for its row ID because it does actually store it for you.
SQLite là một trường hợp thú vị với row ID vì nó thực sự lưu giá trị này cho bạn.
No matter what you declare as the primary key within the table, it's going to use the row ID as the primary key to give a monotonically increasing value.
Dù bạn khai báo khóa chính là gì trong bảng, nó vẫn dùng row ID làm khóa chính để cho một giá trị tăng đơn điệu.
It uses that because that guarantees that you can uniquely identify any given record, even if you don't provide a primary key when you create the table.
Nó dùng như vậy vì điều đó đảm bảo bạn có thể xác định duy nhất bất kỳ bản ghi nào, ngay cả khi bạn không cung cấp khóa chính lúc tạo bảng.
It's important to understand that this is something that will be exposed to you through a database interface. Hopefully, maybe I can do a demo.
Điều quan trọng là hiểu rằng đây là thứ sẽ được phơi bày cho bạn qua giao diện của cơ sở dữ liệu. Hy vọng là tôi có thể làm một demo.
I want to go back and come back to this and cut some of the video here.
Tôi muốn quay lại phần này sau và cắt bớt một số đoạn video ở đây.
You'll be able to see this through SQL and sometimes you can address the records through this, but it's not actually something you'd want to rely on in the application because these IDs can change for a logical tuple based on how the database starts moving data around.
Bạn sẽ thấy được nó qua SQL và đôi khi bạn có thể truy cập các bản ghi qua nó, nhưng thực ra bạn không nên dựa vào nó trong ứng dụng vì các ID này có thể thay đổi đối với một tuple logic tùy theo cách cơ sở dữ liệu bắt đầu di chuyển dữ liệu.
You could do compaction based on the data.
Bạn có thể thực hiện compaction dựa trên dữ liệu.
It's still correct because at a logical level, since SQL and the relational model is unordered, I can change the ordering of tuples and everything is still correct.
Điều đó vẫn đúng vì ở mức logic, do SQL và mô hình quan hệ là không có thứ tự, Tôi có thể thay đổi thứ tự của các tuple mà mọi thứ vẫn đúng.
The record ID may change, but again, I shouldn't have relied on that in my application code.
Record ID có thể thay đổi, nhưng một lần nữa, lẽ ra tôi không nên dựa vào điều đó trong mã ứng dụng của mình.
We know what files look like. We know what pages look like. Let's go deeper inside the pages and talk about what the tuples actually look like.
Chúng ta biết các file trông như thế nào. Chúng ta biết các page trông như thế nào. Hãy đi sâu hơn vào bên trong các page và nói về việc các tuple thực sự trông như thế nào.
Tuples have a header in front of them, just like a page has a header. Tuples are going to have a header too that contains metadata about what's in the tuple itself.
Tuple có một header ở phía trước, giống như page có header. Tuple cũng sẽ có một header chứa metadata về những gì có trong chính tuple đó.
It typically doesn't contain metadata about what the schema is because that's done at the page level.
Nó thường không chứa metadata về schema, vì việc đó được thực hiện ở cấp độ page.
This is why you don't mix page types or mix data within a page, because you don't want to redundantly store the same schema information over and over again for every single tuple in the page.
Đây là lý do bạn không trộn lẫn các loại page hay trộn dữ liệu trong một page, vì bạn không muốn lưu thông tin schema giống nhau một cách dư thừa lặp đi lặp lại cho từng tuple trong page.
It's like a bitmap of what columns are null, information about what transactions can see the data or whether they can see that tuple or not.
Nó giống như một bitmap cho biết những cột nào là null, thông tin về những transaction nào có thể thấy dữ liệu hoặc có thể thấy tuple đó hay không.
For that purpose, we don't need to worry about it.
Với mục đích hiện tại, chúng ta không cần bận tâm về điều đó.
But then the DBMS is going to maintain a catalog to keep track of the schema for every single tuple or table, so that when you go read a page for a given table, you know how to then interpret the bytes within these byte arrays for a tuple to say what the data actually contains.
Nhưng khi đó DBMS sẽ duy trì một catalog để theo dõi schema của từng tuple hay từng bảng, để khi bạn đọc một page của một bảng nào đó, bạn biết cách diễn giải các byte bên trong những mảng byte này của một tuple để biết dữ liệu thực sự chứa gì.
So as I said, the header is going to contain basic information like visibility, what transactions created it and at what time, this data and so forth, a bitmap for null values.
Như tôi đã nói, header sẽ chứa các thông tin cơ bản như khả năng hiển thị (visibility), transaction nào tạo ra nó và vào thời điểm nào, dữ liệu này, v.v., một bitmap cho các giá trị null.
Then everything else after that is just the attribute data.
Sau đó mọi thứ còn lại chỉ là dữ liệu của các thuộc tính.
So typically, the attributes for a tuple are in ways you could reorganize them to ensure things are aligned correctly.
Thông thường, các thuộc tính của một tuple về mặt nào đó bạn có thể sắp xếp lại chúng để đảm bảo mọi thứ được căn chỉnh đúng.
But most systems don't do that. Instead, they're going to rely on padding to make sure things that are correctly aligned across, typically, 64-bit values. So let's say we have a simple example here.
Nhưng hầu hết các hệ thống không làm vậy. Thay vào đó, chúng dựa vào padding để đảm bảo mọi thứ được căn chỉnh đúng, thông thường là theo các giá trị 64 bit. Giả sử chúng ta có một ví dụ đơn giản ở đây.
We have a table foo and it has five columns, three integers followed by a double prior float.
Chúng ta có một bảng foo với năm cột, ba số nguyên theo sau là một double hoặc float.
Again, the byte array for a tuple will just be stored in the order in which it's defined by the CREATE TABLE statement.
Một lần nữa, mảng byte của một tuple sẽ được lưu theo đúng thứ tự được định nghĩa trong câu lệnh CREATE TABLE.
So now the challenge is going to be when you have things that span these boundaries, and you need to be clever in how you're going to handle it.
Vậy thách thức sẽ xuất hiện khi bạn có những thứ vắt qua các ranh giới này, và bạn cần khéo léo trong cách xử lý chúng.
So for this example here, it's pretty simple. I have an ID of 32 bits. I have a value of 64 bits.
Với ví dụ này thì khá đơn giản. Tôi có một ID 32 bit. Tôi có một giá trị 64 bit.
Assuming the header is 32 bits, this will fit nicely in the number of bytes. So again, if I want to jump now to get this attribute, I just look at the...
Giả sử header là 32 bit, thì nó sẽ vừa khít trong số byte đó. Vậy nếu bây giờ tôi muốn nhảy tới để lấy thuộc tính này, tôi chỉ cần nhìn vào...
I get my offset to the tuple by looking at the slot array in the page, and then I just do some arithmetic to jump over the header and then jump to this location to find the attribute that I want.
Tôi lấy offset tới tuple bằng cách nhìn vào slot array trong page, rồi chỉ cần làm vài phép tính số học để nhảy qua header và sau đó nhảy tới vị trí này để tìm thuộc tính tôi muốn.
And then I basically do the equivalent of the interpret cast in C++ to then convert the address that I'm looking at to the value of 64 bits.
Và sau đó về cơ bản tôi làm tương đương với interpret cast trong C++ để rồi chuyển địa chỉ mà tôi đang nhìn thành giá trị 64 bit.
And this is something that's done at runtime. This is actually a compiler directive. There's no computation done here.
Và việc này được thực hiện lúc chạy. Thực ra đây là một chỉ thị của trình biên dịch. Ở đây không có phép tính nào được thực hiện cả.
It's just ensuring that any code that comes after this interpretation of this casting here is going to operate on a 32-bit signed integer.
Nó chỉ đảm bảo rằng bất kỳ đoạn mã nào nằm sau phép diễn giải, tức phép ép kiểu này, sẽ thao tác trên một số nguyên 32 bit có dấu.
So now the tricky thing is going to be when you have data that doesn't fit nicely into these word boundaries. For simplicity, we'll assume it's 64-bit words.
Vậy điều khó là khi bạn có dữ liệu không vừa khít với các ranh giới từ này. Để đơn giản, ta sẽ giả sử đó là các từ 64 bit.
So the challenge is going to be the table might have smaller types or larger types that might go across these boundaries, and we have problems.
Thách thức là bảng có thể có các kiểu nhỏ hơn hoặc lớn hơn, vắt qua các ranh giới này, và ta gặp vấn đề.
So this 32-bit integer here fits nicely in the first half of the 64-bit word, but now I have a 64-bit date or timestamp here, and that's going to span two words.
Số nguyên 32 bit này nằm vừa khít ở nửa đầu của từ 64 bit, nhưng giờ tôi có một ngày hoặc timestamp 64 bit ở đây, và nó sẽ trải dài qua hai từ.
Likewise, I have now a two-byte character.
Tương tự, giờ tôi có một ký tự hai byte.
So if things are not nicely, exactly aligned, I'm going to have this problem where now I try to go access something like the date here, the timestamp.
Nếu các thứ không được căn chỉnh đúng khít, tôi sẽ gặp vấn đề khi cố truy cập một thứ như ngày ở đây, tức là timestamp.
I've got to go fetch two 64-bit words to go read that in, and a compiler might complain, a CPU might freak out, depending on what architecture I'm running on, and this becomes problematic.
Tôi phải lấy hai từ 64 bit để đọc nó, và trình biên dịch có thể báo lỗi, CPU có thể hoạt động bất thường, tùy vào kiến trúc tôi đang chạy, và điều này trở nên rắc rối.
So an easy way to get around this is just to pad and make sure that everything is always byte-aligned.
Vậy một cách dễ để tránh là chèn thêm phần đệm và đảm bảo mọi thứ luôn được căn chỉnh theo byte.
So it's wasting space, but it does ensure that I don't have these problems that I talked about before.
Cách này lãng phí dung lượng, nhưng nó đảm bảo tôi không gặp những vấn đề đã nói ở trên.
So the first case, the integer for the ID, is 32 bits, so I just put another 32 bits of zeros that come after it.
Ở trường hợp đầu, số nguyên cho ID dài 32 bit, nên tôi chỉ thêm 32 bit số không nữa ngay sau nó.
The date simply knows that anytime it tries to access the data, I only need the first 32 bits, and it just ignores what comes after that, but this ensures now that everything is byte-aligned.
Ngày thì chỉ biết rằng mỗi khi truy cập dữ liệu, tôi chỉ cần 32 bit đầu, và nó bỏ qua phần phía sau, nhưng như vậy là đảm bảo mọi thứ đều được căn chỉnh theo byte.
Another approach, you could do this, I've only seen this in the research literature, I don't think any system actually does this, is just to reorder things so that they're nicely packed in.
Một cách khác, bạn có thể làm vậy, tôi chỉ thấy nó trong các tài liệu nghiên cứu, tôi không nghĩ hệ thống nào thực sự làm thế, là sắp xếp lại thứ tự để chúng được đóng gói gọn gàng.
So if I just move the columns around like this, or the entries around like this, then I land with a nice alignment that I would want.
Nếu tôi di chuyển các cột, hay các mục, như thế này, thì tôi sẽ có được sự căn chỉnh đẹp như mong muốn.
Now, logically, it's still defined in the order when they call CREATE TABLE, but physically the bits have to be at the right location to get the data that I would need.
Về mặt logic, nó vẫn được định nghĩa theo thứ tự lúc gọi CREATE TABLE, nhưng về mặt vật lý thì các bit phải nằm đúng vị trí để lấy được dữ liệu tôi cần.
Like I said, you could do this, I don't know if any system actually does it, At least I haven't come across any that do this.
Như tôi đã nói, bạn có thể làm vậy, tôi không biết hệ thống nào thực sự làm, ít nhất tôi chưa gặp hệ thống nào làm thế.
And then you make sure that the next tuple comes afterwards, it's nicely aligned, we just put padding after the last one.
Và rồi bạn đảm bảo tuple tiếp theo đứng sau đó, được căn chỉnh gọn gàng, ta chỉ thêm phần đệm sau tuple cuối.
So again, we still have to make some space, but it's why most systems don't actually do this. So now, what do the actual attributes look like?
Vậy ta vẫn phải tốn một ít dung lượng, nhưng đó là lý do hầu hết hệ thống không làm thế. Vậy bây giờ, các thuộc tính thực tế trông như thế nào?
So for the basic data types, like ints, floats, strings, and timestamps, this is roughly how the system has actually implemented it.
Với các kiểu dữ liệu cơ bản, như int, float, chuỗi, và timestamp, đại khái đây là cách hệ thống thực sự triển khai chúng.
There could be some variation based on the hardware which you're actually running on, but in general this is what you would do.
Có thể có chút khác biệt tùy theo phần cứng mà bạn đang chạy, nhưng nói chung thì bạn sẽ làm như thế này.
So for a 32-bit integer or a 64-bit integer, the same way you would represent things in C++ or C, this is what you would get in your system.
Với số nguyên 32 bit hoặc 64 bit, giống như cách bạn biểu diễn trong C++ hoặc C, thì đây là thứ bạn sẽ có trong hệ thống của mình.
In general, it'll be the same across hardware. You do have to worry about endians, but for our purposes, we'll assume it's x86, we're not going to worry about that problem.
Nói chung, nó sẽ giống nhau trên mọi phần cứng. Bạn có phải lo về endian, nhưng với mục đích của chúng ta, ta sẽ giả định là x86, nên ta sẽ không lo về vấn đề đó.
SQLite, I talked a little about this, SQLite's definition for everything is strings, and then it interprets it at runtime, so that way if you run on a little-endian or big-endian system, it always comes out to be correct.
SQLite, tôi đã nói sơ qua về điều này, SQLite định nghĩa mọi thứ đều là chuỗi, rồi diễn giải nó lúc chạy, nhờ vậy dù chạy trên hệ thống little-endian hay big-endian, kết quả luôn đúng.
But most systems do not do that.
Nhưng hầu hết các hệ thống không làm vậy.
They do a little extra work to keep track of what is the endianness when they store things, so that if you come back up, if you copy your database to another machine that flips things around, you end up with the data as you'd expect.
Chúng làm thêm một chút việc để theo dõi endianness là gì khi lưu dữ liệu, để khi bạn khởi động lại, hay khi sao chép cơ sở dữ liệu sang máy khác có thứ tự byte đảo ngược, bạn vẫn nhận được dữ liệu như mong đợi.
But for now, we can ignore that. So for floats and reals, for floating-point numbers, this will follow what's called the IEEE 754 standard.
Nhưng hiện giờ, ta có thể bỏ qua điều đó. Còn với float và real, tức là số dấu phẩy động, chúng tuân theo cái gọi là chuẩn IEEE 754.
Again, this is a hardware spec that says how these floating-point numbers should be represented in hardware, and again, most systems follow that. Numerics and decimals, or fixed-point decimals, these are going to be database-specific.
Một lần nữa, đây là một đặc tả phần cứng quy định cách biểu diễn các số dấu phẩy động này trong phần cứng, và một lần nữa, hầu hết các hệ thống đều tuân theo. Numeric và decimal, hay số thập phân dấu phẩy tĩnh, sẽ phụ thuộc vào từng hệ cơ sở dữ liệu.
We'll see what they look like in a second.
Lát nữa ta sẽ xem chúng trông như thế nào.
For text strings, either VARCHAR, VARBINARY, TEXT or BLOBS, you either have things be inlined within the tuple itself, so it'll be like the length of the tuple, the length of the attribute, or there'll be a pointer to another location or another page that'll have that data that you can follow along.
Với chuỗi văn bản, như VARCHAR, VARBINARY, TEXT hay BLOB, hoặc dữ liệu được lưu nội tuyến ngay trong tuple, tức là có độ dài của tuple, độ dài của thuộc tính, hoặc có một con trỏ tới một vị trí khác hoặc một trang khác chứa dữ liệu đó mà bạn có thể lần theo.
We'll see what that looks like in a second. If the VARCHARs are small enough, you'll store them inline. If they get too big, then you store them in overflow pages.
Lát nữa ta sẽ xem nó trông như thế nào. Nếu VARCHAR đủ nhỏ, bạn sẽ lưu nội tuyến. Nếu quá lớn, bạn sẽ lưu trong các trang tràn (overflow page).
We're not going to talk about this class, collation sorting, but you do have to be super careful for text strings about who's actually deciding the right way to store things.
Trong môn này ta sẽ không bàn về collation sorting, nhưng với chuỗi văn bản bạn phải hết sức cẩn thận xem ai là người quyết định cách lưu trữ đúng.
For different languages, it has different orderings. Data doesn't have to worry about that, but for our purposes here, at this lowest level for these bytes, we're not worried about that.
Các ngôn ngữ khác nhau có thứ tự sắp xếp khác nhau. Dữ liệu không cần lo về điều đó, nhưng với mục đích của ta ở đây, ở mức thấp nhất này, với các byte này, ta không bận tâm đến chuyện đó.
We'll talk about that later when it comes to sorting, but it's something you need to be mindful of. By default, it says to store things ASCII.
Ta sẽ nói về nó sau, khi bàn đến sắp xếp, nhưng đó là điều bạn cần lưu ý. Theo mặc định, nó lưu dữ liệu dưới dạng ASCII.
You don't have to worry about Unicode or UTF-8 or UTF-16. You can store things as that as well.
Bạn không phải lo về Unicode, UTF-8 hay UTF-16. Bạn cũng có thể lưu dữ liệu theo các dạng đó.
You don't have to worry about characters. You can be mindful that people might be storing things that are English characters. Then timestamps and dates.
Bạn không phải lo về các ký tự. Bạn nên lưu ý rằng mọi người có thể đang lưu những thứ là các ký tự tiếng Anh. Tiếp theo là timestamp và ngày tháng.
Oftentimes internally, you would represent these things as just the number of microseconds or milliseconds since the Unix epoch.
Thông thường, bên trong hệ thống, người ta biểu diễn chúng chỉ bằng số micro giây hoặc mili giây kể từ Unix epoch.
Sometimes some systems have their own internal date format or timestamp format, and then keep track of time zones or not. This varies per system.
Đôi khi một số hệ thống có định dạng ngày hoặc định dạng timestamp riêng, và có theo dõi múi giờ hoặc không. Điều này khác nhau tùy từng hệ thống.
What I want to spend a little time talking about is the difference between floating reels and numerics, because this is a good example where the database systems are going to do a bunch of extra stuff to make sure your data is actually stored correctly in the way you expect, even though it may not be the fastest way to do this, because the hardware can do things much faster than we can, But we can guarantee that we don't have any loss of data or loss of precision
Điều tôi muốn dành một chút thời gian để nói là sự khác biệt giữa số thực dấu phẩy động và numeric, vì đây là một ví dụ hay cho thấy hệ quản trị cơ sở dữ liệu sẽ làm thêm khá nhiều việc để đảm bảo dữ liệu của bạn thực sự được lưu đúng theo cách bạn mong đợi, dù đó có thể không phải là cách nhanh nhất, vì phần cứng có thể làm nhanh hơn chúng ta rất nhiều. Nhưng chúng ta có thể đảm bảo không bị mất dữ liệu hay mất độ chính xác vì ta gọi chúng là số dấu phẩy động.
because we call it the floating point numbers. I think this is using the native data types you would have in C++. You call it float or you call it double.
Tôi nghĩ đây là dùng các kiểu dữ liệu gốc mà bạn có trong C++. Bạn gọi nó là float hoặc double.
In the code, that's defined by the IEEE 754 standard. This is what most architectures are actually going to implement.
Trong mã, nó được định nghĩa bởi chuẩn IEEE 754. Đây là thứ mà hầu hết các kiến trúc thực sự sẽ cài đặt.
They're also going to have specific instructions that can operate on these data that is really fast, but the problem is going to be that, again, you can't guarantee that they can store exact values.
Chúng cũng có các lệnh chuyên dụng có thể thao tác trên dữ liệu này rất nhanh, nhưng vấn đề là, một lần nữa, bạn không thể đảm bảo chúng lưu được giá trị chính xác.
The example I always like to give is something like this. You have some simple C code and you want to store two floating point numbers, x and y, 0.1 and 0.2.
Ví dụ tôi luôn thích đưa ra là như thế này. Bạn có một đoạn mã C đơn giản và muốn lưu hai số dấu phẩy động, x và y, là 0.1 và 0.2.
If I run this code here, you get output that looks like this. It looks as if I would expect that I can store x plus y.
Nếu chạy đoạn mã này, bạn nhận được kết quả như thế này. Có vẻ đúng như ta mong đợi là có thể lưu x cộng y.
I get 0.3 followed by a bunch of zeros. Same with just storing 0.3 by writing out 0.3 by itself.
Tôi nhận được 0.3 theo sau là một loạt số không. Cũng vậy khi chỉ lưu 0.3 bằng cách in riêng 0.3.
If I change the precision of the decimal point like this, now you see you actually get wildly different numbers. Neither one is exactly 0.3.
Nếu tôi thay đổi độ chính xác của dấu thập phân như thế này, thì bạn thấy ta nhận được những con số khác hẳn nhau. Không số nào chính xác bằng 0.3.
This is because the way the hardware is going to store these floating point numbers is using variable precision and it can't exactly store certain decimal values like 0.3.
Đó là vì cách phần cứng lưu các số dấu phẩy động này là dùng độ chính xác thay đổi và nó không thể lưu chính xác một số giá trị thập phân như 0.3.
Even though with less precision it looks like it's the same, but in actuality the bits in the hardware are not the same.
Dù với độ chính xác thấp hơn thì trông chúng có vẻ giống nhau, nhưng thực tế các bit trong phần cứng không giống nhau.
Now if I write this out to disk and I read it back in and based on what calculation I'm trying to do, I may end up with incorrect results or unexpected results.
Bây giờ nếu tôi ghi nó xuống đĩa rồi đọc lại và tùy vào phép tính tôi đang cố làm, tôi có thể nhận được kết quả sai hoặc không như mong đợi.
This is why data systems will maintain what are called fixed precision numbers, where the data systems can basically keep track of what I store, and then now I store maybe a string representation of the decimal,
Đây là lý do các hệ thống dữ liệu duy trì những gì gọi là số có độ chính xác cố định, trong đó hệ thống dữ liệu về cơ bản có thể theo dõi những gì tôi lưu, và giờ tôi có thể lưu một biểu diễn dạng chuỗi của số thập phân,
and then I know I use that extra metadata that I'm storing to be able to interpret what that byte array actually means, to guarantee that any calculation I do, I get the expected precision I would want on the results.
rồi tôi dùng siêu dữ liệu bổ sung mà tôi lưu đó để có thể diễn giải mảng byte đó thực sự có nghĩa là gì, để đảm bảo rằng với bất kỳ phép tính nào tôi thực hiện, tôi đều nhận được kết quả có độ chính xác như mong muốn.
Sometimes it's called fixed point decimals, basically the same idea, where I'm doing decimal points but I'm managing everything inside the data system myself, because we can guarantee that we end up with correct values.
Đôi khi nó được gọi là số thập phân dấu phẩy tĩnh (fixed point decimal), về cơ bản là cùng một ý tưởng, trong đó tôi xử lý các số thập phân nhưng tự mình quản lý mọi thứ bên trong hệ thống dữ liệu, vì như vậy chúng ta có thể đảm bảo cuối cùng có được các giá trị đúng.
So this is super important in things like banking, time-competing interest, you don't want rounding errors, anything with scientific instruments you don't want rounding errors, especially if you're sending a rocket to the moon or something.
Điều này cực kỳ quan trọng trong những lĩnh vực như ngân hàng, tính lãi kép, bạn không muốn có sai số làm tròn, bất cứ thứ gì liên quan đến thiết bị khoa học cũng không được có sai số làm tròn, đặc biệt là nếu bạn đang phóng tên lửa lên mặt trăng chẳng hạn.
So this is why we want to be able to do this, and they don't take it lightly, or it's not trivial to actually implement these things to guarantee the correctness under all possible circumstances.
Đó là lý do chúng ta muốn làm được điều này, và họ không xem nhẹ nó, hay nói cách khác, việc triển khai những thứ này không hề đơn giản để đảm bảo tính đúng đắn trong mọi trường hợp có thể xảy ra.
So the example I always like to show is Postgres' implementation of their fixed point decimals. They have a data type called numeric.
Ví dụ mà tôi luôn thích đưa ra là cách Postgres triển khai số thập phân dấu phẩy tĩnh của họ. Họ có một kiểu dữ liệu gọi là numeric.
If you actually go look at the Postgres code, this is essentially what it looks like.
Nếu bạn thực sự xem mã nguồn của Postgres, thì về cơ bản nó trông như thế này.
You have this struct here, and it has a bunch of metadata about what's going to be in a fixed point decimal, and then at its core the value itself is being stored as a byte array, and then all this additional metadata is then being used to interpret
Bạn có struct này ở đây, và nó có một loạt siêu dữ liệu về những gì sẽ có trong một số thập phân dấu phẩy tĩnh, và cốt lõi là bản thân giá trị được lưu dưới dạng một mảng byte, rồi toàn bộ siêu dữ liệu bổ sung này được dùng để diễn giải
that byte array, to generate the answer, to convert it back into its correct form that guarantees the exact value that you expect.
mảng byte đó, để tạo ra câu trả lời, để chuyển nó trở lại đúng dạng của nó đảm bảo giá trị chính xác như bạn mong đợi.
And of course now this means that when we want to do simple things like add two numerics together, it's not just calling number plus number and instruction in a register.
Và tất nhiên điều này có nghĩa là khi chúng ta muốn làm những việc đơn giản như cộng hai số numeric với nhau, thì không chỉ là gọi số cộng số, tức một lệnh trên thanh ghi.
We have to implement all this stuff ourselves. So this is the code from Postgres a few years ago, but basically it's the same with the newer versions, to add two numerics.
Chúng ta phải tự triển khai tất cả những thứ này. Đây là mã của Postgres từ vài năm trước, nhưng về cơ bản các phiên bản mới hơn vẫn như vậy, để cộng hai số numeric.
You can see here there's a bunch of if then else's.
Bạn có thể thấy ở đây có hàng loạt câu lệnh if then else.
We're checking to see, is the number positive, which is what we want to compute, then just calling the simple addition instruction on two data registers.
Chúng ta kiểm tra xem số đó có dương không, đó là điều chúng ta muốn tính, rồi chỉ gọi lệnh cộng đơn giản trên hai thanh ghi dữ liệu.
This is something that you have to run all this code, but this will guarantee that the value you get is what you expect.
Bạn phải chạy toàn bộ đoạn mã này, nhưng nó sẽ đảm bảo rằng giá trị bạn nhận được đúng như bạn mong đợi.
So the other thing we have to be mindful of is how we're going to handle nulls.
Một điều khác chúng ta phải lưu ý là cách xử lý các giá trị null.
So there's basically three approaches, and as I said, the most common one is if you have a tuple, you have a bitmap that keeps track of what values you have within that tuple are null or not.
Về cơ bản có ba cách tiếp cận, và như tôi đã nói, cách phổ biến nhất là nếu bạn có một tuple, bạn có một bitmap theo dõi xem những giá trị nào trong tuple đó là null hay không.
Typically we store this bitmap to be the same size as the number of entries that you have, regardless of whether columns can be null or not.
Thông thường chúng ta lưu bitmap này có cùng kích thước với số lượng mục mà bạn có, bất kể các cột có thể null hay không.
It's not worth the overhead of checking that as you're interpreting bytes.
Không đáng để chịu chi phí kiểm tra điều đó khi bạn đang diễn giải các byte.
Or, the range of values you can have for a given data type, you designate one of them to represent null.
Hoặc, trong phạm vi các giá trị mà một kiểu dữ liệu nhất định có thể có, bạn chỉ định một giá trị để biểu diễn null.
So if you're storing things as, storing 32-bit integers or 32-bit signed integers, you would say that the smallest value you could have represented by 32 min, you say that value is considered null.
Vậy nếu bạn lưu số nguyên 32-bit, hay số nguyên 32-bit có dấu, thì bạn sẽ nói giá trị nhỏ nhất có thể biểu diễn bằng 32 min, bạn coi giá trị đó là null.
And so you prevent anybody from inserting that value.
Và như vậy bạn không cho ai chèn giá trị đó vào.
Of course, this means you have one less possible value you can have in your domain, but now you don't need to store that header per tuple.
Tất nhiên, điều này nghĩa là miền giá trị của bạn bị mất đi một giá trị có thể có, nhưng đổi lại bạn không cần lưu phần header đó cho mỗi tuple.
So this will be more common in column stores, which we'll cover in a few weeks.
Cách này phổ biến hơn trong column store, mà vài tuần nữa chúng ta sẽ học.
You sometimes see this in memory databases as well, they're trying to reduce the size of the metadata they're storing per tuple. For others, the top one is more common.
Đôi khi bạn cũng thấy nó trong các cơ sở dữ liệu in-memory, vì họ cố giảm kích thước siêu dữ liệu lưu cho mỗi tuple. Còn với các hệ khác, cách đầu tiên phổ biến hơn.
The last one is to store in the tuple to tell you whether this value is null or not.
Cách cuối cùng là lưu ngay trong tuple một cờ cho biết giá trị này có phải null hay không.
So think of like, if I'm storing a 32-bit integer, I have to have a 1-bit flag in front of that value for that 32-bit integer that tells me whether it's null or not.
Hãy nghĩ thế này: nếu tôi lưu một số nguyên 32-bit, tôi phải có một cờ 1-bit đứng trước giá trị đó cho số nguyên 32-bit ấy, cho tôi biết nó có phải null hay không.
Of course, now as you talk about alignment, you can't just store things as single bits, you'd have to store them in columns.
Tất nhiên, khi nói đến căn chỉnh (alignment), bạn không thể chỉ lưu từng bit đơn lẻ, bạn sẽ phải lưu chúng theo từng cột.
So this is a bad idea.
Vì vậy đây là một ý tưởng tồi.
I'm only bringing this up to say this is a possibility of what you can do, but as we go out the entire semester, I'll try to put this little marker here to tell you like, hey, this exists, but don't do this.
Tôi chỉ nêu ra để nói rằng đây là một khả năng bạn có thể làm, nhưng trong suốt cả học kỳ, tôi sẽ cố đặt một dấu nhỏ ở đây để nói với các bạn: này, cái này có tồn tại, nhưng đừng làm vậy.
So definitely don't do this.
Nên chắc chắn đừng làm như vậy.
I only know one system that did this in a few weeks, but if you take the advanced class, we'll read this paper
Tôi chỉ biết một hệ thống đã làm như thế trong vài tuần tới, nhưng nếu bạn học lớp nâng cao, chúng ta sẽ đọc bài báo này
and go into way more detail about how to do it. Alright, so before I said the assumption that a tuple has to fit into a single page.
và đi sâu hơn nhiều về cách làm. Được rồi, trước đó tôi đã nêu giả định rằng một tuple phải vừa trong một page duy nhất.
Of course, now if I have to support really large attributes, this is not going to work.
Tất nhiên, nếu bây giờ phải hỗ trợ các thuộc tính rất lớn, thì cách này sẽ không hiệu quả.
If my attribute I want to store is larger than my page size, what do I actually have to do? So this is where overflow pages come in.
Nếu thuộc tính tôi muốn lưu lớn hơn kích thước page, thì thực sự tôi phải làm gì? Đây là lúc overflow page xuất hiện.
The basic idea is that we have separate pages where, if the value of a given tuple is larger than it can fit in that page, then I have a separate page where I put that value in, and now within my tuple I store a pointer, basically a record ID, to that other overflow page.
Ý tưởng cơ bản là ta có các page riêng, trong đó nếu giá trị của một tuple lớn hơn mức page đó chứa được, thì tôi dùng một page riêng để đặt giá trị đó vào, và trong tuple tôi lưu một con trỏ, về cơ bản là một record ID, trỏ tới overflow page kia.
And now as I'm scanning the data, I'm going to interpret this data within a tuple. I know I've come across one of these pointers to this overflow page.
Và khi tôi quét dữ liệu, tôi sẽ diễn giải dữ liệu này bên trong một tuple. Tôi biết mình đã gặp một trong những con trỏ trỏ tới overflow page này.
I know I need to follow that to get the original data.
Tôi biết cần đi theo nó để lấy dữ liệu gốc.
As I say, this contents attribute in this table here is too big, so I have an overflow page where I'm just going to store all this variable data, and then now within my original tuple I'll store the size of the data and then the page number and offset, record ID, to where to go find this overflow page.
Giả sử thuộc tính contents trong bảng này quá lớn, nên tôi có một overflow page để lưu toàn bộ dữ liệu có độ dài thay đổi này, và trong tuple gốc tôi sẽ lưu kích thước của dữ liệu cùng số hiệu page và offset, tức record ID, chỉ nơi tìm overflow page này.
So different databases do different things to interpret, to trigger when you store things in overflow.
Các cơ sở dữ liệu khác nhau có cách khác nhau để quyết định khi nào thì lưu dữ liệu vào trang tràn (overflow).
So in Postgres, by default, if the, anything you try to store is larger than two kilobytes, even though they have eight kilobyte pages, they put it in the overflow page.
Trong Postgres, theo mặc định, nếu bất cứ thứ gì bạn lưu lớn hơn hai kilobyte, dù trang của họ có kích thước tám kilobyte, họ vẫn đưa nó vào trang tràn.
In MySQL and SQL Server, and I think Oracle as well, if the thing you're trying to store is larger than half the page size, or larger than the page size, or larger than half the page size, then they put it in the overflow page.
Trong MySQL và SQL Server, và tôi nghĩ cả Oracle nữa, nếu thứ bạn định lưu lớn hơn một nửa kích thước trang, hoặc lớn hơn kích thước trang, hoặc lớn hơn một nửa kích thước trang, thì họ đưa nó vào trang tràn.
There's a bunch of optimizations we can do to mitigate the overhead of trying to fetch these pages.
Có một loạt tối ưu hóa chúng ta có thể làm để giảm bớt chi phí của việc phải lấy các trang này.
So we can take these overflow pages and compress them using like Snappy or gzip, and we'll cover that in two weeks. Another technique is called German strings.
Chúng ta có thể lấy các trang tràn này và nén chúng bằng Snappy hay gzip chẳng hạn, và chúng ta sẽ học phần đó trong hai tuần nữa. Một kỹ thuật khác gọi là German strings.
This obviously comes from the Germans, where in addition to the size and offset that I store in the original tuple, I can actually store a prefix of the value.
Cái tên này hiển nhiên xuất phát từ người Đức, trong đó, ngoài kích thước và offset mà tôi lưu trong tuple gốc, tôi còn có thể lưu một tiền tố của giá trị.
So if I'm just trying to do string matching, where like, find all records, find all records where the contents field starts with the word Andy, I can check the prefix in the original tuple and see whether I have it matched there before even following the pointer to go fetch the overflow page.
Nếu tôi chỉ đang so khớp chuỗi, chẳng hạn tìm tất cả các bản ghi, tìm tất cả các bản ghi mà trường contents bắt đầu bằng từ Andy, tôi có thể kiểm tra tiền tố trong tuple gốc và xem liệu nó đã khớp ở đó chưa, trước cả khi theo con trỏ để lấy trang tràn.
It's back to this idea we said at the beginning of like trying to avoid having to read data from disks that I don't actually need.
Nó quay lại ý tưởng chúng ta nói từ đầu, là cố gắng tránh phải đọc từ đĩa những dữ liệu mà tôi thực sự không cần.
If I spend a little storage overhead of storing things in a prefix, it can avoid me having to go do that in certain situations.
Nếu tôi bỏ ra một chút chi phí lưu trữ để lưu tiền tố, thì trong một số tình huống tôi không phải làm việc đó.
And if the data I'm storing in my overflow page is too large, within the overflow page I can just, again, put another record ID at the end of it or the front of it to tell you where the subsequent page can be found.
Và nếu dữ liệu tôi lưu trong trang tràn quá lớn, thì trong trang tràn tôi lại có thể đặt thêm một record ID ở cuối hoặc ở đầu để cho biết tìm trang tiếp theo ở đâu.
So I can chain these things together to reconstruct large tuples. In some systems also too, you can actually represent data in pages that are not managed by the database system.
Vậy tôi có thể xâu chuỗi chúng lại để dựng lại các tuple lớn. Trong một số hệ thống, bạn cũng có thể biểu diễn dữ liệu trong các trang không do hệ quản trị cơ sở dữ liệu quản lý.
These are called external value storage.
Cái này gọi là external value storage (lưu trữ giá trị bên ngoài).
So this would be like if I have a large database and I have a 20 gigabyte movie, I don't want to maybe put that in my database system, but I want to still have the database system be aware of that this data exists.
Ví dụ, nếu tôi có một cơ sở dữ liệu lớn và có một bộ phim 20 gigabyte, có thể tôi không muốn đặt nó vào hệ cơ sở dữ liệu, nhưng tôi vẫn muốn hệ cơ sở dữ liệu biết là dữ liệu này tồn tại.
So I could have a record that has, essentially, a URI or a pointer to some external storage that's managed outside the database system, that if I need to, I can suck it in, read it and hand it back to queries.
Vậy tôi có thể có một bản ghi chứa, về cơ bản, một URI hoặc một con trỏ tới một nơi lưu trữ bên ngoài, do hệ bên ngoài cơ sở dữ liệu quản lý, để khi cần tôi có thể nạp vào, đọc và trả lại cho các truy vấn.
But the responsibility of maintaining that data, making sure that it's transactionally safe and making sure that it is safe on the regular data, it's not going to guarantee those things, but it still allows me to stream data out and serve it into tuples as needed.
Nhưng trách nhiệm duy trì dữ liệu đó, đảm bảo nó an toàn về mặt giao dịch và đảm bảo nó an toàn như dữ liệu thông thường, thì hệ thống sẽ không bảo đảm những điều đó, nhưng nó vẫn cho phép tôi truyền luồng dữ liệu ra và đưa vào các tuple khi cần.
So not every system supports this. Oracle calls them B files, Microsoft calls them file streams.
Không phải hệ thống nào cũng hỗ trợ điều này. Oracle gọi chúng là B files, Microsoft gọi là file streams.
It's basically a way to storage large files outside the database system but then still suck it in if you need to.
Về cơ bản đó là cách lưu các tệp lớn bên ngoài hệ cơ sở dữ liệu. nhưng vẫn nạp nó vào khi cần.
And there's a paper from a few years ago, actually it's over a year ago, it's over 20 years now, from Jim Gray, the guy that went into databases, where they examined whether you should put things in the database system or not.
Có một bài báo từ vài năm trước, thực ra không phải hơn một năm đâu, đã hơn 20 năm rồi, của Jim Gray, người đã đi vào lĩnh vực cơ sở dữ liệu, trong đó họ xem xét liệu có nên đặt dữ liệu vào hệ cơ sở dữ liệu hay không.
I think their recommendation was anything larger than, I think it was like, 128 kilobytes should be external, less than that internal.
Tôi nhớ khuyến nghị của họ là bất cứ thứ gì lớn hơn, hình như là 128 kilobyte thì nên để bên ngoài, nhỏ hơn thì để bên trong.
I don't know if that's entirely true anymore, but people have thought about this problem: when should you store large things in the database or not?
Tôi không biết điều đó giờ còn hoàn toàn đúng không, nhưng người ta đã nghĩ về vấn đề này: khi nào nên lưu dữ liệu lớn trong cơ sở dữ liệu và khi nào không?
And I think in general database systems usually run on more expensive hardware, so you don't want to store massive files, and something that's external value storage is a way to get around that.
Và nhìn chung, các hệ cơ sở dữ liệu thường chạy trên phần cứng đắt tiền hơn, nên bạn không muốn lưu các tệp khổng lồ, và lưu trữ giá trị bên ngoài là một cách để giải quyết việc đó.
So it looks like it's in the database even though it's not. Then you can put it on cheaper storage. All right, so we've covered a lot.
Nó trông như nằm trong cơ sở dữ liệu dù thực tế thì không. Rồi bạn có thể đặt nó lên bộ lưu trữ rẻ hơn. Được rồi, chúng ta đã học khá nhiều.
Fat face Rick is still not out of the hospital yet, so I have to go figure out where he is.
Fat face Rick vẫn chưa ra khỏi bệnh viện, nên tôi phải đi tìm xem anh ấy đang ở đâu.
But we've covered database storage, the basics of it. So again, a database system is basically a collection of pages that can be stored on disk or some non-volatile storage.
Nhưng chúng ta đã học về lưu trữ cơ sở dữ liệu, những kiến thức cơ bản. Một lần nữa, hệ cơ sở dữ liệu về cơ bản là một tập hợp các trang có thể được lưu trên đĩa hoặc bộ lưu trữ không bay hơi nào đó.
And then we'll have different ways to keep track of where those pages are located. And then we'll have different ways to store those pages on disk, whether they're single files, multiple files, or whatever.
Và ta sẽ có nhiều cách khác nhau để theo dõi vị trí của các trang đó. Và ta sẽ có nhiều cách khác nhau để lưu các trang đó trên đĩa, dù là một tệp, nhiều tệp, hay gì đi nữa.
And then we have different ways to store the tuples that are inside those pages. And then, again, because of this layered architecture...
Và ta có nhiều cách khác nhau để lưu các tuple bên trong những trang đó. Và rồi, một lần nữa, nhờ kiến trúc phân tầng này...
Because we have this sort of layered architecture, the other parts of the system don't need to be entirely aware of, like, "Oh, this is actually how I'm storing things, like in a slotted page architecture or not."
Vì ta có kiểu kiến trúc phân tầng này, các phần khác của hệ thống không cần biết rõ là "À, thực ra dữ liệu đang được lưu theo cách này, chẳng hạn kiến trúc slotted page hay không."
All that is abstracted away, and then we can still change things out and modify them and extend them or enhance them as needed without worrying about breaking the entire system.
Tất cả đều được trừu tượng hóa, và ta vẫn có thể thay thế, sửa đổi mở rộng hoặc cải tiến chúng khi cần mà không lo làm hỏng toàn bộ hệ thống.
It's not always the case, but then ultimately that's the goal. Of course, there's a tradeoff of having too much abstraction that makes things inefficient.
Không phải lúc nào cũng vậy, nhưng đó rốt cuộc là mục tiêu. Tất nhiên, có sự đánh đổi khi trừu tượng hóa quá nhiều khiến hệ thống kém hiệu quả.
But, again, it depends on the implementation, and we'll see when we want to relax certain guarantees or certain restrictions later on.
Nhưng, một lần nữa, điều đó tùy vào cách triển khai, và ta sẽ thấy khi muốn nới lỏng một số bảo đảm hoặc một số ràng buộc về sau.
All right, so, again, today's class was about how to represent data as a database of files on disk.
Được rồi, buổi học hôm nay nói về cách biểu diễn dữ liệu như một cơ sở dữ liệu gồm các tệp trên đĩa.
Next class will be then how we then talk about when we bring things into memory, how do we keep track of that, how do we then hand off those pages of memory to other parts of the system, and how to make sure that we write them out in a timely manner, in a safe manner, so that we don't crash and lose anything.
Buổi sau sẽ nói về việc khi ta đưa dữ liệu vào bộ nhớ, ta theo dõi nó như thế nào, làm sao chuyển các trang bộ nhớ đó cho các phần khác của hệ thống, và làm sao đảm bảo ghi chúng ra đúng lúc, một cách an toàn, để không bị sập và mất dữ liệu.
Then after that, we'll come back and talk about different ways to get started with disk again, but we're going to cover the buffer pool, we'll manage the memory stuff first, because you're going to need that for project one that'll go out next week.
Sau đó, ta sẽ quay lại và nói về các cách khác nhau để bắt đầu với đĩa một lần nữa, nhưng ta sẽ học buffer pool, quản lý bộ nhớ trước, vì bạn sẽ cần nó cho project một sẽ được giao vào tuần sau.
Okay?
Được chứ?
So, Next
Vậy, Buổi
class, we're going to talk about how to do that. So, next class, we're how to do that.
học sau, chúng ta sẽ nói về cách làm điều đó. Vậy, buổi học sau, chúng ta sẽ nói về cách làm điều đó.
Đă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.