NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Relaxes error bound from Into<Io::Error> to Into<EvaluationError>

Browse Source
pull/46/head
Tpt 4 years ago
parent 81743f464e
commit 3d07160167
8 changed files with 111 additions and 115 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 42
      lib/src/error.rs
  2. 16
      lib/src/sparql/error.rs
  3. 13
      lib/src/sparql/plan.rs
  4. 16
      lib/src/store/memory.rs
  5. 80
      lib/src/store/mod.rs
  6. 6
      lib/src/store/numeric_encoder.rs
  7. 17
      lib/src/store/rocksdb.rs
  8. 16
      lib/src/store/sled.rs

42
lib/src/error.rs
Unescape View File

@ -1,17 +1,12 @@
use std::convert::Infallible;
use std::error::Error; use std::error::Error;
use std::{fmt, io}; use std::io;
//TODO: convert to "!" when "never_type" is going to be stabilized /// Traits that allows unwrapping only infallible results
#[allow(clippy::empty_enum)] pub(crate) trait UnwrapInfallible {
#[derive(Eq, PartialEq, Debug, Clone, Hash)] type Value;
pub(crate) enum Infallible {}
impl Error for Infallible {}
impl fmt::Display for Infallible { fn unwrap_infallible(self) -> Self::Value;
fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {}
}
} }
impl<T> UnwrapInfallible for Result<T, Infallible> { impl<T> UnwrapInfallible for Result<T, Infallible> {
@ -25,31 +20,6 @@ impl<T> UnwrapInfallible for Result<T, Infallible> {
} }
} }
/// Traits that allows unwrapping only infallible results
pub(crate) trait UnwrapInfallible {
type Value;
fn unwrap_infallible(self) -> Self::Value;
}
impl From<std::convert::Infallible> for Infallible {
fn from(error: std::convert::Infallible) -> Self {
match error {}
}
}
impl From<Infallible> for std::io::Error {
fn from(error: Infallible) -> Self {
match error {}
}
}
impl From<Infallible> for std::convert::Infallible {
fn from(error: Infallible) -> Self {
match error {}
}
}
pub(crate) fn invalid_data_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error { pub(crate) fn invalid_data_error(error: impl Into<Box<dyn Error + Send + Sync>>) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, error) io::Error::new(io::ErrorKind::InvalidData, error)
} }

16
lib/src/sparql/error.rs
Unescape View File

