Struct Table 

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

Implementations

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

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

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

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

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

where E2: Entity<<T as TableSource>::Value>,

Convert this table to use a different entity type

pub fn vista_references(&self) -> Vec<Reference>

Snapshot the table’s relations as Vista references (name, target type, cardinality, foreign key). Driver factories fold this into VistaMetadata so the erased Vista carries enough to drive nested insert and relation traversal.

pub fn vista_contained(&self) -> Vec<ContainedSpec>

Shape-only specs (name, host, kind, id) for the contained relations declared on this table, for driver factories to fold into VistaMetadata. Columns are derived at traversal from each relation’s build_target closure.

pub fn contained_relation(&self, name: &str) -> Option<&ContainedRelation<T>>

Look up a contained relation by name (for the driver’s traversal).

pub fn with<F>(self, func: F) -> Table<T, E>

where F: FnOnce(&mut Table<T, E>),

Use a callback with a builder pattern for configuration

pub fn table_name(&self) -> &str

Get the table name

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

Override the table name. Used by REST API drivers to swap a canonical resource path for a per-reference URI template at traversal time.

pub fn data_source(&self) -> &T

Get the underlying data source

pub fn title_field( &self, ) -> Option<&<T as TableSource>::Column<<T as TableSource>::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 as TableSource>::Column<<T as TableSource>::AnyType>>

Get the id field column if set

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

Mark an already-added column as the id field.

Use this when the id column has been added via Self::add_column (so its type and aliases were chosen explicitly) and you only need to flag it. Self::with_id_column is the typed shortcut that creates the column for you.

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

Mark an already-added column as a display title.

Companion to Self::set_id_field for spec-driven construction.

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

Get the current pagination configuration, if set

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

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

pub fn add_column<NewColumnType>( &mut self, column: <T as TableSource>::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 as TableSource>::Column<NewColumnType>, ) -> Table<T, E>

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>) -> Table<T, E>

where <T as TableSource>::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>, ) -> Table<T, E>

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>, ) -> Table<T, E>

where NewColumnType: ColumnType,

Add a typed column to the table (builder pattern)

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

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

pub fn get_column<Type>( &self, name: &str, ) -> Option<<T as TableSource>::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 as TableSource>::Value>>

where <T as TableSource>::Column<<T as TableSource>::AnyType>: Expressive<<T as TableSource>::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 as TableSource>::Value>, E: Entity<<T as TableSource>::Value> + 'static,

pub fn column_values_expr( &self, column_name: &str, ) -> Expression<<T as TableSource>::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, E> Table<T, E>

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

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

Add a permanent condition to limit what records the table represents

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

Add a temporary condition that can be removed later

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

Remove a temporary condition by its handle

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

Get all conditions

pub fn with_condition( self, condition: impl Into<<T as TableSource>::Condition>, ) -> Table<T, E>

Add a condition using the builder pattern

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

Add a search condition that matches value across all columns.

pub fn with_search(self, value: &str) -> Table<T, E>

Add a search condition using the builder pattern.

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

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

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

where <T as TableSource>::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>( &self, column: &<T as TableSource>::Column<R>, ) -> AssociatedExpression<'_, T, <T as TableSource>::Value, R>

where R: ColumnType + Default + AddAssign,

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

pub fn get_expr_max<R>( &self, column: &<T as TableSource>::Column<R>, ) -> AssociatedExpression<'_, T, <T as TableSource>::Value, R>

where R: ColumnType + Default + AddAssign,

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>( &self, column: &<T as TableSource>::Column<R>, ) -> AssociatedExpression<'_, T, <T as TableSource>::Value, R>

where R: ColumnType + Default + AddAssign,

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

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

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

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

Set pagination configuration

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

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

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

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

Define a one-to-one relationship.

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

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

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

Define a one-to-many relationship.

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

