Struct AnyTable 

pub struct AnyTable { /* private fields */ }

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

Implementations

impl AnyTable

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

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

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

where T: TableSource + 'static, T::Value: Into<Value> + From<Value>, 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 JSON.

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 downcast<T: TableSource<Value = Value, Id = String> + 'static, E: Entity<Value> + '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<Value> + 'static>( &self, ) -> bool

Check if this table matches the given types

impl AnyTable

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 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

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)