ai.grakn.graql.internal.reasoner.query

Class ReasonerAtomicQuery

java.lang.Object

ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl

ai.grakn.graql.internal.reasoner.query.ReasonerAtomicQuery

All Implemented Interfaces:

ReasonerQuery

public class ReasonerAtomicQuery
extends ReasonerQueryImpl

Base reasoner atomic query. An atomic query is a query constrained to having at most one rule-resolvable atom together with its accompanying constraints (predicates and types)

Author:

Kasper Piskorski

Constructor Summary

Constructors

Constructor and Description
ReasonerAtomicQuery(Atom at)
ReasonerAtomicQuery(Conjunction<VarAdmin> pattern, GraknGraph graph)
ReasonerAtomicQuery(ReasonerAtomicQuery query)

Method Summary

Modifier and Type	Method and Description
boolean	addAtom(Atomic at)
java.util.stream.Stream<Map<VarName,Concept>>	answerStream(Set<ReasonerAtomicQuery> subGoals, LazyQueryCache<ReasonerAtomicQuery> cache, boolean materialise)
java.util.stream.Stream<Map<VarName,Concept>>	DBlookup() resolve the query by performing a db lookup
boolean	equals(Object obj)
Atom	getAtom()
Map<VarName,VarName>	getUnifiers(ReasonerQuery p)
int	hashCode()
java.util.stream.Stream<Map<VarName,Concept>>	lookup(LazyQueryCache<ReasonerAtomicQuery> cache) resolve the query by performing either a db or memory lookup, depending on which is more appropriate
java.util.stream.Stream<Map<VarName,Concept>>	materialise(Map<VarName,Concept> answer)
boolean	removeAtom(Atomic at)
java.util.stream.Stream<Map<VarName,Concept>>	resolve(boolean materialise) resolves the query
Set<Atom>	selectAtoms() atom selection function
void	unify(Map<VarName,VarName> unifiers) change each variable occurrence according to provided mappings (apply unifiers {[from, to]_i})

Methods inherited from class ai.grakn.graql.internal.reasoner.query.ReasonerQueryImpl

addAtomConstraints, containsEquivalentAtom, getAtoms, getEquivalentAtoms, getFilters, getIdPredicate, getIdPredicates, getMatchQuery, getPattern, getTypeConstraints, getValuePredicates, getVarNames, getVarTypeMap, graph, isEquivalent, isRuleResolvable, toString, unify

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ReasonerAtomicQuery

public ReasonerAtomicQuery(Conjunction<VarAdmin> pattern,
                           GraknGraph graph)

ReasonerAtomicQuery

public ReasonerAtomicQuery(ReasonerAtomicQuery query)

ReasonerAtomicQuery

public ReasonerAtomicQuery(Atom at)

Method Detail

equals

public boolean equals(Object obj)

Overrides:

equals in class ReasonerQueryImpl

hashCode

public int hashCode()

Overrides:

hashCode in class ReasonerQueryImpl

getAtom

public Atom getAtom()

Returns:

the atom constituting this atomic query

addAtom

public boolean addAtom(Atomic at)

Overrides:

addAtom in class ReasonerQueryImpl

Parameters:

at - to be added

Returns:

true if the atom set did not already contain the specified atom

removeAtom

public boolean removeAtom(Atomic at)

Overrides:

removeAtom in class ReasonerQueryImpl

Parameters:

at - to be removed

Returns:

true if the atom set contained the specified atom

unify

public void unify(Map<VarName,VarName> unifiers)

Description copied from class: ReasonerQueryImpl

change each variable occurrence according to provided mappings (apply unifiers {[from, to]_i})

Specified by:

unify in interface ReasonerQuery

Overrides:

unify in class ReasonerQueryImpl

Parameters:

unifiers - contain unifiers (variable mappings) to be applied

selectAtoms

public Set<Atom> selectAtoms()

Description copied from class: ReasonerQueryImpl

atom selection function

Overrides:

selectAtoms in class ReasonerQueryImpl

Returns:

selected atoms

getUnifiers

public Map<VarName,VarName> getUnifiers(ReasonerQuery p)

Specified by:

getUnifiers in interface ReasonerQuery

Overrides:

getUnifiers in class ReasonerQueryImpl

Returns:

lookup

public java.util.stream.Stream<Map<VarName,Concept>> lookup(LazyQueryCache<ReasonerAtomicQuery> cache)

resolve the query by performing either a db or memory lookup, depending on which is more appropriate

Parameters:

cache - container of already performed query resolutions

DBlookup

public java.util.stream.Stream<Map<VarName,Concept>> DBlookup()

resolve the query by performing a db lookup

materialise

public java.util.stream.Stream<Map<VarName,Concept>> materialise(Map<VarName,Concept> answer)

answerStream

public java.util.stream.Stream<Map<VarName,Concept>> answerStream(Set<ReasonerAtomicQuery> subGoals,
                                                                  LazyQueryCache<ReasonerAtomicQuery> cache,
                                                                  boolean materialise)

resolve

public java.util.stream.Stream<Map<VarName,Concept>> resolve(boolean materialise)

Description copied from class: ReasonerQueryImpl

resolves the query

Specified by:

resolve in interface ReasonerQuery

Overrides:

resolve in class ReasonerQueryImpl

Parameters:

materialise - materialisation flag

Returns:

stream of answers