knowrob::mongo::MongoTriplePattern Class Reference

#include <MongoTriplePattern.h>

Collaboration diagram for knowrob::mongo::MongoTriplePattern:

Public Member Functions
	MongoTriplePattern (const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
auto &	document ()
auto	bson ()
	MongoTriplePattern (const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
auto &	document ()
auto	bson ()

Static Public Member Functions
static void	append (bson_t *selectorDoc, const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static void	appendGraphSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static void	appendEpistemicSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression)
static void	appendTimeSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression)
static void	setTripleVariables (Pipeline &pipeline, const TriplePattern &expr, const std::set< std::string_view > &knownGroundedVariables)
static void	append (bson_t *selectorDoc, const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static void	appendGraphSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static void	appendEpistemicSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression)
static void	appendTimeSelector (bson_t *selectorDoc, const TriplePattern &tripleExpression)
static void	setTripleVariables (Pipeline &pipeline, const TriplePattern &expr, const std::set< std::string_view > &knownGroundedVariables)

Static Protected Member Functions
static bson_t *	create (const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static const char *	getOperatorString (knowrob::FilterType operatorType)
static bson_t *	create (const TriplePattern &tripleExpression, bool b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &importHierarchy)
static const char *	getOperatorString (knowrob::FilterType operatorType)

Protected Attributes
mongo::Document	document_

Detailed Description

A class to represent a triple pattern in a MongoDB.

Definition at line 20 of file MongoTriplePattern.h.

Constructor & Destructor Documentation

MongoTriplePattern() [1/2]

MongoTriplePattern::MongoTriplePattern	(	const TriplePattern &	tripleExpression,
		bool	b_isTaxonomicProperty,
		const std::shared_ptr< ImportHierarchy > &	importHierarchy
	)

Definition at line 19 of file MongoTriplePattern.cpp.

        : document_(create(tripleExpression, b_isTaxonomicProperty, importHierarchy)) {
}

MongoTriplePattern() [2/2]

knowrob::mongo::MongoTriplePattern::MongoTriplePattern	(	const TriplePattern &	tripleExpression,
		bool	b_isTaxonomicProperty,
		const std::shared_ptr< ImportHierarchy > &	importHierarchy
	)

Member Function Documentation

append() [1/2]

void MongoTriplePattern::append ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression, bool  b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

static

Definition at line 35 of file MongoTriplePattern.cpp.

                                                                                       {
    // "s"" field
    MongoTerm::append(selectorDoc,
                      "s", tripleExpression.subjectTerm());
    // "p" field
    MongoTerm::append(selectorDoc,
                      (b_isTaxonomicProperty ? "p" : "p*"),
                      tripleExpression.propertyTerm());
    // "o" field
    const char *objectOperator = getOperatorString(tripleExpression.objectOperator());
    MongoTerm::append(selectorDoc,
                      (b_isTaxonomicProperty ? "o*" : "o"),
                      tripleExpression.objectTerm(),
                      objectOperator);
    // "g" field
    appendGraphSelector(selectorDoc, tripleExpression, importHierarchy);
    // epistemic fields
    appendEpistemicSelector(selectorDoc, tripleExpression);
    // temporal fields
    appendTimeSelector(selectorDoc, tripleExpression);
}

append() [2/2]

static void knowrob::mongo::MongoTriplePattern::append ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression, bool  b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

static

appendEpistemicSelector() [1/2]

void MongoTriplePattern::appendEpistemicSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression  )

static

Definition at line 97 of file MongoTriplePattern.cpp.

                                                                                                           {
    auto &ct = tripleExpression.confidenceTerm();
    auto &at = tripleExpression.perspectiveTerm();
    auto &u = tripleExpression.isUncertainTerm();
 
    if (!((u.has_grounding() && u.grounded()->asBoolean()) || u.has_variable())) {
        // note: null value of "uncertain" field is seen as value "false"
        MongoTerm::append(
                selectorDoc,
                "uncertain",
                Numeric::falseAtom(),
                nullptr,
                true);
    }
 
    if (at) {
        if (at->termType() == TermType::ATOMIC) {
            MongoTerm::append(
                    selectorDoc,
                    "agent",
                    *at,
                    nullptr,
                    false);
        } else {
            KB_WARN("agent term {} has unexpected type", *at);
        }
    } else {
        // make sure agent field is undefined: { agent: { $exists: false } }
        // note: null value of agent field is seen as "self", i.e. the agent running the knowledge base
        bson_t agentDoc;
        BSON_APPEND_DOCUMENT_BEGIN(selectorDoc, "agent", &agentDoc);
        BSON_APPEND_BOOL(&agentDoc, "$exists", false);
        bson_append_document_end(selectorDoc, &agentDoc);
    }
 
    if (ct) {
        if (ct->termType() == TermType::ATOMIC) {
            // note: null value of confidence is seen as larger than the requested threshold
            MongoTerm::append(
                    selectorDoc,
                    "confidence",
                    *ct,
                    MONGO_OPERATOR_GTE,
                    true);
        } else {
            KB_WARN("confidence term {} has unexpected type", *ct);
        }
    }
}

appendEpistemicSelector() [2/2]

static void knowrob::mongo::MongoTriplePattern::appendEpistemicSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression  )

