Enum Partitioning 

pub enum Partitioning {
    Hash {
        columns: Vec<ColumnId>,
        buckets: u32,
    },
    Range {
        columns: Vec<ColumnId>,
        splits: Vec<Key>,
    },
    Tenant {
        tenant_column: ColumnId,
        buckets_per_tenant: u32,
    },
    TimeRange {
        timestamp_column: ColumnId,
        interval: TimeInterval,
    },
}

How one table’s rows map onto tablets (spec section 12.2). Declaration order is frozen; variants are never reused (spec section 4.10).

Variants

Hash

Hash of the declared columns into a fixed bucket space. Tablets own contiguous runs of buckets (see Partitioning::routed_key).

Fields

columns: Vec<ColumnId>

Partition-key columns, in hash order.

buckets: u32

Bucket count; positive.

Range

Lexicographic ranges over the declared columns, split at splits. splits.len() + 1 partitions cover the key space: partition i owns [splits[i - 1], splits[i]), unbounded at the edges.

Fields

columns: Vec<ColumnId>

Partition-key columns, in sort order.

splits: Vec<Key>

Ordered, strictly increasing split points.

Tenant

One bucket space per tenant: the tenant column hashes into buckets_per_tenant buckets, so every tenant’s rows spread evenly and tenants can be isolated onto dedicated tablets (spec section 12.5).

Fields

tenant_column: ColumnId

Column carrying the tenant identifier.

buckets_per_tenant: u32

Buckets each tenant hashes into; positive.

TimeRange

Time-bucketed ranges: partition i owns [i * interval, (i + 1) * interval) of the timestamp column.

Fields

timestamp_column: ColumnId

Column carrying the row timestamp.

interval: TimeInterval

Fixed interval width.

Implementations

impl Partitioning

pub fn validate(&self) -> Result<(), PartitionError>

Validates the declaration: non-empty column lists, positive bucket counts, strictly increasing splits, positive interval.

pub fn partition_columns(&self) -> Vec<ColumnId>

The declared partition-key columns, in key order (spec section 12.2: every table has a declared partition key).

pub fn partition_key( &self, values: &BTreeMap<ColumnId, KeyValue>, ) -> Result<Key, PartitionError>

Extracts the partition key from a row’s column values: the declared partition-key columns, in declared order, encoded by RowKeyEncoder. A missing declared column fails closed.

The fast path of spec section 12.2 — the primary key includes the partition key — means the caller can usually supply the primary-key components directly; this function does not care where the values came from.

pub fn route(&self, partition_key: &Key) -> Result<u64, PartitionError>

Maps an extracted partition key onto its partition slot (spec section 12.2):

• Hash: fnv1a64(key) % buckets.
• Range: index of the first split above the key, 0..=splits.len().
• Tenant: fnv1a64(tenant key) % buckets_per_tenant; the slot is per tenant, so the full partition address is (tenant, slot) — see Self::routed_key.
• TimeRange: timestamp / interval (epoch-floored); pre-epoch timestamps fail closed with PartitionError::NegativeSlot.

pub fn routed_key(&self, partition_key: &Key) -> Result<Key, PartitionError>

The canonical routing address of a partition key — the byte string whose ranges the tablet PartitionBounds of this table are allocated over:

• Range and TimeRange: the partition key itself; bounds range directly over encoded key bytes.
• Hash: the 8 big-endian bytes of the bucket; the meta plane allocates tablet bounds as contiguous bucket runs, e.g. buckets [lo, hi) via hash_slot_bounds.
• Tenant: the tenant key encoding followed by the 8 big-endian bytes of the bucket, so bounds range per tenant over the composite.

pub fn range_bounds(&self, index: u64) -> Option<PartitionBounds>

The bounds of range partition index (0..=splits.len()); None for out-of-range indexes and non-range partitioning.

Trait Implementations

impl Clone for Partitioning

fn clone(&self) -> Partitioning

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Partitioning

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Partitioning

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Partitioning

impl PartialEq for Partitioning

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Partitioning

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Partitioning