RedlandModel.h

Go to the documentation of this file.

/*
 * This file is part of KnowRob, please consult
 * https://github.com/knowrob/knowrob for license details.
 */
 
#ifndef KNOWROB_REDLAND_MODEL_H
#define KNOWROB_REDLAND_MODEL_H
 
#include <redland.h>
#include "knowrob/semweb/TripleContainer.h"
#include "knowrob/URI.h"
#include "knowrob/semweb/TripleFormat.h"
#include "knowrob/storage/Storage.h"
#include "knowrob/semweb/SPARQLQuery.h"
#include "RedlandURI.h"
#include "knowrob/storage/SPARQLBackend.h"
 
namespace knowrob {
    enum class RedlandStorageType {
        // This module is always present (cannot be removed) and provides a simple and fast in-memory store with no persistence.
        MEMORY,
        // This module is always present (cannot be removed) and provides indexed storage using Redland Triple stores
        HASHES,
        // This module is compiled in when MySQL 3 or 4 is available.
        MYSQL,
        // This module is based on the MySQL store and is compiled in when PostgreSQL is available.
        POSTGRESQL,
        // This module provides storage via the SQLite relational database when available and supports SQLite V2 and V3.
        SQLITE
    };
    enum class RedlandHashType {
        // The default hash type.
        MEMORY,
        // The Berkeley DB hash type.
        BDB
    };
 
    class RedlandModel : public SPARQLBackend {
    public:
        static constexpr std::string_view QUERY_LANGUAGE_SPARQL = "sparql";
 
        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) { origin_ = origin; }
 
        auto storageType() const { return storageType_; }
 
        bool isInitialized() const;
 
        bool initializeBackend();
 
        // override DataBackend
        bool initializeBackend(const PropertyTree &config) override;
 
        bool load(const URI &uri, semweb::TripleFormat tripleFormat);
 
        // override SPARQLBackend
        bool sparql(std::string_view queryString, const BindingsHandler &callback) const override;
 
        // override DataBackend
        bool insertOne(const Triple &triple) override;
 
        // override DataBackend
        bool insertAll(const TripleContainerPtr &triples) override;
 
        // override DataBackend
        bool removeOne(const Triple &triple) override;
 
        // override DataBackend
        bool removeAll(const TripleContainerPtr &triples) override;
 
        // override DataBackend
        bool removeAllWithOrigin(std::string_view origin) override;
 
        // Override QueryableBackend
        bool isPersistent() const override;
 
        // Override QueryableBackend
        bool contains(const Triple &triple) override;
 
        // Override QueryableBackend
        void batch(const TripleHandler &callback) const override;
 
        // Override QueryableBackend
        void batchOrigin(std::string_view origin, const TripleHandler &callback) override;
 
        // Override QueryableBackend
        void match(const TriplePattern &query, const TripleVisitor &visitor) override;
 
    protected:
        librdf_world *ownedWorld_;
        librdf_world *world_;
        librdf_model *model_;
        librdf_storage *storage_;
 
        // the uris are created within the context of a librdf_world, so
        // they cannot be defined statically.
        RedlandURI xsdURIs_[static_cast<int>(XSDType::LAST)];
 
        RedlandURI &xsdURI(XSDType xsdType);
 
        std::map<std::string, librdf_node *, std::less<>> contextNodes_;
 
        std::string storageName_;
        // if set when querying, ignore context nodes and use this origin
        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_;
 
        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);
 
    private:
        void finalize();
    };
 
} // knowrob
 
#endif //KNOWROB_REDLAND_MODEL_H