Struct GraphqlApiTableShell 

pub struct GraphqlApiTableShell { /* private fields */ }

The TableShell behind a GraphQL-backed Vista: an erased Table<GraphqlApi, EmptyEntity> plus the metadata and capabilities the factory harvested. Built by GraphqlApiVistaFactory; callers drive it through the Vista it is wrapped in.

Trait Implementations

impl Clone for GraphqlApiTableShell

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl TableShell for GraphqlApiTableShell

fn preview(&self) -> Preview

GraphqlSelect::preview is the synchronous renderer: it produces the real document, and spells out any condition whose value is only known at fetch time rather than resolving it. The executed form differs only in those deferred branches. The document is posted to the endpoint named on the first line.

fn fetch_window<'life0, 'async_trait>( &'life0 self, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Page>> + Send + 'async_trait>>

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

limit:/offset: on a clone of the table, when the root field takes them and conditions reach the server. A GraphQL list reports no total, so the page carries none. Otherwise the leading window is cut from the listing.

fn rebind(&self, _tx: &Transaction) -> Result<Box<dyn TableShell>>

A GraphQL API has no transactions: inside one, the shell works as it does outside.

fn metadata(&self) -> &VistaMetadata

The set’s columns, references and id column. Vista reads its metadata vocabulary (columns, column, id_column, …) from here.

fn capabilities(&self) -> &VistaCapabilities

fn driver_name(&self) -> &'static str

Short label for the driver ("csv", "sqlite", "mongodb").

fn list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<String, Record<CborValue>>>> + Send + 'async_trait>>

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

Every row of the set, keyed by id, in the set’s order.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<CborValue>>>> + Send + 'async_trait>>

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

Row id when it is in the set.

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

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

fn add_condition(&mut self, condition: &Condition) -> Result<()>

Narrow the set by condition. Every shell takes equality; Vista refuses other operators unless the shell advertises FilterOps. An unknown column or a bad value is a normal error, not Unsupported.

fn set_search(&mut self, text: Option<&str>) -> Result<()>

Replace the quicksearch text; None clears it (Search). Quicksearch reads the columns flagged Searchable, or every column when none is (VistaMetadata::search_columns); a shell may exclude columns it can’t filter on (dotted paths, imported columns). Text the backend can’t express is a normal error, not Unsupported.

fn set_order(&mut self, order: Option<(&str, SortDirection)>) -> Result<()>

Replace the order; None clears it (Order). An unknown column is a normal error, not Unsupported.

fn get_ref( &self, relation: &str, row: Option<&Record<CborValue>>, ) -> Result<Vista>

The target of relation (Traverse): with a parent row (from this shell’s set), the related rows; with None, the bare target a new related row is inserted into. Contained relations route through here too: from a row, the records it embeds; with None, the contained schema with no records and no write capabilities, since there is no parent row to write into.

fn fetch_cursor<'life0, 'async_trait>( &'life0 self, _token: Option<Value>, _limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(Page, Option<Value>), VantageError>> + Send + 'async_trait>>

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

Up to limit rows after token (None starts at the beginning) and the token for the next call, None once the set is exhausted (Cursor). The token is driver-private; callers hand it back unchanged. Vista refuses the call without Cursor before the shell is called.

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

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

Subscribe to changes on the set (Subscribe).

fn add_native_condition( &mut self, _condition: NativeCondition, ) -> Result<(), VantageError>

Narrow the set by a condition in the driver’s own type (NativeConditions). A condition of a type the driver doesn’t take is an IncorrectUsage error.

fn insert<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: Option<&'life1 str>, _record: &'life2 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<(String, Record<Value>), VantageError>> + Send + 'async_trait>>

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

Insert record as row id, or under an id the backend makes when id is None (not retry-safe). Returns the id and the stored row. An id already in the set returns the stored row untouched; an id held outside the set is Conflict; a new row is conformed to the set’s equality conditions.

fn replace<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: &'life1 str, _record: &'life2 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

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

Replace row id, creating it when missing; an id held outside the set is Conflict.

fn upsert<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: &'life1 str, _record: &'life2 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

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

Insert row id, or replace it when it exists, in one operation.

fn patch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: &'life1 str, _partial: &'life2 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

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

Merge partial into row id. A row outside the set or missing is NotFound; a result that leaves the set is Conflict.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), VantageError>> + Send + 'async_trait>>

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

Remove row id when it is in the set; Ok whether it was in the set, outside it, or missing.

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

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

Remove exactly the rows in the set.

fn import<'life0, 'life1, 'async_trait>( &'life0 self, _rows: &'life1 IndexMap<String, Record<Value>>, ) -> Pin<Box<dyn Future<Output = Result<usize, VantageError>> + Send + 'async_trait>>

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

Store rows in one all-or-nothing, driver-native operation and return how many were newly inserted; an id already held counts zero (Import). A driver that can’t make the batch atomic, or can’t tell new rows from existing ones, doesn’t advertise Import; callers then insert row by row.

fn set_lock(&mut self) -> Result<(), VantageError>

Lock the rows the next reads return until the transaction ends (Vista::lock). There is no capability for it: the default refuses.