Struct CsrWithProperties 

pub struct CsrWithProperties { /* private fields */ }

Implementations

impl CsrWithProperties

pub fn column_stats_snapshot(&self, column: &str) -> Option<ColumnStatsSnapshot>

pub fn prune_bounds(&self, column: &str) -> Option<(Value, Value)>

Global min/max bounds of one column for predicate pushdown pruning.

Callers must scan instead of pruning when this is None.

pub fn column_encoding_type(&self, column: &str) -> Option<EncodingType>

Encoding applied to one property column, if the column exists.

pub fn apply_encoding_to_column( &mut self, column: &str, encoding_type: EncodingType, fsst_max_symbols: usize, ) -> Result<(), StorageError>

Apply one encoding to a single property column.

Property columns are chunk-backed, so the encoding is applied per chunk and point updates keep decoding only the affected chunk. Empty columns are a no-op. Unknown columns are an explicit error.

pub fn auto_encode_properties(&mut self) -> usize

Select and apply one encoding per property column.

Explicit maintenance operation: hot columns stay unencoded between runs by design so everyday writes never pay re-encoding. Each column is profiled chunk by chunk, so no column-wide value vector is built. Returns the number of columns that received an encoding.

pub fn adapt_encodings_for_checkpoint( &mut self, dirty_only: Option<&[Arc<str>]>, min_rows: usize, ) -> usize

Infer encodings for checkpoint dirty columns.

Checkpoint-only entry: the write path never calls this, so hot columns pay no re-encoding on everyday writes. dirty_only selects the inference set; None infers every column for first-flush completeness. Columns below min_rows are skipped. A column keeps its current encoding when inference yields none or matches. Returns the number of columns that changed encoding.

impl CsrWithProperties

pub fn reserve_for_batch(&mut self, additional: usize)

Pre-allocate row and column capacity for an incoming batch.

Sizes visibility, reverse indexes and every property column once so a batch of additional edges lands in reserved gaps instead of growing row by row. Inline stubs keep no rows and skip reservation.

pub fn compaction_stats(&self) -> PropertyCompactionStats

pub fn gc_property_versions(&mut self, min_active_snapshot_ts: u64) -> usize

Garbage-collect property version-chain entries that no active snapshot can observe. Returns the total number of before-images removed.

pub fn used_memory_size(&self) -> usize

pub fn mapping_row_bytes(&self) -> (usize, usize)

Split property memory into mapping bytes (edge map plus reverse index plus free list) and row bytes (visibility plus columns). Caliber for per-edge accounting without walking rows.

pub fn refresh_column_stats(&mut self)

Recompute persisted per-column statistics from flush buffers.

Called before the property file is serialized so statistics follow the checkpoint instead of drifting. Only columns marked dirty are recomputed; clean columns keep their persisted statistics. Columns that fail to compute keep their previous statistics.

pub fn refresh_column_stats_for(&mut self, column: &str)

Refresh statistics for one column only. Used by column-level checkpoint follow-up when only a subset changed.

impl CsrWithProperties

pub const EDGE_MAP_SEGMENT_ROWS: usize = 1024

Segment granularity for sparse map scans. One segment covers this many edge ids; empty segments are skipped by segment-aware scans so sparse id ranges never pay a full dense walk.

pub fn release_row(&mut self, row_idx: usize)

Release a row back to the free list without leaving an orphan.

Clears the visibility stamp so the slot is skipped by reads and GC scans, drops the edge mapping via the reverse index, and queues the slot for reuse. Reused slots are fully overwritten by allocate_row. Idempotent via the explicit state machine: releasing an already-free or out-of-range row is a no-op, and virgin slots never enter the free list twice so no separate membership set is needed. Slots that were never used are never admitted to the free list.

pub fn get_row_for_edge(&self, edge_id: EdgeId) -> Option<usize>

Get the row index for an edge.

pub fn remove_edge_mapping(&mut self, edge_id: EdgeId) -> Option<usize>

Remove edge-to-row mapping and return the row index.

pub fn contains_edge(&self, edge_id: EdgeId) -> bool

Whether the store holds a row mapping for edge_id.

pub fn edge_mappings(&self) -> impl Iterator<Item = (EdgeId, u32)>

Iterate over all edge->row mappings in slot order (for compaction).

pub fn edge_ids(&self) -> impl Iterator<Item = EdgeId>

pub fn row_count(&self) -> usize

pub fn nonempty_map_segments(&self) -> Vec<usize>

Ids of segments holding at least one live mapping.

pub fn edge_mappings_in_segment( &self, segment: usize, ) -> impl Iterator<Item = (EdgeId, u32)>

Mappings within one segment, for segment-skipping scans.

pub fn edge_map_memory_bytes(&self) -> usize

Sparse map memory in bytes, for observability.

impl CsrWithProperties

pub fn dump(&self) -> Vec<u8>

pub fn load(&mut self, data: &[u8]) -> Result<(), StorageError>

