Struct LoadExecutor 

pub struct LoadExecutor<E: EntityKind> { /* private fields */ }

LoadExecutor

Implementations

impl<E: EntityKind> LoadExecutor<E>

pub const fn new(db: Db<E::Canister>, debug: bool) -> Self

pub fn one(&self, value: impl FieldValue) -> Result<Response<E>, Error>

Execute a query for a single primary key.

pub fn only(&self) -> Result<Response<E>, Error>

Execute a query for the unit primary key.

pub fn many<I, V>(&self, values: I) -> Result<Response<E>, Error>

where I: IntoIterator<Item = V>, V: FieldValue,

Execute a query matching multiple primary keys.

pub fn all(&self) -> Result<Response<E>, Error>

Execute an unfiltered query for all rows.

pub fn filter<F, I>(&self, f: F) -> Result<Response<E>, Error>

where F: FnOnce(FilterDsl) -> I, I: IntoFilterExpr,

Execute a query built from a filter.

pub fn require_one(&self, query: LoadQuery) -> Result<(), Error>

Execute a query and require exactly one row.

pub fn require_one_pk(&self, value: impl FieldValue) -> Result<(), Error>

Require exactly one row by primary key.

pub fn require_one_filter<F, I>(&self, f: F) -> Result<(), Error>

where F: FnOnce(FilterDsl) -> I, I: IntoFilterExpr,

Require exactly one row from a filter.

pub fn exists(&self, query: LoadQuery) -> Result<bool, Error>

Check whether at least one row matches the query.

Note: existence checks are best-effort. If matching rows are malformed or missing, exists may return false.

Respects offset/limit when provided (limit=0 returns false).

pub fn exists_one(&self, value: impl FieldValue) -> Result<bool, Error>

Check existence by primary key.

pub fn exists_filter<F, I>(&self, f: F) -> Result<bool, Error>

where F: FnOnce(FilterDsl) -> I, I: IntoFilterExpr,

Check existence with a filter.

pub fn exists_any(&self) -> Result<bool, Error>

Check whether the table contains any rows.

pub fn ensure_exists_one(&self, value: impl FieldValue) -> Result<(), Error>

Require at least one row by primary key.

pub fn ensure_exists_many<I, V>(&self, values: I) -> Result<(), Error>

where I: IntoIterator<Item = V>, V: FieldValue,

Require that all provided primary keys exist.

pub fn ensure_exists_filter<F, I>(&self, f: F) -> Result<(), Error>

where F: FnOnce(FilterDsl) -> I, I: IntoFilterExpr,

Require at least one row from a filter.

pub fn explain(self, query: LoadQuery) -> Result<QueryPlan, Error>

Validate and return the query plan without executing.

pub fn execute(&self, query: LoadQuery) -> Result<Response<E>, Error>

Execute a full query and return a collection of entities.

Note: index-backed loads are best-effort. If index entries point to missing or malformed rows, those candidates are skipped. Use explicit strict APIs when corruption must surface as an error.

pub fn count(&self, query: LoadQuery) -> Result<u32, Error>

Count rows matching a query.

pub fn count_all(&self) -> Result<u32, Error>

pub fn group_count_by<K, F>( &self, query: LoadQuery, key_fn: F, ) -> Result<HashMap<K, u32>, Error>

where K: Eq + Hash, F: Fn(&E) -> K,

Group rows matching a query and count them by a derived key.

This is intentionally implemented on the executor (not Response) so it can later avoid full deserialization.

Trait Implementations

impl<E: Clone + EntityKind> Clone for LoadExecutor<E>

where E::Canister: Clone,

fn clone(&self) -> LoadExecutor<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Copy + EntityKind> Copy for LoadExecutor<E>

where E::Canister: Copy,