Struct FederatedQueryEngine 

pub struct FederatedQueryEngine<'a> {
    pub local_quins: &'a [NQuin],
    pub services: HashMap<String, FederatedService>,
    pub initialized: bool,
}

Federated query engine — dispatches queries across local and remote services.

Local services (local:/qualia:) are executed in-process via the standard SPARQL parser → planner → executor pipeline. Remote HTTP(S) services are executed over the real SPARQL 1.1 Protocol ([fetch_remote_sparql] + [parse_sparql_results_json]): a application/sparql-query POST, the application/sparql-results+json response parsed into binding rows + a resolvable lexicon. Remote execution is real network egress and runs only for endpoints the caller explicitly targets.

Fields

local_quins: &'a [NQuin]

Local Quins the engine executes local services against.

services: HashMap<String, FederatedService>

Registered service endpoints keyed by endpoint URL.

initialized: bool

Whether initialize has been called.

Implementations

impl<'a> FederatedQueryEngine<'a>

pub fn new(quins: &'a [NQuin]) -> Self

Create a new engine over a slice of local Quins.

pub fn initialize(&mut self) -> Result<(), String>

Initialize the engine for use. Clears any stale state and marks the engine ready. Calling this is required before executing federated queries so that downstream code can rely on a deterministic start state.

pub fn register_service(&mut self, service: FederatedService)

Register a federated service endpoint. Re-registering an existing endpoint URL updates its configuration in place.

pub fn list_services(&self) -> Vec<String>

List the endpoint URLs of all registered services.

pub fn execute_service( &self, service: &FederatedService, query: &str, ) -> Result<FederatedQueryResult, String>

Execute a query against a single federated service.

• Local endpoints (local:/qualia:) are executed in-process and return real result bindings.
• Remote HTTP endpoints return a placeholder result containing the constructed query URL (<endpoint>?query=<encoded>). The HTTP fetch itself requires an async runtime which is not available in this synchronous module; the placeholder is structured so a transport layer can be plugged in later without changing the call sites.

pub fn execute_federated( &self, query: &FederatedQuery, ) -> Result<Vec<FederatedQueryResult>, String>

Execute a federated query across all of its services.

Each service is dispatched via execute_service and the per-service results are collected. Results are concatenated (simple merge); full SPARQL join semantics across services are a separate task.

Trait Implementations

impl<'a> Default for FederatedQueryEngine<'a>

fn default() -> Self

Returns the “default value” for a type.