Enum EncodedTerm 

pub enum EncodedTerm {
    DefaultGraph,
    NamedNode {
        iri_id: StrHash,
    },
    NumericalBlankNode {
        id: [u8; 16],
    },
    SmallBlankNode(SmallString),
    BigBlankNode {
        id_id: StrHash,
    },
    SmallStringLiteral(SmallString),
    BigStringLiteral {
        value_id: StrHash,
    },
    SmallSmallLangStringLiteral {
        value: SmallString,
        language: SmallString,
    },
    SmallBigLangStringLiteral {
        value: SmallString,
        language_id: StrHash,
    },
    BigSmallLangStringLiteral {
        value_id: StrHash,
        language: SmallString,
    },
    BigBigLangStringLiteral {
        value_id: StrHash,
        language_id: StrHash,
    },
    SmallSmallTypedLiteral {
        value: SmallString,
        datatype: SmallString,
    },
    SmallBigTypedLiteral {
        value: SmallString,
        datatype_id: StrHash,
    },
    BigSmallTypedLiteral {
        value_id: StrHash,
        datatype: SmallString,
    },
    BigBigTypedLiteral {
        value_id: StrHash,
        datatype_id: StrHash,
    },
    QuotedTriple {
        subject: Box<EncodedTerm>,
        predicate: Box<EncodedTerm>,
        object: Box<EncodedTerm>,
    },
}

Encoded term representation for efficient storage

Variants

DefaultGraph

Default graph (for quad-based stores)

NamedNode

Named node with hashed IRI

Fields

iri_id: StrHash

NumericalBlankNode

Blank node with numerical ID (16 bytes for uniqueness)

Fields

id: [u8; 16]

SmallBlankNode(SmallString)

Small blank node with inline string

BigBlankNode

Large blank node with hashed ID

Fields

id_id: StrHash

SmallStringLiteral(SmallString)

Small string literal (inline)

BigStringLiteral

Large string literal (hashed)

Fields

value_id: StrHash

SmallSmallLangStringLiteral

Small value, small language tag

Fields

value: SmallString

language: SmallString

SmallBigLangStringLiteral

Small value, large language tag

Fields

value: SmallString

language_id: StrHash

BigSmallLangStringLiteral

Large value, small language tag

Fields

value_id: StrHash

language: SmallString

BigBigLangStringLiteral

Large value, large language tag

Fields

value_id: StrHash

language_id: StrHash

SmallSmallTypedLiteral

Typed literal with small value and small datatype

Fields

value: SmallString

datatype: SmallString

SmallBigTypedLiteral

Typed literal with small value and hashed datatype

Fields

value: SmallString

datatype_id: StrHash

BigSmallTypedLiteral

Typed literal with hashed value and small datatype

Fields

value_id: StrHash

datatype: SmallString

BigBigTypedLiteral

Typed literal with hashed value and hashed datatype

Fields

value_id: StrHash

datatype_id: StrHash

QuotedTriple

Quoted triple (RDF-star)

Fields

subject: Box<EncodedTerm>

predicate: Box<EncodedTerm>

object: Box<EncodedTerm>

Implementations

impl EncodedTerm

pub fn encode_named_node(node: &NamedNode) -> Self

Encodes a named node

pub fn encode_named_node_ref(node: NamedNodeRef<'_>) -> Self

Encodes a named node reference

pub fn encode_blank_node(node: &BlankNode) -> Self

Encodes a blank node

pub fn encode_blank_node_ref(node: BlankNodeRef<'_>) -> Self

Encodes a blank node reference

pub fn encode_literal(literal: &Literal) -> Self

Encodes a literal

pub fn encode_literal_ref(literal: LiteralRef<'_>) -> Self

Encodes a literal reference

pub fn encode_variable(_variable: &Variable) -> Self

Encodes a variable (currently not supported in storage context)

pub fn encode_quoted_triple(quoted_triple: &QuotedTriple) -> Self

Encodes a quoted triple (RDF-star)

pub fn encode_term(term: &Term) -> Self

Encodes any term

pub fn encode_term_ref(term: TermRef<'_>) -> Self

Encodes any term reference

pub fn type_discriminant(&self) -> u8

Returns the type discriminant for sorting and indexing

pub fn is_named_node(&self) -> bool

Returns true if this is a named node

pub fn is_blank_node(&self) -> bool

Returns true if this is a blank node

pub fn is_literal(&self) -> bool

Returns true if this is a literal

pub fn is_quoted_triple(&self) -> bool

Returns true if this is a quoted triple (RDF-star)

pub fn size_hint(&self) -> usize

Returns the size in bytes of this encoded term

Trait Implementations

impl Clone for EncodedTerm

fn clone(&self) -> EncodedTerm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EncodedTerm

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EncodedTerm

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for EncodedTerm

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 EncodedTerm

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

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 EncodedTerm

impl StructuralPartialEq for EncodedTerm