knowrob::transaction::Transaction Class Reference

#include <Transaction.h>

Inheritance diagram for knowrob::transaction::Transaction:

Public Member Functions
	Transaction (const std::shared_ptr< QueryableStorage > &queryable, const std::shared_ptr< Vocabulary > &vocabulary, bool isRemoval)
virtual	~Transaction ()=default
void	addBackend (const std::shared_ptr< NamedBackend > &backend)
bool	commit (const Triple &triple)
bool	commit (const Triple &triple, const IRIAtomPtr &reifiedName)
bool	commit (const TripleContainerPtr &triples)
bool	commit (const TripleContainerPtr &triples, const ReifiedNames &reifiedNames)
	Transaction (const std::shared_ptr< QueryableStorage > &queryable, const std::shared_ptr< Vocabulary > &vocabulary, bool isRemoval)
virtual	~Transaction ()=default
void	addBackend (const std::shared_ptr< NamedBackend > &backend)
bool	commit (const Triple &triple)
bool	commit (const Triple &triple, const IRIAtomPtr &reifiedName)
bool	commit (const TripleContainerPtr &triples)
bool	commit (const TripleContainerPtr &triples, const ReifiedNames &reifiedNames)

Protected Member Functions
bool	commitProtected (const TripleContainerPtr &triple, const StoragePtr &backend)
virtual bool	doCommit (const Triple &triple, const StoragePtr &backend)=0
virtual bool	doCommit (const TripleContainerPtr &triples, const StoragePtr &backend)=0
virtual void	updateVocabulary (const Triple &triple)=0
IRIAtomPtr	queryReifiedName (const Triple &triple)
bool	commitProtected (const TripleContainerPtr &triple, const StoragePtr &backend)
virtual bool	doCommit (const Triple &triple, const StoragePtr &backend)=0
virtual bool	doCommit (const TripleContainerPtr &triples, const StoragePtr &backend)=0
virtual void	updateVocabulary (const Triple &triple)=0
IRIAtomPtr	queryReifiedName (const Triple &triple)

Static Protected Member Functions
static std::shared_ptr< ThreadPool::Runner >	createTripleWorker (const TripleContainerPtr &triples, const std::function< void(const TriplePtr &)> &fn)
static std::shared_ptr< ThreadPool::Runner >	createTripleWorker (const TripleContainerPtr &triples, const std::function< void(const TriplePtr &)> &fn)

Protected Attributes
std::shared_ptr< Vocabulary >	vocabulary_
std::shared_ptr< QueryableStorage >	queryable_
std::vector< std::shared_ptr< NamedBackend > >	backends_
bool	isRemoval_

Detailed Description

Baseclass for transactions. A set of backends can be added to a transaction. When a transaction is committed, the triple is committed to all backends. If a backend does not support the context of the triple, the triple is reified and the reified triples are committed to the backend.

Definition at line 23 of file Transaction.h.

Constructor & Destructor Documentation

Transaction() [1/2]

knowrob::transaction::Transaction::Transaction ( const std::shared_ptr< QueryableStorage > &  queryable, const std::shared_ptr< Vocabulary > &  vocabulary, bool  isRemoval  )

inline

Definition at line 25 of file Transaction.h.

                : vocabulary_(vocabulary),
                  queryable_(queryable),
                  isRemoval_(isRemoval) {}

~Transaction() [1/2]

virtual knowrob::transaction::Transaction::~Transaction ( )

virtualdefault

Transaction() [2/2]

knowrob::transaction::Transaction::Transaction ( const std::shared_ptr< QueryableStorage > &  queryable, const std::shared_ptr< Vocabulary > &  vocabulary, bool  isRemoval  )

inline

Definition at line 25 of file Transaction.h.

                : vocabulary_(vocabulary),
                  queryable_(queryable),
                  isRemoval_(isRemoval) {}

~Transaction() [2/2]

virtual knowrob::transaction::Transaction::~Transaction ( )

virtualdefault

Member Function Documentation

addBackend() [1/2]

void knowrob::transaction::Transaction::addBackend ( const std::shared_ptr< NamedBackend > &  backend )

inline

Adds a backend to the transaction.

Parameters

backend

the backend to add.

Definition at line 38 of file Transaction.h.

{ backends_.push_back(backend); }

addBackend() [2/2]

void knowrob::transaction::Transaction::addBackend ( const std::shared_ptr< NamedBackend > &  backend )

inline

Adds a backend to the transaction.

Parameters

backend

the backend to add.

Definition at line 38 of file Transaction.h.

{ backends_.push_back(backend); }

commit() [1/8]

bool Transaction::commit

(

const Triple &

triple

)

Commits a triple to all backends.

Parameters

triple

the triple to commit.

Returns

true if the triple was committed to all backends, false otherwise.

Definition at line 58 of file Transaction.cpp.

                                             {
    static auto v_reification = std::make_shared<Variable>("reification");
    if (isRemoval_ && ReifiedTriple::isReifiable(triple)) {
        return commit(triple, queryReifiedName(triple));
    } else {
        return commit(triple, nullptr);
    }
}

commit() [2/8]

bool knowrob::transaction::Transaction::commit

