#include <RedlandModel.h>

Inheritance diagram for knowrob::RedlandModel:

[legend]

Collaboration diagram for knowrob::RedlandModel:

[legend]

Public Member Functions
	RedlandModel ()

	~RedlandModel () override

void	setStorageType (RedlandStorageType storageType)

void	setStorageHashType (RedlandHashType hashType)

void	setHost (std::string_view host)

void	setDatabase (std::string_view database)

void	setUser (std::string_view user)

void	setPassword (std::string_view password)

void	setStorageDirectory (std::string_view dir=".")

void	setHashesStorage (RedlandHashType hashType, std::string_view dir=".")

void	setMemoryStorage ()

void	setRaptorWorld (librdf_world *world)

void	setOrigin (std::string_view origin)

auto	storageType () const

bool	isInitialized () const

bool	initializeBackend ()

bool	initializeBackend (const PropertyTree &config) override

bool	load (const URI &uri, semweb::TripleFormat tripleFormat)

bool	sparql (std::string_view queryString, const BindingsHandler &callback) const override

bool	insertOne (const Triple &triple) override

bool	insertAll (const TripleContainerPtr &triples) override

bool	removeOne (const Triple &triple) override

bool	removeAll (const TripleContainerPtr &triples) override

bool	removeAllWithOrigin (std::string_view origin) override

bool	isPersistent () const override

bool	contains (const Triple &triple) override

void	batch (const TripleHandler &callback) const override

void	batchOrigin (std::string_view origin, const TripleHandler &callback) override

void	match (const TriplePattern &query, const TripleVisitor &visitor) override

	RedlandModel ()

	~RedlandModel () override

void	setStorageType (RedlandStorageType storageType)

void	setStorageHashType (RedlandHashType hashType)

void	setHost (std::string_view host)

void	setDatabase (std::string_view database)

void	setUser (std::string_view user)

void	setPassword (std::string_view password)

void	setStorageDirectory (std::string_view dir=".")

void	setHashesStorage (RedlandHashType hashType, std::string_view dir=".")

void	setMemoryStorage ()

void	setRaptorWorld (librdf_world *world)

void	setOrigin (std::string_view origin)

auto	storageType () const

bool	isInitialized () const

bool	initializeBackend ()

bool	initializeBackend (const PropertyTree &config) override

bool	load (const URI &uri, semweb::TripleFormat tripleFormat)

bool	sparql (std::string_view queryString, const BindingsHandler &callback) const override

bool	insertOne (const Triple &triple) override

bool	insertAll (const TripleContainerPtr &triples) override

bool	removeOne (const Triple &triple) override

bool	removeAll (const TripleContainerPtr &triples) override

bool	removeAllWithOrigin (std::string_view origin) override

bool	isPersistent () const override

bool	contains (const Triple &triple) override

void	batch (const TripleHandler &callback) const override

void	batchOrigin (std::string_view origin, const TripleHandler &callback) override

void	match (const TriplePattern &query, const TripleVisitor &visitor) override

Public Member Functions inherited from knowrob::SPARQLBackend
	SPARQLBackend (SPARQLFlags flags)

bool	query (const SPARQLQuery &query, const BindingsHandler &callback) const

void	query (const GraphQueryPtr &query, const BindingsHandler &callback) override

void	count (const ResourceCounter &callback) const override

	SPARQLBackend (SPARQLFlags flags)

bool	query (const SPARQLQuery &query, const BindingsHandler &callback) const

void	query (const GraphQueryPtr &query, const BindingsHandler &callback) override

void	count (const ResourceCounter &callback) const override

Public Member Functions inherited from knowrob::QueryableStorage
	QueryableStorage (StorageFeatures features=StorageFeature::NothingSpecial)

	~QueryableStorage () override=default

virtual void	foreach (const TripleVisitor &visitor) const

bool	exportTo (const std::string &filename, semweb::TripleFormat format=semweb::RDF_XML) const

std::vector< VersionedOriginPtr >	getOrigins ()

std::optional< std::string >	getVersionOfOrigin (std::string_view origin)

void	setVersionOfOrigin (std::string_view origin, std::string_view version)

void	dropSessionOrigins ()

GraphQueryExpansionPtr	expand (const GraphQueryPtr &q)

	QueryableStorage (StorageFeatures features=StorageFeature::NothingSpecial)

	~QueryableStorage () override=default

virtual void	foreach (const TripleVisitor &visitor) const

bool	exportTo (const std::string &filename, semweb::TripleFormat format=semweb::RDF_XML) const

std::vector< VersionedOriginPtr >	getOrigins ()

std::optional< std::string >	getVersionOfOrigin (std::string_view origin)

void	setVersionOfOrigin (std::string_view origin, std::string_view version)

void	dropSessionOrigins ()

GraphQueryExpansionPtr	expand (const GraphQueryPtr &q)

Public Member Functions inherited from knowrob::Storage
	Storage (StorageFeatures features=StorageFeature::NothingSpecial)

virtual	~Storage ()=default

PluginLanguage	storageLanguage () const

const auto &	vocabulary () const

void	setVocabulary (std::shared_ptr< Vocabulary > vocabulary)

bool	supports (StorageFeature feature) const

std::optional< std::string >	getVersionOfOrigin (std::string_view origin) const

void	setVersionOfOrigin (std::string_view origin, std::optional< std::string_view > version)

	Storage (StorageFeatures features=StorageFeature::NothingSpecial)

virtual	~Storage ()=default

PluginLanguage	storageLanguage () const

const auto &	vocabulary () const

void	setVocabulary (std::shared_ptr< Vocabulary > vocabulary)

bool	supports (StorageFeature feature) const

std::optional< std::string >	getVersionOfOrigin (std::string_view origin) const

void	setVersionOfOrigin (std::string_view origin, std::optional< std::string_view > version)

Public Member Functions inherited from knowrob::DataSourceHandler
	DataSourceHandler ()=default

virtual	~DataSourceHandler ()=default

void	addDataHandler (const std::string &format, const DataSourceLoader &fn)

bool	loadDataSource (const DataSourcePtr &dataSource)

