knowrob::ReifiedQuery Class Reference

#include <ReifiedQuery.h>

Inheritance diagram for knowrob::ReifiedQuery:

Collaboration diagram for knowrob::ReifiedQuery:

Public Member Functions
	ReifiedQuery (const std::shared_ptr< GraphQuery > &nonReified, VocabularyPtr vocabulary, bool withFullFrame=false)
	ReifiedQuery (const TriplePattern &nonReified, VocabularyPtr vocabulary, bool withFullFrame=false)
	ReifiedQuery (const std::shared_ptr< GraphQuery > &nonReified, VocabularyPtr vocabulary, bool withFullFrame=false)
	ReifiedQuery (const TriplePattern &nonReified, VocabularyPtr vocabulary, bool withFullFrame=false)
Public Member Functions inherited from knowrob::GraphQuery
	GraphQuery (const std::shared_ptr< GraphTerm > &query, const QueryContextPtr &ctx=DefaultQueryContext())
	GraphQuery (const std::vector< TriplePatternPtr > &query, const QueryContextPtr &ctx=DefaultQueryContext())
	GraphQuery (const TriplePatternPtr &query)
	GraphQuery (const TriplePatternPtr &query, const QueryContextPtr &ctx)
auto	term () const
FormulaPtr	toFormula () const
	GraphQuery (const std::shared_ptr< GraphTerm > &query, const QueryContextPtr &ctx=DefaultQueryContext())
	GraphQuery (const std::vector< TriplePatternPtr > &query, const QueryContextPtr &ctx=DefaultQueryContext())
	GraphQuery (const TriplePatternPtr &query)
	GraphQuery (const TriplePatternPtr &query, const QueryContextPtr &ctx)
auto	term () const
FormulaPtr	toFormula () const
Public Member Functions inherited from knowrob::Query
	Query (QueryContextPtr ctx=DefaultQueryContext())
virtual	~Query ()=default
auto &	ctx () const
void	setContext (QueryContextPtr ctx)
	Query (QueryContextPtr ctx=DefaultQueryContext())
virtual	~Query ()=default
auto &	ctx () const
void	setContext (QueryContextPtr ctx)
Public Member Functions inherited from knowrob::Printable
virtual	~Printable ()=default
virtual std::string	format () const
virtual	~Printable ()=default
virtual std::string	format () const

Static Public Member Functions
static bool	hasReifiablePattern (const std::shared_ptr< GraphQuery > &nonReified)
static int	getReificationFlags (const TriplePattern &q)
static bool	hasReifiablePattern (const std::shared_ptr< GraphQuery > &nonReified)
static int	getReificationFlags (const TriplePattern &q)

Protected Member Functions
void	setNonReified (const std::shared_ptr< GraphTerm > &nonReified)
std::shared_ptr< GraphTerm >	reifiedPatternSequence (const TriplePattern &pattern)
std::shared_ptr< GraphTerm >	reifyPattern (const std::shared_ptr< GraphPattern > &nonReified)
std::shared_ptr< GraphUnion >	reifyUnion (const std::shared_ptr< GraphUnion > &graphUnion)
std::shared_ptr< GraphSequence >	reifySequence (const std::shared_ptr< GraphSequence > &graphSequence)
void	reifyConnective (const std::shared_ptr< GraphConnective > &reifiedConnective, const std::shared_ptr< GraphConnective > &originalConnective)
void	setNonReified (const std::shared_ptr< GraphTerm > &nonReified)
std::shared_ptr< GraphTerm >	reifiedPatternSequence (const TriplePattern &pattern)
std::shared_ptr< GraphTerm >	reifyPattern (const std::shared_ptr< GraphPattern > &nonReified)
std::shared_ptr< GraphUnion >	reifyUnion (const std::shared_ptr< GraphUnion > &graphUnion)
std::shared_ptr< GraphSequence >	reifySequence (const std::shared_ptr< GraphSequence > &graphSequence)
void	reifyConnective (const std::shared_ptr< GraphConnective > &reifiedConnective, const std::shared_ptr< GraphConnective > &originalConnective)
Protected Member Functions inherited from knowrob::GraphQuery
void	write (std::ostream &os) const override
	GraphQuery (const QueryContextPtr &ctx=DefaultQueryContext())
void	write (std::ostream &os) const override
	GraphQuery (const QueryContextPtr &ctx=DefaultQueryContext())

Static Protected Member Functions
static bool	hasReifiablePattern (const GraphTerm *term)
static bool	hasReifiablePattern (const GraphTerm *term)

