Struct NQuadsParser

Source

pub struct NQuadsParser { /* private fields */ }

Expand description

A N-Quads streaming parser.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NQuadsParser;

let file = r#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for quad in NQuadsParser::new().for_reader(file.as_bytes()) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations§

Source §

impl NQuadsParser

Source

pub fn new() -> Self

Builds a new NQuadsParser.

Source

pub fn lenient(self) -> Self

Assumes the file is valid to make parsing faster.

It will skip some validations.

Note that if the file is actually not valid, the parser might emit broken RDF.

Source

pub fn unchecked(self) -> Self

👎Deprecated since 0.2.0:

Use lenient() instead

Source

pub fn for_reader<R: Read>(self, reader: R) -> ReaderNQuadsParser<R> ⓘ

Parses a N-Quads file from a Read implementation.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NQuadsParser;

let file = r#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for quad in NQuadsParser::new().for_reader(file.as_bytes()) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Source

pub fn for_slice( self, slice: &(impl AsRef<[u8]> + ?Sized), ) -> SliceNQuadsParser<'_> ⓘ

Parses a N-Quads file from a byte slice.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NQuadsParser;

let file = r#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for quad in NQuadsParser::new().for_slice(file) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Source

pub fn split_slice_for_parallel_parsing( self, slice: &(impl AsRef<[u8]> + ?Sized), target_parallelism: usize, ) -> Vec<SliceNQuadsParser<'_>>

Creates a vector of parsers that may be used to parse an NQuads document slice in parallel. To dynamically specify target_parallelism, use e.g. std::thread::available_parallelism. Intended to work on large documents.

Count the number of people:

use oxrdf::vocab::rdf;
use oxrdf::NamedNodeRef;
use oxttl::NQuadsParser;
use rayon::iter::{IntoParallelIterator, ParallelIterator};

let file = r#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let readers = NQuadsParser::new().split_slice_for_parallel_parsing(file, 2);
let count = readers
    .into_par_iter()
    .map(|reader| {
        let mut count = 0;
        for quad in reader {
            let quad = quad.unwrap();
            if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
                count += 1;
            }
        }
        count
    })
    .sum();
assert_eq!(2, count);

Source

pub fn split_file_for_parallel_parsing( self, path: impl AsRef<Path>, target_parallelism: usize, ) -> Result<Vec<ReaderNQuadsParser<Take<File>>>>

Creates a vector of parsers that may be used to parse an NQuads file in parallel. To dynamically specify target_parallelism, use e.g. std::thread::available_parallelism. Intended to work on large documents.

Count the number of people:

use oxrdf::vocab::rdf;
use oxrdf::NamedNodeRef;
use oxttl::NTriplesParser;
use rayon::iter::{IntoParallelIterator, ParallelIterator};

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let readers = NTriplesParser::new().split_file_for_parallel_parsing(&path, 2)?;
let count = readers
    .into_par_iter()
    .map(|reader| {
        let mut count = 0;
        for triple in reader {
            let triple = triple.unwrap();
            if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
                count += 1;
            }
        }
        count
    })
    .sum();
assert_eq!(2, count);

Source

pub fn low_level(self) -> LowLevelNQuadsParser

Allows parsing an N-Quads file by using a low-level API.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NQuadsParser;

let file: [&[u8]; 4] = [
    b"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .\n",
    b"<http://example.com/foo> <http://schema.org/name> \"Foo\" .\n",
    b"<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .\n",
    b"<http://example.com/bar> <http://schema.org/name> \"Bar\" .\n"
];

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
let mut parser = NQuadsParser::new().low_level();
let mut file_chunks = file.iter();
while !parser.is_end() {
    // We feed more data to the parser
    if let Some(chunk) = file_chunks.next() {
        parser.extend_from_slice(chunk);    
    } else {
        parser.end(); // It's finished
    }
    // We read as many quads from the parser as possible
    while let Some(quad) = parser.parse_next() {
        let quad = quad?;
        if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
            count += 1;
        }
    }
}
assert_eq!(2, count);