Struct Table 

pub struct Table<T, E>
where
    T: TableSource,
    E: Entity<T::Value>,
{ /* private fields */ }

Implementations

impl<T: TableSource, E: Entity<T::Value>> Table<T, E>

pub fn new(table_name: impl Into<String>, data_source: T) -> Self

Create a new Table with the given table name and data source

pub fn into_entity<E2: Entity<T::Value>>(self) -> Table<T, E2>

Convert this table to use a different entity type

pub fn with<F>(self, func: F) -> Self

where F: FnOnce(&mut Self),

Use a callback with a builder pattern for configuration

pub fn table_name(&self) -> &str

Get the table name

pub fn data_source(&self) -> &T

Get the underlying data source

pub fn title_field(&self) -> Option<&T::Column<T::AnyType>>

Get the title field column if set

pub fn title_fields(&self) -> &[String]

Names of columns marked as display titles (set via Self::with_title_column_of). These show alongside the id in list views and on the leading lines of single-record displays.

pub fn id_field(&self) -> Option<&T::Column<T::AnyType>>

Get the id field column if set

pub fn pagination(&self) -> Option<&Pagination>

Get the current pagination configuration, if set

impl<T: TableSource, E: Entity<T::Value>> Table<T, E>

pub fn add_column<NewColumnType>(&mut self, column: T::Column<NewColumnType>)

where NewColumnType: ColumnType,

Add a column to the table (accepts any typed column, converts to Column<AnyType>)

pub fn with_column<NewColumnType>( self, column: T::Column<NewColumnType>, ) -> Self

where NewColumnType: ColumnType,

Add a column using builder pattern

pub fn add_column_of<NewColumnType>(&mut self, name: impl Into<String>)

where NewColumnType: ColumnType,

Add a typed column to the table (mutable)

pub fn with_id_column(self, name: impl Into<String>) -> Self

where T::Id: ColumnType,

Add an ID column — sets both the column and the id_field flag.

pub fn with_title_column_of<NewColumnType>( self, name: impl Into<String>, ) -> Self

where NewColumnType: ColumnType,

Add a typed column AND mark it as a display title.

Title columns show alongside the id in generic list views and lead the body of single-record displays. Multiple title columns are allowed; their order matches the order of these calls.

pub fn with_column_of<NewColumnType>(self, name: impl Into<String>) -> Self

where NewColumnType: ColumnType,

Add a typed column to the table (builder pattern)

pub fn columns(&self) -> &IndexMap<String, T::Column<T::AnyType>>

Get all columns as type-erased columns (Column<AnyType>)

pub fn get_column<Type>(&self, name: &str) -> Option<T::Column<Type>>

where Type: ColumnType,

Get a typed column by converting from stored Column<AnyType>

pub fn get_column_expr(&self, name: &str) -> Option<Expression<T::Value>>

where T::Column<T::AnyType>: Expressive<T::Value>,

Get an expression for a column or computed expression by name.

If name matches a registered expression (from with_expression), evaluates and returns it. Otherwise returns the column as an expression. Returns None if the name doesn’t match either.

impl<T, E> Table<T, E>

where T: TableSource + ExprDataSource<T::Value>, E: Entity<T::Value> + 'static,

pub fn column_values_expr(&self, column_name: &str) -> Expression<T::Value>

Expression yielding all values of the named column under the table’s current conditions.

SQL backends materialise this as a SELECT col FROM tbl WHERE … subquery (embeddable directly into IN clauses); non-query backends wrap a DeferredFn that runs list_table_values and projects the column at execute time.

Panics if column_name isn’t a column on this table — the callsite is meant to be a literal column reference, so a typo is a programmer error, not a runtime failure mode worth surfacing as Result.

impl<T: TableSource, E: Entity<T::Value>> Table<T, E>

pub fn add_condition(&mut self, condition: impl Into<T::Condition>)

Add a permanent condition to limit what records the table represents

pub fn temp_add_condition( &mut self, condition: impl Into<T::Condition>, ) -> ConditionHandle

Add a temporary condition that can be removed later

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

Remove a temporary condition by its handle

pub fn conditions(&self) -> impl Iterator<Item = &T::Condition>

Get all conditions

pub fn with_condition(self, condition: impl Into<T::Condition>) -> Self

Add a condition using the builder pattern

pub fn add_search(&mut self, value: &str)

where T: Sized,

Add a search condition that matches value across all columns.

pub fn with_search(self, value: &str) -> Self

where T: Sized,

Add a search condition using the builder pattern.

impl<T, E> Table<T, E>

where T: TableSource + ExprDataSource<T::Value> + TableExprSource, E: Entity<T::Value>,

pub fn get_expr_count(&self) -> AssociatedExpression<'_, T, T::Value, usize>

where T::Value: From<String>,

Get an expression for counting rows in this table Returns an AssociatedExpression that can be executed or composed

