Struct LiveTable 

pub struct LiveTable { /* private fields */ }

Implementations

impl LiveTable

pub fn new( master: AnyTable, cache_key: impl Into<String>, cache: Arc<dyn Cache>, ) -> Self

Build a LiveTable around master, caching results under cache_key. The worker task is spawned on the current tokio runtime; call this from within an async context.

pub fn with_master_ipp(self, ipp: i64) -> Self

Set the master’s max items-per-page hint. Stored, not enforced in v1 (caller is responsible for keeping UI ipp at or below).

pub fn with_custom_write_target(self, target: AnyTable) -> Self

Route writes to a different table than the master. Reads stay on the master; only writes are diverted. Setting this rebuilds the worker so it picks up the new target.

pub fn with_live_stream(self, stream: Arc<dyn LiveStream>) -> Self

Attach a live event source. Spawns a background task that subscribes to the stream and invalidates the cache on every event (sloppy invalidation — see DESIGN.md).

pub fn page_cache_key(&self, page: i64) -> String

The cache key used for a given page number. Public for observability / debugging — there’s no production reason to call this from outside the crate.

pub fn id_cache_key(&self, id: &str) -> String

The cache key used for a single-row get_value lookup.

Trait Implementations

impl Clone for LiveTable

fn clone(&self) -> LiveTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LiveTable

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

Formats the value using the given formatter.

impl ReadableValueSet for LiveTable

fn list_values<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<<Self as ValueSet>::Id, Record<<Self as ValueSet>::Value>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve all records as raw storage values preserving insertion order where supported.

fn get_value<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 <Self as ValueSet>::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<<Self as ValueSet>::Value>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a specific record by ID as a structured record.

fn get_some_value<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<(<Self as ValueSet>::Id, Record<<Self as ValueSet>::Value>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve one single record from the set. If records are ordered - return first record. will return Ok(None).

fn stream_values( &self, ) -> Pin<Box<dyn Stream<Item = Result<(Self::Id, Record<Self::Value>), VantageError>> + Send + '_>>

where Self: Sync,

Stream all records as (Id, Record) pairs.

impl TableLike for LiveTable

fn table_name(&self) -> &str

fn table_alias(&self) -> &str

fn column_names(&self) -> Vec<String>

fn id_field_name(&self) -> Option<String>

Name of the column flagged as the id field, if any.

fn title_field_names(&self) -> Vec<String>

Names of columns flagged as TitleField.

fn column_types(&self) -> IndexMap<String, &'static str>

Map of column name -> original Rust type name. Backends that preserve type metadata (e.g. Column::get_type()) override this so generic UIs can drive type-aware rendering without poking at concrete column types.

fn get_ref_names(&self) -> Vec<String>

Names of relations traversable via get_ref.

fn add_condition( &mut self, _condition: Box<dyn Any + Send + Sync>, ) -> Result<()>

Add a condition to this table using a type-erased expression The expression must be of type T::Expr for the underlying table’s TableSource

fn temp_add_condition( &mut self, _condition: AnyExpression, ) -> Result<ConditionHandle>

Add a temporary condition using AnyExpression that can be removed later

fn temp_remove_condition(&mut self, _handle: ConditionHandle) -> Result<()>

Remove a temporary condition by its handle

fn search_expression(&self, search_value: &str) -> Result<AnyExpression>

Create a search expression for this table

fn clone_box(&self) -> Box<dyn TableLike<Value = Self::Value, Id = Self::Id>>

Clone into a Box for object-safe cloning

fn into_any(self: Box<Self>) -> Box<dyn Any>

Convert to Any for downcasting

fn as_any_ref(&self) -> &dyn Any

fn set_pagination(&mut self, pagination: Option<Pagination>)

Set pagination for this table

fn get_pagination(&self) -> Option<&Pagination>

Get pagination for this table

fn get_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get count of records in the table

fn get_ref(&self, relation: &str) -> Result<AnyTable>

Traverse a named reference and return the related table as AnyTable.

fn set_table_name(&mut self, _name: String)

Override the table name. Default is a no-op for backends that don’t honor it; the REST API driver overrides it to swap a canonical endpoint for a per-reference URI template at traversal time.

fn add_condition_eq( &mut self, field: &str, value: &str, ) -> Result<(), VantageError>

Add a permanent equality condition expressed as raw strings.

impl ValueSet for LiveTable

type Id = String

Unique identifier type for records in this storage backend.

type Value = Value

Raw storage value type, representing data as stored in the backend, like serde_json::Value or cborium::Value. Can also be a custom type.

impl WritableValueSet for LiveTable

fn insert_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 <Self as ValueSet>::Id, record: &'life2 Record<<Self as ValueSet>::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<<Self as ValueSet>::Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert value with a specific ID (often generated) (HTTP POST with ID)

fn replace_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 <Self as ValueSet>::Id, record: &'life2 Record<<Self as ValueSet>::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<<Self as ValueSet>::Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Replace the entire record at the specified ID (HTTP PUT)

fn patch_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 <Self as ValueSet>::Id, partial: &'life2 Record<<Self as ValueSet>::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<<Self as ValueSet>::Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Partially update a record by merging with the provided value (HTTP PATCH)

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 <Self as ValueSet>::Id, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a record by ID (HTTP DELETE)

fn delete_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete all records in the set (HTTP DELETE without ID)