@ -1,6 +1,7 @@
use crate::error::Infallible; use crate::error::invalid_data_error;
use crate::sparql::ParseError; use crate::sparql::ParseError;
use crate::store::numeric_encoder::DecoderError; use crate::store::numeric_encoder::DecoderError;
use std::convert::Infallible;
use std::error; use std::error;
use std::fmt; use std::fmt;
use std::io; use std::io;
@ -91,12 +92,6 @@ impl From<Infallible> for EvaluationError {
} }
} }
impl From<std::convert::Infallible> for EvaluationError {
fn from(error: std::convert::Infallible) -> Self {
match error {}
}
}
impl From<ParseError> for EvaluationError { impl From<ParseError> for EvaluationError {
fn from(error: ParseError) -> Self { fn from(error: ParseError) -> Self {
Self::Parsing(error) Self::Parsing(error)
@ -109,8 +104,11 @@ impl From<io::Error> for EvaluationError {
} }
} }
impl<E: Into<io::Error>> From<DecoderError<E>> for EvaluationError { impl<E: Into<EvaluationError>> From<DecoderError<E>> for EvaluationError {
fn from(error: DecoderError<E>) -> Self { fn from(error: DecoderError<E>) -> Self {
io::Error::from(error).into() match error {
DecoderError::Store(error) => error.into(),
DecoderError::Decoder { msg } => invalid_data_error(msg).into(),
}
} }
} }

13
lib/src/sparql/plan.rs
Unescape View File

@ -9,7 +9,6 @@ use crate::store::numeric_encoder::{
use crate::store::ReadableEncodedStore; use crate::store::ReadableEncodedStore;
use std::cell::{RefCell, RefMut}; use std::cell::{RefCell, RefMut};
use std::collections::BTreeSet; use std::collections::BTreeSet;
use std::io;
use std::rc::Rc; use std::rc::Rc;
#[derive(Eq, PartialEq, Debug, Clone, Hash)] #[derive(Eq, PartialEq, Debug, Clone, Hash)]
@ -584,7 +583,7 @@ impl<S: ReadableEncodedStore> DatasetView<S> {
) -> Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>> { ) -> Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>> {
if graph_name == None { if graph_name == None {
Box::new( Box::new(
map_io_err( map_iter_err(
self.store self.store
.encoded_quads_for_pattern(subject, predicate, object, None), .encoded_quads_for_pattern(subject, predicate, object, None),
) )
@ -595,7 +594,7 @@ impl<S: ReadableEncodedStore> DatasetView<S> {
) )
} else if graph_name == Some(EncodedTerm::DefaultGraph) && self.default_graph_as_union { } else if graph_name == Some(EncodedTerm::DefaultGraph) && self.default_graph_as_union {
Box::new( Box::new(
map_io_err( map_iter_err(
self.store self.store
.encoded_quads_for_pattern(subject, predicate, object, None), .encoded_quads_for_pattern(subject, predicate, object, None),
) )
@ -610,7 +609,7 @@ impl<S: ReadableEncodedStore> DatasetView<S> {
}), }),
) )
} else { } else {
Box::new(map_io_err(self.store.encoded_quads_for_pattern( Box::new(map_iter_err(self.store.encoded_quads_for_pattern(
subject, predicate, object, graph_name, subject, predicate, object, graph_name,
))) )))
} }
@ -624,10 +623,10 @@ impl<S: ReadableEncodedStore> DatasetView<S> {
} }
} }
fn map_io_err<'a, T>( fn map_iter_err<'a, T>(
iter: impl Iterator<Item = Result<T, impl Into<io::Error>>> + 'a, iter: impl Iterator<Item = Result<T, impl Into<EvaluationError>>> + 'a,
) -> impl Iterator<Item = Result<T, EvaluationError>> + 'a { ) -> impl Iterator<Item = Result<T, EvaluationError>> + 'a {
iter.map(|e| e.map_err(|e| e.into().into())) iter.map(|e| e.map_err(|e| e.into()))
} }
impl<S: ReadableEncodedStore> WithStoreError for DatasetView<S> { impl<S: ReadableEncodedStore> WithStoreError for DatasetView<S> {

16
lib/src/store/memory.rs
Unescape View File

@ -1,6 +1,6 @@
//! In-memory store. //! In-memory store.
use crate::error::{Infallible, UnwrapInfallible}; use crate::error::UnwrapInfallible;
use crate::io::{DatasetFormat, GraphFormat}; use crate::io::{DatasetFormat, GraphFormat};
use crate::model::*; use crate::model::*;
use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery}; use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
@ -10,7 +10,7 @@ use crate::store::{
}; };
use std::collections::hash_map::DefaultHasher; use std::collections::hash_map::DefaultHasher;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::convert::TryInto; use std::convert::{Infallible, TryInto};
use std::hash::{BuildHasherDefault, Hash, Hasher}; use std::hash::{BuildHasherDefault, Hash, Hasher};
use std::io::{BufRead, Write}; use std::io::{BufRead, Write};
use std::iter::FromIterator; use std::iter::FromIterator;
@ -276,7 +276,8 @@ impl MemoryStore {
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
let mut store = self; let mut store = self;
load_graph(&mut store, reader, format, to_graph_name, base_iri) load_graph(&mut store, reader, format, to_graph_name, base_iri)?;
Ok(())
} }
/// Loads a dataset file (i.e. quads) into the store. /// Loads a dataset file (i.e. quads) into the store.
@ -309,7 +310,8 @@ impl MemoryStore {
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
let mut store = self; let mut store = self;
load_dataset(&mut store, reader, format, base_iri) load_dataset(&mut store, reader, format, base_iri)?;
Ok(())
} }
/// Adds a quad to this store. /// Adds a quad to this store.
@ -977,7 +979,8 @@ impl<'a> MemoryTransaction<'a> {
to_graph_name: &GraphName, to_graph_name: &GraphName,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_graph(self, reader, format, to_graph_name, base_iri) load_graph(self, reader, format, to_graph_name, base_iri)?;
Ok(())
} }
/// Loads a dataset file (i.e. quads) into the store during the transaction. /// Loads a dataset file (i.e. quads) into the store during the transaction.
@ -1006,7 +1009,8 @@ impl<'a> MemoryTransaction<'a> {
format: DatasetFormat, format: DatasetFormat,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_dataset(self, reader, format, base_iri) load_dataset(self, reader, format, base_iri)?;
Ok(())
} }
/// Adds a quad to this store during the transaction. /// Adds a quad to this store during the transaction.

