Struct Model 

pub struct Model { /* private fields */ }

An RDF graph model backed by an Oxigraph store.

In-memory models use Oxigraph alone. Persistent models opened with Model::open / Model::open_with keep an Oxigraph working set and a Fjall durable copy under Oxiland format v1 (ADR-006).

Cloning a Model clones the store handle and shares the same dataset; it does not deep-copy statements. Model is Send and Sync.

Readers (find / query execution) take a shared lock; writers take an exclusive lock so Fjall reload cannot expose an empty working set.

Examples

use oxiland::terms::{self, Literal, Triple};
use oxiland::{Model, StatementPattern};

let model = Model::new()?;
let statement = Triple::new(
    terms::named_node("https://example.com/alice")?,
    terms::named_node("https://example.com/name")?,
    Literal::new_simple_literal("Alice"),
);

assert!(model.add(statement.clone())?);
assert!(model.contains(statement.as_ref())?);

let matches = model
    .find(StatementPattern {
        subject: Some(statement.subject.as_ref()),
        ..StatementPattern::default()
    })
    .collect::<Result<Vec<_>, _>>()?;
assert_eq!(matches.len(), 1);

Implementations

impl Model

pub fn new() -> Result<Self>

Creates an empty in-memory model.

pub fn open(path: impl AsRef<Path>) -> Result<Self>

Opens or creates a persistent format-v1 model at path.

pub fn open_with(options: OpenOptions) -> Result<Self>

Opens a persistent model with typed options (ADR-006 / ADR-022).

pub fn migrate_legacy_store(path: impl AsRef<Path>) -> Result<Self>

Migrates a pre-0.4 experimental Fjall directory to format v1, then opens it.

pub fn capabilities(&self) -> StorageCapabilities

Returns capability bits for this model.

pub fn backend(&self) -> StorageBackend

Returns the storage backend for this model.

pub fn store(&self) -> &Store

Returns the underlying Oxigraph store.

This is an escape hatch for advanced Oxigraph use. Mutations through the returned handle bypass Oxiland’s lock and Fjall durability sync. Prefer Model::insert_quad, Model::transaction, and crate::Update so memory and disk stay aligned.

pub fn storage_backend_available(name: &str) -> Result<bool>

Reports whether a named storage backend is available in this build.

pub fn transaction<R>( &self, f: impl FnOnce(&mut ModelTransaction<'_>) -> Result<R>, ) -> Result<R>

Runs f inside an Oxigraph transaction; Fjall models sync on commit.

Same-thread Model reads (len / find / Query::execute) during the callback see the last committed working set and do not deadlock. Use ModelTransaction methods for in-transaction mutations. Nested transaction / auto-commit writes return Error::Unsupported.

pub fn sync(&self) -> Result<()>

Forces a durable sync (Fjall SyncAll). No-op success for memory models.

pub fn clear(&self) -> Result<()>

Clears all statements (and named graphs) from the model.

pub fn clear_graph(&self, graph_name: impl Into<GraphName>) -> Result<()>

Clears a single graph/context.

pub fn bulk_insert_quads( &self, quads: impl IntoIterator<Item = Quad>, ) -> Result<usize>

Inserts many quads inside a single transaction (then durable sync).

Returns the number of quads in the input iterator (including duplicates that were already present), not the count of newly inserted quads.

pub fn export_nquads_to_path(&self, path: impl AsRef<Path>) -> Result<()>

Exports the model as N-Quads to a filesystem path (archival helper).

pub fn import_nquads_from_path(&self, path: impl AsRef<Path>) -> Result<usize>

Imports N-Quads from a path inside a transaction (atomic on success).

Quads are merged into the existing model (RDF union); this does not clear the store first. A leading UTF-8 BOM is skipped when present.

pub fn add(&self, statement: impl Into<Triple>) -> Result<bool>

Adds a statement to the default graph.

pub fn add_to_graph( &self, statement: impl Into<Triple>, graph_name: impl Into<GraphName>, ) -> Result<bool>

Adds a statement to a named graph/context.

pub fn insert_quad(&self, quad: Quad) -> Result<bool>

Inserts a fully formed quad into the model.

pub fn remove_quad(&self, quad: &Quad) -> Result<bool>

Removes a fully formed quad from the model.

pub fn remove(&self, statement: impl Into<Triple>) -> Result<bool>

Removes a statement from the default graph.

pub fn remove_from_graph( &self, statement: impl Into<Triple>, graph_name: impl Into<GraphName>, ) -> Result<bool>

Removes a statement from a named graph/context.

pub fn contains(&self, statement: TripleRef<'_>) -> Result<bool>

Tests whether the default graph contains a statement.

pub fn contains_in_graph( &self, statement: TripleRef<'_>, graph_name: GraphNameRef<'_>, ) -> Result<bool>

Tests whether a named graph/context contains a statement.

pub fn len(&self) -> Result<usize>

Returns the number of statements across all contexts.

pub fn is_empty(&self) -> Result<bool>

Returns whether the model contains no statements.

pub fn find(&self, pattern: StatementPattern<'_>) -> StatementMatches

Streams quads matching a partial statement/context pattern.

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.