Protected Attributes
VocabularyPtr	vocabulary_
uint32_t	varCounter_
bool	withFullFrame_
Protected Attributes inherited from knowrob::GraphQuery
std::shared_ptr< GraphTerm >	term_
Protected Attributes inherited from knowrob::Query
QueryContextPtr	ctx_

Detailed Description

Reifies an inout query such that it can be issued to a backend that does not support contextualization of triples.

Definition at line 25 of file ReifiedQuery.h.

Constructor & Destructor Documentation

ReifiedQuery() [1/4]

ReifiedQuery::ReifiedQuery ( const std::shared_ptr< GraphQuery > &  nonReified, VocabularyPtr  vocabulary, bool  withFullFrame = false  )

explicit

Parameters

nonReified	a query that is not reified.
vocabulary	the vocabulary to use for reification.
withFullFrame	if true, the reified query will contain a full frame for each reified triple.

Definition at line 16 of file ReifiedQuery.cpp.

        : GraphQuery(nonReified->ctx()),
          vocabulary_(std::move(vocabulary)),
          varCounter_(0),
          withFullFrame_(withFullFrame) {
    setNonReified(nonReified->term());
}

ReifiedQuery() [2/4]

ReifiedQuery::ReifiedQuery ( const TriplePattern &  nonReified, VocabularyPtr  vocabulary, bool  withFullFrame = false  )

explicit

Parameters

nonReified	a query that is not reified.
vocabulary	the vocabulary to use for reification.
withFullFrame	if true, the reified query will contain a full frame for each reified triple.

Definition at line 24 of file ReifiedQuery.cpp.

        : GraphQuery(),
          vocabulary_(std::move(vocabulary)),
          varCounter_(0),
          withFullFrame_(withFullFrame) {
    term_ = reifiedPatternSequence(nonReified);
}

ReifiedQuery() [3/4]

knowrob::ReifiedQuery::ReifiedQuery ( const std::shared_ptr< GraphQuery > &  nonReified, VocabularyPtr  vocabulary, bool  withFullFrame = false  )

explicit

Parameters

nonReified	a query that is not reified.
vocabulary	the vocabulary to use for reification.
withFullFrame	if true, the reified query will contain a full frame for each reified triple.

ReifiedQuery() [4/4]

knowrob::ReifiedQuery::ReifiedQuery ( const TriplePattern &  nonReified, VocabularyPtr  vocabulary, bool  withFullFrame = false  )

explicit

Parameters

nonReified	a query that is not reified.
vocabulary	the vocabulary to use for reification.
withFullFrame	if true, the reified query will contain a full frame for each reified triple.

Member Function Documentation

getReificationFlags() [1/2]

int ReifiedQuery::getReificationFlags ( const TriplePattern &  q )

static

Parameters

q	a triple query.

Returns

a bitmask of ReificationFlag's that indicates if the pattern may have instances in the original or reified form.

Definition at line 276 of file ReifiedQuery.cpp.

                                                            {
    bool includeOriginal = true;
    bool includeReified = false;
    // include reified if isUncertain is true or a variable in the query
    if ((q.isUncertainTerm().has_grounding() && q.isUncertainTerm().grounded()->asBoolean()) ||
        q.isUncertainTerm().has_variable()) {
        includeReified = true;
    }
    // include reified if confidence has a value or is a variable
    if (q.confidenceTerm().has_grounding() || q.confidenceTerm().has_variable()) {
        includeReified = true;
    }
    // include reified if perspective is not the ego perspective or a variable.
    // In case perspective is not ego perspective, the original triples are not included.
    if (q.perspectiveTerm().has_grounding()) {
        auto perspective = q.perspectiveTerm().grounded();
        if (!Perspective::isEgoPerspective(perspective->stringForm())) {
            includeOriginal = false;
            includeReified = true;
        }
    } else if (q.perspectiveTerm().has_variable()) {
        includeReified = true;
    }
    // include reified if isOccasional is true or a variable in the query.
    // In case isOccasional is true, the original triples are not included.
    if (q.isOccasionalTerm().has_grounding()) {
        auto occasional = q.isOccasionalTerm().grounded();
        if (occasional->asBoolean()) {
            includeReified = true;
            includeOriginal = false;
        }
    } else if (q.isOccasionalTerm().has_variable()) {
        includeReified = true;
    }
    // include reified if begin or end is a variable or has a grounding.
    if (q.beginTerm().has_grounding() || q.beginTerm().has_variable() ||
        q.endTerm().has_grounding() || q.endTerm().has_variable()) {
        includeReified = true;
    }
    int flags = 0;
    if (includeOriginal) flags |= IncludeOriginal;
    if (includeReified) flags |= IncludeReified;
    return flags;
}