(

const Triple &

triple

)

Commits a triple to all backends.

Parameters

triple

the triple to commit.

Returns

true if the triple was committed to all backends, false otherwise.

commit() [3/8]

bool Transaction::commit	(	const Triple &	triple,
		const IRIAtomPtr &	reifiedName
	)

Commits a triple to all backends.

Parameters

triple	the triple to commit.
reifiedName	the reified name of the triple.

Returns

true if the triple was committed to all backends, false otherwise.

Definition at line 67 of file Transaction.cpp.

                                                                            {
    ReifiedTriplePtr reification;
    bool success = true;
 
    // make sure the vocabulary is updated before committing the triple as the vocabulary
    // could be used within some backends.
    updateVocabulary(triple);
 
    for (auto &definedBackend: backends_) {
        auto &backend = definedBackend->value();
        if (!backend->supports(StorageFeature::TripleContext) && ReifiedTriple::isReifiable(triple)) {
            if (!reification) reification = std::make_shared<ReifiedTriple>(triple, vocabulary_, reifiedName);
            for (auto &reified: *reification) {
                success = success && doCommit(*reified.ptr, backend);
            }
        } else {
            success = doCommit(triple, backend);
        }
        if (!success) break;
    }
    return success;
}

commit() [4/8]

bool knowrob::transaction::Transaction::commit	(	const Triple &	triple,
		const IRIAtomPtr &	reifiedName
	)

Commits a triple to all backends.

Parameters

triple	the triple to commit.
reifiedName	the reified name of the triple.

Returns

true if the triple was committed to all backends, false otherwise.

commit() [5/8]

bool Transaction::commit

(

const TripleContainerPtr &

triples

)

Commits a set of triples to all backends.

Parameters

triples

the triples to commit.

Returns

true if the triples were committed to all backends, false otherwise.

Definition at line 90 of file Transaction.cpp.

                                                          {
    static auto v_reification = std::make_shared<Variable>("reification");
    if (isRemoval_ && !queryable_->supports(StorageFeature::TripleContext)) {
        // FIXME: The name lookup only works in case the queryable backend does store reified triples.
        //        - current: commit generates a ReificationContainer over triples, and the container forms
        //        ground triples with explicit names of reified individuals for removal.
        //        (1) we could search for a queryable backend without context support and use this instead
        //        (2) we could store the reified names also in backends that support context, such they
        //            can be queried from any queryable backend.
        //        (3) remove for reified backends could use "removeAllMatching" instead, where the reified
        //           name is used as a variable in the query. but this interface was removed from DataBackend class!
        //           or allow none value as subject in removals, could be ok in the backends.
        // Note: the container type does not provide a size method because it internally uses a generator
        // without knowing when it will end. Also, container with additional filtering could be implemented.
        // So we need to resize the reifiedNames vector while looping over the triples, but we can use
        // the default batch size as initial size.
        auto estimatedSize = GlobalSettings::batchSize();
        ReifiedNames reifiedNames = std::make_shared<std::vector<IRIAtomPtr>>();
        reifiedNames->reserve(estimatedSize);
        for (auto &triple: *triples) {
            if (ReifiedTriple::isReifiable(*triple)) {
                reifiedNames->push_back(queryReifiedName(*triple));
            } else {
                reifiedNames->push_back(nullptr);
            }
        }
        // If fewer elements were added, resize the vector
        if (reifiedNames->size() < estimatedSize) {
            reifiedNames->resize(reifiedNames->size());
        }
        return commit(triples, reifiedNames);
    } else {
        return commit(triples, {});
    }
}

commit() [6/8]

bool knowrob::transaction::Transaction::commit

(

const TripleContainerPtr &

triples

)

Commits a set of triples to all backends.

Parameters

triples

the triples to commit.

Returns

true if the triples were committed to all backends, false otherwise.

commit() [7/8]

bool Transaction::commit	(	const TripleContainerPtr &	triples,
		const ReifiedNames &	reifiedNames
	)

Commits a set of triples to all backends.

Parameters

triples	the triples to commit.
reifiedNames	the reified names of the triples.

Returns

true if the triples were committed to all backends, false otherwise.

Definition at line 126 of file Transaction.cpp.

                                                                                            {
    TripleContainerPtr reified;
    std::vector<std::shared_ptr<ThreadPool::Runner>> transactions;
    bool success = true;
 
    // make sure the vocabulary is updated before committing the triples as the vocabulary
    // could be used within some backends.
    for (auto &triple: *triples) {
        updateVocabulary(*triple);
    }
 
    for (auto &definedBackend: backends_) {
        auto &backend = definedBackend->value();
        const TripleContainerPtr *backendTriples;
        if (!backend->supports(StorageFeature::TripleContext)) {
            if (!reified) reified = std::make_shared<ReificationContainer>(triples, vocabulary_, reifiedNames);
            backendTriples = &reified;
        } else {
            backendTriples = &triples;
        }
        auto worker = std::make_shared<ThreadPool::LambdaRunner>(
                [&](const std::function<bool()> &) { success = success && commitProtected(*backendTriples, backend); });
        transactions.push_back(worker);
 
        DefaultThreadPool()->pushWork(worker,
                                      [&definedBackend](const std::exception &exc) {
                                          KB_ERROR("transaction failed for backend '{}': {}", definedBackend->name(),
                                                   exc.what());
                                      });
    }
 
    for (auto &transaction: transactions) transaction->join();
 
    return success;
}