bool	hasDataHandler (const DataSourcePtr &dataSource) const

	DataSourceHandler ()=default

virtual	~DataSourceHandler ()=default

void	addDataHandler (const std::string &format, const DataSourceLoader &fn)

bool	loadDataSource (const DataSourcePtr &dataSource)

bool	hasDataHandler (const DataSourcePtr &dataSource) const

Static Public Attributes
static constexpr std::string_view	QUERY_LANGUAGE_SPARQL = "sparql"

Static Public Attributes inherited from knowrob::QueryableStorage
static AtomPtr	versionProperty = IRIAtom::Tabled("http://knowrob.org/kb/knowrob.owl#hasVersionOfOrigin")

Protected Member Functions
RedlandURI &	xsdURI (XSDType xsdType)

std::string	getStorageOptions () const

void	knowrobToRaptor (const Triple &triple, raptor_statement *raptorTriple)

void	knowrobToRaptor (const TriplePattern &pat, raptor_statement *raptorTriple)

raptor_term *	knowrobToRaptor (const TermPtr &term)

librdf_node *	getContextNode (std::string_view origin)

librdf_node *	getContextNode (const Triple &triple)

RedlandURI &	xsdURI (XSDType xsdType)

std::string	getStorageOptions () const

void	knowrobToRaptor (const Triple &triple, raptor_statement *raptorTriple)

void	knowrobToRaptor (const TriplePattern &pat, raptor_statement *raptorTriple)

raptor_term *	knowrobToRaptor (const TermPtr &term)

librdf_node *	getContextNode (std::string_view origin)

librdf_node *	getContextNode (const Triple &triple)

Protected Member Functions inherited from knowrob::Storage
void	enableFeature (StorageFeature feature)

void	setStorageLanguage (PluginLanguage storageLanguage)

void	enableFeature (StorageFeature feature)

void	setStorageLanguage (PluginLanguage storageLanguage)

Protected Member Functions inherited from knowrob::DataSourceHandler
virtual bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &)

virtual bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &)

Protected Attributes
librdf_world *	ownedWorld_

librdf_world *	world_

librdf_model *	model_

librdf_storage *	storage_

RedlandURI	xsdURIs_ [static_cast< int >(XSDType::LAST)]

std::map< std::string, librdf_node *, std::less<> >	contextNodes_

std::string	storageName_

std::optional< std::string >	origin_

std::optional< std::string >	host_

std::optional< std::string >	port_

std::optional< std::string >	database_

std::optional< std::string >	user_

std::optional< std::string >	password_

std::optional< std::string >	storageDir_

std::optional< RedlandHashType >	hashType_

RedlandStorageType	storageType_

std::string	storageOptions_

Protected Attributes inherited from knowrob::SPARQLBackend
SPARQLFlags	sparqlFlags_

Protected Attributes inherited from knowrob::Storage
std::map< std::string, std::string >	originVersions_

std::shared_ptr< Vocabulary >	vocabulary_

StorageFeatures	features_

PluginLanguage	storageLanguage_

Protected Attributes inherited from knowrob::DataSourceHandler
std::map< std::string, DataSourceLoader >	dataSourceHandler_

Additional Inherited Members
Static Public Member Functions inherited from knowrob::QueryableStorage
static std::shared_ptr< AnswerYes >	yes (const GraphPathQueryPtr &original, const GraphQueryExpansionPtr &expansion, const BindingsPtr &bindings)

static std::shared_ptr< AnswerNo >	no (const GraphPathQueryPtr &q)

static std::shared_ptr< AnswerYes >	yes (const GraphPathQueryPtr &original, const GraphQueryExpansionPtr &expansion, const BindingsPtr &bindings)

static std::shared_ptr< AnswerNo >	no (const GraphPathQueryPtr &q)

Detailed Description

Interface for a Redland model. A redland model is a triple store that can be queried with SPARQL. It can interface with different storage types, such as in-memory, MySQL, PostgreSQL, and SQLite, and can load and save triples in different formats, such as RDF/XML, Turtle, and N-Triples. It can further interface with SPARQL endpoints.

Definition at line 52 of file RedlandModel.h.

Constructor & Destructor Documentation

◆ RedlandModel() [1/2]

RedlandModel::RedlandModel ( )

Definition at line 79 of file RedlandModel.cpp.

         : SPARQLBackend(SPARQLFlag::NOT_EXISTS_UNSUPPORTED),
           ownedWorld_(nullptr),
           world_(nullptr),
           model_(nullptr),
           storage_(nullptr),
           storageType_(RedlandStorageType::MEMORY) {
 }

◆ ~RedlandModel() [1/2]

RedlandModel::~RedlandModel ( )

override

Definition at line 88 of file RedlandModel.cpp.

                             {
     finalize();
 }

◆ RedlandModel() [2/2]

knowrob::RedlandModel::RedlandModel ( )

◆ ~RedlandModel() [2/2]

knowrob::RedlandModel::~RedlandModel ( )

override

Member Function Documentation

◆ batch() [1/2]

void RedlandModel::batch ( const TripleHandler & callback ) const

overridevirtual

Iterate over all triples in the model.

Parameters

callback the callback to handle the triples.

Returns: true if the iteration was successful.

Implements knowrob::QueryableStorage.

Definition at line 437 of file RedlandModel.cpp.

                                                             {
     auto triples = std::make_shared<RaptorContainer>(GlobalSettings::batchSize());
     auto contexts = librdf_model_get_contexts(model_);
     while (!librdf_iterator_end(contexts)) {
         batch_(model_, (librdf_node *) librdf_iterator_get_object(contexts), triples, callback);
         librdf_iterator_next(contexts);
     }
     if (triples->size() > 0) {
         triples->shrink();
         callback(triples);
     }
     librdf_free_iterator(contexts);
 }

◆ batch() [2/2]

void knowrob::RedlandModel::batch ( const TripleHandler & callback ) const

overridevirtual

Iterate over all triples in the model.

Parameters

callback the callback to handle the triples.

Returns: true if the iteration was successful.

Implements knowrob::QueryableStorage.