static

appendGraphSelector() [1/2]

void MongoTriplePattern::appendGraphSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

static

Definition at line 60 of file MongoTriplePattern.cpp.

                                                                                                    {
    auto &gt = tripleExpression.graphTerm();
    if (!gt) return;
 
    if (gt->termType() == TermType::ATOMIC) {
        auto graphString = gt.grounded();
        if (graphString->stringForm() == ImportHierarchy::ORIGIN_ANY || graphString->stringForm() == "*")
            return;
 
        std::vector<TermPtr> childrenNames;
        for (auto &child: importHierarchy->getImports(graphString->stringForm())) {
            childrenNames.push_back(Atom::Tabled(child->name()));
        }
        if (childrenNames.empty()) {
            MongoTerm::append(selectorDoc, "graph", graphString);
        } else {
            childrenNames.push_back(graphString);
            MongoTerm::append(selectorDoc, "graph", childrenNames, "$in");
        }
    }
        /*
        else if (gt->termType() == TermType::FUNCTION) {
            auto fn = (Function*) gt.get();
            if (*fn->functor() == *ListTerm::listFunctor()) {
                aggregation::appendArrayQuery(selectorDoc, "graph", fn->arguments(), "$in");
            } else {
                KB_WARN("graph term {} has unexpected function type", *gt);
            }
        }
         */
    else {
        KB_WARN("graph term {} has unexpected type", *gt);
    }
}

appendGraphSelector() [2/2]

static void knowrob::mongo::MongoTriplePattern::appendGraphSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

static

appendTimeSelector() [1/2]

void MongoTriplePattern::appendTimeSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression  )

static

Definition at line 147 of file MongoTriplePattern.cpp.

                                                                                                      {
    static const bool allowNullValues = true;
    static auto b_occasional = std::make_shared<Integer>(static_cast<int32_t>(true));
    static auto b_always = std::make_shared<Integer>(static_cast<int32_t>(false));
    auto bt = &tripleExpression.beginTerm();
    auto et = &tripleExpression.endTerm();
    auto &o = tripleExpression.isOccasionalTerm();
 
    if (!((o.has_grounding() && o.grounded()->asBoolean()) || o.has_variable())) {
        // note: null value of "occasional" field is seen as value "false"
        MongoTerm::append(
                selectorDoc,
                "occasional",
                Numeric::falseAtom(),
                nullptr,
                true);
    } else {
        auto swap = bt;
        bt = et;
        et = swap;
    }
 
    if (bt->has_grounding()) {
        MongoTerm::append(
                selectorDoc,
                "scope.time.since",
                bt->get(),
                MONGO_OPERATOR_LTE,
                allowNullValues);
    }
    if (et->has_grounding()) {
        MongoTerm::append(
                selectorDoc,
                "scope.time.until",
                et->get(),
                MONGO_OPERATOR_GTE,
                allowNullValues);
    }
}

appendTimeSelector() [2/2]

static void knowrob::mongo::MongoTriplePattern::appendTimeSelector ( bson_t *  selectorDoc, const TriplePattern &  tripleExpression  )

static

bson() [1/2]

auto knowrob::mongo::MongoTriplePattern::bson ( )

inline

Definition at line 29 of file MongoTriplePattern.h.

{ return document_.bson(); }

bson() [2/2]

auto knowrob::mongo::MongoTriplePattern::bson ( )

inline

Definition at line 29 of file MongoTriplePattern.h.

{ return document_.bson(); }

create() [1/2]

