Struct SparqlAdapter 

pub struct SparqlAdapter {
    pub id: &'static str,
    pub endpoint: String,
}

Adapter for Semantic Web RDF / SPARQL endpoints (e.g. Wikidata).

Fields

id: &'static str

endpoint: String

Implementations

impl SparqlAdapter

pub fn new(id: &'static str, endpoint: &str) -> Self

pub fn parse_features(&self, body: &str) -> Result<Vec<NQuin>, String>

Parse a standard SPARQL 1.1 Query Results JSON response (e.g. from Wikidata or any generic SPARQL endpoint) into provenance NQuins.

The mapping is generic and deterministic so the resulting quins are queryable by the SPARQL layer, which hashes IRIs with the same generate_60bit_token:

For each results.bindings row i (iterating head.vars in declared order):

• subject = the value of the FIRST variable whose binding is type == "uri"; if the row binds no URI, subject = generate_60bit_token("urn:sparql:row:{i}").
• for every OTHER bound variable v in the row: predicate = generate_60bit_token("urn:sparql:var:{v}"), object = generate_60bit_token(binding.value), emitting quin(subject, predicate, object).

If results or results.bindings are absent, an empty Vec is returned (not an error). Err is only returned when body is not valid JSON.

Trait Implementations

impl DataAdapter for SparqlAdapter

fn adapter_id(&self) -> &'static str

Returns the unique identifier for this adapter (e.g., “dem_adapter”)

fn build_fetch_request( &self, bbox: (f64, f64, f64, f64), _time_range: (u64, u64), registry: &NetworkDisclosureRegistry, ) -> Result<AdapterHttpRequest, String>

Build the outbound request for a spatial bounding box [x1, y1, x2, y2] and temporal range [t0, t1]. Implementations must check NetworkDisclosureRegistry before returning an actual network request.

fn parse_response(&self, body: &str) -> Result<Vec<NQuin>, String>

Parse a fetched response body into provenance NQuins (title / license / created / source / lat / long, hashed with the same generate_60bit_token the SPARQL layer uses, so the results are queryable). Adapters that can interpret their response format override this — GBIF, OSM/Overpass, STAC, OGC 3D Tiles and SPARQL-results do — and the default yields none. This is how a fetched response becomes graph data rather than being discarded.

fn primary_endpoint(&self) -> &str

Primary egress endpoint for disclosure checks and fetch reports.

fn estimate_tile_count(&self, _bbox: (f64, f64, f64, f64)) -> u32

Honest estimate of how many tile/API units would be requested (no fake payloads).

fn fetch_region( &self, bbox: (f64, f64, f64, f64), time_range: (u64, u64), registry: &NetworkDisclosureRegistry, ) -> Result<(), String>

Initiate fetching through the native blocking transport. Browser WASM cannot legally block on network I/O, so wasm callers use fetch_region_async.

fn needs_fetch_body(&self) -> bool

Whether the adapter consumes the response body instead of only checking that the endpoint accepted the request.

fn handle_fetch_body(&self, _body: &str) -> Result<(), String>

Parse or enqueue the fetched body. Most adapters currently only verify access; CKAN consumes JSON discovery results here.

fn fetch_region_features( &self, bbox: (f64, f64, f64, f64), time_range: (u64, u64), registry: &NetworkDisclosureRegistry, ) -> Result<Vec<NQuin>, String>

Native fetch that returns the parsed provenance NQuins: build the consent-gated request, execute it, and run parse_response on the body. A caller can then route the quins into the graph. (WASM callers fetch via fetch_region_async and call parse_response on the returned body.)