impl CsrWithProperties

pub fn get_projected_physical_by_edge_id( &self, edge_id: EdgeId, query_ts: u64, projection: Option<&[Arc<str>]>, ) -> Option<Vec<(Arc<str>, Option<Value>)>>

Physical property projection without row visibility filtering.

Callers must decide visibility through the version authority first; row stamps exist only for collection. Returns None only when the edge has no row mapping. Lenient on history: version chains do not survive checkpoints, so pre-floor reads may return the current value; time-travel callers use the strict entry instead.

pub fn get_projected_physical_batch_by_edge_ids( &self, edge_ids: &[EdgeId], query_ts: u64, projection: Option<&[Arc<str>]>, ) -> Vec<Option<Vec<(Arc<str>, Option<Value>)>>>

Physical property projection for many edges without visibility filtering.

Batch form of Self::get_projected_physical_by_edge_id: the projection resolves to column indices once and every edge reuses the mapping, so a projected adjacency pays one hash-based schema pass instead of one string scan per edge. Output order follows the input; each entry carries the same contract as the single-edge call (None for inline tables, unmapped edges and out-of-range rows).

pub fn try_get_projected_physical_by_edge_id( &self, edge_id: EdgeId, query_ts: u64, projection: Option<&[Arc<str>]>, ) -> Result<Option<Vec<(Arc<str>, Option<Value>)>>, StorageError>

Strict physical projection with explicit decode errors.

Query entry for explicit failure semantics. Visibility stays with the caller through the version authority; row stamps never decide it here. Never-written windows yield None cells; corrupt snapshots, side-store payloads and raw length or dimension mismatches yield Err carrying the column and edge so scans never observe silent nulls. Reads below the history epoch floor fail instead of serving the current value as history. Unmapped edges still yield Ok(None).

pub fn try_get_projected_physical_batch_by_edge_ids( &self, edge_ids: &[EdgeId], query_ts: u64, projection: Option<&[Arc<str>]>, ) -> Result<Vec<Option<Vec<(Arc<str>, Option<Value>)>>>, StorageError>

Strict batch physical projection with explicit decode errors.

Batch form of Self::try_get_projected_physical_by_edge_id: the projection resolves once and every edge reuses it, with the same epoch fence and decode contract per edge. Output order follows the input.

pub fn latest_properties_by_edge_id( &self, edge_id: EdgeId, ) -> Option<Vec<(Arc<str>, Value)>>

Newest stored value of every non-null column for one edge.

Snapshot-independent by design: callers need the word currently stored (index maintenance, rollback bookkeeping), which must not depend on a reader timestamp and must not pay a version-chain walk. Nulls are dropped because an absent cell has no index entry to reconcile; inline tables have no rows to read and yield None.

pub fn matches_predicates_for_edge( &self, edge_id: EdgeId, query_ts: u64, predicates: &[ScanPredicate], ) -> bool

Whether one edge matches every pushed predicate at query_ts.

Column-scan layer: only predicate columns are read, each through its null bitmap, and no intermediate record is materialized. A missing column, a missing row mapping or a null cell never matches, mirroring the query NULL semantics where comparisons against NULL are false.

pub fn filter_edge_ids_by_predicates( &self, predicates: &[ScanPredicate], query_ts: u64, candidates: Option<&[EdgeId]>, ) -> Vec<EdgeId>

Filter edge ids by pushed predicates at the column-scan layer.

Attribute equality and range predicates filter row numbers first; callers look up topology only for the returned hits. Nulls use bitmap semantics throughout and no intermediate records are materialized. candidates bounds the scan when the caller already holds row numbers; None scans every mapped edge.

Two pre-filters run before the per-row version-chain reads: the merged column bounds short-circuit the whole scan, then the per-chunk zone bounds skip dead 1024-row chunks, so a selective predicate over a clustered column only decodes its surviving chunks. Output order follows the input in both arms: skipping never reorders survivors.

pub fn get_typed_columns_batch_by_edge_ids( &self, edge_ids: &[EdgeId], query_ts: u64, projection: Option<&[Arc<str>]>, ) -> Vec<(Arc<str>, ColumnValues)>

Typed column-major batch decode without visibility filtering.

Native edge columnar entry: the caller holds one authority verdict per edge, so this decodes straight from the property columns into typed crate::cursor::ColumnValues. Projection resolves once; each column decodes according to its declared type and degrades to General on type mismatch, so one mixed column never forces the whole batch back to row transpose. Output order follows the input edge order.

impl CsrWithProperties

pub fn new(property_schema: Vec<PropertySchema>) -> CsrWithProperties

Build the columnar store from its schema.

property_schema owns every column name: column_index, the name index and the dump format all read from it. Column also carries a name, but only to label decode errors, so it is filled here and refreshed on rename without any other code reading it.

pub fn inline_stub(property_schema: Vec<PropertySchema>) -> CsrWithProperties

Schema-only stub for the inline record forms.

