Struct Query 

pub struct Query {

    pub raw: String,
    pub query_type: QueryType,
    pub triple_patterns: Vec<TriplePattern>,
    pub predicates: HashSet<String>,
    pub types: HashSet<String>,
    pub graphs: SmallVec<[String; 2]>,
    pub has_optional: bool,
    pub has_union: bool,
    pub has_filter: bool,
    pub has_aggregation: bool,
    pub has_property_paths: bool,
    pub has_subquery: bool,
    pub has_service: bool,
    pub limit: Option<u32>,
    pub offset: Option<u32>,
    pub complexity: f32,
    pub projection_vars: SmallVec<[String; 4]>,
    pub structured_triples: Vec<StructuredTriple>,
    pub prefixes: HashMap<String, String>,
}

A parsed SPARQL query with extracted features

Fields

raw: String

Original query string

query_type: QueryType

Query type (SELECT, CONSTRUCT, ASK, DESCRIBE)

triple_patterns: Vec<TriplePattern>

Extracted triple patterns

predicates: HashSet<String>

Predicates used in the query (URIs)

types: HashSet<String>

Types/classes referenced (rdf:type objects)

graphs: SmallVec<[String; 2]>

Named graphs referenced

has_optional: bool

Whether the query uses OPTIONAL

has_union: bool

Whether the query uses UNION

has_filter: bool

Whether the query uses FILTER

has_aggregation: bool

Whether the query uses aggregation

has_property_paths: bool

Whether the query uses property paths

has_subquery: bool

Whether the query uses subqueries

has_service: bool

Whether the query uses SERVICE (federation)

limit: Option<u32>

LIMIT value (if specified)

offset: Option<u32>

OFFSET value (if specified)

complexity: f32

Complexity score (0.0 - 1.0)

projection_vars: SmallVec<[String; 4]>

Variables named in the SELECT projection (e.g. ["a", "b"] for SELECT ?a ?b). ["*"] for SELECT *. Empty for ASK, CONSTRUCT, DESCRIBE, or when constructed via the heuristic Query::parse (kept for backwards compatibility).

structured_triples: Vec<StructuredTriple>

Per-triple structured terms from BGP triples (populated by [Query::from_sparql]). Empty when using heuristic Query::parse.

prefixes: HashMap<String, String>

Prefix declarations from the SPARQL source (populated by [Query::from_sparql]). Keys are bare prefix labels (e.g., "foaf"), values are namespace IRIs. Empty when using heuristic Query::parse.

Implementations

impl Query

pub fn parse(query: &str) -> Result<Self>

Parse a SPARQL query string

Errors

Returns an error if the query cannot be parsed

pub fn vocabularies(&self) -> HashSet<String>

Get vocabulary namespaces used in this query

pub fn predicate_hash(&self) -> u64

Hash the predicates for feature extraction (FNV-1a)

pub const fn requires_sparql_1_1(&self) -> bool

Check if query requires a specific capability

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Query

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Query

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

where __S: Serializer,

Serialize this value into the given Serde serializer.