◆ batchOrigin() [1/2]

void RedlandModel::batchOrigin	(	std::string_view	origin,
		const TripleHandler &	callback
	)

overridevirtual

Iterate over all triples in the model that have a given origin.

Parameters

origin	the origin of the triples.
callback	the callback to handle the triples.

Returns: true if the iteration was successful.

Implements knowrob::QueryableStorage.

Definition at line 451 of file RedlandModel.cpp.

                                                                                    {
     auto triples = std::make_shared<RaptorContainer>(GlobalSettings::batchSize());
     batch_(model_, getContextNode(origin), triples, callback);
     if (triples->size() > 0) {
         triples->shrink();
         callback(triples);
     }
 }

◆ batchOrigin() [2/2]

void knowrob::RedlandModel::batchOrigin	(	std::string_view	origin,
		const TripleHandler &	callback
	)

overridevirtual

Iterate over all triples in the model that have a given origin.

Parameters

origin	the origin of the triples.
callback	the callback to handle the triples.

Returns: true if the iteration was successful.

Implements knowrob::QueryableStorage.

◆ contains() [1/2]

bool RedlandModel::contains ( const Triple & triple )

overridevirtual

Parameters

triple a framed triple.

Returns: true if the model contains the triple.

Reimplemented from knowrob::QueryableStorage.

Definition at line 460 of file RedlandModel.cpp.

                                                 {
     auto raptorTriple = librdf_new_statement(world_);
     knowrobToRaptor(triple, raptorTriple);
     auto result = librdf_model_contains_statement(model_, raptorTriple);
     librdf_free_statement(raptorTriple);
     return result;
 }

◆ contains() [2/2]

bool knowrob::RedlandModel::contains ( const Triple & triple )

overridevirtual

Parameters

triple a framed triple.

Returns: true if the model contains the triple.

Reimplemented from knowrob::QueryableStorage.

◆ getContextNode() [1/4]

librdf_node * RedlandModel::getContextNode ( const Triple & triple )

protected

Definition at line 557 of file RedlandModel.cpp.

                                                               {
     return getContextNode(
             triple.graph() ? triple.graph().value() :
             origin_.has_value() ? origin_.value() :
             ImportHierarchy::ORIGIN_USER);
 }

◆ getContextNode() [2/4]

librdf_node* knowrob::RedlandModel::getContextNode ( const Triple & triple )

protected

◆ getContextNode() [3/4]

librdf_node * RedlandModel::getContextNode ( std::string_view origin )

protected

Definition at line 545 of file RedlandModel.cpp.

                                                                {
     auto it = contextNodes_.find(origin);
     if (it != contextNodes_.end()) {
         return it->second;
     }
     auto contextNode = librdf_new_node_from_uri_string(
             world_,
             (const unsigned char *) origin.data());
     contextNodes_[std::string(origin)] = contextNode;
     return contextNode;
 }

◆ getContextNode() [4/4]

librdf_node* knowrob::RedlandModel::getContextNode ( std::string_view origin )

protected

◆ getStorageOptions() [1/2]

std::string RedlandModel::getStorageOptions ( ) const

protected

Definition at line 259 of file RedlandModel.cpp.

                                                 {
     using OptPair_o = std::pair<std::string, std::optional<std::string>>;
     std::vector<std::pair<std::string, std::string>> opts;
     for (auto &option: {
             OptPair_o{"host", host_},
             OptPair_o{"port", port_},
             OptPair_o{"database", database_},
             OptPair_o{"user", user_},
             OptPair_o{"password", password_},
             OptPair_o{"dir", storageDir_}}) {
         if (option.second.has_value()) {
             opts.emplace_back(option.first, option.second.value());
         }
     }
     // "hash-type" is required by "hashes" storage type
     if (hashType_.has_value()) {
         switch (hashType_.value()) {
             case RedlandHashType::MEMORY:
                 opts.emplace_back("hash-type", "memory");
                 break;
             case RedlandHashType::BDB:
                 opts.emplace_back("hash-type", "bdb");
                 break;
         }
     }
     // context support currently is required which limits the storage types we can use.
     // but "memory" and "hashes" can do it.
     opts.emplace_back("contexts", "yes");
     std::stringstream ss;
     for (std::size_t i = 0; i < opts.size(); i++) {
         ss << opts[i].first << "='" << opts[i].second << '\'';
         if (i < opts.size() - 1) {
             ss << ",";
         }
     }
     return ss.str();
 }

◆ getStorageOptions() [2/2]

std::string knowrob::RedlandModel::getStorageOptions ( ) const

protected

◆ initializeBackend() [1/4]

bool RedlandModel::initializeBackend ( )

Initialize the backend.

Returns: true if the backend was initialized successfully.

Definition at line 174 of file RedlandModel.cpp.

                                      {
     if (isInitialized()) {
         KB_WARN("RedlandModel already initialized.");
         return false;
     }
  
     // initialize the world if it hasn't been set before
     if (!world_) {
         ownedWorld_ = world_ = librdf_new_world();
         if (!world_) {
             throw StorageError("Failed to create Redland world.");
         }
         librdf_world_open(world_);
         librdf_world_set_logger(world_, nullptr, logRedlandMessage);
     }
  
     // initialize the storage
     storageOptions_ = getStorageOptions();
     const char *storageOptions = storageOptions_.empty() ? nullptr : storageOptions_.c_str();
     const char *storageType = getStorageTypeString(storageType_);
     const char *storageName = origin_.has_value() ? origin_.value().c_str() : "knowrob";
     KB_INFO("[redland] using storage of type \"{}\" with name \"{}\" and options \"{}\".",
             storageType, storageName, storageOptions);
     storage_ = librdf_new_storage(world_,
                                   storageType,
                                   storageName,
                                   storageOptions);
     if (!storage_) {
         throw StorageError("Failed to create Redland storage for type \"{}\".", storageType);
     }
  
     // initialize the model
     static const char *modelOptions = nullptr;
     model_ = librdf_new_model(world_, storage_, modelOptions);
     if (!model_) {
         librdf_free_storage(storage_);
         storage_ = nullptr;
         throw StorageError("Failed to create Redland model for storage type \"{}\".", storageType);
     }
  
     // initialize URIs
     for (int i = 0; i != static_cast<int>(XSDType::LAST); i++) {
         xsdURIs_[i].set(world_, xsdTypeToIRI((XSDType) i));
     }
  
     return true;
 }