80
lib/src/store/mod.rs
Unescape View File

@ -28,7 +28,7 @@ use rio_turtle::{
}; };
use rio_xml::{RdfXmlError, RdfXmlFormatter, RdfXmlParser}; use rio_xml::{RdfXmlError, RdfXmlFormatter, RdfXmlParser};
use std::collections::HashMap; use std::collections::HashMap;
use std::error::Error; use std::convert::Infallible;
use std::io; use std::io;
use std::io::{BufRead, Write}; use std::io::{BufRead, Write};
use std::iter::Iterator; use std::iter::Iterator;
@ -57,7 +57,7 @@ fn load_graph<S: WritableEncodedStore>(
format: GraphFormat, format: GraphFormat,
to_graph_name: &GraphName, to_graph_name: &GraphName,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), StoreOrParseError<S::Error, io::Error>> {
let base_iri = base_iri.unwrap_or(""); let base_iri = base_iri.unwrap_or("");
match format { match format {
GraphFormat::NTriples => { GraphFormat::NTriples => {
@ -76,26 +76,30 @@ fn load_from_triple_parser<S: WritableEncodedStore, P: TriplesParser>(
store: &mut S, store: &mut S,
parser: Result<P, P::Error>, parser: Result<P, P::Error>,
to_graph_name: &GraphName, to_graph_name: &GraphName,
) -> Result<(), io::Error> ) -> Result<(), StoreOrParseError<S::Error, io::Error>>
where where
IoOrParseError<P::Error>: From<P::Error>, StoreOrParseError<S::Error, P::Error>: From<P::Error>,
P::Error: Send + Sync + 'static, P::Error: Send + Sync + 'static,
{ {
let mut parser = parser.map_err(invalid_input_error)?; let mut parser = parser.map_err(invalid_input_error)?;
let mut bnode_map = HashMap::default(); let mut bnode_map = HashMap::default();
let to_graph_name = store let to_graph_name = store
.encode_graph_name(to_graph_name) .encode_graph_name(to_graph_name)
.map_err(|e| e.into())?; .map_err(StoreOrParseError::Store)?;
let result: Result<(), IoOrParseError<_>> = parser.parse_all(&mut move |t| { parser
.parse_all(&mut move |t| {
let quad = store let quad = store
.encode_rio_triple_in_graph(t, to_graph_name, &mut bnode_map) .encode_rio_triple_in_graph(t, to_graph_name, &mut bnode_map)
.map_err(|e| IoOrParseError::Io(e.into()))?; .map_err(StoreOrParseError::Store)?;
store store
.insert_encoded(&quad) .insert_encoded(&quad)
.map_err(|e| IoOrParseError::Io(e.into()))?; .map_err(StoreOrParseError::Store)?;
Ok(()) Ok(())
}); })
Ok(result?) .map_err(|e| match e {
StoreOrParseError::Store(e) => StoreOrParseError::Store(e),
StoreOrParseError::Parse(e) => StoreOrParseError::Parse(invalid_data_error(e)),
})
} }
fn dump_graph( fn dump_graph(
@ -138,7 +142,7 @@ fn load_dataset<S: WritableEncodedStore>(
reader: impl BufRead, reader: impl BufRead,
format: DatasetFormat, format: DatasetFormat,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), StoreOrParseError<S::Error, io::Error>> {
let base_iri = base_iri.unwrap_or(""); let base_iri = base_iri.unwrap_or("");
match format { match format {
DatasetFormat::NQuads => load_from_quad_parser(store, NQuadsParser::new(reader)), DatasetFormat::NQuads => load_from_quad_parser(store, NQuadsParser::new(reader)),
@ -149,23 +153,27 @@ fn load_dataset<S: WritableEncodedStore>(
fn load_from_quad_parser<S: WritableEncodedStore, P: QuadsParser>( fn load_from_quad_parser<S: WritableEncodedStore, P: QuadsParser>(
store: &mut S, store: &mut S,
parser: Result<P, P::Error>, parser: Result<P, P::Error>,
) -> Result<(), io::Error> ) -> Result<(), StoreOrParseError<S::Error, io::Error>>
where where
IoOrParseError<P::Error>: From<P::Error>, StoreOrParseError<S::Error, P::Error>: From<P::Error>,
P::Error: Send + Sync + 'static, P::Error: Send + Sync + 'static,
{ {
let mut parser = parser.map_err(invalid_input_error)?; let mut parser = parser.map_err(invalid_input_error)?;
let mut bnode_map = HashMap::default(); let mut bnode_map = HashMap::default();
let result: Result<(), IoOrParseError<_>> = parser.parse_all(&mut move |q| { parser
.parse_all(&mut move |q| {
let quad = store let quad = store
.encode_rio_quad(q, &mut bnode_map) .encode_rio_quad(q, &mut bnode_map)
.map_err(|e| IoOrParseError::Io(e.into()))?; .map_err(StoreOrParseError::Store)?;
store store
.insert_encoded(&quad) .insert_encoded(&quad)
.map_err(|e| IoOrParseError::Io(e.into()))?; .map_err(StoreOrParseError::Store)?;
Ok(()) Ok(())
}); })
Ok(result?) .map_err(|e| match e {
StoreOrParseError::Store(e) => StoreOrParseError::Store(e),
StoreOrParseError::Parse(e) => StoreOrParseError::Parse(invalid_data_error(e)),
})
} }
fn dump_dataset( fn dump_dataset(
@ -192,34 +200,42 @@ fn dump_dataset(
Ok(()) Ok(())
} }
enum IoOrParseError<E: Sized> { enum StoreOrParseError<S, P> {
Io(io::Error), Store(S),
Parse(E), Parse(P),
} }
impl<E: Sized> From<io::Error> for IoOrParseError<E> { impl<S> From<TurtleError> for StoreOrParseError<S, TurtleError> {
fn from(error: io::Error) -> Self { fn from(error: TurtleError) -> Self {
Self::Io(error) Self::Parse(error)
} }
} }
impl From<TurtleError> for IoOrParseError<TurtleError> { impl<S> From<RdfXmlError> for StoreOrParseError<S, RdfXmlError> {
fn from(error: TurtleError) -> Self { fn from(error: RdfXmlError) -> Self {
Self::Parse(error) Self::Parse(error)
} }
} }
impl From<RdfXmlError> for IoOrParseError<RdfXmlError> { impl<S> From<io::Error> for StoreOrParseError<S, io::Error> {
fn from(error: RdfXmlError) -> Self { fn from(error: io::Error) -> Self {
Self::Parse(error) Self::Parse(error)
} }
} }
impl<E: Sized + Error + Send + Sync + 'static> From<IoOrParseError<E>> for io::Error { impl<P: Into<io::Error>> From<StoreOrParseError<io::Error, P>> for io::Error {
fn from(error: IoOrParseError<E>) -> Self { fn from(error: StoreOrParseError<io::Error, P>) -> Self {
match error {
StoreOrParseError::Store(error) => error,
StoreOrParseError::Parse(error) => error.into(),
}
}
}
impl<P: Into<io::Error>> From<StoreOrParseError<Infallible, P>> for io::Error {
fn from(error: StoreOrParseError<Infallible, P>) -> Self {
match error { match error {
IoOrParseError::Io(error) => error, StoreOrParseError::Store(error) => match error {},
IoOrParseError::Parse(error) => invalid_data_error(error), StoreOrParseError::Parse(error) => error.into(),
} }
} }
} }

6
lib/src/store/numeric_encoder.rs
Unescape View File

@ -1,12 +1,14 @@
#![allow(clippy::unreadable_literal)] #![allow(clippy::unreadable_literal)]
use crate::error::{invalid_data_error, Infallible}; use crate::error::invalid_data_error;
use crate::model::xsd::*; use crate::model::xsd::*;
use crate::model::*; use crate::model::*;
use crate::sparql::EvaluationError;
use rand::random; use rand::random;
use rio_api::model as rio; use rio_api::model as rio;
use siphasher::sip128::{Hasher128, SipHasher24}; use siphasher::sip128::{Hasher128, SipHasher24};
use std::collections::HashMap; use std::collections::HashMap;
use std::convert::Infallible;
use std::error::Error; use std::error::Error;
use std::hash::Hash; use std::hash::Hash;
use std::hash::Hasher; use std::hash::Hasher;
@ -763,7 +765,7 @@ pub fn write_term(sink: &mut Vec<u8>, term: EncodedTerm) {
} }
pub(crate) trait WithStoreError { pub(crate) trait WithStoreError {
type Error: Error + Into<io::Error> + 'static; type Error: Error + Into<EvaluationError> + 'static;
} }
pub(crate) trait StrLookup: WithStoreError { pub(crate) trait StrLookup: WithStoreError {

17
lib/src/store/rocksdb.rs
Unescape View File

@ -1,6 +1,6 @@
//! Store based on the [RocksDB](https://rocksdb.org/) key-value database. //! Store based on the [RocksDB](https://rocksdb.org/) key-value database.
use crate::error::{invalid_data_error, Infallible, UnwrapInfallible}; use crate::error::{invalid_data_error, UnwrapInfallible};
use crate::io::{DatasetFormat, GraphFormat}; use crate::io::{DatasetFormat, GraphFormat};
use crate::model::*; use crate::model::*;
use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery}; use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
@ -9,7 +9,7 @@ use crate::store::{
dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore, dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore,
}; };
use rocksdb::*; use rocksdb::*;
use std::convert::TryInto; use std::convert::{Infallible, TryInto};
use std::io; use std::io;
use std::io::{BufRead, Cursor, Write}; use std::io::{BufRead, Cursor, Write};
use std::mem::{take, transmute}; use std::mem::{take, transmute};
@ -576,7 +576,8 @@ impl RocksDbTransaction<'_> {
to_graph_name: &GraphName, to_graph_name: &GraphName,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_graph(&mut self.inner, reader, syntax, to_graph_name, base_iri) load_graph(&mut self.inner, reader, syntax, to_graph_name, base_iri)?;
Ok(())
} }
/// Loads a dataset file (i.e. quads) into the store. into the store during the transaction. /// Loads a dataset file (i.e. quads) into the store. into the store during the transaction.
@ -595,7 +596,8 @@ impl RocksDbTransaction<'_> {
format: DatasetFormat, format: DatasetFormat,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_dataset(&mut self.inner, reader, format, base_iri) load_dataset(&mut self.inner, reader, format, base_iri)?;
Ok(())
} }
/// Adds a quad to this store during the transaction. /// Adds a quad to this store during the transaction.
@ -703,18 +705,19 @@ impl WithStoreError for AutoBatchWriter<'_> {
impl StrContainer for AutoBatchWriter<'_> { impl StrContainer for AutoBatchWriter<'_> {
fn insert_str(&mut self, key: StrHash, value: &str) -> Result<(), io::Error> { fn insert_str(&mut self, key: StrHash, value: &str) -> Result<(), io::Error> {
Ok(self.inner.insert_str(key, value)?) self.inner.insert_str(key, value).unwrap_infallible();
Ok(())
} }
} }
impl WritableEncodedStore for AutoBatchWriter<'_> { impl WritableEncodedStore for AutoBatchWriter<'_> {
fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> { fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
self.inner.insert_encoded(quad)?; self.inner.insert_encoded(quad).unwrap_infallible();
self.apply_if_big() self.apply_if_big()
} }
fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> { fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
self.inner.remove_encoded(quad)?; self.inner.remove_encoded(quad).unwrap_infallible();
self.apply_if_big() self.apply_if_big()
} }
} }