getReificationFlags() [2/2]

static int knowrob::ReifiedQuery::getReificationFlags ( const TriplePattern &  q )

static

Parameters

q	a triple query.

Returns

a bitmask of ReificationFlag's that indicates if the pattern may have instances in the original or reified form.

hasReifiablePattern() [1/4]

bool ReifiedQuery::hasReifiablePattern ( const GraphTerm *  term )

staticprotected

Definition at line 248 of file ReifiedQuery.cpp.

                                                            { //NOLINT
    switch (term->termType()) {
        case GraphTermType::Pattern:
            return getReificationFlags(*((const GraphPattern *) term)->value()) & IncludeReified;
        case GraphTermType::Union:
            for (auto &t: ((const GraphUnion *) term)->terms()) {
                if (hasReifiablePattern(t.get())) {
                    return true;
                }
            }
            return false;
        case GraphTermType::Sequence:
            for (auto &t: ((const GraphSequence *) term)->terms()) {
                if (hasReifiablePattern(t.get())) {
                    return true;
                }
            }
            return false;
        case GraphTermType::Builtin:
            return false;
    }
    return false;
}

hasReifiablePattern() [2/4]

static bool knowrob::ReifiedQuery::hasReifiablePattern ( const GraphTerm *  term )

staticprotected

hasReifiablePattern() [3/4]

bool ReifiedQuery::hasReifiablePattern ( const std::shared_ptr< GraphQuery > &  nonReified )

static

Returns

true if the query has reifiable patterns.

Definition at line 272 of file ReifiedQuery.cpp.

                                                                                  {
    return hasReifiablePattern(nonReified->term().get());
}

hasReifiablePattern() [4/4]

static bool knowrob::ReifiedQuery::hasReifiablePattern ( const std::shared_ptr< GraphQuery > &  nonReified )

static

Returns

true if the query has reifiable patterns.

reifiedPatternSequence() [1/2]

std::shared_ptr< GraphTerm > ReifiedQuery::reifiedPatternSequence ( const TriplePattern &  pattern )

protected