◆ initializeBackend() [2/4]

bool knowrob::RedlandModel::initializeBackend ( )

Initialize the backend.

Returns: true if the backend was initialized successfully.

◆ initializeBackend() [3/4]

bool RedlandModel::initializeBackend ( const PropertyTree & config )

overridevirtual

Initialize this backend from a property tree.

Parameters

config a property tree.

Returns: true on success

Implements knowrob::Storage.

Definition at line 222 of file RedlandModel.cpp.

                                                               {
     if (isInitialized()) {
         KB_WARN("RedlandModel already initialized.");
         return false;
     }
     auto o_host = ptree->get_optional<std::string>(REDLAND_SETTING_HOST);
     auto o_port = ptree->get_optional<std::string>(REDLAND_SETTING_PORT);
     auto o_user = ptree->get_optional<std::string>(REDLAND_SETTING_USER);
     auto o_password = ptree->get_optional<std::string>(REDLAND_SETTING_PASSWORD);
     auto o_db = ptree->get_optional<std::string>(REDLAND_SETTING_DB);
     auto o_origin = ptree->get_optional<std::string>(REDLAND_SETTING_ORIGIN);
     auto o_storage = ptree->get_optional<std::string>(REDLAND_SETTING_STORAGE);
  
     if (o_host) host_ = o_host.value();
     if (o_port) port_ = o_port.value();
     if (o_user) user_ = o_user.value();
     if (o_password) password_ = o_password.value();
     if (o_db) database_ = o_db.value();
     if (o_origin) origin_ = o_origin.value();
     if (o_storage) {
         storageType_ = RedlandStorageType::MEMORY;
         if (o_storage.value() == "hashes") {
             storageType_ = RedlandStorageType::HASHES;
         } else if (o_storage.value() == "mysql") {
             storageType_ = RedlandStorageType::MYSQL;
         } else if (o_storage.value() == "postgresql") {
             storageType_ = RedlandStorageType::POSTGRESQL;
         } else if (o_storage.value() == "sqlite") {
             storageType_ = RedlandStorageType::SQLITE;
         } else {
             KB_WARN("Unknown storage type \"{}\", falling back to memory.", o_storage.value());
         }
     }
     // finally call initializeBackend()
     return initializeBackend();
 }

◆ initializeBackend() [4/4]

bool knowrob::RedlandModel::initializeBackend ( const PropertyTree & config )

overridevirtual

Initialize this backend from a property tree.

Parameters

config a property tree.

Returns: true on success

Implements knowrob::Storage.

◆ insertAll() [1/2]

bool RedlandModel::insertAll ( const TripleContainerPtr & triples )

overridevirtual

Add assertions to this backend.

Parameters

triples a set of triples.

Returns: true on success

Implements knowrob::Storage.

Definition at line 362 of file RedlandModel.cpp.

                                                               {
     // insert all triples into an in-memory model.
     // only after all triples are inserted, the model is transformed and then pushed to the next stage.
     for (auto &knowrobTriple: *triples) {
         auto raptorTriple = librdf_new_statement(world_);
         // map the knowrob triple into a raptor triple
         knowrobToRaptor(*knowrobTriple, raptorTriple);
         librdf_model_context_add_statement(model_, getContextNode(*knowrobTriple), raptorTriple);
         librdf_free_statement(raptorTriple);
     }
     return true;
 }

◆ insertAll() [2/2]

bool knowrob::RedlandModel::insertAll ( const TripleContainerPtr & triples )

overridevirtual

Add assertions to this backend.

Parameters

triples a set of triples.

Returns: true on success

Implements knowrob::Storage.

◆ insertOne() [1/2]

bool RedlandModel::insertOne ( const Triple & triple )

overridevirtual

Add an assertion to this backend.

Parameters

triple a triple.

Returns: true on success

Implements knowrob::Storage.

Definition at line 352 of file RedlandModel.cpp.

                                                         {
     auto raptorTriple = librdf_new_statement(world_);
     // map the knowrob triple into a raptor triple
     knowrobToRaptor(knowrobTriple, raptorTriple);
     // add the triple together with a context node holding the origin literal
     librdf_model_context_add_statement(model_, getContextNode(knowrobTriple), raptorTriple);
     librdf_free_statement(raptorTriple);
     return true;
 }

◆ insertOne() [2/2]

bool knowrob::RedlandModel::insertOne ( const Triple & triple )

overridevirtual

Add an assertion to this backend.

Parameters

triple a triple.

Returns: true on success

Implements knowrob::Storage.

◆ isInitialized() [1/2]

bool RedlandModel::isInitialized ( ) const

Returns: true if the model is initialized.

Definition at line 117 of file RedlandModel.cpp.

                                        {
     return model_ != nullptr;
 }

◆ isInitialized() [2/2]

bool knowrob::RedlandModel::isInitialized ( ) const

Returns: true if the model is initialized.

◆ isPersistent() [1/2]

bool RedlandModel::isPersistent ( ) const

overridevirtual

Returns: true if the backend is persistent.

Implements knowrob::QueryableStorage.

Definition at line 121 of file RedlandModel.cpp.

                                       {
     return storageType_ != RedlandStorageType::MEMORY &&
            storageType_ != RedlandStorageType::HASHES;
 }

◆ isPersistent() [2/2]

bool knowrob::RedlandModel::isPersistent ( ) const

overridevirtual

Returns: true if the backend is persistent.

Implements knowrob::QueryableStorage.

◆ knowrobToRaptor() [1/6]

raptor_term * RedlandModel::knowrobToRaptor ( const TermPtr & term )

protected