pub fn get_expr_sum<R: ColumnType + Default + AddAssign>( &self, column: &T::Column<R>, ) -> AssociatedExpression<'_, T, T::Value, R>

Get an expression for the sum of a column Returns an AssociatedExpression that can be executed or composed

pub fn get_expr_max<R: ColumnType + Default + AddAssign>( &self, column: &T::Column<R>, ) -> AssociatedExpression<'_, T, T::Value, R>

Get an expression for the maximum value of a column Returns an AssociatedExpression that can be executed or composed

pub fn get_expr_min<R: ColumnType + Default + AddAssign>( &self, column: &T::Column<R>, ) -> AssociatedExpression<'_, T, T::Value, R>

Get an expression for the minimum value of a column Returns an AssociatedExpression that can be executed or composed

impl<T: TableSource, E: Entity<T::Value>> Table<T, E>

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

Set pagination configuration

impl<T: TableSource + 'static, E: Entity<T::Value> + 'static> Table<T, E>

pub fn with_one<E2: Entity<T::Value> + 'static>( self, relation: &str, foreign_key: &str, build_target: impl Fn(T) -> Table<T, E2> + Send + Sync + 'static, ) -> Self

where T::Value: Into<Value> + From<Value>, T::Id: Display + From<String>,

Define a one-to-one relationship.

.with_one("bakery", "bakery_id", Bakery::postgres_table)

pub fn with_many<E2: Entity<T::Value> + 'static>( self, relation: &str, foreign_key: &str, build_target: impl Fn(T) -> Table<T, E2> + Send + Sync + 'static, ) -> Self

where T::Value: Into<Value> + From<Value>, T::Id: Display + From<String>,

Define a one-to-many relationship.

.with_many("orders", "client_id", Order::postgres_table)

pub fn with_foreign( self, relation: &str, target_type: &'static str, resolve: impl Fn(&Table<T, E>) -> Result<AnyTable> + Send + Sync + 'static, ) -> Self

Define a cross-persistence reference.

The closure receives this table and returns an AnyTable from any backend with deferred conditions attached.

.with_foreign("mongo_orders", "Table<MongoDB, Order>", |clients| {
    let mut orders = Order::mongo_table(mongo_db.clone());
    // attach deferred condition ...
    Ok(AnyTable::from_table(orders))
})

pub fn references(&self) -> Vec<String>

pub fn is_foreign_ref(&self, relation: &str) -> Result<bool>

Check if a reference is cross-persistence (foreign).

pub fn get_ref_as<E2: Entity<T::Value> + 'static>( &self, relation: &str, ) -> Result<Table<T, E2>>

Get a same-backend related table with automatic downcasting.

For foreign references, use get_ref() instead.

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

Get a related table as AnyTable — works for both same-backend and foreign refs.

pub fn get_subquery_as<E2: Entity<T::Value> + 'static>( &self, relation: &str, ) -> Result<Table<T, E2>>

Get a correlated related table for use inside SELECT expressions.

Unlike get_ref_as (which uses IN (subquery)), this produces a correlated condition like order.client_id = client.id, suitable for embedding as a subquery in a SELECT clause.