Keeps the schema with its name/id indexes for validation and WAL naming, but holds no rows: every row read or write fails loudly so a missed dispatch can never fork a second property truth beside the CSR value column.

pub fn is_inline_stub(&self) -> bool

Whether this store is a schema-only inline stub.

pub fn column_name_by_prop_id(&self, prop_id: i32) -> Option<&str>

Column name for one stable identifier, if the column exists.

pub fn clear_dirty_columns(&mut self)

Clear per-column dirt after a successful checkpoint.

pub fn property_schema(&self) -> &[PropertySchema]

pub fn has_property(&self, name: &str) -> bool

pub fn get_property_id(&self, name: &str) -> Option<PropertyId>

pub fn add_property( &mut self, name: String, data_type: DataType, nullable: bool, ) -> Result<PropertyId, StorageError>

pub fn remove_property(&mut self, name: &str) -> Result<(), StorageError>

pub fn column_cloned(&self, name: &str) -> Option<Column>

Clone one physical column for the staged drop snapshot.

pub fn has_column_dirt(&self, name: &str) -> bool

Whether one column holds unrefreshed writes.

pub fn dirty_column_names(&self) -> Vec<Arc<str>>

Names of columns mutated since the last checkpoint. Drives dirty-column incremental persistence: clean columns reuse the last flushed encoding instead of paying re-export and re-encode.

pub fn restore_property_at( &mut self, index: usize, schema: PropertySchema, column: Column, had_column_dirt: bool, )

Put back a column removed by a failed drop publish at its exact schema position, restoring its dirt mark when it had one.

pub fn rename_property( &mut self, old_name: &str, new_name: &str, ) -> Result<(), StorageError>

pub fn backfill_column( &mut self, column: &str, default: &Value, ) -> Result<(), StorageError>

Backfill one column with a default value on every existing row.

Used by the staged add-column fill step. Unknown columns are an explicit error; a single row failure aborts with the error.

pub fn restore_prop_ids(&mut self, ids: &HashMap<Arc<str>, i32>)

Restore stable column identifiers from shard payloads after a merge.

Shard dumps carry the flushed identifiers; the fresh merge target starts from dense indexes, so identifiers are re-applied here to keep undo parameters keyed by id valid across checkpoints. Unknown names are skipped. The allocator moves past the maximum restored id.

pub fn prop_id_of(&self, name: &str) -> Option<i32>

Stable identifier for one column in this shard, if present.

impl CsrWithProperties

pub fn export_row( &self, edge_id: EdgeId, ) -> Option<(u64, Option<u64>, Vec<(Arc<str>, Option<Value>)>)>

Export one edge row for per-group property sharding.

Returns the row visibility plus current values for every schema column (nulls as None). Unknown edges yield None. The export carries plain values only; version history stays memory-only and is collapsed on checkpoint, matching the whole-file dump contract.

pub fn import_row( &mut self, edge_id: EdgeId, create_ts: u64, delete_ts: Option<u64>, values: &[(Arc<str>, Option<Value>)], ) -> Result<(), StorageError>

Import one exported row into this store for shard merge.

Unknown columns in values are skipped so shards written under an older published schema still merge; missing columns keep their defaults via the fresh insert path. Nulls are materialized explicitly so a shard null never becomes a default on merge.

impl CsrWithProperties

pub fn mark_deleted(&mut self, edge_id: EdgeId, ts: u64) -> bool

pub fn revert_deletion_at_row(&mut self, row_idx: usize) -> bool

pub fn revert_deletion_for_edge(&mut self, edge_id: EdgeId) -> bool

impl CsrWithProperties

pub fn insert_for_edge( &mut self, edge_id: EdgeId, values: &[(Arc<str>, Value)], create_ts: u64, ) -> Result<(), StorageError>

Insert properties for an edge and associate the row with edge_id.

pub fn insert_for_edge_at( &mut self, edge_id: EdgeId, positioned: &[(usize, Value)], create_ts: u64, ) -> Result<(), StorageError>

Insert properties for an edge from pre-resolved column positions.

Hot write-path entry: the caller resolved every column once through the schema index, so this performs no name lookup, string clone or string comparison per edge. Positions must be store column positions; out-of-range entries fail loudly through allocate_row_at.

pub fn set_property_for_edge( &mut self, edge_id: EdgeId, name: &str, value: Option<Value>, ts: u64, ) -> Result<(), StorageError>

Edge-aware property update: lookup row via edge_id.

pub fn set_property_by_id_for_edge( &mut self, edge_id: EdgeId, prop_id: PropertyId, value: Option<Value>, ts: u64, ) -> Result<(), StorageError>

pub fn set_property_at_row( &mut self, row_idx: usize, name: &str, value: Option<Value>, ts: u64, ) -> Result<(), StorageError>

Trait Implementations

impl Clone for CsrWithProperties

fn clone(&self) -> CsrWithProperties

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CsrWithProperties

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

Formats the value using the given formatter.