Definition at line 568 of file RedlandModel.cpp.

                                                               {
     if (!term || !term->isAtomic()) {
         return nullptr;
     }
     auto atomic = std::static_pointer_cast<Atomic>(term);
     if (term->isIRI()) {
         return KNOWROB_RDF_NEW_URI(atomic->stringForm());
     } else if (term->isBlank()) {
         return KNOWROB_RDF_NEW_BLANK(atomic->stringForm());
     } else if (term->isString()) {
         return KNOWROB_RDF_NEW_LITERAL(atomic->stringForm().data(), xsdURI(XSDType::STRING));
     } else if (term->isNumeric()) {
         auto numeric = std::static_pointer_cast<Numeric>(atomic);
         return KNOWROB_RDF_NEW_LITERAL(atomic->stringForm().data(), xsdURI(numeric->xsdType()));
     }
     KB_WARN("Failed to convert term {} to raptor term.", *term);
     return nullptr;
 }

◆ knowrobToRaptor() [2/6]

raptor_term* knowrob::RedlandModel::knowrobToRaptor ( const TermPtr & term )

protected

◆ knowrobToRaptor() [3/6]

void RedlandModel::knowrobToRaptor	(	const Triple &	triple,
		raptor_statement *	raptorTriple
	)

protected

Definition at line 603 of file RedlandModel.cpp.

                                                                                        {
     raptor_term *subject, *predicate, *object;
     predicate = KNOWROB_RDF_NEW_URI(triple.predicate());
     if (triple.isSubjectBlank()) {
         subject = KNOWROB_RDF_NEW_BLANK(triple.subject());
     } else {
         subject = KNOWROB_RDF_NEW_URI(triple.subject());
     }
     if (triple.isObjectBlank()) {
         object = KNOWROB_RDF_NEW_BLANK(triple.valueAsString());
     } else if (triple.isObjectIRI()) {
         object = KNOWROB_RDF_NEW_URI(triple.valueAsString());
     } else if (triple.xsdType()) {
         switch (triple.xsdType().value()) {
             case XSDType::STRING:
                 object = KNOWROB_RDF_NEW_LITERAL(triple.valueAsString().data(), xsdURI(triple.xsdType().value()));
                 break;
             default:
                 object = KNOWROB_RDF_NEW_LITERAL(triple.createStringValue().c_str(), xsdURI(triple.xsdType().value()));
                 break;
         }
     } else {
         object = KNOWROB_RDF_NEW_LITERAL(triple.createStringValue().c_str(), xsdURI(XSDType::STRING));
     }
     librdf_statement_set_subject(raptorTriple, subject);
     librdf_statement_set_predicate(raptorTriple, predicate);
     librdf_statement_set_object(raptorTriple, object);
 }

◆ knowrobToRaptor() [4/6]

void knowrob::RedlandModel::knowrobToRaptor	(	const Triple &	triple,
		raptor_statement *	raptorTriple
	)

protected

◆ knowrobToRaptor() [5/6]

void RedlandModel::knowrobToRaptor	(	const TriplePattern &	pat,
		raptor_statement *	raptorTriple
	)

protected

Definition at line 587 of file RedlandModel.cpp.

                                                                                            {
     raptor_term *subject, *predicate, *object;
     if (pat.subjectTerm()) {
         subject = knowrobToRaptor(pat.subjectTerm());
         librdf_statement_set_subject(raptorTriple, subject);
     }
     if (pat.propertyTerm()) {
         predicate = knowrobToRaptor(pat.propertyTerm());
         librdf_statement_set_predicate(raptorTriple, predicate);
     }
     if (pat.objectTerm() && pat.objectOperator() == FilterType::EQ) {
         object = knowrobToRaptor(pat.objectTerm());
         librdf_statement_set_object(raptorTriple, object);
     }
 }

◆ knowrobToRaptor() [6/6]

void knowrob::RedlandModel::knowrobToRaptor	(	const TriplePattern &	pat,
		raptor_statement *	raptorTriple
	)

protected

◆ load() [1/2]

bool RedlandModel::load	(	const URI &	uri,
		semweb::TripleFormat	tripleFormat
	)

Load an URI into the model. Note that in case of SPARQL endpoints, this does not mean al data is copied into the model.

Parameters

uri	the uri to load.
tripleFormat	the format of the triples.

Returns: true if the uri was loaded successfully.

Definition at line 297 of file RedlandModel.cpp.

                                                                        {
     static const char *modelName = nullptr;
     auto rdf_uri = librdf_new_uri(
             world_,
             (const unsigned char *) uri().c_str());
     int returnCode = librdf_model_load(
             model_,
             rdf_uri,
             modelName,
             tripleFormatMimeType(tripleFormat).data(),
             nullptr);
     librdf_free_uri(rdf_uri);
     return returnCode == 0;
 }

◆ load() [2/2]

bool knowrob::RedlandModel::load	(	const URI &	uri,
		semweb::TripleFormat	tripleFormat
	)

Load an URI into the model. Note that in case of SPARQL endpoints, this does not mean al data is copied into the model.

Parameters

uri	the uri to load.
tripleFormat	the format of the triples.

Returns: true if the uri was loaded successfully.

◆ match() [1/2]

void RedlandModel::match	(	const TriplePattern &	query,
		const TripleVisitor &	visitor
	)

overridevirtual

Parameters

query	a framed triple pattern.
visitor	a function that is called for each matching framed triple.

Reimplemented from knowrob::QueryableStorage.

Definition at line 468 of file RedlandModel.cpp.

                                                                                  {
     auto triples = std::make_shared<RaptorContainer>(1);
     auto rdf_query = librdf_new_statement(world_);
     knowrobToRaptor(query, rdf_query);
  
     auto stream = librdf_model_find_statements(model_, rdf_query);
     while (!librdf_stream_end(stream)) {
         auto rdf_statement = librdf_stream_get_object(stream);
         triples->add(rdf_statement->subject, rdf_statement->predicate, rdf_statement->object);
         auto &triple = *triples->begin();
  
         if (query.objectOperator() != FilterType::EQ) {
             if (query.filter(*triple)) visitor(triple);
         } else {
             visitor(triple);
         }
         triples->reset();
         librdf_stream_next(stream);
     }
     librdf_free_stream(stream);
 }

◆ match() [2/2]

