Struct DataClient 

pub struct DataClient { /* private fields */ }

A data-plane client backed by a remote engine over gRPC + Flight SQL.

Cheap to clone: it holds the cloneable transport and the composed CatalogClient (which shares the same transport).

Implementations

impl DataClient

pub async fn connect(endpoint: impl Into<Endpoint>) -> Result<Self>

Connect to a jammi.v1 gRPC endpoint and mint a fresh session id. The composed control client shares the same transport (and session id), so a tenant bound through Self::bind_tenant is observed by every data verb.

pub fn over(transport: SessionTransport) -> Self

Build a data client over an existing transport, composing a control client over the same channel + session id.

pub fn catalog(&self) -> &CatalogClient

The composed control-plane client over the same session — the source/ model registry, channel, mutable-table, topic-admin, and tenant verbs.

pub fn session_id(&self) -> &str

The opaque session id the server keys tenant state against. The Flight SQL lane stamps this same id so a bound-tenant query scopes correctly.

pub async fn bind_tenant(&self, t: TenantId) -> Result<()>

Bind a tenant scope to this session (sticky form).

pub async fn unbind_tenant(&self) -> Result<()>

Clear the bound tenant.

pub async fn tenant(&self) -> Result<Option<TenantId>>

The tenant currently bound, if any.

pub async fn sql(&self, query: &str) -> Result<Vec<RecordBatch>>

Execute a SQL query over the Flight SQL lane and collect the terminal batches.

sql does not ride a typed gRPC verb — per ADR-01 §3.2 the Flight SQL surface carries query/result. So this opens a FlightSqlServiceClient over the same tonic channel the typed-RPC verbs use, stamps the SESSION_HEADER with Self::session_id — the identical id bind_tenant bound the tenant scope against — so the server’s TenantBoundProvider resolves this query to that bound tenant, then runs execute → do_get(ticket) per endpoint and concatenates the streamed batches. Stamping the bound session id (not a fresh one) is what keeps a --tenant A query scoped to tenant A rather than silently unscoped.

pub async fn generate_embeddings( &self, source_id: &str, model_id: &str, columns: &[String], key_column: &str, modality: Modality, cache: CachePolicy, ) -> Result<(ResultTableRecord, CacheOutcome)>

Generate embeddings for columns of a source with the given model and modality, persisting one vector per row.

pub async fn encode_query( &self, model_id: &str, input: QueryInput, modality: Modality, ) -> Result<Vec<f32>>

Encode a single query into a vector with the given model.

pub async fn search(&self, request: SearchRequest) -> Result<Vec<RecordBatch>>

Run a vector search and return the terminal hydrated batches.

pub async fn infer( &self, source_id: &str, model_id: &str, task: ModelTask, content_columns: &[String], key_column: &str, cache: CachePolicy, ) -> Result<(Vec<RecordBatch>, CacheOutcome)>

Run inference on a registered source using a model.

pub async fn fine_tune( &self, source: &str, base_model: &str, columns: &[String], method: FineTuneMethod, task: ModelTask, config: Option<FineTuneConfig>, ) -> Result<FineTuneJobId>

Start a fine-tuning job and return its id. Poll completion with Self::fine_tune_status.

pub async fn fine_tune_status(&self, id: &FineTuneJobId) -> Result<String>

Current status string for a fine-tune job, looked up by id.

pub async fn eval_embeddings( &self, source_id: &str, embedding_table: Option<&str>, golden_source: &str, k: usize, cohorts: &HashMap<String, BTreeMap<String, String>>, ) -> Result<EmbeddingEvalReport>

Evaluate embedding quality against golden relevance judgments.

pub async fn eval_per_query( &self, eval_run_id: &str, ) -> Result<Vec<PerQueryEvalRecord>>

Read back the persisted per-query eval records for a run.

pub async fn eval_inference( &self, model_id: &str, source_id: &str, columns: &[String], task: EvalTask, golden_source: &str, label_column: &str, ) -> Result<InferenceEvalReport>

Evaluate inference quality against golden labels.

pub async fn eval_compare( &self, embedding_tables: &[String], source_id: &str, golden_source: &str, k: usize, ) -> Result<CompareEvalReport>

Compare multiple embedding tables side-by-side.

pub async fn publish( &self, topic: &TopicDefinition, batch: RecordBatch, ) -> Result<Offset, TriggerError>

Publish one batch to a topic under the session’s tenant scope, returning the assigned offset.

pub async fn subscribe( &self, topic: &TopicDefinition, predicate: Predicate, from_offset: Option<Offset>, replay_only: bool, ) -> Result<Pin<Box<dyn Stream<Item = Result<DeliveredBatch, TriggerError>> + Send>>, TriggerError>

Subscribe to a topic, returning a transport-neutral stream of delivered batches. The stream replays from from_offset (or the live tail when None) and then tails live, scoped to the session’s tenant. When replay_only is set the server drives its finite drain and closes the stream rather than holding open to tail live batches.

pub async fn audit_log( &self, records: Vec<PerQueryAudit>, ) -> Result<(), AuditError>

Sign and persist a batch of audit records; publishes them to the audit topic.

pub async fn audit_fetch_by_query_id( &self, query_id: Uuid, ) -> Result<Option<PerQueryAudit>, AuditError>

Fetch one audit record by query id (tenant-scoped).

pub async fn audit_fetch_recent( &self, limit: usize, ) -> Result<Vec<PerQueryAudit>, AuditError>

Fetch the most recent audit records (tenant-scoped), newest first.

Trait Implementations

impl Clone for DataClient

fn clone(&self) -> DataClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.