Struct ReconfigurableLiveQuery 

pub struct ReconfigurableLiveQuery<Request, Value> { /* private fields */ }

A tracked query whose absolute request can change without replacing the subscription.

Construct one with CovenHandle::subscribe_reconfigurable. Request changes and relevant commits are coalesced before each run. If the request changes while a run is in progress, that result is discarded and the latest request is evaluated before an event is returned.

A run caused only by committed changes whose value equals the last delivered value is not delivered: the query’s read dependencies are table-and-key granular, so a paged query (ORDER BY … LIMIT) reruns for any row change in its tables, and most of those reruns leave its window unchanged. The initial run, a run after a request change, and every error are always delivered; the first successful value after an error is too.

Implementations

impl<Request, Value> ReconfigurableLiveQuery<Request, Value>

where Request: Clone + PartialEq + Send + Sync + 'static, Value: Send + 'static,

pub fn process<P, R>(self, process: P) -> ReconfigurableLiveQuery<Request, R>

where P: Fn(&Request, Value) -> CovenResult<R> + Send + Sync + 'static, R: Send + 'static,

Process each fetched value on bounded workers after releasing its read connection. Dependencies and request revisions stay attached to the read; only processed values are compared when deciding whether to deliver.

The returned subscription starts with an initial result for the latest request, even if this subscription previously delivered values. Existing request handles continue to control it.

pub fn requests(&self) -> LiveQueryRequests<Request>

Return a handle that can replace this subscription’s absolute request.

pub async fn next(&mut self) -> ReconfigurableLiveQueryEvent<Request, Value>

where Value: Clone + PartialEq,

Return the initial event, or wait for a request change or relevant committed database change and return the next event.

Query errors are events and do not end the subscription. Cancelling the future preserves the pending request or database change. A commit-caused rerun whose value equals the last delivered value is not an event; the query goes back to waiting.