Struct Query 

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

Implementations

impl<E: EntityKind> Query<E>

pub const fn new(consistency: MissingRowPolicy) -> Self

Create a new intent with an explicit missing-row policy. Ignore favors idempotency and may mask index/data divergence on deletes. Use Error to surface missing rows during scan/delete execution.

pub const fn mode(&self) -> QueryMode

Return the intent mode (load vs delete).

pub fn filter(self, predicate: Predicate) -> Self

Add a predicate, implicitly AND-ing with any existing predicate.

pub fn filter_expr(self, expr: FilterExpr) -> Result<Self, QueryError>

Apply a dynamic filter expression.

pub fn sort_expr(self, expr: SortExpr) -> Result<Self, QueryError>

Apply a dynamic sort expression.

pub fn order_by(self, field: impl AsRef<str>) -> Self

Append an ascending sort key.

pub fn order_by_desc(self, field: impl AsRef<str>) -> Self

Append a descending sort key.

pub fn distinct(self) -> Self

Enable DISTINCT semantics for this query.

pub fn group_by(self, field: impl AsRef<str>) -> Result<Self, QueryError>

Add one GROUP BY field.

pub fn aggregate(self, aggregate: AggregateExpr) -> Self

Add one aggregate terminal via composable aggregate expression.

pub fn grouped_limits(self, max_groups: u64, max_group_bytes: u64) -> Self

Override grouped hard limits for grouped execution budget enforcement.

pub fn having_group( self, field: impl AsRef<str>, op: CompareOp, value: Value, ) -> Result<Self, QueryError>

Add one grouped HAVING compare clause over one grouped key field.

pub fn having_aggregate( self, aggregate_index: usize, op: CompareOp, value: Value, ) -> Result<Self, QueryError>

Add one grouped HAVING compare clause over one grouped aggregate output.

pub fn delete(self) -> Self

Mark this intent as a delete query.

pub fn limit(self, limit: u32) -> Self

Apply a limit to the current mode.

Load limits bound result size; delete limits bound mutation size. For scalar load queries, any use of limit or offset requires an explicit order_by(...) so pagination is deterministic. GROUP BY queries use canonical grouped-key order by default.

pub fn offset(self, offset: u32) -> Self

Apply an offset to a load intent.

Scalar pagination requires an explicit order_by(...). GROUP BY queries use canonical grouped-key order by default.

pub fn explain(&self) -> Result<ExplainPlan, QueryError>

Explain this intent without executing it.

pub fn planned(&self) -> Result<PlannedQuery<E>, QueryError>

Plan this intent into a neutral planned query contract.

pub fn plan(&self) -> Result<CompiledQuery<E>, QueryError>

Compile this intent into query-owned handoff state.

This boundary intentionally does not expose executor runtime shape.

Trait Implementations

impl<E: Debug + EntityKind> Debug for Query<E>

where E::Key: Debug,

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

Formats the value using the given formatter.