void knowrob::RedlandModel::match	(	const TriplePattern &	query,
		const TripleVisitor &	visitor
	)

overridevirtual

Parameters

query	a framed triple pattern.
visitor	a function that is called for each matching framed triple.

Reimplemented from knowrob::QueryableStorage.

◆ removeAll() [1/2]

bool RedlandModel::removeAll ( const TripleContainerPtr & triples )

overridevirtual

Delete all matching statements from this backend.

Parameters

triples a set of triples.

Implements knowrob::Storage.

Definition at line 384 of file RedlandModel.cpp.

                                                               {
     bool allRemoved = true;
     for (auto &knowrobTriple: *triples) {
         // map the knowrob triple into a raptor triple
         auto raptorTriple = librdf_new_statement(world_);
         knowrobToRaptor(*knowrobTriple, raptorTriple);
         auto ret = librdf_model_context_remove_statement(model_, getContextNode(*knowrobTriple), raptorTriple);
         if (ret != 0) {
             allRemoved = false;
         }
         librdf_free_statement(raptorTriple);
     }
     return allRemoved;
 }

◆ removeAll() [2/2]

bool knowrob::RedlandModel::removeAll ( const TripleContainerPtr & triples )

overridevirtual

Delete all matching statements from this backend.

Parameters

triples a set of triples.

Implements knowrob::Storage.

◆ removeAllWithOrigin() [1/2]

bool RedlandModel::removeAllWithOrigin ( std::string_view origin )

overridevirtual

Delete all statements with a given origin from this backend.

Parameters

origin the origin of the statements to be deleted.

Implements knowrob::Storage.

Definition at line 399 of file RedlandModel.cpp.

                                                             {
     auto stream = librdf_model_find_statements_in_context(
             model_, nullptr, getContextNode(origin));
     if (!stream) return false;
     // collect matching statements
     std::vector<librdf_statement *> toRemove;
     while (!librdf_stream_end(stream)) {
         auto next = librdf_stream_get_object(stream);
         toRemove.push_back(librdf_new_statement_from_statement(next));
         librdf_stream_next(stream);
     }
     librdf_free_stream(stream);
     // finally remove matching statements
     for (auto statement: toRemove) {
         librdf_model_remove_statement(model_, statement);
         librdf_free_statement(statement);
     }
     return true;
 }

◆ removeAllWithOrigin() [2/2]

bool knowrob::RedlandModel::removeAllWithOrigin ( std::string_view origin )

overridevirtual

Delete all statements with a given origin from this backend.

Parameters

origin the origin of the statements to be deleted.

Implements knowrob::Storage.

◆ removeOne() [1/2]

bool RedlandModel::removeOne ( const Triple & triple )

overridevirtual

Delete the first matching statement from this backend.

Parameters

triple a triple.

Implements knowrob::Storage.

Definition at line 375 of file RedlandModel.cpp.

                                                         {
     auto raptorTriple = librdf_new_statement(world_);
     // map the knowrob triple into a raptor triple
     knowrobToRaptor(knowrobTriple, raptorTriple);
     auto ret = librdf_model_context_remove_statement(model_, getContextNode(knowrobTriple), raptorTriple);
     librdf_free_statement(raptorTriple);
     return ret == 0;
 }

◆ removeOne() [2/2]

bool knowrob::RedlandModel::removeOne ( const Triple & triple )

overridevirtual

Delete the first matching statement from this backend.

Parameters

triple a triple.

Implements knowrob::Storage.

◆ setDatabase() [1/2]

void RedlandModel::setDatabase ( std::string_view database )

Parameters

database the database name.

Definition at line 142 of file RedlandModel.cpp.

                                                       {
     REDLAND_REQUIRE_UNINITIALIZED("database", database_, database);
 }

◆ setDatabase() [2/2]

void knowrob::RedlandModel::setDatabase ( std::string_view database )

Parameters

database the database name.

◆ setHashesStorage() [1/2]

void RedlandModel::setHashesStorage	(	RedlandHashType	hashType,
		std::string_view	dir = `"."`
	)

Set the storage type to "hashes".

Parameters

hashType	the hash type.
dir	the directory for the hashes storage.

See also: https://librdf.org/docs/api/redland-storage-module-hashes.html

Definition at line 162 of file RedlandModel.cpp.

                                                                                 {
     setStorageType(RedlandStorageType::HASHES);
     setStorageHashType(hashType);
     if (hashType == RedlandHashType::BDB) {
         setStorageDirectory(dir);
     }
 }

◆ setHashesStorage() [2/2]

void knowrob::RedlandModel::setHashesStorage	(	RedlandHashType	hashType,
		std::string_view	dir = `"."`
	)

Set the storage type to "hashes".

Parameters

hashType	the hash type.
dir	the directory for the hashes storage.

See also: https://librdf.org/docs/api/redland-storage-module-hashes.html

◆ setHost() [1/2]

void RedlandModel::setHost ( std::string_view host )

Parameters

host	the host of the database.

Definition at line 138 of file RedlandModel.cpp.

                                               {
     REDLAND_REQUIRE_UNINITIALIZED("host", host_, host);
 }

◆ setHost() [2/2]

void knowrob::RedlandModel::setHost ( std::string_view host )

Parameters

host	the host of the database.

◆ setMemoryStorage() [1/2]

void RedlandModel::setMemoryStorage ( )

Set the storage type to "memory".

See also: https://librdf.org/docs/api/redland-storage-module-memory.html

Definition at line 170 of file RedlandModel.cpp.

                                     {
     setStorageType(RedlandStorageType::MEMORY);
 }

◆ setMemoryStorage() [2/2]

void knowrob::RedlandModel::setMemoryStorage ( )

Set the storage type to "memory".

See also: https://librdf.org/docs/api/redland-storage-module-memory.html

◆ setOrigin() [1/2]

void knowrob::RedlandModel::setOrigin ( std::string_view origin )

inline

If set assume triples in this backend have this as a default origin.

Parameters

origin the origin of the triples.

Definition at line 121 of file RedlandModel.h.

121 { origin_ = origin; }