16
lib/src/store/sled.rs
Unescape View File

@ -1,6 +1,6 @@
//! Store based on the [Sled](https://sled.rs/) key-value database. //! Store based on the [Sled](https://sled.rs/) key-value database.
use crate::error::{invalid_data_error, Infallible, UnwrapInfallible}; use crate::error::{invalid_data_error, UnwrapInfallible};
use crate::io::{DatasetFormat, GraphFormat}; use crate::io::{DatasetFormat, GraphFormat};
use crate::model::*; use crate::model::*;
use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery}; use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
@ -9,7 +9,7 @@ use crate::store::{
dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore, dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore,
}; };
use sled::{Batch, Config, Iter, Tree}; use sled::{Batch, Config, Iter, Tree};
use std::convert::TryInto; use std::convert::{Infallible, TryInto};
use std::io::{BufRead, Cursor, Write}; use std::io::{BufRead, Cursor, Write};
use std::path::Path; use std::path::Path;
use std::{fmt, io, str}; use std::{fmt, io, str};
@ -184,7 +184,8 @@ impl SledStore {
format, format,
to_graph_name, to_graph_name,
base_iri, base_iri,
) )?;
Ok(())
} }
/// Loads a dataset file (i.e. quads) into the store. /// Loads a dataset file (i.e. quads) into the store.
@ -203,7 +204,8 @@ impl SledStore {
format: DatasetFormat, format: DatasetFormat,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_dataset(&mut DirectWriter::new(self), reader, format, base_iri) load_dataset(&mut DirectWriter::new(self), reader, format, base_iri)?;
Ok(())
} }
/// Adds a quad to this store. /// Adds a quad to this store.
@ -671,7 +673,8 @@ impl SledTransaction<'_> {
to_graph_name: &GraphName, to_graph_name: &GraphName,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_graph(&mut self.inner, reader, format, to_graph_name, base_iri) load_graph(&mut self.inner, reader, format, to_graph_name, base_iri)?;
Ok(())
} }
/// Loads a dataset file (i.e. quads) into the store. into the store during the transaction. /// Loads a dataset file (i.e. quads) into the store. into the store during the transaction.
@ -690,7 +693,8 @@ impl SledTransaction<'_> {
format: DatasetFormat, format: DatasetFormat,
base_iri: Option<&str>, base_iri: Option<&str>,
) -> Result<(), io::Error> { ) -> Result<(), io::Error> {
load_dataset(&mut self.inner, reader, format, base_iri) load_dataset(&mut self.inner, reader, format, base_iri)?;
Ok(())
} }
/// Adds a quad to this store during the transaction. /// Adds a quad to this store during the transaction.

Write Preview
Loading…
Cancel
Save