Enum Term 

pub enum Term {
    Variable(String),
    Iri(String),
    PrefixedName(String, String),
    Literal(String),
    BlankNode(String),
}

A SPARQL term with resolved values.

Unlike crate::core::query::TermType which only carries the kind, this enum carries the actual string content of the term.

Variants

Variable(String)

Variable name without the leading ?.

Iri(String)

Fully-qualified IRI.

PrefixedName(String, String)

Prefixed name: (prefix_label, local_part).

Literal(String)

Literal lexical form, raw (including "..."@en or "..."^^xsd:integer).

BlankNode(String)

Blank node label without the leading _:.

Implementations

impl Term

pub fn resolve(&self, prefix_map: &HashMap<String, String>) -> Self

Resolve PrefixedName(p, l) → Iri(prefix_map[p] + l) if p is in the map; otherwise return self unchanged.

Note: prefix_map keys are bare prefix labels (e.g., "foaf"), not the colon-terminated form.

pub fn from_token(token: &str) -> Self

Parse a raw SPARQL token into a Term.

• ?name or $name → Variable("name")
• <iri> → Iri("iri")
• _:label → BlankNode("label")
• "..." / '...' or starting with a digit / sign → Literal(raw)
• prefix:local → PrefixedName("prefix", "local")
• a (rdf:type shorthand) → PrefixedName("rdf", "type")
• anything else → Iri(token) (best-effort)

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Term

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Term

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Term

fn eq(&self, other: &Term) -> 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 Term

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 Term

impl StructuralPartialEq for Term