pub fn with_contained_one( self, relation: &str, host_column: &str, build_target: impl Fn(T) -> Table<T, EmptyEntity> + Send + Sync + 'static, ) -> Table<T, E>

Declare a contains_one relation: a single record embedded in host_column (e.g. a product’s inventory object), surfaced as a sub-Vista. build_target builds the contained record’s table — the same closure shape as with_one.

.with_contained_one("inventory", "inventory", |db| {
    Table::new("inventory", db).with_column_of::<i64>("stock")
})

pub fn with_contained_many( self, relation: &str, host_column: &str, build_target: impl Fn(T) -> Table<T, EmptyEntity> + Send + Sync + 'static, id_column: Option<&str>, ) -> Table<T, E>

Declare a contains_many relation: an array of records embedded in host_column (e.g. an order’s lines). build_target builds the contained record’s table; id_column names the field used as each record’s id (None → positional index).

.with_contained_many("lines", "lines", |db| {
    Table::new("lines", db)
        .with_column_of::<Thing>("product")
        .with_column_of::<i64>("quantity")
}, None)

pub fn vista_columns(&self) -> Vec<Column>

where <T as TableSource>::Column<<T as TableSource>::AnyType>: ColumnLike<<T as TableSource>::AnyType>,

Harvest this table’s columns as Vista columns (name + declared type, hidden flag). Used to give a contained sub-Vista its schema.

pub fn get_contained_ref( &self, relation: &str, row: &Record<Value>, parent_id: <T as TableSource>::Id, wrap: impl Fn(Table<T, EmptyEntity>) -> Result<Vista, VantageError> + Send + Sync + 'static, decode_host: impl Fn(&Value) -> Option<Value>, encode_host: impl Fn(Value) -> Value + Send + Sync + 'static, ) -> Result<Vista, VantageError>

where <T as TableSource>::Value: From<Value> + Send + Sync, <T as TableSource>::Id: Clone + Send + Sync, <T as TableSource>::Column<<T as TableSource>::AnyType>: ColumnLike<<T as TableSource>::AnyType>,

Resolve a contained relation embedded in row into a sub-Vista.

This is the backend-agnostic skeleton every driver shares: seed the embedded records, wire the eager writeback (patch the host column on the parent row), and the traverse-out resolver. The driver supplies only the three things it alone knows:

• parent_id — the row’s id in the driver’s native id type;
• wrap — turn a target Table into a Vista via the driver’s factory (used when a contained record traverses out to a real table);
• decode_host / encode_host — the host-column codec: native passthrough, or JSON parse/serialize for backends without nested columns.

pub fn with_contained_specs<C>( self, specs: &IndexMap<String, ContainedYaml<C>>, build_col: impl Fn(&str, &ColumnSpec<C>) -> Result<<T as TableSource>::Column<<T as TableSource>::AnyType>, VantageError>, ) -> Result<Table<T, E>, VantageError>

where <T as TableSource>::Column<<T as TableSource>::AnyType>: Clone,

Lower a YAML contained: section into with_contained_* registrations, reusing the driver’s build_col to construct each contained record’s columns. Column-build errors surface here; the per-relation target closure stays infallible by cloning the pre-built columns.

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

pub fn with_id( self, id: impl Into<<T as TableSource>::Value>, ) -> Result<Table<T, E>, VantageError>

Narrow the table to a single row by id.

Pairs with get_some_value for the “I only know an id” workflow. The actual condition construction goes through TableSource::eq_value_condition, so backends that don’t yet implement that path return an error here.

pub fn get_ref_from_row<E2>( &self, relation: &str, row: &Record<<T as TableSource>::Value>, ) -> Result<Table<T, E2>, VantageError>

where E2: Entity<<T as TableSource>::Value> + 'static,

Traverse a same-persistence reference using a known source row as the join origin.

Reads the join field value out of row, builds the target table via the reference’s stored factory, and applies one eq-condition that selects the related rows. No subquery, no deferred fetch — row already carries the value.

HasOne reads from its stored foreign-key column; HasMany reads from the source’s id field (looked up here and forwarded into the reference). The returned table preserves columns, refs, and expressions from the reference’s factory; only the entity type changes if E2 differs from the factory’s output.

pub fn get_ref_as<E2>( &self, relation: &str, ) -> Result<Table<T, E2>, VantageError>

where E2: Entity<<T as TableSource>::Value> + 'static,

Traverse a same-backend relation into a typed Table<T, E2> with an IN (subquery) filter on the source column.

Use this when the parent table already carries the narrowing conditions (e.g. clients.add_condition(is_paying = true)) and you want every related child row matching that filter. For the “I have a specific row in hand” case, prefer Table::get_ref_from_row — it pushes a plain eq-condition instead of a subquery.

pub fn get_subquery_as<E2>( &self, relation: &str, ) -> Result<Table<T, E2>, VantageError>

where E2: Entity<<T as TableSource>::Value> + 'static,

Get a correlated related table for use inside SELECT expressions.

Unlike Self::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 via Self::with_expression.

pub fn get_ref_target<E2>( &self, relation: &str, ) -> Result<Table<T, E2>, VantageError>

where E2: Entity<<T as TableSource>::Value> + 'static,

Build the relation’s target table with no condition applied.

Unlike Self::get_ref_from_row / Self::get_ref_as (which select the related rows for a known parent), this returns the bare target — the table you’d insert a new related row into. Used by Vista’s nested insert to obtain the destination for a has-one/has-many child before any join value exists.

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

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.

pub fn ref_cardinality( &self, relation: &str, ) -> Result<ReferenceKind, VantageError>

Look up cardinality for a registered relation.

pub fn ref_kinds(&self) -> Vec<(String, ReferenceKind)>

List all registered relations with their cardinality.

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

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

pub fn select_empty( &self, ) -> <T as SelectableDataSource<<T as TableSource>::Value, <T as TableSource>::Condition>>::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 as SelectableDataSource<<T as TableSource>::Value, <T as TableSource>::Condition>>::Select

Create a select query with table configuration applied

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

Get count of records in the table

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

Get sum of a column in the table

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

Get max of a column in the table

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

Get min of a column in the table

pub fn get_count_query(&self) -> Expression<<T as TableSource>::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 as TableSource>::Column<Type>, ) -> Expression<<T as TableSource>::Value>

where Type: ColumnType, <T as TableSource>::Column<Type>: Expressive<<T as TableSource>::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 as TableSource>::Value>

where <T as TableSource>::Column<<T as TableSource>::AnyType>: Expressive<<T as TableSource>::Value>, <T as SelectableDataSource<<T as TableSource>::Value, <T as TableSource>::Condition>>::Select: Expressive<<T as TableSource>::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 as TableSource>::Condition> + TableSource<Value = Value> + ExprDataSource, <T as TableSource>::Value: From<String>, E: Entity,

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

Get count using QuerySource for serde_json::Value

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

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

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

Add a permanent order clause

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

Add a temporary order clause that can be removed later

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

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 as TableSource>::Condition, SortDirection)>