◆ setOrigin() [2/2]

void knowrob::RedlandModel::setOrigin ( std::string_view origin )

inline

If set assume triples in this backend have this as a default origin.

Parameters

origin the origin of the triples.

Definition at line 121 of file RedlandModel.h.

121 { origin_ = origin; }

◆ setPassword() [1/2]

void RedlandModel::setPassword ( std::string_view password )

Parameters

password the password for the database.

Definition at line 150 of file RedlandModel.cpp.

                                                       {
     REDLAND_REQUIRE_UNINITIALIZED("password", password_, password);
 }

◆ setPassword() [2/2]

void knowrob::RedlandModel::setPassword ( std::string_view password )

Parameters

password the password for the database.

◆ setRaptorWorld() [1/2]

void RedlandModel::setRaptorWorld ( librdf_world * world )

If not set, the model will create its own.

Parameters

world a redland world.

Definition at line 158 of file RedlandModel.cpp.

                                                      {
     REDLAND_REQUIRE_UNINITIALIZED("raptor-world", world_, world);
 }

◆ setRaptorWorld() [2/2]

void knowrob::RedlandModel::setRaptorWorld ( librdf_world * world )

If not set, the model will create its own.

Parameters

world a redland world.

◆ setStorageDirectory() [1/2]

void RedlandModel::setStorageDirectory ( std::string_view dir = "." )

Parameters

dir	the directory for the storage.

Definition at line 154 of file RedlandModel.cpp.

                                                          {
     REDLAND_REQUIRE_UNINITIALIZED("dir", storageDir_, dir);
 }

◆ setStorageDirectory() [2/2]

void knowrob::RedlandModel::setStorageDirectory ( std::string_view dir = "." )

Parameters

dir	the directory for the storage.

◆ setStorageHashType() [1/2]

void RedlandModel::setStorageHashType ( RedlandHashType hashType )

Set the "hash-type" parameter of the storage.

Parameters

hashType the hash type.

Definition at line 134 of file RedlandModel.cpp.

                                                               {
     REDLAND_REQUIRE_UNINITIALIZED("hash-type", hashType_, hashType);
 }

◆ setStorageHashType() [2/2]

void knowrob::RedlandModel::setStorageHashType ( RedlandHashType hashType )

Set the "hash-type" parameter of the storage.

Parameters

hashType the hash type.

◆ setStorageType() [1/2]

void RedlandModel::setStorageType ( RedlandStorageType storageType )

Set the storage type.

Parameters

storageType the storage type.

Definition at line 130 of file RedlandModel.cpp.

                                                                 {
     REDLAND_REQUIRE_UNINITIALIZED("storage-type", storageType_, storageType);
 }

◆ setStorageType() [2/2]

void knowrob::RedlandModel::setStorageType ( RedlandStorageType storageType )

Set the storage type.

Parameters

storageType the storage type.

◆ setUser() [1/2]

void RedlandModel::setUser ( std::string_view user )

Parameters

user	the user name for the database.

Definition at line 146 of file RedlandModel.cpp.

                                               {
     REDLAND_REQUIRE_UNINITIALIZED("user", user_, user);
 }

◆ setUser() [2/2]

void knowrob::RedlandModel::setUser ( std::string_view user )

Parameters

user	the user name for the database.

◆ sparql() [1/2]

bool RedlandModel::sparql	(	std::string_view	queryString,
		const BindingsHandler &	callback
	)		const

overridevirtual

Run a SPARQL query on the model.

Parameters

queryString	the query to run.
callback	the callback to handle the results.

Returns: true if the query was successful.

Implements knowrob::SPARQLBackend.

Definition at line 490 of file RedlandModel.cpp.

                                                                                            {
     auto queryObj = librdf_new_query(
             world_,
             QUERY_LANGUAGE_SPARQL.data(),
             nullptr,
             (unsigned char *) queryString.data(),
             nullptr);
     if (!queryObj) {
         KB_WARN("Failed to create query `{}` for model \"{}\".", queryString, storageName_);
         return false;
     }
     auto results = librdf_query_execute(queryObj, model_);
     if (!results) {
         KB_WARN("Failed to execute query `{}` for model \"{}\".", queryString, storageName_);
         librdf_free_query(queryObj);
         return false;
     }
     while (!librdf_query_results_finished(results)) {
         auto bindings = std::make_shared<Bindings>();
  
         // read bindings
         int bindings_count = librdf_query_results_get_bindings_count(results);
         for (int i = 0; i < bindings_count; ++i) {
             auto name = std::string_view(librdf_query_results_get_binding_name(results, i));
             if (name.empty() || name[0] == '_') {
                 // skip variables that start with '_'.
                 // afaik, there is no way to prevent these from being returned when "*" is
                 // used in select pattern.
                 continue;
             }
  
             auto node = librdf_query_results_get_binding_value(results, i);
             if (!node) {
                 // this indicates that a variable appears in select pattern, but it was not grounded
                 // in the query. this is not an error, but rather means the grounding was OPTIONAL.
                 // we can just skip this variable.
                 continue;
             }
  
             auto knowrobTerm = termFromNode(node);
             if (knowrobTerm) {
                 bindings->set(std::make_shared<Variable>(name), knowrobTerm);
             } else {
                 KB_WARN("Failed to process binding for variable \"{}\".", name);
             }
             librdf_free_node(node);
         }
         callback(bindings);
         librdf_query_results_next(results);
     }
     librdf_free_query_results(results);
     librdf_free_query(queryObj);
     return true;
 }

◆ sparql() [2/2]

bool knowrob::RedlandModel::sparql	(	std::string_view	queryString,
		const BindingsHandler &	callback
	)		const

overridevirtual

Run a SPARQL query on the model.

Parameters

queryString	the query to run.
callback	the callback to handle the results.

Returns: true if the query was successful.

Implements knowrob::SPARQLBackend.

◆ storageType() [1/2]

auto knowrob::RedlandModel::storageType ( ) const

inline

Returns: the redland storage type of the model.

Definition at line 126 of file RedlandModel.h.

126 { return storageType_; }

◆ storageType() [2/2]

