Enum QueryIsolation 

pub enum QueryIsolation {
    ReadUncommitted,
    ReadCommitted {
        wait_for: Vec<ConsensusId>,
    },
    Snapshot {
        prestate_hash: Hash32,
    },
    ReadLatest {
        scope: ResourceScope,
    },
}

Query isolation levels for consistency requirements.

Aura’s journal is eventually consistent via CRDT merge. These isolation levels let queries specify their consistency requirements:

• ReadUncommitted: See latest CRDT state (fastest, may see uncommitted facts)
• ReadCommitted: Only see facts confirmed by consensus
• Snapshot: Query against a specific historical prestate
• ReadLatest: Wait for all pending consensus in scope to complete

Example

// Fast query - may see uncommitted facts
let result = effects.query_with_isolation(
    &ChannelsQuery::default(),
    QueryIsolation::ReadUncommitted,
).await?;

// Strong consistency - wait for specific consensus
let result = effects.query_with_isolation(
    &ChannelsQuery::default(),
    QueryIsolation::ReadCommitted { wait_for: vec![consensus_id] },
).await?;

Variants

ReadUncommitted

See all facts including uncommitted (CRDT state).

Fastest option - queries execute immediately against the current CRDT state without waiting for consensus confirmation.

ReadCommitted

Only see facts with consensus commit.

Waits for specified consensus instances to complete before executing the query. Use this when you need to see the results of specific operations that required consensus.

Fields

wait_for: Vec<ConsensusId>

Consensus instances to wait for before executing query

Snapshot

Snapshot at specific prestate (time-travel query).

Queries against a historical state identified by its prestate hash. Useful for auditing or debugging. The prestate must still be available (not garbage collected).

Fields

prestate_hash: Hash32

Hash of the prestate to query against

ReadLatest

Wait for all pending consensus in scope to complete.

More expensive than ReadCommitted - waits for all pending consensus operations that affect the specified resource scope. Use sparingly.

Note: This is NOT linearizable - just ensures all pending commits are visible at query time.

Fields

scope: ResourceScope

Resource scope to wait for

Implementations

impl QueryIsolation

pub fn read_committed(consensus_id: ConsensusId) -> Self

Create a ReadCommitted isolation waiting for a single consensus

pub fn snapshot(prestate_hash: Hash32) -> Self

Create a Snapshot isolation for a specific prestate

pub fn read_latest(scope: ResourceScope) -> Self

Create a ReadLatest isolation for a resource scope

pub fn requires_wait(&self) -> bool

Check if this isolation level requires waiting

Trait Implementations

impl Clone for QueryIsolation

fn clone(&self) -> QueryIsolation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryIsolation

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

Formats the value using the given formatter.

impl Default for QueryIsolation

fn default() -> QueryIsolation

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for QueryIsolation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for QueryIsolation

fn eq(&self, other: &QueryIsolation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for QueryIsolation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for QueryIsolation

impl StructuralPartialEq for QueryIsolation