Definition at line 111 of file ReifiedQuery.cpp.

                                                                                             {
    static auto fullyConfident = std::make_shared<Double>(1.0);
    static auto egoPerspective = Perspective::getEgoPerspective()->atom();
    static auto b_var = std::make_shared<Variable>("_reified_b");
    static auto e_var = std::make_shared<Variable>("_reified_e");
 
    if (!nonReified.propertyTerm() || !nonReified.propertyTerm()->isAtom()) {
        throw QueryError("non-reified triple does not have a property term");
    }
    auto seq = std::make_shared<GraphSequence>();
    auto p_atom = std::static_pointer_cast<Atom>(nonReified.propertyTerm());
    auto property = vocabulary_->defineProperty(p_atom->stringForm());
    // map the property to a Relation concept
    auto relationType = property->reification();
    // generate a unique individual variable.
    // note that we are actually not interested in its instantiation.
    auto name = std::make_shared<Variable>("_reified" + std::to_string(varCounter_++));
    // optionally set origin of reified queries if term is grounded
    auto &g = nonReified.graphTerm();
 
    // create a type assertion
    addPattern(seq, name, rdf::type, relationType->iriAtom(), g);
 
    // create a query for subject
    addPattern(seq, name, reification::hasSubject, nonReified.subjectTerm(), g);
 
    // create a query for the object/literal value
    std::shared_ptr<TriplePattern> objectQuery;
    if (property->isObjectProperty()) {
        objectQuery = addPattern(seq, name, reification::hasObject, nonReified.objectTerm(), g);
    } else {
        objectQuery = addPattern(seq, name, reification::hasLiteral, nonReified.objectTerm(), g);
    }
    objectQuery->setObjectOperator(nonReified.objectOperator());
 
    // create queries for optional properties
    bool includeOnlyCertain;
    if (nonReified.isUncertainTerm().has_grounding() && nonReified.isUncertainTerm().grounded()->asBoolean()) {
        if (withFullFrame_) {
            auto x = addPattern(seq, name, reification::isUncertain, Numeric::trueAtom(), g);
            x->setIsOptional(true);
        }
        includeOnlyCertain = false;
    } else if (nonReified.isUncertainTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::isUncertain, nonReified.isUncertainTerm().variable(), g);
        x->setIsOptional(true);
        includeOnlyCertain = false;
    } else {
        auto x = addPattern(seq, name, reification::isUncertain, Numeric::falseAtom(), g);
        x->setIsOptional(true);
        includeOnlyCertain = true;
    }
 
    if (nonReified.confidenceTerm().has_grounding()) {
        auto x = addPattern(seq, name, reification::hasConfidence, nonReified.confidenceTerm().grounded(), g);
        x->setObjectOperator(FilterType::GEQ);
        x->setIsOptional(true);
    } else if (nonReified.confidenceTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::hasConfidence, nonReified.confidenceTerm().variable(), g);
        x->setIsOptional(true);
    } else if (includeOnlyCertain) {
        auto x = addPattern(seq, name, reification::hasConfidence, fullyConfident, g);
        x->setObjectOperator(FilterType::GEQ);
        x->setIsOptional(true);
    }
 
    if (nonReified.perspectiveTerm().has_grounding()) {
        if (Perspective::isEgoPerspective(nonReified.perspectiveTerm().grounded()->stringForm())) {
            auto x = addPattern(seq, name, reification::hasPerspective, egoPerspective, g);
            x->setIsOptional(true);
        } else {
            addPattern(seq, name, reification::hasPerspective, nonReified.perspectiveTerm().grounded(), g);
        }
    } else if (nonReified.perspectiveTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::hasPerspective, nonReified.perspectiveTerm().variable(), g);
        x->setIsOptional(true);
    } else {
        auto x = addPattern(seq, name, reification::hasPerspective, egoPerspective, g);
        x->setIsOptional(true);
    }
 
    bool includeOccasional;
    if (nonReified.isOccasionalTerm().has_grounding() && nonReified.isOccasionalTerm().grounded()->asBoolean()) {
        if (withFullFrame_) {
            auto x = addPattern(seq, name, reification::isOccasional, Numeric::trueAtom(), g);
            x->setIsOptional(true);
        }
        includeOccasional = true;
    } else if (nonReified.isOccasionalTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::isOccasional, nonReified.isOccasionalTerm().variable(), g);
        x->setIsOptional(true);
        includeOccasional = true;
    } else {
        auto x = addPattern(seq, name, reification::isOccasional, Numeric::falseAtom(), g);
        x->setIsOptional(true);
        includeOccasional = false;
    }
 
    if (nonReified.beginTerm().has_grounding()) {
        if (includeOccasional) {
            auto x = addPattern(seq, name, reification::hasEndTime, nonReified.beginTerm().grounded(), g);
            x->setObjectOperator(FilterType::GEQ);
            x->setIsOptional(true);
        } else {
            auto x = addPattern(seq, name, reification::hasBeginTime, nonReified.beginTerm().grounded(), g);
            x->setObjectOperator(FilterType::LEQ);
            x->setIsOptional(true);
        }
    } else if (nonReified.beginTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::hasBeginTime, nonReified.beginTerm().variable(), g);
        x->setIsOptional(true);
    } else {
        auto x = addPattern(seq, name, reification::hasBeginTime, b_var, g);
        x->setIsNegated(true);
    }
 
    if (nonReified.endTerm().has_grounding()) {
        if (includeOccasional) {
            auto x = addPattern(seq, name, reification::hasBeginTime, nonReified.endTerm().grounded(), g);
            x->setObjectOperator(FilterType::LEQ);
            x->setIsOptional(true);
        } else {
            auto x = addPattern(seq, name, reification::hasEndTime, nonReified.endTerm().grounded(), g);
            x->setObjectOperator(FilterType::GEQ);
            x->setIsOptional(true);
        }
    } else if (nonReified.endTerm().has_variable()) {
        auto x = addPattern(seq, name, reification::hasEndTime, nonReified.endTerm().variable(), g);
        x->setIsOptional(true);
    } else {
        auto x = addPattern(seq, name, reification::hasEndTime, e_var, g);
        x->setIsNegated(true);
    }
 
    return seq;
}

reifiedPatternSequence() [2/2]

std::shared_ptr<GraphTerm> knowrob::ReifiedQuery::reifiedPatternSequence ( const TriplePattern &  pattern )

protected

reifyConnective() [1/2]

void ReifiedQuery::reifyConnective ( const std::shared_ptr< GraphConnective > &  reifiedConnective, const std::shared_ptr< GraphConnective > &  originalConnective  )

protected

