Crate oxirs_ttl

Expand description

§OxiRS Turtle - RDF Format Parser

Status: Production Release (v0.3.1) Stability: Production-ready with 461 passing tests and 97% W3C compliance.

High-performance parsing and serialization for RDF formats in the Turtle family. Supports Turtle, TriG, N-Triples, N-Quads, and N3 with streaming and error recovery.

Ported from Oxigraph’s oxttl crate with adaptations for OxiRS.

§Features

Streaming support: Process large files with minimal memory usage
Error recovery: Continue parsing despite syntax errors
Async I/O: Optional Tokio async support
Parallel processing: Process files in parallel chunks
RDF 1.2 support: Quoted triples and directional language tags
Incremental parsing: Parse as bytes arrive with checkpointing

§Quick Start

§Basic Turtle Parsing

use oxirs_ttl::{turtle::TurtleParser, Parser};
use std::io::Cursor;

let turtle_data = r#"
@prefix ex: <http://example.org/> .
ex:subject ex:predicate "object" .
"#;

let parser = TurtleParser::new();
for result in parser.for_reader(Cursor::new(turtle_data)) {
    let triple = result?;
    println!("{}", triple);
}

§Error Recovery with Lenient Mode

use oxirs_ttl::turtle::TurtleParser;

let turtle_with_errors = r#"
@prefix ex: <http://example.org/> .
ex:good ex:pred "value" .
ex:also_good ex:pred "value2" .
"#;

// Lenient mode continues parsing after errors
let parser = TurtleParser::new_lenient();
let triples = parser.parse_document(turtle_with_errors)?;
println!("Parsed {} triples", triples.len());

§Streaming Large Files

use oxirs_ttl::{StreamingParser, StreamingConfig};
use std::io::Cursor;

let config = StreamingConfig::default()
    .with_batch_size(10000);  // Process 10K triples per batch

let data = Cursor::new(b"<http://s> <http://p> <http://o> .");
let parser = StreamingParser::with_config(data, config);
let mut total = 0;

for batch in parser.batches() {
    let triples = batch?;
    total += triples.len();
    println!("Processed batch of {} triples", triples.len());
}
println!("Total: {} triples", total);

§Incremental Parsing

use oxirs_ttl::{IncrementalParser, ParseState};

let mut parser = IncrementalParser::new();

// Feed data as it arrives
parser.push_data(b"@prefix ex: <http://example.org/> .\n")?;
parser.push_data(b"ex:s ex:p \"object\" .\n")?;
parser.push_eof();

// Parse available complete statements
let triples = parser.parse_available()?;
println!("Parsed {} triples", triples.len());

assert_eq!(parser.state(), ParseState::Complete);

§Serialization with Pretty Printing

use oxirs_ttl::turtle::TurtleSerializer;
use oxirs_ttl::toolkit::{Serializer, SerializationConfig};
use oxirs_core::model::{NamedNode, Triple};

let triple = Triple::new(
    NamedNode::new("http://example.org/subject")?,
    NamedNode::new("http://example.org/predicate")?,
    NamedNode::new("http://example.org/object")?
);

// Create config with pretty printing
let config = SerializationConfig::default()
    .with_pretty(true)
    .with_use_prefixes(true);

let serializer = TurtleSerializer::with_config(config);

let mut output = Vec::new();
serializer.serialize(&vec![triple], &mut output)?;

let turtle_string = String::from_utf8(output)?;
println!("{}", turtle_string);

Re-exports§

pub use diff::compute_diff;
pub use diff::parse_patch;
pub use diff::RdfDiff;
pub use error::TurtleParseError;
pub use error::TurtleSyntaxError;
pub use incremental::IncrementalParser;
pub use incremental::ParseCheckpoint;
pub use incremental::ParseState;
pub use parser::NQuad;
pub use parser::NQuadsLiteParser;
pub use parser::NTriple;
pub use parser::NTriplesLiteParser;
pub use parser::ParseError as NtParseError;
pub use profiling::ParsingStats;
pub use profiling::TtlProfiler;
pub use streaming::PrintProgress;
pub use streaming::ProgressCallback;
pub use streaming::StreamingConfig;
pub use streaming::StreamingParser;
pub use toolkit::Parser;
pub use toolkit::RuleRecognizer;
pub use toolkit::Serializer;
pub use toolkit::TokenRecognizer;
pub use writer::RdfTerm;
pub use writer::TermType;
pub use writer::TurtleWriter;
pub use writer::TurtleWriterConfig;
pub use patch::apply_patch;
pub use patch::diff_to_patch;
pub use patch::Graph;
pub use patch::PatchChange;
pub use patch::PatchError;
pub use patch::PatchHeader;
pub use patch::PatchParser;
pub use patch::PatchQuad;
pub use patch::PatchResult;
pub use patch::PatchSerializer;
pub use patch::PatchStats;
pub use patch::PatchTerm;
pub use patch::PatchTriple;
pub use patch::RdfPatch;
pub use mapping::DataSource;
pub use mapping::MappingEngine;
pub use mapping::MappingRule;
pub use mapping::MappingRuleBuilder;
pub use mapping::ObjectSpec;
pub use formats::jsonld::JsonLdContext;
pub use formats::jsonld::JsonLdError;
pub use formats::jsonld::JsonLdProcessor;
pub use formats::jsonld::JsonLdQuad;
pub use formats::jsonld::JsonLdResult;
pub use formats::jsonld::JsonLdTerm;
pub use formats::jsonld::JsonLdWriter;
pub use formats::jsonld::TermDefinition;
pub use csvw::parse_csv;
pub use csvw::CsvwConverter;
pub use csvw::CsvwError;
pub use csvw::CsvwMetadata;

