Struct QueryGroup 

pub struct QueryGroup {

    pub id: QueryGroupId,
    pub query_name: String,
    pub args: Arc<Value>,
    pub auth_scope: AuthScope,
    pub auth_context: AuthContext,
    pub table_deps: &'static [&'static str],
    pub selected_cols: &'static [&'static str],
    pub read_set: ReadSet,
    pub last_result_hash: Option<String>,
    pub last_result: Option<Arc<Value>>,
    pub subscribers: Vec<SubscriberId>,
    pub created_at: DateTime<Utc>,
    pub execution_count: u64,
}

Coalesces subscriptions sharing the same query+args+auth_scope. On invalidation the query executes once per group, not per subscriber.

Fields

id: QueryGroupId

query_name: String

args: Arc<Value>

auth_scope: AuthScope

auth_context: AuthContext

Cached at subscribe time; not refreshed mid-lifetime. The reactor skips re-execution for groups with expired tokens; session cleanup evicts them.

table_deps: &'static [&'static str]

selected_cols: &'static [&'static str]

read_set: ReadSet

last_result_hash: Option<String>

Shared across all subscribers for delta detection.

last_result: Option<Arc<Value>>

Sent to new subscribers joining an existing group.

subscribers: Vec<SubscriberId>

created_at: DateTime<Utc>

execution_count: u64

Implementations

impl QueryGroup

pub fn compute_lookup_key( query_name: &str, args: &Value, auth_scope: &AuthScope, ) -> SubscriptionKey

Compute the dedup key for (query_name, args, auth_scope).

Uses FNV-1a so the result is stable across process restarts — unlike DefaultHasher which randomises its seed per process.

pub fn record_execution(&mut self, read_set: ReadSet, result_hash: String)

Record a query execution result.

pub fn record_execution_with_data( &mut self, read_set: ReadSet, result_hash: String, data: Arc<Value>, )

Record execution with the result data cached for new subscribers.

pub fn should_invalidate(&self, change: &Change) -> bool

Check if a change should invalidate this group. Uses the runtime read set when populated, otherwise falls back to the compile-time table dependencies from macro extraction.