auto knowrob::RedlandModel::storageType ( ) const

inline

Returns: the redland storage type of the model.

Definition at line 126 of file RedlandModel.h.

126 { return storageType_; }

◆ xsdURI() [1/2]

RedlandURI & RedlandModel::xsdURI ( XSDType xsdType )

protected

Definition at line 564 of file RedlandModel.cpp.

                                                 {
     return xsdURIs_[static_cast<int>(xsdType)];
 }

◆ xsdURI() [2/2]

RedlandURI& knowrob::RedlandModel::xsdURI ( XSDType xsdType )

protected

Member Data Documentation

◆ contextNodes_

std::map< std::string, librdf_node *, std::less<> > knowrob::RedlandModel::contextNodes_

protected

Definition at line 196 of file RedlandModel.h.

◆ database_

std::optional< std::string > knowrob::RedlandModel::database_

protected

Definition at line 203 of file RedlandModel.h.

◆ hashType_

std::optional< RedlandHashType > knowrob::RedlandModel::hashType_

protected

Definition at line 207 of file RedlandModel.h.

◆ host_

std::optional< std::string > knowrob::RedlandModel::host_

protected

Definition at line 201 of file RedlandModel.h.

◆ model_

librdf_model * knowrob::RedlandModel::model_

protected

Definition at line 187 of file RedlandModel.h.

◆ origin_

std::optional< std::string > knowrob::RedlandModel::origin_

protected

Definition at line 200 of file RedlandModel.h.

◆ ownedWorld_

librdf_world * knowrob::RedlandModel::ownedWorld_

protected

Definition at line 185 of file RedlandModel.h.

◆ password_

std::optional< std::string > knowrob::RedlandModel::password_

protected

Definition at line 205 of file RedlandModel.h.

◆ port_

std::optional< std::string > knowrob::RedlandModel::port_

protected

Definition at line 202 of file RedlandModel.h.

◆ QUERY_LANGUAGE_SPARQL

static constexpr std::string_view knowrob::RedlandModel::QUERY_LANGUAGE_SPARQL = "sparql"

staticconstexpr

Definition at line 54 of file RedlandModel.h.

◆ storage_

librdf_storage * knowrob::RedlandModel::storage_

protected

Definition at line 188 of file RedlandModel.h.

◆ storageDir_

std::optional< std::string > knowrob::RedlandModel::storageDir_

protected

Definition at line 206 of file RedlandModel.h.

◆ storageName_

std::string knowrob::RedlandModel::storageName_

protected

Definition at line 198 of file RedlandModel.h.

◆ storageOptions_

std::string knowrob::RedlandModel::storageOptions_

protected

Definition at line 209 of file RedlandModel.h.

◆ storageType_

RedlandStorageType knowrob::RedlandModel::storageType_

protected

Definition at line 208 of file RedlandModel.h.

◆ user_

std::optional< std::string > knowrob::RedlandModel::user_

protected

Definition at line 204 of file RedlandModel.h.

◆ world_

librdf_world * knowrob::RedlandModel::world_

protected

Definition at line 186 of file RedlandModel.h.

◆ xsdURIs_

RedlandURI knowrob::RedlandModel::xsdURIs_

protected

Definition at line 192 of file RedlandModel.h.

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

build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/storage/redland/RedlandModel.h
src/storage/redland/RedlandModel.cpp

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RedlandModel() [1/2]

◆ ~RedlandModel() [1/2]

◆ RedlandModel() [2/2]

◆ ~RedlandModel() [2/2]

Member Function Documentation

◆ batch() [1/2]

◆ batch() [2/2]

◆ batchOrigin() [1/2]

◆ batchOrigin() [2/2]

◆ contains() [1/2]

◆ contains() [2/2]

◆ getContextNode() [1/4]

◆ getContextNode() [2/4]

◆ getContextNode() [3/4]

◆ getContextNode() [4/4]

◆ getStorageOptions() [1/2]

◆ getStorageOptions() [2/2]

◆ initializeBackend() [1/4]

◆ initializeBackend() [2/4]

◆ initializeBackend() [3/4]

◆ initializeBackend() [4/4]

◆ insertAll() [1/2]

◆ insertAll() [2/2]

◆ insertOne() [1/2]

◆ insertOne() [2/2]

◆ isInitialized() [1/2]

◆ isInitialized() [2/2]

◆ isPersistent() [1/2]

◆ isPersistent() [2/2]

◆ knowrobToRaptor() [1/6]

◆ knowrobToRaptor() [2/6]

◆ knowrobToRaptor() [3/6]

◆ knowrobToRaptor() [4/6]

◆ knowrobToRaptor() [5/6]

◆ knowrobToRaptor() [6/6]

◆ load() [1/2]

◆ load() [2/2]

◆ match() [1/2]

◆ match() [2/2]

◆ removeAll() [1/2]

◆ removeAll() [2/2]

◆ removeAllWithOrigin() [1/2]

◆ removeAllWithOrigin() [2/2]

◆ removeOne() [1/2]

◆ removeOne() [2/2]

◆ setDatabase() [1/2]

◆ setDatabase() [2/2]

◆ setHashesStorage() [1/2]

◆ setHashesStorage() [2/2]

◆ setHost() [1/2]

◆ setHost() [2/2]

◆ setMemoryStorage() [1/2]

◆ setMemoryStorage() [2/2]

◆ setOrigin() [1/2]

◆ setOrigin() [2/2]

◆ setPassword() [1/2]

◆ setPassword() [2/2]

◆ setRaptorWorld() [1/2]

◆ setRaptorWorld() [2/2]

◆ setStorageDirectory() [1/2]

◆ setStorageDirectory() [2/2]

◆ setStorageHashType() [1/2]

◆ setStorageHashType() [2/2]

◆ setStorageType() [1/2]

◆ setStorageType() [2/2]

◆ setUser() [1/2]

◆ setUser() [2/2]

◆ sparql() [1/2]

◆ sparql() [2/2]

◆ storageType() [1/2]

◆ storageType() [2/2]

◆ xsdURI() [1/2]

◆ xsdURI() [2/2]