Modules§

async_parserasync-tokio: Async I/O support for RDF parsing using Tokio
base_directive: @base / @prefix IRI resolution for Turtle/TriG (v1.1.0 round 6) @base / @prefix IRI resolution for Turtle and TriG.
compact_serializer: Compact Turtle serialization with subject/predicate grouping (v1.1.0 round 12) Compact Turtle serialization.
convenience: Convenience functions for common RDF parsing operations
csvw: CSV on the Web (CSVW) parser and RDF converter (Track H25).
diff: RDF graph diff and patch utilities
error: Error types for Turtle-family format parsing
formats: Format-specific parsers and serializers
incremental: Incremental parsing support for RDF formats
iri_catalog: IRI prefix catalog with CURIE expansion and compression (v1.1.0 round 13)
json_ld_framing: JSON-LD framing: apply a frame template to a node set (v1.1.0 round 11)
jsonld: JSON-LD 1.1 format parser, serializer, and processing algorithms
jsonld_compactor: JSON-LD compaction: converts expanded JSON-LD to compact form using a context (v1.1.0 round 15) JSON-LD compaction: converts expanded JSON-LD to compact form using a context.
lexer: Lexical analysis for Turtle-family formats
mapping: RML-inspired RDF Mapping Language support
n3: N3 format parser and reasoning (experimental)
namespace_mapper: Namespace/prefix management for Turtle and SPARQL serialization (v1.1.0 round 8) Namespace/prefix management for Turtle and SPARQL serialization.
nquads: N-Quads format parser and serializer
nquads_streaming: N-Quads streaming pull-parser: line-by-line Iterator over nquads_streaming::StreamedQuad. N-Quads streaming parser: pull-parse N-Quads format line by line.
nt_parser: N-Triples and N-Quads streaming parser: IRI/blank-node/literal tokens, comment/blank line skip, typed literals, language tags, Unicode escapes (v1.1.0 round 14) N-Triples and N-Quads streaming parser (v1.1.0 round 14)
ntriples: N-Triples format parser and serializer
ntriples_writer: N-Triples/N-Quads serialization with proper escaping (v1.1.0 round 11) N-Triples and N-Quads serialization.
parallelparallel: Parallel processing support for RDF parsing using rayon
parser: Standalone RDF parsers operating on lightweight crate::writer::RdfTerm types
patch: RDF Patch Protocol implementation
prefix_resolver: Prefix/CURIE resolver for Turtle and TriG documents (v1.1.0 round 10)
pretty_printer: Turtle pretty printer with prefix analysis.
profiling: Performance profiling support for TTL parsing
rdf_thrift: RDF Binary (Thrift) format — read + write support
rdfa_parser: Basic RDFa 1.1 Lite parser: property/typeof/resource/about/prefix attributes, literal extraction, rel/rev links, context inheritance (v1.1.0 round 13) Basic RDFa 1.1 Lite parser.
streaming: Streaming support for memory-efficient parsing of large RDF files
streaming_parser: Incremental/streaming Turtle parser for large files (v1.1.0 round 7)
toolkit: Generic toolkit for building RDF parsers and serializers
trig: TriG format parser and serializer
trig_parser: TriG named-graph Turtle parser: @prefix/PREFIX declarations, GRAPH blocks, default-graph triples, prefix expansion, graph_sizes, named_graphs (v1.1.0 round 16) TriG named-graph Turtle parser (v1.1.0 round 16).
turtle: Turtle format parser and serializer
turtle_validator: Turtle/TriG document syntax validation (v1.1.0 round 9)
writer: Writer module: high-level Turtle serializer with prefix abbreviation

Crate oxirs_ttl

Crate oxirs_ttl Copy item path

§OxiRS Turtle - RDF Format Parser

§Features

§Quick Start

§Basic Turtle Parsing

§Error Recovery with Lenient Mode

§Streaming Large Files

§Incremental Parsing

§Serialization with Pretty Printing

Re-exports§

Modules§

Crate oxirs_ttl