Struct Cmd 

pub struct Cmd { /* private fields */ }

A command-execution datasource.

Cheap to clone (everything is Arc-backed). The command and env here are the locked defaults; individual tables can be registered with their own CmdSpec overrides via Cmd::with_table.

Implementations

impl Cmd

pub fn new(command: impl Into<Arc<str>>) -> Self

Build a datasource locked to command (e.g. "aws").

pub fn with_env(self, key: impl Into<String>, value: impl Into<String>) -> Self

Declare a datasource-level env var, passed to every table’s child process unless a table overrides it.

pub fn with_pass_path(self, pass_path: bool) -> Self

Whether to forward PATH/HOME from the current process so the command can be located. Defaults to true; set false to require an absolute command path and a fully-declared environment.

pub fn with_base_dir(self, base_dir: impl Into<PathBuf>) -> Self

Set the base directory used to resolve a relative command path and as the child process’s working directory.

A command that contains a path separator but isn’t absolute (e.g. ./scripts/gh-stats.py) is resolved against this directory; bare names (e.g. gh) are left untouched for PATH lookup, and absolute paths pass through. When set, every table’s child process also runs with this directory as its working directory, so a script can resolve sibling files relative to it.

pub fn with_script( self, name: impl Into<String>, script: impl Into<Arc<str>>, ) -> Self

Register a script under name with no overrides.

pub fn with_table(self, name: impl Into<String>, spec: CmdSpec) -> Self

Register a fully-specified CmdSpec under name.

pub fn command(&self) -> &str

The locked default command.

pub fn compile_count(&self, name: &str) -> usize

How many times the named script has been compiled. Reuse means this stays at 1 no matter how many reads run.

pub fn vista_factory(&self) -> CmdVistaFactory

A Vista factory bound to this datasource.

impl Cmd

pub async fn get_table_value_with_row<E>( &self, table: &Table<Self, E>, id: &str, row: &Record<CborValue>, ) -> Result<Option<Record<CborValue>>>

where E: Entity<CborValue>, Self: Sized,

Detail-script hydration for one id, with the existing list-pass row injected into the script scope as row. Falls back to the normal list-and-pick path when the table has no detail script. The detail script runs without the table’s conditions. Its answer is the row keyed by id, or a single row carrying no id, stamped with id.

Trait Implementations

impl Clone for Cmd

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataSource for Cmd

impl Debug for Cmd

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

Formats the value using the given formatter.

impl ExprDataSource<Value> for Cmd

async fn execute(&self, expr: &Expression<CborValue>) -> Result<CborValue>

fn defer(&self, expr: Expression<CborValue>) -> DeferredFn<CborValue>

fn associate<R>( &self, expr: Expression<T>, ) -> AssociatedExpression<'_, Self, T, R>

where Self: Sized,

Create an associated expression with type-safe return type

impl TableSource for Cmd

type Column<Type> = Column<Type> where Type: ColumnType

type AnyType = Value

type Value = Value

type Id = String

type Condition = CmdCondition

The condition type stored by Table. SQL/SurrealDB backends use Expression<Self::Value>; document-oriented backends like MongoDB can use a native filter type (e.g. bson::Document).

type Source = String

How this backend names its source. Most backends use String; SQL/SurrealDB backends use SelectSource<Self::Select> so a table can be sourced from an arbitrary sub-SELECT. See crate::source.

fn eq_condition(field: &str, value: &str) -> Result<Self::Condition>

Build a textual field == value condition.

fn eq_value_condition( &self, field: &str, value: Self::Value, ) -> Result<Self::Condition>

Build a field == value condition with a typed Self::Value.

fn create_column<Type: ColumnType>(&self, name: &str) -> Self::Column<Type>

Create a new column with the given name

fn to_any_column<Type: ColumnType>( &self, column: Self::Column<Type>, ) -> Self::Column<Self::AnyType>

Convert a typed column to type-erased column

fn convert_any_column<Type: ColumnType>( &self, any_column: Self::Column<Self::AnyType>, ) -> Option<Self::Column<Type>>

Attempt to convert a type-erased column back to typed column

fn expr( &self, template: impl Into<String>, parameters: Vec<ExpressiveEnum<Self::Value>>, ) -> Expression<Self::Value>

Create an expression from a template and parameters, similar to Expression::new

fn search_table_condition<E>( &self, _table: &Table<Self, E>, search_value: &str, ) -> Self::Condition

where E: Entity<Self::Value>,

Create a search condition matching search_value across the columns of Table::search_columns: those flagged Searchable, or every column when none is. A backend may leave out columns it can’t filter on (dotted paths, imported columns). This is a server-side capability — it pushes the match down to the backend’s query engine.

fn list_table_values<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<Self::Id, Record<Self::Value>>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all data from a table as Record values with IDs (for ReadableValueSet implementation)

fn get_table_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, id: &'life2 Self::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<Self::Value>>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a single record by ID as Record value (for ReadableValueSet implementation).