Definition at line 49 of file ReifiedQuery.cpp.

                                                                                             {
    for (auto &t: originalConnective->terms()) {
        switch (t->termType()) {
            case GraphTermType::Pattern:
                reifiedConnective->addMember(reifyPattern(std::static_pointer_cast<GraphPattern>(t)));
                break;
            case GraphTermType::Union:
                reifiedConnective->addMember(reifyUnion(std::static_pointer_cast<GraphUnion>(t)));
                break;
            case GraphTermType::Sequence:
                reifiedConnective->addMember(reifySequence(std::static_pointer_cast<GraphSequence>(t)));
                break;
            case GraphTermType::Builtin:
                reifiedConnective->addMember(t);
                break;
        }
    }
}

reifyConnective() [2/2]

void knowrob::ReifiedQuery::reifyConnective ( const std::shared_ptr< GraphConnective > &  reifiedConnective, const std::shared_ptr< GraphConnective > &  originalConnective  )

protected

reifyPattern() [1/2]

std::shared_ptr< GraphTerm > ReifiedQuery::reifyPattern ( const std::shared_ptr< GraphPattern > &  nonReified )

protected

Definition at line 82 of file ReifiedQuery.cpp.

                                                                                                 {
    auto flags = getReificationFlags(*nonReified->value());
    if (flags & IncludeReified && flags & IncludeOriginal) {
        // if both reified and original are included, we need to create a union of both
        auto graphUnion = std::make_shared<GraphUnion>();
        graphUnion->addMember(nonReified);
        graphUnion->addMember(reifiedPatternSequence(*nonReified->value()));
        return graphUnion;
    } else if (flags & IncludeReified) {
        return reifiedPatternSequence(*nonReified->value());
    } else {
        return nonReified;
    }
}

reifyPattern() [2/2]

std::shared_ptr<GraphTerm> knowrob::ReifiedQuery::reifyPattern ( const std::shared_ptr< GraphPattern > &  nonReified )

protected

reifySequence() [1/2]

std::shared_ptr< GraphSequence > ReifiedQuery::reifySequence ( const std::shared_ptr< GraphSequence > &  graphSequence )

protected

Definition at line 76 of file ReifiedQuery.cpp.

                                                                             { //NOLINT
    auto reified = std::make_shared<GraphSequence>();
    reifyConnective(reified, graphSequence);
    return reified;
}

reifySequence() [2/2]

std::shared_ptr<GraphSequence> knowrob::ReifiedQuery::reifySequence ( const std::shared_ptr< GraphSequence > &  graphSequence )

protected

reifyUnion() [1/2]

std::shared_ptr< GraphUnion > ReifiedQuery::reifyUnion ( const std::shared_ptr< GraphUnion > &  graphUnion )

protected

Definition at line 69 of file ReifiedQuery.cpp.

                                                                                              { //NOLINT
    auto reified = std::make_shared<GraphUnion>();
    reifyConnective(reified, graphUnion);
    return reified;
}

reifyUnion() [2/2]

std::shared_ptr<GraphUnion> knowrob::ReifiedQuery::reifyUnion ( const std::shared_ptr< GraphUnion > &  graphUnion )

protected

setNonReified() [1/2]

void ReifiedQuery::setNonReified ( const std::shared_ptr< GraphTerm > &  nonReified )

protected

Definition at line 32 of file ReifiedQuery.cpp.

                                                                           {
    switch (nonReified->termType()) {
        case GraphTermType::Pattern:
            term_ = reifyPattern(std::static_pointer_cast<GraphPattern>(nonReified));
            break;
        case GraphTermType::Union:
            term_ = reifyUnion(std::static_pointer_cast<GraphUnion>(nonReified));
            break;
        case GraphTermType::Sequence:
            term_ = reifySequence(std::static_pointer_cast<GraphSequence>(nonReified));
            break;
        case GraphTermType::Builtin:
            term_ = nonReified;
            break;
    }
}

setNonReified() [2/2]

void knowrob::ReifiedQuery::setNonReified ( const std::shared_ptr< GraphTerm > &  nonReified )

protected

Member Data Documentation

varCounter_

uint32_t knowrob::ReifiedQuery::varCounter_

protected

Definition at line 54 of file ReifiedQuery.h.

vocabulary_

VocabularyPtr knowrob::ReifiedQuery::vocabulary_

protected

Definition at line 53 of file ReifiedQuery.h.

withFullFrame_

bool knowrob::ReifiedQuery::withFullFrame_

protected

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