commit() [8/8]

bool knowrob::transaction::Transaction::commit	(	const TripleContainerPtr &	triples,
		const ReifiedNames &	reifiedNames
	)

Commits a set of triples to all backends.

Parameters

triples	the triples to commit.
reifiedNames	the reified names of the triples.

Returns

true if the triples were committed to all backends, false otherwise.

commitProtected() [1/2]

bool Transaction::commitProtected ( const TripleContainerPtr &  triple, const StoragePtr &  backend  )

protected

Definition at line 162 of file Transaction.cpp.

                                                                                              {
    if (backend->storageLanguage() == PluginLanguage::PYTHON) {
        py::gil_lock lock;
        return doCommit(triples, backend);
    } else {
        return doCommit(triples, backend);
    }
}

commitProtected() [2/2]

bool knowrob::transaction::Transaction::commitProtected ( const TripleContainerPtr &  triple, const StoragePtr &  backend  )

protected

createTripleWorker() [1/2]

std::shared_ptr< ThreadPool::Runner > Transaction::createTripleWorker ( const TripleContainerPtr &  triples, const std::function< void(const TriplePtr &)> &  fn  )

staticprotected

Definition at line 171 of file Transaction.cpp.

                                                        {
    auto perTripleWorker =
            std::make_shared<ThreadPool::LambdaRunner>([fn, triples](const ThreadPool::LambdaRunner::StopChecker &) {
                std::for_each(triples->begin(), triples->end(), fn);
            });
    DefaultThreadPool()->pushWork(perTripleWorker,
                                  [](const std::exception &exc) {
                                      KB_ERROR("failed to perform per triple work: {}", exc.what());
                                  });
    return perTripleWorker;
}

createTripleWorker() [2/2]

static std::shared_ptr<ThreadPool::Runner> knowrob::transaction::Transaction::createTripleWorker ( const TripleContainerPtr &  triples, const std::function< void(const TriplePtr &)> &  fn  )

staticprotected

doCommit() [1/4]

virtual bool knowrob::transaction::Transaction::doCommit ( const Triple &  triple, const StoragePtr &  backend  )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

doCommit() [2/4]

virtual bool knowrob::transaction::Transaction::doCommit ( const Triple &  triple, const StoragePtr &  backend  )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

doCommit() [3/4]

virtual bool knowrob::transaction::Transaction::doCommit ( const TripleContainerPtr &  triples, const StoragePtr &  backend  )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

doCommit() [4/4]

virtual bool knowrob::transaction::Transaction::doCommit ( const TripleContainerPtr &  triples, const StoragePtr &  backend  )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

queryReifiedName() [1/2]

IRIAtomPtr Transaction::queryReifiedName ( const Triple &  triple )

protected

Definition at line 41 of file Transaction.cpp.

                                                             {
    static auto v_reification = std::make_shared<Variable>("reification");
    auto pat = std::make_shared<TriplePattern>(triple);
    auto query = std::make_shared<GraphPathQuery>(pat);
    auto reified = std::make_shared<ReifiedQuery>(query, vocabulary_);
    setReificationVariable(reified->term(), v_reification);
 
    IRIAtomPtr reifiedName;
    queryable_->query(reified, [&](const BindingsPtr &bindings) {
        auto t_reifiedName = bindings->get(v_reification->name());
        if (t_reifiedName && t_reifiedName->isIRI()) {
            reifiedName = IRIAtom::Tabled(std::static_pointer_cast<IRIAtom>(t_reifiedName)->stringForm());
        }
    });
    return reifiedName;
}

queryReifiedName() [2/2]

IRIAtomPtr knowrob::transaction::Transaction::queryReifiedName ( const Triple &  triple )

protected

updateVocabulary() [1/2]

virtual void knowrob::transaction::Transaction::updateVocabulary ( const Triple &  triple )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

updateVocabulary() [2/2]

virtual void knowrob::transaction::Transaction::updateVocabulary ( const Triple &  triple )

protectedpure virtual

Implemented in knowrob::transaction::Remove, knowrob::transaction::Insert, knowrob::transaction::Remove, and knowrob::transaction::Insert.

Member Data Documentation

backends_

std::vector< std::shared_ptr< NamedBackend > > knowrob::transaction::Transaction::backends_

protected

Definition at line 73 of file Transaction.h.

isRemoval_

bool knowrob::transaction::Transaction::isRemoval_

protected

Definition at line 74 of file Transaction.h.

queryable_

std::shared_ptr< QueryableStorage > knowrob::transaction::Transaction::queryable_

protected

Definition at line 72 of file Transaction.h.

vocabulary_

std::shared_ptr< Vocabulary > knowrob::transaction::Transaction::vocabulary_

protected

Definition at line 71 of file Transaction.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/Transaction.h
• src/storage/Transaction.cpp