fn get_table_some_value<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<Option<(Self::Id, Record<Self::Value>)>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get some data from a table as Record value with ID (for ReadableValueSet implementation)

fn get_table_count<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get count of records in the table

fn get_table_sum<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get sum of a column in the table (returns native value type)

fn get_table_max<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get maximum value of a column in the table (returns native value type)

fn get_table_min<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get minimum value of a column in the table (returns native value type)

fn insert_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _record: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Insert a record by ID. Confined and idempotent: when the id is already stored in table.conditions(), return the stored row unchanged; when it is held by a row outside the set, fail with Conflict; a new row must fit the conditions, else Conflict and nothing is stored. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn replace_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _record: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace a record by ID, creating it when missing. Confined and idempotent: an id held by a row outside table.conditions() fails with Conflict; the written row must fit the conditions, else Conflict and nothing changes. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn patch_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _partial: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Merge partial into the row with this ID. Confined: a missing row or one outside table.conditions() is NotFound (marked); the merged row must still fit the conditions, else Conflict and nothing changes. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn delete_table_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a record by ID. Confined and idempotent: delete only when the row is in table.conditions(); a missing row or a row outside the set is Ok(()) (no lookup is needed — SQL: DELETE … WHERE id = ? AND <conditions>). Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

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

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete every record the table represents (for WritableValueSet).

fn insert_table_return_id_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _record: &'life2 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Self::Id>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert a record under a generated ID and return it. Confined, not retry-safe: the record must fit table.conditions(), else Conflict and nothing is stored; a retry after a lost reply stores a second row. Refuse with Unsupported when a condition can be neither applied nor evaluated.

fn related_in_condition<SourceE: Entity<Self::Value> + 'static>( &self, target_field: &str, source_table: &Table<Self, SourceE>, source_column: &str, ) -> Self::Condition

where Self: Sized,

Build a condition for “target_field IN (values of source_column from source_table)”.

fn column_table_values_expr<'a, E, Type: ColumnType>( &'a self, table: &Table<Self, E>, column: &Self::Column<Type>, ) -> AssociatedExpression<'a, Self, Self::Value, Vec<Type>>

where E: Entity<Self::Value> + 'static, Self: Sized,

Return an associated expression that, when resolved, yields all values of the given typed column from this table (respecting current conditions).

fn in_values_condition( &self, field: &str, values: Vec<Self::Value>, ) -> Result<Self::Condition, VantageError>

Build a field IN (values) condition from native-typed values: the list-valued sibling of Self::eq_value_condition. Self::condition_column names field for it. An empty values matches no row. The default returns an error.

fn condition_equality( &self, condition: &Self::Condition, ) -> Option<(String, Self::Value)>

When condition is a literal column = value, return the pair.

fn describe_condition(&self, condition: &Self::Condition) -> String

condition as text for people, e.g. client_id = 7: what a log entry records for a bulk delete. Not for parsing; use Self::condition_column / Self::condition_equality in code. A part resolved only at query time renders as a placeholder.

fn condition_column(&self, condition: &Self::Condition) -> Option<String>

The column condition narrows to values, for the shapes this backend can read (col = v, col IN (…), comparisons, LIKE), with a value — not a column or an arbitrary expression — on the right. None when it can’t tell — a raw expression, a combination, a negation (!=, NOT IN, NOT LIKE), col = other_col — so a check that requires a condition on some column fails safe.

fn can_confine_writes(&self) -> bool

Whether every by-id write (insert_table_value, replace_table_value, patch_table_value, delete_table_value, insert_table_return_id_value) honours the write contract over table.conditions(): it only touches rows in the set, and only leaves rows that still belong to it. A source that returns false is refused any by-id write through a conditioned table: Table refuses it with Unsupported before reaching the source. Default false.

fn coerce_reference_value(&self, value: Self::Value) -> Self::Value

Coerce a reference join value into the backend’s native id form.

fn stream_table_values<'a, E>( &'a self, table: &Table<Self, E>, ) -> Pin<Box<dyn Stream<Item = Result<(Self::Id, Record<Self::Value>), VantageError>> + Send + 'a>>

where E: Entity<Self::Value> + 'a, Self: Sized,

Stream all records from a table as (Id, Record) pairs.

fn related_correlated_condition( &self, target_table: &str, target_field: &str, source_table: &str, source_column: &str, ) -> Self::Condition

Build a correlated condition: target_table.target_field = source_table.source_column.

fn supports_traversal(&self) -> bool

Whether this backend can lower a dotted active column ("country.name") into its own query — a nested correlated subquery for SQL, a native idiom path for SurrealDB, $lookup stages for MongoDB. Backends that can build none of these (e.g. CSV, REST) leave the default false, and Table::with_active_columns rejects dotted names against them at build time rather than at fetch time.

fn traversal_path_expr( &self, hops: &[&str], column: &str, ) -> Option<Expression<Self::Value>>

Build a backend-native path expression for a dotted active column, tried before the generic correlated-subquery chain.