pub fn with_expression( self, name: &str, expr_fn: impl Fn(&Table<T, E>) -> Expression<T::Value> + Send + Sync + 'static, ) -> Self

Add a computed expression field using builder pattern.

The closure receives &Table<T, E> and returns an Expression<T::Value>. It is evaluated lazily when select() builds the query.

.with_expression("order_count", |t| {
    t.get_subquery_as::<Order>("orders").unwrap().get_count_query()
})

impl<T, E> Table<T, E>

where T: SelectableDataSource<T::Value, T::Condition> + TableSource, T::Value: From<String>, E: Entity<T::Value>,

pub fn select_empty(&self) -> T::Select

Create a bare select with source, conditions, ordering, and pagination — but no fields. Used by select_column and aggregates to avoid evaluating all expressions.

pub fn select(&self) -> T::Select

Create a select query with table configuration applied

pub async fn get_count(&self) -> Result<i64>

Get count of records in the table

pub async fn get_sum(&self, column: &T::Column<T::AnyType>) -> Result<T::Value>

Get sum of a column in the table

pub async fn get_max(&self, column: &T::Column<T::AnyType>) -> Result<T::Value>

Get max of a column in the table

pub async fn get_min(&self, column: &T::Column<T::AnyType>) -> Result<T::Value>

Get min of a column in the table

pub fn get_count_query(&self) -> Expression<T::Value>

Create a count query expression (does not execute). The result is wrapped in parentheses so it’s safe to nest as a subquery.

pub fn get_sum_query<Type>( &self, column: &T::Column<Type>, ) -> Expression<T::Value>

where Type: ColumnType, T::Column<Type>: Expressive<T::Value>,

Create a sum query expression for a column (does not execute). The result is wrapped in parentheses so it’s safe to nest as a subquery.

pub fn select_column(&self, field: &str) -> Expression<T::Value>

where T::Column<T::AnyType>: Expressive<T::Value>, T::Select: Expressive<T::Value>,

Create a subquery expression that selects a single column from this table.

Builds SELECT field FROM table WHERE conditions — useful as a correlated subquery inside with_expression:

.with_expression("category", |t| {
    t.get_subquery_as::<Category>("category").unwrap()
        .select_column("name")
})

impl<T, E> Table<T, E>

where T: SelectableDataSource<Value, T::Condition> + TableSource<Value = Value> + ExprDataSource<Value>, T::Value: From<String>, E: Entity<Value>,

pub async fn get_count_via_query(&self) -> Result<i64>

Get count using QuerySource for serde_json::Value

impl<T: TableSource, E: Entity<T::Value>> Table<T, E>

pub fn add_order(&mut self, order: OrderBy<T::Condition>)

Add a permanent order clause

pub fn temp_add_order(&mut self, order: OrderBy<T::Condition>) -> OrderHandle

Add a temporary order clause that can be removed later

pub fn temp_remove_order(&mut self, handle: OrderHandle) -> Result<()>

Remove a temporary order clause by its handle

Errors

Returns error if the handle refers to a permanent order (added via add_order)

pub fn orders(&self) -> impl Iterator<Item = &(T::Condition, SortDirection)>

Get all order clauses

pub fn with_order(self, order: OrderBy<T::Condition>) -> Self

Add an order clause using the builder pattern

impl<T, E> Table<T, E>

where T: TableSource, E: Entity<T::Value>,

pub fn stream( &self, ) -> Pin<Box<dyn Stream<Item = Result<(T::Id, E)>> + Send + '_>>

Stream all entities as (Id, Entity) pairs.

Delegates to stream_table_values on the data source, converting each record to the entity type. Backends with native streaming (e.g. paginated REST APIs) yield records incrementally.

Trait Implementations

impl<T, E> Clone for Table<T, E>

where T: TableSource + Clone, E: Entity<T::Value> + Clone, T::Column<T::AnyType>: Clone, T::AnyType: Clone, T::Condition: Clone,

fn clone(&self) -> Table<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: TableSource, E: Entity<T::Value>> Debug for Table<T, E>

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

Formats the value using the given formatter.

impl<T: TableSource, E: Entity<T::Value>> Index<&str> for Table<T, E>

type Output = <T as TableSource>::Column<<T as TableSource>::AnyType>

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, E> InsertableDataSet<E> for Table<T, E>

where T: TableSource, E: Entity<T::Value>,

fn insert_return_id<'life0, 'life1, 'async_trait>( &'life0 self, entity: &'life1 E, ) -> Pin<Box<dyn Future<Output = Result<Self::Id>> + Send + 'async_trait>>

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

Insert an entity and return the generated ID.

impl<T: TableSource, E: Entity<T::Value>> InsertableValueSet for Table<T, E>

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

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

Insert a value and return the generated ID (Similar to HTTP POST without ID)

impl<T, E> ReadableDataSet<E> for Table<T, E>

where T: TableSource, E: Entity<T::Value>,

fn list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<Self::Id, E>>> + Send + 'async_trait>>

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

Retrieve all entities with their IDs.

fn get<'life0, 'async_trait>( &'life0 self, id: impl 'async_trait + Into<Self::Id> + Send, ) -> Pin<Box<dyn Future<Output = Result<Option<E>>> + Send + 'async_trait>>

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

Retrieve a specific entity by ID.

fn get_some<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<(Self::Id, E)>>> + Send + 'async_trait>>

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

Retrieve one single entity from the set. If entities are ordered - return first entity.

impl<T: TableSource, E: Entity<T::Value>> ReadableValueSet for Table<T, E>

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>)>> + Send + '_>>

Stream all records as (Id, Record) pairs.

impl<T, E> TableLike for Table<T, E>

where T: TableSource + Send + Sync + 'static, E: Send + Sync + Entity<T::Value> + 'static,

fn table_alias(&self) -> &str

fn table_name(&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<T: TableSource, E: Entity<T::Value>> ValueSet for Table<T, E>

type Id = <T as TableSource>::Id

Unique identifier type for records in this storage backend.

type Value = <T as TableSource>::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<T, E> WritableDataSet<E> for Table<T, E>

where T: TableSource, E: Entity<T::Value>,

fn insert<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 Self::Id, entity: &'life2 E, ) -> Pin<Box<dyn Future<Output = Result<E>> + Send + 'async_trait>>

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

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

fn replace<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 Self::Id, entity: &'life2 E, ) -> Pin<Box<dyn Future<Output = Result<E>> + Send + 'async_trait>>

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

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

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

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

Partially update an entity by merging with the provided data (HTTP PATCH)

impl<T: TableSource, E: Entity<T::Value>> WritableValueSet for Table<T, E>

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)

impl<T: TableSource, E: Entity<T::Value>> DataSet<E> for Table<T, E>