Struct AnyTable 

pub struct AnyTable { /* private fields */ }

Type-erased table that can be downcast to concrete Table<T, E> Works with AnyRecord (which uses ciborium::Value)

Implementations

impl AnyTable

pub fn new<T: TableSource<Value = CborValue, Id = String> + 'static, E: Entity<CborValue> + 'static>( table: Table<T, E>, ) -> Self

Create a new AnyTable from a concrete table. Only works with tables that use ciborium::Value as their Value type.

pub fn from_table<T, E>(table: Table<T, E>) -> Self

where T: TableSource + 'static, T::Value: Into<CborValue> + From<CborValue>, T::Id: Display + From<String>, E: Entity<T::Value> + 'static,

Create an AnyTable from a table with any value/id types that convert to/from CBOR.

This wraps the table in an internal adapter that converts values on the fly, so any TableSource can be used with the unified AnyTable interface.

pub fn from_table_like<T>(table: T) -> Self

where T: TableLike<Value = CborValue, Id = String> + 'static,

Wrap any TableLike<Value = CborValue, Id = String> directly. Use this for table-like wrappers (e.g. vantage_live::LiveTable) that aren’t a Table<T, E> instance themselves but already satisfy the AnyTable-facing trait surface. The entity type is recorded as () since wrappers don’t carry one.

pub fn downcast<T: TableSource<Value = CborValue, Id = String> + 'static, E: Entity<CborValue> + 'static>( self, ) -> Result<Table<T, E>>

Attempt to downcast to a concrete Table<T, E>

Returns Err(self) if the type doesn’t match, allowing recovery

pub fn datasource_name(&self) -> &str

Get the datasource type name for debugging

pub fn entity_name(&self) -> &str

Get the entity type name for debugging

pub fn datasource_type_id(&self) -> TypeId

Get the datasource TypeId

pub fn entity_type_id(&self) -> TypeId

Get the entity TypeId

pub fn is_type<T: TableSource + 'static, E: Entity<CborValue> + 'static>( &self, ) -> bool

Check if this table matches the given types

impl AnyTable

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

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

Inherent wrapper so callers don’t need use TableLike in scope.

pub fn with_pagination<F>(&mut self, func: F)

where F: FnOnce(&mut Pagination),

Configure pagination using a callback

Trait Implementations

impl Clone for AnyTable

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AnyTable

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

Formats the value using the given formatter.

impl ReadableValueSet for AnyTable

fn list_values<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<Self::Id, Record<Self::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::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<Self::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::Id, Record<Self::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 AnyTable

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 add_condition_eq(&mut self, field: &str, value: &str) -> Result<()>

Add a permanent equality condition expressed as raw strings.

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.

impl ValueSet for AnyTable

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 AnyTable

fn insert_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 Self::Id, record: &'life2 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::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::Id, record: &'life2 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::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::Id, partial: &'life2 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::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::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)