ai.grakn.graql.internal.reasoner.query

Class ReasonerQueryImpl

java.lang.Object

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

All Implemented Interfaces:

ReasonerQuery

Direct Known Subclasses:

ReasonerAtomicQuery

public class ReasonerQueryImpl
extends Object
implements ReasonerQuery

Base reasoner query providing resolution and atom handling facilities for conjunctive graql queries.

Author:

Kasper Piskorski

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ReasonerQueryImpl(Atom atom)
	ReasonerQueryImpl(Conjunction<VarAdmin> pattern, GraknGraph graph)
	ReasonerQueryImpl(ReasonerQueryImpl q)

Method Summary

Modifier and Type	Method and Description
void	addAtomConstraints(Set<? extends Atomic> cstrs) adds a set of constraints (types, predicates) to the atom set
boolean	addAtomic(Atomic atom)
boolean	containsEquivalentAtom(Atomic atom)
ReasonerQuery	copy()
boolean	equals(Object obj)
Atom	findNextJoinable(Atom atom)
Set<Atomic>	getAtoms()
Set<NotEquals>	getFilters()
IdPredicate	getIdPredicate(VarName var)
Set<IdPredicate>	getIdPredicates()
MatchQuery	getMatchQuery()
Conjunction<PatternAdmin>	getPattern()
Set<TypeAtom>	getTypeConstraints()
Unifier	getUnifier(ReasonerQuery parent)
Set<ValuePredicate>	getValuePredicates()
Set<VarName>	getVarNames()
Map<VarName,Type>	getVarTypeMap()
GraknGraph	graph()
int	hashCode()
boolean	isEquivalent(ReasonerQueryImpl q)
boolean	isRuleResolvable()
ReasonerQueryIterator	iterator(Answer sub, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)
boolean	removeAtomic(Atomic atom)
java.util.stream.Stream<Answer>	resolve(boolean materialise, boolean explanation) resolves the query
java.util.stream.Stream<Answer>	resolve(boolean materialise, boolean explanation, LazyQueryCache<ReasonerAtomicQuery> cache, LazyQueryCache<ReasonerAtomicQuery> dCache) resolves the query
Set<Atom>	selectAtoms() atom selection function
String	toString()
void	unify(Unifier unifier) change each variable occurrence according to provided mappings (apply unifiers {[from, to]_i})
void	unify(VarName from, VarName to) change each variable occurrence in the query (apply unifier [from/to])

Methods inherited from class java.lang.Object

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

Constructor Detail

ReasonerQueryImpl

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

ReasonerQueryImpl

public ReasonerQueryImpl(ReasonerQueryImpl q)

ReasonerQueryImpl

protected ReasonerQueryImpl(Atom atom)

Method Detail

copy

public ReasonerQuery copy()

Specified by:

copy in interface ReasonerQuery

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object

graph

public GraknGraph graph()

Specified by:

graph in interface ReasonerQuery

Returns:

GraknGraph associated with this reasoner query

getPattern

public Conjunction<PatternAdmin> getPattern()

Specified by:

getPattern in interface ReasonerQuery

Returns:

conjunctive pattern corresponding to this reasoner query

isRuleResolvable

public boolean isRuleResolvable()

Specified by:

isRuleResolvable in interface ReasonerQuery

Returns:

true if any of the atoms constituting the query can be resolved through a rule

getAtoms

public Set<Atomic> getAtoms()

Specified by:

getAtoms in interface ReasonerQuery

Returns:

atom set constituting this query

getIdPredicates

public Set<IdPredicate> getIdPredicates()

Returns:

set of id predicates contained in this query

getValuePredicates

public Set<ValuePredicate> getValuePredicates()

Returns:

set of value predicates contained in this query

getTypeConstraints

public Set<TypeAtom> getTypeConstraints()

Returns:

set of atoms constituting constraints (by means of types) for this atom

getFilters

public Set<NotEquals> getFilters()

Returns:

set of filter atoms (currently only NotEquals) contained in this query

getVarNames

public Set<VarName> getVarNames()

Specified by:

getVarNames in interface ReasonerQuery

Returns:

set of variables appearing in this query

containsEquivalentAtom

public boolean containsEquivalentAtom(Atomic atom)

Parameters:

atom - in question

Returns:

true if query contains an equivalent atom

getUnifier

public Unifier getUnifier(ReasonerQuery parent)

Specified by:

getUnifier in interface ReasonerQuery

Returns:

unify

public void unify(VarName from,
                  VarName to)

change each variable occurrence in the query (apply unifier [from/to])

Specified by:

unify in interface ReasonerQuery

Parameters:

from - variable name to be changed

to - new variable name

unify

public void unify(Unifier unifier)

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

Specified by:

unify in interface ReasonerQuery

Parameters:

unifier - (variable mappings) to be applied

getMatchQuery

public MatchQuery getMatchQuery()

Specified by:

getMatchQuery in interface ReasonerQuery

Returns:

corresponding MatchQuery

getVarTypeMap

public Map<VarName,Type> getVarTypeMap()

Specified by:

getVarTypeMap in interface ReasonerQuery

Returns:

map of variable name - type pairs

getIdPredicate

public IdPredicate getIdPredicate(VarName var)

Parameters:

var - variable name

Returns:

id predicate for the specified var name if any

addAtomic

public boolean addAtomic(Atomic atom)

Parameters:

atom - to be added

Returns:

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

removeAtomic

public boolean removeAtomic(Atomic atom)

Parameters:

atom - to be removed

Returns:

true if the atom set contained the specified atom

addAtomConstraints

public void addAtomConstraints(Set<? extends Atomic> cstrs)

adds a set of constraints (types, predicates) to the atom set

Parameters:

cstrs - set of constraints

findNextJoinable

public Atom findNextJoinable(Atom atom)

Parameters:

atom - for which the neighbour is to be found

Returns:

neighbour or null if disjoint

selectAtoms

public Set<Atom> selectAtoms()

atom selection function

Returns:

selected atoms

isEquivalent

public boolean isEquivalent(ReasonerQueryImpl q)

Parameters:

q - query to be compared with

Returns:

true if two queries are alpha-equivalent

resolve

public java.util.stream.Stream<Answer> resolve(boolean materialise,
                                               boolean explanation)

Description copied from interface: ReasonerQuery

resolves the query

Specified by:

resolve in interface ReasonerQuery

Parameters:

materialise - materialisation flag

explanation - whether to provide explanation

Returns:

stream of answers

resolve

public java.util.stream.Stream<Answer> resolve(boolean materialise,
                                               boolean explanation,
                                               LazyQueryCache<ReasonerAtomicQuery> cache,
                                               LazyQueryCache<ReasonerAtomicQuery> dCache)

resolves the query

Parameters:

materialise - materialisation flag

Returns:

stream of answers

iterator

public ReasonerQueryIterator iterator(Answer sub,
                                      Set<ReasonerAtomicQuery> subGoals,
                                      QueryCache<ReasonerAtomicQuery> cache)