Dataquay::BasicStore Class Reference

BasicStore is an in-memory RDF data store implementing the Store interface, providing add, remove, matching and query operations for RDF triples and SPARQL, as well as export and import. More...

#include <dataquay/BasicStore.h>

Inheritance diagram for Dataquay::BasicStore:

Public Types
enum	ImportDuplicatesMode { ImportIgnoreDuplicates , ImportFailOnDuplicates , ImportPermitDuplicates }
	ImportDuplicatesMode determines the outcome when an import operation encounters a triple in the imported data set that already exists in the store. More...
enum	Feature { ModifyFeature , QueryFeature , RemoteImportFeature }
	Feature defines the set of optional features a Store implementation may support. More...
typedef QSet< Feature >	Features

Public Member Functions
	BasicStore ()
	~BasicStore ()
void	setBaseUri (Uri uri)
	Set the base URI for the store.
Uri	getBaseUri () const
	Retrieve the base URI for the store.
void	clear ()
	Empty the store of triples.
void	addPrefix (QString prefix, Uri uri)
	Add a prefix/uri pair (an XML namespace, except that this class doesn't directly deal in XML) for use in subsequent operations.
bool	add (Triple t)
	Add a triple to the store.
bool	remove (Triple t)
	Remove a triple from the store.
void	change (ChangeSet changes)
	Atomically apply the sequence of add/remove changes described in the given ChangeSet.
void	revert (ChangeSet changes)
	Atomically apply the sequence of add/remove changes described in the given ChangeSet, in reverse (ie removing adds and adding removes, in reverse order).
bool	contains (Triple t) const
	Return true if the store contains the given triple, false otherwise.
Triples	match (Triple t) const
	Return all triples matching the given wildcard triple.
ResultSet	query (QString sparql) const
	Run a SPARQL query against the store and return its results.
Node	complete (Triple t) const
	Given a triple in which any two nodes are specified and the other is a wildcard node of type Nothing, return a node that can be substituted for the Nothing node in order to complete a triple that exists in the store.
Triple	matchOnce (Triple t) const
	Return a triple from the store that matches the given wildcard triple, or the empty triple if none matches.
Node	queryOnce (QString sparql, QString bindingName) const
	Run a SPARQL query against the store and return the node of the first result for the given query binding.
Uri	getUniqueUri (QString prefix) const
	Get a new URI, starting with the given prefix (e.g.
Node	addBlankNode ()
	Create and return a new blank node.
Uri	expand (QString uri) const
	Expand the given URI (which may use local namespaces) and prefix-expand it, returning the result as a Uri.
void	save (QString filename) const
	Export the store to an RDF/TTL file with the given filename.
void	import (QUrl url, ImportDuplicatesMode idm, QString format="")
	Import the RDF document found at the given URL into the current store (in addition to its existing contents).
void	importString (QString encodedRdf, Uri baseUri, ImportDuplicatesMode idm, QString format="")
	Import the RDF document encoded in the given string into the current store (in addition to its existing contents).
Features	getSupportedFeatures () const
	Retrieve the set of optional features supported by this Store implementation.

Static Public Member Functions
static BasicStore *	load (QUrl url, QString format="")
	Construct a new BasicStore from the RDF document at the given URL.
static BasicStore *	loadString (QString encodedRdf, Uri baseUri, QString format="")
	Construct a new BasicStore from the RDF document encoded in the given string.

Detailed Description

BasicStore is an in-memory RDF data store implementing the Store interface, providing add, remove, matching and query operations for RDF triples and SPARQL, as well as export and import.

BasicStore uses a Redland or Sord datastore internally, depending on whether USE_REDLAND or USE_SORD was defined when Dataquay was built.

All operations are thread safe.

Definition at line 55 of file BasicStore.h.

Member Typedef Documentation

Features

QSet<Feature> Dataquay::Store::Features

inherited

Definition at line 290 of file Store.h.

Member Enumeration Documentation

ImportDuplicatesMode

enum Dataquay::Store::ImportDuplicatesMode

inherited

ImportDuplicatesMode determines the outcome when an import operation encounters a triple in the imported data set that already exists in the store.

ImportIgnoreDuplicates: Any duplicate of a triple that is already in the store is discarded without comment.

ImportFailOnDuplicates: Import will fail with an RDFDuplicateImportException if any duplicate of a triple already in the store is found, and nothing will be imported.

ImportPermitDuplicates: No tests for duplicate triples will be carried out, and the behaviour when duplicates are imported will depend on the underlying store implementation (which may merge them or store them as separate duplicate triples). This is usually inadvisable: besides its unpredictability, this class does not generally handle duplicate triples well in other contexts.

Enumerator
ImportIgnoreDuplicates
ImportFailOnDuplicates
ImportPermitDuplicates

Definition at line 222 of file Store.h.

Feature

enum Dataquay::Store::Feature

inherited

Feature defines the set of optional features a Store implementation may support.

Code that uses Store should check that the features it requires are available before trying to make use of them.

ModifyFeature: The store can be modified (triples can be added to it). All current Store implementations support this feature.

QueryFeature: The store supports SPARQL queries through the query and queryOnce methods. A store that does not support queries will throw RDFUnsupportedError when these functions are called.

RemoteImportFeature: The store can import URLs that represent network resources as well as URLs referring to files on the local disc. The extent to which this feature is actually available may also depend on the configuration of the underlying RDF library. A store that does not support remote URLs will fail as if the resource was absent, when asked to load one.

Enumerator
ModifyFeature
QueryFeature
RemoteImportFeature

Definition at line 284 of file Store.h.

Constructor & Destructor Documentation

BasicStore()

Dataquay::BasicStore::BasicStore

(

)

~BasicStore()

Dataquay::BasicStore::~BasicStore

(

)

Member Function Documentation

setBaseUri()

void Dataquay::BasicStore::setBaseUri

(

Uri

uri

)

Set the base URI for the store.

This is used to expand the empty URI prefix when adding and querying triples, and is also used as the document base URI when exporting.

getBaseUri()

Uri Dataquay::BasicStore::getBaseUri

(

)

const

Retrieve the base URI for the store.

clear()

void Dataquay::BasicStore::clear

(

)

Empty the store of triples.

Prefixes that have been added with addPrefix are unaffected. !!! hoist to Store()?

addPrefix()

void Dataquay::BasicStore::addPrefix	(	QString	prefix,
		Uri	uri )

Add a prefix/uri pair (an XML namespace, except that this class doesn't directly deal in XML) for use in subsequent operations.

If the prefix has already been added, this overrides any uri associated with it.

Example: addPrefix("dc", "http://purl.org/dc/elements/1.1/") to add a prefix for the Dublin Core namespace.

The store always knows about the XSD and RDF namespaces.

Note that the base URI is always available as the empty prefix. For example, the URI ":blather" will be expanded to the base URI plus "blather".

add()

bool Dataquay::BasicStore::add ( Triple t )

virtual

Add a triple to the store.

Return false if the triple was already in the store. (Dataquay does not permit duplicate triples in a store.) Throw RDFException if the triple can not be added for some other reason.

Implements Dataquay::Store.

remove()

bool Dataquay::BasicStore::remove ( Triple t )

virtual

Remove a triple from the store.

If some nodes in the triple are Nothing nodes, remove all matching triples. Return false if no matching triple was found in the store. Throw RDFException if removal failed for some other reason.

Implements Dataquay::Store.

change()

void Dataquay::BasicStore::change ( ChangeSet changes )

virtual

Atomically apply the sequence of add/remove changes described in the given ChangeSet.

Throw RDFException if any operation fails for any reason (including duplication etc).

Implements Dataquay::Store.

revert()

void Dataquay::BasicStore::revert ( ChangeSet changes )

virtual

Atomically apply the sequence of add/remove changes described in the given ChangeSet, in reverse (ie removing adds and adding removes, in reverse order).

Throw RDFException if any operation fails for any reason (including duplication etc).

Implements Dataquay::Store.

contains()

bool Dataquay::BasicStore::contains ( Triple t ) const

virtual

Return true if the store contains the given triple, false otherwise.

Throw RDFException if the triple is not complete or if the test failed for any other reason.

Implements Dataquay::Store.

match()

Triples Dataquay::BasicStore::match ( Triple t ) const

virtual

Return all triples matching the given wildcard triple.

A node of type Nothing in any part of the triple matches any node in the data store. Return an empty list if there are no matches; may throw RDFException if matching fails in some other way.

Implements Dataquay::Store.

query()

ResultSet Dataquay::BasicStore::query ( QString sparql ) const

virtual

Run a SPARQL query against the store and return its results.

Any prefixes added previously using addQueryPrefix will be available in this query without needing to be declared in the SPARQL given here (equivalent to writing "PREFIX prefix: <uri>" for each prefix,uri pair set with addPrefix).

May throw RDFException.

Note that the RDF store must have an absolute base URI (rather than the default "#") in order to perform queries, as relative URIs in the query will be interpreted relative to the query base rather than the store and without a proper base URI there is no way to override that internally.

Implements Dataquay::Store.

complete()

Node Dataquay::BasicStore::complete ( Triple t ) const

virtual

Given a triple in which any two nodes are specified and the other is a wildcard node of type Nothing, return a node that can be substituted for the Nothing node in order to complete a triple that exists in the store.

If no matching triple can be found, return a null node. If more than one triple matches, the returned value may arbitrarily be from any of them. May throw RDFException.

Implements Dataquay::Store.

matchOnce()

Triple Dataquay::BasicStore::matchOnce ( Triple t ) const

virtual

Return a triple from the store that matches the given wildcard triple, or the empty triple if none matches.

A node of type Nothing in any part of the triple matches any node in the data store. If more than one triple matches, the returned value may arbitrarily be any of them. May throw RDFException.

Implements Dataquay::Store.

queryOnce()

Node Dataquay::BasicStore::queryOnce ( QString sparql, QString bindingName ) const

virtual

Run a SPARQL query against the store and return the node of the first result for the given query binding.

This is a shorthand for use with queries that are only expected to have one result. May throw RDFException.

Implements Dataquay::Store.

getUniqueUri()

Uri Dataquay::BasicStore::getUniqueUri ( QString prefix ) const

virtual

Get a new URI, starting with the given prefix (e.g.

":event_"), that does not currently exist within this store. The URI will be prefix expanded.

Implements Dataquay::Store.

addBlankNode()

Node Dataquay::BasicStore::addBlankNode ( )

virtual

Create and return a new blank node.

This node can only be referred to using the given Node object, and only during its lifetime within this instance of the store.

Implements Dataquay::Store.

expand()

Uri Dataquay::BasicStore::expand ( QString uri ) const

virtual

Expand the given URI (which may use local namespaces) and prefix-expand it, returning the result as a Uri.

(The Uri class cannot be used to store URIs that have unexpanded namespace prefixes.)

The set of available prefixes for expansion depends on the subclass implementation. See, for example, BasicStore::addPrefix.

Implements Dataquay::Store.

save()

void Dataquay::BasicStore::save ( QString filename ) const

virtual

Export the store to an RDF/TTL file with the given filename.

If the file already exists, it will if possible be overwritten. May throw RDFException, FileOperationFailed, FailedToOpenFile, etc.

Note that unlike import (which takes a URL argument), save takes a simple filename with no file:// prefix.

Implements Dataquay::Store.

import()

void Dataquay::BasicStore::import ( QUrl url, ImportDuplicatesMode idm, QString format = "" )

virtual

Import the RDF document found at the given URL into the current store (in addition to its existing contents).

Its behaviour when a triple is encountered that already exists in the store is controlled by the ImportDuplicatesMode.

May throw RDFException or RDFDuplicateImportException.

Note that the URL must be a URL, not just a filename (i.e. local files need the file: prefix).

If format is specified, it will be taken as the RDF parse format (e.g. ntriples). The set of supported format strings depends on the underlying RDF library configuration. The default is to guess the format if possible.

Implements Dataquay::Store.

importString()

void Dataquay::BasicStore::importString ( QString encodedRdf, Uri baseUri, ImportDuplicatesMode idm, QString format = "" )

virtual

Import the RDF document encoded in the given string into the current store (in addition to its existing contents).

Its behaviour when a triple is encountered that already exists in the store is controlled by the ImportDuplicatesMode.

May throw RDFException or RDFDuplicateImportException.

If format is specified, it will be taken as the RDF parse format (e.g. ntriples). The set of supported format strings depends on the underlying RDF library configuration. The default is to guess the format if possible.

Implements Dataquay::Store.

getSupportedFeatures()

Features Dataquay::BasicStore::getSupportedFeatures ( ) const

virtual

Retrieve the set of optional features supported by this Store implementation.

Implements Dataquay::Store.

load()

static BasicStore * Dataquay::BasicStore::load ( QUrl url, QString format = "" )

static

Construct a new BasicStore from the RDF document at the given URL.

May throw RDFException. The returned BasicStore is owned by the caller and must be deleted using delete when finished with. The return value is never NULL; all errors result in exceptions.

Note that the URL must be a URL, not just a filename (i.e. local files need the file: prefix). The file URL will also become the base URI of the store.

If format is specified, it will be taken as the RDF parse format (e.g. ntriples). The set of supported format strings depends on the underlying RDF library configuration. The default is to guess the format if possible.

loadString()

static BasicStore * Dataquay::BasicStore::loadString ( QString encodedRdf, Uri baseUri, QString format = "" )

static

Construct a new BasicStore from the RDF document encoded in the given string.

May throw RDFException. The returned BasicStore is owned by the caller and must be deleted using delete when finished with. The return value is never NULL; all errors result in exceptions.

If format is specified, it will be taken as the RDF parse format (e.g. ntriples). The set of supported format strings depends on the underlying RDF library configuration. The default is to guess the format if possible.

---

The documentation for this class was generated from the following file:

• BasicStore.h