mirror of
https://github.com/neondatabase/neon.git
synced 2026-05-19 22:20:37 +00:00
9ff122835f
This clarifies - I hope - the abstractions between Repository and ObjectRepository. The ObjectTag struct was a mix of objects that could be accessed directly through the public Timeline interface, and also objects that were created and used internally by the ObjectRepository implementation and not supposed to be accessed directly by the callers. With the RelishTag separaate from ObjectTag, the distinction is more clear: RelishTag is used in the public interface, and ObjectTag is used internally between object_repository.rs and object_store.rs, and it contains the internal metadata object types. One awkward thing with the ObjectTag struct was that the Repository implementation had to distinguish between ObjectTags for relations, and track the size of the relation, while others were used to store "blobs". With the RelishTags, some relishes are considered "non-blocky", and the Repository implementation is expected to track their sizes, while others are stored as blobs. I'm not 100% happy with how RelishTag captures that either: it just knows that some relish kinds are blocky and some non-blocky, and there's an is_block() function to check that. But this does enable size-tracking for SLRUs, allowing us to treat them more like relations. This changes the way SLRUs are stored in the repository. Each SLRU segment, e.g. "pg_clog/0000", "pg_clog/0001", are now handled as a separate relish. This removes the need for the SLRU-specific put_slru_truncate() function in the Timeline trait. SLRU truncation is now handled by caling put_unlink() on the segment. This is more in line with how PostgreSQL stores SLRUs and handles their trunction. The SLRUs are "blocky", so they are accessed one 8k page at a time, and repository tracks their size. I considered an alternative design where we would treat each SLRU segment as non-blocky, and just store the whole file as one blob. Each SLRU segment is up to 256 kB in size, which isn't that large, so that might've worked fine, too. One reason I didn't do that is that it seems better to have the WAL redo routines be as close as possible to the PostgreSQL routines. It doesn't matter much in the repository, though; we have to track the size for relations anyway, so there's not much difference in whether we also do it for SLRUs. While working on this, I noticed that the CLOG and MultiXact redo code did not handle wraparound correctly. We need to fix that, but for now, I just commented them out with a FIXME comment.
50 lines
1.7 KiB
Rust
50 lines
1.7 KiB
Rust
//!
|
|
//! Common structs shared by object_repository.rs and object_store.rs.
|
|
//!
|
|
|
|
use crate::relish::RelishTag;
|
|
use crate::ZTimelineId;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
///
|
|
/// ObjectKey is the key type used to identify objects stored in an object
|
|
/// repository. It is shared between object_repository.rs and object_store.rs.
|
|
/// It is mostly opaque to ObjectStore, it just stores and retrieves objects
|
|
/// using the key given by the caller.
|
|
///
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ObjectKey {
|
|
pub timeline: ZTimelineId,
|
|
pub tag: ObjectTag,
|
|
}
|
|
|
|
///
|
|
/// ObjectTag is a part of ObjectKey that is specific to the type of
|
|
/// the stored object.
|
|
///
|
|
/// NB: the order of the enum values is significant! In particular,
|
|
/// rocksdb_storage.rs assumes that TimelineMetadataTag is first
|
|
///
|
|
/// Buffer is the kind of object that is accessible by the public
|
|
/// get_page_at_lsn() / put_page_image() / put_wal_record() functions in
|
|
/// the repository.rs interface. The rest are internal objects stored in
|
|
/// the key-value store, to store various metadata. They're not directly
|
|
/// accessible outside object_repository.rs
|
|
///
|
|
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum ObjectTag {
|
|
// dummy tag preceeding all other keys
|
|
FirstTag,
|
|
|
|
// Metadata about a timeline. Not versioned.
|
|
TimelineMetadataTag,
|
|
|
|
// These objects store metadata about one relish. Currently it's used
|
|
// just to track the relish's size. It's not used for non-blocky relishes
|
|
// at all.
|
|
RelationMetadata(RelishTag),
|
|
|
|
// These are the pages exposed in the public Repository/Timeline interface.
|
|
Buffer(RelishTag, u32),
|
|
}
|