bson_t * MongoTriplePattern::create ( const TriplePattern &  tripleExpression, bool  b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

staticprotected

Definition at line 26 of file MongoTriplePattern.cpp.

                                                               {
    auto selectorDoc = bson_new();
    append(selectorDoc, tripleExpression, b_isTaxonomicProperty, importHierarchy);
    return selectorDoc;
}

create() [2/2]

static bson_t* knowrob::mongo::MongoTriplePattern::create ( const TriplePattern &  tripleExpression, bool  b_isTaxonomicProperty, const std::shared_ptr< ImportHierarchy > &  importHierarchy  )

staticprotected

document() [1/2]

auto& knowrob::mongo::MongoTriplePattern::document ( )

inline

Definition at line 27 of file MongoTriplePattern.h.

{ return document_; }

document() [2/2]

auto& knowrob::mongo::MongoTriplePattern::document ( )

inline

Definition at line 27 of file MongoTriplePattern.h.

{ return document_; }

getOperatorString() [1/2]

const char * MongoTriplePattern::getOperatorString ( knowrob::FilterType  operatorType )

staticprotected

Definition at line 187 of file MongoTriplePattern.cpp.

                                                                                {
    switch (operatorType) {
        case FilterType::EQ:
            return nullptr;
        case FilterType::NEQ:
            return MONGO_OPERATOR_NEQ;
        case FilterType::LEQ:
            return MONGO_OPERATOR_LTE;
        case FilterType::GEQ:
            return MONGO_OPERATOR_GTE;
        case FilterType::LT:
            return MONGO_OPERATOR_LT;
        case FilterType::GT:
            return MONGO_OPERATOR_GT;
    }
    return nullptr;
}

getOperatorString() [2/2]

static const char* knowrob::mongo::MongoTriplePattern::getOperatorString ( knowrob::FilterType  operatorType )

staticprotected

setTripleVariables() [1/2]

void MongoTriplePattern::setTripleVariables ( Pipeline &  pipeline, const TriplePattern &  expr, const std::set< std::string_view > &  knownGroundedVariables  )

static

Definition at line 269 of file MongoTriplePattern.cpp.

                                                                                                  {
    std::list<std::pair<const char *, Variable *>> varList;
 
    // the object can be specified as a triple (Value, Operator, ActualValue) such that
    // a value constraint is given plus a variable where the actual value of the triple should be stored.
    TermPtr objectVar = expr.objectTerm();
    if (objectVar && !objectVar->isVariable() && expr.objectVariable()) {
        objectVar = expr.objectVariable();
    }
 
    for (auto &it: {
            std::make_pair("$next.s", expr.subjectTerm()),
            std::make_pair("$next.p", expr.propertyTerm()),
            std::make_pair("$next.o", objectVar),
            std::make_pair("$next.graph", expr.graphTerm().get()),
            std::make_pair("$next.confidence", expr.confidenceTerm().get()),
            std::make_pair("$next.agent", expr.perspectiveTerm().get()),
            std::make_pair("$next.scope.time.since", expr.beginTerm().get()),
            std::make_pair("$next.scope.time.until", expr.endTerm().get()),
            std::make_pair("$next.uncertain", expr.isUncertainTerm().get()),
            std::make_pair("$next.occasional", expr.isOccasionalTerm().get())
    }) {
        if (!it.second || it.second->termType() != TermType::VARIABLE) continue;
        auto var = (Variable *) it.second.get();
        // skip variables that were instantiated in previous steps
        if (knownGroundedVariables.count(var->name()) > 0) continue;
        varList.emplace_back(it.first, var);
    }
 
    if (!varList.empty()) {
        auto setVariables = pipeline.appendStageBegin("$set");
        std::set<std::string_view> setVariablesNames;
        std::vector<std::pair<const char *, Variable *>> duplicates;
        for (auto &it: varList) {
            if (setVariablesNames.count(it.second->name()) > 0) {
                duplicates.push_back(it);
                continue;
            }
            appendSetVariable(setVariables, it.second->name(), it.first);
            setVariablesNames.insert(it.second->name());
        }
        pipeline.appendStageEnd(setVariables);
 
        // handle duplicates: make sure that each variable value is equal to the computed value
        // of the duplicate variable.
        for (auto &it: duplicates) {
            static const std::string varPrefix("$");
            auto varValue = std::string("$") + MongoTerm::variableKey(it.second->name());
 
            // append $match stage for each duplicate variable
            bson_t exprDoc, matchArr;
            auto matchStage = pipeline.appendStageBegin("$match"); {
                BSON_APPEND_DOCUMENT_BEGIN(matchStage, "$expr", &exprDoc);
                BSON_APPEND_ARRAY_BEGIN(&exprDoc, "$eq", &matchArr);
                BSON_APPEND_UTF8(&matchArr, "0", varValue.c_str());
                BSON_APPEND_UTF8(&matchArr, "1", it.first);
                bson_append_array_end(&exprDoc, &matchArr);
                bson_append_document_end(matchStage, &exprDoc);
            }
            pipeline.appendStageEnd(matchStage);
        }
    }
}

setTripleVariables() [2/2]

static void knowrob::mongo::MongoTriplePattern::setTripleVariables ( Pipeline &  pipeline, const TriplePattern &  expr, const std::set< std::string_view > &  knownGroundedVariables  )

static

Member Data Documentation

document_

mongo::Document knowrob::mongo::MongoTriplePattern::document_

protected

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