Struct SnapshotId 

pub struct SnapshotId(pub u64);

Snapshot identifier - points to committed transaction state

Only data committed at or before this snapshot_id is visible. If a value cannot be tied to a committed snapshot_id → it does not exist.

Invariant

snapshot_id.0 MUST correspond to a committed transaction. Uncommitted transactions do not create valid snapshots.

Representation

Internally, SnapshotId wraps a TransactionId (u64). This is valid because:

• TransactionId is allocated at begin_transaction()
• SnapshotId is created at commit_transaction()
• The 1:1 mapping ensures snapshot_id uniquely identifies committed state

Tuple Fields

0: u64

Implementations

impl SnapshotId

pub fn current() -> Self

The “current” snapshot - sees only committed data

This returns a special sentinel value (0) that represents “all committed data”. All reads using this snapshot are guaranteed to see only data that has been durably committed.

Backend Behavior

• SQLite backend: Uses SnapshotId(0) to indicate “current” (no historical snapshots)
• Native-v3 backend: May use SnapshotId(0) or use new_incrementing() for sequential snapshots

Why SnapshotId(0)?

SQLite backend does not support historical snapshots (no AS OF queries or MVCC). Only the current committed state is accessible, which we represent as SnapshotId(0).

Example

let snapshot = SnapshotId::current();
// snapshot is now SnapshotId(0) - "current committed data"

pub fn new_incrementing() -> Self

Create a new incrementing snapshot ID

This generates a new snapshot ID using a global atomic counter. Each call returns a unique, monotonically increasing snapshot ID.

When to Use

• Native-v3 backend: Use this when you need unique snapshot IDs for MVCC
• SQLite backend: Do NOT use this - SQLite only supports SnapshotId(0)

Example

let snapshot1 = SnapshotId::new_incrementing();
let snapshot2 = SnapshotId::new_incrementing();
assert!(snapshot2.as_u64() > snapshot1.as_u64());

pub fn from_tx(tx_id: u64) -> Self

Create from explicit transaction ID

Arguments

• tx_id - A committed transaction ID

Important

The caller MUST ensure that tx_id corresponds to a committed transaction. Using an uncommitted transaction ID violates snapshot isolation guarantees.

Example

// After commit returns SnapshotId
let snapshot = coordinator.commit_transaction(tx_id)?;
// Later, reuse same snapshot for repeatable reads
let node = backend.get_node(snapshot, node_id)?;

pub fn from_lsn(lsn: u64) -> Self

Create snapshot from explicit LSN (Log Sequence Number)

Arguments

• lsn - A commit LSN representing a committed transaction

Important

The caller MUST ensure that lsn corresponds to a committed transaction. Using an uncommitted LSN violates snapshot isolation guarantees.

Example

// Create snapshot at specific LSN
let snapshot = SnapshotId::from_lsn(12345);

pub fn invalid() -> Self

Invalid snapshot - used for error cases

This sentinel value indicates that no valid snapshot exists. Read operations receiving this snapshot should return an error.

Example

fn validate_snapshot(snapshot: SnapshotId) -> Result<(), &'static str> {
    if snapshot == SnapshotId::invalid() {
        return Err("Invalid snapshot");
    }
    Ok(())
}

pub fn is_valid(&self) -> bool

Check if this snapshot is valid

Returns false for the invalid sentinel value.

pub fn as_u64(&self) -> u64

Get the underlying transaction ID

pub fn as_lsn(&self) -> u64

Get snapshot as LSN (Log Sequence Number)

Since SnapshotId wraps a commit LSN, this returns the LSN directly. Used for WAL record visibility checks.

Trait Implementations

impl Clone for SnapshotId

fn clone(&self) -> SnapshotId

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SnapshotId

impl Debug for SnapshotId

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SnapshotId

impl Hash for SnapshotId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SnapshotId

fn eq(&self, other: &SnapshotId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SnapshotId