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

Method Summary

Modifier and Type	Method and Description
void	checkValid()
ReasonerQuery	conjunction(ReasonerQuery q)
ReasonerQuery	copy()
boolean	equals(Object obj)
Set<Atomic>	getAtoms()
<T extends Atomic> java.util.stream.Stream<T>	getAtoms(Class<T> type)
MultiUnifier	getMultiUnifier(ReasonerQuery parent)
MultiUnifier	getMultiUnifier(ReasonerQuery parent, UnifierComparison unifierType)
Conjunction<PatternAdmin>	getPattern()
GetQuery	getQuery()
Answer	getRoleSubstitution()
Answer	getSubstitution()
Set<Var>	getVarNames()
com.google.common.collect.ImmutableMap<Var,Type>	getVarTypeMap()
com.google.common.collect.ImmutableMap<Var,Type>	getVarTypeMap(Answer sub)
int	hashCode()
Map<Var,ConceptId>	idTransform(ReasonerQueryImpl query, Unifier unifier) returns id transform that would convert this query to a query alpha-equivalent to the query, provided they are structurally equivalent
ReasonerQueryImpl	inferTypes()
boolean	isEquivalent(ReasonerQueryImpl q)
boolean	isRuleResolvable()
boolean	isTypeRoleCompatible(Var typedVar, Type parentType)
ReasonerQueryImpl	positive()
Pair<Iterator<ResolutionState>,MultiUnifier>	queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)
boolean	requiresReiteration() reiteration might be required if rule graph contains loops with negative flux or there exists a rule which head satisfies body
java.util.stream.Stream<Answer>	resolve(boolean materialise)
Set<Atom>	selectAtoms() atom selection function
ResolutionState	subGoal(Answer sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)
java.util.stream.Stream<ResolutionState>	subGoals(Answer sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)
String	toString()
ReasonerQueryImpl	transformIds(Map<Var,ConceptId> transform)
GraknTx	tx()
Set<String>	validateOntologically()
ReasonerQueryImpl	withSubstitution(Answer sub)

Methods inherited from class java.lang.Object

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

Method Detail

conjunction

public ReasonerQuery conjunction(ReasonerQuery q)

Specified by:

conjunction in interface ReasonerQuery

withSubstitution

public ReasonerQueryImpl withSubstitution(Answer sub)

Parameters:

sub - substitution to be inserted into the query

Returns:

corresponding query with additional substitution

inferTypes

public ReasonerQueryImpl inferTypes()

Returns:

corresponding reasoner query with inferred types

positive

public ReasonerQueryImpl positive()

Returns:

corresponding positive query (with neq predicates removed)

transformIds

public ReasonerQueryImpl transformIds(Map<Var,ConceptId> transform)

Parameters:

transform - map defining id transform: var -> new id

Returns:

new query with id predicates transformed according to the transform

toString

public String toString()

Overrides:

toString in class Object

copy

public ReasonerQuery copy()

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

isEquivalent

public boolean isEquivalent(ReasonerQueryImpl q)

Parameters:

q - query to be compared with

Returns:

true if two queries are alpha-equivalent

tx

public GraknTx tx()

Specified by:

tx in interface ReasonerQuery

checkValid

public void checkValid()

Specified by:

checkValid in interface ReasonerQuery

getPattern

public Conjunction<PatternAdmin> getPattern()

validateOntologically

public Set<String> validateOntologically()

Specified by:

validateOntologically in interface ReasonerQuery

isRuleResolvable

public boolean isRuleResolvable()

Specified by:

isRuleResolvable in interface ReasonerQuery

isTypeRoleCompatible

public boolean isTypeRoleCompatible(Var typedVar,
                                    Type parentType)

Specified by:

isTypeRoleCompatible in interface ReasonerQuery

Parameters:

typedVar - variable of interest

parentType - to be checked

Returns:

true if typing the typeVar with type is compatible with role configuration of this query

getAtoms

public Set<Atomic> getAtoms()

Specified by:

getAtoms in interface ReasonerQuery

getAtoms

public <T extends Atomic> java.util.stream.Stream<T> getAtoms(Class<T> type)

Specified by:

getAtoms in interface ReasonerQuery

getVarNames

public Set<Var> getVarNames()

Specified by:

getVarNames in interface ReasonerQuery

getMultiUnifier

public MultiUnifier getMultiUnifier(ReasonerQuery parent)

getMultiUnifier

public MultiUnifier getMultiUnifier(ReasonerQuery parent,
                                    UnifierComparison unifierType)

Parameters:

parent - query for which unifier to unify with should be found

unifierType - unifier type

Returns:

corresponding multiunifier

getQuery

public GetQuery getQuery()

getVarTypeMap

public com.google.common.collect.ImmutableMap<Var,Type> getVarTypeMap()

Specified by:

getVarTypeMap in interface ReasonerQuery

getVarTypeMap

public com.google.common.collect.ImmutableMap<Var,Type> getVarTypeMap(Answer sub)

Specified by:

getVarTypeMap in interface ReasonerQuery

idTransform

public Map<Var,ConceptId> idTransform(ReasonerQueryImpl query,
                                      Unifier unifier)

returns id transform that would convert this query to a query alpha-equivalent to the query, provided they are structurally equivalent

Parameters:

query - for which the transform is to be constructed

unifier - between this query and provided query

Returns:

id transform

selectAtoms

public Set<Atom> selectAtoms()

atom selection function

Returns:

selected atoms

getSubstitution

public Answer getSubstitution()

Specified by:

getSubstitution in interface ReasonerQuery

Returns:

substitution obtained from all id predicates (including internal) in the query

getRoleSubstitution

public Answer getRoleSubstitution()

resolve

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

Specified by:

resolve in interface ReasonerQuery

subGoal

public ResolutionState subGoal(Answer sub,
                               Unifier u,
                               QueryStateBase parent,
                               Set<ReasonerAtomicQuery> subGoals,
                               QueryCache<ReasonerAtomicQuery> cache)

Parameters:

sub - partial substitution

u - unifier with parent state

parent - parent state

subGoals - set of visited sub goals

cache - query cache

Returns:

resolution subGoal formed from this query

subGoals

public java.util.stream.Stream<ResolutionState> subGoals(Answer sub,
                                                         Unifier u,
                                                         QueryStateBase parent,
                                                         Set<ReasonerAtomicQuery> subGoals,
                                                         QueryCache<ReasonerAtomicQuery> cache)

Parameters:

sub - partial substitution

u - unifier with parent state

parent - parent state

subGoals - set of visited sub goals

cache - query cache

Returns:

resolution subGoals formed from this query obtained by expanding the inferred types contained in the query

queryStateIterator

public Pair<Iterator<ResolutionState>,MultiUnifier> queryStateIterator(QueryStateBase parent,
                                                                       Set<ReasonerAtomicQuery> subGoals,
                                                                       QueryCache<ReasonerAtomicQuery> cache)

Parameters:

parent - parent state

subGoals - set of visited sub goals

cache - query cache

Returns:

query state iterator (db iter + unifier + state iter) for this query

requiresReiteration

public boolean requiresReiteration()

reiteration might be required if rule graph contains loops with negative flux or there exists a rule which head satisfies body

Returns:

true if because of the rule graph form, the resolution of this query may require reiteration