Get all order clauses

pub fn clear_orders(&mut self)

Drop every order clause — both permanent and temporary. Used by Vista to reset sort state under its replace-semantics add_order.

pub fn with_order( self, order: OrderBy<<T as TableSource>::Condition>, ) -> Table<T, E>

Add an order clause using the builder pattern

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

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

pub fn stream( &self, ) -> Pin<Box<dyn Stream<Item = Result<(<T as TableSource>::Id, E), VantageError>> + 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: Clone + TableSource, E: Clone + Entity<<T as TableSource>::Value>, <T as TableSource>::Column<<T as TableSource>::AnyType>: Clone, <T as TableSource>::AnyType: Clone, <T as TableSource>::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, E> Debug for Table<T, E>

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

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

Formats the value using the given formatter.

impl<T, E> Index<&str> for Table<T, E>

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

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

The returned type after indexing.

fn index(&self, index: &str) -> &<Table<T, E> as Index<&str>>::Output

Performs the indexing (container[index]) operation.

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

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, Table<T, E>: 'async_trait,

Insert an entity and return the generated ID.

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

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, Table<T, E>: '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 as TableSource>::Value>,

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

where 'life0: 'async_trait, Table<T, E>: 'async_trait,

Retrieve all entities with their IDs.

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

where 'life0: 'async_trait, Table<T, E>: 'async_trait,

Retrieve a specific entity by ID.

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

where 'life0: 'async_trait, Table<T, E>: 'async_trait,

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

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

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

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

where 'life0: 'async_trait, Table<T, E>: '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 <Table<T, E> as ValueSet>::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<<Table<T, E> as ValueSet>::Value>>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Table<T, E>: '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<(<Table<T, E> as ValueSet>::Id, Record<<Table<T, E> as ValueSet>::Value>)>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Table<T, E>: '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<(<Table<T, E> as ValueSet>::Id, Record<<Table<T, E> as ValueSet>::Value>), VantageError>> + Send + '_>>

Stream all records as (Id, Record) pairs.

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

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

fn table_alias(&self) -> &str

fn table_name(&self) -> &str

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 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 + Sync + Send>, ) -> Result<(), VantageError>

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<(), VantageError>

Add a permanent equality condition expressed as raw strings.

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

Add a temporary condition using AnyExpression that can be removed later

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

Remove a temporary condition by its handle

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

Create a search expression for this table

fn clone_box( &self, ) -> Box<dyn TableLike<Value = <Table<T, E> as ValueSet>::Value, Id = <Table<T, E> as ValueSet>::Id>>

Clone into a Box for object-safe cloning

fn into_any(self: Box<Table<T, E>>) -> Box<dyn Any>

Convert to Any for downcasting

fn as_any_ref(&self) -> &(dyn Any + 'static)

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, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Table<T, E>: 'async_trait,

Get count of records in the table

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

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

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 as TableSource>::Value>,

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

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: '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 <Table<T, E> as ValueSet>::Id, entity: &'life2 E, ) -> Pin<Box<dyn Future<Output = Result<E, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: 'async_trait,

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: 'async_trait,

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

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

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: '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 <Table<T, E> as ValueSet>::Id, record: &'life2 Record<<Table<T, E> as ValueSet>::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<<Table<T, E> as ValueSet>::Value>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: 'async_trait,

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Table<T, E>: 'async_trait,

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, Table<T, E>: 'async_trait,

Delete a record by ID (HTTP DELETE)

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

where 'life0: 'async_trait, Table<T, E>: 'async_trait,

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

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

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